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