libkern/c++/OSSerialize.cpp

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