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