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
40OSDefineMetaClassAndStructors(OSData, OSObject)
41OSMetaClassDefineReservedUsed(OSData, 0);    // setDeallocFunction
42OSMetaClassDefineReservedUnused(OSData, 1);
43OSMetaClassDefineReservedUnused(OSData, 2);
44OSMetaClassDefineReservedUnused(OSData, 3);
45OSMetaClassDefineReservedUnused(OSData, 4);
46OSMetaClassDefineReservedUnused(OSData, 5);
47OSMetaClassDefineReservedUnused(OSData, 6);
48OSMetaClassDefineReservedUnused(OSData, 7);
49
50#define EXTERNAL ((unsigned int) -1)
51
52#if OSALLOCDEBUG
53extern 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
59bool 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
88bool 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
100bool 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
112bool OSData::initWithData(const OSData *inData)
113{
114    return initWithBytes(inData->data, inData->length);
115}
116
117bool 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
128OSData *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
140OSData *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
151OSData *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
163OSData *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
175OSData *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
188void 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
203unsigned int OSData::getLength() const { return length; }
204unsigned int OSData::getCapacity() const { return capacity; }
205
206unsigned int OSData::getCapacityIncrement() const
207{
208    return capacityIncrement;
209}
210
211unsigned int OSData::setCapacityIncrement(unsigned increment)
212{
213    return capacityIncrement = increment;
214}
215
216// xx-review: does not check for capacity == EXTERNAL
217
218unsigned 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
249bool 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
273bool 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
293bool OSData::appendBytes(const OSData *other)
294{
295    return appendBytes(other->data, other->length);
296}
297
298const void *OSData::getBytesNoCopy() const
299{
300    if (!length)
301        return 0;
302    else
303        return data;
304}
305
306const 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
319bool 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
330bool OSData::isEqualTo(const void *someData, unsigned int inLength) const
331{
332    return (length >= inLength) && (bcmp(data, someData, inLength) == 0);
333}
334
335bool 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
348bool 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
390static const char __CFPLDataEncodeTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
391
392bool 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
444void 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
455void 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}
465