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