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