Chameleon

Chameleon Svn Source Tree

Root/branches/ErmaC/Enoch/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 "boot.h"
32#include "xml.h"
33
34extern char *Language;
35extern char *LoadableFamilies;
36
37bool sysConfigValid;
38
39#if UNUSED
40
41/*
42 * Compare a string to a key with quoted characters
43 */
44static inline int keyncmp(const char *str, const char *key, int n)
45{
46 int c;
47 while (n--) {
48c = *key++;
49if (c == '\\') {
50 switch(c = *key++) {
51 case 'n':
52c = '\n';
53break;
54 case 'r':
55c = '\r';
56break;
57 case 't':
58c = '\t';
59break;
60 default:
61break;
62 }
63} else if (c == '\"') {
64 // Premature end of key
65 return 1;
66}
67if (c != *str++) {
68 return 1;
69}
70 }
71 return 0;
72}
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. */
92bool removeKeyFromTable(const char *key, char *table)
93{
94 register int len;
95 register char *tab;
96 char *buf;
97
98 len = strlen(key);
99 tab = (char *)table;
100 buf = (char *)malloc(len + 3);
101
102 snprintf(buf, len + 3,"\"%s\"", key);
103 len = strlen(buf);
104
105 while(*tab) {
106 if(strncmp(buf, tab, len) == 0) {
107 char c;
108
109 while((c = *(tab + len)) != ';') {
110 if(c == 0) {
111 len = -1;
112 goto out;
113 }
114 len++;
115 }
116 len++;
117 if(*(tab + len) == '\n') len++;
118 goto out;
119 }
120 tab++;
121 }
122 len = -1;
123out:
124 free(buf);
125
126 if(len == -1) return false;
127
128 while((*tab = *(tab + len))) {
129 tab++;
130 }
131
132 return true;
133}
134
135char *newStringFromList(char **list, int *size)
136{
137char *begin = *list, *end;
138char *newstr;
139int newsize = *size;
140int bufsize;
141
142while (*begin && newsize && isspace(*begin)) {
143begin++;
144newsize--;
145}
146end = begin;
147while (*end && newsize && !isspace(*end)) {
148end++;
149newsize--;
150}
151if (begin == end) {
152return 0;
153}
154bufsize = end - begin + 1;
155newstr = malloc(bufsize);
156if (!newstr)
157{
158return 0;
159}
160strlcpy(newstr, begin, bufsize);
161*list = end;
162*size = newsize;
163return newstr;
164}
165
166#endif
167
168/*
169 * compress == compress escaped characters to one character
170 */
171int stringLength(const char *table, int compress)
172{
173int ret = 0;
174
175while (*table) {
176if (*table == '\\') {
177table += 2;
178ret += 1 + (compress ? 0 : 1);
179}
180else
181{
182if (*table == '\"')
183{
184return ret;
185}
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", key);
203return false;
204}
205*val = value->string;
206*size = strlen(value->string);
207return true;
208}
209} else {
210
211// Legacy plist-style table
212
213}
214
215return false;
216}
217
218#if UNUSED
219
220/*
221 * Returns a new malloc'ed string if one is found
222 * in the string table matching 'key'. Also translates
223 * \n escapes in the string.
224 */
225char *newStringForStringTableKey(char *table, char *key, config_file_t *config)
226{
227const char *val;
228char *newstr, *p;
229int size;
230
231if (getValueForConfigTableKey(config, key, &val, &size))
232{
233newstr = (char *)malloc(size+1);
234if (!newstr)
235{
236return 0;
237}
238for (p = newstr; size; size--, p++, val++) {
239if ((*p = *val) == '\\') {
240switch (*++val) {
241case 'r':
242*p = '\r';
243break;
244case 'n':
245*p = '\n';
246break;
247case 't':
248*p = '\t';
249break;
250default:
251*p = *val;
252break;
253}
254size--;
255}
256}
257*p = '\0';
258return newstr;
259} else {
260return 0;
261}
262}
263
264#endif
265
266char *newStringForKey(char *key, config_file_t *config)
267{
268const char *val;
269char *newstr;
270int size;
271
272if (getValueForKey(key, &val, &size, config) && size) {
273newstr = (char *)malloc(size + 1);
274if (!newstr)
275{
276return 0;
277}
278strlcpy(newstr, val, size + 1);
279return newstr;
280} else {
281return 0;
282}
283}
284
285/* parse a command line
286 * in the form: [<argument> ...] [<option>=<value> ...]
287 * both <option> and <value> must be either composed of
288 * non-whitespace characters, or enclosed in quotes.
289 */
290static const char *getToken(const char *line, const char **begin, int *len)
291{
292if (*line == '\"') {
293*begin = ++line;
294while (*line && *line != '\"') {
295line++;
296}
297*len = line++ - *begin;
298} else {
299*begin = line;
300while (*line && !isspace(*line) && *line != '=') {
301line++;
302}
303*len = line - *begin;
304}
305return line;
306}
307
308bool getValueForBootKey(const char *line, const char *match, const char **matchval, int *len)
309{
310const char *key, *value;
311int key_len, value_len;
312bool retval = false;
313
314while (*line) {
315/* look for keyword or argument */
316while (isspace(*line))
317{
318line++;
319}
320
321/* now look for '=' or whitespace */
322line = getToken(line, &key, &key_len);
323/* line now points to '=' or space */
324if (*line && !isspace(*line)) {
325line = getToken(++line, &value, &value_len);
326} else {
327value = line;
328value_len = 0;
329}
330if ((strlen(match) == key_len) && strncmp(match, key, key_len) == 0)
331{
332// create a new string
333char* newstr = malloc(value_len + 1);
334strncpy(newstr, value, value_len);
335newstr[value_len] = 0;
336
337*matchval = newstr;
338*len = value_len;
339retval = true;
340/* Continue to look for this key; last one wins. */
341}
342}
343
344return retval;
345}
346
347/* Return NULL if no option has been successfully retrieved, or the string otherwise */
348const char *getStringForKey(const char *key, config_file_t *config)
349{
350static const char *value = 0;
351int len = 0;
352if (!getValueForKey(key, &value, &len, config))
353{
354value = 0;
355}
356return value;
357}
358
359/* Returns TRUE if a value was found, FALSE otherwise.
360 * The boolean value of the key is stored in 'val'.
361 */
362bool getBoolForKey(const char *key, bool *result_val, config_file_t *config)
363{
364const char *key_val;
365int size;
366
367if (getValueForKey(key, &key_val, &size, config))
368{
369if ((size >= 1) && (key_val[0] == 'Y' || key_val[0] == 'y'))
370{
371*result_val = true;
372}
373else
374{
375*result_val = false;
376}
377return true;
378}
379return false;
380}
381
382bool getIntForKey(const char *key, int *value, config_file_t *config)
383{
384const char *val;
385int size, sum;
386bool negative = false;
387
388if (getValueForKey(key, &val, &size, config))
389{
390if (size)
391{
392if (*val == '-')
393{
394negative = true;
395val++;
396size--;
397}
398
399for (sum = 0; size > 0; size--)
400{
401if (*val < '0' || *val > '9')
402{
403return false;
404}
405
406sum = (sum * 10) + (*val++ - '0');
407}
408
409if (negative)
410{
411sum = -sum;
412}
413*value = sum;
414return true;
415}
416}
417return false;
418}
419/*
420 *
421 */
422bool getDimensionForKey( const char *key, unsigned int *value, config_file_t *config, unsigned int dimension_max, unsigned int object_size )
423{
424const char *val;
425
426int size = 0;
427int sum = 0;
428
429bool negative = false;
430bool percentage = false;
431
432if (getValueForKey(key, &val, &size, config))
433{
434if ( size )
435{
436if (*val == '-')
437{
438negative = true;
439val++;
440size--;
441}
442
443if (val[size-1] == '%')
444{
445percentage = true;
446size--;
447}
448
449// convert string to integer
450for (sum = 0; size > 0; size--)
451{
452if (*val < '0' || *val > '9')
453{
454return false;
455}
456
457sum = (sum * 10) + (*val++ - '0');
458}
459
460if (percentage)
461{
462sum = ( dimension_max * sum ) / 100;
463}
464
465// calculate offset from opposite origin
466if (negative)
467{
468sum = ( ( dimension_max - object_size ) - sum );
469}
470
471}
472else
473{
474
475// null value calculate center
476sum = ( dimension_max - object_size ) / 2;
477
478}
479
480*value = (uint16_t) sum;
481return true;
482}
483
484// key not found
485return false;
486}
487
488/*
489 *get color value from plist format #RRGGBB
490 */
491bool getColorForKey( const char *key, unsigned int *value, config_file_t *config )
492{
493const char *val;
494int size;
495
496if (getValueForKey(key, &val, &size, config))
497{
498if (*val == '#') {
499val++;
500*value = strtol(val, NULL, 16);
501return true;
502}
503}
504return false;
505}
506
507bool getValueForKey( const char *key, const char **val, int *size, config_file_t *config )
508{
509const char *overrideVal;
510int overrideSize;
511bool override, ret;
512
513if (getValueForBootKey(bootArgs->CommandLine, key, val, size))
514{
515return true;
516}
517
518ret = getValueForConfigTableKey(config, key, val, size);
519
520// Try to find alternate keys in bootInfo->chameleonConfig (if config can be overriden)
521// and prefer its values with the exceptions for
522// "Kernel"="mach_kernel" and "Kernel Flags"="".
523
524if (config->canOverride)
525{
526if (getValueForConfigTableKey(&bootInfo->chameleonConfig, key, &overrideVal, &overrideSize))
527{
528override = true;
529
530// NOTE: Values are defined by apple as being in com.apple.Boot.plist
531// kHelperRootUUIDKey, kKernelArchKey, kMKextCacheKey, kKernelCacheKey, kKernelNameKey, kKernelFlagsKey
532if (ret && (strcmp(key, kKernelNameKey) == 0) && (overrideSize == 0))
533{
534override = false;
535}
536
537if (ret && (strcmp(key, kKernelFlagsKey) == 0) && (overrideSize == 0))
538{
539override = false;
540}
541
542if (override)
543{
544*val = overrideVal;
545*size = overrideSize;
546ret = true;
547}
548}
549}
550return ret;
551}
552
553#if UNUSED
554void printSystemConfig(char *p1)
555{
556char *p2 = p1, tmp;
557
558while (*p1 != '\0')
559{
560while (*p2 != '\0' && *p2 != '\n')
561{
562p2++;
563}
564tmp = *p2;
565*p2 = '\0';
566printf("%s\n", p1);
567*p2 = tmp;
568if (tmp == '\0')
569{
570break;
571}
572p1 = ++p2;
573 }
574}
575#endif
576
577//==========================================================================
578// ParseXMLFile
579// Modifies the input buffer.
580// Expects to see one dictionary in the XML file.
581// Puts the first dictionary it finds in the
582// tag pointer and returns 0, or returns -1 if not found
583// (and does not modify dict pointer).
584// Prints an error message if there is a parsing error.
585//
586int ParseXMLFile( char *buffer, TagPtr *dict )
587{
588long length, pos;
589TagPtr tag = 0;
590pos = 0;
591char *configBuffer;
592
593length = strlen(buffer) + 1;
594
595configBuffer = malloc(strlen(buffer)+1);
596if (!configBuffer)
597{
598return -1;
599}
600strlcpy(configBuffer, buffer, length );
601
602while (1)
603{
604length = XMLParseNextTag(configBuffer + pos, &tag);
605if (length == -1)
606{
607break;
608}
609
610pos += length;
611
612if (tag == 0)
613{
614continue;
615}
616if (tag->type == kTagTypeDict)
617{
618break;
619}
620
621XMLFreeTag(tag);
622}
623free(configBuffer);
624if (length < 0) {
625error ("Error parsing plist file\n");
626return -1;
627}
628*dict = tag;
629return 0;
630}
631
632/* loadConfigFile
633 *
634 * Returns 0 - successful.
635 * -1 - unsuccesful.
636 */
637int loadConfigFile (const char *configFile, config_file_t *config)
638{
639int fd, count;
640
641if ((fd = open_bvdev("bt(0,0)", configFile, 0)) < 0)
642{
643return -1;
644}
645// read file
646count = read(fd, config->plist, IO_CONFIG_DATA_SIZE);
647close(fd);
648
649// build xml dictionary
650ParseXMLFile(config->plist, &config->dictionary);
651return 0;
652}
653
654/* loadSystemConfig
655 *
656 * Returns 0 - successful.
657 * -1 - unsuccesful.
658 */
659int loadSystemConfig(config_file_t *config)
660{
661// Micky1979, the order is important
662char *dirspec[] = {
663"/com.apple.recovery.boot/com.apple.Boot.plist",// OS X Recovery
664"/OS X Install Data/com.apple.Boot.plist",// OS X Upgrade (10.8+)
665"/Mac OS X Install Data/com.apple.Boot.plist",// OS X Upgrade (Lion 10.7)
666"/.IABootFiles/com.apple.Boot.plist",// OS X Installer
667"/Library/Preferences/SystemConfiguration/com.apple.Boot.plist"// (Installed System or Installer)
668};
669
670int i, fd, count, ret=-1;
671
672for(i = 0; i< sizeof(dirspec)/sizeof(dirspec[0]); i++)
673{
674if ((fd = open(dirspec[i], 0)) >= 0)
675{
676// read file
677count = read(fd, config->plist, IO_CONFIG_DATA_SIZE);
678close(fd);
679
680// build xml dictionary
681ParseXMLFile(config->plist, &config->dictionary);
682sysConfigValid = true;
683ret=0;
684
685break;
686}
687}
688
689if(ret == -1) ret = loadHelperConfig(config);
690
691// Always enable canOverride flag (for SystemConfig)
692config->canOverride = true;
693
694return ret;
695}
696
697/* loadChameleonConfig
698 *
699 * Returns 0 - successful.
700 * -1 - unsuccesful.
701 */
702int loadChameleonConfig(config_file_t *config, BVRef chain)
703{
704char *dirspec[] = {
705"/Extra/org.chameleon.Boot.plist",
706"/Extra/com.apple.Boot.plist", /* DEPRECATED */
707};
708
709int i;
710
711for(i = 0; i< sizeof(dirspec)/sizeof(dirspec[0]); i++)
712{
713if ( loadChameleonConfigForDevice(config, "rd(0,0)", dirspec[i]) == 0 )
714{
715return 0;
716}
717
718if ( loadChameleonConfigForDevice(config, "", dirspec[i]) == 0 )
719{
720return 0;
721}
722
723if ( loadChameleonConfigForDevice(config, "bt(0,0)", dirspec[i]) == 0 )
724{
725return 0;
726}
727BVRef bvr;
728for ( bvr = chain; bvr; bvr = bvr->next ) /* C99 Error */
729{
730char device[256];
731getDeviceDescription(bvr, device);
732
733if ( loadChameleonConfigForDevice(config, device, dirspec[i]) == 0 )
734{
735return 0;
736}
737}
738}
739return -1;
740}
741
742/* loadChameleonConfigForDevice
743 *
744 * Returns 0 - successful.
745 * -1 - unsuccesful.
746 */
747int loadChameleonConfigForDevice(config_file_t *config, const char *device, const char *path)
748{
749char full_path[1024];
750int fd;
751
752snprintf(full_path, sizeof(full_path), "%s%s", device, path);
753
754if ((fd = open(full_path, 0)) >= 0)
755{
756// Check for depreciated file names and annoy the user about it.
757if(strstr(full_path, "com.apple.Boot.plist")) {
758printf("%s is deprecated.\n", full_path);
759full_path[strlen(full_path) - strlen("com.apple.Boot.plist")] = 0;
760printf("Please use the file %sorg.chameleon.Boot.plist instead.\n", full_path);
761pause();
762}
763// read file
764read(fd, config->plist, IO_CONFIG_DATA_SIZE);
765close(fd);
766
767// build xml dictionary
768ParseXMLFile(config->plist, &config->dictionary);
769sysConfigValid = true;
770return 0;
771}
772return -1;
773}
774
775/* loadHelperConfig
776 *
777 * Returns 0 - successful.
778 * -1 - unsuccesful.
779 */
780int loadHelperConfig(config_file_t *config)
781{
782int rfd, pfd, sfd, count, ret=-1, fixedsize;
783
784char *dirspec[] = {
785"/com.apple.boot.P/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
786"/com.apple.boot.R/Library/Preferences/SystemConfiguration/com.apple.Boot.plist",
787"/com.apple.boot.S/Library/Preferences/SystemConfiguration/com.apple.Boot.plist"
788};
789
790// This is a simple rock - paper scissors algo. R beats S, P beats R, S beats P
791// If all three, S is used for now. This should be changed to something else (say, timestamp?)
792
793pfd = open(dirspec[0], 0);
794if(pfd >= 0)// com.apple.boot.P exists
795{
796
797sfd = open(dirspec[2], 0); // com.apple.boot.S takes precidence if it also exists
798if(sfd >= 0)
799{
800// Use sfd
801fixedsize = MIN(file_size(sfd), IO_CONFIG_DATA_SIZE);
802count = read(sfd, config->plist, fixedsize);
803close(sfd);
804close(pfd);
805if (count != fixedsize) return -1;
806
807// build xml dictionary
808ParseXMLFile(config->plist, &config->dictionary);
809sysConfigValid = true;
810ret=0;
811
812}
813else
814{
815// used pfd
816fixedsize = MIN(file_size(pfd), IO_CONFIG_DATA_SIZE);
817count = read(pfd, config->plist, fixedsize);
818close(pfd);
819if (count != fixedsize) return -1;
820
821// build xml dictionary
822ParseXMLFile(config->plist, &config->dictionary);
823sysConfigValid = true;
824ret = 0;
825}
826
827}
828else
829{
830rfd = open(dirspec[1], 0); // com.apple.boot.R exists
831if(rfd >= 0)
832{
833pfd = open(dirspec[2], 0); // com.apple.boot.P takes recidence if it exists
834if(pfd >= 0)
835{
836// use sfd
837fixedsize = MIN(file_size(pfd), IO_CONFIG_DATA_SIZE);
838count = read(pfd, config->plist, fixedsize);
839close(pfd);
840close(rfd);
841if (count != fixedsize) return -1;
842
843// build xml dictionary
844ParseXMLFile(config->plist, &config->dictionary);
845sysConfigValid = true;
846ret = 0;
847
848}
849else
850{
851// use rfd
852fixedsize = MIN(file_size(rfd), IO_CONFIG_DATA_SIZE);
853count = read(rfd, config->plist, fixedsize);
854close(rfd);
855if (count != fixedsize) return -1;
856
857// build xml dictionary
858ParseXMLFile(config->plist, &config->dictionary);
859sysConfigValid = true;
860ret = 0;
861
862}
863
864}
865else
866{
867sfd = open(dirspec[2], 0); // com.apple.boot.S exists, but nothing else does
868if(sfd >= 0)
869{
870// use sfd
871fixedsize = MIN(file_size(sfd), IO_CONFIG_DATA_SIZE);
872count = read(sfd, config->plist, fixedsize);
873close(sfd);
874if (count != fixedsize) return -1;
875
876// build xml dictionary
877ParseXMLFile(config->plist, &config->dictionary);
878sysConfigValid = true;
879ret = 0;
880
881}
882}
883
884}
885
886return ret;
887}
888
889char *newString(const char *oldString)
890{
891if ( oldString )
892{
893return strcpy(malloc(strlen(oldString)+1), oldString);
894}
895else
896{
897return NULL;
898}
899}
900
901/*
902 * Extracts the next argument from the command line, double quotes are allowed here.
903 */
904char *getNextArg(char **argPtr, char *val)
905{
906char * ptr = *argPtr;
907const char * strStart;
908int len = 0;
909bool isQuoted = false;
910
911*val = '\0';
912
913// Scan for the next non-whitespace character.
914while ( *ptr && (*ptr == ' ' || *ptr == '=') )
915{
916ptr++;
917}
918
919strStart = ptr;
920
921// Skip the leading double quote character.
922if (*ptr == '\"')
923{
924isQuoted = true;
925ptr++;
926strStart++;
927}
928
929// Scan for the argument terminator character.
930// This can be either a NULL character - in case we reach the end of the string,
931// a double quote in case of quoted argument,
932// or a whitespace character (' ' or '=') for non-quoted argument.
933while (*ptr && !( (isQuoted && (*ptr == '\"')) ||
934 (!isQuoted && (*ptr == ' ' || *ptr == '=')) )
935 ) {
936ptr++;
937}
938
939len = ptr - strStart;
940
941// Skip the closing double quote character and adjust
942// the starting pointer for the next getNextArg call.
943if (*ptr && isQuoted && *ptr == '\"') {
944ptr++;
945}
946
947// Copy the extracted argument to val.
948strncat(val, strStart, len);
949
950// Set command line pointer.
951*argPtr = ptr;
952
953return ptr;
954}
955

Archive Download this file

Revision: 2849