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