## 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_malloc
25. ca_set_boolean
26. ca_set_dirlist
27. ca_set_string
28. ca_writeNewValue
29. ca_getStorageLocation
30. ca_getConfig
31. ca_getType

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

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