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                              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 <stdio.h>
  38 #include <stdlib.h>
  39 #include <glib.h>
  40 #include <string.h>
  41 #include <stubs.h>
  42 #include <unistd.h>
  43 #include "ca_configFns.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         /*
 116          * Function prototypes of ca_parseDbLine(), ca_parseNrtmLine() and
 117          * ca_parseSrcLine().  We put them here so that it can only be called
 118          * from within the ca_readSources() function.
 119          */
 120         void ca_parseDbLine(char *, ca_database_t *);
 121         void ca_parseNrtmLine(char *, ca_mirror_t *);
 122         void ca_parseSrcLine(char *, ca_dbSource_t *);
 123 
 124 
 125 #ifdef DEBUG
 126         printf("\nInside ca_readSources() function.\n");
 127         printf("Sources file is: %s\n", sourcesDefFile);
 128 #endif  /* DEBUG */
 129 
 130         /*
 131          * Open the sources file for reading .....
 132          */
 133         if ((sourcesFilePtr = fopen(sourcesDefFile, "r")) == NULL) {
 134                 printf("Error: the file %s could not be opened.\n", sourcesDefFile);
 135                 die;
 136         }
 137 
 138         /* Before reading the file, we initialise all flags to 0. */
 139         in_DATABASE_def = 0;
 140         in_NRTM_def = 0;
 141         in_SOURCE_def = 0;
 142 
 143         /*
 144          * Read the first line of the file. Remove leading and trailing
 145          * blank-space characters. if the first character of the line is a
 146          * comment or if it is a blank-line, continue.
 147          * 
 148          */
 149 
 150         fgets(line, sizeof(line), sourcesFilePtr);
 151         g_strstrip(line);
 152 
 153         /*
 154          * While there are lines to be read in the sources file, process the
 155          * current line and read the next line.
 156          */
 157 
 158         while (!feof(sourcesFilePtr)) {
 159 #ifdef DEBUG
 160                 printf("line:%s:End of line\n", line);
 161                 printf("Length of line: %d\n", strlen(line));
 162 #endif  /* DEBUG */
 163 
 164                 /*
 165                  * Ignore comments and empty lines.
 166                  */
 167                 if ((strncmp(line, comment, 1) == 0) || (strlen(line) == 0)) {
 168 #ifdef DEBUG
 169                         printf("We are reading a comment or an empty line ..... \n");
 170 #endif  /* DEBUG */
 171                         fgets(line, sizeof(line), sourcesFilePtr);
 172                         g_strstrip(line);
 173                         continue;
 174                 }
 175 
 176                 /* Testing */
 177 #ifdef DEBUG
 178                 printf("LINE >>>%sEND_OF_LINE\n", line);
 179 #endif  /* DEBUG */
 180 
 181                 /*
 182                  * if we are in a DATABASE definition then have we read all
 183                  * of the definition ? if yes, then commit the definition,
 184                  * reset the 'Database' flag and read the next line.
 185                  * Otherwise parse the line and store the details in
 186                  * temporary variables.
 187                  */
 188 
 189                 /* If we are in a DATABASE definition */
 190                 if (in_DATABASE_def) {
 191                         /*
 192                          * If we have reached the end of a DATABASE
 193                          * definition, commit the definition.
 194                          */
 195 
 196                         if (strcmp(line, "/DATABASE") == 0) {
 197                                 /* Commit the definition */
 198                                 /* Some code. */
 199 #ifdef DEBUG
 200                                 puts("We have reached the end of a DATABASE definition");
 201                                 puts("Testing the population of the db structure:");
 202                                 printf("\n%s::%d::%s::%s::%s\n", newDbPtr->host, newDbPtr->port, newDbPtr->user, newDbPtr->password, newDbPtr->dbName);
 203 #endif  /* DEBUG */
 204 
 205                                 /*
 206                                  * Commit the definition to the linked list
 207                                  * of Databases.
 208                                  */
 209 
 210                                 dbList = g_slist_append(dbList, newDbPtr);
 211 
 212                                 /*
 213                                  * We have reached the end of the DATABASE
 214                                  * definition
 215                                  */
 216                                 /* Thus, reset the flag and free some memory. */
 217                                 in_DATABASE_def = 0;
 218 
 219 
 220                                 /*
 221                                  * Read the next line and do the conditional
 222                                  * test.
 223                                  */
 224                                 fgets(line, sizeof(line), sourcesFilePtr);
 225                                 g_strstrip(line);
 226                                 continue;
 227                         }
 228 
 229                         /*
 230                          * Otherwise, parse the line and fill in the
 231                          * structure of the Database.
 232                          */
 233                         ca_parseDbLine(line, newDbPtr);
 234 
 235                 }
 236 
 237                 /*
 238                  * If we have found the _beginning_ of a Database definition,
 239                  * then set the in_DATABASE_def flag and allocate space, etc.
 240                  * for the database.
 241                  */
 242 
 243                 if ((!in_DATABASE_def) && (strncmp(line, DATABASE_KEY, strlen(DATABASE_KEY)) == 0)) {
 244                         in_DATABASE_def = 1;
 245 
 246                         /* Allocate space for the database */
 247                         /* Current_db = fscanf etc.) */
 248                         /* Fill in the defaults. */
 249 #ifdef DEBUG
 250                         puts("Beginning of a database defintion ..... ");
 251 #endif  /* DEBUG */
 252 
 253                         sscanf(line, "%s %s", varName, database);
 254                         g_strstrip(database);
 255 
 256 #ifdef DEBUG
 257                         printf("Database name is: %s\n", database);
 258 #endif  /* DEBUG */
 259 
 260                         /*
 261                          * Create a structure for the database.
 262                          */
 263                         newDbPtr = calloc(1, sizeof(ca_database_t));
 264                         if (newDbPtr == NULL) {
 265                                 fprintf(stderr, "Cannot allocate memory to new db structure\n");
 266                                 die;
 267                         }
 268 
 269                         /* Assign the name of the database */
 270                         strcpy(newDbPtr->dbName, database);
 271 
 272                 }
 273 
 274 
 275                 /********************
 276                        * NRTM definition  *
 277                        ********************/
 278 
 279                 /*
 280                  * if we are in a NRTM definition then have we read all of
 281                  * the definition ? if yes, then commit the definition and
 282                  * read the next line. otherwise parse the line and store the
 283                  * details in temporary variables.
 284                  */
 285 
 286                 /* If we are in a NRTM definition */
 287                 if (in_NRTM_def) {
 288                         /*
 289                          * If we have reached the end of a NRTM definition,
 290                          * commit the definition.
 291                          */
 292                         if (strcmp(line, "/NRTM") == 0) {
 293                                 /* Commit the definition */
 294                                 /* Some code. */
 295 #ifdef DEBUG
 296                                 puts("We have reached the end of a NRTM definition");
 297                                 puts("Testing the population of the mirror structure:");
 298                                 printf("\n%s::%d::%d::%d\n", newMirrPtr->host, newMirrPtr->port, newMirrPtr->delay, newMirrPtr->protocolVer);
 299 #endif  /* DEBUG */
 300 
 301                                 /*
 302                                  * Commit the definition to the linked list
 303                                  * of nrt-mirrors.
 304                                  */
 305 
 306                                 nrtmList = g_slist_append(nrtmList, newMirrPtr);
 307 
 308                                 /*
 309                                  * We have reached the end of the NRTM
 310                                  * definition
 311                                  */
 312                                 /* Thus, reset the NRTM flag. */
 313                                 in_NRTM_def = 0;
 314 
 315                                 /*
 316                                  * Read the next line and do the conditional
 317                                  * test.
 318                                  */
 319                                 fgets(line, sizeof(line), sourcesFilePtr);
 320                                 g_strstrip(line);
 321                                 continue;
 322                         }
 323 
 324                         /*
 325                          * Otherwise, parse the line and fill in the
 326                          * structure of the NRMT.
 327                          */
 328 
 329                         ca_parseNrtmLine(line, newMirrPtr);
 330                 }
 331 
 332                 /*
 333                  * If we have found the beginning of a Near-Real-Time-Mirror
 334                  * definition, then set the in_NRTM_def flag and allocate
 335                  * space, etc. for the Near-Real-Time-Mirror.
 336                  */
 337 
 338                 if ((!in_NRTM_def) && (strncmp(line, NRTM_KEY, strlen(NRTM_KEY)) == 0)) {
 339                         in_NRTM_def = 1;
 340                         /* Allocate space for the Near-Real-Time-Mirror. */
 341                         /* Current_db = fscanf etc.) */
 342                         /* Fill in the defaults. */
 343 #ifdef DEBUG
 344                         puts("Beginning of a Near-Real-Time-Mirror defintion ..... ");
 345 #endif  /* DEBUG */
 346 
 347                         sscanf(line, "%s %s", varName, mirror);
 348 
 349                         /*
 350                          * Create a structure for the mirror.
 351                          */
 352                         newMirrPtr = calloc(1, sizeof(ca_mirror_t));
 353                         if (newMirrPtr == NULL) {
 354                                 fprintf(stderr, "Cannot allocate memory to new nrtm structure\n");
 355                                 die;
 356                         }
 357                         /* Assign the name of the mirror ? */
 358                         strcpy(newMirrPtr->mrName, mirror);
 359 
 360                 }
 361 
 362                 /*********************
 363                        * SOURCE Definition *
 364                        *********************/
 365 
 366                 /*
 367                  * if we are in a SOURCE definition then have we read all of
 368                  * the definition ? if yes, then commit the definition, reset
 369                  * the 'Database' flag and read the next line. Otherwise
 370                  * parse the line and store the details in temporary
 371                  * variables.
 372                  */
 373 
 374                 /* If we are in a SOURCE definition */
 375                 if (in_SOURCE_def) {
 376                         /*
 377                          * If we have reached the end of a SOURCE definition,
 378                          * commit the definition.
 379                          */
 380 
 381                         if (strcmp(line, "/SOURCE") == 0) {
 382                                 /* Commit the definition */
 383                                 /* Some code. */
 384 #ifdef DEBUG
 385                                 puts("We have reached the end of a SOURCE definition");
 386                                 puts("Testing the population of the new Source structure:");
 387                                 printf("Source name: %s\n", newSrcPtr->name);
 388                                 printf("\nDB == %s::%d::%s::%s::%s\n", (newSrcPtr->db).host, (newSrcPtr->db).port, (newSrcPtr->db).user, (newSrcPtr->db).password, (newSrcPtr->db).dbName);
 389                                 printf("Mode: %d\n", newSrcPtr->opMode);
 390                                 printf("NRTM == %s::%d::%d:%d\n", (newSrcPtr->nrtm).host, (newSrcPtr->nrtm).port, (newSrcPtr->nrtm).delay, (newSrcPtr->nrtm).protocolVer);
 391                                 printf("UpdPort: %d\n", newSrcPtr->updPort);
 392                                 printf("New Source Options == %s::%s\n", newSrcPtr->canupd, newSrcPtr->deflook);
 393 #endif  /* DEBUG */
 394 
 395                                 /*
 396                                  * Commit the definition to the linked list
 397                                  * of Databases.
 398                                  */
 399 
 400                                 sourceList = g_slist_append(sourceList, newSrcPtr);
 401 
 402                                 /*
 403                                  * We have reached the end of the DATABASE
 404                                  * definition
 405                                  */
 406                                 /* Thus, reset the flag and free some memory. */
 407                                 in_SOURCE_def = 0;
 408 
 409 
 410                                 /*
 411                                  * Read the next line and do the conditional
 412                                  * test.
 413                                  */
 414                                 fgets(line, sizeof(line), sourcesFilePtr);
 415                                 g_strstrip(line);
 416                                 continue;
 417                         }
 418 
 419                         /*
 420                          * Otherwise, parse the line and fill in the
 421                          * structure of the Database.
 422                          */
 423                         ca_parseSrcLine(line, newSrcPtr);
 424 
 425                 }
 426 
 427                 /*
 428                  * If we have found the _beginning_ of a SOURCE definition,
 429                  * then set the in_SOURCE_def flag and allocate space, etc.
 430                  * for the database.
 431                  */
 432 
 433                 if ((!in_SOURCE_def) && (strncmp(line, SOURCE_KEY, strlen(SOURCE_KEY)) == 0)) {
 434                         in_SOURCE_def = 1;
 435 
 436                         /* Allocate space for the Source */
 437                         /* Current_source = fscanf etc.) */
 438                         /* Fill in the defaults. */
 439 #ifdef DEBUG
 440                         puts("Beginning of a Source defintion ..... ");
 441 #endif  /* DEBUG */
 442 
 443                         sscanf(line, "%s %s", varName, source);
 444                         g_strstrip(source);
 445 
 446 #ifdef DEBUG
 447                         printf("Source name is: %s\n", source);
 448 #endif  /* DEBUG */
 449 
 450                         /*
 451                          * Create a structure for the source.
 452                          * 
 453                          */
 454                         newSrcPtr = calloc(1, sizeof(ca_dbSource_t));
 455                         if (newSrcPtr == NULL) {
 456                                 fprintf(stderr, "Cannot allocate memory to new Source structure\n");
 457                                 die;
 458                         }
 459 
 460                         /* Assign the name of the Source */
 461                         strcpy(newSrcPtr->name, source);
 462 
 463                 }
 464 
 465                 /* Read the next line. */
 466                 fgets(line, sizeof(line), sourcesFilePtr);
 467                 g_strstrip(line);
 468 
 469                 /* End of while loop; i.e. end of processing a line. */
 470         }
 471 
 472         /* Close the sources definition file. */
 473         fclose(sourcesFilePtr);
 474 
 475         /* End of ca_readSources() function */
 476 
 477 }
 478 
 479 void
 480 ca_getAllDatabases(GSList * databases)
     /* [<][>][^][v][top][bottom][index][help] */
 481 {
 482         GSList *currentPtr;     /* Pointer to the structure at which we look. */
 483 
 484         /*
 485          * Look at the first member of the linked-list of sources.
 486          */
 487         currentPtr = databases;
 488 
 489         /*
 490          * Look at each data component of the source list, untill we reach
 491          * the end of the list.
 492          */
 493         while (currentPtr != NULL) {
 494                 ca_database_t *dbPtr = currentPtr->data;
 495                 printf("\n%s,%d,%s,%s,%s\n", dbPtr->host, dbPtr->port, dbPtr->user, dbPtr->password, dbPtr->dbName);
 496                 currentPtr = currentPtr->next;
 497         }
 498 }
 499 
 500 
 501 void
 502 ca_getAllMirrors(GSList * mirrors)
     /* [<][>][^][v][top][bottom][index][help] */
 503 {
 504         GSList *currentPtr;     /* Pointer to the structure at which we look. */
 505 
 506         /*
 507          * Look at the first member of the linked-list of sources.
 508          */
 509         currentPtr = mirrors;
 510 
 511         /*
 512          * Look at each data component of the source list, untill we reach
 513          * the end of the list.
 514          */
 515         while (currentPtr != NULL) {
 516                 ca_mirror_t *nrtmPtr = currentPtr->data;
 517                 printf("\n%s,%d,%d,%d, %s\n", nrtmPtr->host, nrtmPtr->port, nrtmPtr->delay, nrtmPtr->protocolVer, nrtmPtr->mrName);
 518                 currentPtr = currentPtr->next;
 519         }
 520 }
 521 
 522 void
 523 ca_parseDbLine(char *lineStr, ca_database_t * dbStructPtr)
     /* [<][>][^][v][top][bottom][index][help] */
 524 /*******************************************************************
 525  *                                             *
 526  * ca_parseLine  -- parses the a line in the Sources file and     *
 527  *             writes the values into temporary variables.    *
 528  *                                            *
 529  * Parameters                                    *
 530   *    lineStr     -- the current line of the Sources file       *
 531  *               -- a NULL terminated string            *
 532   *    dbStructPtr  -- the db we are filling                 *
 533   *              -- a pointer to a ca_database_t structure.  *
 534  *                                            *
 535  * Returns                                      *
 536   *    Nothing -- perhaps make this return 0 on successful exit ?  *
 537  *                                            *
 538  *******************************************************************/
 539 {
 540         char dbComp[64];        /* Component of a database. */
 541         char varName[16];       /* The name of the variable. */
 542 
 543         gchar **tokens; /* Pointer to an array of strings. */
 544 
 545 #ifdef DEBUG
 546         int i;  /* A counting variable. */
 547 #endif  /* DEBUG */
 548 
 549         /*
 550          * Split the line on the ':' character. Then, for both the name of
 551          * the variable and its value, remove leading and trailing
 552          * blank-space characters.
 553          */
 554         tokens = g_strsplit(lineStr, ":", 0);
 555 
 556 #ifdef DEBUG
 557         for (i = 0; tokens[i] != NULL; i++)
 558                 printf("tokens[%d] = %s\n", i, tokens[i]);
 559 #endif  /* DEBUG */
 560 
 561         strcpy(varName, tokens[0]);
 562         strcpy(dbComp, tokens[1]);
 563 
 564         /* Free the memory used by the tokens array. */
 565         g_strfreev(tokens);
 566 
 567         /* Remove leading and trailing blank-space characters. */
 568         g_strstrip(varName);
 569         g_strstrip(dbComp);
 570 
 571 #ifdef DEBUG
 572         printf("VarName: %s; dbComp: %s\n", varName, dbComp);
 573 #endif  /* DEBUG */
 574 
 575         if (strcmp(varName, "host") == 0) {
 576                 strcpy(dbStructPtr->host, dbComp);
 577         }
 578         else {
 579                 if (strcmp(varName, "port") == 0) {
 580                         dbStructPtr->port = atoi(dbComp);
 581                 }
 582                 else {
 583                         if (strcmp(varName, "user") == 0) {
 584                                 strcpy(dbStructPtr->user, dbComp);
 585                         }
 586                         else {
 587                                 if (strcmp(varName, "password") == 0) {
 588                                         strcpy(dbStructPtr->password, dbComp);
 589                                 }
 590                                 else {
 591                                         fprintf(stderr, "Unknown database component \"%s\".\n", dbComp);
 592                                         die;
 593                                 }
 594                         }
 595                 }
 596         }
 597 }
 598 
 599 
 600 
 601 void
 602 ca_parseNrtmLine(char *lineStr, ca_mirror_t * mrStructPtr)
     /* [<][>][^][v][top][bottom][index][help] */
 603 /*
 604  * */
 605 {
 606         char nrtmComp[64];      /* Component of a NRTM. */
 607         char varName[16];       /* The name of the variable. */
 608 
 609         gchar **tokens; /* Pointer to an array of strings. */
 610 
 611 #ifdef DEBUG
 612         int i;  /* A counting variable. */
 613 #endif  /* DEBUG */
 614 
 615         /*
 616          * Split the line on the ':' character. Then, for both the name of
 617          * the variable and its value, remove leading and trailing
 618          * blank-space characters.
 619          */
 620         tokens = g_strsplit(lineStr, ":", 0);
 621 
 622 #ifdef DEBUG
 623         for (i = 0; tokens[i] != NULL; i++)
 624                 printf("tokens[%d] = %s\n", i, tokens[i]);
 625 #endif  /* DEBUG */
 626 
 627         strcpy(varName, tokens[0]);
 628         strcpy(nrtmComp, tokens[1]);
 629 
 630         /* Free the memory used by the tokens array. */
 631         g_strfreev(tokens);
 632 
 633         /* Remove leading and trailing blank-space characters. */
 634         g_strstrip(varName);
 635         g_strstrip(nrtmComp);
 636 
 637 #ifdef DEBUG
 638         printf("VarName: %s; nrtmComp: %s\n", varName, nrtmComp);
 639 #endif  /* DEBUG */
 640 
 641 
 642         if (strcmp(varName, "host") == 0) {
 643                 strcpy(mrStructPtr->host, nrtmComp);
 644         }
 645         else {
 646                 if (strcmp(varName, "port") == 0) {
 647                         mrStructPtr->port = atoi(nrtmComp);
 648                 }
 649                 else {
 650                         if (strcmp(varName, "delay") == 0) {
 651                                 mrStructPtr->delay = atoi(nrtmComp);
 652                         }
 653                         else {
 654                                 if (strcmp(varName, "protocolVersion") == 0) {
 655                                         mrStructPtr->protocolVer = atoi(nrtmComp);
 656                                 }
 657                                 else {
 658                                         fprintf(stderr, "Unknown mirror component \"%s\".\n", nrtmComp);
 659                                         die;
 660                                 }
 661                         }
 662                 }
 663         }
 664 }
 665 
 666 
 667 
 668 
 669 void
 670 ca_parseSrcLine(char *lineStr, ca_dbSource_t * srcStructPtr)
     /* [<][>][^][v][top][bottom][index][help] */
 671 /*
 672  * ca_parseSrcLine() function.
 673  */
 674 {
 675         char srcComp[64];       /* Component of a database. */
 676         char varName[16];       /* The name of the variable. */
 677 
 678         gchar **tokens; /* Pointer to an array of strings. */
 679 
 680 #ifdef DEBUG
 681         int i;  /* A counting variable. */
 682 #endif  /* DEBUG */
 683 
 684         /*
 685          * Split the line on the ':' character. Then, for both the name of
 686          * the variable and its value, remove leading and trailing
 687          * blank-space characters.
 688          */
 689         tokens = g_strsplit(lineStr, ":", 0);
 690 
 691 #ifdef DEBUG
 692         for (i = 0; tokens[i] != NULL; i++)
 693                 printf("tokens[%d] = %s\n", i, tokens[i]);
 694 #endif  /* DEBUG */
 695 
 696         strcpy(varName, tokens[0]);
 697         strcpy(srcComp, tokens[1]);
 698 
 699         /* Free the memory used by the tokens array. */
 700         g_strfreev(tokens);
 701 
 702         /* Remove leading and trailing blank-space characters. */
 703         g_strstrip(varName);
 704         g_strstrip(srcComp);
 705 
 706 #ifdef DEBUG
 707         printf("VarName: %s; srcComp: %s\n", varName, srcComp);
 708 #endif  /* DEBUG */
 709 
 710         /*
 711          * Parse each line of the SOURCE definition. If we find a database or
 712          * a mirror, search for it in the appropriate linked list and make
 713          * this source point to it.
 714          */
 715         if (strcmp(varName, "database") == 0) {
 716                 /* Search for the appropriate database. */
 717                 /* Make this source point to it. */
 718                 /* Use ca_getDbHandleByName(). */
 719                 srcStructPtr->db = *ca_getDbHandleByName(srcComp);
 720         }
 721         else {
 722                 if (strcmp(varName, "opMode") == 0) {
 723                         srcStructPtr->opMode = atoi(srcComp);
 724                 }
 725                 else {
 726                         if (strcmp(varName, "updPort") == 0) {
 727                                 srcStructPtr->updPort = atoi(srcComp);
 728                         }
 729                         else {
 730                                 if (strcmp(varName, "canupd") == 0) {
 731                                         strcpy(srcStructPtr->canupd, srcComp);
 732                                 }
 733                                 else {
 734                                         if (strcmp(varName, "deflook") == 0) {
 735                                                 strcpy(srcStructPtr->deflook, srcComp);
 736                                         }
 737                                         else {
 738                                                 if (strcmp(varName, "nrtm") == 0) {
 739                                                         /*
 740                                                          * Get Mirror Handle
 741                                                          * by Name
 742                                                          */
 743                                                         /*
 744                                                          * Assign this mirror
 745                                                          * to
 746                                                          */
 747                                                         /*
 748                                                          * 
 749                                                          * srcStructPtr->nrtm.
 750                                                          * 
 751                                                          */
 752                                                         srcStructPtr->nrtm = *ca_getNrtmHandleByName(srcComp);
 753                                                 }
 754                                                 else {
 755                                                         fprintf(stderr, "Unknown SOURCE component \"%s\".\n", srcComp);
 756                                                         die;
 757                                                 }
 758                                         }
 759                                 }
 760                         }
 761                 }
 762         }
 763 }
 764 
 765 
 766 ca_database_t *
 767 ca_getDbHandleByName(char *databaseNameStr)
     /* [<][>][^][v][top][bottom][index][help] */
 768 /*******************************************************************
 769  * ca_getDbHandleByName                              *
 770  *   -- A function that compares each 'name' component of every     *
 771  *    element in the linked-list of databases with the name of   *
 772  *    the database to be found.  If the required database is     *
 773  *    found, a pointer to the structure representing this       *
 774  *     database is  returned.                          *
 775  *                                            *
 776  *   Parameters                                    *
 777  *  -- databaseNameStr - the name of the required database        *
 778  *                                            *
 779  *  Returns                                      *
 780   *  -- dbasePtr  - a pointer to the structure representing the     *
 781   *            database or a pointer to NULL, if we cannot     *
 782  *            find the database.                      *
 783  *                                            *
 784  *******************************************************************/
 785 {
 786         /*
 787          * Define a pointer to the current element in the linked list.
 788          * Initialise it to the start of the list.
 789          */
 790         GSList *currentPtr = dbList;
 791 
 792         /*
 793          * Define and initialise a pointer that points to the 'data'
 794          * component of the GSList struct; i.e. a pointer to a variable of
 795          * type ca_database_t.
 796          */
 797         ca_database_t *dbasePtr = currentPtr->data;
 798 
 799         /*
 800          * Look at each data component of the list of databases; (each data
 801          * component is a structure of type ca_database_t). Compare the
 802          * 'name' component of each ca_database_t structure with the value of
 803          * databaseName untill we get a match or we reach the end of the
 804          * list.
 805          */
 806 
 807         /*
 808          * We first check if currentPtr is pointing to NULL; if yes, we exit
 809          * the while loop; if no, we make dbasePtr point to the data
 810          * component of the current ca_database_t structure; then, we check
 811          * if this is the database name that we want; if yes, we _break_ from
 812          * the while loop.
 813          */
 814         while (currentPtr != NULL) {
 815                 dbasePtr = currentPtr->data;
 816                 if (strcmp(dbasePtr->dbName, databaseNameStr) == 0)
 817                         break;
 818                 currentPtr = currentPtr->next;
 819         }
 820 
 821         /*
 822          * We return a pointer.  If we found the database, this pointer
 823          * points to the ca_database_t structure which represents the
 824          * database. If we did not find the database, we return a pointer to
 825          * NULL.
 826          */
 827         if (currentPtr == NULL) {
 828                 dbasePtr = NULL;
 829                 return (dbasePtr);
 830         }
 831         else {
 832                 return (dbasePtr);
 833         }
 834 
 835 }
 836 
 837 
 838 
 839 ca_mirror_t *
 840 ca_getNrtmHandleByName(char *nrtmNameStr)
     /* [<][>][^][v][top][bottom][index][help] */
 841 /*******************************************************************
 842  * ca_NrtmHandleByName                              *
 843  *   -- A function that compares each 'name' component of every     *
 844  *    element in the linked-list of databases with the name of   *
 845  *    the database to be found.  If the required database is     *
 846  *    found, a pointer to the structure representing this       *
 847  *     database is  returned.                          *
 848  *                                            *
 849  *   Parameters                                    *
 850  *  -- nrtmNameStr - the name of the required database        *
 851  *                                            *
 852  *  Returns                                      *
 853   *  -- nrtmPtr  - a pointer to the structure representing the     *
 854   *            database or a pointer to NULL, if we cannot     *
 855  *            find the database.                      *
 856  *                                            *
 857  *******************************************************************/
 858 {
 859         /*
 860          * Define a pointer to the current element in the linked list.
 861          * Initialise it to the start of the list.
 862          */
 863         GSList *currentPtr = nrtmList;
 864 
 865         /*
 866          * Define and initialise a pointer that points to the 'data'
 867          * component of the GSList struct; i.e. a pointer to a variable of
 868          * type ca_database_t.
 869          */
 870         ca_mirror_t *nrtmPtr = currentPtr->data;
 871 
 872         /*
 873          * Look at each data component of the list of databases; (each data
 874          * component is a structure of type ca_database_t). Compare the
 875          * 'name' component of each ca_database_t structure with the value of
 876          * databaseName untill we get a match or we reach the end of the
 877          * list.
 878          */
 879 
 880         /*
 881          * We first check if currentPtr is pointing to NULL; if yes, we exit
 882          * the while loop; if no, we make nrtmPtr point to the data component
 883          * of the current ca_database_t structure; then, we check if this is
 884          * the database name that we want; if yes, we _break_ from the while
 885          * loop.
 886          */
 887         while (currentPtr != NULL) {
 888                 nrtmPtr = currentPtr->data;
 889                 if (strcmp(nrtmPtr->mrName, nrtmNameStr) == 0)
 890                         break;
 891                 currentPtr = currentPtr->next;
 892         }
 893 
 894         /*
 895          * We return a pointer.  If we found the database, this pointer
 896          * points to the ca_database_t structure which represents the
 897          * database. If we did not find the database, we return a pointer to
 898          * NULL.
 899          */
 900         if (currentPtr == NULL) {
 901                 nrtmPtr = NULL;
 902                 return (nrtmPtr);
 903         }
 904         else {
 905                 return (nrtmPtr);
 906         }
 907 
 908 }

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