The Tor Browser / file comparison

comparison: security/nss/cmd/modutil/install-ds.c

security/nss/cmd/modutil/install-ds.c

branch
TOR_BUG_9701
changeset 9
a63d609f5ebe
equal deleted inserted replaced
-1:000000000000 0:9404ae4b433d
1 /* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5 #include "install-ds.h"
6 #include <prmem.h>
7 #include <plstr.h>
8 #include <prprf.h>
9 #include <string.h>
10
11 #define PORT_Strcasecmp PL_strcasecmp
12
13 #define MODULE_FILE_STRING "ModuleFile"
14 #define MODULE_NAME_STRING "ModuleName"
15 #define MECH_FLAGS_STRING "DefaultMechanismFlags"
16 #define CIPHER_FLAGS_STRING "DefaultCipherFlags"
17 #define FILES_STRING "Files"
18 #define FORWARD_COMPATIBLE_STRING "ForwardCompatible"
19 #define PLATFORMS_STRING "Platforms"
20 #define RELATIVE_DIR_STRING "RelativePath"
21 #define ABSOLUTE_DIR_STRING "AbsolutePath"
22 #define FILE_PERMISSIONS_STRING "FilePermissions"
23 #define EQUIVALENT_PLATFORM_STRING "EquivalentPlatform"
24 #define EXECUTABLE_STRING "Executable"
25
26 #define DEFAULT_PERMISSIONS 0777
27
28 #define PLATFORM_SEPARATOR_CHAR ':'
29
30 /* Error codes */
31 enum {
32 BOGUS_RELATIVE_DIR=0,
33 BOGUS_ABSOLUTE_DIR,
34 BOGUS_FILE_PERMISSIONS,
35 NO_RELATIVE_DIR,
36 NO_ABSOLUTE_DIR,
37 EMPTY_PLATFORM_STRING,
38 BOGUS_PLATFORM_STRING,
39 REPEAT_MODULE_FILE,
40 REPEAT_MODULE_NAME,
41 BOGUS_MODULE_FILE,
42 BOGUS_MODULE_NAME,
43 REPEAT_MECH,
44 BOGUS_MECH_FLAGS,
45 REPEAT_CIPHER,
46 BOGUS_CIPHER_FLAGS,
47 REPEAT_FILES,
48 REPEAT_EQUIV,
49 BOGUS_EQUIV,
50 EQUIV_TOO_MUCH_INFO,
51 NO_FILES,
52 NO_MODULE_FILE,
53 NO_MODULE_NAME,
54 NO_PLATFORMS,
55 EQUIV_LOOP,
56 UNKNOWN_MODULE_FILE
57 };
58
59 /* Indexed by the above error codes */
60 static const char *errString[] = {
61 "%s: Invalid relative directory",
62 "%s: Invalid absolute directory",
63 "%s: Invalid file permissions",
64 "%s: No relative directory specified",
65 "%s: No absolute directory specified",
66 "Empty string given for platform name",
67 "%s: invalid platform string",
68 "More than one ModuleFile entry given for platform %s",
69 "More than one ModuleName entry given for platform %s",
70 "Invalid ModuleFile specification for platform %s",
71 "Invalid ModuleName specification for platform %s",
72 "More than one DefaultMechanismFlags entry given for platform %s",
73 "Invalid DefaultMechanismFlags specification for platform %s",
74 "More than one DefaultCipherFlags entry given for platform %s",
75 "Invalid DefaultCipherFlags entry given for platform %s",
76 "More than one Files entry given for platform %s",
77 "More than one EquivalentPlatform entry given for platform %s",
78 "Invalid EquivalentPlatform specification for platform %s",
79 "Module %s uses an EquivalentPlatform but also specifies its own"
80 " information",
81 "No Files specification in module %s",
82 "No ModuleFile specification in module %s",
83 "No ModuleName specification in module %s",
84 "No Platforms specification in installer script",
85 "Platform %s has an equivalency loop",
86 "Module file \"%s\" in platform \"%s\" does not exist"
87 };
88
89 static char* PR_Strdup(const char* str);
90
91 #define PAD(x) {int i; for(i=0;i<x;i++) printf(" ");}
92 #define PADINC 4
93
94 Pk11Install_File*
95 Pk11Install_File_new()
96 {
97 Pk11Install_File* new_this;
98 new_this = (Pk11Install_File*)PR_Malloc(sizeof(Pk11Install_File));
99 Pk11Install_File_init(new_this);
100 return new_this;
101 }
102
103 void
104 Pk11Install_File_init(Pk11Install_File* _this)
105 {
106 _this->jarPath=NULL;
107 _this->relativePath=NULL;
108 _this->absolutePath=NULL;
109 _this->executable=PR_FALSE;
110 _this->permissions=0;
111 }
112
113 /*
114 //////////////////////////////////////////////////////////////////////////
115 // Method: ~Pk11Install_File
116 // Class: Pk11Install_File
117 // Notes: Destructor.
118 */
119 void
120 Pk11Install_File_delete(Pk11Install_File* _this)
121 {
122 Pk11Install_File_Cleanup(_this);
123 }
124
125 /*
126 //////////////////////////////////////////////////////////////////////////
127 // Method: Cleanup
128 // Class: Pk11Install_File
129 */
130 void
131 Pk11Install_File_Cleanup(Pk11Install_File* _this)
132 {
133 if(_this->jarPath) {
134 PR_Free(_this->jarPath);
135 _this->jarPath = NULL;
136 }
137 if(_this->relativePath) {
138 PR_Free(_this->relativePath);
139 _this->relativePath = NULL;
140 }
141 if(_this->absolutePath) {
142 PR_Free(_this->absolutePath);
143 _this->absolutePath = NULL;
144 }
145
146 _this->permissions = 0;
147 _this->executable = PR_FALSE;
148 }
149
150 /*
151 //////////////////////////////////////////////////////////////////////////
152 // Method: Generate
153 // Class: Pk11Install_File
154 // Notes: Creates a file data structure from a syntax tree.
155 // Returns: NULL for success, otherwise an error message.
156 */
157 char*
158 Pk11Install_File_Generate(Pk11Install_File* _this,
159 const Pk11Install_Pair *pair)
160 {
161 Pk11Install_ListIter *iter;
162 Pk11Install_Value *val;
163 Pk11Install_Pair *subpair;
164 Pk11Install_ListIter *subiter;
165 Pk11Install_Value *subval;
166 char* errStr;
167 char *endp;
168 PRBool gotPerms;
169
170 iter=NULL;
171 subiter=NULL;
172 errStr=NULL;
173 gotPerms=PR_FALSE;
174
175 /* Clear out old values */
176 Pk11Install_File_Cleanup(_this);
177
178 _this->jarPath = PR_Strdup(pair->key);
179
180 /* Go through all the pairs under this file heading */
181 iter = Pk11Install_ListIter_new(pair->list);
182 for( ; (val = iter->current); Pk11Install_ListIter_nextItem(iter)) {
183 if(val->type == PAIR_VALUE) {
184 subpair = val->pair;
185
186 /* Relative directory */
187 if(!PORT_Strcasecmp(subpair->key, RELATIVE_DIR_STRING)) {
188 subiter = Pk11Install_ListIter_new(subpair->list);
189 subval = subiter->current;
190 if(!subval || (subval->type != STRING_VALUE)){
191 errStr = PR_smprintf(errString[BOGUS_RELATIVE_DIR],
192 _this->jarPath);
193 goto loser;
194 }
195 _this->relativePath = PR_Strdup(subval->string);
196 Pk11Install_ListIter_delete(subiter);
197 subiter = NULL;
198
199 /* Absolute directory */
200 } else if( !PORT_Strcasecmp(subpair->key, ABSOLUTE_DIR_STRING)) {
201 subiter = Pk11Install_ListIter_new(subpair->list);
202 subval = subiter->current;
203 if(!subval || (subval->type != STRING_VALUE)){
204 errStr = PR_smprintf(errString[BOGUS_ABSOLUTE_DIR],
205 _this->jarPath);
206 goto loser;
207 }
208 _this->absolutePath = PR_Strdup(subval->string);
209 Pk11Install_ListIter_delete(subiter);
210 subiter = NULL;
211
212 /* file permissions */
213 } else if( !PORT_Strcasecmp(subpair->key,
214 FILE_PERMISSIONS_STRING)) {
215 subiter = Pk11Install_ListIter_new(subpair->list);
216 subval = subiter->current;
217 if(!subval || (subval->type != STRING_VALUE) ||
218 !subval->string || !subval->string[0]){
219 errStr = PR_smprintf(errString[BOGUS_FILE_PERMISSIONS],
220 _this->jarPath);
221 goto loser;
222 }
223 _this->permissions = (int) strtol(subval->string, &endp, 8);
224 if(*endp != '\0') {
225 errStr = PR_smprintf(errString[BOGUS_FILE_PERMISSIONS],
226 _this->jarPath);
227 goto loser;
228 }
229 gotPerms = PR_TRUE;
230 Pk11Install_ListIter_delete(subiter);
231 subiter = NULL;
232 }
233 } else {
234 if(!PORT_Strcasecmp(val->string, EXECUTABLE_STRING)) {
235 _this->executable = PR_TRUE;
236 }
237 }
238 }
239
240 /* Default permission value */
241 if(!gotPerms) {
242 _this->permissions = DEFAULT_PERMISSIONS;
243 }
244
245 /* Make sure we got all the information */
246 if(!_this->relativePath && !_this->absolutePath) {
247 errStr = PR_smprintf(errString[NO_ABSOLUTE_DIR], _this->jarPath);
248 goto loser;
249 }
250 #if 0
251 if(!_this->relativePath ) {
252 errStr = PR_smprintf(errString[NO_RELATIVE_DIR], _this->jarPath);
253 goto loser;
254 }
255 if(!_this->absolutePath) {
256 errStr = PR_smprintf(errString[NO_ABSOLUTE_DIR], _this->jarPath);
257 goto loser;
258 }
259 #endif
260
261 loser:
262 if(iter) {
263 Pk11Install_ListIter_delete(iter);
264 PR_Free(iter);
265 }
266 if(subiter) {
267 Pk11Install_ListIter_delete(subiter);
268 PR_Free(subiter);
269 }
270 return errStr;
271 }
272
273 /*
274 //////////////////////////////////////////////////////////////////////////
275 // Method: Print
276 // Class: Pk11Install_File
277 */
278 void
279 Pk11Install_File_Print(Pk11Install_File* _this, int pad)
280 {
281 PAD(pad); printf("jarPath: %s\n",
282 _this->jarPath ? _this->jarPath : "<NULL>");
283 PAD(pad); printf("relativePath: %s\n",
284 _this->relativePath ? _this->relativePath: "<NULL>");
285 PAD(pad); printf("absolutePath: %s\n",
286 _this->absolutePath ? _this->absolutePath: "<NULL>");
287 PAD(pad); printf("permissions: %o\n", _this->permissions);
288 }
289
290 Pk11Install_PlatformName*
291 Pk11Install_PlatformName_new()
292 {
293 Pk11Install_PlatformName* new_this;
294 new_this = (Pk11Install_PlatformName*)
295 PR_Malloc(sizeof(Pk11Install_PlatformName));
296 Pk11Install_PlatformName_init(new_this);
297 return new_this;
298 }
299
300 void
301 Pk11Install_PlatformName_init(Pk11Install_PlatformName* _this)
302 {
303 _this->OS = NULL;
304 _this->verString = NULL;
305 _this->numDigits = 0;
306 _this->arch = NULL;
307 }
308
309 /*
310 //////////////////////////////////////////////////////////////////////////
311 // Method: ~Pk11Install_PlatformName
312 // Class: Pk11Install_PlatformName
313 */
314 void
315 Pk11Install_PlatformName_delete(Pk11Install_PlatformName* _this)
316 {
317 Pk11Install_PlatformName_Cleanup(_this);
318 }
319
320 /*
321 //////////////////////////////////////////////////////////////////////////
322 // Method: Cleanup
323 // Class: Pk11Install_PlatformName
324 */
325 void
326 Pk11Install_PlatformName_Cleanup(Pk11Install_PlatformName* _this)
327 {
328 if(_this->OS) {
329 PR_Free(_this->OS);
330 _this->OS = NULL;
331 }
332 if(_this->verString) {
333 int i;
334 for (i=0; i<_this->numDigits; i++) {
335 PR_Free(_this->verString[i]);
336 }
337 PR_Free(_this->verString);
338 _this->verString = NULL;
339 }
340 if(_this->arch) {
341 PR_Free(_this->arch);
342 _this->arch = NULL;
343 }
344 _this->numDigits = 0;
345 }
346
347 /*
348 //////////////////////////////////////////////////////////////////////////
349 // Method: Generate
350 // Class: Pk11Install_PlatformName
351 // Notes: Extracts the information from a platform string.
352 */
353 char*
354 Pk11Install_PlatformName_Generate(Pk11Install_PlatformName* _this,
355 const char *str)
356 {
357 char *errStr;
358 char *copy;
359 char *end, *start; /* start and end of a section (OS, version, arch)*/
360 char *pend, *pstart; /* start and end of one portion of version*/
361 char *endp; /* used by strtol*/
362 int periods, i;
363
364 errStr=NULL;
365 copy=NULL;
366
367 if(!str) {
368 errStr = PR_smprintf(errString[EMPTY_PLATFORM_STRING]);
369 goto loser;
370 }
371 copy = PR_Strdup(str);
372
373 /*
374 // Get the OS
375 */
376 end = strchr(copy, PLATFORM_SEPARATOR_CHAR);
377 if(!end || end==copy) {
378 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
379 goto loser;
380 }
381 *end = '\0';
382
383 _this->OS = PR_Strdup(copy);
384
385 /*
386 // Get the digits of the version of form: x.x.x (arbitrary number of digits)
387 */
388
389 start = end+1;
390 end = strchr(start, PLATFORM_SEPARATOR_CHAR);
391 if(!end) {
392 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
393 goto loser;
394 }
395 *end = '\0';
396
397 if(end!=start) {
398 /* Find out how many periods*/
399 periods = 0;
400 pstart = start;
401 while( (pend=strchr(pstart, '.')) ) {
402 periods++;
403 pstart = pend+1;
404 }
405 _this->numDigits= 1+ periods;
406 _this->verString = (char**)PR_Malloc(sizeof(char*)*_this->numDigits);
407
408 pstart = start;
409 i = 0;
410 /* Get the digits before each period*/
411 while( (pend=strchr(pstart, '.')) ) {
412 if(pend == pstart) {
413 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
414 goto loser;
415 }
416 *pend = '\0';
417 _this->verString[i] = PR_Strdup(pstart);
418 endp = pend;
419 if(endp==pstart || (*endp != '\0')) {
420 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
421 goto loser;
422 }
423 pstart = pend+1;
424 i++;
425 }
426 /* Last digit comes after the last period*/
427 if(*pstart == '\0') {
428 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
429 goto loser;
430 }
431 _this->verString[i] = PR_Strdup(pstart);
432 /*
433 if(endp==pstart || (*endp != '\0')) {
434 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
435 goto loser;
436 }
437 */
438 } else {
439 _this->verString = NULL;
440 _this->numDigits = 0;
441 }
442
443 /*
444 // Get the architecture
445 */
446 start = end+1;
447 if( strchr(start, PLATFORM_SEPARATOR_CHAR) ) {
448 errStr = PR_smprintf(errString[BOGUS_PLATFORM_STRING], str);
449 goto loser;
450 }
451 _this->arch = PR_Strdup(start);
452
453 if(copy) {
454 PR_Free(copy);
455 }
456 return NULL;
457 loser:
458 if(_this->OS) {
459 PR_Free(_this->OS);
460 _this->OS = NULL;
461 }
462 if(_this->verString) {
463 for (i=0; i<_this->numDigits; i++) {
464 PR_Free(_this->verString[i]);
465 }
466 PR_Free(_this->verString);
467 _this->verString = NULL;
468 }
469 _this->numDigits = 0;
470 if(_this->arch) {
471 PR_Free(_this->arch);
472 _this->arch = NULL;
473 }
474
475 return errStr;
476 }
477
478 /*
479 //////////////////////////////////////////////////////////////////////////
480 // Method: operator ==
481 // Class: Pk11Install_PlatformName
482 // Returns: PR_TRUE if the platform have the same OS, arch, and version
483 */
484 PRBool
485 Pk11Install_PlatformName_equal(Pk11Install_PlatformName* _this,
486 Pk11Install_PlatformName* cmp)
487 {
488 int i;
489
490 if(!_this->OS || !_this->arch || !cmp->OS || !cmp->arch) {
491 return PR_FALSE;
492 }
493
494 if( PORT_Strcasecmp(_this->OS, cmp->OS) ||
495 PORT_Strcasecmp(_this->arch, cmp->arch) ||
496 _this->numDigits != cmp->numDigits ) {
497 return PR_FALSE;
498 }
499
500 for(i=0; i < _this->numDigits; i++) {
501 if(PORT_Strcasecmp(_this->verString[i], cmp->verString[i])) {
502 return PR_FALSE;
503 }
504 }
505 return PR_TRUE;
506 }
507
508 /*
509 //////////////////////////////////////////////////////////////////////////
510 // Method: operator <=
511 // Class: Pk11Install_PlatformName
512 // Returns: PR_TRUE if the platform have the same OS and arch and a lower
513 // or equal release.
514 */
515 PRBool
516 Pk11Install_PlatformName_lteq(Pk11Install_PlatformName* _this,
517 Pk11Install_PlatformName* cmp)
518 {
519 return (Pk11Install_PlatformName_equal(_this,cmp) ||
520 Pk11Install_PlatformName_lt(_this,cmp)) ? PR_TRUE : PR_FALSE;
521 }
522
523 /*
524 //////////////////////////////////////////////////////////////////////////
525 // Method: operator <
526 // Class: Pk11Install_PlatformName
527 // Returns: PR_TRUE if the platform have the same OS and arch and a greater
528 // release.
529 */
530 PRBool
531 Pk11Install_PlatformName_lt(Pk11Install_PlatformName* _this,
532 Pk11Install_PlatformName* cmp)
533 {
534 int i, scmp;
535
536 if(!_this->OS || !_this->arch || !cmp->OS || !cmp->arch) {
537 return PR_FALSE;
538 }
539
540 if( PORT_Strcasecmp(_this->OS, cmp->OS) ) {
541 return PR_FALSE;
542 }
543 if( PORT_Strcasecmp(_this->arch, cmp->arch) ) {
544 return PR_FALSE;
545 }
546
547 for(i=0; (i < _this->numDigits) && (i < cmp->numDigits); i++) {
548 scmp = PORT_Strcasecmp(_this->verString[i], cmp->verString[i]);
549 if (scmp > 0) {
550 return PR_FALSE;
551 } else if (scmp < 0) {
552 return PR_TRUE;
553 }
554 }
555 /* All the digits they have in common are the same. */
556 if(_this->numDigits < cmp->numDigits) {
557 return PR_TRUE;
558 }
559
560 return PR_FALSE;
561 }
562
563 /*
564 //////////////////////////////////////////////////////////////////////////
565 // Method: GetString
566 // Class: Pk11Install_PlatformName
567 // Returns: String composed of OS, release, and architecture separated
568 // by the separator char. Memory is allocated by this function
569 // but is the responsibility of the caller to de-allocate.
570 */
571 char*
572 Pk11Install_PlatformName_GetString(Pk11Install_PlatformName* _this)
573 {
574 char *ret;
575 char *ver;
576 char *OS_;
577 char *arch_;
578
579 OS_=NULL;
580 arch_=NULL;
581
582 OS_ = _this->OS ? _this->OS : "";
583 arch_ = _this->arch ? _this->arch : "";
584
585 ver = Pk11Install_PlatformName_GetVerString(_this);
586 ret = PR_smprintf("%s%c%s%c%s", OS_, PLATFORM_SEPARATOR_CHAR, ver,
587 PLATFORM_SEPARATOR_CHAR, arch_);
588
589 PR_Free(ver);
590
591 return ret;
592 }
593
594 /*
595 //////////////////////////////////////////////////////////////////////////
596 // Method: GetVerString
597 // Class: Pk11Install_PlatformName
598 // Returns: The version string for this platform, in the form x.x.x with an
599 // arbitrary number of digits. Memory allocated by function,
600 // must be de-allocated by caller.
601 */
602 char*
603 Pk11Install_PlatformName_GetVerString(Pk11Install_PlatformName* _this)
604 {
605 char *tmp;
606 char *ret;
607 int i;
608 char buf[80];
609
610 tmp = (char*)PR_Malloc(80*_this->numDigits+1);
611 tmp[0] = '\0';
612
613 for(i=0; i < _this->numDigits-1; i++) {
614 sprintf(buf, "%s.", _this->verString[i]);
615 strcat(tmp, buf);
616 }
617 if(i < _this->numDigits) {
618 sprintf(buf, "%s", _this->verString[i]);
619 strcat(tmp, buf);
620 }
621
622 ret = PR_Strdup(tmp);
623 free(tmp);
624
625 return ret;
626 }
627
628 /*
629 //////////////////////////////////////////////////////////////////////////
630 // Method: Print
631 // Class: Pk11Install_PlatformName
632 */
633 void
634 Pk11Install_PlatformName_Print(Pk11Install_PlatformName* _this, int pad)
635 {
636 PAD(pad); printf("OS: %s\n", _this->OS ? _this->OS : "<NULL>");
637 PAD(pad); printf("Digits: ");
638 if(_this->numDigits == 0) {
639 printf("None\n");
640 } else {
641 printf("%s\n", Pk11Install_PlatformName_GetVerString(_this));
642 }
643 PAD(pad); printf("arch: %s\n", _this->arch ? _this->arch : "<NULL>");
644 }
645
646 Pk11Install_Platform*
647 Pk11Install_Platform_new()
648 {
649 Pk11Install_Platform* new_this;
650 new_this = (Pk11Install_Platform*)PR_Malloc(sizeof(Pk11Install_Platform));
651 Pk11Install_Platform_init(new_this);
652 return new_this;
653 }
654
655 void
656 Pk11Install_Platform_init(Pk11Install_Platform* _this)
657 {
658 Pk11Install_PlatformName_init(&_this->name);
659 Pk11Install_PlatformName_init(&_this->equivName);
660 _this->equiv = NULL;
661 _this->usesEquiv = PR_FALSE;
662 _this->moduleFile = NULL;
663 _this->moduleName = NULL;
664 _this->modFile = -1;
665 _this->mechFlags = 0;
666 _this->cipherFlags = 0;
667 _this->files = NULL;
668 _this->numFiles = 0;
669 }
670
671 /*
672 //////////////////////////////////////////////////////////////////////////
673 // Method: ~Pk11Install_Platform
674 // Class: Pk11Install_Platform
675 */
676 void
677 Pk11Install_Platform_delete(Pk11Install_Platform* _this)
678 {
679 Pk11Install_Platform_Cleanup(_this);
680 }
681
682 /*
683 //////////////////////////////////////////////////////////////////////////
684 // Method: Cleanup
685 // Class: Pk11Install_Platform
686 */
687 void
688 Pk11Install_Platform_Cleanup(Pk11Install_Platform* _this)
689 {
690 int i;
691 if(_this->moduleFile) {
692 PR_Free(_this->moduleFile);
693 _this->moduleFile = NULL;
694 }
695 if(_this->moduleName) {
696 PR_Free(_this->moduleName);
697 _this->moduleName = NULL;
698 }
699 if(_this->files) {
700 for (i=0;i<_this->numFiles;i++) {
701 Pk11Install_File_delete(&_this->files[i]);
702 }
703 PR_Free(_this->files);
704 _this->files = NULL;
705 }
706 _this->equiv = NULL;
707 _this->usesEquiv = PR_FALSE;
708 _this->modFile = -1;
709 _this->numFiles = 0;
710 _this->mechFlags = _this->cipherFlags = 0;
711 }
712
713 /*
714 //////////////////////////////////////////////////////////////////////////
715 // Method: Generate
716 // Class: Pk11Install_Platform
717 // Notes: Creates a platform data structure from a syntax tree.
718 // Returns: NULL for success, otherwise an error message.
719 */
720 char*
721 Pk11Install_Platform_Generate(Pk11Install_Platform* _this,
722 const Pk11Install_Pair *pair)
723 {
724 char* errStr;
725 char* endptr;
726 char* tmp;
727 int i;
728 Pk11Install_ListIter *iter;
729 Pk11Install_Value *val;
730 Pk11Install_Value *subval;
731 Pk11Install_Pair *subpair;
732 Pk11Install_ListIter *subiter;
733 PRBool gotModuleFile, gotModuleName, gotMech,
734 gotCipher, gotFiles, gotEquiv;
735
736 errStr=NULL;
737 iter=subiter=NULL;
738 val=subval=NULL;
739 subpair=NULL;
740 gotModuleFile=gotModuleName=gotMech=gotCipher=gotFiles=gotEquiv=PR_FALSE;
741 Pk11Install_Platform_Cleanup(_this);
742
743 errStr = Pk11Install_PlatformName_Generate(&_this->name,pair->key);
744 if(errStr) {
745 tmp = PR_smprintf("%s: %s", pair->key, errStr);
746 PR_smprintf_free(errStr);
747 errStr = tmp;
748 goto loser;
749 }
750
751 iter = Pk11Install_ListIter_new(pair->list);
752 for( ; (val=iter->current); Pk11Install_ListIter_nextItem(iter)) {
753 if(val->type==PAIR_VALUE) {
754 subpair = val->pair;
755
756 if( !PORT_Strcasecmp(subpair->key, MODULE_FILE_STRING)) {
757 if(gotModuleFile) {
758 errStr = PR_smprintf(errString[REPEAT_MODULE_FILE],
759 Pk11Install_PlatformName_GetString(&_this->name));
760 goto loser;
761 }
762 subiter = Pk11Install_ListIter_new(subpair->list);
763 subval = subiter->current;
764 if(!subval || (subval->type != STRING_VALUE)) {
765 errStr = PR_smprintf(errString[BOGUS_MODULE_FILE],
766 Pk11Install_PlatformName_GetString(&_this->name));
767 goto loser;
768 }
769 _this->moduleFile = PR_Strdup(subval->string);
770 Pk11Install_ListIter_delete(subiter);
771 PR_Free(subiter);
772 subiter = NULL;
773 gotModuleFile = PR_TRUE;
774 } else if(!PORT_Strcasecmp(subpair->key, MODULE_NAME_STRING)){
775 if(gotModuleName) {
776 errStr = PR_smprintf(errString[REPEAT_MODULE_NAME],
777 Pk11Install_PlatformName_GetString(&_this->name));
778 goto loser;
779 }
780 subiter = Pk11Install_ListIter_new(subpair->list);
781 subval = subiter->current;
782 if(!subval || (subval->type != STRING_VALUE)) {
783 errStr = PR_smprintf(errString[BOGUS_MODULE_NAME],
784 Pk11Install_PlatformName_GetString(&_this->name));
785 goto loser;
786 }
787 _this->moduleName = PR_Strdup(subval->string);
788 Pk11Install_ListIter_delete(subiter);
789 PR_Free(subiter);
790 subiter = NULL;
791 gotModuleName = PR_TRUE;
792 } else if(!PORT_Strcasecmp(subpair->key, MECH_FLAGS_STRING)) {
793 endptr=NULL;
794
795 if(gotMech) {
796 errStr = PR_smprintf(errString[REPEAT_MECH],
797 Pk11Install_PlatformName_GetString(&_this->name));
798 goto loser;
799 }
800 subiter = Pk11Install_ListIter_new(subpair->list);
801 subval = subiter->current;
802 if(!subval || (subval->type != STRING_VALUE)) {
803 errStr = PR_smprintf(errString[BOGUS_MECH_FLAGS],
804 Pk11Install_PlatformName_GetString(&_this->name));
805 goto loser;
806 }
807 _this->mechFlags = strtol(subval->string, &endptr, 0);
808 if(*endptr!='\0' || (endptr==subval->string) ) {
809 errStr = PR_smprintf(errString[BOGUS_MECH_FLAGS],
810 Pk11Install_PlatformName_GetString(&_this->name));
811 goto loser;
812 }
813 Pk11Install_ListIter_delete(subiter);
814 PR_Free(subiter);
815 subiter=NULL;
816 gotMech = PR_TRUE;
817 } else if(!PORT_Strcasecmp(subpair->key,CIPHER_FLAGS_STRING)) {
818 endptr=NULL;
819
820 if(gotCipher) {
821 errStr = PR_smprintf(errString[REPEAT_CIPHER],
822 Pk11Install_PlatformName_GetString(&_this->name));
823 goto loser;
824 }
825 subiter = Pk11Install_ListIter_new(subpair->list);
826 subval = subiter->current;
827 if(!subval || (subval->type != STRING_VALUE)) {
828 errStr = PR_smprintf(errString[BOGUS_CIPHER_FLAGS],
829 Pk11Install_PlatformName_GetString(&_this->name));
830 goto loser;
831 }
832 _this->cipherFlags = strtol(subval->string, &endptr, 0);
833 if(*endptr!='\0' || (endptr==subval->string) ) {
834 errStr = PR_smprintf(errString[BOGUS_CIPHER_FLAGS],
835 Pk11Install_PlatformName_GetString(&_this->name));
836 goto loser;
837 }
838 Pk11Install_ListIter_delete(subiter);
839 PR_Free(subiter);
840 subiter=NULL;
841 gotCipher = PR_TRUE;
842 } else if(!PORT_Strcasecmp(subpair->key, FILES_STRING)) {
843 if(gotFiles) {
844 errStr = PR_smprintf(errString[REPEAT_FILES],
845 Pk11Install_PlatformName_GetString(&_this->name));
846 goto loser;
847 }
848 subiter = Pk11Install_ListIter_new(subpair->list);
849 _this->numFiles = subpair->list->numPairs;
850 _this->files = (Pk11Install_File*)
851 PR_Malloc(sizeof(Pk11Install_File)*_this->numFiles);
852 for(i=0; i < _this->numFiles; i++,
853 Pk11Install_ListIter_nextItem(subiter)) {
854 Pk11Install_File_init(&_this->files[i]);
855 val = subiter->current;
856 if(val && (val->type==PAIR_VALUE)) {
857 errStr = Pk11Install_File_Generate(&_this->files[i],val->pair);
858 if(errStr) {
859 tmp = PR_smprintf("%s: %s",
860 Pk11Install_PlatformName_GetString(&_this->name),errStr);
861 PR_smprintf_free(errStr);
862 errStr = tmp;
863 goto loser;
864 }
865 }
866 }
867 gotFiles = PR_TRUE;
868 } else if(!PORT_Strcasecmp(subpair->key,
869 EQUIVALENT_PLATFORM_STRING)) {
870 if(gotEquiv) {
871 errStr = PR_smprintf(errString[REPEAT_EQUIV],
872 Pk11Install_PlatformName_GetString(&_this->name));
873 goto loser;
874 }
875 subiter = Pk11Install_ListIter_new(subpair->list);
876 subval = subiter->current;
877 if(!subval || (subval->type != STRING_VALUE) ) {
878 errStr = PR_smprintf(errString[BOGUS_EQUIV],
879 Pk11Install_PlatformName_GetString(&_this->name));
880 goto loser;
881 }
882 errStr = Pk11Install_PlatformName_Generate(&_this->equivName,
883 subval->string);
884 if(errStr) {
885 tmp = PR_smprintf("%s: %s",
886 Pk11Install_PlatformName_GetString(&_this->name), errStr);
887 tmp = PR_smprintf("%s: %s",
888 Pk11Install_PlatformName_GetString(&_this->name), errStr);
889 PR_smprintf_free(errStr);
890 errStr = tmp;
891 goto loser;
892 }
893 _this->usesEquiv = PR_TRUE;
894 }
895 }
896 }
897
898 /* Make sure we either have an EquivalentPlatform or all the other info */
899 if(_this->usesEquiv &&
900 (gotFiles || gotModuleFile || gotModuleName || gotMech || gotCipher)) {
901 errStr = PR_smprintf(errString[EQUIV_TOO_MUCH_INFO],
902 Pk11Install_PlatformName_GetString(&_this->name));
903 goto loser;
904 }
905 if(!gotFiles && !_this->usesEquiv) {
906 errStr = PR_smprintf(errString[NO_FILES],
907 Pk11Install_PlatformName_GetString(&_this->name));
908 goto loser;
909 }
910 if(!gotModuleFile && !_this->usesEquiv) {
911 errStr= PR_smprintf(errString[NO_MODULE_FILE],
912 Pk11Install_PlatformName_GetString(&_this->name));
913 goto loser;
914 }
915 if(!gotModuleName && !_this->usesEquiv) {
916 errStr = PR_smprintf(errString[NO_MODULE_NAME],
917 Pk11Install_PlatformName_GetString(&_this->name));
918 goto loser;
919 }
920
921 /* Point the modFile pointer to the correct file */
922 if(gotModuleFile) {
923 for(i=0; i < _this->numFiles; i++) {
924 if(!PORT_Strcasecmp(_this->moduleFile, _this->files[i].jarPath) ) {
925 _this->modFile = i;
926 break;
927 }
928 }
929 if(_this->modFile==-1) {
930 errStr = PR_smprintf(errString[UNKNOWN_MODULE_FILE],
931 _this->moduleFile,
932 Pk11Install_PlatformName_GetString(&_this->name));
933 goto loser;
934 }
935 }
936
937 loser:
938 if(iter) {
939 PR_Free(iter);
940 }
941 if(subiter) {
942 PR_Free(subiter);
943 }
944 return errStr;
945 }
946
947 /*
948 //////////////////////////////////////////////////////////////////////////
949 // Method: Print
950 // Class: Pk11Install_Platform
951 */
952 void
953 Pk11Install_Platform_Print(Pk11Install_Platform* _this, int pad)
954 {
955 int i;
956
957 PAD(pad); printf("Name:\n");
958 Pk11Install_PlatformName_Print(&_this->name,pad+PADINC);
959 PAD(pad); printf("equivName:\n");
960 Pk11Install_PlatformName_Print(&_this->equivName,pad+PADINC);
961 PAD(pad);
962 if(_this->usesEquiv) {
963 printf("Uses equiv, which points to:\n");
964 Pk11Install_Platform_Print(_this->equiv,pad+PADINC);
965 } else {
966 printf("Doesn't use equiv\n");
967 }
968 PAD(pad);
969 printf("Module File: %s\n", _this->moduleFile ? _this->moduleFile
970 : "<NULL>");
971 PAD(pad); printf("mechFlags: %lx\n", _this->mechFlags);
972 PAD(pad); printf("cipherFlags: %lx\n", _this->cipherFlags);
973 PAD(pad); printf("Files:\n");
974 for(i=0; i < _this->numFiles; i++) {
975 Pk11Install_File_Print(&_this->files[i],pad+PADINC);
976 PAD(pad); printf("--------------------\n");
977 }
978 }
979
980 /*
981 //////////////////////////////////////////////////////////////////////////
982 // Method: Pk11Install_Info
983 // Class: Pk11Install_Info
984 */
985 Pk11Install_Info*
986 Pk11Install_Info_new()
987 {
988 Pk11Install_Info* new_this;
989 new_this = (Pk11Install_Info*)PR_Malloc(sizeof(Pk11Install_Info));
990 Pk11Install_Info_init(new_this);
991 return new_this;
992 }
993
994 void
995 Pk11Install_Info_init(Pk11Install_Info* _this)
996 {
997 _this->platforms = NULL;
998 _this->numPlatforms = 0;
999 _this->forwardCompatible = NULL;
1000 _this->numForwardCompatible = 0;
1001 }
1002
1003 /*
1004 //////////////////////////////////////////////////////////////////////////
1005 // Method: ~Pk11Install_Info
1006 // Class: Pk11Install_Info
1007 */
1008 void
1009 Pk11Install_Info_delete(Pk11Install_Info* _this)
1010 {
1011 Pk11Install_Info_Cleanup(_this);
1012 }
1013
1014 /*
1015 //////////////////////////////////////////////////////////////////////////
1016 // Method: Cleanup
1017 // Class: Pk11Install_Info
1018 */
1019 void
1020 Pk11Install_Info_Cleanup(Pk11Install_Info* _this)
1021 {
1022 int i;
1023 if(_this->platforms) {
1024 for (i=0;i<_this->numPlatforms;i++) {
1025 Pk11Install_Platform_delete(&_this->platforms[i]);
1026 }
1027 PR_Free(&_this->platforms);
1028 _this->platforms = NULL;
1029 _this->numPlatforms = 0;
1030 }
1031
1032 if(_this->forwardCompatible) {
1033 for (i=0;i<_this->numForwardCompatible;i++) {
1034 Pk11Install_PlatformName_delete(&_this->forwardCompatible[i]);
1035 }
1036 PR_Free(&_this->forwardCompatible);
1037 _this->numForwardCompatible = 0;
1038 }
1039 }
1040
1041 /*
1042 //////////////////////////////////////////////////////////////////////////
1043 // Method: Generate
1044 // Class: Pk11Install_Info
1045 // Takes: Pk11Install_ValueList *list, the top-level list
1046 // resulting from parsing an installer file.
1047 // Returns: char*, NULL if successful, otherwise an error string.
1048 // Caller is responsible for freeing memory.
1049 */
1050 char*
1051 Pk11Install_Info_Generate(Pk11Install_Info* _this,
1052 const Pk11Install_ValueList *list)
1053 {
1054 char *errStr;
1055 Pk11Install_ListIter *iter;
1056 Pk11Install_Value *val;
1057 Pk11Install_Pair *pair;
1058 Pk11Install_ListIter *subiter;
1059 Pk11Install_Value *subval;
1060 Pk11Install_Platform *first, *second;
1061 int i, j;
1062
1063 errStr=NULL;
1064 iter=subiter=NULL;
1065 Pk11Install_Info_Cleanup(_this);
1066
1067 iter = Pk11Install_ListIter_new(list);
1068 for( ; (val=iter->current); Pk11Install_ListIter_nextItem(iter)) {
1069 if(val->type == PAIR_VALUE) {
1070 pair = val->pair;
1071
1072 if(!PORT_Strcasecmp(pair->key, FORWARD_COMPATIBLE_STRING)) {
1073 subiter = Pk11Install_ListIter_new(pair->list);
1074 _this->numForwardCompatible = pair->list->numStrings;
1075 _this->forwardCompatible = (Pk11Install_PlatformName*)
1076 PR_Malloc(sizeof(Pk11Install_PlatformName)*
1077 _this->numForwardCompatible);
1078 for(i=0; i < _this->numForwardCompatible; i++,
1079 Pk11Install_ListIter_nextItem(subiter)) {
1080 subval = subiter->current;
1081 if(subval->type == STRING_VALUE) {
1082 errStr = Pk11Install_PlatformName_Generate(
1083 &_this->forwardCompatible[i], subval->string);
1084 if(errStr) {
1085 goto loser;
1086 }
1087 }
1088 }
1089 Pk11Install_ListIter_delete(subiter);
1090 PR_Free(subiter);
1091 subiter = NULL;
1092 } else if(!PORT_Strcasecmp(pair->key, PLATFORMS_STRING)) {
1093 subiter = Pk11Install_ListIter_new(pair->list);
1094 _this->numPlatforms = pair->list->numPairs;
1095 _this->platforms = (Pk11Install_Platform*)
1096 PR_Malloc(sizeof(Pk11Install_Platform)*
1097 _this->numPlatforms);
1098 for(i=0; i < _this->numPlatforms; i++,
1099 Pk11Install_ListIter_nextItem(subiter)) {
1100 Pk11Install_Platform_init(&_this->platforms[i]);
1101 subval = subiter->current;
1102 if(subval->type == PAIR_VALUE) {
1103 errStr = Pk11Install_Platform_Generate(&_this->platforms[i],subval->pair);
1104 if(errStr) {
1105 goto loser;
1106 }
1107 }
1108 }
1109 Pk11Install_ListIter_delete(subiter);
1110 PR_Free(subiter);
1111 subiter = NULL;
1112 }
1113 }
1114 }
1115
1116 if(_this->numPlatforms == 0) {
1117 errStr = PR_smprintf(errString[NO_PLATFORMS]);
1118 goto loser;
1119 }
1120
1121 /*
1122 //
1123 // Now process equivalent platforms
1124 //
1125
1126 // First the naive pass
1127 */
1128 for(i=0; i < _this->numPlatforms; i++) {
1129 if(_this->platforms[i].usesEquiv) {
1130 _this->platforms[i].equiv = NULL;
1131 for(j=0; j < _this->numPlatforms; j++) {
1132 if (Pk11Install_PlatformName_equal(&_this->platforms[i].equivName,
1133 &_this->platforms[j].name)) {
1134 if(i==j) {
1135 errStr = PR_smprintf(errString[EQUIV_LOOP],
1136 Pk11Install_PlatformName_GetString(&_this->platforms[i].name));
1137 goto loser;
1138 }
1139 _this->platforms[i].equiv = &_this->platforms[j];
1140 break;
1141 }
1142 }
1143 if(_this->platforms[i].equiv == NULL) {
1144 errStr = PR_smprintf(errString[BOGUS_EQUIV],
1145 Pk11Install_PlatformName_GetString(&_this->platforms[i].name));
1146 goto loser;
1147 }
1148 }
1149 }
1150
1151 /*
1152 // Now the intelligent pass, which will also detect loops.
1153 // We will send two pointers through the linked list of equivalent
1154 // platforms. Both start with the current node. "first" traverses
1155 // two nodes for each iteration. "second" lags behind, only traversing
1156 // one node per iteration. Eventually one of two things will happen:
1157 // first will hit the end of the list (a platform that doesn't use
1158 // an equivalency), or first will equal second if there is a loop.
1159 */
1160 for(i=0; i < _this->numPlatforms; i++) {
1161 if(_this->platforms[i].usesEquiv) {
1162 second = _this->platforms[i].equiv;
1163 if(!second->usesEquiv) {
1164 /* The first link is the terminal node */
1165 continue;
1166 }
1167 first = second->equiv;
1168 while(first->usesEquiv) {
1169 if(first == second) {
1170 errStr = PR_smprintf(errString[EQUIV_LOOP],
1171 Pk11Install_PlatformName_GetString(&_this->platforms[i].name));
1172 goto loser;
1173 }
1174 first = first->equiv;
1175 if(!first->usesEquiv) {
1176 break;
1177 }
1178 if(first == second) {
1179 errStr = PR_smprintf(errString[EQUIV_LOOP],
1180 Pk11Install_PlatformName_GetString(&_this->platforms[i].name));
1181 goto loser;
1182 }
1183 second = second->equiv;
1184 first = first->equiv;
1185 }
1186 _this->platforms[i].equiv = first;
1187 }
1188 }
1189
1190 loser:
1191 if(iter) {
1192 Pk11Install_ListIter_delete(iter);
1193 PR_Free(iter);
1194 iter = NULL;
1195 }
1196 if(subiter) {
1197 Pk11Install_ListIter_delete(subiter);
1198 PR_Free(subiter);
1199 subiter = NULL;
1200 }
1201 return errStr;
1202 }
1203
1204 /*
1205 //////////////////////////////////////////////////////////////////////////
1206 // Method: GetBestPlatform
1207 // Class: Pk11Install_Info
1208 // Takes: char *myPlatform, the platform we are currently running
1209 // on.
1210 */
1211 Pk11Install_Platform*
1212 Pk11Install_Info_GetBestPlatform(Pk11Install_Info* _this, char *myPlatform)
1213 {
1214 Pk11Install_PlatformName plat;
1215 char *errStr;
1216 int i, j;
1217
1218 errStr=NULL;
1219
1220 Pk11Install_PlatformName_init(&plat);
1221 if( (errStr=Pk11Install_PlatformName_Generate(&plat, myPlatform)) ) {
1222 PR_smprintf_free(errStr);
1223 return NULL;
1224 }
1225
1226 /* First try real platforms */
1227 for(i=0; i < _this->numPlatforms; i++) {
1228 if(Pk11Install_PlatformName_equal(&_this->platforms[i].name,&plat)) {
1229 if(_this->platforms[i].equiv) {
1230 return _this->platforms[i].equiv;
1231 }
1232 else {
1233 return &_this->platforms[i];
1234 }
1235 }
1236 }
1237
1238 /* Now try forward compatible platforms */
1239 for(i=0; i < _this->numForwardCompatible; i++) {
1240 if(Pk11Install_PlatformName_lteq(&_this->forwardCompatible[i],&plat)) {
1241 break;
1242 }
1243 }
1244 if(i == _this->numForwardCompatible) {
1245 return NULL;
1246 }
1247
1248 /* Got a forward compatible name, find the actual platform. */
1249 for(j=0; j < _this->numPlatforms; j++) {
1250 if(Pk11Install_PlatformName_equal(&_this->platforms[j].name,
1251 &_this->forwardCompatible[i])) {
1252 if(_this->platforms[j].equiv) {
1253 return _this->platforms[j].equiv;
1254 } else {
1255 return &_this->platforms[j];
1256 }
1257 }
1258 }
1259
1260 return NULL;
1261 }
1262
1263 /*
1264 //////////////////////////////////////////////////////////////////////////
1265 // Method: Print
1266 // Class: Pk11Install_Info
1267 */
1268 void
1269 Pk11Install_Info_Print(Pk11Install_Info* _this, int pad)
1270 {
1271 int i;
1272
1273 PAD(pad); printf("Forward Compatible:\n");
1274 for(i = 0; i < _this->numForwardCompatible; i++) {
1275 Pk11Install_PlatformName_Print(&_this->forwardCompatible[i],pad+PADINC);
1276 PAD(pad); printf("-------------------\n");
1277 }
1278 PAD(pad); printf("Platforms:\n");
1279 for( i = 0; i < _this->numPlatforms; i++) {
1280 Pk11Install_Platform_Print(&_this->platforms[i],pad+PADINC);
1281 PAD(pad); printf("-------------------\n");
1282 }
1283 }
1284
1285 /*
1286 //////////////////////////////////////////////////////////////////////////
1287 */
1288 static char*
1289 PR_Strdup(const char* str)
1290 {
1291 char *tmp;
1292 tmp = (char*) PR_Malloc((unsigned int)(strlen(str)+1));
1293 strcpy(tmp, str);
1294 return tmp;
1295 }
1296
1297 /* The global value list, the top of the tree */
1298 Pk11Install_ValueList* Pk11Install_valueList=NULL;
1299
1300 /****************************************************************************/
1301 void
1302 Pk11Install_ValueList_AddItem(Pk11Install_ValueList* _this,
1303 Pk11Install_Value *item)
1304 {
1305 _this->numItems++;
1306 if (item->type == STRING_VALUE) {
1307 _this->numStrings++;
1308 } else {
1309 _this->numPairs++;
1310 }
1311 item->next = _this->head;
1312 _this->head = item;
1313 }
1314
1315 /****************************************************************************/
1316 Pk11Install_ListIter*
1317 Pk11Install_ListIter_new_default()
1318 {
1319 Pk11Install_ListIter* new_this;
1320 new_this = (Pk11Install_ListIter*)
1321 PR_Malloc(sizeof(Pk11Install_ListIter));
1322 Pk11Install_ListIter_init(new_this);
1323 return new_this;
1324 }
1325
1326 /****************************************************************************/
1327 void
1328 Pk11Install_ListIter_init(Pk11Install_ListIter* _this)
1329 {
1330 _this->list = NULL;
1331 _this->current = NULL;
1332 }
1333
1334 /****************************************************************************/
1335 Pk11Install_ListIter*
1336 Pk11Install_ListIter_new(const Pk11Install_ValueList *_list)
1337 {
1338 Pk11Install_ListIter* new_this;
1339 new_this = (Pk11Install_ListIter*)
1340 PR_Malloc(sizeof(Pk11Install_ListIter));
1341 new_this->list = _list;
1342 new_this->current = _list->head;
1343 return new_this;
1344 }
1345
1346 /****************************************************************************/
1347 void
1348 Pk11Install_ListIter_delete(Pk11Install_ListIter* _this)
1349 {
1350 _this->list=NULL;
1351 _this->current=NULL;
1352 }
1353
1354 /****************************************************************************/
1355 void
1356 Pk11Install_ListIter_reset(Pk11Install_ListIter* _this)
1357 {
1358 if(_this->list) {
1359 _this->current = _this->list->head;
1360 }
1361 }
1362
1363 /*************************************************************************/
1364 Pk11Install_Value*
1365 Pk11Install_ListIter_nextItem(Pk11Install_ListIter* _this)
1366 {
1367 if(_this->current) {
1368 _this->current = _this->current->next;
1369 }
1370
1371 return _this->current;
1372 }
1373
1374 /****************************************************************************/
1375 Pk11Install_ValueList*
1376 Pk11Install_ValueList_new()
1377 {
1378 Pk11Install_ValueList* new_this;
1379 new_this = (Pk11Install_ValueList*)
1380 PR_Malloc(sizeof(Pk11Install_ValueList));
1381 new_this->numItems = 0;
1382 new_this->numPairs = 0;
1383 new_this->numStrings = 0;
1384 new_this->head = NULL;
1385 return new_this;
1386 }
1387
1388 /****************************************************************************/
1389 void
1390 Pk11Install_ValueList_delete(Pk11Install_ValueList* _this)
1391 {
1392
1393 Pk11Install_Value *tmp;
1394 Pk11Install_Value *list;
1395 list = _this->head;
1396
1397 while(list != NULL) {
1398 tmp = list;
1399 list = list->next;
1400 PR_Free(tmp);
1401 }
1402 PR_Free(_this);
1403 }
1404
1405 /****************************************************************************/
1406 Pk11Install_Value*
1407 Pk11Install_Value_new_default()
1408 {
1409 Pk11Install_Value* new_this;
1410 new_this = (Pk11Install_Value*)PR_Malloc(sizeof(Pk11Install_Value));
1411 new_this->type = STRING_VALUE;
1412 new_this->string = NULL;
1413 new_this->pair = NULL;
1414 new_this->next = NULL;
1415 return new_this;
1416 }
1417
1418 /****************************************************************************/
1419 Pk11Install_Value*
1420 Pk11Install_Value_new(ValueType _type, Pk11Install_Pointer ptr)
1421 {
1422 Pk11Install_Value* new_this;
1423 new_this = Pk11Install_Value_new_default();
1424 new_this->type = _type;
1425 if(_type == STRING_VALUE) {
1426 new_this->pair = NULL;
1427 new_this->string = ptr.string;
1428 } else {
1429 new_this->string = NULL;
1430 new_this->pair = ptr.pair;
1431 }
1432 return new_this;
1433 }
1434
1435 /****************************************************************************/
1436 void
1437 Pk11Install_Value_delete(Pk11Install_Value* _this)
1438 {
1439 if(_this->type == STRING_VALUE) {
1440 PR_Free(_this->string);
1441 } else {
1442 PR_Free(_this->pair);
1443 }
1444 }
1445
1446 /****************************************************************************/
1447 Pk11Install_Pair*
1448 Pk11Install_Pair_new_default()
1449 {
1450 return Pk11Install_Pair_new(NULL,NULL);
1451 }
1452
1453 /****************************************************************************/
1454 Pk11Install_Pair*
1455 Pk11Install_Pair_new(char *_key, Pk11Install_ValueList *_list)
1456 {
1457 Pk11Install_Pair* new_this;
1458 new_this = (Pk11Install_Pair*)PR_Malloc(sizeof(Pk11Install_Pair));
1459 new_this->key = _key;
1460 new_this->list = _list;
1461 return new_this;
1462 }
1463
1464 /****************************************************************************/
1465 void
1466 Pk11Install_Pair_delete(Pk11Install_Pair* _this)
1467 {
1468 PR_Free(_this->key);
1469 Pk11Install_ValueList_delete(_this->list);
1470 PR_Free(_this->list);
1471 }
1472
1473 /*************************************************************************/
1474 void
1475 Pk11Install_Pair_Print(Pk11Install_Pair* _this, int pad)
1476 {
1477 while (_this) {
1478 /*PAD(pad); printf("**Pair\n");
1479 PAD(pad); printf("***Key====\n");*/
1480 PAD(pad); printf("%s {\n", _this->key);
1481 /*PAD(pad); printf("====\n");*/
1482 /*PAD(pad); printf("***ValueList\n");*/
1483 Pk11Install_ValueList_Print(_this->list,pad+PADINC);
1484 PAD(pad); printf("}\n");
1485 }
1486 }
1487
1488 /*************************************************************************/
1489 void
1490 Pk11Install_ValueList_Print(Pk11Install_ValueList* _this, int pad)
1491 {
1492 Pk11Install_Value *v;
1493
1494 /*PAD(pad);printf("**Value List**\n");*/
1495 for(v = _this->head; v != NULL; v=v->next) {
1496 Pk11Install_Value_Print(v,pad);
1497 }
1498 }
1499
1500 /*************************************************************************/
1501 void
1502 Pk11Install_Value_Print(Pk11Install_Value* _this, int pad)
1503 {
1504 /*PAD(pad); printf("**Value, type=%s\n",
1505 type==STRING_VALUE ? "string" : "pair");*/
1506 if(_this->type==STRING_VALUE) {
1507 /*PAD(pad+PADINC); printf("====\n");*/
1508 PAD(pad); printf("%s\n", _this->string);
1509 /*PAD(pad+PADINC); printf("====\n");*/
1510 } else {
1511 Pk11Install_Pair_Print(_this->pair,pad+PADINC);
1512 }
1513 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial