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