Source File modules/ca/ca_configFns.c

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