## modules/ca/ca_configFns.c

/* [<][>][^][v][top][bottom][index][help] */

## FUNCTIONS

This source file includes following functions.

1. stringPack
2. ca_populateDictionary
3. opSplitsen
4. ca_readConfig
5. ca_getDictionary
6. ca_get_int
7. ca_get_dirlist
8. ca_get_string
9. ca_get_boolean
10. ca_set_int
11. ca_change_int_value
12. testFunction
13. ca_getDatabase
14. ca_getSource
15. ca_getAllSources
16. ca_getAsource
17. ca_getSourceDetails
18. ca_get_SourceHandleByPosition
19. ca_get_SourceHandleByName
20. ca_srchandle2Strelement
21. ca_srchandle2Intelement
22. ca_get_adminStrElement
23. ca_get_adminIntElement
24. ca_set_boolean
25. ca_set_dirlist
26. gets
27. ca_writeNewValue
28. ca_getStorageLocation
29. ca_getConfig
30. ca_getType
31. ca_get_UpdSourceHandle
32. ca_UpdSrcHandle2StrElement
33. ca_UpdSrcHandle2IntElement
34. ca_sanityChk
35. ca_mandVarChk

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

/* [<][>][^][v][top][bottom][index][help] */