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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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[])
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[])
1666 | {
1667 | printf("\nInside the Test function.\n");
1668 | }
1669 |
1670 |
1671 | void ca_getDatabase(ca_database_t db)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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 | }