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 OSMetaClassDefineReservedUsed(OSData, 0);    // setDeallocFunction
  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     } else if (capacity == EXTERNAL) {
 194         DeallocFunction freemem = reserved ? reserved->deallocFunction : NULL;
 195         if (freemem && data && length) {
 196                 freemem(data, length);
 197         }
 198     }
 199     if (reserved) kfree(reserved, sizeof(ExpansionData));
 200     super::free();
 201 }
 202
 203 unsigned int OSData::getLength() const { return length; }
 204 unsigned int OSData::getCapacity() const { return capacity; }
 205
 206 unsigned int OSData::getCapacityIncrement() const
 207 {
 208     return capacityIncrement;
 209 }
 210
 211 unsigned int OSData::setCapacityIncrement(unsigned increment)
 212 {
 213     return capacityIncrement = increment;
 214 }
 215
 216 // xx-review: does not check for capacity == EXTERNAL
 217
 218 unsigned int OSData::ensureCapacity(unsigned int newCapacity)
 219 {
 220     unsigned char * newData;
 221     unsigned int finalCapacity;
 222
 223     if (newCapacity <= capacity)
 224         return capacity;
 225
 226     finalCapacity = (((newCapacity - 1) / capacityIncrement) + 1)
 227                 * capacityIncrement;
 228
 229     // integer overflow check
 230     if (finalCapacity < newCapacity)
 231         return capacity;
 232
 233     newData = (unsigned char *) kalloc(finalCapacity);
 234
 235     if ( newData ) {
 236         bzero(newData + capacity, finalCapacity - capacity);
 237         if (data) {
 238             bcopy(data, newData, capacity);
 239             kfree(data, capacity);
 240         }
 241         ACCUMSIZE( finalCapacity - capacity );
 242         data = (void *) newData;
 243         capacity = finalCapacity;
 244     }
 245
 246     return capacity;
 247 }
 248
 249 bool OSData::appendBytes(const void *bytes, unsigned int inLength)
 250 {
 251     unsigned int newSize;
 252
 253     if (!inLength)
 254         return true;
 255
 256     if (capacity == EXTERNAL)
 257         return false;
 258
 259     newSize = length + inLength;
 260     if ( (newSize > capacity) && newSize > ensureCapacity(newSize) )
 261         return false;
 262
 263     if (bytes)
 264         bcopy(bytes, &((unsigned char *)data)[length], inLength);
 265     else
 266         bzero(&((unsigned char *)data)[length], inLength);
 267
 268     length = newSize;
 269
 270     return true;
 271 }
 272
 273 bool OSData::appendByte(unsigned char byte, unsigned int inLength)
 274 {
 275     unsigned int newSize;
 276
 277     if (!inLength)
 278         return true;
 279
 280     if (capacity == EXTERNAL)
 281         return false;
 282
 283     newSize = length + inLength;
 284     if ( (newSize > capacity) && newSize > ensureCapacity(newSize) )
 285         return false;
 286
 287     memset(&((unsigned char *)data)[length], byte, inLength);
 288     length = newSize;
 289
 290     return true;
 291 }
 292
 293 bool OSData::appendBytes(const OSData *other)
 294 {
 295     return appendBytes(other->data, other->length);
 296 }
 297
 298 const void *OSData::getBytesNoCopy() const
 299 {
 300     if (!length)
 301         return 0;
 302     else
 303         return data;
 304 }
 305
 306 const void *OSData::getBytesNoCopy(unsigned int start,
 307                                    unsigned int inLength) const
 308 {
 309     const void *outData = 0;
 310
 311     if (length
 312     &&  start < length
 313     && (start + inLength) <= length)
 314         outData = (const void *) ((char *) data + start);
 315
 316     return outData;
 317 }
 318
 319 bool OSData::isEqualTo(const OSData *aData) const
 320 {
 321     unsigned int len;
 322
 323     len = aData->length;
 324     if ( length != len )
 325         return false;
 326
 327     return isEqualTo(aData->data, len);
 328 }
 329
 330 bool OSData::isEqualTo(const void *someData, unsigned int inLength) const
 331 {
 332     return (length >= inLength) && (bcmp(data, someData, inLength) == 0);
 333 }
 334
 335 bool OSData::isEqualTo(const OSMetaClassBase *obj) const
 336 {
 337     OSData *    otherData;
 338     OSString *  str;
 339
 340     if ((otherData = OSDynamicCast(OSData, obj)))
 341         return isEqualTo(otherData);
 342     else if ((str = OSDynamicCast (OSString, obj)))
 343         return isEqualTo(str);
 344     else
 345         return false;
 346 }
 347
 348 bool OSData::isEqualTo(const OSString *obj) const
 349 {
 350     const char * aCString;
 351     char * dataPtr;
 352     unsigned int checkLen = length;
 353     unsigned int stringLen;
 354
 355     if (!obj)
 356       return false;
 357
 358     stringLen = obj->getLength ();
 359
 360     dataPtr = (char *)data;
 361
 362     if (stringLen != checkLen) {
 363
 364       // check for the fact that OSData may be a buffer that
 365       // that includes a termination byte and will thus have
 366       // a length of the actual string length PLUS 1. In this
 367       // case we verify that the additional byte is a terminator
 368       // and if so count the two lengths as being the same.
 369
 370       if ( (checkLen - stringLen) == 1) {
 371         if (dataPtr[checkLen-1] != 0) // non-zero means not a terminator and thus not likely the same
 372           return false;
 373         checkLen--;
 374       }
 375       else
 376         return false;
 377     }
 378
 379     aCString = obj->getCStringNoCopy ();
 380
 381     for ( unsigned int i=0; i < checkLen; i++ ) {
 382       if ( *dataPtr++ != aCString[i] )
 383         return false;
 384     }
 385
 386    return true;
 387 }
 388
 389 //this was taken from CFPropertyList.c
 390 static const char __CFPLDataEncodeTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 391
 392 bool OSData::serialize(OSSerialize *s) const
 393 {
 394     unsigned int i;
 395     const unsigned char *p;
 396     unsigned char c;
 397     unsigned int serializeLength;
 398
 399     if (s->previouslySerialized(this)) return true;
 400
 401     if (!s->addXMLStartTag(this, "data")) return false;
 402
 403     serializeLength = length;
 404     if (reserved && reserved->disableSerialization) serializeLength = 0;
 405
 406     for (i = 0, p = (unsigned char *)data; i < serializeLength; i++, p++) {
 407         /* 3 bytes are encoded as 4 */
 408         switch (i % 3) {
 409         case 0:
 410                 c = __CFPLDataEncodeTable [ ((p[0] >> 2) & 0x3f)];
 411                 if (!s->addChar(c)) return false;
 412                 break;
 413         case 1:
 414                 c = __CFPLDataEncodeTable [ ((((p[-1] << 8) | p[0]) >> 4) & 0x3f)];
 415                 if (!s->addChar(c)) return false;
 416                 break;
 417         case 2:
 418                 c = __CFPLDataEncodeTable [ ((((p[-1] << 8) | p[0]) >> 6) & 0x3f)];
 419                 if (!s->addChar(c)) return false;
 420                 c = __CFPLDataEncodeTable [ (p[0] & 0x3f)];
 421                 if (!s->addChar(c)) return false;
 422                 break;
 423         }
 424     }
 425     switch (i % 3) {
 426     case 0:
 427             break;
 428     case 1:
 429             c = __CFPLDataEncodeTable [ ((p[-1] << 4) & 0x30)];
 430             if (!s->addChar(c)) return false;
 431             if (!s->addChar('=')) return false;
 432             if (!s->addChar('=')) return false;
 433             break;
 434     case 2:
 435             c = __CFPLDataEncodeTable [ ((p[-1] << 2) & 0x3c)];
 436             if (!s->addChar(c)) return false;
 437             if (!s->addChar('=')) return false;
 438             break;
 439     }
 440
 441     return s->addXMLEndTag("data");
 442 }
 443
 444 void OSData::setDeallocFunction(DeallocFunction func)
 445 {
 446     if (!reserved)
 447     {
 448         reserved = (typeof(reserved)) kalloc(sizeof(ExpansionData));
 449         if (!reserved) return;
 450         bzero(reserved, sizeof(ExpansionData));
 451     }
 452     reserved->deallocFunction = func;
 453 }
 454
 455 void OSData::setSerializable(bool serializable)
 456 {
 457     if (!reserved)
 458     {
 459         reserved = (typeof(reserved)) kalloc(sizeof(ExpansionData));
 460         if (!reserved) return;
 461         bzero(reserved, sizeof(ExpansionData));
 462     }
 463     reserved->disableSerialization = (!serializable);
 464 }