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 #include <IOKit/IOLib.h> 41 42 #define super OSObject 43 44 OSDefineMetaClassAndStructors(OSSerialize, OSObject) 45 OSMetaClassDefineReservedUnused(OSSerialize, 0); 46 OSMetaClassDefineReservedUnused(OSSerialize, 1); 47 OSMetaClassDefineReservedUnused(OSSerialize, 2); 48 OSMetaClassDefineReservedUnused(OSSerialize, 3); 49 OSMetaClassDefineReservedUnused(OSSerialize, 4); 50 OSMetaClassDefineReservedUnused(OSSerialize, 5); 51 OSMetaClassDefineReservedUnused(OSSerialize, 6); 52 OSMetaClassDefineReservedUnused(OSSerialize, 7); 53 54 55 char * OSSerialize::text() const 56 { 57 return data; 58 } 59 60 void OSSerialize::clearText() 61 { 62 if (binary) 63 { 64 length = sizeof(kOSSerializeBinarySignature); 65 bzero(&data[length], capacity - length); 66 endCollection = true; 67 } 68 else 69 { 70 bzero((void *)data, capacity); 71 length = 1; 72 } 73 tags->flushCollection(); 74 } 75 76 bool OSSerialize::previouslySerialized(const OSMetaClassBase *o) 77 { 78 char temp[16]; 79 unsigned int tagIdx; 80 81 if (binary) return (binarySerialize(o)); 82 83 // look it up 84 tagIdx = tags->getNextIndexOfObject(o, 0); 85 86 // xx-review: no error checking here for addString calls! 87 // does it exist? 88 if (tagIdx != -1U) { 89 addString("<reference IDREF=\""); 90 snprintf(temp, sizeof(temp), "%u", tagIdx); 91 addString(temp); 92 addString("\"/>"); 93 return true; 94 } 95 96 // add to tag array 97 tags->setObject(o);// XXX check return 98 99 return false; 100 } 101 102 bool OSSerialize::addXMLStartTag(const OSMetaClassBase *o, const char *tagString) 103 { 104 char temp[16]; 105 unsigned int tagIdx; 106 107 if (binary) 108 { 109 printf("class %s: xml serialize\n", o->getMetaClass()->getClassName()); 110 return (false); 111 } 112 113 if (!addChar('<')) return false; 114 if (!addString(tagString)) return false; 115 if (!addString(" ID=\"")) return false; 116 tagIdx = tags->getNextIndexOfObject(o, 0); 117 assert(tagIdx != -1U); 118 snprintf(temp, sizeof(temp), "%u", tagIdx); 119 if (!addString(temp)) 120 return false; 121 if (!addChar('\"')) return false; 122 if (!addChar('>')) return false; 123 return true; 124 } 125 126 bool OSSerialize::addXMLEndTag(const char *tagString) 127 { 128 129 if (!addChar('<')) return false; 130 if (!addChar('/')) return false; 131 if (!addString(tagString)) return false; 132 if (!addChar('>')) return false; 133 return true; 134 } 135 136 bool OSSerialize::addChar(const char c) 137 { 138 if (binary) 139 { 140 printf("xml serialize\n"); 141 return (false); 142 } 143 144 // add char, possibly extending our capacity 145 if (length >= capacity && length >=ensureCapacity(capacity+capacityIncrement)) 146 return false; 147 148 data[length - 1] = c; 149 length++; 150 151 return true; 152 } 153 154 bool OSSerialize::addString(const char *s) 155 { 156 bool rc = false; 157 158 while (*s && (rc = addChar(*s++))) ; 159 160 return rc; 161 } 162 163 bool OSSerialize::initWithCapacity(unsigned int inCapacity) 164 { 165 if (!super::init()) 166 return false; 167 168 tags = OSArray::withCapacity(256); 169 if (!tags) { 170 return false; 171 } 172 173 length = 1; 174 175 if (!inCapacity) { 176 inCapacity = 1; 177 } 178 if (round_page_overflow(inCapacity, &capacity)) { 179 tags->release(); 180 tags = 0; 181 return false; 182 } 183 184 capacityIncrement = capacity; 185 186 // allocate from the kernel map so that we can safely map this data 187 // into user space (the primary use of the OSSerialize object) 188 189 kern_return_t rc = kmem_alloc(kernel_map, (vm_offset_t *)&data, capacity, IOMemoryTag(kernel_map)); 190 if (rc) { 191 tags->release(); 192 tags = 0; 193 return false; 194 } 195 bzero((void *)data, capacity); 196 197 198 OSCONTAINER_ACCUMSIZE(capacity); 199 200 return true; 201 } 202 203 OSSerialize *OSSerialize::withCapacity(unsigned int inCapacity) 204 { 205 OSSerialize *me = new OSSerialize; 206 207 if (me && !me->initWithCapacity(inCapacity)) { 208 me->release(); 209 return 0; 210 } 211 212 return me; 213 } 214 215 unsigned int OSSerialize::getLength() const { return length; } 216 unsigned int OSSerialize::getCapacity() const { return capacity; } 217 unsigned int OSSerialize::getCapacityIncrement() const { return capacityIncrement; } 218 unsigned int OSSerialize::setCapacityIncrement(unsigned int increment) 219 { 220 capacityIncrement = (increment)? increment : 256; 221 return capacityIncrement; 222 } 223 224 unsigned int OSSerialize::ensureCapacity(unsigned int newCapacity) 225 { 226 char *newData; 227 228 if (newCapacity <= capacity) 229 return capacity; 230 231 if (round_page_overflow(newCapacity, &newCapacity)) { 232 return capacity; 233 } 234 235 kern_return_t rc = kmem_realloc(kernel_map, 236 (vm_offset_t)data, 237 capacity, 238 (vm_offset_t *)&newData, 239 newCapacity, 240 VM_KERN_MEMORY_IOKIT); 241 if (!rc) { 242 OSCONTAINER_ACCUMSIZE(newCapacity); 243 244 // kmem realloc does not free the old address range 245 kmem_free(kernel_map, (vm_offset_t)data, capacity); 246 OSCONTAINER_ACCUMSIZE(-((size_t)capacity)); 247 248 // kmem realloc does not zero out the new memory 249 // and this could end up going to user land 250 bzero(&newData[capacity], newCapacity - capacity); 251 252 data = newData; 253 capacity = newCapacity; 254 } 255 256 return capacity; 257 } 258 259 void OSSerialize::free() 260 { 261 if (tags) 262 tags->release(); 263 264 if (data) { 265 kmem_free(kernel_map, (vm_offset_t)data, capacity); 266 OSCONTAINER_ACCUMSIZE( -((size_t)capacity) ); 267 } 268 super::free(); 269 } 270 271 272 OSDefineMetaClassAndStructors(OSSerializer, OSObject) 273 274 OSSerializer * OSSerializer::forTarget( void * target, 275 OSSerializerCallback callback, void * ref ) 276 { 277 OSSerializer * thing; 278 279 thing = new OSSerializer; 280 if( thing && !thing->init()) { 281 thing->release(); 282 thing = 0; 283 } 284 285 if( thing) { 286 thing->target = target; 287 thing->ref = ref; 288 thing->callback = callback; 289 } 290 return( thing ); 291 } 292 293 bool OSSerializer::serialize( OSSerialize * s ) const 294 { 295 return( (*callback)(target, ref, s) ); 296 } 297