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

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