1 | #include <stdio.h>
2 | #include <stdlib.h>
3 | #include <glib.h>
4 | #include "ca_defs.h"
5 | #define DEBUG
6 |
7 | void stringPack(char *dest, const char *source)
8 | {
9 | #ifdef DEBUG
10 | printf("\nInside stringPack function\n");
11 | #endif /* DEBUG */
12 |
13 | /*----------------------------------------------------------------------*\
14 |
15 | * Function to rewrite a line of text with only one blankspace between *
16 | * each word.
17 | *
18 |
19 | \*----------------------------------------------------------------------*/
20 |
21 |
22 | /*
23 | * This while loop continues until the NULL character is copied into
24 | * the destination string. If a tab character is copied into the
25 | * destination string, it is replaced with a blank-space character.
26 | *
27 | * Multiple blank-space and/or tab characters are skipped in the source
28 | * string until any other character is found.
29 | */
30 |
31 | while (1)
32 | {
33 | *dest = *source;
34 |
35 | if (*dest == '\t')
36 | (*dest = ' ');
37 |
38 | /* Exit if have copied the end of the string. */
39 | if (*dest == '\0')
40 | return;
41 |
42 | /*
43 | * If the source character was a blank-space or a tab, move to the next
44 | * source character. While the source character is a blank-space or a
45 | * tab, move to the next character (i.e. ignore these characters). When
46 | * any other character is found in the source string, move to the next
47 | * element of the destination string.
48 | *
49 | * Otherwise, simultaneously, move to the next elements of the destination
50 | * and the source strings.
51 | */
52 |
53 |
54 |
55 | if ( (*source == ' ') || (*source == '\t') )
56 | {
57 | ++source;
58 | while ( (*source == ' ') || (*source == '\t') )
59 | {
60 | ++source;
61 | }
62 |
63 | ++dest;
64 | }
65 | else
66 | {
67 | ++dest;
68 | ++source;
69 | }
70 | }
71 | }
72 |
73 |
74 | void ca_populateDictionary(dict_t woordenboek[], int size)
75 |
76 | /*******************************************************************
77 | * ca_populateDictionary -- Parses dictionary file, initializes *
78 | * the dictionary structure and writes *
79 | * the file of dictionary symbols, *
80 | * ca_dictSyms.h *
81 | * *
82 | * Parameters *
83 | * woordenboek -- the dictionary to be populated *
84 | * size -- the total number of variables i.e. the size of the *
85 | * array of dict_t structures. See D. & D., p.276 *
86 | * *
87 | * Returns *
88 | * Nothing ? (may change this later) *
89 | * *
90 | *******************************************************************/
91 |
92 | {
93 | const char *blankLine = "\n";
94 | const char *comment = "#";
95 | char line[120];
96 | char input[120];
97 | char test[120];
98 | int lineNo = 0;
99 | int i;
100 | int entry = 0;
101 | FILE *dictPtr, *defnPtr;
102 |
103 | gchar **tokens; /* Pointer to an array of strings. */
104 |
105 | /*
106 | * Try to open the dictionary file for reading. If it cannot be
107 | * opened, exit with an error.
108 | */
109 | if ( (dictPtr = fopen("dictionary.txt", "r")) == NULL)
110 | {
111 | fprintf(stderr, "Error: Unable to open 'dictionary.txt'\n");
112 | exit (51);
113 | }
114 |
115 |
116 | /*
117 | *Try to open the definitions file for writing. If it cannot be
118 | * opened,exit with an error
119 | */
120 | if ( (defnPtr = fopen("defs.txt", "w")) == NULL)
121 | {
122 | fprintf(stderr, "Error: Unable to open 'defs.txt'\n");
123 | exit (51);
124 | }
125 |
126 | /*
127 | * Read the file one line at a time;
128 | * if the line begins with a comment, ignore it;
129 | * otherwise, split each line into tokens;
130 | * print each token.
131 | * Assign each token to the appropriate member of
132 | * the appropriate element of the dictionary array.
133 | */
134 |
135 | fgets(input, sizeof(input), dictPtr);
136 |
137 | if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0) )
138 |
139 | {
140 | /*
141 | * First remove the newline character.
142 | * Then replace multiple tab and space
143 | * characters with single space characters.
144 | */
145 |
146 | /* Remove the newline character, if present.
147 | * Replace the last character of the string
148 | * array with with '\0'.
149 | */
150 |
151 | input[strlen(input) - 1] = '\0';
152 |
153 | /* Now, remove the multiple space and tab
154 | * characters.
155 | */
156 |
157 | stringPack(line, input);
158 |
159 | g_strchomp(line); /* Remove trailing w-space. */
160 | #ifdef DEBUG
161 | puts(line);
162 | #endif /*DEBUG */
163 |
164 | tokens = g_strsplit(line, " ", 0);
165 |
166 | #ifdef DEBUG
167 | for (i = 0; tokens[i] != NULL; i++)
168 | printf("tokens[%d] = %s\n", i, tokens[i]);
169 | #endif /* DEBUG */
170 |
171 | /* We no longer need a variable for scope
172 | * woordenboek[entry].varScope = atoi(tokens[1]);
173 | */
174 |
175 | strcpy(woordenboek[entry].varName, tokens[0]);
176 | strcpy(woordenboek[entry].varSym, tokens[1]);
177 | strcpy(woordenboek[entry].varType, tokens[2]);
178 | woordenboek[entry].varNum = entry;
179 |
180 | /*
181 | * Write the dictionary symbol and the entry number
182 | * to the definitions file.
183 | */
184 | fprintf(defnPtr, "%s\t%d\n", tokens[1], entry);
185 |
186 | ++entry;
187 | }
188 | /*
189 | * Get the 2nd and subsequent line of the file.
190 | */
191 |
192 | fgets(input, sizeof(input), dictPtr);
193 |
194 | while(!feof(dictPtr) )
195 | {
196 | /*
197 | * Process the line if it is not a comment.
198 | */
199 |
200 | if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0 ) )
201 | {
202 | /*
203 | * First remove the newline character.
204 | * Then replace multiple tab and space
205 | * characters with single space characters.
206 | */
207 |
208 | /* Remove the newline character, if present.
209 | * Replace the last character of the string
210 | * array with with '\0'.
211 | */
212 |
213 | input[strlen(input) - 1] = '\0';
214 |
215 | /* Now, remove the multiple space and tab
216 | * characters.
217 | */
218 |
219 | stringPack(line, input);
220 |
221 | g_strchomp(line); /* Remove trailing w/space. */
222 | #ifdef DEBUG
223 | puts(line);
224 | #endif /* DEBUG */
225 | tokens = g_strsplit(line, " ", 0);
226 |
227 | #ifdef DEBUG
228 | for (i = 0; tokens[i] != NULL; i++)
229 | printf("tokens[%d] = %s\n", i, tokens[i]);
230 | #endif /* DEBUG */
231 |
232 | /*
233 | * We no longer need to know the scope of a variable
234 | * woordenboek[entry].varScope = atoi(tokens[1]);
235 | */
236 |
237 | strcpy(woordenboek[entry].varName, tokens[0]);
238 | strcpy(woordenboek[entry].varSym, tokens[1]);
239 | strcpy(woordenboek[entry].varType, tokens[2]);
240 | woordenboek[entry].varNum = entry;
241 | fprintf(defnPtr, "%s\t%d\n", tokens[1], entry);
242 | ++entry;
243 | }
244 | fgets(input, sizeof(input), dictPtr);
245 | }
246 |
247 | fclose(dictPtr);
248 | fclose(defnPtr);
249 |
250 | } /* End of ca_populateDictionary() function. */
251 |
252 |
253 | void opSplitsen (FILE *filePtr, gchar **tokenArray)
254 | {
255 | /*
256 | * Declaring character constants is safer than using #define.
257 | * See Oualline's book, p.145.
258 | *
259 | */
260 |
261 | const char *blankLine = "\n"; /* Declared as a string, not a character. */
262 | const char *comment = "#"; /* Declared as a string. */
263 | char line[99];
264 | char input[99];
265 | int lineNo = 0;
266 | int j;
267 |
268 |
269 | fgets(input, sizeof(input), filePtr); /* Get the (first) line from the */
270 | /* file to which filePtr points. */
271 |
272 | #ifdef DEBUG
273 | printf("\nFIRST INPUT >>> %s\n", input);
274 | #endif /* DEBUG */
275 |
276 | /* Compare the first character of the input */
277 | /* to the comment and the newline strings. */
278 |
279 | if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0) )
280 |
281 |
282 |
283 | {
284 | /* Remove the newline character, if present. */
285 | /* Replace the last character */
286 | /* of the string array with '\0'. */
287 |
288 | input[strlen(input) - 1] = '\0';
289 | #ifdef DEBUG
290 | printf("First Input >>> %s\n", input);
291 | #endif /* DEBUG */
292 |
293 | strcpy(line, input);
294 | #ifdef DEBUG
295 | printf("First Line after copy >>> %s\n", line);
296 | #endif /* DEBUG */
297 |
298 | stringPack(line, input);
299 | #ifdef DEBUG
300 | printf("Line: %s\n", line);
301 | #endif /* DEBUG */
302 |
303 | g_strchomp(line);
304 | /* g_strdelimit(line, " ", ':');
305 | * g_strdelimit(line, "\t", '*');
306 | */
307 |
308 | printf("%3d> %s\n", ++lineNo, line);
309 |
310 | /*
311 | * g_strsplit() is a GLib function;
312 | * it returns an array of strings.
313 | *
314 | * Here, we split on two spaces, " ".
315 | * We set max_tokenArray to be 0. We want the
316 | * first token to be the name of the variable
317 | * and the other tokens to be the value of the variable,
318 | * qualifiers, etc.
319 | */
320 |
321 | tokenArray = g_strsplit(line, " ", 0);
322 |
323 | for (j = 0; tokenArray[j] != NULL; j++)
324 | printf("token[%d] = %s\n", j, tokenArray[j]);
325 | } /* End of processing the first line, if not commented. */
326 |
327 | /* End of getting the first line. */
328 |
329 |
330 | /*Get the 2nd line of the file. */
331 | fgets(input, sizeof(input), filePtr);
332 |
333 | while(!feof(filePtr) )
334 | {
335 |
336 | /* Process the line if it is not commented. */
337 | if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0 ) )
338 | {
339 | /* Remove the newline character, if present. */
340 | input[strlen(input) -1] = '\0';
341 | #ifdef DEBUG
342 | printf("Subsequent Input >>> %s\n", input);
343 | #endif /* DEBUG */
344 |
345 | strcpy(line, input);
346 | #ifdef DEBUG
347 | printf("Subsequent Line after copy >>> %s\n", line);
348 | #endif /* DEBUG */
349 |
350 | stringPack(line, input);
351 | #ifdef DEBUG
352 | printf("Line: %s\n", line);
353 | #endif /* DEBUG */
354 |
355 | g_strchomp(line);
356 | /* g_strdelimit(line, " ", ':');
357 | * g_strdelimit(line, "\t", '*');
358 | */
359 | printf("%3d> %s\n", ++lineNo, line);
360 |
361 | /*
362 | * See the comment above about the maximum
363 | * number of tokens being set to 0.
364 | */
365 |
366 | tokenArray = g_strsplit(line, " ", 0);
367 | for (j = 0; tokenArray[j] != NULL; j++)
368 | {
369 | printf("token[%d] = %s\n", j, tokenArray[j]);
370 | /* Can also use puts(tokenArray[j]) here. */
371 | }
372 | } /* Processed uncommented lines. */
373 |
374 | fgets(input, sizeof(input), filePtr);
375 | } /* Processed the 2nd & subsequent lines of the file. */
376 |
377 | } /* End of processing the opened file. */
378 |
379 |
380 | void ca_readConfig(const char *configFile, values_t confVars[], int size)
381 | /*******************************************************************
382 | * *
383 | * ca_readConfig -- parses the config file and writes the values *
384 | * into memory. *
385 | * *
386 | * Parameters *
387 | * configFile -- the configuration file
388 | * confVars[] -- the array of values structures *
389 | * size -- the number of configuration variables *
390 | * *
391 | * Returns *
392 | * Nothing -- perhaps make this return 0 on successful exit ? *
393 | * *
394 | * Note: Should we make the name of the config file a global *
395 | * variable ? *
396 | *******************************************************************/
397 | {
398 | FILE *confPtr; /* Pointer to config file. */
399 | char name[STRLENGTH]; /* The name of the config variable */
400 | char value[STRLENGTH]; /* The value of the variable */
401 | int location; /* Storage Location of the variable's value. */
402 | int type; /* Data type of the variable, represented by an integer. */
403 |
404 |
405 | const char *blankLine = "\n"; /* Declared as a string, not a character. */
406 | const char *comment = "#"; /* Declared as a string. */
407 |
408 | char source[16]; /* The name of a source. */
409 | char database[STRLENGTH]; /* The elements of a database. */
410 |
411 | gchar **dbcomps; /* Pointer to an array of strings that represents */
412 | /* the components of a db. */
413 |
414 | int i; /* A counting variable. */
415 |
416 | ca_database_t *newDbPtr; /* A pointer to a new instance of */
417 | /* ca_database_t. */
418 |
419 | ca_database_list_t *newSrc; /* A pointer to a new instance of */
420 | /* ca_database_list_t. */
421 |
422 | /*
423 | * Function Prototype for ca_getStorageLocation()
424 | * We put it here; thus it can only be called from
425 | * within ca_readConfig()
426 | *
427 | * This function finds the location in the values_t array
428 | * where we store pointers to the string value and the actual
429 | * value of the variable. It returns this location as an
430 | * integer.
431 | *
432 | */
433 | int ca_getStorageLocation(char [], dict_t [], int);
434 |
435 | /*
436 | * Function Prototype for ca_getType()
437 | * We put it here so that it can only be called from
438 | * within ca_readConfig()
439 | *
440 | * This function returns the type of the configuration
441 | * variable. It returns it as a string.
442 | *
443 | */
444 | int ca_getType(char [], dict_t [], int);
445 |
446 |
447 | #ifdef DEBUG
448 | printf("\nInside readConfig() function.\n");
449 | printf("Configuration file is: %s\n", configFile);
450 | #endif /* DEBUG */
451 |
452 | /*
453 | * Open the configuration file for reading .....
454 | */
455 | if ( (confPtr = fopen(configFile, "r")) == NULL)
456 | {
457 | printf("Error: file %s could not be opened.\n", configFile);
458 | exit (51);
459 | }
460 |
461 | /*
462 | * Read the first record in the configuration file .....
463 | * We read the _name_ of the variable using fscanf into a
464 | * string array. We read the _value_ of the variable
465 | * using fgets into an array; thus, we can handle values of
466 | * variables with qualifiers (e.g. SPLIT after DBLIST) and
467 | * values with blank characters (e.g. REPLYBANNER).
468 | */
469 | fscanf(confPtr, "%s", name);
470 | fgets(value, sizeof(value), confPtr);
471 |
472 |
473 | /*
474 | * While there are records to be read in the config file.
475 | * write the current record into memory,
476 | * read the next record in the config file
477 | */
478 |
479 |
480 | while (!feof(confPtr) )
481 | {
482 |
483 | /*
484 | * From the variable name, find the dictionary number.
485 | * The dictionary number is defined as the place in the
486 | * values array in which to store the value of the variable.
487 | *
488 | */
489 |
490 | /*
491 | * Process the line only when/if it is not a comment or
492 | * a blankline.
493 | */
494 | if ( (strncmp(name, comment, 1) != 0) && (strncmp(name, blankLine, 1) != 0) )
495 | {
496 | /*
497 | * If the last character of "value" is '\n',
498 | * replace it with '\0'.
499 | */
500 | if ( value[strlen(value) - 1] == '\n')
501 | {
502 | value[strlen(value) - 1] = '\0';
503 | }
504 |
505 | /*
506 | * From the variable name, find the element of the values
507 | * array in which to store the value of the variable.
508 | *
509 | */
510 | location = ca_getStorageLocation(name, dictionary, VARS);
511 | printf("The location is: %d\n", location);
512 |
513 | /*
514 | * Store a pointer to the string that contains the value
515 | * This is not necessarily the actual value itself.
516 | * First, we must allocate some memory.
517 | */
518 | confVars[location].strPtr = (char *)malloc(STRLENGTH);
519 | /*
520 | * We check the return value of the malloc function .....
521 | */
522 | if (confVars[location].strPtr == NULL)
523 | {
524 | fprintf(stderr, "Cannot allocate memory for confVars[location].strPtr\n");
525 | exit (8);
526 | }
527 |
528 | strcpy(confVars[location].strPtr, value);
529 |
530 | /*
531 | * Now, store a pointer to the _value_ of the variable.
532 | * Do this as follows:
533 | * (a) get the _type_ of the variable
534 | * (b) store a pointer to the value of the variable in
535 | * a way that depends on the _type_ of the variable.
536 | */
537 | #ifdef DEBUG
538 | printf("Variable \"%s\" is data-type \"%d\"\n", name, ca_getType(name, dictionary, VARS) );
539 | #endif /* DEBUG */
540 |
541 |
542 | type = ca_getType(name, dictionary, VARS);
543 |
544 | /*
545 | * Given the _type_ of the variable, store the value of the
546 | * variable in the appropriate way.
547 | */
548 | switch(type)
549 | {
550 | case 11:
551 | puts("Data type is Integer");
552 | confVars[location].valPtr = malloc(sizeof(int) );
553 | if (confVars[location].valPtr == NULL)
554 | {
555 | fprintf(stderr, "Cannot allocate memory !!!\n");
556 | exit (8);
557 | }
558 | sscanf(value, "%d", (int *) confVars[location].valPtr);
559 | break;
560 |
561 | case 12:
562 | puts("Data type is String");
563 | confVars[location].valPtr = (char *)malloc(STRLENGTH);
564 | if (confVars[location].valPtr == NULL)
565 | {
566 | fprintf(stderr, "Cannot allocate memory !!!\n");
567 | exit (8);
568 | }
569 | strcpy(confVars[location].valPtr, value);
570 | break;
571 |
572 | case 13:
573 | puts("Data type is Dirlist");
574 | confVars[location].valPtr = (char *)malloc(STRLENGTH);
575 | if (confVars[location].valPtr == NULL)
576 | {
577 | fprintf(stderr, "Cannot allocate memory !!!\n");
578 | exit (8);
579 | }
580 | strcpy(confVars[location].valPtr, value);
581 | break;
582 |
583 | case 15:
584 | puts("Data type is Source !!!");
585 | /*
586 | * Split the value into "source" and "database"
587 | * Use blankspace as the delimiter between the
588 | * "source" and "database".
589 | */
590 | sscanf(value, "%s %s", source, database);
591 | #ifdef DEBUG
592 | puts(source);
593 | puts(database);
594 | #endif /* DEBUG */
595 |
596 | /*
597 | * Using the values in "database".
598 | * populate a ca_database_t structure.
599 | * Give this variable a name.
600 | *
601 | */
602 |
603 | /* First, separate the values in "database", using "," as
604 | * as a delimiting character.
605 | */
606 | dbcomps = g_strsplit(database, ",", 0);
607 |
608 | #ifdef DEBUG
609 | for (i = 0; dbcomps[i] != NULL; i++)
610 | printf("dbcomps[%d] = %s\n", i, dbcomps[i]);
611 | #endif /* DEBUG */
612 |
613 |
614 | /*
615 | * Create a structure for this database.
616 | */
617 | newDbPtr = malloc(sizeof(ca_database_t));
618 | if (newDbPtr == NULL)
619 | {
620 | fprintf(stderr, "Cannot allocate memory to new db structure\n");
621 | exit (8);
622 | }
623 |
624 | strcpy(newDbPtr->host, dbcomps[0]);
625 | strcpy(newDbPtr->port, dbcomps[1]);
626 | strcpy(newDbPtr->user, dbcomps[2]);
627 | strcpy(newDbPtr->password, dbcomps[3]);
628 | strcpy(newDbPtr->dbName, dbcomps[4]);
629 | #ifdef DEBUG
630 | puts("Testing the population of the db structure:");
631 | printf("\n%s::%s::%s::%s::%s\n", newDbPtr->host, newDbPtr->port, newDbPtr->user, newDbPtr->password, newDbPtr->dbName);
632 | #endif /* DEBUG */
633 |
634 | /*
635 | * Using the above ca_database_t structure
636 | * and the "source" value,
637 | * populate the ca_src_t structure.
638 | */
639 |
640 | /*
641 | * Create a new structure for this source.
642 | */
643 | newSrc = malloc(sizeof(ca_database_list_t));
644 |
645 | if (newSrc == NULL)
646 | {
647 | fprintf(stderr, "Cannot allocate memory to new source structure\n");
648 | exit (8);
649 | }
650 |
651 | strcpy(newSrc->name, source);
652 | newSrc->db = *newDbPtr;
653 |
654 | #ifdef DEBUG
655 | puts("Testing the population of the ca_database_list_t structure:");
656 | printf("\n%s::%s::%s::%s::%s::%s\n", newSrc->name, (newSrc->db).host, (newSrc->db).port, (newSrc->db).user, (newSrc->db).password, (newSrc->db).dbName);
657 | #endif /* DEBUG */
658 |
659 | /*
660 | * Append this ca_src_t structure to the sourceList,
661 | * which is a singly-linked list if type GSList.
662 | */
663 |
664 | sourceList = g_slist_append(sourceList, newSrc);
665 |
666 | break;
667 |
668 | default:
669 | printf("Data type not found for variable \"%s\".\n", name);
670 | break;
671 | }
672 | }
673 |
674 | fscanf(confPtr, "%s", name);
675 | fgets(value, sizeof(value), confPtr);
676 |
677 | } /* End of processing the config file. */
678 |
679 | } /* End of readConfig() function */
680 |
681 |
682 | /*
683 | * void ca_populateDictionary(dictionary_t woordenboek[], int size, FILE *fiPtr)
684 | * {
685 | * int j;
686 | * char input[99];
687 | *
688 | * for (j=0; (j < size) && !feof(fiPtr); j++)
689 | * j = 0;
690 | * while ((j < size) && !feof(fiPtr) )
691 | * {
692 | * printf("\n%d\n", j);
693 | *
694 | * fgets(input, sizeof(input), filePtr);
695 | *
696 | * if ( (strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1)
697 | * != 0) )
698 | * {
699 | * fscanf(fiPtr, "%s %s %s %s", woordenboek[j].varName, woordenboek[j].varScope, woordenboek[j].varSym, woordenboek[j].varType);
700 | * }
701 | *
702 | * fgets(input, sizeof(input), filePtr);
703 | * printf("%s\n", woordenboek[j].varName);
704 | * }
705 | * }
706 | *
707 | */
708 |
709 |
710 | void ca_getDictionary(dict_t woordenboek[], int size)
711 | {
712 | int k;
713 |
714 | for (k = 0; k <= size; k++)
715 | {
716 | printf("\nj = %d\n", k);
717 | /*
718 | * printf("%s\t%d\t%s\n", woordenboek[k].varName, woordenboek[k].varScope, woordenboek[k].varType);
719 | */
720 | printf("%s\t%s\t%s\t%d\n", woordenboek[k].varName, woordenboek[k].varSym, woordenboek[k].varType, woordenboek[k].varNum);
721 |
722 | }
723 | }
724 |
725 |
726 | int ca_get_int(int symbol)
727 | {
728 | int *xPtr;
729 |
730 | /*
731 | * First print a message saying that the ca_get_int()
732 | * function is being called.
733 | */
734 | #ifdef DEBUG
735 | printf("\nDEBUG: ca_get_int() function is called .....\n");
736 | printf("DEBUG: New value of StringPtr: %s\n", globals[symbol].strPtr);
737 | #endif /* DEBUG */
738 |
739 | /*
740 | * Look at the appropriate place in the dictionary;
741 | * e.g. C_BINDPORT => the first element, index = 0.
742 | *
743 | * if the varType is not an integer, exit with an error;
744 | *
745 | * otherwise,
746 | * if the varScope is global, look for the value in the
747 | * appropriate place in memory in the global values array;
748 | * otherwise, look for the value in the appropriate place in
749 | * memory in the local values array;
750 | *
751 | *
752 | */
753 |
754 | /* Look at the appropriate place in the dictionary. */
755 |
756 | #ifdef DEBUG
757 | printf("\nDEBUG: Variable type: %s\n", dictionary[symbol].varType);
758 | #endif /* DEBUG */
759 |
760 | /* If the variable type is not an integer, exit with an error. */
761 | if ( strcmp(dictionary[symbol].varType, "CA_INT") != 0)
762 | {
763 | fprintf(stderr, "Error: unexpected variable type.\n");
764 | exit (51);
765 | }
766 | else
767 | {
768 | /*
769 | * If the variable has global scope, look for it in
770 | * the globals array. Otherwise, look for it in the
771 | * locals array.
772 | *
773 | */
774 |
775 | /*
776 | * Lock the value of the variable before reading it.
777 | */
778 |
779 | mutex_lock(&Lock);
780 |
781 | switch(dictionary[symbol].varScope)
782 | {
783 | case 1:
784 | #ifdef DEBUG
785 | printf("\nThis variable has global scope.\n");
786 | printf("The string is: %s\n", globals[symbol].strPtr);
787 | printf("String2Value: %d\n", atoi(globals[symbol].strPtr));
788 | #endif /* DEBUG */
789 |
790 | xPtr = globals[symbol].valPtr;
791 | printf("Value: %d\n", *xPtr);
792 | return(*xPtr);
793 | break;
794 |
795 | case 99:
796 | #ifdef DEBUG
797 | printf("\nThis variable has local scope.\n");
798 | printf("The string is %s\n", locals[symbol].strPtr);
799 | printf("String2Value: %d\n", atoi(locals[symbol].strPtr));
800 | #endif /* DEBUG */
801 | xPtr = locals[symbol].valPtr;
802 | printf("Value: %d\n", *xPtr);
803 | return(*xPtr);
804 | break;
805 |
806 | default:
807 | printf("\nAaaargh !!! This variable has unwelcome scope.\n");
808 | break;
809 | }
810 | /*
811 | * Unlock the value of the variable after reading it.
812 | */
813 | mutex_unlock(&Lock);
814 |
815 | }
816 |
817 | }
818 |
819 | char *ca_get_dirlist(int symbol)
820 | {
821 | /*
822 | * This function returns a pointer to a character array. Thus,
823 | * we need to declare such a pointer.
824 | *
825 | */
826 |
827 | char *xPtr;
828 | #ifdef DEBUG
829 | printf("\nca_get_dirlist() function is called .....\n");
830 | #endif /* DEBUG */
831 |
832 |
833 | /*
834 | * Look at the appropriate place in the dictionary;
835 | * e.g. CA_HELP => the second element, index = 1.
836 | *
837 | * if the varType is not CA_DIRLIST, exit with an error;
838 | *
839 | * otherwise,
840 | * if the varScope is global, look for the value in the
841 | * appropriate place in memory in the global values array;
842 | * otherwise, look for the value in the appropriate place in
843 | * memory in the local values array;
844 | *
845 | *
846 | */
847 |
848 | /* Look at the appropriate place in the dictionary. */
849 |
850 | printf("\nVariable type: %s\n", dictionary[symbol].varType);
851 |
852 | /* If the variable type is not CA_DIRLIST, exit with an error. */
853 | if ( strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0)
854 | {
855 | fprintf(stderr, "Error: unexpected variable type.\n");
856 | exit (51);
857 | }
858 | else
859 | {
860 | /*
861 | * If the variable has global scope, look for it in
862 | * the globals array. Otherwise, look for it in the
863 | * locals array.
864 | *
865 | */
866 |
867 | switch(dictionary[symbol].varScope)
868 | {
869 | case 1:
870 | printf("\nThis variable has global scope.\n");
871 | printf("The string is: %s\n", globals[symbol].strPtr);
872 | xPtr = globals[symbol].valPtr;
873 | printf("Value: %s\n", xPtr);
874 | return(xPtr);
875 | break;
876 |
877 | case 99:
878 | printf("\nThis variable has local scope.\n");
879 | printf("The string is %s\n", locals[symbol].strPtr);
880 | xPtr = locals[symbol].valPtr;
881 | printf("Value: %s\n", xPtr);
882 | return(xPtr);
883 | break;
884 |
885 | default:
886 | printf("\nAaaargh !!! This variable has unwelcome scope.\n");
887 | break;
888 | }
889 |
890 | }
891 |
892 | }
893 |
894 |
895 | char *ca_get_string(int symbol)
896 | {
897 | /*
898 | * This function returns a pointer to a character array. Thus,
899 | * we need to declare such a pointer.
900 | *
901 | */
902 |
903 | char *xPtr;
904 | #ifdef DEBUG
905 | printf("\nca_get_text() function is called .....\n");
906 | #endif /* DEBUG */
907 |
908 |
909 | /*
910 | * Look at the appropriate place in the dictionary;
911 | * e.g. CA_REPLYBANNER => the third element, index = 2.
912 | *
913 | * if the varType is not CA_STRING, exit with an error;
914 | *
915 | * otherwise,
916 | * if the varScope is global, look for the value in the
917 | * appropriate place in memory in the global values array;
918 | * otherwise, look for the value in the appropriate place in
919 | * memory in the local values array;
920 | *
921 | *
922 | */
923 |
924 | /* Look at the appropriate place in the dictionary. */
925 |
926 | printf("\nVariable type: %s\n", dictionary[symbol].varType);
927 |
928 | /* If the variable type is not CA_STRING, exit with an error. */
929 | if ( strcmp(dictionary[symbol].varType, "CA_STRING") != 0)
930 | {
931 | fprintf(stderr, "Error: unexpected variable type.\n");
932 | exit (51);
933 | }
934 | else
935 | {
936 | /*
937 | * If the variable has global scope, look for it in
938 | * the globals array. Otherwise, look for it in the
939 | * locals array.
940 | *
941 | */
942 |
943 | switch(dictionary[symbol].varScope)
944 | {
945 | case 1:
946 | printf("\nThis variable has global scope.\n");
947 | printf("The string is: %s\n", globals[symbol].strPtr);
948 | xPtr = globals[symbol].valPtr;
949 | printf("Value: %s\n", xPtr);
950 | return(xPtr);
951 | break;
952 |
953 | case 99:
954 | printf("\nThis variable has local scope.\n");
955 | printf("The string is %s\n", locals[symbol].strPtr);
956 | xPtr = locals[symbol].valPtr;
957 | printf("Value: %s\n", xPtr);
958 | return(xPtr);
959 | break;
960 |
961 | default:
962 | printf("\nAaaargh !!! This variable has unwelcome scope.\n");
963 | break;
964 | }
965 |
966 | }
967 | }
968 |
969 |
970 | int ca_get_boolean(int symbol)
971 | {
972 | /**********************************************
973 | * ca_get_boolean() *
974 | * *
975 | * *
976 | * Parameters *
977 | * *
978 | * symbol -- the symbol for the variable *
979 | * *
980 | * *
981 | * Returns *
982 | * *
983 | * 1 if true, 0 if false. *
984 | * *
985 | * Remarks *
986 | * *
987 | * Is there a better way to implement *
988 | * Boolean values in C ? *
989 | * *
990 | *********************************************/
991 |
992 | int *xPtr;
993 |
994 | /*
995 | * Print this message if in debug mode.
996 | *
997 | */
998 | #ifdef DEBUG
999 | printf("\nca_get_boolean() function is called .....\n");
1000 | printf("DEBUG 5: New value of StringPtr: %s\n", globals[symbol].strPtr);
1001 | #endif /* DEBUG */
1002 |
1003 | /**********************************************\
1004 | * *
1005 | * Here is how this works: *
1006 | * *
1007 | * (a) Check that the type of variable whose *
1008 | * value is being read is CA_BOOLEAN. *
1009 | * *
1010 | * (b) Lock the value of the variable before *
1011 | * reading it. *
1012 | * *
1013 | * (c) Depending on the scope of the variable *
1014 | * look for it in the appropriate array. *
1015 | * *
1016 | * (d) Read the value of the variable. *
1017 | * *
1018 | * (e) Unlock the value of the variable after *
1019 | * reading it. *
1020 | * *
1021 | * *
1022 | * Returns *
1023 | *
1024 | * an integer value as follows: *
1025 | * 1 if the db is in testmode (true), *
1026 | * 0 if the db is not in testmode (false). *
1027 | \*********************************************/
1028 |
1029 |
1030 | /*
1031 | * Look at the appropriate place in the dictionary;
1032 | * e.g. CA_BOOLEAN = the fifth element of the dict_t array,
1033 | * => index = 4.
1034 | *
1035 | * If the varType is not Boolean, exit with an error
1036 | *
1037 | * Otherwise,
1038 | * if the varScope is global, look for the value in the
1039 | * appropriate place in the global values array;
1040 | *
1041 | * otherwise, look for the value in the appropriate place in the
1042 | * locals array.
1043 | *
1044 | */
1045 |
1046 | #ifdef DEBUG
1047 | /* Look in the appropriate place in the dictionary. */
1048 | printf("\nVariable type: %s\n", dictionary[symbol].varType);
1049 | #endif /* DEBUG */
1050 |
1051 | /* If the variable type is not Boolean, exit with an error. */
1052 |
1053 | if ( strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0)
1054 | {
1055 | fprintf(stderr, "Error: Boolean type expected.\n");
1056 | exit (51);
1057 | }
1058 |
1059 | else
1060 | {
1061 | /*
1062 | * Lock the value of the variable before reading it.
1063 | *
1064 | */
1065 |
1066 | mutex_lock(&Lock);
1067 |
1068 | /*
1069 | * If the variable has global scope, look for it in the globals
1070 | * array. Otherwise, look for it in the locals array.
1071 | *
1072 | */
1073 |
1074 | switch(dictionary[symbol].varScope)
1075 | {
1076 | case 1:
1077 | printf("\nThis variable has global scope.\n");
1078 | printf("The string is: %s\n", globals[symbol].strPtr);
1079 | printf("String2Value: %d\n", atoi(globals[symbol].strPtr) );
1080 | xPtr = globals[symbol].valPtr;
1081 | printf("Value: %d\n", *xPtr);
1082 | return (*xPtr);
1083 | break;
1084 |
1085 | case 99:
1086 | printf("\nThis variable has local scope.\n");
1087 | printf("The string is %s\n", locals[symbol].strPtr);
1088 | printf("String2Value: %d\n", atoi(locals[symbol].strPtr) );
1089 | xPtr = locals[symbol].valPtr;
1090 | printf("Value: %d\n", *xPtr);
1091 | return(*xPtr);
1092 | break;
1093 |
1094 | default:
1095 | printf("\nError: This variable has unknown scope.\n");
1096 | break;
1097 | }
1098 |
1099 | /*
1100 | * Unlock the value of the variable after reading it.
1101 | */
1102 | mutex_unlock(&Lock);
1103 |
1104 | }
1105 |
1106 | }
1107 |
1108 |
1109 |
1110 | void ca_set_int(int symbol)
1111 | {
1112 | /*********************************************
1113 | * ca_set_int() *
1114 | * *
1115 | * Parameters *
1116 | * symbol -- the symbol for the variable. *
1117 | * *
1118 | * Returns *
1119 | * 1 if successful 0 if not ? *
1120 | * *
1121 | * Remarks *
1122 | * Needs a better way to check for valid *
1123 | * values from the keyboard. *
1124 | * *
1125 | *********************************************/
1126 |
1127 | void *tempPtr; /* Temp pointer to point to the value pointer
1128 | in the appropriate values array. */
1129 | char newPort[16];
1130 | int invalid;
1131 | int portNr;
1132 |
1133 | /* Function to change the value in a given values array.
1134 | * This function can only be called from within ca_set_int().
1135 | */
1136 | int *ca_change_int_value(char []);
1137 | void testFunction(values_t values[]);
1138 |
1139 | /*
1140 | * Using the symbol, look at the appropriate place in the
1141 | * dictionary.
1142 | */
1143 | #ifdef DEBUG
1144 | printf("\nca_set_int() function called .....\n");
1145 | printf("Variable type: %s\n", dictionary[symbol].varType);
1146 | #endif /* DEBUG */
1147 |
1148 |
1149 | /*
1150 | * Make sure that a reasonable, sensible value of bind-port has
1151 | * been read from the keyboard.
1152 | */
1153 |
1154 | do {
1155 |
1156 | /*
1157 | * First, flush input stream.
1158 | */
1159 | fflush(stdin);
1160 |
1161 | /*
1162 | * Prompt for the new value of the bind-port.
1163 | */
1164 |
1165 | printf("\nNew value of bind-port (non-zero positive integer) >>> ");
1166 | scanf("%s", newPort);
1167 | /*
1168 | * gets(newPort);
1169 | */
1170 | #ifdef DEBUG
1171 | printf("\nDEBUG: Value of newPort variable: %s\n", newPort);
1172 | #endif /* DEBUG */
1173 |
1174 | sscanf(newPort, "%d", &portNr);
1175 |
1176 | #ifdef DEBUG
1177 | printf("\nDEBUG: Value of integer variable, portNr: %d\n", portNr);
1178 | #endif /* DEBUG */
1179 |
1180 | if (portNr < 0)
1181 | {
1182 | invalid = 1;
1183 | puts("Only non-zero positive integer values accepted for bind-port");
1184 | }
1185 | else
1186 | {
1187 | invalid = 0;
1188 | }
1189 |
1190 | } while(invalid);
1191 |
1192 | /*
1193 | * Check that the function is attempting to set the correct type
1194 | * of value. If not, do not set the value and exit.
1195 | */
1196 |
1197 | if (strcmp(dictionary[symbol].varType, "CA_INT") != 0)
1198 | {
1199 | fprintf(stderr, "Error: unexpected variable type.\n");
1200 | exit (51);
1201 | }
1202 |
1203 | /*
1204 | * Choose the appropriate values array.
1205 | */
1206 | switch(dictionary[symbol].varScope)
1207 | {
1208 | /* If the variable has global scope,
1209 | * write it into the globals array.
1210 | * If it has local scope,
1211 | * write it into the local array.
1212 | * If the scope cannot be found, then report an error.
1213 | */
1214 | case 1:
1215 | globals[symbol].valPtr = ca_change_int_value(newPort);
1216 | globals[symbol].strPtr = newPort;
1217 |
1218 | globals[symbol].strPtr = (char *)malloc(sizeof(newPort) );
1219 |
1220 | /* Check the return value of malloc() to make sure that we
1221 | * actually got the memory.
1222 | */
1223 | if (globals[symbol].strPtr == NULL)
1224 | {
1225 | fprintf(stderr, "Cannot allocate memory for globals[symbol].strPtr.\n");
1226 | exit (8);
1227 | }
1228 | #ifdef DEBUG
1229 | printf("DEBUG: New value of StringPtr: %s\n", globals[symbol].strPtr);
1230 | #endif /* DEBUG */
1231 |
1232 | strcpy(globals[symbol].strPtr, newPort);
1233 |
1234 | #ifdef DEBUG
1235 | printf("DEBUG 2: New value of StringPtr: %s\n", globals[symbol].strPtr);
1236 | #endif /* DEBUG */
1237 | break;
1238 |
1239 | case 99:
1240 | locals[symbol].valPtr = ca_change_int_value(newPort);
1241 | /*
1242 | * First allocate some memory and then copy the value of the new
1243 | * Port into it.
1244 | */
1245 | locals[symbol].strPtr = (char *)malloc(sizeof(newPort) );
1246 | /*
1247 | * Now, check that the memory was actually allocated.
1248 | */
1249 | if (locals[symbol].strPtr == NULL)
1250 | {
1251 | fprintf(stderr, "Cannot allocate memory for locals[symbol].strPtr\n");
1252 | exit(8);
1253 | }
1254 |
1255 | strcpy(locals[symbol].strPtr, newPort);
1256 | /*
1257 | * locals[symbol].strPtr = newPort;
1258 | */
1259 | break;
1260 |
1261 | default:
1262 | fprintf(stderr, "Error; unknown scope: %d\n", dictionary[symbol].varScope);
1263 | break;
1264 | }
1265 |
1266 | /*
1267 | * Write the new value of the variable to the correct place in
1268 | * this array. (First, set a mutex lock ???).
1269 | */
1270 |
1271 | /*
1272 | * Write the new value of this variable back to the config. file
1273 | */
1274 |
1275 | ca_writeNewValue(symbol, newPort);
1276 |
1277 | printf("DEBUG 3: New value of StringPtr: %s\n", globals[symbol].strPtr);
1278 |
1279 | }
1280 |
1281 | int *ca_change_int_value(char value[])
1282 | {
1283 | void *tempPtr;
1284 |
1285 | /*
1286 | * Check the return value of malloc() in case we did not actually get
1287 | * the memory.
1288 | */
1289 | tempPtr = malloc(sizeof(int) );
1290 | if (tempPtr == NULL)
1291 | {
1292 | fprintf(stderr, "Cannot allocate memory for tempPtr\n");
1293 | exit (8);
1294 | }
1295 |
1296 | sscanf(value, "%d", (int *) tempPtr);
1297 | return(tempPtr);
1298 | }
1299 |
1300 |
1301 |
1302 | void testFunction(values_t array[])
1303 | {
1304 | printf("\nInside the Test function.\n");
1305 | }
1306 |
1307 |
1308 | void ca_getDatabase(ca_database_t db)
1309 | {
1310 | printf("\n%s\t%s\t%s\t%s\t%s\n", db.host, db.port, db.user, db.password, db.dbName);
1311 | }
1312 |
1313 | void ca_getSource(ca_database_list_t src)
1314 | {
1315 | printf("\n%s\t%s\t%s\t%s\t%s\t%s\n", src.name, (src.db).host, (src.db).port, (src.db).user, (src.db).password, (src.db).dbName);
1316 | }
1317 |
1318 |
1319 | void ca_getAllSources(GSList *sources)
1320 | {
1321 | /*
1322 | * Function Prototype of getSource().
1323 | * getSource can only be called from within getAllSources().
1324 | */
1325 | void ca_getAsource(ca_database_list_t *);
1326 |
1327 | GSList *currentPtr; /* Pointer to the structure at which we look. */
1328 |
1329 | /*
1330 | * Look at the first member of the linked-list of sources.
1331 | */
1332 | currentPtr = sources;
1333 |
1334 | /*
1335 | * Look at each data component of the source list,
1336 | * untill we reach the end of the list.
1337 | */
1338 | while(currentPtr != NULL)
1339 | {
1340 | ca_database_list_t *srcPtr = currentPtr->data;
1341 | printf("\n%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).dbName);
1342 | currentPtr = currentPtr->next;
1343 | }
1344 | }
1345 |
1346 | void ca_getAsource(ca_database_list_t *srcPtr)
1347 | {
1348 | printf("\n%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).dbName);
1349 | }
1350 |
1351 |
1352 | void ca_set_boolean(int symbol)
1353 | {
1354 | /*************************************************************
1355 | * *
1356 | * ca_set_boolean() *
1357 | * *
1358 | * *
1359 | * Parameters *
1360 | * *
1361 | * symbol -- the symbol for the variable. *
1362 | * *
1363 | * *
1364 | * Returns *
1365 | * *
1366 | * nothing *
1367 | * *
1368 | * *
1369 | * Remarks *
1370 | * *
1371 | * Must check that a sensible value is given as input. *
1372 | * *
1373 | * *
1374 | *************************************************************/
1375 |
1376 |
1377 | char newTestmodeStr[2];
1378 | int newTestmodeVal; /* The new value of the testmode variable. */
1379 | int invalid; /* Flag to indicate an invalid new value. */
1380 |
1381 | FILE *testPtr, *tempPtr; /* The pointer to the files. */
1382 | char name[STRLENGTH]; /* The name of the variable. */
1383 | char value[STRLENGTH]; /* The value of the variable. */
1384 |
1385 | /*
1386 | * Function to change the value in a given values array.
1387 | * This function can only be called from within ca_set_boolean().
1388 | */
1389 | int *ca_change_int_value(char []);
1390 |
1391 |
1392 | /*
1393 | * Using the symbol, look at the appropriate place in the
1394 | * dictionary.
1395 | */
1396 | #ifdef DEBUG
1397 | printf("\nca_set_int() function called .....\n");
1398 | printf("Variable type: %s\n", dictionary[symbol].varType);
1399 | #endif /* DEBUG */
1400 |
1401 | /*
1402 | * Check that the function is attempting to set the correct type of
1403 | * value. If not, do not set the value, but exit instead.
1404 | */
1405 |
1406 | if (strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0)
1407 | {
1408 | fprintf(stderr, "Error: CA_BOOLEAN data type expected.\n");
1409 | exit (51);
1410 | }
1411 |
1412 | /*
1413 | * First, flush the input stream.
1414 | */
1415 | fflush(stdin);
1416 |
1417 |
1418 | /*
1419 | * Make sure that a reasonable, sensible value of bind-port has
1420 | * been read from the keyboard.
1421 | */
1422 |
1423 | do {
1424 | /*
1425 | * Prompt for the new value of the testmode.
1426 | */
1427 |
1428 | printf("\nNew value of testmode (0 or 1) >>> ");
1429 | scanf("%s", newTestmodeStr);
1430 |
1431 | /*
1432 | * We scanf() the value as a string, but we want it to be an
1433 | * integer. Thus, we use sscanf() to scanf the value from the
1434 | * string-variable and store it as an integer in an integer
1435 | * variable.
1436 | */
1437 | sscanf(newTestmodeStr, "%d", &newTestmodeVal);
1438 |
1439 | /*
1440 | * We only change the testmode when the user is absolutely sure
1441 | * that they want to change. Thus, we only accept two possible
1442 | * values for testmode.
1443 | */
1444 |
1445 | if ( (newTestmodeVal < 0) || (newTestmodeVal > 1) )
1446 | {
1447 | invalid = 1;
1448 | puts("Only '0' or '1' accepted as value for testmode.");
1449 | }
1450 | else
1451 | {
1452 | invalid = 0;
1453 | }
1454 | } while(invalid);
1455 |
1456 |
1457 | /*
1458 | * Lock the value of the variable before changing it.
1459 | */
1460 |
1461 | mutex_lock(&Lock);
1462 |
1463 |
1464 | /*
1465 | * Choose the appropriate values array.
1466 | */
1467 |
1468 | switch(dictionary[symbol].varScope)
1469 | {
1470 | /*
1471 | * If the variable has global scope,
1472 | * write it into the globals array.
1473 | * If it has local scope,
1474 | * write it into the local array.
1475 | * If the scope cannot be found, then report an error.
1476 | */
1477 | case 1:
1478 | globals[symbol].valPtr = ca_change_int_value(newTestmodeStr);
1479 | globals[symbol].strPtr = newTestmodeStr;
1480 | break;
1481 |
1482 | case 99:
1483 | locals[symbol].valPtr = ca_change_int_value(newTestmodeStr);
1484 | locals[symbol].strPtr = newTestmodeStr;
1485 | break;
1486 |
1487 | default:
1488 | fprintf(stderr, "Error: unknown scope: %d\n", dictionary[symbol].varScope);
1489 | break;
1490 | }
1491 |
1492 | /*
1493 | * Write the new value of this variable back to the config file.
1494 | *
1495 | * To be implemented.
1496 | */
1497 |
1498 | /*
1499 | * Find the actual name of the variable from the dictionary
1500 | * structure (use the variable symbol as an index into the
1501 | * array of dictionary structures.
1502 | */
1503 |
1504 | printf("Name of variable to be changed: %s\n", dictionary[symbol].varName);
1505 | printf("Type of variable to be changed: %s\n", dictionary[symbol].varType);
1506 |
1507 | /*
1508 | * Open the test config file for reading .....
1509 | */
1510 | if ( (testPtr = fopen(testFile, "r")) == NULL)
1511 | {
1512 | printf("File \"%s\" could not be opened.\n", testFile);
1513 | exit (51);
1514 | }
1515 |
1516 | /*
1517 | * Open the temporary file for writing .....
1518 | */
1519 | if ((tempPtr = fopen(tempFile, "w")) == NULL)
1520 | {
1521 | printf("File \"%s\" could not be opened.\n", tempFile);
1522 | exit (51);
1523 | }
1524 |
1525 | /*
1526 | * Read the first record in the test config file.
1527 | */
1528 |
1529 | fscanf(testPtr, "%s", name);
1530 | fgets(value, sizeof(value), testPtr);
1531 |
1532 | /*
1533 | * If the last character of "value" is '\n',
1534 | * replace it with '\0'.
1535 | */
1536 | if (value[strlen(value) - 1] == '\n')
1537 | {
1538 | printf("The value string is %s", value);
1539 | printf("Replacing last character of \"%s\" with the NULL character\n", name);
1540 | value[strlen(value) - 1] = '\0';
1541 | printf("The new value string is %s", value);
1542 | }
1543 |
1544 |
1545 | /*
1546 | * While there are records to be read in the test config file:
1547 | * Write the current record into the temporary file.
1548 | * Read the next record in the config file.
1549 | * Repeat untill the EOF has been reached.
1550 | */
1551 |
1552 | while(!feof(testPtr) )
1553 | {
1554 | fprintf(tempPtr, "%s %s\n", name, value);
1555 | fscanf(testPtr, "%s", name);
1556 | fgets(value, sizeof(value), testPtr);
1557 |
1558 | /*
1559 | * If the last character of "value" is '\n',
1560 | * replace it with '\0'.
1561 | */
1562 | if (value[strlen(value) - 1] == '\n')
1563 | {
1564 | printf("The last character of the value string is %c", value[strlen(value) - 1]);
1565 | printf("The value string is %s", value);
1566 | printf("Replacing last character of \"%s\" with the NULL character\n",name);
1567 | value[strlen(value) - 1] = '\0';
1568 | printf("The new value string is %s", value);
1569 | }
1570 |
1571 |
1572 | /*
1573 | * if we read the variable that we want to change,
1574 | * stop reading this file and print only the name
1575 | * of this variable to the temporary file.
1576 | */
1577 |
1578 | /*
1579 | * If we read the variable that we want to change,
1580 | * replace the value of this variable in the config
1581 | * file with the value supplied from the keyboard.
1582 | *
1583 | */
1584 | if ( strcmp(name, dictionary[symbol].varName) == 0)
1585 | {
1586 | strcpy(value, newTestmodeStr);
1587 | printf("The replacement string is %s", value);
1588 | }
1589 | /*
1590 | * Flush the pointer to the test config file.
1591 | */
1592 | fflush(testPtr);
1593 |
1594 | }
1595 | /*
1596 | * Here ends the loop that writes the config file, with the
1597 | * new variable, to the temporary file.
1598 | */
1599 |
1600 | /*
1601 | *
1602 | * While !(the record to be updated)
1603 | * BEGIN
1604 | * Write the record to the temporary file
1605 | * Read the next record in the config file
1606 | * END
1607 | *
1608 | * Write the new value to the temporary file
1609 | * Read the next record in the config file
1610 | * COMMENT: this is the record to be updated.
1611 | * COMMENT: discard this record.
1612 | *
1613 | * Read the next record in the config file
1614 | *
1615 | * While !(EOF)
1616 | * BEGIN
1617 | * write the record to the temporary file
1618 | * read the next record in the config file
1619 | * END
1620 | *
1621 | * Close Config file
1622 | * Close Temporary file
1623 | *
1624 | * Open Temporary file for reading
1625 | * Open Config file for writing
1626 | *
1627 | * Read the next record of the Temporary file
1628 | *
1629 | * While (!EOF of Temporary file)
1630 | * BEGIN
1631 | * write the record into the Config file
1632 | * read the next record of the Temporary file
1633 | * END
1634 | *
1635 | * Close Temporary file
1636 | * Close Config file
1637 | *
1638 | */
1639 |
1640 | fclose(testPtr);
1641 | fclose(tempPtr);
1642 |
1643 | /*
1644 | * Now, flush the file pointers
1645 | */
1646 | fflush(testPtr);
1647 | fflush(tempPtr);
1648 |
1649 | /*
1650 | * Open the temporary file for reading.
1651 | * Open the config file for writing.
1652 | * Write the contents of the temporary file
1653 | * into the config file.
1654 | */
1655 |
1656 | /*
1657 | * Open the temporary file for reading .....
1658 | */
1659 | if ((tempPtr = fopen(tempFile, "r")) == NULL)
1660 | {
1661 | printf("File \"%s\" could not be opened for reading.\n", tempFile);
1662 | exit (51);
1663 | }
1664 |
1665 | /*
1666 | * Open the config file for writing .....
1667 | */
1668 | if ((testPtr = fopen(testFile, "w")) == NULL)
1669 | {
1670 | printf("File \"%s\" could not be opened for writing.\n", testFile);
1671 | exit (51);
1672 | }
1673 |
1674 | /*
1675 | * Read the first record in the temporary file.
1676 | */
1677 |
1678 | fscanf(tempPtr, "%s", name);
1679 | fgets(value, sizeof(value), tempPtr);
1680 | printf("\nFIRST LINE: %s %s", name, value);
1681 |
1682 |
1683 | /*
1684 | * While there are records to be read in the temporary file:
1685 | * Write the current record into the test config file.
1686 | * Read the next record in the temporary file.
1687 | * Repeat untill the EOF has been reached.
1688 | */
1689 |
1690 | while(!feof(tempPtr) )
1691 | {
1692 | fprintf(testPtr, "%s %s", name, value);
1693 | fscanf(tempPtr, "%s", name);
1694 | fgets(value, sizeof(value), tempPtr);
1695 | }
1696 |
1697 | fclose(testPtr);
1698 | fclose(tempPtr);
1699 |
1700 | /*
1701 | * Unlock the value of the variable after setting it and writing the
1702 | * new value back to the configuration (and the dictionary) file.
1703 | *
1704 | */
1705 | mutex_unlock(&Lock);
1706 |
1707 | }
1708 |
1709 |
1710 | void ca_set_dirlist(int symbol)
1711 | {
1712 | /****************************************************************
1713 | * ca_set_dirlist() *
1714 | * *
1715 | * Parameters *
1716 | * symbol -- the symbol of the variable. *
1717 | * *
1718 | * Returns *
1719 | * 1 if successful, 0 if not successful. *
1720 | * *
1721 | * Remarks *
1722 | * Writing the new value back to the config file has yet to *
1723 | * be implemented. *
1724 | * *
1725 | ****************************************************************/
1726 |
1727 | char newDir[80];
1728 | /*
1729 | * Declare a pointer to a values_t variable.
1730 | * Later, we shall assign this pointer to the first element
1731 | * of either the globals or the locals array, as appropriate.
1732 | */
1733 | values_t *hereValues;
1734 |
1735 | /*
1736 | * Using the symbol, look in the appropriate place in the dictionary.
1737 | */
1738 | #ifdef DEBUG
1739 | printf("\nca_set_dirlist() function called ..... \n");
1740 | printf("Variable type: %s\n", dictionary[symbol].varType);
1741 | #endif
1742 |
1743 | /*
1744 | * First, flush the input stream.
1745 | */
1746 | fflush(stdin);
1747 |
1748 | /*
1749 | * Prompt for the new value of the directory.
1750 | */
1751 | printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName);
1752 | scanf("%s", newDir);
1753 |
1754 | /*
1755 | * Make sure that a reasonable, sensible value of the directory
1756 | * value has been read from the keyboard.
1757 | *
1758 | * How do we implement this ???
1759 | *
1760 | */
1761 |
1762 |
1763 | /*
1764 | * Make sure that the function is attempting to set the correct type
1765 | * of value. If not, do not set the value - and exit.
1766 | */
1767 |
1768 | if (strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0)
1769 | {
1770 | fprintf(stderr, "Error: unexpected variable type.\n");
1771 | exit(51);
1772 | }
1773 |
1774 | /*
1775 | * Choose the appropriate values array.
1776 | * Assign a temporary pointer to this array.
1777 | */
1778 |
1779 | switch(dictionary[symbol].varScope)
1780 | {
1781 | /* If the variable has global scope,
1782 | * write it into the globals array.
1783 | * If it has local scope,
1784 | * write it into the locals array.
1785 | * If the scope cannot be found, report an error.
1786 | */
1787 | case 1:
1788 | hereValues = globals;
1789 | break;
1790 |
1791 | case 99:
1792 | hereValues = locals;
1793 | break;
1794 |
1795 | default:
1796 | fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope);
1797 | break;
1798 | }
1799 |
1800 |
1801 | /*
1802 | * Check for the presence of the mutex lock:
1803 | * if present,
1804 | * wait until it is available;
1805 | * else
1806 | * get the lock and proceed with the change of value.
1807 | */
1808 |
1809 | /*
1810 | * Write the new value of the variable to the correct place
1811 | * in the [appropriate] values array.
1812 | *
1813 | * Note that there is a check to see if malloc() actually worked .....
1814 | */
1815 |
1816 | hereValues[symbol].valPtr = (char *)malloc(80);
1817 | if (hereValues[symbol].valPtr == NULL)
1818 | {
1819 | fprintf(stderr, "Cannot alllocate memory for hereValuesvlPtr\n");
1820 | exit (8);
1821 | }
1822 | strcpy(hereValues[symbol].valPtr,newDir);
1823 |
1824 |
1825 | hereValues[symbol].strPtr = (char *)malloc(sizeof(newDir) );
1826 | if (hereValues[symbol].strPtr == NULL)
1827 | {
1828 | fprintf(stderr, "Cannot alllocate memory for hereValuestPtr\n");
1829 | exit (8);
1830 | }
1831 | strcpy(hereValues[symbol].strPtr, newDir);
1832 |
1833 | /*
1834 | * Free the temporary pointer, hereValues.
1835 | *
1836 | */
1837 | free(hereValues);
1838 | hereValues = NULL;
1839 |
1840 | /*
1841 | * Release the mutex lock.
1842 | */
1843 |
1844 | /*
1845 | * Write the new value of this variable back to the config file.
1846 | */
1847 |
1848 | }
1849 |
1850 |
1851 | void ca_set_string(int symbol)
1852 | {
1853 |
1854 | /****************************************************************
1855 | * ca_set_string() *
1856 | * *
1857 | * Parameters *
1858 | * symbol -- the symbol of the variable. *
1859 | * *
1860 | * Returns *
1861 | * 1 if successful, 0 if not successful ? *
1862 | * *
1863 | * Remarks *
1864 | * Writing the new value back to the config file has yet to *
1865 | * be implemented. *
1866 | * *
1867 | ****************************************************************/
1868 |
1869 | char newString[80]; /* May need to make this bigger. */
1870 |
1871 | /*
1872 | * Declare a pointer to a values_t variable.
1873 | * Later, we shall assign this pointer to the first element
1874 | * of either the globals or the locals array, as appropriate.
1875 | */
1876 | values_t *hereValues;
1877 |
1878 | /*
1879 | * Using the symbol, look in the appropriate place in the dictionary.
1880 | */
1881 | #ifdef DEBUG
1882 | printf("\nca_set_string() function called ..... \n");
1883 | printf("Variable type: %s\n", dictionary[symbol].varType);
1884 | #endif
1885 |
1886 | /*
1887 | * First, flush the input stream.
1888 | */
1889 | fflush(stdin);
1890 |
1891 | /*
1892 | * Prompt for the new value of the string.
1893 | */
1894 | printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName);
1895 | gets(newString);
1896 |
1897 | /*
1898 | * Make sure that a reasonable, sensible value of the string
1899 | * value has been read from the keyboard.
1900 | *
1901 | * How do we implement this ???
1902 | *
1903 | */
1904 |
1905 |
1906 | /*
1907 | * Make sure that the function is attempting to set the correct type
1908 | * of value. If not, do not set the value - and exit.
1909 | */
1910 |
1911 | if (strcmp(dictionary[symbol].varType, "CA_STRING") != 0)
1912 | {
1913 | fprintf(stderr, "Error: unexpected variable type.\n");
1914 | exit(51);
1915 | }
1916 |
1917 | /*
1918 | * Choose the appropriate values array.
1919 | * Assign a temporary pointer to this array.
1920 | */
1921 |
1922 | switch(dictionary[symbol].varScope)
1923 | {
1924 | /* If the variable has global scope,
1925 | * write it into the globals array.
1926 | * If it has local scope,
1927 | * write it into the locals array.
1928 | * If the scope cannot be found, report an error.
1929 | */
1930 | case 1:
1931 | hereValues = globals;
1932 | break;
1933 |
1934 | case 99:
1935 | hereValues = locals;
1936 | break;
1937 |
1938 | default:
1939 | fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope);
1940 | break;
1941 | }
1942 |
1943 |
1944 | /*
1945 | * Check for the presence of the mutex lock:
1946 | * if present,
1947 | * wait until it is available;
1948 | * else
1949 | * get the lock and proceed with the change of value.
1950 | */
1951 | mutex_lock(&Lock);
1952 |
1953 | /*
1954 | * Write the new value of the variable to the correct place
1955 | * in the [appropriate] values array.
1956 | * Note the check to the return value of malloc() to see if the
1957 | * memory was actually obtained.
1958 | */
1959 |
1960 | hereValues[symbol].valPtr = (char *)malloc(80);
1961 | if (hereValues[symbol].valPtr == NULL)
1962 | {
1963 | fprintf(stderr, "Cannot allocate memory for hereValues[symbol].valPtr\n");
1964 | exit (8);
1965 | }
1966 | strcpy(hereValues[symbol].valPtr, newString);
1967 |
1968 |
1969 | hereValues[symbol].strPtr = (char *)malloc(sizeof(newString) );
1970 | if (hereValues[symbol].strPtr == NULL)
1971 | {
1972 | fprintf(stderr, "Cannot allocate memory for hereValues[symbol].strPtr\n");
1973 | exit (8);
1974 | }
1975 | strcpy(hereValues[symbol].strPtr, newString);
1976 |
1977 | /*
1978 | * Free the temporary pointer, hereValues.
1979 | *
1980 | */
1981 | free(hereValues);
1982 | hereValues = NULL;
1983 |
1984 | /*
1985 | * Release the mutex lock.
1986 | */
1987 | mutex_unlock(&Lock);
1988 |
1989 | /*
1990 | * Write the new value of this variable back to the config file.
1991 | * Implement this later ?
1992 | */
1993 |
1994 | }
1995 |
1996 |
1997 | int ca_writeNewValue(int dictSymbol, char *newValue)
1998 | {
1999 |
2000 | FILE *confPtr; /* Pointer to config file */
2001 | FILE *tempPtr; /* The pointer to temp file. */
2002 | char name[STRLENGTH]; /* The name of the variable. */
2003 | char value[STRLENGTH]; /* The value of the variable. */
2004 |
2005 |
2006 | /*
2007 | * Find the actual name of the variable from the dictionary
2008 | * structure (use the variable symbol as an index into the
2009 | * array of dictionary structures.
2010 | */
2011 | #ifdef DEBUG
2012 | printf("Name of variable to be changed: %s\n", dictionary[dictSymbol].varName);
2013 | printf("Type of variable to be changed: %s\n", dictionary[dictSymbol].varType);
2014 | #endif /* DEBUG */
2015 |
2016 | /*
2017 | * Open the test config file for reading .....
2018 | */
2019 | if ( (confPtr = fopen(testFile, "r")) == NULL)
2020 | {
2021 | printf("File \"%s\" could not be opened.\n", testFile);
2022 | exit (51);
2023 | }
2024 |
2025 | /*
2026 | * Open the temporary file for writing .....
2027 | */
2028 | if ((tempPtr = fopen(tempFile, "w")) == NULL)
2029 | {
2030 | printf("File \"%s\" could not be opened.\n", tempFile);
2031 | exit (51);
2032 | }
2033 |
2034 | /*
2035 | * Read the first record in the test config file.
2036 | */
2037 |
2038 | fscanf(confPtr, "%s", name);
2039 | fgets(value, sizeof(value), confPtr);
2040 |
2041 | /*
2042 | * If the last character of "value" is '\n',
2043 | * replace it with '\0'.
2044 | */
2045 | if (value[strlen(value) - 1] == '\n')
2046 | {
2047 | #ifdef DEBUG
2048 | printf("The value string is %s", value);
2049 | printf("Replacing last character of \"%s\" with the NULL character\n", name);
2050 | #endif /* DEBUG */
2051 |
2052 | value[strlen(value) - 1] = '\0';
2053 |
2054 | #ifdef DEBUG
2055 | printf("The new value string is %s", value);
2056 | #endif /* DEBUG */
2057 | }
2058 |
2059 | /*
2060 | * If we read the variable that we want to change,
2061 | * replace the value of this variable in the config
2062 | * file with the value supplied from the keyboard.
2063 | *
2064 | */
2065 | if ( strcmp(name, dictionary[dictSymbol].varName) == 0)
2066 | {
2067 | strcpy(value, newValue);
2068 |
2069 | #ifdef DEBUG
2070 | printf("The replacement string is %s", value);
2071 | #endif /* DEBUG */
2072 | }
2073 |
2074 | /*
2075 | * While there are records to be read in the test config file:
2076 | * Write the current record into the temporary file.
2077 | * Read the next record in the config file.
2078 | * Repeat untill the EOF has been reached.
2079 | */
2080 |
2081 | while(!feof(confPtr) )
2082 | {
2083 | fprintf(tempPtr, "%s %s\n", name, value);
2084 | fscanf(confPtr, "%s", name);
2085 | fgets(value, sizeof(value), confPtr);
2086 |
2087 | /*
2088 | * If the last character of "value" is '\n',
2089 | * replace it with '\0'.
2090 | */
2091 | if (value[strlen(value) - 1] == '\n')
2092 | {
2093 | #ifdef DEBUG
2094 | printf("The last character of the value string is %c", value[strlen(value) - 1]);
2095 | printf("The value string is %s", value);
2096 | printf("Replacing last character of \"%s\" with the NULL character\n",name);
2097 | #endif /* DEBUG */
2098 |
2099 | value[strlen(value) - 1] = '\0';
2100 | #ifdef DEBUG
2101 | printf("The new value string is %s", value);
2102 | #endif /* DEBUG */
2103 | }
2104 |
2105 |
2106 | /*
2107 | * If we read the variable that we want to change,
2108 | * replace the value of this variable in the config
2109 | * file with the value supplied from the keyboard.
2110 | *
2111 | */
2112 | if ( strcmp(name, dictionary[dictSymbol].varName) == 0)
2113 | {
2114 | strcpy(value, newValue);
2115 |
2116 | #ifdef DEBUG
2117 | printf("The replacement string is %s", value);
2118 | #endif /* DEBUG */
2119 | }
2120 |
2121 | /*
2122 | * Flush the pointer to the test config file.
2123 | */
2124 | fflush(confPtr);
2125 |
2126 | }
2127 | /*
2128 | * Here ends the loop that writes the config file, with the
2129 | * new variable, to the temporary file.
2130 | */
2131 |
2132 | /*
2133 | *
2134 | * While !(the record to be updated)
2135 | * BEGIN
2136 | * Write the record to the temporary file
2137 | * Read the next record in the config file
2138 | * END
2139 | *
2140 | * Write the new value to the temporary file
2141 | * Read the next record in the config file
2142 | * COMMENT: this is the record to be updated.
2143 | * COMMENT: discard this record.
2144 | *
2145 | * Read the next record in the config file
2146 | *
2147 | * While !(EOF)
2148 | * BEGIN
2149 | * write the record to the temporary file
2150 | * read the next record in the config file
2151 | * END
2152 | *
2153 | * Close Config file
2154 | * Close Temporary file
2155 | *
2156 | * Open Temporary file for reading
2157 | * Open Config file for writing
2158 | *
2159 | * Read the next record of the Temporary file
2160 | *
2161 | * While (!EOF of Temporary file)
2162 | * BEGIN
2163 | * write the record into the Config file
2164 | * read the next record of the Temporary file
2165 | * END
2166 | *
2167 | * Close Temporary file
2168 | * Close Config file
2169 | *
2170 | */
2171 |
2172 | fclose(confPtr);
2173 | fclose(tempPtr);
2174 |
2175 | /*
2176 | * Now, flush the file pointers
2177 | */
2178 | fflush(confPtr);
2179 | fflush(tempPtr);
2180 |
2181 | /*
2182 | * Open the temporary file for reading.
2183 | * Open the config file for writing.
2184 | * Write the contents of the temporary file
2185 | * into the config file.
2186 | */
2187 |
2188 | /*
2189 | * Open the temporary file for reading .....
2190 | */
2191 | if ((tempPtr = fopen(tempFile, "r")) == NULL)
2192 | {
2193 | printf("File \"%s\" could not be opened for reading.\n", tempFile);
2194 | exit (51);
2195 | }
2196 |
2197 | /*
2198 | * Open the config file for writing .....
2199 | */
2200 | if ((confPtr = fopen(testFile, "w")) == NULL)
2201 | {
2202 | printf("File \"%s\" could not be opened for writing.\n", testFile);
2203 | exit (51);
2204 | }
2205 |
2206 | /*
2207 | * Read the first record in the temporary file.
2208 | */
2209 |
2210 | fscanf(tempPtr, "%s", name);
2211 | fgets(value, sizeof(value), tempPtr);
2212 | #ifdef DEBUG
2213 | printf("\nFIRST LINE: %s %s", name, value);
2214 | #endif /* DEBUG */
2215 |
2216 | /*
2217 | * While there are records to be read in the temporary file:
2218 | * Write the current record into the test config file.
2219 | * Read the next record in the temporary file.
2220 | * Repeat untill the EOF has been reached.
2221 | */
2222 |
2223 | while(!feof(tempPtr) )
2224 | {
2225 | fprintf(confPtr, "%s %s", name, value);
2226 | fscanf(tempPtr, "%s", name);
2227 | fgets(value, sizeof(value), tempPtr);
2228 | }
2229 |
2230 | fclose(confPtr);
2231 | fclose(tempPtr);
2232 | unlink(tempFile);
2233 |
2234 | return(0);
2235 | }
2236 |
2237 |
2238 | int ca_getStorageLocation(char *confVar, dict_t woordenboek[], int size)
2239 | /*************************************************************
2240 | * ca_getStorageLocation() *
2241 | * - takes the name of a config variable and searches the *
2242 | * dictionary structure for the storage location for this *
2243 | * variable. *
2244 | * *
2245 | * Parameters *
2246 | * confVar -- the string variable that contains the name *
2247 | * of the variable. *
2248 | * woordenboek -- the dictionary structure to be searched *
2249 | * size -- the size of the dictionary structure to *
2250 | * searched. *
2251 | * *
2252 | * Returns *
2253 | * the location (integer) in the values array. *
2254 | * *
2255 | *************************************************************/
2256 | {
2257 | int i,
2258 | where,
2259 | found = 0 ; /* Whether or not the symbol has been found. */
2260 |
2261 |
2262 | #ifdef DEBUG
2263 | printf("The variable name in ca_getStorageLocation is: %s\n", confVar);
2264 | #endif /* DEBUG */
2265 |
2266 | /*
2267 | * Compares each name in the dictionary with the one for which
2268 | * we are looking.
2269 | */
2270 | i = 0;
2271 | while (!found && i <= size)
2272 | {
2273 | if (strcmp(woordenboek[i].varName, confVar) == 0)
2274 | {
2275 | found = 1;
2276 | }
2277 | else
2278 | {
2279 | ++i;
2280 | }
2281 | }
2282 |
2283 | /*
2284 | * Returns the storage location for the given variable name
2285 | * or else returns NOT_FOUND
2286 | */
2287 | if (found)
2288 | {
2289 | /* mySymbol = atoi(woordenboek[i].varSym); */
2290 | printf("Symbol is %s\n", woordenboek[i].varSym);
2291 | printf("Storage Location is: %d\n", woordenboek[i].varNum);
2292 | where = woordenboek[i].varNum;
2293 | }
2294 | else
2295 | {
2296 | fprintf(stderr, "Error: cannot find storage location for variable %s\n", confVar);
2297 | where = NOT_FOUND;
2298 | }
2299 | return (where);
2300 |
2301 | }
2302 |
2303 |
2304 | void ca_getConfig(values_t confVars[], int size)
2305 | /*************************************************************
2306 | * ca_getConfig -- prints the strings representing the *
2307 | * values of the configuration variables *
2308 | * *
2309 | * Parameters *
2310 | * confVars -- the values_t array which stores the *
2311 | * values of the configuration variables. *
2312 | * size -- the number of configuration variables, *
2313 | * the number of elements in the confVars array *
2314 | * *
2315 | * *
2316 | *************************************************************/
2317 | {
2318 | int i = 0; /* A counting variable. */
2319 |
2320 | puts("A dump of the strings of the values of the Config Vars:");
2321 | puts("Number\t\tString");
2322 | puts("----------");
2323 |
2324 | while (i < size)
2325 | {
2326 | printf("%d\t\t%s\n", i, confVars[i].strPtr);
2327 | ++i;
2328 | }
2329 |
2330 | }
2331 |
2332 |
2333 | int ca_getType(char *confVar, dict_t woordenboek[], int size)
2334 | /****************************************************************
2335 | * ca_getType -- returns the data type of the variable. *
2336 | * *
2337 | * Parameters *
2338 | * confVar -- the name of the configuration variable. *
2339 | * woordenboek -- the array of dict_t structures. *
2340 | * size -- the number of configuration variables. *
2341 | * *
2342 | * Returns *
2343 | * an integer representing the data type of the variable *
2344 | * *
2345 | ****************************************************************/
2346 | {
2347 | int i = 0, /* Counter variable. */
2348 | found = 0; /* Set this == 1 when we find the variable. */
2349 | int myType; /* Integer representing the type of the config variable. */
2350 |
2351 | /*
2352 | * Compare each name in the dictionary with the one for which we
2353 | * are looking.
2354 | */
2355 |
2356 | myType = 0;
2357 |
2358 | #ifdef DEBUG
2359 | printf("ca_getType function called for variable: %s\n", confVar);
2360 | #endif /* DEBUG */
2361 |
2362 | while (!found && i <= size)
2363 | {
2364 | if (strcmp(woordenboek[i].varName, confVar) == 0)
2365 | {
2366 | found = 1;
2367 | #ifdef DEBUG
2368 | printf("ca_getType function: %s, %s matched.\n", woordenboek[i].varName, confVar);
2369 | #endif /* DEBUG */
2370 | }
2371 | else
2372 | {
2373 | ++i;
2374 | }
2375 | }
2376 |
2377 | /*
2378 | * Return the type of the config variable or
2379 | * else return "NOT FOUND".
2380 | */
2381 | if (found)
2382 | {
2383 | if(strcmp(woordenboek[i].varType, "CA_INT") == 0)
2384 | {
2385 | #ifdef DEBUG
2386 | printf("ca_getType function: %s variable of type %s is Integer type\n", woordenboek[i].varName, woordenboek[i].varType);
2387 |
2388 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2389 | #endif /* DEBUG */
2390 | myType = 11;
2391 | printf("For type CA_INT, myType is %d\n", myType);
2392 | #ifdef DEBUG
2393 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2394 | #endif /* DEBUG */
2395 | }
2396 | else
2397 | {
2398 | if(strcmp(woordenboek[i].varType, "CA_STRING") == 0)
2399 | {
2400 | #ifdef DEBUG
2401 | printf("ca_getType function: %s variable of type %s is String type\n", woordenboek[i].varName, woordenboek[i].varType);
2402 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2403 | #endif /* DEBUG */
2404 | myType = 12;
2405 | #ifdef DEBUG
2406 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2407 | #endif /* DEBUG */
2408 | }
2409 | else
2410 | {
2411 | if (strcmp(woordenboek[i].varType, "CA_DIRLIST") == 0 )
2412 | {
2413 | #ifdef DEBUG
2414 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2415 | #endif /* DEBUG */
2416 | myType = 13;
2417 | #ifdef DEBUG
2418 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2419 | #endif /* DEBUG */
2420 | }
2421 | else
2422 | {
2423 | if (strcmp(woordenboek[i].varType, "CA_BOOLEAN") == 0)
2424 | {
2425 | #ifdef DEBUG
2426 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2427 | #endif /* DEBUG */
2428 | myType = 14;
2429 | #ifdef DEBUG
2430 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2431 | #endif /* DEBUG */
2432 | }
2433 | else
2434 | {
2435 | if (strcmp(woordenboek[i].varType, "CA_SOURCETYPE") == 0)
2436 | {
2437 | #ifdef DEBUG
2438 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType);
2439 | #endif /* DEBUG */
2440 | myType = 15;
2441 | #ifdef DEBUG
2442 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType);
2443 | #endif /* DEBUG */
2444 | }
2445 | }
2446 | }
2447 | }
2448 | }
2449 | }
2450 | else
2451 | {
2452 | myType = NOT_FOUND;
2453 | }
2454 | return(myType);
2455 | }