libkern/c++/OSData.cpp

   1 /*
   2  * Copyright (c) 2000 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 /* IOData.m created by rsulack on Thu 25-Sep-1997 */
  29
  30 #include <string.h>
  31
  32 #include <libkern/c++/OSData.h>
  33 #include <libkern/c++/OSSerialize.h>
  34 #include <libkern/c++/OSLib.h>
  35 #include <libkern/c++/OSString.h>
  36 #include <string.h>
  37
  38 #define super OSObject
  39
  40 OSDefineMetaClassAndStructors(OSData, OSObject)
  41 OSMetaClassDefineReservedUnused(OSData, 0);
  42 OSMetaClassDefineReservedUnused(OSData, 1);
  43 OSMetaClassDefineReservedUnused(OSData, 2);
  44 OSMetaClassDefineReservedUnused(OSData, 3);
  45 OSMetaClassDefineReservedUnused(OSData, 4);
  46 OSMetaClassDefineReservedUnused(OSData, 5);
  47 OSMetaClassDefineReservedUnused(OSData, 6);
  48 OSMetaClassDefineReservedUnused(OSData, 7);
  49
  50 #define EXTERNAL ((unsigned int) -1)
  51
  52 #if OSALLOCDEBUG
  53 extern int debug_container_malloc_size;
  54 #define ACCUMSIZE(s) do { debug_container_malloc_size += (s); } while(0)
  55 #else
  56 #define ACCUMSIZE(s)
  57 #endif
  58
  59 bool OSData::initWithCapacity(unsigned int inCapacity)
  60 {
  61     if (!super::init())
  62         return false;
  63
  64     if (data && (!inCapacity || capacity < inCapacity) ) {
  65         // clean out old data's storage if it isn't big enough
  66         kfree(data, capacity);
  67         data = 0;
  68         ACCUMSIZE(-capacity);
  69     }
  70
  71     if (inCapacity && !data) {
  72         data = (void *) kalloc(inCapacity);
  73         if (!data)
  74             return false;
  75         capacity = inCapacity;
  76         ACCUMSIZE(inCapacity);
  77     }
  78
  79     length = 0;
  80     if (inCapacity < 16)
  81         capacityIncrement = 16;
  82     else
  83         capacityIncrement = inCapacity;
  84
  85     return true;
  86 }
  87
  88 bool OSData::initWithBytes(const void *bytes, unsigned int inLength)
  89 {
  90     if ((inLength && !bytes) || !initWithCapacity(inLength))
  91         return false;
  92
  93     if (bytes != data)
  94         bcopy(bytes, data, inLength);
  95     length = inLength;
  96
  97     return true;
  98 }
  99
 100 bool OSData::initWithBytesNoCopy(void *bytes, unsigned int inLength)
 101 {
 102     if (!super::init())
 103         return false;
 104
 105     length = inLength;
 106     capacity = EXTERNAL;
 107     data = bytes;
 108
 109     return true;
 110 }
 111
 112 bool OSData::initWithData(const OSData *inData)
 113 {
 114     return initWithBytes(inData->data, inData->length);
 115 }
 116
 117 bool OSData::initWithData(const OSData *inData,
 118                           unsigned int start, unsigned int inLength)
 119 {
 120     const void *localData = inData->getBytesNoCopy(start, inLength);
 121
 122     if (localData)
 123         return initWithBytes(localData, inLength);
 124     else
 125         return false;
 126 }
 127
 128 OSData *OSData::withCapacity(unsigned int inCapacity)
 129 {
 130     OSData *me = new OSData;
 131
 132     if (me && !me->initWithCapacity(inCapacity)) {
 133         me->release();
 134         return 0;
 135     }
 136
 137     return me;
 138 }
 139
 140 OSData *OSData::withBytes(const void *bytes, unsigned int inLength)
 141 {
 142     OSData *me = new OSData;
 143
 144     if (me && !me->initWithBytes(bytes, inLength)) {
 145         me->release();
 146         return 0;
 147     }
 148     return me;
 149 }
 150
 151 OSData *OSData::withBytesNoCopy(void *bytes, unsigned int inLength)
 152 {
 153     OSData *me = new OSData;
 154
 155     if (me && !me->initWithBytesNoCopy(bytes, inLength)) {
 156         me->release();
 157         return 0;
 158     }
 159
 160     return me;
 161 }
 162
 163 OSData *OSData::withData(const OSData *inData)
 164 {
 165     OSData *me = new OSData;
 166
 167     if (me && !me->initWithData(inData)) {
 168         me->release();
 169         return 0;
 170     }
 171
 172     return me;
 173 }
 174
 175 OSData *OSData::withData(const OSData *inData,
 176                          unsigned int start, unsigned int inLength)
 177 {
 178     OSData *me = new OSData;
 179
 180     if (me && !me->initWithData(inData, start, inLength)) {
 181         me->release();
 182         return 0;
 183     }
 184
 185     return me;
 186 }
 187
 188 void OSData::free()
 189 {
 190     if (capacity != EXTERNAL && data && capacity) {
 191         kfree(data, capacity);
 192         ACCUMSIZE( -capacity );
 193     }
 194     super::free();
 195 }
 196
 197 unsigned int OSData::getLength() const { return length; }
 198 unsigned int OSData::getCapacity() const { return capacity; }
 199
 200 unsigned int OSData::getCapacityIncrement() const
 201 {
 202     return capacityIncrement;
 203 }
 204
 205 unsigned int OSData::setCapacityIncrement(unsigned increment)
 206 {
 207     return capacityIncrement = increment;
 208 }
 209
 210 unsigned int OSData::ensureCapacity(unsigned int newCapacity)
 211 {
 212     unsigned char * newData;
 213
 214     if (newCapacity <= capacity)
 215         return capacity;
 216
 217     newCapacity = (((newCapacity - 1) / capacityIncrement) + 1)
 218                 * capacityIncrement;
 219
 220     newData = (unsigned char *) kalloc(newCapacity);
 221
 222     if ( newData ) {
 223         bzero(newData + capacity, newCapacity - capacity);
 224         if (data) {
 225             bcopy(data, newData, capacity);
 226             kfree(data, capacity);
 227         }
 228         ACCUMSIZE( newCapacity - capacity );
 229         data = (void *) newData;
 230         capacity = newCapacity;
 231     }
 232
 233     return capacity;
 234 }
 235
 236 bool OSData::appendBytes(const void *bytes, unsigned int inLength)
 237 {
 238     unsigned int newSize;
 239
 240     if (!inLength)
 241         return true;
 242
 243     if (capacity == EXTERNAL)
 244         return false;
 245
 246     newSize = length + inLength;
 247     if ( (newSize > capacity) && newSize > ensureCapacity(newSize) )
 248         return false;
 249
 250     if (bytes)
 251         bcopy(bytes, &((unsigned char *)data)[length], inLength);
 252     else
 253         bzero(&((unsigned char *)data)[length], inLength);
 254
 255     length = newSize;
 256
 257     return true;
 258 }
 259
 260 bool OSData::appendByte(unsigned char byte, unsigned int inLength)
 261 {
 262     unsigned int newSize;
 263
 264     if (!inLength)
 265         return true;
 266
 267     if (capacity == EXTERNAL)
 268         return false;
 269
 270     newSize = length + inLength;
 271     if ( (newSize > capacity) && newSize > ensureCapacity(newSize) )
 272         return false;
 273
 274     memset(&((unsigned char *)data)[length], byte, inLength);
 275     length = newSize;
 276
 277     return true;
 278 }
 279
 280 bool OSData::appendBytes(const OSData *other)
 281 {
 282     return appendBytes(other->data, other->length);
 283 }
 284
 285 const void *OSData::getBytesNoCopy() const
 286 {
 287     if (!length)
 288         return 0;
 289     else
 290         return data;
 291 }
 292
 293 const void *OSData::getBytesNoCopy(unsigned int start,
 294                                    unsigned int inLength) const
 295 {
 296     const void *outData = 0;
 297
 298     if (length
 299     &&  start < length
 300     && (start + inLength) <= length)
 301         outData = (const void *) ((char *) data + start);
 302
 303     return outData;
 304 }
 305
 306 bool OSData::isEqualTo(const OSData *aData) const
 307 {
 308     unsigned int len;
 309
 310     len = aData->length;
 311     if ( length != len )
 312         return false;
 313
 314     return isEqualTo(aData->data, len);
 315 }
 316
 317 bool OSData::isEqualTo(const void *someData, unsigned int inLength) const
 318 {
 319     return (length >= inLength) && (bcmp(data, someData, inLength) == 0);
 320 }
 321
 322 bool OSData::isEqualTo(const OSMetaClassBase *obj) const
 323 {
 324     OSData *    data;
 325     OSString *  str;
 326
 327     if ((data = OSDynamicCast(OSData, obj)))
 328         return isEqualTo(data);
 329     else if ((str = OSDynamicCast (OSString, obj)))
 330         return isEqualTo(str);
 331     else
 332         return false;
 333 }
 334
 335 bool OSData::isEqualTo(const OSString *obj) const
 336 {
 337     const char * aCString;
 338     char * dataPtr;
 339     unsigned int checkLen = length;
 340     unsigned int stringLen;
 341
 342     if (!obj)
 343       return false;
 344
 345     stringLen = obj->getLength ();
 346
 347     dataPtr = (char *)data;
 348
 349     if (stringLen != checkLen) {
 350
 351       // check for the fact that OSData may be a buffer that
 352       // that includes a termination byte and will thus have
 353       // a length of the actual string length PLUS 1. In this
 354       // case we verify that the additional byte is a terminator
 355       // and if so count the two lengths as being the same.
 356
 357       if ( (checkLen - stringLen) == 1) {
 358         if (dataPtr[checkLen-1] != 0) // non-zero means not a terminator and thus not likely the same
 359           return false;
 360         checkLen--;
 361       }
 362       else
 363         return false;
 364     }
 365
 366     aCString = obj->getCStringNoCopy ();
 367
 368     for ( unsigned int i=0; i < checkLen; i++ ) {
 369       if ( *dataPtr++ != aCString[i] )
 370         return false;
 371     }
 372
 373    return true;
 374 }
 375
 376 //this was taken from CFPropertyList.c
 377 static const char __CFPLDataEncodeTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 378
 379 bool OSData::serialize(OSSerialize *s) const
 380 {
 381     unsigned int i;
 382     const unsigned char *p;
 383     unsigned char c;
 384
 385     if (s->previouslySerialized(this)) return true;
 386
 387     if (!s->addXMLStartTag(this, "data")) return false;
 388
 389     for (i = 0, p = (unsigned char *)data; i < length; i++, p++) {
 390         /* 3 bytes are encoded as 4 */
 391         switch (i % 3) {
 392         case 0:
 393                 c = __CFPLDataEncodeTable [ ((p[0] >> 2) & 0x3f)];
 394                 if (!s->addChar(c)) return false;
 395                 break;
 396         case 1:
 397                 c = __CFPLDataEncodeTable [ ((((p[-1] << 8) | p[0]) >> 4) & 0x3f)];
 398                 if (!s->addChar(c)) return false;
 399                 break;
 400         case 2:
 401                 c = __CFPLDataEncodeTable [ ((((p[-1] << 8) | p[0]) >> 6) & 0x3f)];
 402                 if (!s->addChar(c)) return false;
 403                 c = __CFPLDataEncodeTable [ (p[0] & 0x3f)];
 404                 if (!s->addChar(c)) return false;
 405                 break;
 406         }
 407     }
 408     switch (i % 3) {
 409     case 0:
 410             break;
 411     case 1:
 412             c = __CFPLDataEncodeTable [ ((p[-1] << 4) & 0x30)];
 413             if (!s->addChar(c)) return false;
 414             if (!s->addChar('=')) return false;
 415             if (!s->addChar('=')) return false;
 416             break;
 417     case 2:
 418             c = __CFPLDataEncodeTable [ ((p[-1] << 2) & 0x3c)];
 419             if (!s->addChar(c)) return false;
 420             if (!s->addChar('=')) return false;
 421             break;
 422     }
 423
 424     return s->addXMLEndTag("data");
 425 }