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