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