Chameleon

Chameleon Svn Source Tree

Root/branches/andyvand/i386/libsaio/stringTable.c

1/*
2 * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * Portions Copyright (c) 1999-2003 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 2.0 (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 1993 NeXT, Inc.
26 * All rights reserved.
27 */
28
29#include "bootstruct.h"
30#include "libsaio.h"
31#include "xml.h"
32
33extern char *Language;
34extern char *LoadableFamilies;
35
36bool sysConfigValid;
37
38/*
39 * Compare a string to a key with quoted characters
40 */
41static inline int
42keyncmp(const char *str, const char *key, int n)
43{
44 int c;
45 while (n--) {
46c = *key++;
47if (c == '\\') {
48 switch(c = *key++) {
49 case 'n':
50c = '\n';
51break;
52 case 'r':
53c = '\r';
54break;
55 case 't':
56c = '\t';
57break;
58 default:
59break;
60 }
61} else if (c == '\"') {
62 /* Premature end of key */
63 return 1;
64}
65if (c != *str++) {
66 return 1;
67}
68 }
69 return 0;
70}
71
72#if UNUSED
73
74static void eatThru(char val, const char **table_p)
75{
76register const char *table = *table_p;
77register bool found = false;
78
79while (*table && !found)
80{
81if (*table == '\\') table += 2;
82else
83{
84if (*table == val) found = true;
85table++;
86}
87}
88*table_p = table;
89}
90
91/* Remove key and its associated value from the table. */
92
93bool
94removeKeyFromTable(const char *key, char *table)
95{
96 register int len;
97 register char *tab;
98 char *buf;
99
100 len = strlen(key);
101 tab = (char *)table;
102 buf = (char *)malloc(len + 3);
103
104 sprintf(buf, "\"%s\"", key);
105 len = strlen(buf);
106
107 while(*tab) {
108 if(strncmp(buf, tab, len) == 0) {
109 char c;
110
111 while((c = *(tab + len)) != ';') {
112 if(c == 0) {
113 len = -1;
114 goto out;
115 }
116 len++;
117 }
118 len++;
119 if(*(tab + len) == '\n') len++;
120 goto out;
121 }
122 tab++;
123 }
124 len = -1;
125out:
126 free(buf);
127
128 if(len == -1) return false;
129
130 while((*tab = *(tab + len))) {
131 tab++;
132 }
133
134 return true;
135}
136
137char *
138newStringFromList(
139 char **list,
140 int *size
141)
142{
143 char *begin = *list, *end;
144 char *newstr;
145 int newsize = *size;
146 int bufsize;
147
148 while (*begin && newsize && isspace(*begin)) {
149begin++;
150newsize--;
151 }
152 end = begin;
153 while (*end && newsize && !isspace(*end)) {
154end++;
155newsize--;
156 }
157 if (begin == end)
158return 0;
159 bufsize = end - begin + 1;
160 newstr = malloc(bufsize);
161 strlcpy(newstr, begin, bufsize);
162 *list = end;
163 *size = newsize;
164 return newstr;
165}
166
167#endif
168
169/*
170 * compress == compress escaped characters to one character
171 */
172int stringLength(const char *table, int compress)
173{
174int ret = 0;
175
176while (*table)
177{
178if (*table == '\\')
179{
180table += 2;
181ret += 1 + (compress ? 0 : 1);
182}
183else
184{
185if (*table == '\"') return ret;
186ret++;
187table++;
188}
189}
190return ret;
191}
192
193
194bool getValueForConfigTableKey(config_file_t *config, const char *key, const char **val, int *size)
195{
196if (config->dictionary != 0 ) {
197// Look up key in XML dictionary
198TagPtr value;
199value = XMLGetProperty(config->dictionary, key);
200if (value != 0) {
201if (value->type != kTagTypeString) {
202error("Non-string tag '%s' found in config file\n",
203 key);
204return false;
205}
206*val = value->string;
207*size = strlen(value->string);
208return true;
209}
210} else {
211
212// Legacy plist-style table
213
214}
215
216return false;
217}
218
219#if UNUSED
220
221/*
222 * Returns a new malloc'ed string if one is found
223 * in the string table matching 'key'. Also translates
224 * \n escapes in the string.
225 */
226char *newStringForStringTableKey(
227char *table,
228char *key,
229config_file_t *config
230)
231{
232 const char *val;
233 char *newstr, *p;
234 int size;
235
236 if (getValueForConfigTableKey(config, key, &val, &size)) {
237newstr = (char *)malloc(size+1);
238for (p = newstr; size; size--, p++, val++) {
239 if ((*p = *val) == '\\') {
240switch (*++val) {
241case 'r':
242 *p = '\r';
243 break;
244case 'n':
245 *p = '\n';
246 break;
247case 't':
248 *p = '\t';
249 break;
250default:
251 *p = *val;
252 break;
253}
254size--;
255 }
256}
257*p = '\0';
258return newstr;
259 } else {
260return 0;
261 }
262}
263
264#endif
265
266char *
267newStringForKey(char *key, config_file_t *config)
268{
269 const char *val;
270 char *newstr;
271 int size;
272
273 if (getValueForKey(key, &val, &size, config) && size) {
274newstr = (char *)malloc(size + 1);
275strlcpy(newstr, val, size + 1);
276return newstr;
277 } else {
278return 0;
279 }
280}
281
282/* parse a command line
283 * in the form: [<argument> ...] [<option>=<value> ...]
284 * both <option> and <value> must be either composed of
285 * non-whitespace characters, or enclosed in quotes.
286 */
287
288static const char *getToken(const char *line, const char **begin, int *len)
289{
290 if (*line == '\"') {
291*begin = ++line;
292while (*line && *line != '\"')
293 line++;
294*len = line++ - *begin;
295 } else {
296*begin = line;
297while (*line && !isspace(*line) && *line != '=')
298 line++;
299*len = line - *begin;
300 }
301 return line;
302}
303
304bool getValueForBootKey(const char *line, const char *match, const char **matchval, int *len)
305{
306 const char *key, *value;
307 int key_len, value_len;
308 bool retval = false;
309
310 while (*line) {
311/* look for keyword or argument */
312while (isspace(*line)) line++;
313
314/* now look for '=' or whitespace */
315line = getToken(line, &key, &key_len);
316/* line now points to '=' or space */
317if (*line && !isspace(*line)) {
318 line = getToken(++line, &value, &value_len);
319} else {
320 value = line;
321 value_len = 0;
322}
323if ((strlen(match) == key_len)
324 && strncmp(match, key, key_len) == 0) {
325 *matchval = value;
326 *len = value_len;
327 retval = true;
328 /* Continue to look for this key; last one wins. */
329}
330 }
331 return retval;
332}
333
334/* Return NULL if no option has been successfully retrieved, or the string otherwise */
335const char * getStringForKey(const char * key, config_file_t *config)
336{
337 static const char* value =0;
338 int len=0;
339 if(!getValueForKey(key, &value, &len, config)) value = 0;
340 return value;
341}
342
343
344/* Returns TRUE if a value was found, FALSE otherwise.
345 * The boolean value of the key is stored in 'val'.
346 */
347
348bool getBoolForKey( const char *key, bool *result_val, config_file_t *config )
349{
350 const char *key_val;
351 int size;
352
353 if (getValueForKey(key, &key_val, &size, config)) {
354 if ( (size >= 1) && (key_val[0] == 'Y' || key_val[0] == 'y') ) {
355 *result_val = true;
356 } else {
357 *result_val = false;
358 }
359 return true;
360 }
361 return false;
362}
363
364bool getIntForKey( const char *key, int *value, config_file_t *config )
365{
366 const char *val;
367 int size, sum;
368 bool negative = false;
369
370 if (getValueForKey(key, &val, &size, config))
371{
372if ( size )
373{
374if (*val == '-')
375{
376negative = true;
377val++;
378size--;
379}
380
381for (sum = 0; size > 0; size--)
382{
383if (*val < '0' || *val > '9')
384return false;
385
386sum = (sum * 10) + (*val++ - '0');
387}
388
389if (negative)
390sum = -sum;
391
392*value = sum;
393return true;
394}
395}
396 return false;
397}
398
399/*
400 *
401 */
402
403bool getDimensionForKey( const char *key, unsigned int *value, config_file_t *config, unsigned int dimension_max, unsigned int object_size )
404{
405const char *val;
406
407 int size = 0;
408int sum = 0;
409
410bool negative = false;
411bool percentage = false;
412
413 if (getValueForKey(key, &val, &size, config))
414{
415if ( size )
416{
417if (*val == '-')
418{
419negative = true;
420val++;
421size--;
422}
423
424if (val[size-1] == '%')
425{
426percentage = true;
427size--;
428}
429
430// convert string to integer
431for (sum = 0; size > 0; size--)
432{
433if (*val < '0' || *val > '9')
434return false;
435
436sum = (sum * 10) + (*val++ - '0');
437}
438
439if (percentage)
440sum = ( dimension_max * sum ) / 100;
441
442// calculate offset from opposite origin
443if (negative)
444sum = ( ( dimension_max - object_size ) - sum );
445
446} else {
447
448// null value calculate center
449sum = ( dimension_max - object_size ) / 2;
450
451}
452
453*value = (uint16_t) sum;
454return true;
455}
456
457// key not found
458 return false;
459}
460
461/*
462 *get color value from plist format #RRGGBB
463 */
464
465bool getColorForKey( const char *key, unsigned int *value, config_file_t *config )
466{
467 const char *val;
468 int size;
469
470 if (getValueForKey(key, &val, &size, config))
471{
472if (*val == '#')
473{
474 val++;
475*value = strtol(val, NULL, 16);
476return true;
477 }
478 }
479 return false;
480}
481
482bool getValueForKey( const char *key, const char **val, int *size, config_file_t *config )
483{
484 if (getValueForBootKey(bootArgs->CommandLine, key, val, size))
485 return true;
486
487 return getValueForConfigTableKey(config, key, val, size);
488}
489
490
491#if UNUSED
492void
493printSystemConfig(char *p1)
494{
495 char *p2 = p1, tmp;
496
497 while (*p1 != '\0') {
498while (*p2 != '\0' && *p2 != '\n') p2++;
499tmp = *p2;
500*p2 = '\0';
501printf("%s\n", p1);
502*p2 = tmp;
503if (tmp == '\0') break;
504p1 = ++p2;
505 }
506}
507#endif
508
509//==========================================================================
510// ParseXMLFile
511// Modifies the input buffer.
512// Expects to see one dictionary in the XML file.
513// Puts the first dictionary it finds in the
514// tag pointer and returns 0, or returns -1 if not found
515// (and does not modify dict pointer).
516// Prints an error message if there is a parsing error.
517//
518int ParseXMLFile( char * buffer, TagPtr * dict )
519{
520 long length, pos;
521 TagPtr tag;
522 pos = 0;
523 char *configBuffer;
524
525 configBuffer = malloc(strlen(buffer)+1);
526 strcpy(configBuffer, buffer);
527
528 while (1)
529 {
530 length = XMLParseNextTag(configBuffer + pos, &tag);
531 if (length == -1) break;
532
533 pos += length;
534
535 if (tag == 0) continue;
536 if (tag->type == kTagTypeDict) break;
537
538 XMLFreeTag(tag);
539 }
540 free(configBuffer);
541 if (length < 0) {
542 error ("Error parsing plist file\n");
543 return -1;
544 }
545 *dict = tag;
546 return 0;
547}
548
549/* loadConfigFile
550 *
551 * Returns 0 - successful.
552 * -1 - unsuccesful.
553 */
554int loadConfigFile (const char *configFile, config_file_t *config)
555{
556int fd, count;
557
558if ((fd = open_bvdev("bt(0,0)", configFile, 0)) < 0) {
559return -1;
560}
561// read file
562count = read(fd, config->plist, IO_CONFIG_DATA_SIZE);
563close(fd);
564
565// build xml dictionary
566ParseXMLFile(config->plist, &config->dictionary);
567return 0;
568}
569
570
571/* loadSystemConfig
572 *
573 * filename == NULL:
574 * You are loading from com.apple.Boot.plist somewhere in the universe.
575 * Also, bootarg's "config=" is considerd as replacement name.
576 *
577 * filename != NULL:
578 * Use it as file name.
579 *
580 * Returns 0 - successful.
581 * -1 - unsuccesful.
582 */
583#define MAX_DIRSPECS (8)
584
585int loadSystemConfig(const char* bootargs, config_file_t *config, const char* filename, bool override)
586{
587char config_filename[512];// Will be filled with the name of boot.plist
588
589char *defaultDirspec[MAX_DIRSPECS] = {
590"/Extra/",
591"bt(0,0)/Extra/",
592NULL,
593NULL,
594NULL,
595NULL,
596NULL,
597NULL
598};
599
600char *overrideDirspec[MAX_DIRSPECS] = {
601"rd(0,0)/Extra/",
602"/Extra/",
603NULL,
604NULL,
605NULL,
606NULL,
607NULL,
608NULL
609};
610
611char* moreBootPlist[4] = {
612"/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
613"/com.apple.boot.P/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
614"/com.apple.boot.R/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
615"/com.apple.boot.S/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
616};
617
618int i, j, fd, count, size;
619const char* val;
620char filespec[512];
621char *dirspec[MAX_DIRSPECS];
622
623if (override)
624 memcpy(dirspec, overrideDirspec, sizeof(overrideDirspec));
625else
626 memcpy(dirspec, defaultDirspec, sizeof(defaultDirspec));
627
628
629if (filename)
630{
631 strcpy(config_filename, filename);
632}
633else
634{
635 strcpy(config_filename, "com.apple.Boot.plist");
636 for (j = 0; dirspec[j]; j++) /* noop */;
637 memcpy(&dirspec[j], moreBootPlist, sizeof(moreBootPlist));
638 // If there is a config designated, point boot.plist to something else.
639 if (bootargs && getValueForBootKey(bootargs, "config", &val, &size))
640 {
641 if (size > 480) size = 480;
642 if (size > 0)
643 {
644 memcpy(config_filename, val, size);
645 config_filename[size] = 0;
646 }
647 }
648}
649
650for(i = 0; dirspec[i]; i++)
651{
652strcpy(filespec, dirspec[i]);
653/* If the last char is / then append the boot.plist name */
654if (filespec[strlen(filespec)-1] == '/')
655{
656strcat(filespec, config_filename);
657}
658
659if ((fd = open(filespec, 0)) >= 0)
660{
661// read file
662count = read(fd, config->plist, IO_CONFIG_DATA_SIZE);
663close(fd);
664
665// build xml dictionary
666ParseXMLFile(config->plist, &config->dictionary);
667sysConfigValid=true;
668verbose("Config file %s loaded\n", filespec);
669return 0;
670}
671}
672return -1;
673}
674
675/* loadHelperConfig
676 *
677 * Returns 0 - successful.
678 * -1 - unsuccesful.
679 */
680int loadHelperConfig(config_file_t *config)
681{
682char *dirspec[] = {
683"/com.apple.boot.P/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
684"/com.apple.boot.R/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
685"/com.apple.boot.S/Library/Preferences/SystemConfiguration/com.apple.Boot.plist"
686};
687
688int i, fd, count, ret=-1;
689
690for(i = 0; i< sizeof(dirspec)/sizeof(dirspec[0]); i++)
691{
692if ((fd = open(dirspec[i], 0)) >= 0)
693{
694// read file
695count = read(fd, config->plist, IO_CONFIG_DATA_SIZE);
696close(fd);
697
698// build xml dictionary
699ParseXMLFile(config->plist, &config->dictionary);
700sysConfigValid = true;
701ret=0;
702break;
703}
704}
705return ret;
706}
707
708char * newString(const char * oldString)
709{
710 if ( oldString )
711 return strcpy(malloc(strlen(oldString)+1), oldString);
712 else
713 return NULL;
714}
715
716/*
717 * Extracts the next argument from the command line, double quotes are allowed here.
718 */
719char * getNextArg(char ** argPtr, char * val)
720{
721 char * ptr = *argPtr;
722 const char * strStart;
723 int len = 0;
724 bool isQuoted = false;
725
726 *val = '\0';
727
728 // Scan for the next non-whitespace character.
729 while ( *ptr && (*ptr == ' ' || *ptr == '=') )
730 {
731 ptr++;
732 }
733
734 strStart = ptr;
735
736 // Skip the leading double quote character.
737 if (*ptr == '\"')
738 {
739 isQuoted = true;
740 ptr++;
741 strStart++;
742 }
743
744 // Scan for the argument terminator character.
745 // This can be either a NULL character - in case we reach the end of the string,
746 // a double quote in case of quoted argument,
747 // or a whitespace character (' ' or '=') for non-quoted argument.
748 while (*ptr && !( (isQuoted && (*ptr == '\"')) ||
749 (!isQuoted && (*ptr == ' ' || *ptr == '=')) )
750 )
751 {
752 ptr++;
753 }
754
755 len = ptr - strStart;
756
757 // Skip the closing double quote character and adjust
758 // the starting pointer for the next getNextArg call.
759 if (*ptr && isQuoted && *ptr == '\"')
760 ptr++;
761
762 // Copy the extracted argument to val.
763 strncat(val, strStart, len);
764
765 // Set command line pointer.
766 *argPtr = ptr;
767
768 return ptr;
769}
770
771
772

Archive Download this file

Revision: 141