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