Source File modules/ca/ca_configFns.c

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