modules/ca/ca_sourceLoader.c

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

FUNCTIONS

This source file includes following functions.
  1. ca_readSources
  2. ca_getAllDatabases
  3. ca_getAllMirrors
  4. ca_parseDbLine
  5. ca_parseNrtmLine
  6. ca_parseSrcLine
  7. ca_getDbHandleByName
  8. ca_getNrtmHandleByName

   1 /***************************************
   2   $Revision:
   3 
   4   CA module: definitions of functions that read a file of databases and
   5              sources.
   6 
   7   Status: NOT REVIEWED, NOT TESTED
   8 
   9   Author(s):       Ambrose Magee
  10 
  11 ******************//******************
  12 Modification History:
  13 
  14 ******************/
  15 
  16 /************************************
  17 Copyright (c) 2000,2001,2002                    RIPE NCC
  18 
  19 All Rights Reserved
  20 
  21 Permission to use, copy, modify, and distribute this software and its
  22 documentation for any purpose and without fee is hereby granted,
  23 provided that the above copyright notice appear in all copies and that
  24 both that copyright notice and this permission notice appear in
  25 supporting documentation, and that the name of the author not be
  26 used in advertising or publicity pertaining to distribution of the
  27 software without specific, written prior permission.
  28 
  29 THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  30 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
  31 AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  32 DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  33 AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  34 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  35 ***************************************/
  36 
  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 */     /* Swich OFF Debugging. */
  46 
  47 /*******************************************************
  48   * This file contains the definitions of functions     *
  49  * that read a file of databases and sources.        *
  50  *******************************************************/
  51 
  52 
  53 void
  54 ca_readSources(const char *sourcesDefFile, values_t confVars[])
     /* [<][>][^][v][top][bottom][index][help] */
  55 /*******************************************************************
  56  *                                             *
  57  * ca_readSources -- parses the Sources file and writes the values  *
  58  *              into memory.                        *
  59  *                                            *
  60  * Parameters                                    *
  61   *    sourcesFile  -- the file of databases, mirrors, sources    *
  62   *    confVars[]  --  the array of values structures          *
  63  *                                            *
  64  * Returns                                      *
  65   *    Nothing -- perhaps make this return 0 on successful exit ?  *
  66  *                                            *
  67  *******************************************************************/
  68 {
  69         FILE *sourcesFilePtr;   /* Pointer to Source file. */
  70         char line[80];  /* The current line of input. */
  71         const char *comment = "#";      /* Declared as a string. */
  72 #ifdef DEBUG
  73         char name[STRLENGTH_M]; /* The name of the config variable */
  74         char value[STRLENGTH_XXL];      /* The value of the variable */
  75         /* 640 characters */
  76 
  77         int location;   /* Storage Location of the variable's value. */
  78         int type;       /* Data type of the variable, represented by an
  79                          * integer. */
  80 
  81         const char *blankLine = "\n";   /* Declared as a string, not a
  82                                          * character. */
  83 
  84         char dbcomp[16];        /* Component of a databse. */
  85         char nrtmcomp[16];      /* Component of an nrtm. */
  86         int mode;       /* The mode of operation of the src */
  87         char srcOptions[16];    /* The options of a source. */
  88         char nrtMirror[STRLENGTH_M];    /* The elements of a NRTM */
  89         int updatePort; /* The update port of the source */
  90         /* N. B.  This is not the same as the */
  91         /* updPort in the UPDSOURCE variables. */
  92 #endif  /* DEBUG */
  93         char source[16];        /* The name of a source. */
  94         char database[16];      /* The name of a database. */
  95         char mirror[16];        /* The name of a mirror. */
  96         char varName[16];       /* Temporary variable */
  97 
  98 
  99 
 100         ca_database_t *newDbPtr;        /* A pointer to a new instance of */
 101         /* ca_database_t.                 */
 102 
 103         ca_mirror_t *newMirrPtr;        /* A pointer to a new instance of */
 104         /* ca_mirror_t.                   */
 105 
 106         ca_dbSource_t *newSrcPtr;       /* A pointer to a new instance of */
 107         /* ca_database_list_t.            */
 108 
 109         int in_DATABASE_def, in_NRTM_def, in_SOURCE_def;
 110         /* When we are reading the definition */
 111         /* of a database, nrtm, source, etc.  */
 112         /* this is set to 1.  Otherwise, it */
 113         /* is 0. */
 114 
 115 int no_source_defd;
 116 /* At least one source _must_ be defined.               */
 117 /* If one or more sources are defined, then     */
 118 /* this variable is set to 0.  Otherwise,               */
 119 /* this is 1.                                                                                   */
 120 
 121         /*
 122          * Function prototypes of ca_parseDbLine(), ca_parseNrtmLine() and
 123          * ca_parseSrcLine().  We put them here so that it can only be called
 124          * from within the ca_readSources() function.
 125          */
 126         void ca_parseDbLine(char *, ca_database_t *);
 127         void ca_parseNrtmLine(char *, ca_mirror_t *);
 128         void ca_parseSrcLine(char *, ca_dbSource_t *);
 129 
 130 
 131 #ifdef DEBUG
 132         printf("\nInside ca_readSources() function.\n");
 133         printf("Sources file is: %s\n", sourcesDefFile);
 134 #endif  /* DEBUG */
 135 
 136         /*
 137          * Open the sources file for reading .....
 138          */
 139         if ((sourcesFilePtr = fopen(sourcesDefFile, "r")) == NULL) {
 140                 printf("Error: the file %s could not be opened.\n", sourcesDefFile);
 141                 die;
 142         }
 143 
 144         /* Before reading the file, we initialise all flags to 0. */
 145         in_DATABASE_def = 0;
 146         in_NRTM_def = 0;
 147         in_SOURCE_def = 0;
 148         no_source_defd = 1;
 149 
 150         /*
 151          * Read the first line of the file. Remove leading and trailing
 152          * blank-space characters. if the first character of the line is a
 153          * comment or if it is a blank-line, continue.
 154          * 
 155          */
 156 
 157         fgets(line, sizeof(line), sourcesFilePtr);
 158         g_strstrip(line);
 159 
 160         /*
 161          * While there are lines to be read in the sources file, process the
 162          * current line and read the next line.
 163          */
 164 
 165         while (!feof(sourcesFilePtr)) {
 166 #ifdef DEBUG
 167                 printf("line:%s:End of line\n", line);
 168                 printf("Length of line: %d\n", strlen(line));
 169 #endif  /* DEBUG */
 170 
 171                 /*
 172                  * Ignore comments and empty lines.
 173                  */
 174                 if ((strncmp(line, comment, 1) == 0) || (strlen(line) == 0)) {
 175 #ifdef DEBUG
 176                         printf("We are reading a comment or an empty line ..... \n");
 177 #endif  /* DEBUG */
 178                         fgets(line, sizeof(line), sourcesFilePtr);
 179                         g_strstrip(line);
 180                         continue;
 181                 }
 182 
 183                 /* Testing */
 184 #ifdef DEBUG
 185                 printf("LINE >>>%sEND_OF_LINE\n", line);
 186 #endif  /* DEBUG */
 187 
 188                 /*
 189                  * if we are in a DATABASE definition then have we read all
 190                  * of the definition ? if yes, then commit the definition,
 191                  * reset the 'Database' flag and read the next line.
 192                  * Otherwise parse the line and store the details in
 193                  * temporary variables.
 194                  */
 195 
 196                 /* If we are in a DATABASE definition */
 197                 if (in_DATABASE_def) {
 198                         /*
 199                          * If we have reached the end of a DATABASE
 200                          * definition, commit the definition.
 201                          */
 202 
 203                         if (strcmp(line, "/DATABASE") == 0) {
 204                                 /* Commit the definition */
 205                                 /* Some code. */
 206 #ifdef DEBUG
 207                                 puts("We have reached the end of a DATABASE definition");
 208                                 puts("Testing the population of the db structure:");
 209                                 printf("\n%s::%d::%s::%s::%s\n", newDbPtr->host, newDbPtr->port, newDbPtr->user, newDbPtr->password, newDbPtr->dbName);
 210 #endif  /* DEBUG */
 211 
 212                         /*
 213                          * Check that the definition of the DATABASE is complete.
 214                          */
 215                          if ( !(newDbPtr->host && newDbPtr->port && newDbPtr->user && newDbPtr->password && newDbPtr->dbName) )
 216                                 {
 217                                 fprintf(stderr, "Error: definition of database is incomplete.\n");
 218                                 die;
 219                                 }
 220 
 221                                 /*
 222                                  * Commit the definition to the linked list
 223                                  * of Databases.
 224                                  */
 225 
 226                                 dbList = g_slist_append(dbList, newDbPtr);
 227 
 228                                 /*
 229                                  * We have reached the end of the DATABASE
 230                                  * definition
 231                                  */
 232                                 /* Thus, reset the flag and free some memory. */
 233                                 in_DATABASE_def = 0;
 234 
 235 
 236                                 /*
 237                                  * Read the next line and do the conditional
 238                                  * test.
 239                                  */
 240                                 fgets(line, sizeof(line), sourcesFilePtr);
 241                                 g_strstrip(line);
 242                                 continue;
 243                         }
 244 
 245                         /*
 246                          * Otherwise, parse the line and fill in the
 247                          * structure of the Database.
 248                          */
 249                         ca_parseDbLine(line, newDbPtr);
 250 
 251                 }
 252 
 253                 /*
 254                  * If we have found the _beginning_ of a Database definition,
 255                  * then set the in_DATABASE_def flag and allocate space, etc.
 256                  * for the database.
 257                  */
 258 
 259                 if ((!in_DATABASE_def) && (strncmp(line, DATABASE_KEY, strlen(DATABASE_KEY)) == 0)) {
 260                         in_DATABASE_def = 1;
 261 
 262                         /* Allocate space for the database */
 263                         /* Current_db = fscanf etc.) */
 264                         /* Fill in the defaults. */
 265 #ifdef DEBUG
 266                         puts("Beginning of a database defintion ..... ");
 267 #endif  /* DEBUG */
 268 
 269                         sscanf(line, "%s %s", varName, database);
 270                         g_strstrip(database);
 271 
 272 #ifdef DEBUG
 273                         printf("Database name is: %s\n", database);
 274 #endif  /* DEBUG */
 275 
 276                         /*
 277                          * Create a structure for the database.
 278                          */
 279                         newDbPtr = UT_calloc(1, sizeof(ca_database_t));
 280                         /*
 281                          *      if (newDbPtr == NULL) {
 282                     *           fprintf(stderr, "Cannot allocate memory to new db structure\n");
 283                     *           die;
 284                                         }
 285                          */
 286 
 287                         /* Assign the name of the database */
 288                         strcpy(newDbPtr->dbName, database);
 289 
 290                 }
 291 
 292 
 293                 /********************
 294                        * NRTM definition  *
 295                        ********************/
 296 
 297                 /*
 298                  * if we are in a NRTM definition then have we read all of
 299                  * the definition ? if yes, then commit the definition and
 300                  * read the next line. otherwise parse the line and store the
 301                  * details in temporary variables.
 302                  */
 303 
 304                 /* If we are in a NRTM definition */
 305                 if (in_NRTM_def) {
 306                         /*
 307                          * If we have reached the end of a NRTM definition,
 308                          * commit the definition.
 309                          */
 310                         if (strcmp(line, "/NRTM") == 0) {
 311                                 /* Commit the definition */
 312                                 /* Some code. */
 313 #ifdef DEBUG
 314                                 puts("We have reached the end of a NRTM definition");
 315                                 puts("Testing the population of the mirror structure:");
 316                                 printf("\n%s::%d::%d::%d\n", newMirrPtr->host, newMirrPtr->port, newMirrPtr->delay, newMirrPtr->protocolVer);
 317 #endif  /* DEBUG */
 318 
 319 
 320                         /*
 321                          * Check that the definition of the NRTM is complete.
 322                          */
 323                          if ( !( newMirrPtr->host && newMirrPtr->port && newMirrPtr->protocolVer) && (newMirrPtr->delay < 0) )
 324                                 {
 325                                 fprintf(stderr, "Error: definition of near-real-time-mirror is incomplete.\n");
 326                                 die;
 327                                 }
 328                                 /*
 329                                  * Commit the definition to the linked list
 330                                  * of nrt-mirrors.
 331                                  */
 332 
 333                                 nrtmList = g_slist_append(nrtmList, newMirrPtr);
 334 
 335                                 /*
 336                                  * We have reached the end of the NRTM
 337                                  * definition
 338                                  */
 339                                 /* Thus, reset the NRTM flag. */
 340                                 in_NRTM_def = 0;
 341 
 342                                 /*
 343                                  * Read the next line and do the conditional
 344                                  * test.
 345                                  */
 346                                 fgets(line, sizeof(line), sourcesFilePtr);
 347                                 g_strstrip(line);
 348                                 continue;
 349                         }
 350 
 351                         /*
 352                          * Otherwise, parse the line and fill in the
 353                          * structure of the NRMT.
 354                          */
 355 
 356                         ca_parseNrtmLine(line, newMirrPtr);
 357                 }
 358 
 359                 /*
 360                  * If we have found the beginning of a Near-Real-Time-Mirror
 361                  * definition, then set the in_NRTM_def flag and allocate
 362                  * space, etc. for the Near-Real-Time-Mirror.
 363                  */
 364 
 365                 if ((!in_NRTM_def) && (strncmp(line, NRTM_KEY, strlen(NRTM_KEY)) == 0)) {
 366                         in_NRTM_def = 1;
 367                         /* Allocate space for the Near-Real-Time-Mirror. */
 368                         /* Current_db = fscanf etc.) */
 369                         /* Fill in the defaults. */
 370 #ifdef DEBUG
 371                         puts("Beginning of a Near-Real-Time-Mirror defintion ..... ");
 372 #endif  /* DEBUG */
 373 
 374                         sscanf(line, "%s %s", varName, mirror);
 375 
 376                         /*
 377                          * Create a structure for the mirror.
 378                          */
 379                         newMirrPtr = UT_calloc(1, sizeof(ca_mirror_t));
 380 /*
 381  * No need to verify that NULL has not been returned.
 382  *
 383  *              if (newMirrPtr == NULL) {
 384  *                              fprintf(stderr, "Cannot allocate memory to new nrtm structure\n");
 385         *                       die;
 386  *                      }
 387  */
 388 
 389                         /* Assign the name of the mirror ? */
 390                         strcpy(newMirrPtr->mrName, mirror);
 391 
 392                 }
 393 
 394                 /*********************
 395                        * SOURCE Definition *
 396                        *********************/
 397 
 398                 /*
 399                  * if we are in a SOURCE definition then have we read all of
 400                  * the definition ? if yes, then commit the definition, reset
 401                  * the 'Database' flag and read the next line. Otherwise
 402                  * parse the line and store the details in temporary
 403                  * variables.
 404                  */
 405 
 406                 /* If we are in a SOURCE definition */
 407                 if (in_SOURCE_def) {
 408                         /*
 409                          * If we have reached the end of a SOURCE definition,
 410                          * commit the definition.
 411                          */
 412 
 413                         if (strcmp(line, "/SOURCE") == 0) {
 414                                 /* Commit the definition */
 415                                 /* Some code. */
 416 #ifdef DEBUG
 417                                 puts("We have reached the end of a SOURCE definition");
 418                                 puts("Testing the population of the new Source structure:");
 419                                 printf("Source name: %s\n", newSrcPtr->name);
 420                                 printf("\nDB == %s::%d::%s::%s::%s\n", (newSrcPtr->db).host, (newSrcPtr->db).port, (newSrcPtr->db).user, (newSrcPtr->db).password, (newSrcPtr->db).dbName);
 421                                 printf("Mode: %d\n", newSrcPtr->opMode);
 422                                 printf("NRTM == %s::%d::%d:%d\n", (newSrcPtr->nrtm).host, (newSrcPtr->nrtm).port, (newSrcPtr->nrtm).delay, (newSrcPtr->nrtm).protocolVer);
 423                                 printf("UpdPort: %d\n", newSrcPtr->updPort);
 424                                 printf("New Source Options == %s::%s\n", newSrcPtr->canupd, newSrcPtr->deflook);
 425 #endif  /* DEBUG */
 426 
 427 
 428                         /*
 429                          * Check that the definition of the SOURCE is complete.
 430                          */
 431                          if ( !(newSrcPtr->name && newSrcPtr->updPort && newSrcPtr->canupd && newSrcPtr->deflook) && (newSrcPtr->opMode < 0) )
 432                                 {
 433                                 fprintf(stderr, "Error: definition of source is incomplete.\n");
 434                                 die;
 435                                 }
 436                                 /*
 437                                  * Commit the definition to the linked list
 438                                  * of Sources.
 439                                  */
 440 
 441                                 sourceList = g_slist_append(sourceList, newSrcPtr);
 442 
 443                                 /*
 444                                  * We have reached the end of the SOURCE
 445                                  * definition
 446                                  */
 447                                 /* Thus, reset the flag and free some memory. */
 448                                 in_SOURCE_def = 0;
 449 
 450 
 451                                 /*
 452                                  * Read the next line and do the conditional
 453                                  * test.
 454                                  */
 455                                 fgets(line, sizeof(line), sourcesFilePtr);
 456                                 g_strstrip(line);
 457                                 continue;
 458                         }
 459 
 460                         /*
 461                          * Otherwise, parse the line and fill in the
 462                          * structure of the Database.
 463                          */
 464                         ca_parseSrcLine(line, newSrcPtr);
 465 
 466                 }
 467 
 468                 /*
 469                  * If we have found the _beginning_ of a SOURCE definition,
 470                  * then set the in_SOURCE_def flag and allocate space, etc.
 471                  * for the database.
 472                  * We also set the no_source_defd flag.
 473                  */
 474 
 475                 if ((!in_SOURCE_def) && (strncmp(line, SOURCE_KEY, strlen(SOURCE_KEY)) == 0)) {
 476                         in_SOURCE_def = 1;
 477                         no_source_defd = 0;
 478 
 479                         /* Allocate space for the Source */
 480                         /* Current_source = fscanf etc.) */
 481                         /* Fill in the defaults. */
 482 #ifdef DEBUG
 483                         puts("Beginning of a Source defintion ..... ");
 484 #endif  /* DEBUG */
 485 
 486                         sscanf(line, "%s %s", varName, source);
 487                         g_strstrip(source);
 488 
 489 #ifdef DEBUG
 490                         printf("Source name is: %s\n", source);
 491 #endif  /* DEBUG */
 492 
 493                         /*
 494                          * Create a structure for the source.
 495                          * 
 496                          */
 497                         newSrcPtr = UT_calloc(1, sizeof(ca_dbSource_t));
 498 
 499                         /*
 500                          * No need to check that NULL has not been returned.
 501                          *
 502                          * if (newSrcPtr == NULL) {
 503                     *           fprintf(stderr, "Cannot allocate memory to new Source structure\n");
 504                     *           die;
 505                          * }
 506                          */
 507 
 508                         /* Assign the name of the Source */
 509                         strcpy(newSrcPtr->name, source);
 510 
 511                 }
 512 
 513                 /* Read the next line. */
 514                 fgets(line, sizeof(line), sourcesFilePtr);
 515                 g_strstrip(line);
 516 
 517                 /* End of while loop; i.e. end of processing a line. */
 518         }
 519 
 520         /* Close the sources definition file. */
 521         fclose(sourcesFilePtr);
 522 
 523         /* End of ca_readSources() function */
 524 
 525 if (no_source_defd != 0)
 526                 {
 527                 fprintf(stderr, "Error: No source defined !!!\n");
 528                 die;
 529                 }
 530 }
 531 
 532 void
 533 ca_getAllDatabases(GSList * databases)
     /* [<][>][^][v][top][bottom][index][help] */
 534 {
 535         GSList *currentPtr;     /* Pointer to the structure at which we look. */
 536 
 537         /*
 538          * Look at the first member of the linked-list of sources.
 539          */
 540         currentPtr = databases;
 541 
 542         /*
 543          * Look at each data component of the source list, untill we reach
 544          * the end of the list.
 545          */
 546         while (currentPtr != NULL) {
 547                 ca_database_t *dbPtr = currentPtr->data;
 548                 printf("\n%s,%d,%s,%s,%s\n", dbPtr->host, dbPtr->port, dbPtr->user, dbPtr->password, dbPtr->dbName);
 549                 currentPtr = currentPtr->next;
 550         }
 551 }
 552 
 553 
 554 void
 555 ca_getAllMirrors(GSList * mirrors)
     /* [<][>][^][v][top][bottom][index][help] */
 556 {
 557         GSList *currentPtr;     /* Pointer to the structure at which we look. */
 558 
 559         /*
 560          * Look at the first member of the linked-list of sources.
 561          */
 562         currentPtr = mirrors;
 563 
 564         /*
 565          * Look at each data component of the source list, untill we reach
 566          * the end of the list.
 567          */
 568         while (currentPtr != NULL) {
 569                 ca_mirror_t *nrtmPtr = currentPtr->data;
 570                 printf("\n%s,%d,%d,%d, %s\n", nrtmPtr->host, nrtmPtr->port, nrtmPtr->delay, nrtmPtr->protocolVer, nrtmPtr->mrName);
 571                 currentPtr = currentPtr->next;
 572         }
 573 }
 574 
 575 void
 576 ca_parseDbLine(char *lineStr, ca_database_t * dbStructPtr)
     /* [<][>][^][v][top][bottom][index][help] */
 577 /*******************************************************************
 578  *                                             *
 579  * ca_parseLine  -- parses the a line in the Sources file and     *
 580  *             writes the values into temporary variables.    *
 581  *                                            *
 582  * Parameters                                    *
 583   *    lineStr     -- the current line of the Sources file       *
 584  *               -- a NULL terminated string            *
 585   *    dbStructPtr  -- the db we are filling                 *
 586   *              -- a pointer to a ca_database_t structure.  *
 587  *                                            *
 588  * Returns                                      *
 589   *    Nothing -- perhaps make this return 0 on successful exit ?  *
 590  *                                            *
 591  *******************************************************************/
 592 {
 593         char dbComp[64];        /* Component of a database. */
 594         char varName[16];       /* The name of the variable. */
 595 
 596         gchar **tokens; /* Pointer to an array of strings. */
 597 
 598 #ifdef DEBUG
 599         int i;  /* A counting variable. */
 600 #endif  /* DEBUG */
 601 
 602         /*
 603          * Split the line on the ':' character. Then, for both the name of
 604          * the variable and its value, remove leading and trailing
 605          * blank-space characters.
 606          * We set max_tokens to be 1 to allow ':' in the password.
 607          */
 608         tokens = g_strsplit(lineStr, ":", 1);
 609 
 610 #ifdef DEBUG
 611         for (i = 0; tokens[i] != NULL; i++)
 612                 printf("tokens[%d] = %s\n", i, tokens[i]);
 613 #endif  /* DEBUG */
 614 
 615         strcpy(varName, tokens[0]);
 616         strcpy(dbComp, tokens[1]);
 617 
 618         /* Free the memory used by the tokens array. */
 619         g_strfreev(tokens);
 620 
 621         /* Remove leading and trailing blank-space characters. */
 622         g_strstrip(varName);
 623         g_strstrip(dbComp);
 624 
 625 #ifdef DEBUG
 626         printf("VarName: %s; dbComp: %s\n", varName, dbComp);
 627 #endif  /* DEBUG */
 628 
 629         if (strcmp(varName, "host") == 0) {
 630                 strcpy(dbStructPtr->host, dbComp);
 631         }
 632         else {
 633                 if (strcmp(varName, "port") == 0) {
 634                         dbStructPtr->port = atoi(dbComp);
 635                 }
 636                 else {
 637                         if (strcmp(varName, "user") == 0) {
 638                                 strcpy(dbStructPtr->user, dbComp);
 639                         }
 640                         else {
 641                                 if (strcmp(varName, "password") == 0) {
 642                                         strcpy(dbStructPtr->password, dbComp);
 643                                 }
 644                                 else {
 645                                         fprintf(stderr, "Unknown database component \"%s\".\n", dbComp);
 646                                         die;
 647                                 }
 648                         }
 649                 }
 650         }
 651 }
 652 
 653 
 654 
 655 void
 656 ca_parseNrtmLine(char *lineStr, ca_mirror_t * mrStructPtr)
     /* [<][>][^][v][top][bottom][index][help] */
 657 /*
 658  * */
 659 {
 660         char nrtmComp[64];      /* Component of a NRTM. */
 661         char varName[16];       /* The name of the variable. */
 662 
 663         gchar **tokens; /* Pointer to an array of strings. */
 664 
 665 #ifdef DEBUG
 666         int i;  /* A counting variable. */
 667 #endif  /* DEBUG */
 668 
 669         /*
 670          * Split the line on the ':' character. Then, for both the name of
 671          * the variable and its value, remove leading and trailing
 672          * blank-space characters.
 673   * We set max_tokens to be 1; thus the line is split after the first
 674   * ':'.
 675          */
 676         tokens = g_strsplit(lineStr, ":", 1);
 677 
 678 #ifdef DEBUG
 679         for (i = 0; tokens[i] != NULL; i++)
 680                 printf("tokens[%d] = %s\n", i, tokens[i]);
 681 #endif  /* DEBUG */
 682 
 683         strcpy(varName, tokens[0]);
 684         strcpy(nrtmComp, tokens[1]);
 685 
 686         /* Free the memory used by the tokens array. */
 687         g_strfreev(tokens);
 688 
 689         /* Remove leading and trailing blank-space characters. */
 690         g_strstrip(varName);
 691         g_strstrip(nrtmComp);
 692 
 693 #ifdef DEBUG
 694         printf("VarName: %s; nrtmComp: %s\n", varName, nrtmComp);
 695 #endif  /* DEBUG */
 696 
 697 
 698         if (strcmp(varName, "host") == 0) {
 699                 strcpy(mrStructPtr->host, nrtmComp);
 700         }
 701         else {
 702                 if (strcmp(varName, "port") == 0) {
 703                         mrStructPtr->port = atoi(nrtmComp);
 704                 }
 705                 else {
 706                         if (strcmp(varName, "delay") == 0) {
 707                                 mrStructPtr->delay = atoi(nrtmComp);
 708                         }
 709                         else {
 710                                 if (strcmp(varName, "protocolVersion") == 0) {
 711                                         mrStructPtr->protocolVer = atoi(nrtmComp);
 712                                 }
 713                                 else {
 714                                         fprintf(stderr, "Unknown mirror component \"%s\".\n", nrtmComp);
 715                                         die;
 716                                 }
 717                         }
 718          }
 719  }
 720 }
 721 
 722 
 723 
 724 
 725 void
 726 ca_parseSrcLine(char *lineStr, ca_dbSource_t * srcStructPtr)
     /* [<][>][^][v][top][bottom][index][help] */
 727 /*
 728  * ca_parseSrcLine() function.
 729  */
 730 {
 731         char srcComp[64];       /* Component of a database. */
 732         char varName[16];       /* The name of the variable. */
 733 
 734         gchar **tokens; /* Pointer to an array of strings. */
 735 
 736 #ifdef DEBUG
 737         int i;  /* A counting variable. */
 738 #endif  /* DEBUG */
 739 
 740         /*
 741          * Split the line on the ':' character. Then, for both the name of
 742          * the variable and its value, remove leading and trailing
 743          * blank-space characters.
 744          * We set the value of max_tokens to be 1; thus, the line is split at
 745          * the first ':' character.
 746          */
 747         tokens = g_strsplit(lineStr, ":", 1);
 748 
 749 
 750 #ifdef DEBUG
 751         for (i = 0; tokens[i] != NULL; i++)
 752                 printf("tokens[%d] = %s\n", i, tokens[i]);
 753 #endif  /* DEBUG */
 754 
 755         strcpy(varName, tokens[0]);
 756         strcpy(srcComp, tokens[1]);
 757 
 758         /* Free the memory used by the tokens array. */
 759         g_strfreev(tokens);
 760 
 761         /* Remove leading and trailing blank-space characters. */
 762         g_strstrip(varName);
 763         g_strstrip(srcComp);
 764 
 765 #ifdef DEBUG
 766         printf("VarName: %s; srcComp: %s\n", varName, srcComp);
 767 #endif  /* DEBUG */
 768 
 769         /*
 770          * Parse each line of the SOURCE definition. If we find a database or
 771          * a mirror, search for it in the appropriate linked list and make
 772          * this source point to it.
 773          */
 774 
 775         if (strcmp(varName, "database") == 0) {
 776                 /* Search for the appropriate database. */
 777                 /* Make this source point to it. */
 778                 /* Use ca_getDbHandleByName(). */
 779 
 780                 /* Check that we did not get a NULL pointer.            */
 781                 /* If we did, then print an error message and   */
 782                 /* die.                                                                                                         */
 783 
 784                 if ( ca_getDbHandleByName(srcComp) == NULL)
 785                         {
 786                         fprintf(stderr, "Error: Non-existent database \"%s\" referenced !!!\n", srcComp);
 787                         die;
 788                         }
 789                 else
 790                         {
 791                         srcStructPtr->db = *ca_getDbHandleByName(srcComp);
 792                         }
 793 
 794         }
 795         else {
 796                 if (strcmp(varName, "opMode") == 0) {
 797                         srcStructPtr->opMode = atoi(srcComp);
 798                 }
 799                 else {
 800                         if (strcmp(varName, "updPort") == 0) {
 801                                 srcStructPtr->updPort = atoi(srcComp);
 802                         }
 803                         else {
 804                                 if (strcmp(varName, "canupd") == 0) {
 805                                         strcpy(srcStructPtr->canupd, srcComp);
 806                                 }
 807                                 else {
 808                                         if (strcmp(varName, "deflook") == 0) {
 809                                                 strcpy(srcStructPtr->deflook, srcComp);
 810                                         }
 811                                         else {
 812                                                 if (strcmp(varName, "nrtm") == 0) {
 813                                                         /*
 814                                                          * Get Mirror Handle
 815                                                          * by Name
 816                                                          */
 817                                                         /*
 818                                                          * Assign this mirror
 819                                                          * to
 820                                                          */
 821                                                         /*
 822                                                          * 
 823                                                          * srcStructPtr->nrtm.
 824                                                          * 
 825                                                          */
 826 
 827                                                          /* We check that the mirror is defined.                */
 828 
 829                                                          if ( ca_getNrtmHandleByName(srcComp) == NULL)
 830                                                                 {
 831                                                                 fprintf(stderr, "Error: non-existent mirror \"%s\" referenced !!!\n", srcComp);
 832                                                                 die;
 833                                                                 }
 834                                                          else
 835                                                                 {
 836                                                                 srcStructPtr->nrtm = *ca_getNrtmHandleByName(srcComp);
 837                                                                 }
 838                                                 }
 839                                                 else {
 840                                                         fprintf(stderr, "Unknown SOURCE component \"%s\".\n", srcComp);
 841                                                         die;
 842                                                 }
 843                                         }
 844                                 }
 845                         }
 846                 }
 847         }
 848 }
 849 
 850 
 851 ca_database_t *
 852 ca_getDbHandleByName(char *databaseNameStr)
     /* [<][>][^][v][top][bottom][index][help] */
 853 /*******************************************************************
 854  * ca_getDbHandleByName                              *
 855  *   -- A function that compares each 'name' component of every     *
 856  *    element in the linked-list of databases with the name of   *
 857  *    the database to be found.  If the required database is     *
 858  *    found, a pointer to the structure representing this       *
 859  *     database is  returned.                          *
 860  *                                            *
 861  *   Parameters                                    *
 862  *  -- databaseNameStr - the name of the required database        *
 863  *                                            *
 864  *  Returns                                      *
 865   *  -- dbasePtr  - a pointer to the structure representing the     *
 866   *            database or a pointer to NULL, if we cannot     *
 867  *            find the database.                      *
 868  *                                            *
 869  *******************************************************************/
 870 {
 871         /*
 872          * Define a pointer to the current element in the linked list.
 873          * Later, initialise it to the start of the list.
 874          */
 875         GSList *currentPtr; 
 876 
 877         /*
 878          * Define and later initialise a pointer that points to the 'data'
 879          * component of the GSList struct; i.e. a pointer to a variable of
 880          * type ca_database_t.
 881          */
 882         ca_database_t *dbasePtr; 
 883 
 884  /*
 885   * Before we search the linked-list, we must first check that it is
 886   * not empty.  If it is, then print a error message and exit.
 887   */
 888 
 889  if (dbList == NULL)
 890                 {
 891                 fprintf(stderr, "Error: no database is defined in SOURCEFILE.\n");
 892                 die;
 893                 }
 894 
 895  currentPtr = dbList;
 896  dbasePtr = currentPtr->data;
 897 
 898         /*
 899          * Look at each data component of the list of databases; (each data
 900          * component is a structure of type ca_database_t). Compare the
 901          * 'name' component of each ca_database_t structure with the value of
 902          * databaseName untill we get a match or we reach the end of the
 903          * list.
 904          */
 905 
 906         /*
 907          * We first check if currentPtr is pointing to NULL; if yes, we exit
 908          * the while loop; if no, we make dbasePtr point to the data
 909          * component of the current ca_database_t structure; then, we check
 910          * if this is the database name that we want; if yes, we _break_ from
 911          * the while loop.
 912          */
 913         while (currentPtr != NULL) {
 914                 dbasePtr = currentPtr->data;
 915                 if (strcmp(dbasePtr->dbName, databaseNameStr) == 0)
 916                         break;
 917                 currentPtr = currentPtr->next;
 918         }
 919 
 920         /*
 921          * We return a pointer.  If we found the database, this pointer
 922          * points to the ca_database_t structure which represents the
 923          * database. If we did not find the database, we return a pointer to
 924          * NULL.
 925          */
 926         if (currentPtr == NULL) {
 927                 dbasePtr = NULL;
 928                 return (dbasePtr);
 929         }
 930         else {
 931                 return (dbasePtr);
 932         }
 933 
 934 }
 935 
 936 
 937 
 938 ca_mirror_t *
 939 ca_getNrtmHandleByName(char *nrtmNameStr)
     /* [<][>][^][v][top][bottom][index][help] */
 940 /*******************************************************************
 941  * ca_NrtmHandleByName                              *
 942  *   -- A function that compares each 'name' component of every     *
 943  *    element in the linked-list of databases with the name of   *
 944  *    the database to be found.  If the required database is     *
 945  *    found, a pointer to the structure representing this       *
 946  *     database is  returned.                          *
 947  *                                            *
 948  *   Parameters                                    *
 949  *  -- nrtmNameStr - the name of the required database        *
 950  *                                            *
 951  *  Returns                                      *
 952   *  -- nrtmPtr  - a pointer to the structure representing the     *
 953   *            database or a pointer to NULL, if we cannot     *
 954  *            find the database.                      *
 955  *                                            *
 956  *******************************************************************/
 957 {
 958         /*
 959          * Define a pointer to the current element in the linked list.
 960          * Later, initialise it to the start of the list.
 961          */
 962         GSList *currentPtr; 
 963 
 964         /*
 965          * Define and initialise a pointer that points to the 'data'
 966          * component of the GSList struct; i.e. a pointer to a variable of
 967          * type ca_database_t.
 968          */
 969         ca_mirror_t *nrtmPtr; 
 970 
 971         /*
 972          * First check that the linked list of mirrors is not empty.  If it
 973          * is, print an error and exit.
 974          */
 975          if (nrtmList == NULL)
 976                 {
 977                 fprintf(stderr, "Error: no near-real-time mirror defined in SOURCEFILE.\n");
 978                 die;
 979                 }
 980 
 981  currentPtr = nrtmList; 
 982  nrtmPtr = currentPtr->data;
 983 
 984         /*
 985          * Look at each data component of the list of databases; (each data
 986          * component is a structure of type ca_database_t). Compare the
 987          * 'name' component of each ca_database_t structure with the value of
 988          * databaseName untill we get a match or we reach the end of the
 989          * list.
 990          */
 991 
 992 
 993         /*
 994          * We first check if currentPtr is pointing to NULL; if yes, we exit
 995          * the while loop; if no, we make nrtmPtr point to the data component
 996          * of the current ca_database_t structure; then, we check if this is
 997          * the database name that we want; if yes, we _break_ from the while
 998          * loop.
 999          */
1000         while (currentPtr != NULL) {
1001                 nrtmPtr = currentPtr->data;
1002                 if (strcmp(nrtmPtr->mrName, nrtmNameStr) == 0)
1003                         break;
1004                 currentPtr = currentPtr->next;
1005         }
1006 
1007         /*
1008          * We return a pointer.  If we found the mirror, this pointer
1009          * points to the ca_mirror_t structure which represents the
1010          * mirror. If we did not find the database, we return a pointer to
1011          * NULL.
1012          */
1013         if (currentPtr == NULL) {
1014                 nrtmPtr = NULL;
1015                 return (nrtmPtr);
1016         }
1017         else {
1018                 return (nrtmPtr);
1019         }
1020 
1021 }

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