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 } 426