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