1 /* 2 * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 /* OSSerialize.cpp created by rsulack on Wen 25-Nov-1998 */ 29 30 #include <sys/cdefs.h> 31 32 __BEGIN_DECLS 33 #include <vm/vm_kern.h> 34 __END_DECLS 35 36 #include <libkern/c++/OSContainers.h> 37 #include <libkern/c++/OSLib.h> 38 #include <libkern/c++/OSDictionary.h> 39 #include <libkern/OSSerializeBinary.h> 40 41 #define super OSObject 42 43 OSDefineMetaClassAndStructors(OSSerialize, OSObject) 44 OSMetaClassDefineReservedUnused(OSSerialize, 0); 45 OSMetaClassDefineReservedUnused(OSSerialize, 1); 46 OSMetaClassDefineReservedUnused(OSSerialize, 2); 47 OSMetaClassDefineReservedUnused(OSSerialize, 3); 48 OSMetaClassDefineReservedUnused(OSSerialize, 4); 49 OSMetaClassDefineReservedUnused(OSSerialize, 5); 50 OSMetaClassDefineReservedUnused(OSSerialize, 6); 51 OSMetaClassDefineReservedUnused(OSSerialize, 7); 52 53 #if OSALLOCDEBUG 54 extern "C" { 55 extern int debug_container_malloc_size; 56 }; 57 #define ACCUMSIZE(s) do { debug_container_malloc_size += (s); } while(0) 58 #else 59 #define ACCUMSIZE(s) 60 #endif 61 62 char * OSSerialize::text() const 63 { 64 return data; 65 } 66 67 void OSSerialize::clearText() 68 { 69 if (binary) 70 { 71 length = sizeof(kOSSerializeBinarySignature); 72 bzero(&data[length], capacity - length); 73 endCollection = true; 74 } 75 else 76 { 77 bzero((void *)data, capacity); 78 length = 1; 79 } 80 tag = 0; 81 tags->flushCollection(); 82 } 83 84 bool OSSerialize::previouslySerialized(const OSMetaClassBase *o) 85 { 86 char temp[16]; 87 OSString *tagString; 88 89 if (binary) return (binarySerialize(o)); 90 91 // look it up 92 tagString = (OSString *)tags->getObject((const OSSymbol *) o); 93 94 // xx-review: no error checking here for addString calls! 95 // does it exist? 96 if (tagString) { 97 addString("<reference IDREF=\""); 98 addString(tagString->getCStringNoCopy()); 99 addString("\"/>"); 100 return true; 101 } 102 103 // build a tag 104 snprintf(temp, sizeof(temp), "%u", tag++); 105 tagString = OSString::withCString(temp); 106 107 // add to tag dictionary 108 tags->setObject((const OSSymbol *) o, tagString);// XXX check return 109 tagString->release(); 110 111 return false; 112 } 113 114 bool OSSerialize::addXMLStartTag(const OSMetaClassBase *o, const char *tagString) 115 { 116 if (binary) 117 { 118 printf("class %s: xml serialize\n", o->getMetaClass()->getClassName()); 119 return (false); 120 } 121 122 if (!addChar('<')) return false; 123 if (!addString(tagString)) return false; 124 if (!addString(" ID=\"")) return false; 125 if (!addString(((OSString *)tags->getObject((const OSSymbol *)o))->getCStringNoCopy())) 126 return false; 127 if (!addChar('\"')) return false; 128 if (!addChar('>')) return false; 129 return true; 130 } 131 132 bool OSSerialize::addXMLEndTag(const char *tagString) 133 { 134 135 if (!addChar('<')) return false; 136 if (!addChar('/')) return false; 137 if (!addString(tagString)) return false; 138 if (!addChar('>')) return false; 139 return true; 140 } 141 142 bool OSSerialize::addChar(const char c) 143 { 144 if (binary) 145 { 146 printf("xml serialize\n"); 147 return (false); 148 } 149 150 // add char, possibly extending our capacity 151 if (length >= capacity && length >=ensureCapacity(capacity+capacityIncrement)) 152 return false; 153 154 data[length - 1] = c; 155 length++; 156 157 return true; 158 } 159 160 bool OSSerialize::addString(const char *s) 161 { 162 bool rc = false; 163 164 while (*s && (rc = addChar(*s++))) ; 165 166 return rc; 167 } 168 169 bool OSSerialize::initWithCapacity(unsigned int inCapacity) 170 { 171 if (!super::init()) 172 return false; 173 174 tags = OSDictionary::withCapacity(32); 175 if (!tags) { 176 return false; 177 } 178 179 tag = 0; 180 length = 1; 181 capacity = (inCapacity) ? round_page_32(inCapacity) : round_page_32(1); 182 capacityIncrement = capacity; 183 184 // allocate from the kernel map so that we can safely map this data 185 // into user space (the primary use of the OSSerialize object) 186 187 kern_return_t rc = kmem_alloc(kernel_map, (vm_offset_t *)&data, capacity); 188 if (rc) { 189 tags->release(); 190 tags = 0; 191 return false; 192 } 193 bzero((void *)data, capacity); 194 195 196 ACCUMSIZE(capacity); 197 198 return true; 199 } 200 201 OSSerialize *OSSerialize::withCapacity(unsigned int inCapacity) 202 { 203 OSSerialize *me = new OSSerialize; 204 205 if (me && !me->initWithCapacity(inCapacity)) { 206 me->release(); 207 return 0; 208 } 209 210 return me; 211 } 212 213 unsigned int OSSerialize::getLength() const { return length; } 214 unsigned int OSSerialize::getCapacity() const { return capacity; } 215 unsigned int OSSerialize::getCapacityIncrement() const { return capacityIncrement; } 216 unsigned int OSSerialize::setCapacityIncrement(unsigned int increment) 217 { 218 capacityIncrement = (increment)? increment : 256; 219 return capacityIncrement; 220 } 221 222 unsigned int OSSerialize::ensureCapacity(unsigned int newCapacity) 223 { 224 char *newData; 225 226 if (newCapacity <= capacity) 227 return capacity; 228 229 // round up 230 newCapacity = round_page_32(newCapacity); 231 232 kern_return_t rc = kmem_realloc(kernel_map, 233 (vm_offset_t)data, 234 capacity, 235 (vm_offset_t *)&newData, 236 newCapacity); 237 if (!rc) { 238 ACCUMSIZE(newCapacity); 239 240 // kmem realloc does not free the old address range 241 kmem_free(kernel_map, (vm_offset_t)data, capacity); 242 ACCUMSIZE(-capacity); 243 244 // kmem realloc does not zero out the new memory 245 // and this could end up going to user land 246 bzero(&newData[capacity], newCapacity - capacity); 247 248 data = newData; 249 capacity = newCapacity; 250 } 251 252 return capacity; 253 } 254 255 void OSSerialize::free() 256 { 257 if (tags) 258 tags->release(); 259 260 if (data) { 261 kmem_free(kernel_map, (vm_offset_t)data, capacity); 262 ACCUMSIZE( -capacity ); 263 } 264 super::free(); 265 } 266 267 268 OSDefineMetaClassAndStructors(OSSerializer, OSObject) 269 270 OSSerializer * OSSerializer::forTarget( void * target, 271 OSSerializerCallback callback, void * ref ) 272 { 273 OSSerializer * thing; 274 275 thing = new OSSerializer; 276 if( thing && !thing->init()) { 277 thing->release(); 278 thing = 0; 279 } 280 281 if( thing) { 282 thing->target = target; 283 thing->ref = ref; 284 thing->callback = callback; 285 } 286 return( thing ); 287 } 288 289 bool OSSerializer::serialize( OSSerialize * s ) const 290 { 291 return( (*callback)(target, ref, s) ); 292 } 293