## 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] */