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

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