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