modules/ca/ca_configFns.c

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

DEFINITIONS

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

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

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