![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOPropertyTable.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver / ppc|
Return to IOPropertyTable.m CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / ppc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /*
25: * Copyright (c) 1997 Apple Computer, Inc.
26: *
27: *
28: * HISTORY
29: *
30: * Simon Douglas 22 Oct 97
31: * - first checked in.
32: */
33:
34:
35:
36: #include <stdlib.h>
37: #include <string.h>
38:
39: #include <driverkit/ppc/IOPropertyTable.h>
40:
41:
42: typedef struct PTEntry PTEntry;
43: struct PTEntry
44: {
45: PTEntry * next;
46: void * data;
47: ByteCount dataLength;
48: OptionBits flags;
49: char name[ 1 ];
50: };
51:
52:
53: struct PTable
54: {
55: PTEntry dummy;
56: };
57: typedef struct PTable PTable;
58:
59: @implementation IOPropertyTable
60:
61: void * PTAlloc( UInt32 size, Boolean clear )
62: {
63: void * mem;
64:
65: mem = (void *) IOMalloc( size);
66: if( mem && clear)
67: bzero( mem, size);
68: return( mem);
69: }
70:
71: void PTFree( void * data, UInt32 size )
72: {
73: IOFree( data, size);
74: }
75:
76:
77: - init
78: {
79: _ptprivate = PTAlloc( sizeof( PTable), true);
80:
81: return( self);
82: }
83:
84: -(IOReturn) deleteEntry:(PTEntry *)entry prev:(PTEntry *)prev
85: {
86: prev->next = entry->next;
87:
88: if( 0 == (entry->flags & kReferenceProperty))
89: PTFree( entry->data, entry->dataLength);
90:
91: PTFree( entry, strlen( entry->name) + sizeof( PTEntry));
92:
93: return( noErr);
94: }
95:
96: - free
97: {
98: PTable * table = _ptprivate;
99: PTEntry * previous = &table->dummy;
100: PTEntry * entry;
101:
102: while( (entry = previous->next))
103: [self deleteEntry:entry prev:previous];
104:
105: PTFree( table, sizeof( PTable));
106: return( [super free]);
107: }
108:
109:
110: - (PTEntry *) findProperty:(const char *)name prev:(PTEntry **)prev
111: {
112: PTable * table = _ptprivate;
113: PTEntry * previous = &table->dummy;
114: PTEntry * entry;
115:
116: while( (entry = previous->next)) {
117: if( 0 == strcmp( name, entry->name)) {
118: if( prev)
119: *prev = previous;
120: return( entry);
121: }
122: previous = entry;
123: }
124:
125: return( NULL);
126: }
127:
128:
129: -(IOReturn) getPropertyWithIndex:(UInt32)index name:(char *)name
130: {
131:
132: PTable * table = _ptprivate;
133: PTEntry * previous = &table->dummy;
134: PTEntry * entry;
135:
136: while( (entry = previous->next)) {
137: if( (index--) == 0) {
138: strcpy( name, entry->name );
139: return( noErr);
140: }
141: previous = entry;
142: }
143:
144: return( nrNotFoundErr);
145: }
146:
147:
148: -(IOReturn) setEntryProperty:(PTEntry *)entry
149: flags:(OptionBits)flags value:(void *)value length:(ByteCount)length
150: {
151: void * copy;
152:
153: if( flags & kReferenceProperty) {
154: copy = value;
155: } else {
156: copy = PTAlloc( length, false);
157: if( nil == copy)
158: return( nrNotEnoughMemoryErr);
159: bcopy( value, copy, length );
160: }
161:
162: if( (0 == (entry->flags & kReferenceProperty))
163: && entry->data )
164: PTFree( entry->data, entry->dataLength);
165:
166: entry->flags = flags;
167: entry->data = copy;
168: entry->dataLength = length;
169:
170: return( noErr);
171: }
172:
173:
174: -(IOReturn) createProperty:(const char *)name flags:(OptionBits)flags
175: value:(void *)value length:(ByteCount)length
176: {
177: IOReturn err;
178: PTable * table = _ptprivate;
179: PTEntry * entry;
180:
181: if( [self findProperty:name prev:NULL] )
182: return( nrPropertyAlreadyExists);
183:
184: entry = PTAlloc( strlen(name) + sizeof( PTEntry), true);
185: if( NULL == entry)
186: return( nrNotEnoughMemoryErr);
187:
188: err = [self setEntryProperty:entry flags:flags value:value length:length];
189: if( err) {
190: PTFree( entry, strlen(name) + sizeof( PTEntry));
191: return( err);
192: }
193:
194: entry->next = table->dummy.next;
195: table->dummy.next = entry;
196: strcpy( entry->name, name );
197:
198: return( noErr);
199:
200: }
201:
202: -(IOReturn) setProperty:(const char *)name flags:(OptionBits)flags
203: value:(void *)value length:(ByteCount)length
204: {
205: PTEntry * entry;
206:
207: entry = [self findProperty:name prev:NULL];
208: if( entry == NULL)
209: return( nrNotFoundErr);
210:
211: return( [self setEntryProperty:entry flags:flags value:value length:length] );
212: }
213:
214: -(IOReturn) deleteProperty:(const char *)name
215: {
216: PTEntry * entry;
217: PTEntry * prev;
218:
219: entry = [self findProperty:name prev:&prev];
220: if( entry == NULL)
221: return( nrNotFoundErr);
222:
223: return( [self deleteEntry:entry prev:prev] );
224: }
225:
226: -(IOReturn) getProperty:(const char *)name flags:(OptionBits)flags
227: value:(void **)value length:(ByteCount *)length
228: {
229: PTEntry * entry;
230:
231: entry = [self findProperty:name prev:NULL];
232: if( entry == NULL)
233: return( nrNotFoundErr);
234:
235: if( flags & kReferenceProperty) {
236: if( value) // can be NULL to just get the size
237: *value = entry->data;
238: } else {
239: bcopy( entry->data, *value, ((*length) < entry->dataLength)
240: ? (*length) : entry->dataLength );
241: }
242:
243: *length = entry->dataLength;
244:
245: return( noErr);
246: }
247:
248: //////// IOConfigTable methods ////////
249:
250: - (const char *)valueForStringKey:(const char *)key
251: {
252: IOReturn err;
253: ByteCount length;
254: char * data;
255: char * result;
256: char nameBuf[ 88 ] = "AAPL,dk_";
257:
258: length = strlen( key);
259: if( length > 80)
260: length = 80;
261: strncpy( nameBuf + 8, key, length);
262: nameBuf[ 8 + length ] = 0;
263:
264: err = [self getProperty:nameBuf flags:kReferenceProperty
265: value:(void **)&data length:&length];
266: if( err)
267: return( NULL);
268:
269: result = (char *) IOMalloc( length + 1);
270: if( result) {
271: strncpy( result, data, length);
272: result[ length ] = 0;
273: }
274:
275: return( result);
276: }
277:
278: static const char * getNextStr( const char *where, UInt32 * len )
279: {
280: const char * start;
281: const char * end;
282:
283: start = strchr( where, '\"');
284: if( start != NULL) {
285: start++;
286: end = strchr( start, '\"');
287: if( end)
288: *len = end - start;
289: else
290: start = NULL;
291: }
292: return( start);
293: }
294:
295:
296: - addConfigData:(const char *)configData
297: {
298:
299: char nameBuf[ 88 ] = "AAPL,dk_";
300: const char * str;
301: const char * eol;
302: const char * value;
303: UInt32 len;
304:
305: str = configData;
306: while( (str = getNextStr( str, &len))) {
307:
308: if( len > 80)
309: len = 80;
310: strncpy( nameBuf + 8, str, len);
311: nameBuf[ 8 + len ] = 0;
312:
313: str += len + 1;
314: eol = strchr( str, ';');
315: value = getNextStr( str, &len);
316: if( value == NULL)
317: break;
318: [self deleteProperty:(const char *)nameBuf];
319: if( eol > value) {
320: [self createProperty:(const char *)nameBuf flags:0 value:value length:len];
321: str = value + len + 1;
322: } else // key with no value
323: [self createProperty:(const char *)nameBuf flags:0 value:value length:0];
324: }
325:
326: return( self);
327: }
328:
329: + (void)freeString : (const char *)string
330: {
331: IOFree((char *)string, strlen(string) + 1);
332: }
333:
334: - (void)freeString : (const char *)string
335: {
336: [IOPropertyTable freeString:string];
337: }
338:
339: @end
340:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.