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