1/*
2 * Copyright (c) 2000-2006 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/* OSSerialize.cpp created by rsulack on Wen 25-Nov-1998 */
29
30#include <sys/cdefs.h>
31
32__BEGIN_DECLS
33#include <vm/vm_kern.h>
34__END_DECLS
35
36#include <libkern/c++/OSContainers.h>
37#include <libkern/c++/OSLib.h>
38#include <libkern/c++/OSDictionary.h>
39
40#define super OSObject
41
42OSDefineMetaClassAndStructors(OSSerialize, OSObject)
43OSMetaClassDefineReservedUnused(OSSerialize, 0);
44OSMetaClassDefineReservedUnused(OSSerialize, 1);
45OSMetaClassDefineReservedUnused(OSSerialize, 2);
46OSMetaClassDefineReservedUnused(OSSerialize, 3);
47OSMetaClassDefineReservedUnused(OSSerialize, 4);
48OSMetaClassDefineReservedUnused(OSSerialize, 5);
49OSMetaClassDefineReservedUnused(OSSerialize, 6);
50OSMetaClassDefineReservedUnused(OSSerialize, 7);
51
52#if OSALLOCDEBUG
53extern "C" {
54    extern int debug_container_malloc_size;
55};
56#define ACCUMSIZE(s) do { debug_container_malloc_size += (s); } while(0)
57#else
58#define ACCUMSIZE(s)
59#endif
60
61char * OSSerialize::text() const
62{
63	return data;
64}
65
66void OSSerialize::clearText()
67{
68	bzero((void *)data, capacity);
69	length = 1;
70	tag = 0;
71	tags->flushCollection();
72}
73
74bool OSSerialize::previouslySerialized(const OSMetaClassBase *o)
75{
76	char temp[16];
77	OSString *tagString;
78
79	// look it up
80	tagString = (OSString *)tags->getObject((const OSSymbol *) o);
81
82// xx-review: no error checking here for addString calls!
83	// does it exist?
84	if (tagString) {
85		addString("<reference IDREF=\"");
86		addString(tagString->getCStringNoCopy());
87		addString("\"/>");
88		return true;
89	}
90
91	// build a tag
92	snprintf(temp, sizeof(temp), "%u", tag++);
93	tagString = OSString::withCString(temp);
94
95	// add to tag dictionary
96        tags->setObject((const OSSymbol *) o, tagString);// XXX check return
97	tagString->release();
98
99	return false;
100}
101
102bool OSSerialize::addXMLStartTag(const OSMetaClassBase *o, const char *tagString)
103{
104
105	if (!addChar('<')) return false;
106	if (!addString(tagString)) return false;
107	if (!addString(" ID=\"")) return false;
108	if (!addString(((OSString *)tags->getObject((const OSSymbol *)o))->getCStringNoCopy()))
109		return false;
110	if (!addChar('\"')) return false;
111	if (!addChar('>')) return false;
112	return true;
113}
114
115bool OSSerialize::addXMLEndTag(const char *tagString)
116{
117
118	if (!addChar('<')) return false;
119	if (!addChar('/')) return false;
120	if (!addString(tagString)) return false;
121	if (!addChar('>')) return false;
122	return true;
123}
124
125bool OSSerialize::addChar(const char c)
126{
127	// add char, possibly extending our capacity
128	if (length >= capacity && length >=ensureCapacity(capacity+capacityIncrement))
129		return false;
130
131	data[length - 1] = c;
132	length++;
133
134	return true;
135}
136
137bool OSSerialize::addString(const char *s)
138{
139	bool rc = false;
140
141	while (*s && (rc = addChar(*s++))) ;
142
143	return rc;
144}
145
146bool OSSerialize::initWithCapacity(unsigned int inCapacity)
147{
148    if (!super::init())
149            return false;
150
151    tags = OSDictionary::withCapacity(32);
152    if (!tags) {
153        return false;
154    }
155
156    tag = 0;
157    length = 1;
158    capacity = (inCapacity) ? round_page_32(inCapacity) : round_page_32(1);
159    capacityIncrement = capacity;
160
161    // allocate from the kernel map so that we can safely map this data
162    // into user space (the primary use of the OSSerialize object)
163
164    kern_return_t rc = kmem_alloc(kernel_map, (vm_offset_t *)&data, capacity);
165    if (rc) {
166        tags->release();
167        tags = 0;
168        return false;
169    }
170    bzero((void *)data, capacity);
171
172
173    ACCUMSIZE(capacity);
174
175    return true;
176}
177
178OSSerialize *OSSerialize::withCapacity(unsigned int inCapacity)
179{
180	OSSerialize *me = new OSSerialize;
181
182	if (me && !me->initWithCapacity(inCapacity)) {
183		me->release();
184		return 0;
185	}
186
187	return me;
188}
189
190unsigned int OSSerialize::getLength() const { return length; }
191unsigned int OSSerialize::getCapacity() const { return capacity; }
192unsigned int OSSerialize::getCapacityIncrement() const { return capacityIncrement; }
193unsigned int OSSerialize::setCapacityIncrement(unsigned int increment)
194{
195    capacityIncrement = (increment)? increment : 256;
196    return capacityIncrement;
197}
198
199unsigned int OSSerialize::ensureCapacity(unsigned int newCapacity)
200{
201	char *newData;
202
203	if (newCapacity <= capacity)
204		return capacity;
205
206	// round up
207	newCapacity = round_page_32(newCapacity);
208
209	kern_return_t rc = kmem_realloc(kernel_map,
210					(vm_offset_t)data,
211					capacity,
212					(vm_offset_t *)&newData,
213					newCapacity);
214	if (!rc) {
215	    ACCUMSIZE(newCapacity);
216
217	    // kmem realloc does not free the old address range
218	    kmem_free(kernel_map, (vm_offset_t)data, capacity);
219	    ACCUMSIZE(-capacity);
220
221	    // kmem realloc does not zero out the new memory
222	    // and this could end up going to user land
223	    bzero(&newData[capacity], newCapacity - capacity);
224
225	    data = newData;
226	    capacity = newCapacity;
227	}
228
229	return capacity;
230}
231
232void OSSerialize::free()
233{
234    if (tags)
235        tags->release();
236
237    if (data) {
238	kmem_free(kernel_map, (vm_offset_t)data, capacity);
239        ACCUMSIZE( -capacity );
240    }
241    super::free();
242}
243
244
245OSDefineMetaClassAndStructors(OSSerializer, OSObject)
246
247OSSerializer * OSSerializer::forTarget( void * target,
248                               OSSerializerCallback callback, void * ref )
249{
250    OSSerializer * thing;
251
252    thing = new OSSerializer;
253    if( thing && !thing->init()) {
254	thing->release();
255	thing = 0;
256    }
257
258    if( thing) {
259	thing->target	= target;
260        thing->ref	= ref;
261        thing->callback = callback;
262    }
263    return( thing );
264}
265
266bool OSSerializer::serialize( OSSerialize * s ) const
267{
268    return( (*callback)(target, ref, s) );
269}
270