modules/ca/ca_configFns.c

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

FUNCTIONS

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

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

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