modules/ca/ca_configFns.c
/* [<][>][^][v][top][bottom][index][help] */
FUNCTIONS
This source file includes following functions.
- stringPack
- ca_populateDictionary
- opSplitsen
- ca_readConfig
- ca_getDictionary
- ca_get_int
- ca_get_dirlist
- ca_get_string
- ca_get_boolean
- ca_set_int
- ca_change_int_value
- testFunction
- ca_getDatabase
- ca_getSource
- ca_getAllSources
- ca_getAsource
- ca_getSourceDetails
- ca_get_SourceHandleByPosition
- ca_get_SourceHandleByName
- ca_srchandle2Strelement
- ca_srchandle2Intelement
- ca_get_adminStrElement
- ca_get_adminIntElement
- ca_malloc
- ca_set_boolean
- ca_set_dirlist
- ca_set_string
- ca_writeNewValue
- ca_getStorageLocation
- ca_getConfig
- ca_getType
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <glib.h>
4 #include <string.h>
5 #include <stubs.h>
6 #include "ca_defs.h"
7 /* #define DEBUG */
8
9 /**********************************************
10 * This file contains the definitions of all *
11 * the functions. *
12 **********************************************/
13
14
15 void stringPack(char *dest, const char *source)
/* [<][>][^][v][top][bottom][index][help] */
16 {
17 #ifdef DEBUG
18 printf("\nInside stringPack function\n");
19 #endif /* DEBUG */
20
21 /*----------------------------------------------------------------------*\
22
23 * Function to rewrite a line of text with only one blankspace between *
24 * each word.
25 *
26
27 \*----------------------------------------------------------------------*/
28
29
30 /*
31 * This while loop continues until the NULL character is copied into
32 * the destination string. If a tab character is copied into the
33 * destination string, it is replaced with a blank-space character.
34 *
35 * Multiple blank-space and/or tab characters are skipped in the source
36 * string until any other character is found.
37 */
38
39 while (1)
40 {
41 *dest = *source;
42
43 if (*dest == '\t')
44 (*dest = ' ');
45
46 /* Exit if have copied the end of the string. */
47 if (*dest == '\0')
48 return;
49
50 /*
51 * If the source character was a blank-space or a tab, move to the next
52 * source character. While the source character is a blank-space or a
53 * tab, move to the next character (i.e. ignore these characters). When
54 * any other character is found in the source string, move to the next
55 * element of the destination string.
56 *
57 * Otherwise, simultaneously, move to the next elements of the destination
58 * and the source strings.
59 */
60
61
62
63 if ( (*source == ' ') || (*source == '\t') )
64 {
65 ++source;
66 while ( (*source == ' ') || (*source == '\t') )
67 {
68 ++source;
69 }
70
71 ++dest;
72 }
73 else
74 {
75 ++dest;
76 ++source;
77 }
78 }
79 }
80
81
82 void ca_populateDictionary(dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
83
84 /*******************************************************************
85 * ca_populateDictionary -- Parses dictionary file, initializes *
86 * the dictionary structure and writes *
87 * the file of dictionary symbols, *
88 * ca_dictSyms.h *
89 * *
90 * Parameters *
91 * woordenboek -- the dictionary to be populated *
92 * size -- the total number of variables i.e. the size of the *
93 * array of dict_t structures. See D. & D., p.276 *
94 * *
95 * Returns *
96 * Nothing ? (may change this later) *
97 * *
98 *******************************************************************/
99
100 {
101 const char *blankLine = "\n";
102 const char *comment = "#";
103 char line[120];
104 char input[120];
105 char test[120];
106 int lineNo = 0;
107 int i;
108 int entry = 0;
109 FILE *dictPtr, *defnPtr;
110
111 gchar **tokens; /* Pointer to an array of strings. */
112
113 /*
114 * Try to open the dictionary file for reading. If it cannot be
115 * opened, exit with an error.
116 */
117 if ( (dictPtr = fopen("dictionary.txt", "r")) == NULL)
118 {
119 fprintf(stderr, "Error: Unable to open 'dictionary.txt'\n");
120 die;
121 }
122
123
124 /*
125 *Try to open the definitions file for writing. If it cannot be
126 * opened,exit with an error
127 */
128 if ( (defnPtr = fopen("defs.txt", "w")) == NULL)
129 {
130 fprintf(stderr, "Error: Unable to open 'defs.txt'\n");
131 die;
132 }
133
134 /*
135 * Read the file one line at a time;
136 * if the line begins with a comment, ignore it;
137 * otherwise, split each line into tokens;
138 * print each token.
139 * Assign each token to the appropriate member of
140 * the appropriate element of the dictionary array.
141 */
142
143 fgets(input, sizeof(input), dictPtr);
144
145 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0) )
146
147 {
148 /*
149 * First remove the newline character.
150 * Then replace multiple tab and space
151 * characters with single space characters.
152 */
153
154 /* Remove the newline character, if present.
155 * Replace the last character of the string
156 * array with with '\0'.
157 */
158
159 input[strlen(input) - 1] = '\0';
160
161 /* Now, remove the multiple space and tab
162 * characters.
163 */
164
165 stringPack(line, input);
166
167 g_strchomp(line); /* Remove trailing w-space. */
168 #ifdef DEBUG
169 puts(line);
170 #endif /*DEBUG */
171
172 tokens = g_strsplit(line, " ", 0);
173
174 #ifdef DEBUG
175 for (i = 0; tokens[i] != NULL; i++)
176 printf("tokens[%d] = %s\n", i, tokens[i]);
177 #endif /* DEBUG */
178
179 /* We no longer need a variable for scope
180 * woordenboek[entry].varScope = atoi(tokens[1]);
181 */
182
183 strcpy(woordenboek[entry].varName, tokens[0]);
184 strcpy(woordenboek[entry].varSym, tokens[1]);
185 strcpy(woordenboek[entry].varType, tokens[2]);
186 woordenboek[entry].varNum = entry;
187
188 /*
189 * Write the dictionary symbol and the entry number
190 * to the definitions file.
191 */
192 fprintf(defnPtr, "%s\t%d\n", tokens[1], entry);
193
194 ++entry;
195 g_strfreev( tokens );
196 }
197 /*
198 * Get the 2nd and subsequent line of the file.
199 */
200
201 fgets(input, sizeof(input), dictPtr);
202
203 while(!feof(dictPtr) )
204 {
205 /*
206 * Process the line if it is not a comment.
207 */
208
209 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0 ) )
210 {
211 /*
212 * First remove the newline character.
213 * Then replace multiple tab and space
214 * characters with single space characters.
215 */
216
217 /* Remove the newline character, if present.
218 * Replace the last character of the string
219 * array with with '\0'.
220 */
221
222 input[strlen(input) - 1] = '\0';
223
224 /* Now, remove the multiple space and tab
225 * characters.
226 */
227
228 stringPack(line, input);
229
230 g_strchomp(line); /* Remove trailing w/space. */
231 #ifdef DEBUG
232 puts(line);
233 #endif /* DEBUG */
234 tokens = g_strsplit(line, " ", 0);
235
236 #ifdef DEBUG
237 for (i = 0; tokens[i] != NULL; i++)
238 printf("tokens[%d] = %s\n", i, tokens[i]);
239 #endif /* DEBUG */
240
241 /*
242 * We no longer need to know the scope of a variable
243 * woordenboek[entry].varScope = atoi(tokens[1]);
244 */
245
246 strcpy(woordenboek[entry].varName, tokens[0]);
247 strcpy(woordenboek[entry].varSym, tokens[1]);
248 strcpy(woordenboek[entry].varType, tokens[2]);
249 woordenboek[entry].varNum = entry;
250 fprintf(defnPtr, "%s\t%d\n", tokens[1], entry);
251 ++entry;
252
253 g_strfreev( tokens );
254 }
255 fgets(input, sizeof(input), dictPtr);
256 }
257
258 fclose(dictPtr);
259 fclose(defnPtr);
260
261 } /* End of ca_populateDictionary() function. */
262
263
264 void opSplitsen (FILE *filePtr, gchar **tokenArray)
/* [<][>][^][v][top][bottom][index][help] */
265 {
266 /*
267 * Declaring character constants is safer than using #define.
268 * See Oualline's book, p.145.
269 *
270 */
271
272 const char *blankLine = "\n"; /* Declared as a string, not a character. */
273 const char *comment = "#"; /* Declared as a string. */
274 char line[99];
275 char input[99];
276 int lineNo = 0;
277 int j;
278
279
280 fgets(input, sizeof(input), filePtr); /* Get the (first) line from the */
281 /* file to which filePtr points. */
282
283 #ifdef DEBUG
284 printf("\nFIRST INPUT >>> %s\n", input);
285 #endif /* DEBUG */
286
287 /* Compare the first character of the input */
288 /* to the comment and the newline strings. */
289
290 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0) )
291
292
293
294 {
295 /* Remove the newline character, if present. */
296 /* Replace the last character */
297 /* of the string array with '\0'. */
298
299 input[strlen(input) - 1] = '\0';
300 #ifdef DEBUG
301 printf("First Input >>> %s\n", input);
302 #endif /* DEBUG */
303
304 strcpy(line, input);
305 #ifdef DEBUG
306 printf("First Line after copy >>> %s\n", line);
307 #endif /* DEBUG */
308
309 stringPack(line, input);
310 #ifdef DEBUG
311 printf("Line: %s\n", line);
312 #endif /* DEBUG */
313
314 g_strchomp(line);
315 /* g_strdelimit(line, " ", ':');
316 * g_strdelimit(line, "\t", '*');
317 */
318
319 #ifdef DEBUG
320 printf("%3d> %s\n", ++lineNo, line);
321 #endif /* DEBUG */
322
323 /*
324 * g_strsplit() is a GLib function;
325 * it returns an array of strings.
326 *
327 * Here, we split on two spaces, " ".
328 * We set max_tokenArray to be 0. We want the
329 * first token to be the name of the variable
330 * and the other tokens to be the value of the variable,
331 * qualifiers, etc.
332 */
333
334 tokenArray = g_strsplit(line, " ", 0);
335
336 #ifdef DEBUG
337 for (j = 0; tokenArray[j] != NULL; j++)
338 printf("token[%d] = %s\n", j, tokenArray[j]);
339 #endif /* DEBUG */
340
341 } /* End of processing the first line, if not commented. */
342
343 /* End of getting the first line. */
344
345
346 /*Get the 2nd line of the file. */
347 fgets(input, sizeof(input), filePtr);
348
349 while(!feof(filePtr) )
350 {
351
352 /* Process the line if it is not commented. */
353 if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0 ) )
354 {
355 /* Remove the newline character, if present. */
356 input[strlen(input) -1] = '\0';
357 #ifdef DEBUG
358 printf("Subsequent Input >>> %s\n", input);
359 #endif /* DEBUG */
360
361 strcpy(line, input);
362 #ifdef DEBUG
363 printf("Subsequent Line after copy >>> %s\n", line);
364 #endif /* DEBUG */
365
366 stringPack(line, input);
367 #ifdef DEBUG
368 printf("Line: %s\n", line);
369 #endif /* DEBUG */
370
371 g_strchomp(line);
372 /* g_strdelimit(line, " ", ':');
373 * g_strdelimit(line, "\t", '*');
374 */
375
376 #ifdef DEBUG
377 printf("%3d> %s\n", ++lineNo, line);
378 #endif /* DEBUG */
379
380 /*
381 * See the comment above about the maximum
382 * number of tokens being set to 0.
383 */
384
385 tokenArray = g_strsplit(line, " ", 0);
386
387 #ifdef DEBUG
388 for (j = 0; tokenArray[j] != NULL; j++)
389 {
390 printf("token[%d] = %s\n", j, tokenArray[j]);
391 /* Can also use puts(tokenArray[j]) here. */
392 }
393 #endif /* DEBUG */
394 } /* Processed uncommented lines. */
395
396 fgets(input, sizeof(input), filePtr);
397 } /* Processed the 2nd & subsequent lines of the file. */
398
399 } /* End of processing the opened file. */
400
401
402 void ca_readConfig(const char *configFile, values_t confVars[], int size)
/* [<][>][^][v][top][bottom][index][help] */
403 /*******************************************************************
404 * *
405 * ca_readConfig -- parses the config file and writes the values *
406 * into memory. *
407 * *
408 * Parameters *
409 * configFile -- the configuration file
410 * confVars[] -- the array of values structures *
411 * size -- the number of configuration variables *
412 * *
413 * Returns *
414 * Nothing -- perhaps make this return 0 on successful exit ? *
415 * *
416 * Note: Should we make the name of the config file a global *
417 * variable ? *
418 *******************************************************************/
419 {
420 FILE *confPtr; /* Pointer to config file. */
421 char name[STRLENGTH_M]; /* The name of the config variable */
422 /* 80 characters */
423 char value[STRLENGTH_XXL]; /* The value of the variable */
424 /* 640 characters */
425 int location; /* Storage Location of the variable's value. */
426 int type; /* Data type of the variable, represented by an integer. */
427
428
429 const char *blankLine = "\n"; /* Declared as a string, not a character. */
430 const char *comment = "#"; /* Declared as a string. */
431
432 char source[16]; /* The name of a source. */
433 char database[STRLENGTH_M]; /* The elements of a database. */
434 /* 80 characters */
435 int mode; /* The mode of operation of the src */
436 char srcOptions[16]; /* The options of a source. */
437 char nrtMirror[STRLENGTH_M]; /* The elements of a NRTM */
438 int updatePort; /* The update port of the source */
439
440 gchar **dbcomps; /* Pointer to an array of strings that represents */
441 /* the components of a db. */
442
443 gchar **nrtmcomps; /* Pointer to an array of strings that represents */
444 /* the components of a nrtm. */
445
446 gchar **optcomps; /* Pointer to an array of strings that represents */
447 /* the components of the options of a source. */
448
449 int i; /* A counting variable. */
450
451 ca_database_t *newDbPtr; /* A pointer to a new instance of */
452 /* ca_database_t. */
453
454 ca_mirror_t *newMirrPtr; /* A pointer to a new instance of */
455 /* ca_mirror_t. */
456
457 ca_database_list_t *newSrc; /* A pointer to a new instance of */
458 /* ca_database_list_t. */
459
460 ca_ripadmin_t *newAdminPtr; /* A pointer to a new instance of */
461 /* a ca_ripadmin_t variable. */
462
463 /*
464 * Function Prototype for ca_getStorageLocation()
465 * We put it here; thus it can only be called from
466 * within ca_readConfig()
467 *
468 * This function finds the location in the values_t array
469 * where we store pointers to the string value and the actual
470 * value of the variable. It returns this location as an
471 * integer.
472 *
473 */
474 int ca_getStorageLocation(char [], dict_t [], int);
475
476 /*
477 * Function Prototype for ca_getType()
478 * We put it here so that it can only be called from
479 * within ca_readConfig()
480 *
481 * This function returns the type of the configuration
482 * variable. It returns it as a string.
483 *
484 */
485 int ca_getType(char [], dict_t [], int);
486
487
488 #ifdef DEBUG
489 printf("\nInside readConfig() function.\n");
490 printf("Configuration file is: %s\n", configFile);
491 #endif /* DEBUG */
492
493 /*
494 * Open the configuration file for reading .....
495 */
496 if ( (confPtr = fopen(configFile, "r")) == NULL)
497 {
498 printf("Error: file %s could not be opened.\n", configFile);
499 die;
500 }
501
502 /*
503 * Read the first record in the configuration file .....
504 * We read the _name_ of the variable using fscanf into a
505 * string array. We read the _value_ of the variable
506 * using fgets into an array; thus, we can handle values of
507 * variables with qualifiers (e.g. SPLIT after DBLIST) and
508 * values with blank characters (e.g. REPLYBANNER).
509 */
510 fscanf(confPtr, "%s", name);
511 fgets(value, sizeof(value), confPtr);
512
513
514 /*
515 * While there are records to be read in the config file.
516 * write the current record into memory,
517 * read the next record in the config file
518 */
519
520
521 while (!feof(confPtr) )
522 {
523
524 /*
525 * From the variable name, find the dictionary number.
526 * The dictionary number is defined as the place in the
527 * values array in which to store the value of the variable.
528 *
529 */
530
531 /*
532 * Process the line only when/if it is not a comment or
533 * a blankline.
534 */
535 if ( (strncmp(name, comment, 1) != 0) && (strncmp(name, blankLine, 1) != 0) )
536 {
537 /*
538 * If the last character of "value" is '\n',
539 * replace it with '\0'.
540 */
541 if ( value[strlen(value) - 1] == '\n')
542 {
543 value[strlen(value) - 1] = '\0';
544 }
545
546 /*
547 * From the variable name, find the element of the values
548 * array in which to store the value of the variable.
549 *
550 */
551 location = ca_getStorageLocation(name, dictionary, VARS);
552
553 #ifdef DEBUG
554 printf("The location is: %d\n", location);
555 #endif /* DEBUG */
556
557 /*
558 * See if the string value has already been stored;
559 * if it has, then concatenate the new value to it;
560 * if not, then allocate some memory and copy the
561 * string into it.
562 */
563
564 /*
565 * If this variable already exists, it has a non-zero
566 * value and this 'if' statement returns a "true" value.
567 * Otherwise, it returns a "zero" or "false" value.
568 */
569 if (confVars[location].strPtr)
570 {
571 strcat(confVars[location].strPtr, "\n");
572 strcat(confVars[location].strPtr, value);
573 }
574 else
575 {
576 /*
577 * Store a pointer to the string that contains the value
578 * This is not necessarily the actual value itself.
579 * First, we must allocate some memory.
580 */
581 confVars[location].strPtr = (char *)malloc(STRLENGTH_XXL);
582 /*
583 * We check the return value of the malloc function .....
584 */
585 if (confVars[location].strPtr == NULL)
586 {
587 fprintf(stderr, "Cannot allocate memory for confVars[location].strPtr\n");
588 die;
589 }
590 strcpy(confVars[location].strPtr, value);
591 }
592
593 /*
594 * Now, store a pointer to the _value_ of the variable.
595 * Do this as follows:
596 * (a) get the _type_ of the variable
597 * (b) store a pointer to the value of the variable in
598 * a way that depends on the _type_ of the variable.
599 */
600 #ifdef DEBUG
601 printf("Variable \"%s\" is data-type \"%d\"\n", name, ca_getType(name, dictionary, VARS) );
602 #endif /* DEBUG */
603
604
605 type = ca_getType(name, dictionary, VARS);
606
607 /*
608 * Given the _type_ of the variable, store the value of the
609 * variable in the appropriate way.
610 */
611 switch(type)
612 {
613 case 11:
614
615 #ifdef DEBUG
616 puts("Data type is Integer");
617 #endif /* DEBUG */
618
619 confVars[location].valPtr = malloc(sizeof(int) );
620 if (confVars[location].valPtr == NULL)
621 {
622 fprintf(stderr, "Cannot allocate memory !!!\n");
623 die;
624 }
625 sscanf(value, "%d", (int *) confVars[location].valPtr);
626 break;
627
628 case 12:
629
630 #ifdef DEBUG
631 puts("Data type is String !!! *** !!!");
632 #endif /* DEBUG */
633
634
635 /*
636 * Test if this variable has already been created.
637 * Look for a non-zero i.e. true value.
638 *
639 * First put a '\n' character at the end of the existing
640 * string.
641 * Then, concatenate the additional string.
642 */
643 if (confVars[location].valPtr)
644 {
645 #ifdef DEBUG
646 printf("\n%s variable already exists\n", name);
647 #endif /* DEBUG */
648 strcat(confVars[location].valPtr, "\n");
649 strcat(confVars[location].valPtr, value);
650 }
651 else
652 {
653 /*
654 * If the variable has not already been created,
655 * then create it.
656 */
657 #ifdef DEBUG
658 printf("\n%s variable does not exist\n", name);
659 #endif /* DEBUG */
660
661 confVars[location].valPtr = (char *)malloc(STRLENGTH_XXL);
662 if (confVars[location].valPtr == NULL)
663 {
664 fprintf(stderr, "Cannot allocate memory !!!\n");
665 die;
666 }
667 g_strstrip(value);
668 strcpy(confVars[location].valPtr, value);
669 }
670
671 break;
672
673 case 13:
674 #ifdef DEBUG
675 puts("Data type is Dirlist");
676 #endif /* DEBUG */
677 confVars[location].valPtr = (char *)malloc(STRLENGTH);
678 if (confVars[location].valPtr == NULL)
679 {
680 fprintf(stderr, "Cannot allocate memory !!!\n");
681 die;
682 }
683 strcpy(confVars[location].valPtr, value);
684 break;
685
686 case 14:
687 #ifdef DEBUG
688 puts("Data type is Boolean");
689 #endif /* DEBUG */
690
691 /*
692 * confVars[location].valPtr = (char *)malloc(2);
693 */
694
695 confVars[location].valPtr = malloc(sizeof(int) );
696 if (confVars[location].valPtr == NULL)
697 {
698 fprintf(stderr, "Cannot allocate memory !!!\n");
699 die;
700 }
701 /*
702 * strcpy(confVars[location].valPtr, value);
703 */
704 sscanf(value, "%d", (int *) confVars[location].valPtr);
705 break;
706
707 case 15:
708 #ifdef DEBUG
709 puts("Data type is Source !!!");
710 #endif /* DEBUG */
711
712 #ifdef DEBUG
713 puts(name);
714 puts(value);
715 #endif /* DEBUG */
716 /*
717 * Split the value into "source" and "database"
718 * Use blankspace as the delimiter between the
719 * "source" and "database".
720 */
721 sscanf(value, "%s %s %d %s %d %s", source, database, &mode, nrtMirror, &updatePort, srcOptions);
722 #ifdef DEBUG
723 puts(source);
724 puts(database);
725 printf("%d\n", mode);
726 puts(nrtMirror);
727 printf("%d\n", updatePort);
728 puts(srcOptions);
729 #endif /* DEBUG */
730
731 /*
732 * Using the values in "database".
733 * populate a ca_database_t structure.
734 * Give this variable a name.
735 *
736 */
737
738 /* First, separate the values in "database", using "," as
739 * as a delimiting character.
740 */
741 dbcomps = g_strsplit(database, ",", 0);
742
743 #ifdef DEBUG
744 for (i = 0; dbcomps[i] != NULL; i++)
745 printf("dbcomps[%d] = %s\n", i, dbcomps[i]);
746 #endif /* DEBUG */
747
748
749 /*
750 * Create a structure for this database.
751 */
752 newDbPtr = calloc(1,sizeof(ca_database_t));
753 if (newDbPtr == NULL)
754 {
755 fprintf(stderr, "Cannot allocate memory to new db structure\n");
756 die;
757 }
758
759 strcpy(newDbPtr->host, dbcomps[0]);
760 newDbPtr->port = atoi(dbcomps[1]);
761 strcpy(newDbPtr->user, dbcomps[2]);
762 strcpy(newDbPtr->password, dbcomps[3]);
763 strcpy(newDbPtr->dbName, dbcomps[4]);
764
765 g_strfreev(dbcomps);
766 #ifdef DEBUG
767 puts("Testing the population of the db structure:");
768 printf("\n%s::%d::%s::%s::%s\n", newDbPtr->host, newDbPtr->port, newDbPtr->user, newDbPtr->password, newDbPtr->dbName);
769 #endif /* DEBUG */
770
771
772
773 /*
774 * The mode of operation of the source has already been
775 * set in the sscanf statement above.
776 */
777
778 /*
779 * Using the values in "nrtMirror".
780 * populate a ca_mrrror_t structure.
781 * Give this variable a name.
782 *
783 */
784
785 /* First, separate the values in "nrtMirror", using "," as
786 * as a delimiting character.
787 */
788 nrtmcomps = g_strsplit(nrtMirror, ",", 0);
789
790 #ifdef DEBUG
791 for (i = 0; nrtmcomps[i] != NULL; i++)
792 printf("nrtmcomps[%d] = %s\n", i, nrtmcomps[i]);
793 #endif /* DEBUG */
794
795
796 /*
797 * Create a structure for this near-real-time mirror.
798 */
799 newMirrPtr = calloc(1,sizeof(ca_mirror_t));
800 if (newMirrPtr == NULL)
801 {
802 fprintf(stderr, "Cannot allocate memory to new nrtm structure\n");
803 die;
804 }
805
806 strcpy(newMirrPtr->host, nrtmcomps[0]);
807 newMirrPtr->port = atoi(nrtmcomps[1]);
808 strcpy(newMirrPtr->log, nrtmcomps[2]);
809 newMirrPtr->delay = atoi(nrtmcomps[3]);
810 newMirrPtr->protocolVer = atoi(nrtmcomps[4]);
811 #ifdef DEBUG
812 puts("Testing the population of the nrtm structure:");
813 printf("\n%s::%d::%s::%d::%d\n", newMirrPtr->host, newMirrPtr->port, newMirrPtr->log, newMirrPtr->delay, newMirrPtr->protocolVer);
814 #endif /* DEBUG */
815
816 g_strfreev(nrtmcomps);
817 /*
818 * The update port was already set by the sscanf
819 * statement above.
820 */
821
822 /*
823 * Using the values in "srcOptions"
824 * get the values for the canupd and deflook
825 * components od the ca_dbSource_t structure.
826 *
827 */
828
829 /* First, separate the values in "srcOptions", using ","
830 * as a delimiting character.
831 */
832 optcomps = g_strsplit(srcOptions, ",", 0);
833
834 #ifdef DEBUG
835 for (i = 0; optcomps[i] != NULL; i++)
836 printf("optcomps[%d] = %s\n", i, optcomps[i]);
837 #endif /* DEBUG */
838
839
840 /*
841 * Using the above ca_database_t structure
842 * and the "source" value,
843 * populate the ca_dbSource_t structure.
844 */
845
846 /*
847 * Create a new structure for this source.
848 */
849 newSrc = calloc(1,sizeof(ca_dbSource_t));
850
851 if (newSrc == NULL)
852 {
853 fprintf(stderr, "Cannot allocate memory to new source structure\n");
854 die;
855 }
856
857 strcpy(newSrc->name, source);
858 newSrc->db = *newDbPtr;
859 newSrc->opMode = mode;
860 newSrc->nrtm = *newMirrPtr;
861 newSrc->updPort = updatePort;
862 strcpy(newSrc->canupd, optcomps[0]);
863 strcpy(newSrc->deflook, optcomps[1]);
864
865 free(newMirrPtr); /* was copied */
866 free(newDbPtr); /* was copied */
867 g_strfreev(optcomps);
868
869 #ifdef DEBUG
870 puts("Testing the population of the ca_dbSource_t structure:");
871 printf("Source name: %s\n", newSrc->name);
872 printf("\nDB == %s::%d::%s::%s::%s\n", (newSrc->db).host, (newSrc->db).port, (newSrc->db).user, (newSrc->db).password, (newSrc->db).dbName);
873 printf("Mode: %d\n", newSrc->opMode);
874 printf("NRTM == %s::%d::%s::%d:%d\n", (newSrc->nrtm).host, (newSrc->nrtm).port, (newSrc->nrtm).log, (newSrc->nrtm).delay, (newSrc->nrtm).protocolVer);
875 printf("UpdPort: %d\n", newSrc->updPort);
876 printf("Src Options == %s::%s\n", newSrc->canupd, newSrc->deflook);
877 #endif /* DEBUG */
878
879 /*
880 * Append this ca_src_t structure to the sourceList,
881 * which is a singly-linked list if type GSList.
882 */
883
884 sourceList = g_slist_append(sourceList, newSrc);
885
886 /*
887 * 20000609
888 * Experiment:
889 * Add the newSrc to the other variable describing the list of sources,
890 * mySrcList
891 *
892 * mySrcList = g_slist_append(mySrcList, newSrc);
893 */
894
895 break;
896
897 case 16:
898 #ifdef DEBUG
899 puts("Found the CA_ADMIN stuff !!!");
900 #endif /* DEBUG */
901 /* The elements of the Admin-DB have already been read in. */
902 /* Now, split up the elements and assign them to the */
903 /* components of the Admin-DB structure. */
904 /* First, separate the values in "value", using ',' as a */
905 /* delimiting character. */
906 dbcomps = g_strsplit(value, ",", 0);
907
908 #ifdef DEBUG
909 for (i = 0; dbcomps[i] != NULL; i++)
910 printf("dbcomps[%d] = %s\n", i, dbcomps[i]);
911 #endif /* DEBUG */
912
913 /*
914 * Now, allocate some memory to the newAdminPtr.
915 */
916 newAdminPtr = calloc(1, sizeof(ca_ripadmin_t) );
917
918 /*
919 * Check that we actually got the memory.
920 */
921 if (newAdminPtr ==NULL)
922 {
923 fprintf(stderr, "Cannot allocate memory to new admin-db structure\n");
924 die;
925 }
926
927 /*
928 * Now, assign the elements of the dbcomps array to the
929 * appropriate components of the structure to which
930 * newAdminPtr points.
931 */
932
933 /*
934 * Strip leading and trailing whitespace from dbcomps[0]
935 */
936 g_strstrip( dbcomps[0] );
937
938 strcpy(newAdminPtr->host, dbcomps[0]);
939 newAdminPtr->port = atoi(dbcomps[1]);
940 strcpy(newAdminPtr->user, dbcomps[2]);
941 strcpy(newAdminPtr->password, dbcomps[3]);
942 strcpy(newAdminPtr->tableName, dbcomps[4]);
943
944 g_strfreev(dbcomps);
945
946 #ifdef DEBUG
947 puts("Testing the population of the rip-admin db structure:");
948 printf("\n%s::%d::%s::%s::%s\n", newAdminPtr->host, newAdminPtr->port, newAdminPtr->user, newAdminPtr->password, newAdminPtr->tableName);
949 #endif /* DEBUG */
950
951 /*
952 * Now, assign these values into the correct long-term
953 * storage.
954 */
955
956
957 confVars[location].valPtr = (ca_ripadmin_t *)calloc(1, sizeof(ca_ripadmin_t) );
958
959
960 /*
961 * Check that we actually got the memory.
962 */
963 if (confVars[location].valPtr == NULL)
964 {
965 fprintf(stderr, "Cannot allocate memory to new admin-db structure\n");
966 die;
967 }
968
969 memcpy(confVars[location].valPtr, newAdminPtr, sizeof(ca_ripadmin_t));
970 /*
971 strcpy( ((ca_ripadmin_t *)confVars[location].valPtr)->host, newAdminPtr->host);
972 (confVars[location].valPtr)->port = newAdminPtr->port;
973 strcpy( (confVars[location].valPtr)->user, newAdminPtr->user);
974 strcpy( (confVars[location].valPtr)->password, newAdminPtr->password);
975 strcpy( (confVars[location].valPtr)->tableName, newAdminPtr->tableName);
976 */
977
978 free(newAdminPtr);
979 #ifdef DEBUG
980 printf("The ripadmin machine is: %s\n", ((ca_ripadmin_t *)confVars[location].valPtr)->host);
981 #endif /* DEBUG */
982
983 break;
984
985 default:
986 fprintf(stderr, "Data type not found for variable \"%s\".\n", name);
987 die;
988 break;
989 }
990 }
991
992 fscanf(confPtr, "%s", name);
993 fgets(value, sizeof(value), confPtr);
994
995 } /* End of processing the config file. */
996
997 } /* End of readConfig() function */
998
999
1000 /*
1001 * void ca_populateDictionary(dictionary_t woordenboek[], int size, FILE *fiPtr)
1002 * {
1003 * int j;
1004 * char input[99];
1005 *
1006 * for (j=0; (j < size) && !feof(fiPtr); j++)
1007 * j = 0;
1008 * while ((j < size) && !feof(fiPtr) )
1009 * {
1010 * printf("\n%d\n", j);
1011 *
1012 * fgets(input, sizeof(input), filePtr);
1013 *
1014 * if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1)
1015 * != 0) )
1016 * {
1017 * fscanf(fiPtr, "%s %s %s %s", woordenboek[j].varName, woordenboek[j].varScope, woordenboek[j].varSym, woordenboek[j].varType);
1018 * }
1019 *
1020 * fgets(input, sizeof(input), filePtr);
1021 * printf("%s\n", woordenboek[j].varName);
1022 * }
1023 * }
1024 *
1025 */
1026
1027
1028 void ca_getDictionary(dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
1029 {
1030 int k;
1031
1032 for (k = 0; k < size; k++)
1033 {
1034 printf("\nj = %d\n", k);
1035 /*
1036 * printf("%s\t%d\t%s\n", woordenboek[k].varName, woordenboek[k].varScope, woordenboek[k].varType);
1037 */
1038 printf("%s\t%s\t%s\t%d\n", woordenboek[k].varName, woordenboek[k].varSym, woordenboek[k].varType, woordenboek[k].varNum);
1039
1040 }
1041 }
1042
1043
1044 int ca_get_int(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1045 {
1046 int *xPtr;
1047
1048 /*
1049 * First print a message saying that the ca_get_int()
1050 * function is being called.
1051 */
1052 #ifdef DEBUG
1053 printf("\nDEBUG: ca_get_int() function is called .....\n");
1054 printf("DEBUG: New value of StringPtr: %s\n", confVars[symbol].strPtr);
1055 #endif /* DEBUG */
1056
1057 /*
1058 * Look at the appropriate place in the dictionary;
1059 * e.g. C_BINDPORT => the first element, index = 0.
1060 *
1061 * if the varType is not an integer, exit with an error;
1062 *
1063 * otherwise,
1064 * if the varScope is global, look for the value in the
1065 * appropriate place in memory in the global values array;
1066 * otherwise, look for the value in the appropriate place in
1067 * memory in the local values array;
1068 *
1069 *
1070 */
1071
1072 /* Look at the appropriate place in the dictionary. */
1073
1074 #ifdef DEBUG
1075 printf("\nDEBUG: Variable type: %s\n", dictionary[symbol].varType);
1076 #endif /* DEBUG */
1077
1078 /* If the variable type is not an integer, exit with an error. */
1079 if ( strcmp(dictionary[symbol].varType, "CA_INT") != 0)
1080 {
1081 fprintf(stderr, "Error: unexpected variable type.\n");
1082 die;
1083 }
1084 else
1085 {
1086 /*
1087 * If the variable has global scope, look for it in
1088 * the globals array. Otherwise, look for it in the
1089 * locals array.
1090 *
1091 */
1092
1093
1094 /*
1095 * switch(dictionary[symbol].varScope)
1096 * {
1097 * case 1:
1098 * printf("\nThis variable has global scope.\n");
1099 * printf("The string is: %s\n", globals[symbol].strPtr);
1100 * printf("String2Value: %d\n", atoi(globals[symbol].strPtr));
1101 *
1102 * xPtr = globals[symbol].valPtr;
1103 * printf("Value: %d\n", *xPtr);
1104 * return(*xPtr);
1105 * break;
1106 *
1107 * case 99:
1108 * printf("\nThis variable has local scope.\n");
1109 * printf("The string is %s\n", locals[symbol].strPtr);
1110 * printf("String2Value: %d\n", atoi(locals[symbol].strPtr));
1111 * xPtr = locals[symbol].valPtr;
1112 * printf("Value: %d\n", *xPtr);
1113 * return(*xPtr);
1114 * break;
1115 *
1116 * default:
1117 * printf("\nAaaargh !!! This variable has unwelcome scope.\n");
1118 * break;
1119 * }
1120 */
1121
1122 /*
1123 * Lock the value of the variable before reading it.
1124 */
1125
1126 mutex_lock(&Lock);
1127
1128 xPtr = confVars[symbol].valPtr;
1129 /*
1130 * Unlock the value of the variable after reading it.
1131 */
1132 mutex_unlock(&Lock);
1133 return(*xPtr);
1134 }
1135
1136 }
1137
1138 char *ca_get_dirlist(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1139 {
1140 /*
1141 * This function returns a pointer to a character array. Thus,
1142 * we need to declare such a pointer.
1143 *
1144 */
1145
1146 char *xPtr;
1147 #ifdef DEBUG
1148 printf("\nca_get_dirlist() function is called .....\n");
1149 #endif /* DEBUG */
1150
1151
1152 /*
1153 * Look at the appropriate place in the dictionary;
1154 * e.g. CA_HELP => the second element, index = 1.
1155 *
1156 * if the varType is not CA_DIRLIST, exit with an error;
1157 *
1158 * otherwise,
1159 * if the varScope is global, look for the value in the
1160 * appropriate place in memory in the global values array;
1161 * otherwise, look for the value in the appropriate place in
1162 * memory in the local values array;
1163 *
1164 *
1165 */
1166
1167 /* Look at the appropriate place in the dictionary. */
1168 #ifdef DEBUG
1169 printf("\nVariable type: %s\n", dictionary[symbol].varType);
1170 #endif /* DEBUG */
1171
1172 /* If the variable type is not CA_DIRLIST, exit with an error. */
1173 if ( strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0)
1174 {
1175 fprintf(stderr, "Error: unexpected variable type.\n");
1176 die;
1177 }
1178 else
1179 {
1180 /*
1181 * If the variable has global scope, look for it in
1182 * the globals array. Otherwise, look for it in the
1183 * locals array.
1184 *
1185 */
1186
1187 /*
1188 * This next piece of code (switch statements, etc.) is not
1189 * needed. We do not have global or local variables anymore.
1190 */
1191
1192 /*
1193 * switch(dictionary[symbol].varScope)
1194 * {
1195 * case 1:
1196 * printf("\nThis variable has global scope.\n");
1197 * printf("The string is: %s\n", globals[symbol].strPtr);
1198 * xPtr = strdup(globals[symbol].valPtr);
1199 * printf("Value: %s\n", xPtr);
1200 * return(xPtr);
1201 * break;
1202 *
1203 * case 99:
1204 *
1205 * printf("\nThis variable has local scope.\n");
1206 * printf("The string is %s\n", locals[symbol].strPtr);
1207 * xPtr = locals[symbol].valPtr;
1208 * printf("Value: %s\n", xPtr);
1209 * return(xPtr);
1210 * break;
1211 *
1212 * default:
1213 * printf("\nAaaargh !!! This variable has unwelcome scope.\n");
1214 * break;
1215 * }
1216 */
1217
1218 mutex_lock(&Lock);
1219 xPtr = (strdup(confVars[symbol].valPtr));
1220 #ifdef DEBUG
1221 printf("Value: %s\n", xPtr);
1222 #endif /* DEBUG */
1223 mutex_unlock(&Lock);
1224 return(xPtr);
1225 }
1226
1227 }
1228
1229
1230 char *ca_get_string(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1231 {
1232 /*
1233 * This function returns a pointer to a character array. Thus,
1234 * we need to declare such a pointer.
1235 *
1236 */
1237
1238 char *xPtr;
1239 #ifdef DEBUG
1240 printf("\nca_get_text() function is called .....\n");
1241 #endif /* DEBUG */
1242
1243
1244 /*
1245 * Look at the appropriate place in the dictionary;
1246 * e.g. CA_REPLYBANNER => the third element, index = 2.
1247 *
1248 * if the varType is not CA_STRING, exit with an error;
1249 *
1250 * otherwise,
1251 * if the varScope is global, look for the value in the
1252 * appropriate place in memory in the global values array;
1253 * otherwise, look for the value in the appropriate place in
1254 * memory in the local values array;
1255 *
1256 *
1257 */
1258
1259 /* Look at the appropriate place in the dictionary. */
1260
1261 #ifdef DEBUG
1262 printf("\nVariable type: %s\n", dictionary[symbol].varType);
1263 #endif /* DEBUG */
1264
1265 /* If the variable type is not CA_STRING, exit with an error. */
1266 if ( strcmp(dictionary[symbol].varType, "CA_STRING") != 0)
1267 {
1268 fprintf(stderr, "Error: unexpected variable type.\n");
1269 die;
1270 }
1271 else
1272 {
1273 /*
1274 * If the variable has global scope, look for it in
1275 * the globals array. Otherwise, look for it in the
1276 * locals array.
1277 *
1278 */
1279
1280 /*
1281 * We do not need this code any longer. We do not use
1282 * global or local variables or the associated arrays,
1283 * 'globals' and 'locals'.
1284 *
1285 * switch(dictionary[symbol].varScope)
1286 * {
1287 * case 1:
1288 * printf("\nThis variable has global scope.\n");
1289 * printf("The string is: %s\n", globals[symbol].strPtr);
1290 * xPtr = globals[symbol].valPtr;
1291 * printf("Value: %s\n", xPtr);
1292 * return(xPtr);
1293 * break;
1294 *
1295 * case 99:
1296 * printf("\nThis variable has local scope.\n");
1297 * printf("The string is %s\n", locals[symbol].strPtr);
1298 * xPtr = locals[symbol].valPtr;
1299 * printf("Value: %s\n", xPtr);
1300 * return(xPtr);
1301 * break;
1302 *
1303 * default:
1304 * printf("\nAaaargh !!! This variable has unwelcome scope.\n");
1305 * break;
1306 * }
1307 */
1308 mutex_lock(&Lock);
1309 xPtr = (strdup(confVars[symbol].valPtr));
1310 #ifdef DEBUG
1311 printf("Value: %s\n", xPtr);
1312 #endif /* DEBUG */
1313 mutex_unlock(&Lock);
1314 return(xPtr);
1315
1316 }
1317 }
1318
1319
1320 int ca_get_boolean(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1321 {
1322 /**********************************************
1323 * ca_get_boolean() *
1324 * *
1325 * *
1326 * Parameters *
1327 * *
1328 * symbol -- the symbol for the variable *
1329 * *
1330 * *
1331 * Returns *
1332 * *
1333 * 1 if true, 0 if false. *
1334 * *
1335 * Remarks *
1336 * *
1337 * Is there a better way to implement *
1338 * Boolean values in C ? *
1339 * *
1340 *********************************************/
1341
1342 int *xPtr;
1343
1344 /*
1345 * Print this message if in debug mode.
1346 *
1347 */
1348 #ifdef DEBUG
1349 printf("\nca_get_boolean() function is called .....\n");
1350 printf("DEBUG 5: New value of StringPtr: %s\n", globals[symbol].strPtr);
1351 #endif /* DEBUG */
1352
1353 /**********************************************\
1354 * *
1355 * Here is how this works: *
1356 * *
1357 * (a) Check that the type of variable whose *
1358 * value is being read is CA_BOOLEAN. *
1359 * *
1360 * (b) Lock the value of the variable before *
1361 * reading it. *
1362 * *
1363 * (c) Depending on the scope of the variable *
1364 * look for it in the appropriate array. *
1365 * *
1366 * (d) Read the value of the variable. *
1367 * *
1368 * (e) Unlock the value of the variable after *
1369 * reading it. *
1370 * *
1371 * *
1372 * Returns *
1373 *
1374 * an integer value as follows: *
1375 * 1 if the db is in testmode (true), *
1376 * 0 if the db is not in testmode (false). *
1377 \*********************************************/
1378
1379
1380 /*
1381 * Look at the appropriate place in the dictionary;
1382 * e.g. CA_BOOLEAN = the fifth element of the dict_t array,
1383 * => index = 4.
1384 *
1385 * If the varType is not Boolean, exit with an error
1386 *
1387 * Otherwise,
1388 * if the varScope is global, look for the value in the
1389 * appropriate place in the global values array;
1390 *
1391 * otherwise, look for the value in the appropriate place in the
1392 * locals array.
1393 *
1394 */
1395
1396 #ifdef DEBUG
1397 /* Look in the appropriate place in the dictionary. */
1398 printf("\nVariable type: %s\n", dictionary[symbol].varType);
1399 #endif /* DEBUG */
1400
1401 /* If the variable type is not Boolean, exit with an error. */
1402
1403 if ( strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0)
1404 {
1405 fprintf(stderr, "Error: Boolean type expected.\n");
1406 die;
1407 }
1408
1409 else
1410 {
1411
1412 /*
1413 * If the variable has global scope, look for it in the globals
1414 * array. Otherwise, look for it in the locals array.
1415 *
1416 */
1417 /*
1418 * We do not need this code (switch statements, etc.) anymore.
1419 */
1420
1421 /*
1422 * switch(dictionary[symbol].varScope)
1423 * {
1424 * case 1:
1425 * printf("\nThis variable has global scope.\n");
1426 * printf("The string is: %s\n", globals[symbol].strPtr);
1427 * printf("String2Value: %d\n", atoi(globals[symbol].strPtr) );
1428 * xPtr = globals[symbol].valPtr;
1429 * printf("Value: %d\n", *xPtr);
1430 * return (*xPtr);
1431 * break;
1432 *
1433 * case 99:
1434 * printf("\nThis variable has local scope.\n");
1435 * printf("The string is %s\n", locals[symbol].strPtr);
1436 * printf("String2Value: %d\n", atoi(locals[symbol].strPtr) );
1437 * xPtr = locals[symbol].valPtr;
1438 * printf("Value: %d\n", *xPtr);
1439 * return(*xPtr);
1440 * break;
1441 *
1442 * default:
1443 * printf("\nError: This variable has unknown scope.\n");
1444 * break;
1445 *
1446 * }
1447 */
1448
1449 /*
1450 * Lock the value of the variable before reading it.
1451 *
1452 */
1453
1454 mutex_lock(&Lock);
1455 xPtr = confVars[symbol].valPtr;
1456 /*
1457 * Unlock the value of the variable after reading it.
1458 */
1459 mutex_unlock(&Lock);
1460
1461 return(*xPtr);
1462 }
1463 }
1464
1465
1466
1467 void ca_set_int(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
1468 {
1469 /*********************************************
1470 * ca_set_int() *
1471 * *
1472 * Parameters *
1473 * symbol -- the symbol for the variable. *
1474 * *
1475 * Returns *
1476 * 1 if successful 0 if not ? *
1477 * *
1478 * Remarks *
1479 * Needs a better way to check for valid *
1480 * values from the keyboard. *
1481 * *
1482 *********************************************/
1483
1484 void *tempPtr; /* Temp pointer to point to the value pointer
1485 in the appropriate values array. */
1486 char newPort[16];
1487 int invalid;
1488 int portNr;
1489
1490 /* Function to change the value in a given values array.
1491 * This function can only be called from within ca_set_int().
1492 */
1493 int *ca_change_int_value(char []);
1494 void testFunction(values_t values[]);
1495
1496 /*
1497 * Using the symbol, look at the appropriate place in the
1498 * dictionary.
1499 */
1500 #ifdef DEBUG
1501 printf("\nca_set_int() function called .....\n");
1502 printf("Variable type: %s\n", dictionary[symbol].varType);
1503 #endif /* DEBUG */
1504
1505
1506 /*
1507 * Make sure that a reasonable, sensible value of bind-port has
1508 * been read from the keyboard.
1509 */
1510
1511 do {
1512
1513 /*
1514 * First, flush input stream.
1515 */
1516 fflush(stdin);
1517
1518 /*
1519 * Prompt for the new value of the bind-port.
1520 */
1521
1522 printf("\nNew value of bind-port (non-zero positive integer) >>> ");
1523 scanf("%s", newPort);
1524 /*
1525 * gets(newPort);
1526 */
1527 #ifdef DEBUG
1528 printf("\nDEBUG: Value of newPort variable: %s\n", newPort);
1529 #endif /* DEBUG */
1530
1531 sscanf(newPort, "%d", &portNr);
1532
1533 #ifdef DEBUG
1534 printf("\nDEBUG: Value of integer variable, portNr: %d\n", portNr);
1535 #endif /* DEBUG */
1536
1537 if (portNr < 0)
1538 {
1539 invalid = 1;
1540 puts("Only non-zero positive integer values accepted for bind-port");
1541 }
1542 else
1543 {
1544 invalid = 0;
1545 }
1546
1547 } while(invalid);
1548
1549 /*
1550 * Check that the function is attempting to set the correct type
1551 * of value. If not, do not set the value and exit.
1552 */
1553
1554 if (strcmp(dictionary[symbol].varType, "CA_INT") != 0)
1555 {
1556 fprintf(stderr, "Error: unexpected variable type.\n");
1557 die;
1558 }
1559
1560 /*
1561 * Choose the appropriate values array.
1562 */
1563 switch(dictionary[symbol].varScope)
1564 {
1565 /* If the variable has global scope,
1566 * write it into the globals array.
1567 * If it has local scope,
1568 * write it into the local array.
1569 * If the scope cannot be found, then report an error.
1570 */
1571 case 1:
1572 globals[symbol].valPtr = ca_change_int_value(newPort);
1573 globals[symbol].strPtr = newPort;
1574
1575 globals[symbol].strPtr = (char *)calloc(1,sizeof(newPort) );
1576
1577 /* Check the return value of malloc() to make sure that we
1578 * actually got the memory.
1579 */
1580 if (globals[symbol].strPtr == NULL)
1581 {
1582 fprintf(stderr, "Cannot allocate memory for globals[symbol].strPtr.\n");
1583 die;
1584 }
1585 #ifdef DEBUG
1586 printf("DEBUG: New value of StringPtr: %s\n", globals[symbol].strPtr);
1587 #endif /* DEBUG */
1588
1589 strcpy(globals[symbol].strPtr, newPort);
1590
1591 #ifdef DEBUG
1592 printf("DEBUG 2: New value of StringPtr: %s\n", globals[symbol].strPtr);
1593 #endif /* DEBUG */
1594 break;
1595
1596 case 99:
1597 locals[symbol].valPtr = ca_change_int_value(newPort);
1598 /*
1599 * First allocate some memory and then copy the value of the new
1600 * Port into it.
1601 */
1602 locals[symbol].strPtr = (char *)calloc(1,sizeof(newPort) );
1603 /*
1604 * Now, check that the memory was actually allocated.
1605 */
1606 if (locals[symbol].strPtr == NULL)
1607 {
1608 fprintf(stderr, "Cannot allocate memory for locals[symbol].strPtr\n");
1609 exit(8);
1610 }
1611
1612 strcpy(locals[symbol].strPtr, newPort);
1613 /*
1614 * locals[symbol].strPtr = newPort;
1615 */
1616 break;
1617
1618 default:
1619 fprintf(stderr, "Error; unknown scope: %d\n", dictionary[symbol].varScope);
1620 break;
1621 }
1622
1623 /*
1624 * Write the new value of the variable to the correct place in
1625 * this array. (First, set a mutex lock ???).
1626 */
1627
1628 /*
1629 * Write the new value of this variable back to the config. file
1630 */
1631
1632 ca_writeNewValue(symbol, newPort);
1633
1634 printf("DEBUG 3: New value of StringPtr: %s\n", globals[symbol].strPtr);
1635
1636 }
1637
1638 int *ca_change_int_value(char value[])
/* [<][>][^][v][top][bottom][index][help] */
1639 {
1640 void *tempPtr;
1641
1642 /*
1643 * Check the return value of malloc() in case we did not actually get
1644 * the memory.
1645 */
1646 tempPtr = malloc(sizeof(int) );
1647 if (tempPtr == NULL)
1648 {
1649 fprintf(stderr, "Cannot allocate memory for tempPtr\n");
1650 die;
1651 }
1652
1653 sscanf(value, "%d", (int *) tempPtr);
1654 return(tempPtr);
1655 }
1656
1657
1658
1659 void testFunction(values_t array[])
/* [<][>][^][v][top][bottom][index][help] */
1660 {
1661 printf("\nInside the Test function.\n");
1662 }
1663
1664
1665 void ca_getDatabase(ca_database_t db)
/* [<][>][^][v][top][bottom][index][help] */
1666 {
1667 printf("\n%s\t%s\t%s\t%s\t%s\n", db.host, db.port, db.user, db.password, db.dbName);
1668 }
1669
1670 void ca_getSource(ca_database_list_t src)
/* [<][>][^][v][top][bottom][index][help] */
1671 {
1672 printf("\n%s\t%s\t%s\t%s\t%s\t%s\n", src.name, (src.db).host, (src.db).port, (src.db).user, (src.db).password, (src.db).dbName);
1673 }
1674
1675
1676 void ca_getAllSources(GSList *sources)
/* [<][>][^][v][top][bottom][index][help] */
1677 {
1678
1679 GSList *currentPtr; /* Pointer to the structure at which we look. */
1680
1681 /*
1682 * Look at the first member of the linked-list of sources.
1683 */
1684 currentPtr = sources;
1685
1686 /*
1687 * Look at each data component of the source list,
1688 * untill we reach the end of the list.
1689 */
1690 while(currentPtr != NULL)
1691 {
1692 ca_database_list_t *srcPtr = currentPtr->data;
1693 printf("\n%s\t%s\t%d\t%s\t%s\t%s\n", srcPtr->name, (srcPtr->db).host, (srcPtr->db).port, (srcPtr->db).user, (srcPtr->db).password, (srcPtr->db).dbName);
1694 currentPtr = currentPtr->next;
1695 }
1696 }
1697
1698 void ca_getAsource(char *sourceName, GSList *sources)
/* [<][>][^][v][top][bottom][index][help] */
1699 /*******************************************************************
1700 * ca_getAsource -- looks for a source in the linked list *
1701 * *
1702 * Parameters *
1703 * sourceName -- the name of a source for which to look *
1704 * sources -- the list of sources in which to look *
1705 * *
1706 * Returns *
1707 * nothing, so far. *
1708 * *
1709 *******************************************************************/
1710 {
1711
1712 GSList *currentPtr = sources;
1713
1714 #ifdef DEBUG
1715 printf("\nLooking for source: %s\n", sourceName);
1716 #endif /* DEBUG */
1717
1718 /*
1719 * Look at each data component of the source list,
1720 * compare the name of the source with the sourceName
1721 * untill we find the source o we reach the end of the list
1722 */
1723 { /* Begin special block
1724 * I got a syntax error when I defined
1725 * "ca_database_list_t *srcPtr = currentPtr->data;"
1726 * in the usual way, with all the other local variables.
1727 *
1728 * However, if I define it inside this block, I do not
1729 * get any syntax errors.
1730 *
1731 */
1732
1733
1734 ca_database_list_t *srcPtr = currentPtr->data;
1735 #ifdef DEBUG
1736 printf("FirstSource is: %s\n", srcPtr->name);
1737 #endif /* DEBUG */
1738 while( (currentPtr != NULL) && ( strcmp(srcPtr->name, sourceName) != 0 ) )
1739 {
1740 #ifdef DEBUG
1741 puts("Now printing the current source .....");
1742 printf("CurrentSource is: %s\n", srcPtr->name);
1743 printf("%d\n", strcmp(srcPtr->name, sourceName) );
1744 if ( strcmp(srcPtr->name, sourceName) == 0 )
1745 {
1746 printf("Found it !!! Source: %s\n", srcPtr->name);
1747 }
1748 #endif /* DEBUG */
1749 currentPtr = currentPtr->next;
1750 puts("currentPtr = currentPtr->next");
1751 if (currentPtr != NULL)
1752 {
1753 srcPtr = currentPtr->data;
1754 puts("srcPtr = currentPtr->data");
1755 }
1756 #ifdef DEBUG
1757 puts("At the end of the while loop inside ca_getAsource function .....");
1758 printf("The NewSource is: %s\n", srcPtr->name);
1759 #endif /* DEBUG */
1760 }
1761 #ifdef DEBUG
1762 puts("Exited from while loop in ca_getAsource function .....");
1763 #endif /* DEBUG */
1764
1765 if (currentPtr != NULL)
1766 {
1767 printf("\nFound the source: %s\n", srcPtr->name);
1768 /* printf("\n%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", srcPtr->name, (srcPtr->db).host, (srcPtr->db).port, (srcPtr->db).user, (srcPtr->db).password, (srcPtr->db).canupd, (srcPtr->db).deflook, (srcPtr->db).dbName);
1769 */
1770 }
1771 else
1772 {
1773 printf("\nCould not find source: %s\n", sourceName);
1774 }
1775 } /* End special block */
1776
1777 }
1778
1779
1780 ca_dbSource_t *ca_getSourceDetails(char *sourceName, GSList *sources)
/* [<][>][^][v][top][bottom][index][help] */
1781 /*******************************************************************
1782 * ca_getSourceDetails *
1783 * -- A function that compares each 'name' component of every *
1784 * ca_database_list_t element in the linked-list of sources *
1785 * (the first element of which is a parameter of this function)*
1786 * with the name of the source to be found. If the required *
1787 * source is found, a pointer to the structure representing *
1788 * this source is returned. *
1789 * *
1790 * Parameters *
1791 * -- sourceName - the name of the required source *
1792 * -- sources - the list of sources in which to look *
1793 * *
1794 * Returns *
1795 * -- srcPtr - a pointer to the structure representing the source *
1796 * - or a pointer to NULL, if we cannot find the source *
1797 * *
1798 *******************************************************************/
1799 {
1800 /*
1801 * Define a pointer to the current element in the linked list.
1802 * Initialise it to the start of the list;
1803 */
1804 GSList *currentPtr = sources;
1805
1806 /*
1807 * Define and initialise a pointer that points to the 'data'
1808 * component of the GSList struct; i.e. a pointer to a
1809 * variable of type ca_dbSource_t.
1810 */
1811 ca_dbSource_t *srcPtr = currentPtr->data;
1812
1813
1814 /*
1815 * Look at each data component of list of sources;
1816 * (each data component is a structure of type ca_dbSource_t
1817 * i.e. ca_database_list_t). Compare the 'name' component of
1818 * of each ca_dbSource_t structure with the value of sourceName
1819 * untill we get a match or we reach the end of the list.
1820 */
1821 /*
1822 * We first check if currentPtr is pointing to NULL;
1823 * if yes, we exit the while loop;
1824 * if no, we make srcPtr point to the data component
1825 * of the current dbSource structure;
1826 * then, we check if this is the source name that we want;
1827 * if yes, we _break_ from the while loop.
1828 */
1829 while (currentPtr != NULL)
1830 {
1831 srcPtr = currentPtr->data;
1832 if (strcmp(srcPtr->name, sourceName) == 0 )
1833 break;
1834 currentPtr = currentPtr->next;
1835 }
1836
1837 /*
1838 * We return a pointer. If we found the source, this pointer points
1839 * to the ca_dbSource_t structure which represents the source.
1840 * If we did not find the source, we return a pointer to NULL.
1841 */
1842 if (currentPtr == NULL)
1843 {
1844 srcPtr = NULL;
1845 return(srcPtr);
1846 }
1847 else
1848 {
1849 return(srcPtr);
1850 }
1851
1852 } /* End of ca_getSourceDetails function */
1853
1854
1855 ca_SrcHdl_t *ca_get_SourceHandleByPosition(int position)
/* [<][>][^][v][top][bottom][index][help] */
1856 /*******************************************************************
1857 * ca_get_SourceHandleByPosition *
1858 * -- retrieves the a handle to a Source *
1859 * *
1860 * Parameters *
1861 * -- the position in the linked list of sources *
1862 * *
1863 * *
1864 * Returns *
1865 * -- a pointer to the source or NULL *
1866 * i.e. a pointer to the data component of the appropriate *
1867 * element in the linked list of sources. *
1868 *******************************************************************/
1869 {
1870 ca_dbSource_t * mySource;
1871
1872 mySource = g_slist_nth_data(sourceList, position);
1873 return(mySource);
1874 }
1875
1876 ca_SrcHdl_t *ca_get_SourceHandleByName(char *srcName)
/* [<][>][^][v][top][bottom][index][help] */
1877 /*******************************************************************
1878 * ca_get_SourceHandleByName *
1879 * -- retrieves the a handle to a source *
1880 * *
1881 * Parameters *
1882 * -- the name of the required source
1883 * *
1884 * *
1885 * Returns *
1886 * -- a pointer to the source or NULL *
1887 * i.e. a pointer to the data component of the appropriate *
1888 * element in the linked list of sources. *
1889 *******************************************************************/
1890
1891 {
1892 ca_dbSource_t * mySource;
1893
1894 mySource = ca_getSourceDetails(srcName, sourceList);
1895 return(mySource);
1896 }
1897
1898 char *ca_srchandle2Strelement(ca_SrcHdl_t *ah, int srcAttrib)
/* [<][>][^][v][top][bottom][index][help] */
1899 /*******************************************************************
1900 * ca_srchandle2Strelement *
1901 * -- returns a string which represents the attribute of a source *
1902 * e.g. returns the name of a source *
1903 * It allocates the required memory; *
1904 * but it returns NULL if the required memory cannot be *
1905 * allocated.
1906 * *
1907 * Parameters *
1908 * -- source name - the name of the source
1909 * ca_get_SourceHandleByName or ca_get_SourceHandleByPosition *
1910 * *
1911 * -- srcAttrib - an integer which represents the required *
1912 * attribute of the source. We use #define statments to make *
1913 * a mapping between the attributes and the integers. *
1914 * *
1915 * Returns *
1916 * -- a string or NULL *
1917 *******************************************************************/
1918 {
1919 char *myStr;
1920 void ca_malloc(char *, int);
1921
1922 if(ah == NULL)
1923 {
1924 fprintf(stderr, "ca_srchandle2Strelement(): Cannot dereference NULL pointer\n");
1925 die;
1926 }
1927
1928 switch(srcAttrib)
1929 {
1930 case 0:
1931 /* source name */
1932 myStr = strdup(ah->name);
1933 break;
1934
1935 case 1:
1936 /* canupd */
1937 myStr = strdup(ah->canupd);
1938 break;
1939
1940 case 2:
1941 /* deflook */
1942 /*
1943 * ca_malloc(myStr, 2);
1944 * strcpy(myStr, (ah->db).deflook);
1945 */
1946 myStr = strdup(ah->deflook);
1947 break;
1948
1949 case 3:
1950 /* machine */
1951 myStr = strdup((ah->db).host);
1952 break;
1953
1954 case 5:
1955 /* user */
1956 myStr = strdup((ah->db).user);
1957 break;
1958
1959 case 6:
1960 /* password */
1961 myStr = strdup((ah->db).password);
1962 break;
1963
1964 case 7:
1965 /* dbName */
1966 myStr = strdup((ah->db).dbName);
1967 break;
1968
1969 case 9:
1970 /* Near-Real-Time Mirror host */
1971 myStr = strdup((ah->nrtm).host);
1972 break;
1973
1974 case 11:
1975 /* NRTM Log */
1976 myStr = strdup((ah->nrtm).log);
1977 break;
1978
1979 default:
1980 puts("Cannot find this source attribute");
1981 break;
1982 }
1983
1984 return(myStr);
1985 }
1986
1987 int ca_srchandle2Intelement(ca_SrcHdl_t *ah, int srcAttrib)
/* [<][>][^][v][top][bottom][index][help] */
1988 /*******************************************************************
1989 * ca_srchandle2Intelement *
1990 * -- a function that returns the integer value of the requested *
1991 * attribute of the given source. *
1992 * *
1993 * Parameters *
1994 * -- source name - the name of the source
1995 * ca_get_SourceHandleByName or ca_get_SourceHandleByPosition *
1996 * *
1997 * -- srcAttrib - an integer which represents the required *
1998 * attribute of the source. We use #define statments to make *
1999 * a mapping between the attributes and the integers. *
2000 * *
2001 * Returns *
2002 * -- an integer.
2003 *******************************************************************/
2004 {
2005 int myInt; /* The value of this integer is returned. */
2006
2007 if(ah == NULL)
2008 {
2009 fprintf(stderr, "ca_srchandle2Intelement(): Cannot dereference NULL pointer\n");
2010 die;
2011 }
2012
2013 switch(srcAttrib)
2014 {
2015
2016 case 4:
2017 /* DB Port */
2018 myInt = (ah->db).port;
2019 break;
2020
2021 case 8:
2022 /* Mode of Operation of the Source. */
2023 myInt = ah->opMode;
2024 break;
2025
2026 case 10:
2027 /* Near-Real-Time Mirror port */
2028 myInt = (ah->nrtm).port;
2029 break;
2030
2031 case 12:
2032 /* NRTM Delay */
2033 myInt = (ah->nrtm).delay;
2034 break;
2035
2036 case 13:
2037 /* NRTM Protocol Version. */
2038 myInt = (ah->nrtm).protocolVer;
2039 break;
2040
2041 case 14:
2042 /* Source Update Port */
2043 myInt = ah->updPort;
2044 break;
2045
2046 default:
2047 fprintf(stderr, "Could not find source-attribute %d\n", srcAttrib);
2048 die;
2049 break;
2050 }
2051
2052 return (myInt);
2053 }
2054
2055
2056 char *ca_get_adminStrElement(int symbol, int adminAttrib)
/* [<][>][^][v][top][bottom][index][help] */
2057 /*******************************************************************
2058 * ca_adminStrElement
2059 * -- returns a string which represents the attribute of a admin *
2060 * db
2061 * e.g. returns the name of a host machine. *
2062 * It allocates the required memory; *
2063 * but it returns NULL if the required memory cannot be *
2064 * allocated.
2065 * *
2066 * Parameters *
2067 * -- symbol - the symbol of the variable
2068 * *
2069 * -- adminAttrib - an integer which represents the required *
2070 * attribute of the Admin db. We use #define statements to *
2071 * make a mapping between the attributes and the integers. *
2072 * *
2073 * Returns *
2074 * -- a string or NULL *
2075 *******************************************************************/
2076 {
2077 char *myStr;
2078 void ca_malloc(char *, int);
2079
2080 /*
2081 * Make sure that we are calling the correct function.
2082 */
2083 if ( strcmp(dictionary[symbol].varType, "CA_ADMIN") != 0)
2084 {
2085 fprintf(stderr, "Error: unexpected variable type.\n");
2086 die;
2087 }
2088 else
2089 {
2090 mutex_lock(&Lock);
2091 switch(adminAttrib)
2092 {
2093 case 0:
2094 /* admin host */
2095 myStr = strdup( ((ca_ripadmin_t *)confVars[symbol].valPtr)->host);
2096 break;
2097
2098 case 2:
2099 /* User */
2100 myStr = strdup( ((ca_ripadmin_t *)confVars[symbol].valPtr)->user);
2101 break;
2102
2103 case 3:
2104 /* password */
2105 myStr = strdup( ((ca_ripadmin_t *)confVars[symbol].valPtr)->password);
2106 break;
2107
2108 case 4:
2109 /* tableName */
2110 myStr = strdup( ((ca_ripadmin_t *)confVars[symbol].valPtr)->tableName);
2111 break;
2112
2113 default:
2114 puts("Cannot find this admin attribute");
2115 die;
2116 break;
2117 }
2118 mutex_unlock(&Lock);
2119
2120 return(myStr);
2121 }
2122 }
2123
2124 int ca_get_adminIntElement(int symbol, int adminAttrib)
/* [<][>][^][v][top][bottom][index][help] */
2125 /*
2126 * Returns an int element of the admin db structure.
2127 */
2128 {
2129 int myInt; /* The value of this integer is returned. */
2130
2131 mutex_lock(&Lock);
2132 switch(adminAttrib)
2133 {
2134 case 1:
2135 /* Port number */
2136 myInt = ((ca_ripadmin_t *)confVars[symbol].valPtr)->port;
2137 break;
2138
2139 default:
2140 puts("Cannot find this admin attribute");
2141 die;
2142 break;
2143 }
2144 mutex_unlock(&Lock);
2145
2146 return(myInt);
2147 }
2148
2149 void ca_malloc(char *someStr, int memSize)
/* [<][>][^][v][top][bottom][index][help] */
2150 /*******************************************************************
2151 * ca_malloc *
2152 * -- a function that allocates memory for a string *
2153 * *
2154 * Parameters *
2155 * --someStr - the string that is to be created *
2156 * memSize- required amount of memory in bytes *
2157 * *
2158 * Returns *
2159 * -- nothing; it assigns the allocated memory to the pointer *
2160 * that was passed to it. *
2161 * *
2162 *******************************************************************/
2163 {
2164 someStr = malloc(memSize);
2165
2166 /*
2167 * Check that we actually did get the memory ....
2168 */
2169 if (someStr == NULL)
2170 {
2171 fprintf(stderr, "ca_malloc(): cannot allocate memory !!!\n");
2172 exit(8);
2173 }
2174 }
2175
2176 void ca_set_boolean(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
2177 {
2178 /*************************************************************
2179 * *
2180 * ca_set_boolean() *
2181 * *
2182 * *
2183 * Parameters *
2184 * *
2185 * symbol -- the symbol for the variable. *
2186 * *
2187 * *
2188 * Returns *
2189 * *
2190 * nothing *
2191 * *
2192 * *
2193 * Remarks *
2194 * *
2195 * Must check that a sensible value is given as input. *
2196 * *
2197 * *
2198 *************************************************************/
2199
2200
2201 char newTestmodeStr[2];
2202 int newTestmodeVal; /* The new value of the testmode variable. */
2203 int invalid; /* Flag to indicate an invalid new value. */
2204
2205 FILE *testPtr, *tempPtr; /* The pointer to the files. */
2206 char name[STRLENGTH]; /* The name of the variable. */
2207 char value[STRLENGTH]; /* The value of the variable. */
2208
2209 /*
2210 * Function to change the value in a given values array.
2211 * This function can only be called from within ca_set_boolean().
2212 */
2213 int *ca_change_int_value(char []);
2214
2215
2216 /*
2217 * Using the symbol, look at the appropriate place in the
2218 * dictionary.
2219 */
2220 #ifdef DEBUG
2221 printf("\nca_set_int() function called .....\n");
2222 printf("Variable type: %s\n", dictionary[symbol].varType);
2223 #endif /* DEBUG */
2224
2225 /*
2226 * Check that the function is attempting to set the correct type of
2227 * value. If not, do not set the value, but exit instead.
2228 */
2229
2230 if (strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0)
2231 {
2232 fprintf(stderr, "Error: CA_BOOLEAN data type expected.\n");
2233 die;
2234 }
2235
2236 /*
2237 * First, flush the input stream.
2238 */
2239 fflush(stdin);
2240
2241
2242 /*
2243 * Make sure that a reasonable, sensible value of bind-port has
2244 * been read from the keyboard.
2245 */
2246
2247 do {
2248 /*
2249 * Prompt for the new value of the testmode.
2250 */
2251
2252 printf("\nNew value of testmode (0 or 1) >>> ");
2253 scanf("%s", newTestmodeStr);
2254
2255 /*
2256 * We scanf() the value as a string, but we want it to be an
2257 * integer. Thus, we use sscanf() to scanf the value from the
2258 * string-variable and store it as an integer in an integer
2259 * variable.
2260 */
2261 sscanf(newTestmodeStr, "%d", &newTestmodeVal);
2262
2263 /*
2264 * We only change the testmode when the user is absolutely sure
2265 * that they want to change. Thus, we only accept two possible
2266 * values for testmode.
2267 */
2268
2269 if ( (newTestmodeVal < 0) || (newTestmodeVal > 1) )
2270 {
2271 invalid = 1;
2272 puts("Only '0' or '1' accepted as value for testmode.");
2273 }
2274 else
2275 {
2276 invalid = 0;
2277 }
2278 } while(invalid);
2279
2280
2281 /*
2282 * Lock the value of the variable before changing it.
2283 */
2284
2285 mutex_lock(&Lock);
2286
2287
2288 /*
2289 * Choose the appropriate values array.
2290 */
2291
2292 switch(dictionary[symbol].varScope)
2293 {
2294 /*
2295 * If the variable has global scope,
2296 * write it into the globals array.
2297 * If it has local scope,
2298 * write it into the local array.
2299 * If the scope cannot be found, then report an error.
2300 */
2301 case 1:
2302 globals[symbol].valPtr = ca_change_int_value(newTestmodeStr);
2303 globals[symbol].strPtr = newTestmodeStr;
2304 break;
2305
2306 case 99:
2307 locals[symbol].valPtr = ca_change_int_value(newTestmodeStr);
2308 locals[symbol].strPtr = newTestmodeStr;
2309 break;
2310
2311 default:
2312 fprintf(stderr, "Error: unknown scope: %d\n", dictionary[symbol].varScope);
2313 break;
2314 }
2315
2316 /*
2317 * Write the new value of this variable back to the config file.
2318 *
2319 * To be implemented.
2320 */
2321
2322 /*
2323 * Find the actual name of the variable from the dictionary
2324 * structure (use the variable symbol as an index into the
2325 * array of dictionary structures.
2326 */
2327
2328 printf("Name of variable to be changed: %s\n", dictionary[symbol].varName);
2329 printf("Type of variable to be changed: %s\n", dictionary[symbol].varType);
2330
2331 /*
2332 * Open the test config file for reading .....
2333 */
2334 if ( (testPtr = fopen(testFile, "r")) == NULL)
2335 {
2336 printf("File \"%s\" could not be opened.\n", testFile);
2337 die;
2338 }
2339
2340 /*
2341 * Open the temporary file for writing .....
2342 */
2343 if ((tempPtr = fopen(tempFile, "w")) == NULL)
2344 {
2345 printf("File \"%s\" could not be opened.\n", tempFile);
2346 die;
2347 }
2348
2349 /*
2350 * Read the first record in the test config file.
2351 */
2352
2353 fscanf(testPtr, "%s", name);
2354 fgets(value, sizeof(value), testPtr);
2355
2356 /*
2357 * If the last character of "value" is '\n',
2358 * replace it with '\0'.
2359 */
2360 if (value[strlen(value) - 1] == '\n')
2361 {
2362 printf("The value string is %s", value);
2363 printf("Replacing last character of \"%s\" with the NULL character\n", name);
2364 value[strlen(value) - 1] = '\0';
2365 printf("The new value string is %s", value);
2366 }
2367
2368
2369 /*
2370 * While there are records to be read in the test config file:
2371 * Write the current record into the temporary file.
2372 * Read the next record in the config file.
2373 * Repeat untill the EOF has been reached.
2374 */
2375
2376 while(!feof(testPtr) )
2377 {
2378 fprintf(tempPtr, "%s %s\n", name, value);
2379 fscanf(testPtr, "%s", name);
2380 fgets(value, sizeof(value), testPtr);
2381
2382 /*
2383 * If the last character of "value" is '\n',
2384 * replace it with '\0'.
2385 */
2386 if (value[strlen(value) - 1] == '\n')
2387 {
2388 printf("The last character of the value string is %c", value[strlen(value) - 1]);
2389 printf("The value string is %s", value);
2390 printf("Replacing last character of \"%s\" with the NULL character\n",name);
2391 value[strlen(value) - 1] = '\0';
2392 printf("The new value string is %s", value);
2393 }
2394
2395
2396 /*
2397 * if we read the variable that we want to change,
2398 * stop reading this file and print only the name
2399 * of this variable to the temporary file.
2400 */
2401
2402 /*
2403 * If we read the variable that we want to change,
2404 * replace the value of this variable in the config
2405 * file with the value supplied from the keyboard.
2406 *
2407 */
2408 if ( strcmp(name, dictionary[symbol].varName) == 0)
2409 {
2410 strcpy(value, newTestmodeStr);
2411 printf("The replacement string is %s", value);
2412 }
2413 /*
2414 * Flush the pointer to the test config file.
2415 */
2416 fflush(testPtr);
2417
2418 }
2419 /*
2420 * Here ends the loop that writes the config file, with the
2421 * new variable, to the temporary file.
2422 */
2423
2424 /*
2425 *
2426 * While !(the record to be updated)
2427 * BEGIN
2428 * Write the record to the temporary file
2429 * Read the next record in the config file
2430 * END
2431 *
2432 * Write the new value to the temporary file
2433 * Read the next record in the config file
2434 * COMMENT: this is the record to be updated.
2435 * COMMENT: discard this record.
2436 *
2437 * Read the next record in the config file
2438 *
2439 * While !(EOF)
2440 * BEGIN
2441 * write the record to the temporary file
2442 * read the next record in the config file
2443 * END
2444 *
2445 * Close Config file
2446 * Close Temporary file
2447 *
2448 * Open Temporary file for reading
2449 * Open Config file for writing
2450 *
2451 * Read the next record of the Temporary file
2452 *
2453 * While (!EOF of Temporary file)
2454 * BEGIN
2455 * write the record into the Config file
2456 * read the next record of the Temporary file
2457 * END
2458 *
2459 * Close Temporary file
2460 * Close Config file
2461 *
2462 */
2463
2464 fclose(testPtr);
2465 fclose(tempPtr);
2466
2467 /*
2468 * Now, flush the file pointers
2469 */
2470 fflush(testPtr);
2471 fflush(tempPtr);
2472
2473 /*
2474 * Open the temporary file for reading.
2475 * Open the config file for writing.
2476 * Write the contents of the temporary file
2477 * into the config file.
2478 */
2479
2480 /*
2481 * Open the temporary file for reading .....
2482 */
2483 if ((tempPtr = fopen(tempFile, "r")) == NULL)
2484 {
2485 printf("File \"%s\" could not be opened for reading.\n", tempFile);
2486 die;
2487 }
2488
2489 /*
2490 * Open the config file for writing .....
2491 */
2492 if ((testPtr = fopen(testFile, "w")) == NULL)
2493 {
2494 printf("File \"%s\" could not be opened for writing.\n", testFile);
2495 die;
2496 }
2497
2498 /*
2499 * Read the first record in the temporary file.
2500 */
2501
2502 fscanf(tempPtr, "%s", name);
2503 fgets(value, sizeof(value), tempPtr);
2504 printf("\nFIRST LINE: %s %s", name, value);
2505
2506
2507 /*
2508 * While there are records to be read in the temporary file:
2509 * Write the current record into the test config file.
2510 * Read the next record in the temporary file.
2511 * Repeat untill the EOF has been reached.
2512 */
2513
2514 while(!feof(tempPtr) )
2515 {
2516 fprintf(testPtr, "%s %s", name, value);
2517 fscanf(tempPtr, "%s", name);
2518 fgets(value, sizeof(value), tempPtr);
2519 }
2520
2521 fclose(testPtr);
2522 fclose(tempPtr);
2523
2524 /*
2525 * Unlock the value of the variable after setting it and writing the
2526 * new value back to the configuration (and the dictionary) file.
2527 *
2528 */
2529 mutex_unlock(&Lock);
2530
2531 }
2532
2533
2534 void ca_set_dirlist(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
2535 {
2536 /****************************************************************
2537 * ca_set_dirlist() *
2538 * *
2539 * Parameters *
2540 * symbol -- the symbol of the variable. *
2541 * *
2542 * Returns *
2543 * 1 if successful, 0 if not successful. *
2544 * *
2545 * Remarks *
2546 * Writing the new value back to the config file has yet to *
2547 * be implemented. *
2548 * *
2549 ****************************************************************/
2550
2551 char newDir[80];
2552 /*
2553 * Declare a pointer to a values_t variable.
2554 * Later, we shall assign this pointer to the first element
2555 * of either the globals or the locals array, as appropriate.
2556 */
2557 values_t *hereValues;
2558
2559 /*
2560 * Using the symbol, look in the appropriate place in the dictionary.
2561 */
2562 #ifdef DEBUG
2563 printf("\nca_set_dirlist() function called ..... \n");
2564 printf("Variable type: %s\n", dictionary[symbol].varType);
2565 #endif
2566
2567 /*
2568 * First, flush the input stream.
2569 */
2570 fflush(stdin);
2571
2572 /*
2573 * Prompt for the new value of the directory.
2574 */
2575 printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName);
2576 scanf("%s", newDir);
2577
2578 /*
2579 * Make sure that a reasonable, sensible value of the directory
2580 * value has been read from the keyboard.
2581 *
2582 * How do we implement this ???
2583 *
2584 */
2585
2586
2587 /*
2588 * Make sure that the function is attempting to set the correct type
2589 * of value. If not, do not set the value - and exit.
2590 */
2591
2592 if (strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0)
2593 {
2594 fprintf(stderr, "Error: unexpected variable type.\n");
2595 exit(51);
2596 }
2597
2598 /*
2599 * Choose the appropriate values array.
2600 * Assign a temporary pointer to this array.
2601 */
2602
2603 switch(dictionary[symbol].varScope)
2604 {
2605 /* If the variable has global scope,
2606 * write it into the globals array.
2607 * If it has local scope,
2608 * write it into the locals array.
2609 * If the scope cannot be found, report an error.
2610 */
2611 case 1:
2612 hereValues = globals;
2613 break;
2614
2615 case 99:
2616 hereValues = locals;
2617 break;
2618
2619 default:
2620 fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope);
2621 break;
2622 }
2623
2624
2625 /*
2626 * Check for the presence of the mutex lock:
2627 * if present,
2628 * wait until it is available;
2629 * else
2630 * get the lock and proceed with the change of value.
2631 */
2632
2633 /*
2634 * Write the new value of the variable to the correct place
2635 * in the [appropriate] values array.
2636 *
2637 * Note that there is a check to see if malloc() actually worked .....
2638 */
2639
2640 hereValues[symbol].valPtr = (char *)malloc(80);
2641 if (hereValues[symbol].valPtr == NULL)
2642 {
2643 fprintf(stderr, "Cannot alllocate memory for hereValuesvlPtr\n");
2644 die;
2645 }
2646 strcpy(hereValues[symbol].valPtr,newDir);
2647
2648
2649 hereValues[symbol].strPtr = (char *)malloc(sizeof(newDir) );
2650 if (hereValues[symbol].strPtr == NULL)
2651 {
2652 fprintf(stderr, "Cannot alllocate memory for hereValuestPtr\n");
2653 die;
2654 }
2655 strcpy(hereValues[symbol].strPtr, newDir);
2656
2657 /*
2658 * Free the temporary pointer, hereValues.
2659 *
2660 */
2661 free(hereValues);
2662 hereValues = NULL;
2663
2664 /*
2665 * Release the mutex lock.
2666 */
2667
2668 /*
2669 * Write the new value of this variable back to the config file.
2670 */
2671
2672 }
2673
2674
2675 void ca_set_string(int symbol)
/* [<][>][^][v][top][bottom][index][help] */
2676 {
2677
2678 /****************************************************************
2679 * ca_set_string() *
2680 * *
2681 * Parameters *
2682 * symbol -- the symbol of the variable. *
2683 * *
2684 * Returns *
2685 * 1 if successful, 0 if not successful ? *
2686 * *
2687 * Remarks *
2688 * Writing the new value back to the config file has yet to *
2689 * be implemented. *
2690 * *
2691 ****************************************************************/
2692
2693 char newString[80]; /* May need to make this bigger. */
2694
2695 /*
2696 * Declare a pointer to a values_t variable.
2697 * Later, we shall assign this pointer to the first element
2698 * of either the globals or the locals array, as appropriate.
2699 */
2700 values_t *hereValues;
2701
2702 /*
2703 * Using the symbol, look in the appropriate place in the dictionary.
2704 */
2705 #ifdef DEBUG
2706 printf("\nca_set_string() function called ..... \n");
2707 printf("Variable type: %s\n", dictionary[symbol].varType);
2708 #endif
2709
2710 /*
2711 * First, flush the input stream.
2712 */
2713 fflush(stdin);
2714
2715 /*
2716 * Prompt for the new value of the string.
2717 */
2718 printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName);
2719 gets(newString);
2720
2721 /*
2722 * Make sure that a reasonable, sensible value of the string
2723 * value has been read from the keyboard.
2724 *
2725 * How do we implement this ???
2726 *
2727 */
2728
2729
2730 /*
2731 * Make sure that the function is attempting to set the correct type
2732 * of value. If not, do not set the value - and exit.
2733 */
2734
2735 if (strcmp(dictionary[symbol].varType, "CA_STRING") != 0)
2736 {
2737 fprintf(stderr, "Error: unexpected variable type.\n");
2738 exit(51);
2739 }
2740
2741 /*
2742 * Choose the appropriate values array.
2743 * Assign a temporary pointer to this array.
2744 */
2745
2746 switch(dictionary[symbol].varScope)
2747 {
2748 /* If the variable has global scope,
2749 * write it into the globals array.
2750 * If it has local scope,
2751 * write it into the locals array.
2752 * If the scope cannot be found, report an error.
2753 */
2754 case 1:
2755 hereValues = globals;
2756 break;
2757
2758 case 99:
2759 hereValues = locals;
2760 break;
2761
2762 default:
2763 fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope);
2764 break;
2765 }
2766
2767
2768 /*
2769 * Check for the presence of the mutex lock:
2770 * if present,
2771 * wait until it is available;
2772 * else
2773 * get the lock and proceed with the change of value.
2774 */
2775 mutex_lock(&Lock);
2776
2777 /*
2778 * Write the new value of the variable to the correct place
2779 * in the [appropriate] values array.
2780 * Note the check to the return value of malloc() to see if the
2781 * memory was actually obtained.
2782 */
2783
2784 hereValues[symbol].valPtr = (char *)malloc(80);
2785 if (hereValues[symbol].valPtr == NULL)
2786 {
2787 fprintf(stderr, "Cannot allocate memory for hereValues[symbol].valPtr\n");
2788 die;
2789 }
2790 strcpy(hereValues[symbol].valPtr, newString);
2791
2792
2793 hereValues[symbol].strPtr = (char *)malloc(sizeof(newString) );
2794 if (hereValues[symbol].strPtr == NULL)
2795 {
2796 fprintf(stderr, "Cannot allocate memory for hereValues[symbol].strPtr\n");
2797 die;
2798 }
2799 strcpy(hereValues[symbol].strPtr, newString);
2800
2801 /*
2802 * Free the temporary pointer, hereValues.
2803 *
2804 */
2805 free(hereValues);
2806 hereValues = NULL;
2807
2808 /*
2809 * Release the mutex lock.
2810 */
2811 mutex_unlock(&Lock);
2812
2813 /*
2814 * Write the new value of this variable back to the config file.
2815 * Implement this later ?
2816 */
2817
2818 }
2819
2820
2821 int ca_writeNewValue(int dictSymbol, char *newValue)
/* [<][>][^][v][top][bottom][index][help] */
2822 {
2823
2824 FILE *confPtr; /* Pointer to config file */
2825 FILE *tempPtr; /* The pointer to temp file. */
2826 char name[STRLENGTH]; /* The name of the variable. */
2827 char value[STRLENGTH]; /* The value of the variable. */
2828
2829
2830 /*
2831 * Find the actual name of the variable from the dictionary
2832 * structure (use the variable symbol as an index into the
2833 * array of dictionary structures.
2834 */
2835 #ifdef DEBUG
2836 printf("Name of variable to be changed: %s\n", dictionary[dictSymbol].varName);
2837 printf("Type of variable to be changed: %s\n", dictionary[dictSymbol].varType);
2838 #endif /* DEBUG */
2839
2840 /*
2841 * Open the test config file for reading .....
2842 */
2843 if ( (confPtr = fopen(testFile, "r")) == NULL)
2844 {
2845 printf("File \"%s\" could not be opened.\n", testFile);
2846 die;
2847 }
2848
2849 /*
2850 * Open the temporary file for writing .....
2851 */
2852 if ((tempPtr = fopen(tempFile, "w")) == NULL)
2853 {
2854 printf("File \"%s\" could not be opened.\n", tempFile);
2855 die;
2856 }
2857
2858 /*
2859 * Read the first record in the test config file.
2860 */
2861
2862 fscanf(confPtr, "%s", name);
2863 fgets(value, sizeof(value), confPtr);
2864
2865 /*
2866 * If the last character of "value" is '\n',
2867 * replace it with '\0'.
2868 */
2869 if (value[strlen(value) - 1] == '\n')
2870 {
2871 #ifdef DEBUG
2872 printf("The value string is %s", value);
2873 printf("Replacing last character of \"%s\" with the NULL character\n", name);
2874 #endif /* DEBUG */
2875
2876 value[strlen(value) - 1] = '\0';
2877
2878 #ifdef DEBUG
2879 printf("The new value string is %s", value);
2880 #endif /* DEBUG */
2881 }
2882
2883 /*
2884 * If we read the variable that we want to change,
2885 * replace the value of this variable in the config
2886 * file with the value supplied from the keyboard.
2887 *
2888 */
2889 if ( strcmp(name, dictionary[dictSymbol].varName) == 0)
2890 {
2891 strcpy(value, newValue);
2892
2893 #ifdef DEBUG
2894 printf("The replacement string is %s", value);
2895 #endif /* DEBUG */
2896 }
2897
2898 /*
2899 * While there are records to be read in the test config file:
2900 * Write the current record into the temporary file.
2901 * Read the next record in the config file.
2902 * Repeat untill the EOF has been reached.
2903 */
2904
2905 while(!feof(confPtr) )
2906 {
2907 fprintf(tempPtr, "%s %s\n", name, value);
2908 fscanf(confPtr, "%s", name);
2909 fgets(value, sizeof(value), confPtr);
2910
2911 /*
2912 * If the last character of "value" is '\n',
2913 * replace it with '\0'.
2914 */
2915 if (value[strlen(value) - 1] == '\n')
2916 {
2917 #ifdef DEBUG
2918 printf("The last character of the value string is %c", value[strlen(value) - 1]);
2919 printf("The value string is %s", value);
2920 printf("Replacing last character of \"%s\" with the NULL character\n",name);
2921 #endif /* DEBUG */
2922
2923 value[strlen(value) - 1] = '\0';
2924 #ifdef DEBUG
2925 printf("The new value string is %s", value);
2926 #endif /* DEBUG */
2927 }
2928
2929
2930 /*
2931 * If we read the variable that we want to change,
2932 * replace the value of this variable in the config
2933 * file with the value supplied from the keyboard.
2934 *
2935 */
2936 if ( strcmp(name, dictionary[dictSymbol].varName) == 0)
2937 {
2938 strcpy(value, newValue);
2939
2940 #ifdef DEBUG
2941 printf("The replacement string is %s", value);
2942 #endif /* DEBUG */
2943 }
2944
2945 /*
2946 * Flush the pointer to the test config file.
2947 */
2948 fflush(confPtr);
2949
2950 }
2951 /*
2952 * Here ends the loop that writes the config file, with the
2953 * new variable, to the temporary file.
2954 */
2955
2956 /*
2957 *
2958 * While !(the record to be updated)
2959 * BEGIN
2960 * Write the record to the temporary file
2961 * Read the next record in the config file
2962 * END
2963 *
2964 * Write the new value to the temporary file
2965 * Read the next record in the config file
2966 * COMMENT: this is the record to be updated.
2967 * COMMENT: discard this record.
2968 *
2969 * Read the next record in the config file
2970 *
2971 * While !(EOF)
2972 * BEGIN
2973 * write the record to the temporary file
2974 * read the next record in the config file
2975 * END
2976 *
2977 * Close Config file
2978 * Close Temporary file
2979 *
2980 * Open Temporary file for reading
2981 * Open Config file for writing
2982 *
2983 * Read the next record of the Temporary file
2984 *
2985 * While (!EOF of Temporary file)
2986 * BEGIN
2987 * write the record into the Config file
2988 * read the next record of the Temporary file
2989 * END
2990 *
2991 * Close Temporary file
2992 * Close Config file
2993 *
2994 */
2995
2996 fclose(confPtr);
2997 fclose(tempPtr);
2998
2999 /*
3000 * Now, flush the file pointers
3001 */
3002 fflush(confPtr);
3003 fflush(tempPtr);
3004
3005 /*
3006 * Open the temporary file for reading.
3007 * Open the config file for writing.
3008 * Write the contents of the temporary file
3009 * into the config file.
3010 */
3011
3012 /*
3013 * Open the temporary file for reading .....
3014 */
3015 if ((tempPtr = fopen(tempFile, "r")) == NULL)
3016 {
3017 printf("File \"%s\" could not be opened for reading.\n", tempFile);
3018 die;
3019 }
3020
3021 /*
3022 * Open the config file for writing .....
3023 */
3024 if ((confPtr = fopen(testFile, "w")) == NULL)
3025 {
3026 printf("File \"%s\" could not be opened for writing.\n", testFile);
3027 die;
3028 }
3029
3030 /*
3031 * Read the first record in the temporary file.
3032 */
3033
3034 fscanf(tempPtr, "%s", name);
3035 fgets(value, sizeof(value), tempPtr);
3036 #ifdef DEBUG
3037 printf("\nFIRST LINE: %s %s", name, value);
3038 #endif /* DEBUG */
3039
3040 /*
3041 * While there are records to be read in the temporary file:
3042 * Write the current record into the test config file.
3043 * Read the next record in the temporary file.
3044 * Repeat untill the EOF has been reached.
3045 */
3046
3047 while(!feof(tempPtr) )
3048 {
3049 fprintf(confPtr, "%s %s", name, value);
3050 fscanf(tempPtr, "%s", name);
3051 fgets(value, sizeof(value), tempPtr);
3052 }
3053
3054 fclose(confPtr);
3055 fclose(tempPtr);
3056 unlink(tempFile);
3057
3058 return(0);
3059 }
3060
3061
3062 int ca_getStorageLocation(char *confVar, dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
3063 /*************************************************************
3064 * ca_getStorageLocation() *
3065 * - takes the name of a config variable and searches the *
3066 * dictionary structure for the storage location for this *
3067 * variable. *
3068 * *
3069 * Parameters *
3070 * confVar -- the string variable that contains the name *
3071 * of the variable. *
3072 * woordenboek -- the dictionary structure to be searched *
3073 * size -- the size of the dictionary structure to *
3074 * searched. *
3075 * *
3076 * Returns *
3077 * the location (integer) in the values array. *
3078 * *
3079 *************************************************************/
3080 {
3081 int i,
3082 where,
3083 found = 0 ; /* Whether or not the symbol has been found. */
3084
3085
3086 #ifdef DEBUG
3087 printf("The variable name in ca_getStorageLocation is: %s\n", confVar);
3088 #endif /* DEBUG */
3089
3090 /*
3091 * Compares each name in the dictionary with the one for which
3092 * we are looking.
3093 */
3094 i = 0;
3095 while (!found && i < size)
3096 {
3097 if (strcmp(woordenboek[i].varName, confVar) == 0)
3098 {
3099 found = 1;
3100 }
3101 else
3102 {
3103 ++i;
3104 }
3105 }
3106
3107 /*
3108 * Returns the storage location for the given variable name
3109 * or else returns NOT_FOUND
3110 */
3111 if (found)
3112 {
3113 /* mySymbol = atoi(woordenboek[i].varSym); */
3114 #ifdef DEBUG
3115 printf("Symbol is %s\n", woordenboek[i].varSym);
3116 printf("Storage Location is: %d\n", woordenboek[i].varNum);
3117 #endif /* DEBUG */
3118 where = woordenboek[i].varNum;
3119 }
3120 else
3121 {
3122 fprintf(stderr, "Error: cannot find storage location for variable %s\n", confVar);
3123 where = NOT_FOUND;
3124 }
3125 return (where);
3126
3127 }
3128
3129
3130 void ca_getConfig(values_t confVars[], int size)
/* [<][>][^][v][top][bottom][index][help] */
3131 /*************************************************************
3132 * ca_getConfig -- prints the strings representing the *
3133 * values of the configuration variables *
3134 * *
3135 * Parameters *
3136 * confVars -- the values_t array which stores the *
3137 * values of the configuration variables. *
3138 * size -- the number of configuration variables, *
3139 * the number of elements in the confVars array *
3140 * *
3141 * *
3142 *************************************************************/
3143 {
3144 int i = 0; /* A counting variable. */
3145
3146 puts("A dump of the strings of the values of the Config Vars:");
3147 puts("Number\t\tString");
3148 puts("----------");
3149
3150 while (i < size)
3151 {
3152 printf("%d\t\t%s\n", i, confVars[i].strPtr);
3153 ++i;
3154 }
3155
3156 }
3157
3158
3159 int ca_getType(char *confVar, dict_t woordenboek[], int size)
/* [<][>][^][v][top][bottom][index][help] */
3160 /****************************************************************
3161 * ca_getType -- returns the data type of the variable. *
3162 * *
3163 * Parameters *
3164 * confVar -- the name of the configuration variable. *
3165 * woordenboek -- the array of dict_t structures. *
3166 * size -- the number of configuration variables. *
3167 * *
3168 * Returns *
3169 * an integer representing the data type of the variable *
3170 * *
3171 ****************************************************************/
3172 {
3173 int i = 0, /* Counter variable. */
3174 found = 0; /* Set this == 1 when we find the variable. */
3175 int myType; /* Integer representing the type of the config variable. */
3176
3177 /*
3178 * Compare each name in the dictionary with the one for which we
3179 * are looking.
3180 */
3181
3182 myType = 0;
3183
3184 #ifdef DEBUG
3185 printf("ca_getType function called for variable: %s\n", confVar);
3186 #endif /* DEBUG */
3187
3188 while (!found && i <= size)
3189 {
3190 if (strcmp(woordenboek[i].varName, confVar) == 0)
3191 {
3192 found = 1;
3193 #ifdef DEBUG
3194 printf("ca_getType function: %s, %s matched.\n", woordenboek[i].varName, confVar);
3195 #endif /* DEBUG */
3196 }
3197 else
3198 {
3199 ++i;
3200 }
3201 }
3202
3203 /*
3204 * Return the type of the config variable or
3205 * else return "NOT FOUND".
3206 */
3207 if (found)
3208 {
3209 if(strcmp(woordenboek[i].varType, "CA_INT") == 0)
3210 {
3211 #ifdef DEBUG
3212 printf("ca_getType function: %s variable of type %s is Integer type\n", woordenboek[i].varName, woordenboek[i].varType);
3213
3214 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
3215 #endif /* DEBUG */
3216 myType = 11;
3217 #ifdef DEBUG
3218 printf("For type CA_INT, myType is %d\n", myType);
3219 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
3220 #endif /* DEBUG */
3221 }
3222 else
3223 {
3224 if(strcmp(woordenboek[i].varType, "CA_STRING") == 0)
3225 {
3226 #ifdef DEBUG
3227 printf("ca_getType function: %s variable of type %s is String type\n", woordenboek[i].varName, woordenboek[i].varType);
3228 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
3229 #endif /* DEBUG */
3230 myType = 12;
3231 #ifdef DEBUG
3232 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
3233 #endif /* DEBUG */
3234 }
3235 else
3236 {
3237 if (strcmp(woordenboek[i].varType, "CA_DIRLIST") == 0 )
3238 {
3239 #ifdef DEBUG
3240 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
3241 #endif /* DEBUG */
3242 myType = 13;
3243 #ifdef DEBUG
3244 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
3245 #endif /* DEBUG */
3246 }
3247 else
3248 {
3249 if (strcmp(woordenboek[i].varType, "CA_BOOLEAN") == 0)
3250 {
3251 #ifdef DEBUG
3252 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
3253 #endif /* DEBUG */
3254 myType = 14;
3255 #ifdef DEBUG
3256 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
3257 #endif /* DEBUG */
3258 }
3259 else
3260 {
3261 if (strcmp(woordenboek[i].varType, "CA_SOURCETYPE") == 0)
3262 {
3263 #ifdef DEBUG
3264 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
3265 #endif /* DEBUG */
3266 myType = 15;
3267 #ifdef DEBUG
3268 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
3269 #endif /* DEBUG */
3270 }
3271 else
3272 {
3273 if (strcmp(woordenboek[i].varType, "CA_ADMIN") == 0)
3274 {
3275 #ifdef DEBUG
3276 printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
3277 #endif /* DEBUG */
3278 myType = 16;
3279 #ifdef DEBUG
3280 printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
3281 #endif /* DEBUG */
3282
3283 }
3284 }
3285 }
3286 }
3287 }
3288 }
3289 }
3290 else
3291 {
3292 myType = NOT_FOUND;
3293 }
3294 return(myType);
3295 }