1 | /*************************************** 2 | $Revision: 3 | 4 | CA module: definitions of most functions. 5 | 6 | Status: NOT REVIEWED, NOT TESTED 7 | 8 | Author(s): Ambrose Magee 9 | 10 | ******************//****************** 11 | Modification History: 12 | 13 | ******************/ 14 | 15 | /************************************ 16 | Copyright (c) 2000,2001,2002 RIPE NCC 17 | 18 | All Rights Reserved 19 | 20 | Permission to use, copy, modify, and distribute this software and its 21 | documentation for any purpose and without fee is hereby granted, 22 | provided that the above copyright notice appear in all copies and that 23 | both that copyright notice and this permission notice appear in 24 | supporting documentation, and that the name of the author not be 25 | used in advertising or publicity pertaining to distribution of the 26 | software without specific, written prior permission. 27 | 28 | THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 29 | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL 30 | AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 31 | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 32 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 33 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 34 | ***************************************/ 35 | 36 | #define DICT_INIT 37 | #include "rip.h" 38 | 39 | #include <stdio.h> 40 | #include <stdlib.h> 41 | #include <glib.h> 42 | #include <string.h> 43 | #include <unistd.h> 44 | 45 | int num_sources=0; 46 | 47 | /* #define DEBUG */ 48 | 49 | /********************************************** 50 | * This file contains the definitions of all * 51 | * the functions. * 52 | **********************************************/ 53 | 54 | void 55 | stringPack(char *dest, const char *source) 56 | /**************************************************************** 57 | * stringPack -- function to rewrite a line of text with only * 58 | * one blankspace between each word. * 59 | * * 60 | * Parameters * 61 | * dest -- destination character, the character to be * 62 | * outputted * 63 | * source -- the 'source' character, the original character. * 64 | * * 65 | * Returns * 66 | * Nothing (may change this to the number of characters * 67 | * read or copied). * 68 | * * 69 | ****************************************************************/ 70 | { 71 | #ifdef DEBUG 72 | printf("\nInside stringPack function\n"); 73 | #endif /* DEBUG */ 74 | 75 | /* 76 | * This while loop continues until the NULL character is copied into 77 | * the destination string. If a tab character is copied into the 78 | * destination string, it is replaced with a blank-space character. 79 | * 80 | * Multiple blank-space and/or tab characters are skipped in the source 81 | * string until any other character is found. 82 | */ 83 | 84 | while (1) { 85 | *dest = *source; 86 | 87 | if (*dest == '\t') 88 | (*dest = ' '); 89 | 90 | /* Exit if have copied the end of the string. */ 91 | if (*dest == '\0') 92 | return; 93 | 94 | /* 95 | * If the source character was a blank-space or a tab, move 96 | * to the next source character. While the source character 97 | * is a blank-space or a tab, move to the next character 98 | * (i.e. ignore these characters). When any other character 99 | * is found in the source string, move to the next element of 100 | * the destination string. 101 | * 102 | * Otherwise, simultaneously, move to the next elements of the 103 | * destination and the source strings. 104 | */ 105 | 106 | 107 | 108 | if ((*source == ' ') || (*source == '\t')) { 109 | ++source; 110 | while ((*source == ' ') || (*source == '\t')) { 111 | ++source; 112 | } 113 | 114 | ++dest; 115 | } 116 | else { 117 | ++dest; 118 | ++source; 119 | } 120 | } 121 | } 122 | 123 | 124 | void 125 | ca_populateDictionary(dict_t woordenboek[], int size) 126 | /******************************************************************* 127 | * ca_populateDictionary -- Parses dictionary file, initializes * 128 | * the dictionary structure and writes * 129 | * the file of dictionary symbols, * 130 | * ca_dictSyms.h * 131 | * * 132 | * Parameters * 133 | * woordenboek -- the dictionary to be populated * 134 | * size -- the total number of variables i.e. the size of the * 135 | * array of dict_t structures. See D. & D., p.276 * 136 | * * 137 | * Returns * 138 | * Nothing ? (may change this later) * 139 | * * 140 | *******************************************************************/ 141 | 142 | { 143 | const char *blankLine = "\n"; 144 | const char *comment = "#"; 145 | char line[120]; 146 | char input[120]; 147 | int entry = 0; 148 | FILE *dictPtr; 149 | #ifdef DEBUG 150 | int i; 151 | FILE *defnPtr; 152 | #endif /* DEBUG */ 153 | 154 | gchar **tokens; /* Pointer to an array of strings. */ 155 | 156 | /* 157 | * Try to open the dictionary file for reading. If it cannot be 158 | * opened, exit with an error. 159 | */ 160 | if ((dictPtr = fopen("dictionary.txt", "r")) == NULL) { 161 | fprintf(stderr, "Error: Unable to open 'dictionary.txt'\n"); 162 | die; 163 | } 164 | 165 | 166 | /* 167 | * DEBUG mode only. Try to open the definitions file for writing. If 168 | * it cannot be opened,exit with an error 169 | */ 170 | #ifdef DEBUG 171 | if ((defnPtr = fopen("defs.txt", "w")) == NULL) { 172 | fprintf(stderr, "Error: Unable to open 'defs.txt'\n"); 173 | die; 174 | } 175 | #endif /* DEBUG */ 176 | 177 | /* 178 | * Read the file one line at a time; if the line begins with a 179 | * comment, ignore it; otherwise, split each line into tokens; print 180 | * each token. Assign each token to the appropriate member of the 181 | * appropriate element of the dictionary array. 182 | */ 183 | 184 | fgets(input, sizeof(input), dictPtr); 185 | 186 | if ((strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0)) { 187 | /* 188 | * First remove the newline character. Then replace multiple 189 | * tab and space characters with single space characters. 190 | */ 191 | 192 | /* 193 | * Remove the newline character, if present. Replace the last 194 | * character of the string array with with '\0'. 195 | */ 196 | 197 | input[strlen(input) - 1] = '\0'; 198 | 199 | /* 200 | * Now, remove the multiple space and tab characters. 201 | */ 202 | 203 | stringPack(line, input); 204 | 205 | g_strchomp(line); /* Remove trailing w-space. */ 206 | #ifdef DEBUG 207 | puts(line); 208 | #endif /* DEBUG */ 209 | 210 | tokens = g_strsplit(line, " ", 0); 211 | 212 | #ifdef DEBUG 213 | for (i = 0; tokens[i] != NULL; i++) 214 | printf("tokens[%d] = %s\n", i, tokens[i]); 215 | #endif /* DEBUG */ 216 | 217 | /* 218 | * We no longer need a variable for scope 219 | * woordenboek[entry].varScope = atoi(tokens[1]); 220 | */ 221 | 222 | strcpy(woordenboek[entry].varName, tokens[0]); 223 | strcpy(woordenboek[entry].varSym, tokens[1]); 224 | strcpy(woordenboek[entry].varType, tokens[2]); 225 | woordenboek[entry].varNum = entry; 226 | 227 | /* 228 | * DEBUG mode only. Write the dictionary symbol and the entry 229 | * number to the definitions file. 230 | */ 231 | #ifdef DEBUG 232 | fprintf(defnPtr, "%s\t%d\n", tokens[1], entry); 233 | #endif /* DEBUG */ 234 | 235 | ++entry; 236 | g_strfreev(tokens); 237 | } 238 | /* 239 | * Get the 2nd and subsequent line of the file. 240 | */ 241 | 242 | fgets(input, sizeof(input), dictPtr); 243 | 244 | while (!feof(dictPtr)) { 245 | /* 246 | * Process the line if it is not a comment. 247 | */ 248 | 249 | if ((strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0)) { 250 | /* 251 | * First remove the newline character. Then replace 252 | * multiple tab and space characters with single 253 | * space characters. 254 | */ 255 | 256 | /* 257 | * Remove the newline character, if present. Replace 258 | * the last character of the string array with with 259 | * '\0'. 260 | */ 261 | 262 | input[strlen(input) - 1] = '\0'; 263 | 264 | /* 265 | * Now, remove the multiple space and tab characters. 266 | */ 267 | 268 | stringPack(line, input); 269 | 270 | g_strchomp(line); /* Remove trailing w/space. */ 271 | 272 | #ifdef DEBUG 273 | puts(line); 274 | #endif /* DEBUG */ 275 | tokens = g_strsplit(line, " ", 0); 276 | 277 | #ifdef DEBUG 278 | for (i = 0; tokens[i] != NULL; i++) 279 | printf("tokens[%d] = %s\n", i, tokens[i]); 280 | #endif /* DEBUG */ 281 | 282 | /* 283 | * We no longer need to know the scope of a variable 284 | * woordenboek[entry].varScope = atoi(tokens[1]); 285 | */ 286 | 287 | strcpy(woordenboek[entry].varName, tokens[0]); 288 | strcpy(woordenboek[entry].varSym, tokens[1]); 289 | strcpy(woordenboek[entry].varType, tokens[2]); 290 | woordenboek[entry].varNum = entry; 291 | 292 | #ifdef DEBUG 293 | fprintf(defnPtr, "%s\t%d\n", tokens[1], entry); 294 | #endif /* DEBUG */ 295 | 296 | ++entry; 297 | 298 | g_strfreev(tokens); 299 | } 300 | fgets(input, sizeof(input), dictPtr); 301 | } 302 | 303 | fclose(dictPtr); 304 | 305 | #ifdef DEBUG 306 | fclose(defnPtr); 307 | #endif /* DEBUG */ 308 | 309 | } /* End of ca_populateDictionary() function. */ 310 | 311 | 312 | void 313 | opSplitsen(FILE * filePtr, gchar ** tokenArray) 314 | /******************************************************************* 315 | * opSplitsen -- reads a file and splits it into tokens. * 316 | * * 317 | * Parameters * 318 | * filePtr -- a text file * 319 | * tokenArray -- pointer to an array of strings * 320 | * * 321 | * Returns * 322 | * Nothing * 323 | * * 324 | *******************************************************************/ 325 | { 326 | /* 327 | * Declaring character constants is safer than using #define. 328 | */ 329 | 330 | const char *blankLine = "\n"; /* Declared as a string, not a 331 | * character. */ 332 | const char *comment = "#"; /* Declared as a string. */ 333 | char line[99]; 334 | char input[99]; 335 | #ifdef DEBUG 336 | int lineNo = 0; 337 | int j; 338 | #endif /* DEBUG */ 339 | 340 | 341 | fgets(input, sizeof(input), filePtr); /* Get the (first) line from 342 | * the */ 343 | /* file to which filePtr points. */ 344 | 345 | #ifdef DEBUG 346 | printf("\nFIRST INPUT >>> %s\n", input); 347 | #endif /* DEBUG */ 348 | 349 | /* Compare the first character of the input */ 350 | /* to the comment and the newline strings. */ 351 | 352 | if ((strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0)) { 353 | /* Remove the newline character, if present. */ 354 | /* Replace the last character */ 355 | /* of the string array with '\0'. */ 356 | 357 | input[strlen(input) - 1] = '\0'; 358 | #ifdef DEBUG 359 | printf("First Input >>> %s\n", input); 360 | #endif /* DEBUG */ 361 | 362 | strcpy(line, input); 363 | #ifdef DEBUG 364 | printf("First Line after copy >>> %s\n", line); 365 | #endif /* DEBUG */ 366 | 367 | stringPack(line, input); 368 | #ifdef DEBUG 369 | printf("Line: %s\n", line); 370 | #endif /* DEBUG */ 371 | 372 | g_strchomp(line); 373 | /* 374 | * g_strdelimit(line, " ", ':'); g_strdelimit(line, "\t", 375 | * '*'); 376 | */ 377 | 378 | #ifdef DEBUG 379 | printf("%3d> %s\n", ++lineNo, line); 380 | #endif /* DEBUG */ 381 | 382 | /* 383 | * g_strsplit() is a GLib function; it returns an array of 384 | * strings. 385 | * 386 | * Here, we split on two spaces, " ". We set max_tokenArray to 387 | * be 0. We want the first token to be the name of the 388 | * variable and the other tokens to be the value of the 389 | * variable, qualifiers, etc. 390 | */ 391 | 392 | tokenArray = g_strsplit(line, " ", 0); 393 | 394 | #ifdef DEBUG 395 | for (j = 0; tokenArray[j] != NULL; j++) 396 | printf("token[%d] = %s\n", j, tokenArray[j]); 397 | #endif /* DEBUG */ 398 | 399 | } /* End of processing the first line, if not commented. */ 400 | 401 | /* End of getting the first line. */ 402 | 403 | 404 | /* Get the 2nd line of the file. */ 405 | fgets(input, sizeof(input), filePtr); 406 | 407 | while (!feof(filePtr)) { 408 | 409 | /* Process the line if it is not commented. */ 410 | if ((strncmp(input, comment, 1) != 0) && (strncmp(input, blankLine, 1) != 0)) { 411 | /* Remove the newline character, if present. */ 412 | input[strlen(input) - 1] = '\0'; 413 | #ifdef DEBUG 414 | printf("Subsequent Input >>> %s\n", input); 415 | #endif /* DEBUG */ 416 | 417 | strcpy(line, input); 418 | #ifdef DEBUG 419 | printf("Subsequent Line after copy >>> %s\n", line); 420 | #endif /* DEBUG */ 421 | 422 | stringPack(line, input); 423 | #ifdef DEBUG 424 | printf("Line: %s\n", line); 425 | #endif /* DEBUG */ 426 | 427 | g_strchomp(line); 428 | 429 | #ifdef DEBUG 430 | printf("%3d> %s\n", ++lineNo, line); 431 | #endif /* DEBUG */ 432 | 433 | /* 434 | * See the comment above about the maximum number of 435 | * tokens being set to 0. 436 | */ 437 | 438 | tokenArray = g_strsplit(line, " ", 0); 439 | 440 | #ifdef DEBUG 441 | for (j = 0; tokenArray[j] != NULL; j++) { 442 | printf("token[%d] = %s\n", j, tokenArray[j]); 443 | /* Can also use puts(tokenArray[j]) here. */ 444 | } 445 | #endif /* DEBUG */ 446 | } /* Processed uncommented lines. */ 447 | 448 | fgets(input, sizeof(input), filePtr); 449 | } /* Processed the 2nd & subsequent lines of the file. */ 450 | 451 | } /* End of processing the opened file. */ 452 | 453 | 454 | void 455 | ca_readConfig(const char *configFile, values_t confVars[], int size) 456 | /******************************************************************* 457 | * * 458 | * ca_readConfig -- parses the config file and writes the values * 459 | * into memory. * 460 | * * 461 | * Parameters * 462 | * configFile -- the configuration file 463 | * confVars[] -- the array of values structures * 464 | * size -- the number of configuration variables * 465 | * * 466 | * Returns * 467 | * Nothing -- perhaps make this return 0 on successful exit ? * 468 | * * 469 | * Note: Should we make the name of the config file a global * 470 | * variable ? * 471 | 472 | * 473 | * Using UT_calloc; no need to check that a NULL pointer is 474 | * returned. 475 | * 476 | * 477 | *******************************************************************/ 478 | { 479 | FILE *confPtr; /* Pointer to config file. */ 480 | char name[STRLENGTH_M]; /* The name of the config variable */ 481 | /* 80 characters */ 482 | char value[STRLENGTH_XXL]; /* The value of the variable */ 483 | /* 640 characters */ 484 | int location; /* Storage Location of the variable's value. */ 485 | int type; /* Data type of the variable, represented by an 486 | * integer. */ 487 | 488 | 489 | const char *blankLine = "\n"; /* Declared as a string, not a 490 | * character. */ 491 | const char *comment = "#"; /* Declared as a string. */ 492 | 493 | char source[16]; /* The name of a source. */ 494 | char database[STRLENGTH_M]; /* The elements of a database. */ 495 | /* 80 characters */ 496 | 497 | /* 498 | * UPDSOURCE variables: whoisd host, query-port, update-port. 499 | */ 500 | char updDetails[STRLENGTH_M]; /* The details of the update host: */ 501 | /* the name of the qry & upd machine; */ 502 | /* the query port; */ 503 | /* the update port. */ 504 | 505 | 506 | gchar **dbcomps; /* Pointer to an array of strings that 507 | * represents */ 508 | /* the components of a db. */ 509 | 510 | 511 | gchar **updDbcomps; /* Pointer to an array of strings that */ 512 | /* represents the components of an UPD Source. */ 513 | 514 | ca_ripadmin_t *newAdminPtr; /* A pointer to a new instance of */ 515 | /* a ca_ripadmin_t variable. */ 516 | 517 | ca_database_t *newUpdDbPtr; /* A pointer to a new instance of */ 518 | /* ca_database_t, for UPDSOURCE. */ 519 | 520 | ca_updDbSource_t *newUpdSrc; /* A pointer to a new instance of */ 521 | /* ca_updDbSource_t structure. */ 522 | 523 | #ifdef DEBUG 524 | int i; /* A counting variable used for debugging. */ 525 | #endif /* DEBUG */ 526 | 527 | /* 528 | * Function Prototype for ca_getStorageLocation() We put it here; 529 | * thus it can only be called from within ca_readConfig() 530 | * 531 | * This function finds the location in the values_t array where we store 532 | * pointers to the string value and the actual value of the variable. 533 | * It returns this location as an integer. 534 | * 535 | */ 536 | int ca_getStorageLocation(char[], dict_t[], int); 537 | 538 | /* 539 | * Function Prototype for ca_getType() We put it here so that it can 540 | * only be called from within ca_readConfig() 541 | * 542 | * This function returns the type of the configuration variable. It 543 | * returns it as a string. 544 | * 545 | */ 546 | int ca_getType(char[], dict_t[], int); 547 | 548 | 549 | #ifdef DEBUG 550 | printf("\nInside readConfig() function.\n"); 551 | printf("Configuration file is: %s\n", configFile); 552 | #endif /* DEBUG */ 553 | 554 | /* create an aray for the multiple source data pointers */ 555 | confVars[CA_UPDSOURCE].valPtr = (ca_updDbSource_t **) UT_malloc(CA_MAXSOURCES); 556 | /* first entry used to check for at least one valid source found */ 557 | ((ca_updDbSource_t **)confVars[CA_UPDSOURCE].valPtr)[0] = NULL; 558 | 559 | /* 560 | * Open the configuration file for reading ..... 561 | */ 562 | if ((confPtr = fopen(configFile, "r")) == NULL) { 563 | printf("Error: file %s could not be opened.\n", configFile); 564 | die; 565 | } 566 | 567 | /* 568 | * Read the first record in the configuration file ..... We read the 569 | * _name_ of the variable using fscanf into a string array. We read 570 | * the _value_ of the variable using fgets into an array; thus, we 571 | * can handle values of variables with qualifiers (e.g. SPLIT after 572 | * DBLIST) and values with blank characters (e.g. REPLYBANNER). 573 | */ 574 | fscanf(confPtr, "%s", name); 575 | fgets(value, sizeof(value), confPtr); 576 | g_strstrip(value); 577 | 578 | 579 | /* 580 | * While there are records to be read in the config file. write the 581 | * current record into memory, read the next record in the config 582 | * file 583 | */ 584 | 585 | while (!feof(confPtr)) { 586 | 587 | /* 588 | * From the variable name, find the dictionary number. The 589 | * dictionary number is defined as the place in the values 590 | * array in which to store the value of the variable. 591 | * 592 | */ 593 | 594 | /* 595 | * Process the line only when/if it is not a comment or a 596 | * blankline. 597 | */ 598 | if ((strncmp(name, comment, 1) != 0) && (strncmp(name, blankLine, 1) != 0)) { 599 | /* 600 | * If the last character of "value" is '\n', replace 601 | * it with '\0'. 602 | */ 603 | if (value[strlen(value) - 1] == '\n') { 604 | value[strlen(value) - 1] = '\0'; 605 | } 606 | 607 | /* 608 | * From the variable name, find the element of the 609 | * values array in which to store the value of the 610 | * variable. 611 | * 612 | */ 613 | location = ca_getStorageLocation(name, dictionary, VARS); 614 | 615 | #ifdef DEBUG 616 | printf("The location is: %d\n", location); 617 | #endif /* DEBUG */ 618 | 619 | /* 620 | * See if the string value has already been stored; 621 | * if it has, then concatenate the new value to it; 622 | * if not, then allocate some memory and copy the 623 | * string into it. 624 | */ 625 | 626 | /* 627 | * If this variable already exists, it has a non-zero 628 | * value and this 'if' statement returns a "true" 629 | * value. Otherwise, it returns a "zero" or "false" 630 | * value. 631 | */ 632 | if (confVars[location].strPtr) { 633 | /* 634 | * strcat(confVars[location].strPtr, "\n"); 635 | * strcat(confVars[location].strPtr, value); 636 | */ 637 | g_string_append(confVars[location].strPtr, "\n"); 638 | g_string_append(confVars[location].strPtr, value); 639 | } 640 | else { 641 | /* 642 | * Store a pointer to the string that 643 | * contains the value This is not necessarily 644 | * the actual value itself. 645 | */ 646 | 647 | confVars[location].strPtr = g_string_new(value); 648 | } 649 | 650 | /* 651 | * Now, store a pointer to the _value_ of the 652 | * variable. Do this as follows: (a) get the _type_ 653 | * of the variable (b) store a pointer to the value 654 | * of the variable in a way that depends on the 655 | * _type_ of the variable. 656 | */ 657 | #ifdef DEBUG 658 | printf("Variable \"%s\" is data-type \"%d\"\n", name, ca_getType(name, dictionary, VARS)); 659 | #endif /* DEBUG */ 660 | 661 | 662 | type = ca_getType(name, dictionary, VARS); 663 | 664 | /* 665 | * Given the _type_ of the variable, store the value 666 | * of the variable in the appropriate way. 667 | */ 668 | switch (type) { 669 | case 11: 670 | 671 | #ifdef DEBUG 672 | puts("Data type is Integer"); 673 | #endif /* DEBUG */ 674 | 675 | confVars[location].valPtr = UT_malloc(sizeof(int)); 676 | 677 | sscanf(value, "%d", (int *) confVars[location].valPtr); 678 | break; 679 | 680 | case 12: 681 | 682 | #ifdef DEBUG 683 | puts("Data type is String !!! *** !!!"); 684 | #endif /* DEBUG */ 685 | 686 | 687 | /* 688 | * Test if this variable has already been 689 | * created. Look for a non-zero i.e. true 690 | * value. 691 | * 692 | * First put a '\n' character at the end of the 693 | * existing string. Then, concatenate the 694 | * additional string. 695 | */ 696 | if (confVars[location].valPtr) { 697 | #ifdef DEBUG 698 | printf("\n%s variable already exists\n", name); 699 | #endif /* DEBUG */ 700 | g_string_append(confVars[location].valPtr, value); 701 | g_string_append(confVars[location].valPtr, "\n"); 702 | } 703 | else { 704 | /* 705 | * If the variable has not already 706 | * been created, then create it. 707 | */ 708 | #ifdef DEBUG 709 | printf("\n%s variable does not exist\n", name); 710 | #endif /* DEBUG */ 711 | 712 | /* 713 | * We use g_string_new() to create a 714 | * new GString. This is a _structure_ 715 | * of str and len. The actual string 716 | * is stored in the str component. 717 | * Thus, when we want to access the 718 | * string, we must look into 719 | * structure. 720 | */ 721 | confVars[location].valPtr = g_string_new(value); 722 | g_string_append(confVars[location].valPtr, "\n"); 723 | } 724 | 725 | break; 726 | 727 | case 13: 728 | #ifdef DEBUG 729 | puts("Data type is Dirlist"); 730 | #endif /* DEBUG */ 731 | confVars[location].valPtr = (char *) UT_malloc(STRLENGTH); 732 | 733 | strcpy(confVars[location].valPtr, value); 734 | break; 735 | 736 | case 14: 737 | #ifdef DEBUG 738 | puts("Data type is Boolean"); 739 | #endif /* DEBUG */ 740 | 741 | confVars[location].valPtr = UT_malloc(sizeof(int)); 742 | 743 | sscanf(value, "%d", (int *) confVars[location].valPtr); 744 | break; 745 | 746 | 747 | case 16: 748 | #ifdef DEBUG 749 | puts("Found the CA_ADMIN stuff !!!"); 750 | #endif /* DEBUG */ 751 | /* 752 | * The elements of the Admin-DB have already 753 | * been read in. 754 | * Now, split up the elements and assign them 755 | * to the 756 | * components of the Admin-DB structure. 757 | * 758 | * First, separate the values in "value", 759 | * using ',' as a 760 | * delimiting character. 761 | */ 762 | dbcomps = g_strsplit(value, ",", 0); 763 | 764 | #ifdef DEBUG 765 | for (i = 0; dbcomps[i] != NULL; i++) 766 | printf("dbcomps[%d] = %s\n", i, dbcomps[i]); 767 | #endif /* DEBUG */ 768 | 769 | /* 770 | * Now, allocate some memory to the 771 | * newAdminPtr. 772 | */ 773 | newAdminPtr = UT_calloc(1, sizeof(ca_ripadmin_t)); 774 | 775 | /* 776 | * Now, assign the elements of the dbcomps 777 | * array to the appropriate components of the 778 | * structure to which newAdminPtr points. 779 | */ 780 | 781 | /* 782 | * Strip leading and trailing whitespace from 783 | * dbcomps[0] 784 | */ 785 | /* 786 | * g_strstrip( dbcomps[0] ); 787 | */ 788 | 789 | strcpy(newAdminPtr->host, dbcomps[0]); 790 | newAdminPtr->port = atoi(dbcomps[1]); 791 | strcpy(newAdminPtr->user, dbcomps[2]); 792 | strcpy(newAdminPtr->password, dbcomps[3]); 793 | strcpy(newAdminPtr->tableName, dbcomps[4]); 794 | 795 | g_strfreev(dbcomps); 796 | 797 | #ifdef DEBUG 798 | puts("Testing the population of the rip-admin db structure:"); 799 | printf("\n%s::%d::%s::%s::%s\n", newAdminPtr->host, newAdminPtr->port, newAdminPtr->user, newAdminPtr->password, newAdminPtr->tableName); 800 | #endif /* DEBUG */ 801 | 802 | /* 803 | * Now, assign these values into the correct 804 | * long-term storage. 805 | */ 806 | 807 | confVars[location].valPtr = (ca_ripadmin_t *) UT_calloc(1, sizeof(ca_ripadmin_t)); 808 | 809 | memcpy(confVars[location].valPtr, newAdminPtr, sizeof(ca_ripadmin_t)); 810 | 811 | UT_free(newAdminPtr); 812 | 813 | #ifdef DEBUG 814 | printf("The ripadmin machine is: %s\n", ((ca_ripadmin_t *) confVars[location].valPtr)->host); 815 | #endif /* DEBUG */ 816 | 817 | break; 818 | 819 | case 17: 820 | /* 821 | * Found Update_Source variable. 822 | There may be multiple instances of this 823 | */ 824 | #ifdef DEBUG 825 | printf("Found Update_Source variable !!!\n"); 826 | #endif /* DEBUG */ 827 | 828 | #ifdef DEBUG 829 | puts(name); 830 | puts(value); 831 | #endif /* DEBUG */ 832 | 833 | /* 834 | * Split the value into DB-name, DB-details, 835 | * updDetails. Use blankspace as the 836 | * delimiter between each of these variables. 837 | */ 838 | sscanf(value, "%s %s %s", source, database, updDetails); 839 | #ifdef DEBUG 840 | puts(source); 841 | puts(database); 842 | puts(updDetails); 843 | #endif /* DEBUG */ 844 | 845 | /* 846 | * Using the values in "database", populate a 847 | * ca_database_t structure. Give this 848 | * variable a name. 849 | */ 850 | 851 | /* 852 | * First, separate the values in "database", 853 | * using "," as as a delimiting character. 854 | */ 855 | dbcomps = g_strsplit(database, ",", 0); 856 | 857 | #ifdef DEBUG 858 | for (i = 0; dbcomps[i] != NULL; i++) 859 | printf("dbcomps[%d] = %s\n", i, dbcomps[i]); 860 | #endif /* DEBUG */ 861 | 862 | /* 863 | * Create a structure for this database. 864 | */ 865 | newUpdDbPtr = UT_calloc(1, sizeof(ca_database_t)); 866 | 867 | strcpy(newUpdDbPtr->host, dbcomps[0]); 868 | newUpdDbPtr->port = atoi(dbcomps[1]); 869 | strcpy(newUpdDbPtr->user, dbcomps[2]); 870 | strcpy(newUpdDbPtr->password, dbcomps[3]); 871 | strcpy(newUpdDbPtr->dbName, dbcomps[4]); 872 | 873 | g_strfreev(dbcomps); 874 | 875 | #ifdef DEBUG 876 | puts("Testing the population of the UPD db structure:"); 877 | printf("\n%s::%d::%s::%s::%s\n", newUpdDbPtr->host, newUpdDbPtr->port, newUpdDbPtr->user, newUpdDbPtr->password, newUpdDbPtr->dbName); 878 | #endif /* DEBUG */ 879 | 880 | /* 881 | * Now, store the values contained in the 882 | * updDetails string. 883 | */ 884 | 885 | /* 886 | * First, separate the values in the 887 | * 'updDetails' string, using "," as a 888 | * delimiting character. 889 | */ 890 | updDbcomps = g_strsplit(updDetails, ",", 0); 891 | 892 | #ifdef DEBUG 893 | for (i = 0; updDbcomps[i] != NULL; i++) 894 | printf("updDbcomps[%d] = %s\n", i, updDbcomps[i]); 895 | #endif /* DEBUG */ 896 | 897 | /* 898 | * Using the above ca_database_t structure, 899 | * the "source" value and the values of 900 | * updDbcomps, populate the ca_updDbSource_t 901 | * structure. 902 | * 903 | */ 904 | 905 | /* 906 | * Create a new structure for this UPD 907 | * Source. 908 | */ 909 | newUpdSrc = UT_calloc(1, sizeof(ca_updDbSource_t)); 910 | 911 | #ifdef DEBUG 912 | puts("Created a structure for the UPD Source variable"); 913 | #endif /* DEBUG */ 914 | 915 | /* 916 | * Now, populate this structure. 917 | */ 918 | 919 | strcpy(newUpdSrc->name, source); 920 | newUpdSrc->updDb = *newUpdDbPtr; 921 | strcpy(newUpdSrc->whoisd_host, updDbcomps[0]); 922 | newUpdSrc->qryPort = atoi(updDbcomps[1]); 923 | newUpdSrc->updPort = atoi(updDbcomps[2]); 924 | 925 | UT_free(newUpdDbPtr); /* Was copied */ 926 | g_strfreev(updDbcomps); 927 | 928 | #ifdef DEBUG 929 | puts("Testing the population of the ca_updDbSource_t structure:"); 930 | printf("Update Source name: %s\n", newUpdSrc->name); 931 | printf("\nUPD-DB == %s::%d::%s::%s::%s\n", (newUpdSrc->updDb).host, (newUpdSrc->updDb).port, (newUpdSrc->updDb).user, (newUpdSrc->updDb).password, (newUpdSrc->updDb).dbName); 932 | printf("\nUpdate Source Machine Details: %s::%d::%d\n", newUpdSrc->whoisd_host, newUpdSrc->qryPort, newUpdSrc->updPort); 933 | #endif /* DEBUG */ 934 | 935 | /* 936 | * Now, assign these values into the correct 937 | * long-term storage. 938 | */ 939 | 940 | if ( num_sources < CA_MAXSOURCES ) 941 | { 942 | ((ca_updDbSource_t **)confVars[location].valPtr)[num_sources] = (ca_updDbSource_t *) UT_calloc(1, sizeof(ca_updDbSource_t)); 943 | 944 | memcpy( ((ca_updDbSource_t **)confVars[location].valPtr)[num_sources++], newUpdSrc, sizeof(ca_updDbSource_t)); 945 | } 946 | else 947 | { 948 | fprintf(stderr, "Max number of Update Sources exceeded\n"); 949 | die; 950 | } 951 | 952 | /* No longer needed. */ 953 | UT_free(newUpdSrc); 954 | 955 | #ifdef DEBUG 956 | printf("UPD-Source/DB-details/user: %s\n", (((ca_updDbSource_t *) (confVars[location].valPtr)[num_sources-1])->updDb).user); 957 | #endif /* DEBUG */ 958 | 959 | break; 960 | 961 | default: 962 | fprintf(stderr, "Data type not found for variable \"%s\".\n", name); 963 | die; 964 | break; 965 | } 966 | } 967 | 968 | fscanf(confPtr, "%s", name); 969 | fgets(value, sizeof(value), confPtr); 970 | g_strstrip(value); 971 | 972 | } /* End of processing the config file. */ 973 | 974 | } /* End of readConfig() function */ 975 | 976 | 977 | 978 | 979 | void 980 | ca_getDictionary(dict_t woordenboek[], int size) 981 | { 982 | int k; 983 | 984 | for (k = 0; k < size; k++) { 985 | printf("\nj = %d\n", k); 986 | /* 987 | * printf("%s\t%d\t%s\n", woordenboek[k].varName, 988 | * woordenboek[k].varScope, woordenboek[k].varType); 989 | */ 990 | printf("%s\t%s\t%s\t%d\n", woordenboek[k].varName, woordenboek[k].varSym, woordenboek[k].varType, woordenboek[k].varNum); 991 | 992 | } 993 | } 994 | 995 | 996 | int 997 | ca_get_int(int symbol) 998 | { 999 | int *xPtr; 1000 | 1001 | /* 1002 | * First print a message saying that the ca_get_int() function is 1003 | * being called. 1004 | */ 1005 | #ifdef DEBUG 1006 | printf("\nDEBUG: ca_get_int() function is called .....\n"); 1007 | printf("DEBUG: New value of StringPtr: %s\n", confVars[symbol].strPtr); 1008 | #endif /* DEBUG */ 1009 | 1010 | /* 1011 | * Look at the appropriate place in the dictionary; e.g. C_BINDPORT 1012 | * => the first element, index = 0. 1013 | * 1014 | * if the varType is not an integer, exit with an error; 1015 | * 1016 | * otherwise, return an integer. 1017 | * 1018 | */ 1019 | 1020 | /* Look at the appropriate place in the dictionary. */ 1021 | 1022 | #ifdef DEBUG 1023 | printf("\nDEBUG: Variable type: %s\n", dictionary[symbol].varType); 1024 | #endif /* DEBUG */ 1025 | 1026 | /* If the variable type is not an integer, exit with an error. */ 1027 | if (strcmp(dictionary[symbol].varType, "CA_INT") != 0) { 1028 | fprintf(stderr, "Error: unexpected variable type.\n"); 1029 | die; 1030 | } 1031 | else { 1032 | /* 1033 | * Lock the value of the variable before reading it. 1034 | */ 1035 | 1036 | pthread_mutex_lock(&Lock); 1037 | 1038 | xPtr = confVars[symbol].valPtr; 1039 | /* 1040 | * Unlock the value of the variable after reading it. 1041 | */ 1042 | pthread_mutex_unlock(&Lock); 1043 | } 1044 | 1045 | if (xPtr == NULL) { 1046 | printf("Error: undefined integer variable: %s\n ", dictionary[symbol].varName); 1047 | 1048 | die; 1049 | } 1050 | return (*xPtr); 1051 | } 1052 | 1053 | char * 1054 | ca_get_dirlist(int symbol) 1055 | { 1056 | /* 1057 | * This function returns a pointer to a character array. Thus, we 1058 | * need to declare such a pointer. 1059 | * 1060 | */ 1061 | 1062 | char *xPtr; 1063 | #ifdef DEBUG 1064 | printf("\nca_get_dirlist() function is called .....\n"); 1065 | #endif /* DEBUG */ 1066 | 1067 | 1068 | /* 1069 | * Look at the appropriate place in the dictionary; e.g. CA_HELP => 1070 | * the second element, index = 1. 1071 | * 1072 | * if the varType is not CA_DIRLIST, exit with an error; 1073 | * 1074 | * otherwise, return a pointer to the value. 1075 | * 1076 | */ 1077 | 1078 | /* Look at the appropriate place in the dictionary. */ 1079 | #ifdef DEBUG 1080 | printf("\nVariable type: %s\n", dictionary[symbol].varType); 1081 | #endif /* DEBUG */ 1082 | 1083 | /* If the variable type is not CA_DIRLIST, exit with an error. */ 1084 | if (strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0) { 1085 | fprintf(stderr, "Error: unexpected variable type.\n"); 1086 | die; 1087 | } 1088 | else { 1089 | pthread_mutex_lock(&Lock); 1090 | /* 1091 | * Test if a value for this variable has been defined. If 1092 | * yes, return a copy of it. If not, print an error message 1093 | * and die. 1094 | */ 1095 | if (confVars[symbol].valPtr) { 1096 | xPtr = (UT_strdup(confVars[symbol].valPtr)); 1097 | #ifdef DEBUG 1098 | printf("Value: %s\n", xPtr); 1099 | #endif /* DEBUG */ 1100 | } 1101 | else { 1102 | printf("Error: undefined DIRLIST variable: %s\n", dictionary[symbol].varName); 1103 | die; 1104 | } 1105 | pthread_mutex_unlock(&Lock); 1106 | } 1107 | return (xPtr); 1108 | } 1109 | 1110 | 1111 | char * 1112 | ca_get_string(int symbol) 1113 | { 1114 | /* 1115 | * This function returns a pointer to a character array. Thus, we 1116 | * need to declare such a pointer. 1117 | * 1118 | */ 1119 | 1120 | char *xPtr; 1121 | #ifdef DEBUG 1122 | printf("\nca_get_text() function is called .....\n"); 1123 | #endif /* DEBUG */ 1124 | 1125 | 1126 | /* 1127 | * Look at the appropriate place in the dictionary; e.g. 1128 | * CA_REPLYBANNER => the third element, index = 2. 1129 | * 1130 | * if the varType is not CA_STRING, exit with an error; 1131 | * 1132 | * otherwise, return the value. 1133 | * 1134 | */ 1135 | 1136 | /* Look at the appropriate place in the dictionary. */ 1137 | 1138 | #ifdef DEBUG 1139 | printf("\nVariable type: %s\n", dictionary[symbol].varType); 1140 | #endif /* DEBUG */ 1141 | 1142 | /* If the variable type is not CA_STRING, exit with an error. */ 1143 | if (strcmp(dictionary[symbol].varType, "CA_STRING") != 0) { 1144 | fprintf(stderr, "Error: unexpected variable type.\n"); 1145 | die; 1146 | } 1147 | else { 1148 | pthread_mutex_lock(&Lock); 1149 | 1150 | /* 1151 | * Test if a value for this variable has been defined. If 1152 | * yes, return a copy of it. If not, return a NULL pointer. 1153 | */ 1154 | if (((GString *) confVars[symbol].valPtr)) { 1155 | xPtr = (UT_strdup(((GString *) confVars[symbol].valPtr)->str)); 1156 | #ifdef DEBUG 1157 | printf("Value: %s\n", xPtr); 1158 | #endif /* DEBUG */ 1159 | } 1160 | else { 1161 | #ifdef DEBUG 1162 | printf("STRING value is undefined !!!\n"); 1163 | #endif /* DEBUG */ 1164 | xPtr = NULL; 1165 | } 1166 | pthread_mutex_unlock(&Lock); 1167 | } 1168 | return (xPtr); 1169 | } 1170 | 1171 | 1172 | int 1173 | ca_get_boolean(int symbol) 1174 | { 1175 | /********************************************** 1176 | * ca_get_boolean() * 1177 | * * 1178 | * * 1179 | * Parameters * 1180 | * * 1181 | * symbol -- the symbol for the variable * 1182 | * * 1183 | * * 1184 | * Returns * 1185 | * * 1186 | * 1 if true, 0 if false. * 1187 | * * 1188 | * Remarks * 1189 | * * 1190 | * Is there a better way to implement * 1191 | * Boolean values in C ? * 1192 | * * 1193 | *********************************************/ 1194 | 1195 | int *xPtr; 1196 | 1197 | /* 1198 | * Print this message if in debug mode. 1199 | * 1200 | */ 1201 | #ifdef DEBUG 1202 | printf("\nca_get_boolean() function is called .....\n"); 1203 | printf("DEBUG 5: New value of StringPtr: %s\n", globals[symbol].strPtr); 1204 | #endif /* DEBUG */ 1205 | 1206 | /**********************************************\ 1207 | * * 1208 | * Here is how this works: * 1209 | * * 1210 | * (a) Check that the type of variable whose * 1211 | * value is being read is CA_BOOLEAN. * 1212 | * * 1213 | * (b) Lock the value of the variable before * 1214 | * reading it. * 1215 | * * 1216 | * (c) Depending on the scope of the variable * 1217 | * look for it in the appropriate array. * 1218 | * * 1219 | * (d) Read the value of the variable. * 1220 | * * 1221 | * (e) Unlock the value of the variable after * 1222 | * reading it. * 1223 | * * 1224 | * * 1225 | * Returns * 1226 | * 1227 | * an integer value as follows: * 1228 | * 1 if the db is in testmode (true), * 1229 | * 0 if the db is not in testmode (false). * 1230 | \*********************************************/ 1231 | 1232 | 1233 | /* 1234 | * Look at the appropriate place in the dictionary; e.g. CA_BOOLEAN = 1235 | * the fifth element of the dict_t array, => index = 4. 1236 | * 1237 | * If the varType is not Boolean, exit with an error 1238 | * 1239 | * Otherwise, 1240 | * 1241 | */ 1242 | 1243 | #ifdef DEBUG 1244 | /* Look in the appropriate place in the dictionary. */ 1245 | printf("\nVariable type: %s\n", dictionary[symbol].varType); 1246 | #endif /* DEBUG */ 1247 | 1248 | /* If the variable type is not Boolean, exit with an error. */ 1249 | 1250 | if (strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0) { 1251 | fprintf(stderr, "Error: Boolean type expected.\n"); 1252 | die; 1253 | } 1254 | 1255 | else { 1256 | 1257 | /* 1258 | * Otherwise, return an integer value. 1259 | * 1260 | */ 1261 | 1262 | /* 1263 | * Lock the value of the variable before reading it. 1264 | * 1265 | */ 1266 | 1267 | pthread_mutex_lock(&Lock); 1268 | xPtr = confVars[symbol].valPtr; 1269 | /* 1270 | * Unlock the value of the variable after reading it. 1271 | */ 1272 | pthread_mutex_unlock(&Lock); 1273 | 1274 | } 1275 | if (xPtr == NULL) { 1276 | printf("Undefined Boolean variable: %s\n", dictionary[symbol].varName); 1277 | die; 1278 | } 1279 | return (*xPtr); 1280 | } 1281 | 1282 | 1283 | 1284 | void 1285 | ca_set_int(int symbol) 1286 | { 1287 | /********************************************* 1288 | * ca_set_int() * 1289 | * * 1290 | * Parameters * 1291 | * symbol -- the symbol for the variable. * 1292 | * * 1293 | * Returns * 1294 | * 1 if successful 0 if not ? * 1295 | * * 1296 | * Remarks * 1297 | * Needs a better way to check for valid * 1298 | * values from the keyboard. * 1299 | * * 1300 | *********************************************/ 1301 | 1302 | /* 1303 | * void *tempPtr; 1304 | *//* Temp pointer to point to the value pointer in the appropriate 1305 | * values array. */ 1306 | char newPort[16]; 1307 | int invalid; 1308 | int portNr; 1309 | 1310 | /* 1311 | * Function to change the value in a given values array. This 1312 | * function can only be called from within ca_set_int(). 1313 | */ 1314 | int *ca_change_int_value(char[]); 1315 | void testFunction(values_t values[]); 1316 | 1317 | /* 1318 | * Using the symbol, look at the appropriate place in the dictionary. 1319 | */ 1320 | #ifdef DEBUG 1321 | printf("\nca_set_int() function called .....\n"); 1322 | printf("Variable type: %s\n", dictionary[symbol].varType); 1323 | #endif /* DEBUG */ 1324 | 1325 | 1326 | /* 1327 | * Make sure that a reasonable, sensible value of bind-port has been 1328 | * read from the keyboard. 1329 | */ 1330 | 1331 | do { 1332 | 1333 | /* 1334 | * First, flush input stream. 1335 | */ 1336 | fflush(stdin); 1337 | 1338 | /* 1339 | * Prompt for the new value of the bind-port. 1340 | */ 1341 | 1342 | printf("\nNew value of bind-port (non-zero positive integer) >>> "); 1343 | scanf("%s", newPort); 1344 | /* 1345 | * gets(newPort); 1346 | */ 1347 | #ifdef DEBUG 1348 | printf("\nDEBUG: Value of newPort variable: %s\n", newPort); 1349 | #endif /* DEBUG */ 1350 | 1351 | sscanf(newPort, "%d", &portNr); 1352 | 1353 | #ifdef DEBUG 1354 | printf("\nDEBUG: Value of integer variable, portNr: %d\n", portNr); 1355 | #endif /* DEBUG */ 1356 | 1357 | if (portNr < 0) { 1358 | invalid = 1; 1359 | puts("Only non-zero positive integer values accepted for bind-port"); 1360 | } 1361 | else { 1362 | invalid = 0; 1363 | } 1364 | 1365 | } while (invalid); 1366 | 1367 | /* 1368 | * Check that the function is attempting to set the correct type of 1369 | * value. If not, do not set the value and exit. 1370 | */ 1371 | 1372 | if (strcmp(dictionary[symbol].varType, "CA_INT") != 0) { 1373 | fprintf(stderr, "Error: unexpected variable type.\n"); 1374 | die; 1375 | } 1376 | 1377 | /* 1378 | * Choose the appropriate values array. 1379 | */ 1380 | switch (dictionary[symbol].varScope) { 1381 | /* 1382 | * If the variable has global scope, write it into the 1383 | * globals array. If it has local scope, write it into the 1384 | * local array. If the scope cannot be found, then report an 1385 | * error. 1386 | */ 1387 | case 1: 1388 | globals[symbol].valPtr = ca_change_int_value(newPort); 1389 | 1390 | /************************************************************ 1391 | * * 1392 | * We comment out this code. We use the GLib string * 1393 | * now. It also checks if we got the memory :-) * 1394 | * * 1395 | ************************************************************/ 1396 | 1397 | /* 1398 | * globals[symbol].strPtr = newPort; 1399 | * 1400 | * globals[symbol].strPtr = (char *) calloc(1, sizeof(newPort)); 1401 | */ 1402 | 1403 | /* 1404 | * Check the return value of calloc() to make sure that we 1405 | * actually got the memory. 1406 | */ 1407 | 1408 | /* 1409 | * if (globals[symbol].strPtr == NULL) { 1410 | * fprintf(stderr, "Cannot allocate memory for globals[symbol].strPtr.\n"); 1411 | * die; 1412 | * } 1413 | */ 1414 | 1415 | #ifdef DEBUG 1416 | printf("DEBUG: New value of StringPtr: %s\n", globals[symbol].strPtr); 1417 | #endif /* DEBUG */ 1418 | 1419 | /* 1420 | * strcpy(globals[symbol].strPtr, newPort); 1421 | */ 1422 | 1423 | g_string_assign (globals[symbol].strPtr, newPort); 1424 | 1425 | 1426 | #ifdef DEBUG 1427 | printf("DEBUG 2: New value of StringPtr: %s\n", globals[symbol].strPtr); 1428 | #endif /* DEBUG */ 1429 | break; 1430 | 1431 | case 99: 1432 | locals[symbol].valPtr = ca_change_int_value(newPort); 1433 | /* 1434 | * First allocate some memory and then copy the value of the 1435 | * new Port into it. 1436 | */ 1437 | 1438 | /************************************************************ 1439 | * * 1440 | * We comment out this code. We use the GLib string * 1441 | * now. It also checks if we got the memory :-) * 1442 | * * 1443 | ************************************************************/ 1444 | 1445 | /* 1446 | * locals[symbol].strPtr = (char *) calloc(1, sizeof(newPort)); 1447 | */ 1448 | 1449 | /* 1450 | * Now, check that the memory was actually allocated. 1451 | */ 1452 | 1453 | /* 1454 | * if (locals[symbol].strPtr == NULL) { 1455 | * fprintf(stderr, "Cannot allocate memory for locals[symbol].strPtr\n"); 1456 | * exit(8); 1457 | * } 1458 | * 1459 | * strcpy(locals[symbol].strPtr, newPort); 1460 | */ 1461 | 1462 | g_string_assign (locals[symbol].strPtr, newPort); 1463 | 1464 | /* 1465 | * locals[symbol].strPtr = newPort; 1466 | */ 1467 | break; 1468 | 1469 | default: 1470 | fprintf(stderr, "Error; unknown scope: %d\n", dictionary[symbol].varScope); 1471 | break; 1472 | } 1473 | 1474 | /* 1475 | * Write the new value of the variable to the correct place in this 1476 | * array. (First, set a mutex lock ???). 1477 | */ 1478 | 1479 | /* 1480 | * Write the new value of this variable back to the config. file 1481 | */ 1482 | 1483 | ca_writeNewValue(symbol, newPort); 1484 | 1485 | printf("DEBUG 3: New value of StringPtr: %s\n", (globals[symbol].strPtr)->str); 1486 | 1487 | } 1488 | 1489 | int * 1490 | ca_change_int_value(char value[]) 1491 | { 1492 | void *tempPtr; 1493 | 1494 | tempPtr = UT_malloc(sizeof(int)); 1495 | 1496 | /* 1497 | * No need to check the return value of UT_malloc() in case we did not 1498 | * actually get the memory. 1499 | * 1500 | *if (tempPtr == NULL) { 1501 | * fprintf(stderr, "Cannot allocate memory for tempPtr\n"); 1502 | * die; 1503 | * } 1504 | */ 1505 | 1506 | sscanf(value, "%d", (int *) tempPtr); 1507 | return (tempPtr); 1508 | } 1509 | 1510 | 1511 | 1512 | void 1513 | testFunction(values_t array[]) 1514 | { 1515 | printf("\nInside the Test function.\n"); 1516 | } 1517 | 1518 | 1519 | void 1520 | ca_getDatabase(ca_database_t db) 1521 | { 1522 | printf("\n%s\t%d\t%s\t%s\t%s\n", db.host, db.port, db.user, db.password, db.dbName); 1523 | } 1524 | 1525 | void 1526 | ca_getSource(ca_database_list_t src) 1527 | { 1528 | printf("\n%s\t%s\t%d\t%s\t%s\t%s\n", src.name, (src.db).host, (src.db).port, (src.db).user, (src.db).password, (src.db).dbName); 1529 | } 1530 | 1531 | 1532 | void 1533 | ca_getAllSources(GSList * sources) 1534 | { 1535 | 1536 | GSList *currentPtr; /* Pointer to the structure at which we look. */ 1537 | 1538 | /* 1539 | * Look at the first member of the linked-list of sources. 1540 | */ 1541 | currentPtr = sources; 1542 | 1543 | /* 1544 | * Look at each data component of the source list, untill we reach 1545 | * the end of the list. 1546 | */ 1547 | while (currentPtr != NULL) { 1548 | ca_database_list_t *srcPtr = currentPtr->data; 1549 | printf("\n%s\t%s\t%d\t%s\t%s\t%s\n", srcPtr->name, (srcPtr->db).host, (srcPtr->db).port, (srcPtr->db).user, (srcPtr->db).password, (srcPtr->db).dbName); 1550 | currentPtr = currentPtr->next; 1551 | } 1552 | } 1553 | 1554 | void 1555 | ca_getAsource(char *sourceName, GSList * sources) 1556 | /******************************************************************* 1557 | * ca_getAsource -- looks for a source in the linked list * 1558 | * * 1559 | * Parameters * 1560 | * sourceName -- the name of a source for which to look * 1561 | * sources -- the list of sources in which to look * 1562 | * * 1563 | * Returns * 1564 | * nothing, so far. * 1565 | * * 1566 | *******************************************************************/ 1567 | { 1568 | 1569 | GSList *currentPtr = sources; 1570 | 1571 | #ifdef DEBUG 1572 | printf("\nLooking for source: %s\n", sourceName); 1573 | #endif /* DEBUG */ 1574 | 1575 | /* 1576 | * Look at each data component of the source list, compare the name 1577 | * of the source with the sourceName untill we find the source o we 1578 | * reach the end of the list 1579 | */ 1580 | { /* Begin special block I got a syntax error when I defined 1581 | * "ca_database_list_t *srcPtr = currentPtr->data;" in the 1582 | * usual way, with all the other local variables. 1583 | * 1584 | * However, if I define it inside this block, I do not get any 1585 | * syntax errors. 1586 | * 1587 | */ 1588 | 1589 | 1590 | ca_database_list_t *srcPtr = currentPtr->data; 1591 | #ifdef DEBUG 1592 | printf("FirstSource is: %s\n", srcPtr->name); 1593 | #endif /* DEBUG */ 1594 | while ((currentPtr != NULL) && (strcmp(srcPtr->name, sourceName) != 0)) { 1595 | #ifdef DEBUG 1596 | puts("Now printing the current source ....."); 1597 | printf("CurrentSource is: %s\n", srcPtr->name); 1598 | printf("%d\n", strcmp(srcPtr->name, sourceName)); 1599 | if (strcmp(srcPtr->name, sourceName) == 0) { 1600 | printf("Found it !!! Source: %s\n", srcPtr->name); 1601 | } 1602 | #endif /* DEBUG */ 1603 | currentPtr = currentPtr->next; 1604 | puts("currentPtr = currentPtr->next"); 1605 | if (currentPtr != NULL) { 1606 | srcPtr = currentPtr->data; 1607 | puts("srcPtr = currentPtr->data"); 1608 | } 1609 | #ifdef DEBUG 1610 | puts("At the end of the while loop inside ca_getAsource function ....."); 1611 | printf("The NewSource is: %s\n", srcPtr->name); 1612 | #endif /* DEBUG */ 1613 | } 1614 | #ifdef DEBUG 1615 | puts("Exited from while loop in ca_getAsource function ....."); 1616 | #endif /* DEBUG */ 1617 | 1618 | if (currentPtr != NULL) { 1619 | printf("\nFound the source: %s\n", srcPtr->name); 1620 | /* 1621 | * printf("\n%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", 1622 | * srcPtr->name, (srcPtr->db).host, 1623 | * (srcPtr->db).port, (srcPtr->db).user, 1624 | * (srcPtr->db).password, (srcPtr->db).canupd, 1625 | * (srcPtr->db).deflook, (srcPtr->db).dbName); 1626 | */ 1627 | } 1628 | else { 1629 | printf("\nCould not find source: %s\n", sourceName); 1630 | } 1631 | } /* End special block */ 1632 | 1633 | } 1634 | 1635 | 1636 | ca_dbSource_t * 1637 | ca_getSourceDetails(char *sourceName, GSList * sources) 1638 | /******************************************************************* 1639 | * ca_getSourceDetails * 1640 | * -- A function that compares each 'name' component of every * 1641 | * ca_database_list_t element in the linked-list of sources * 1642 | * (the first element of which is a parameter of this function)* 1643 | * with the name of the source to be found. If the required * 1644 | * source is found, a pointer to the structure representing * 1645 | * this source is returned. * 1646 | * * 1647 | * Parameters * 1648 | * -- sourceName - the name of the required source * 1649 | * -- sources - the list of sources in which to look * 1650 | * * 1651 | * Returns * 1652 | * -- srcPtr - a pointer to the structure representing the source * 1653 | * - or a pointer to NULL, if we cannot find the source * 1654 | * * 1655 | *******************************************************************/ 1656 | { 1657 | /* 1658 | * Define a pointer to the current element in the linked list. 1659 | * Initialise it to the start of the list; 1660 | */ 1661 | GSList *currentPtr = sources; 1662 | 1663 | /* 1664 | * Define and initialise a pointer that points to the 'data' 1665 | * component of the GSList struct; i.e. a pointer to a variable of 1666 | * type ca_dbSource_t. 1667 | */ 1668 | ca_dbSource_t *srcPtr = currentPtr->data; 1669 | 1670 | 1671 | /* 1672 | * Look at each data component of list of sources; (each data 1673 | * component is a structure of type ca_dbSource_t i.e. 1674 | * ca_database_list_t). Compare the 'name' component of of each 1675 | * ca_dbSource_t structure with the value of sourceName untill we get 1676 | * a match or we reach the end of the list. 1677 | */ 1678 | /* 1679 | * We first check if currentPtr is pointing to NULL; if yes, we exit 1680 | * the while loop; if no, we make srcPtr point to the data component 1681 | * of the current dbSource structure; then, we check if this is the 1682 | * source name that we want; if yes, we _break_ from the while loop. 1683 | */ 1684 | while (currentPtr != NULL) { 1685 | srcPtr = currentPtr->data; 1686 | if (strcasecmp(srcPtr->name, sourceName) == 0) 1687 | break; 1688 | currentPtr = currentPtr->next; 1689 | } 1690 | 1691 | /* 1692 | * We return a pointer. If we found the source, this pointer points 1693 | * to the ca_dbSource_t structure which represents the source. If we 1694 | * did not find the source, we return a pointer to NULL. 1695 | */ 1696 | if (currentPtr == NULL) { 1697 | srcPtr = NULL; 1698 | return (srcPtr); 1699 | } 1700 | else { 1701 | return (srcPtr); 1702 | } 1703 | 1704 | } /* End of ca_getSourceDetails function */ 1705 | 1706 | 1707 | ca_SrcHdl_t * 1708 | ca_get_SourceHandleByPosition(int position) 1709 | /******************************************************************* 1710 | * ca_get_SourceHandleByPosition * 1711 | * -- retrieves the a handle to a Source * 1712 | * * 1713 | * Parameters * 1714 | * -- the position in the linked list of sources * 1715 | * * 1716 | * * 1717 | * Returns * 1718 | * -- a pointer to the source or NULL * 1719 | * i.e. a pointer to the data component of the appropriate * 1720 | * element in the linked list of sources. * 1721 | *******************************************************************/ 1722 | { 1723 | ca_dbSource_t *mySource; 1724 | 1725 | mySource = g_slist_nth_data(sourceList, position); 1726 | return (mySource); 1727 | } 1728 | 1729 | ca_SrcHdl_t * 1730 | ca_get_SourceHandleByName(char *srcName) 1731 | /******************************************************************* 1732 | * ca_get_SourceHandleByName * 1733 | * -- retrieves the a handle to a source * 1734 | * * 1735 | * Parameters * 1736 | * -- the name of the required source 1737 | * * 1738 | * * 1739 | * Returns * 1740 | * -- a pointer to the source or NULL * 1741 | * i.e. a pointer to the data component of the appropriate * 1742 | * element in the linked list of sources. * 1743 | *******************************************************************/ 1744 | 1745 | { 1746 | ca_dbSource_t *mySource; 1747 | 1748 | mySource = ca_getSourceDetails(srcName, sourceList); 1749 | return (mySource); 1750 | } 1751 | 1752 | char * 1753 | ca_srchandle2Strelement(ca_SrcHdl_t * ah, int srcAttrib) 1754 | /******************************************************************* 1755 | * ca_srchandle2Strelement * 1756 | * -- returns a string which represents the attribute of a source * 1757 | * e.g. returns the name of a source * 1758 | * It allocates the required memory; * 1759 | * but it returns NULL if the required memory cannot be * 1760 | * allocated. 1761 | * * 1762 | * Parameters * 1763 | * -- source name - the name of the source 1764 | * ca_get_SourceHandleByName or ca_get_SourceHandleByPosition * 1765 | * * 1766 | * -- srcAttrib - an integer which represents the required * 1767 | * attribute of the source. We use #define statments to make * 1768 | * a mapping between the attributes and the integers. * 1769 | * * 1770 | * Returns * 1771 | * -- a string or NULL * 1772 | *******************************************************************/ 1773 | { 1774 | char *myStr; 1775 | 1776 | if (ah == NULL) { 1777 | fprintf(stderr, "ca_srchandle2Strelement(): Cannot dereference NULL pointer\n"); 1778 | die; 1779 | } 1780 | 1781 | pthread_mutex_lock(&Lock); 1782 | switch (srcAttrib) { 1783 | case 0: 1784 | /* source name */ 1785 | myStr = UT_strdup(ah->name); 1786 | break; 1787 | 1788 | case 1: 1789 | /* canupd */ 1790 | myStr = UT_strdup(ah->canupd); 1791 | break; 1792 | 1793 | case 2: 1794 | /* deflook */ 1795 | /* 1796 | * ca_malloc(myStr, 2); strcpy(myStr, (ah->db).deflook); 1797 | */ 1798 | myStr = UT_strdup(ah->deflook); 1799 | break; 1800 | 1801 | case 3: 1802 | /* machine */ 1803 | myStr = UT_strdup((ah->db).host); 1804 | break; 1805 | 1806 | case 5: 1807 | /* user */ 1808 | myStr = UT_strdup((ah->db).user); 1809 | break; 1810 | 1811 | case 6: 1812 | /* password */ 1813 | myStr = UT_strdup((ah->db).password); 1814 | break; 1815 | 1816 | case 7: 1817 | /* dbName */ 1818 | myStr = UT_strdup((ah->db).dbName); 1819 | break; 1820 | 1821 | case 9: 1822 | /* Near-Real-Time Mirror host */ 1823 | myStr = UT_strdup((ah->nrtm).host); 1824 | break; 1825 | 1826 | case 11: 1827 | /* NRTM Log */ 1828 | myStr = UT_strdup((ah->nrtm).log); 1829 | break; 1830 | 1831 | default: 1832 | puts("Cannot find this source attribute"); 1833 | myStr = NULL; 1834 | } 1835 | pthread_mutex_unlock(&Lock); 1836 | 1837 | return (myStr); 1838 | } 1839 | 1840 | int 1841 | ca_srchandle2Intelement(ca_SrcHdl_t * ah, int srcAttrib) 1842 | /******************************************************************* 1843 | * ca_srchandle2Intelement * 1844 | * -- a function that returns the integer value of the requested * 1845 | * attribute of the given source. * 1846 | * * 1847 | * Parameters * 1848 | * -- source name - the name of the source 1849 | * ca_get_SourceHandleByName or ca_get_SourceHandleByPosition * 1850 | * * 1851 | * -- srcAttrib - an integer which represents the required * 1852 | * attribute of the source. We use #define statments to make * 1853 | * a mapping between the attributes and the integers. * 1854 | * * 1855 | * Returns * 1856 | * -- an integer. 1857 | *******************************************************************/ 1858 | { 1859 | int myInt; /* The value of this integer is returned. */ 1860 | 1861 | if (ah == NULL) { 1862 | fprintf(stderr, "ca_srchandle2Intelement(): Cannot dereference NULL pointer\n"); 1863 | die; 1864 | } 1865 | 1866 | pthread_mutex_lock(&Lock); 1867 | switch (srcAttrib) { 1868 | 1869 | case 4: 1870 | /* DB Port */ 1871 | myInt = (ah->db).port; 1872 | break; 1873 | 1874 | case 8: 1875 | /* Mode of Operation of the Source. */ 1876 | myInt = ah->opMode; 1877 | break; 1878 | 1879 | case 10: 1880 | /* Near-Real-Time Mirror port */ 1881 | myInt = (ah->nrtm).port; 1882 | break; 1883 | 1884 | case 12: 1885 | /* NRTM Delay */ 1886 | myInt = (ah->nrtm).delay; 1887 | break; 1888 | 1889 | case 13: 1890 | /* NRTM Protocol Version. */ 1891 | myInt = (ah->nrtm).protocolVer; 1892 | break; 1893 | 1894 | case 14: 1895 | /* Source Update Port */ 1896 | myInt = ah->updPort; 1897 | break; 1898 | 1899 | default: 1900 | fprintf(stderr, "Could not find source-attribute %d\n", srcAttrib); 1901 | die; 1902 | } 1903 | 1904 | pthread_mutex_unlock(&Lock); 1905 | return (myInt); 1906 | } 1907 | 1908 | 1909 | char * 1910 | ca_get_adminStrElement(int symbol, int adminAttrib) 1911 | /******************************************************************* 1912 | * ca_adminStrElement 1913 | * -- returns a string which represents the attribute of a admin * 1914 | * db 1915 | * e.g. returns the name of a host machine. * 1916 | * It allocates the required memory; * 1917 | * but it returns NULL if the required memory cannot be * 1918 | * allocated. 1919 | * * 1920 | * Parameters * 1921 | * -- symbol - the symbol of the variable 1922 | * * 1923 | * -- adminAttrib - an integer which represents the required * 1924 | * attribute of the Admin db. We use #define statements to * 1925 | * make a mapping between the attributes and the integers. * 1926 | * * 1927 | * Returns * 1928 | * -- a string or NULL * 1929 | *******************************************************************/ 1930 | { 1931 | char *myStr; 1932 | 1933 | /* 1934 | * Make sure that we are calling the correct function. 1935 | */ 1936 | if (strcmp(dictionary[symbol].varType, "CA_ADMIN") != 0) { 1937 | fprintf(stderr, "Error: unexpected variable type.\n"); 1938 | die; 1939 | } 1940 | else { 1941 | pthread_mutex_lock(&Lock); 1942 | switch (adminAttrib) { 1943 | case 0: 1944 | /* admin host */ 1945 | myStr = UT_strdup(((ca_ripadmin_t *) confVars[symbol].valPtr)->host); 1946 | break; 1947 | 1948 | case 2: 1949 | /* User */ 1950 | myStr = UT_strdup(((ca_ripadmin_t *) confVars[symbol].valPtr)->user); 1951 | break; 1952 | 1953 | case 3: 1954 | /* password */ 1955 | myStr = UT_strdup(((ca_ripadmin_t *) confVars[symbol].valPtr)->password); 1956 | break; 1957 | 1958 | case 4: 1959 | /* tableName */ 1960 | myStr = UT_strdup(((ca_ripadmin_t *) confVars[symbol].valPtr)->tableName); 1961 | break; 1962 | 1963 | default: 1964 | puts("Cannot find this admin attribute"); 1965 | die; 1966 | } 1967 | pthread_mutex_unlock(&Lock); 1968 | 1969 | } 1970 | return (myStr); 1971 | } 1972 | 1973 | int 1974 | ca_get_adminIntElement(int symbol, int adminAttrib) 1975 | /* 1976 | * Returns an int element of the admin db structure. 1977 | */ 1978 | { 1979 | int myInt; /* The value of this integer is returned. */ 1980 | 1981 | pthread_mutex_lock(&Lock); 1982 | switch (adminAttrib) { 1983 | case 1: 1984 | /* Port number */ 1985 | myInt = ((ca_ripadmin_t *) confVars[symbol].valPtr)->port; 1986 | break; 1987 | 1988 | default: 1989 | puts("Cannot find this admin attribute"); 1990 | die; 1991 | } 1992 | pthread_mutex_unlock(&Lock); 1993 | 1994 | return (myInt); 1995 | } 1996 | 1997 | void 1998 | ca_set_boolean(int symbol) 1999 | { 2000 | /************************************************************* 2001 | * * 2002 | * ca_set_boolean() * 2003 | * * 2004 | * * 2005 | * Parameters * 2006 | * * 2007 | * symbol -- the symbol for the variable. * 2008 | * * 2009 | * * 2010 | * Returns * 2011 | * * 2012 | * nothing * 2013 | * * 2014 | * * 2015 | * Remarks * 2016 | * * 2017 | * Must check that a sensible value is given as input. * 2018 | * * 2019 | * * 2020 | *************************************************************/ 2021 | 2022 | 2023 | char newTestmodeStr[2]; 2024 | int newTestmodeVal; /* The new value of the testmode variable. */ 2025 | int invalid; /* Flag to indicate an invalid new value. */ 2026 | 2027 | FILE *testPtr, *tempPtr; /* The pointer to the files. */ 2028 | char name[STRLENGTH]; /* The name of the variable. */ 2029 | char value[STRLENGTH]; /* The value of the variable. */ 2030 | 2031 | /* 2032 | * Function to change the value in a given values array. This 2033 | * function can only be called from within ca_set_boolean(). 2034 | */ 2035 | int *ca_change_int_value(char[]); 2036 | 2037 | 2038 | /* 2039 | * Using the symbol, look at the appropriate place in the dictionary. 2040 | */ 2041 | #ifdef DEBUG 2042 | printf("\nca_set_int() function called .....\n"); 2043 | printf("Variable type: %s\n", dictionary[symbol].varType); 2044 | #endif /* DEBUG */ 2045 | 2046 | /* 2047 | * Check that the function is attempting to set the correct type of 2048 | * value. If not, do not set the value, but exit instead. 2049 | */ 2050 | 2051 | if (strcmp(dictionary[symbol].varType, "CA_BOOLEAN") != 0) { 2052 | fprintf(stderr, "Error: CA_BOOLEAN data type expected.\n"); 2053 | die; 2054 | } 2055 | 2056 | /* 2057 | * First, flush the input stream. 2058 | */ 2059 | fflush(stdin); 2060 | 2061 | 2062 | /* 2063 | * Make sure that a reasonable, sensible value of bind-port has been 2064 | * read from the keyboard. 2065 | */ 2066 | 2067 | do { 2068 | /* 2069 | * Prompt for the new value of the testmode. 2070 | */ 2071 | 2072 | printf("\nNew value of testmode (0 or 1) >>> "); 2073 | scanf("%s", newTestmodeStr); 2074 | 2075 | /* 2076 | * We scanf() the value as a string, but we want it to be an 2077 | * integer. Thus, we use sscanf() to scanf the value from 2078 | * the string-variable and store it as an integer in an 2079 | * integer variable. 2080 | */ 2081 | sscanf(newTestmodeStr, "%d", &newTestmodeVal); 2082 | 2083 | /* 2084 | * We only change the testmode when the user is absolutely 2085 | * sure that they want to change. Thus, we only accept two 2086 | * possible values for testmode. 2087 | */ 2088 | 2089 | if ((newTestmodeVal < 0) || (newTestmodeVal > 1)) { 2090 | invalid = 1; 2091 | puts("Only '0' or '1' accepted as value for testmode."); 2092 | } 2093 | else { 2094 | invalid = 0; 2095 | } 2096 | } while (invalid); 2097 | 2098 | 2099 | /* 2100 | * Lock the value of the variable before changing it. 2101 | */ 2102 | 2103 | pthread_mutex_lock(&Lock); 2104 | 2105 | 2106 | /* 2107 | * Choose the appropriate values array. 2108 | */ 2109 | 2110 | switch (dictionary[symbol].varScope) { 2111 | /* 2112 | * If the variable has global scope, write it into the 2113 | * globals array. If it has local scope, write it into the 2114 | * local array. If the scope cannot be found, then report an 2115 | * error. 2116 | */ 2117 | 2118 | /************************************************************ 2119 | * * 2120 | * We comment out this code. We use the GLib string * 2121 | * now. It also checks if we got the memory :-) * 2122 | * * 2123 | ************************************************************/ 2124 | 2125 | case 1: 2126 | globals[symbol].valPtr = ca_change_int_value(newTestmodeStr); 2127 | /* 2128 | * globals[symbol].strPtr = newTestmodeStr; 2129 | */ 2130 | g_string_assign(globals[symbol].strPtr, newTestmodeStr); 2131 | break; 2132 | 2133 | case 99: 2134 | locals[symbol].valPtr = ca_change_int_value(newTestmodeStr); 2135 | /* 2136 | * locals[symbol].strPtr = newTestmodeStr; 2137 | */ 2138 | g_string_assign(locals[symbol].strPtr, newTestmodeStr); 2139 | break; 2140 | 2141 | default: 2142 | fprintf(stderr, "Error: unknown scope: %d\n", dictionary[symbol].varScope); 2143 | break; 2144 | } 2145 | 2146 | /* 2147 | * Write the new value of this variable back to the config file. 2148 | * 2149 | * To be implemented. 2150 | */ 2151 | 2152 | /* 2153 | * Find the actual name of the variable from the dictionary structure 2154 | * (use the variable symbol as an index into the array of dictionary 2155 | * structures. 2156 | */ 2157 | 2158 | printf("Name of variable to be changed: %s\n", dictionary[symbol].varName); 2159 | printf("Type of variable to be changed: %s\n", dictionary[symbol].varType); 2160 | 2161 | /* 2162 | * Open the test config file for reading ..... 2163 | */ 2164 | if ((testPtr = fopen(testFile, "r")) == NULL) { 2165 | printf("File \"%s\" could not be opened.\n", testFile); 2166 | die; 2167 | } 2168 | 2169 | /* 2170 | * Open the temporary file for writing ..... 2171 | */ 2172 | if ((tempPtr = fopen(tempFile, "w")) == NULL) { 2173 | printf("File \"%s\" could not be opened.\n", tempFile); 2174 | die; 2175 | } 2176 | 2177 | /* 2178 | * Read the first record in the test config file. 2179 | */ 2180 | 2181 | fscanf(testPtr, "%s", name); 2182 | fgets(value, sizeof(value), testPtr); 2183 | 2184 | /* 2185 | * If the last character of "value" is '\n', replace it with '\0'. 2186 | */ 2187 | if (value[strlen(value) - 1] == '\n') { 2188 | printf("The value string is %s", value); 2189 | printf("Replacing last character of \"%s\" with the NULL character\n", name); 2190 | value[strlen(value) - 1] = '\0'; 2191 | printf("The new value string is %s", value); 2192 | } 2193 | 2194 | 2195 | /* 2196 | * While there are records to be read in the test config file: Write 2197 | * the current record into the temporary file. Read the next record 2198 | * in the config file. Repeat untill the EOF has been reached. 2199 | */ 2200 | 2201 | while (!feof(testPtr)) { 2202 | fprintf(tempPtr, "%s %s\n", name, value); 2203 | fscanf(testPtr, "%s", name); 2204 | fgets(value, sizeof(value), testPtr); 2205 | 2206 | /* 2207 | * If the last character of "value" is '\n', replace it with 2208 | * '\0'. 2209 | */ 2210 | if (value[strlen(value) - 1] == '\n') { 2211 | printf("The last character of the value string is %c", value[strlen(value) - 1]); 2212 | printf("The value string is %s", value); 2213 | printf("Replacing last character of \"%s\" with the NULL character\n", name); 2214 | value[strlen(value) - 1] = '\0'; 2215 | printf("The new value string is %s", value); 2216 | } 2217 | 2218 | 2219 | /* 2220 | * if we read the variable that we want to change, stop 2221 | * reading this file and print only the name of this variable 2222 | * to the temporary file. 2223 | */ 2224 | 2225 | /* 2226 | * If we read the variable that we want to change, replace 2227 | * the value of this variable in the config file with the 2228 | * value supplied from the keyboard. 2229 | * 2230 | */ 2231 | if (strcmp(name, dictionary[symbol].varName) == 0) { 2232 | strcpy(value, newTestmodeStr); 2233 | printf("The replacement string is %s", value); 2234 | } 2235 | /* 2236 | * Flush the pointer to the test config file. 2237 | */ 2238 | fflush(testPtr); 2239 | 2240 | } 2241 | /* 2242 | * Here ends the loop that writes the config file, with the new 2243 | * variable, to the temporary file. 2244 | */ 2245 | 2246 | /* 2247 | * While !(the record to be updated) BEGIN Write the record to the 2248 | * temporary file Read the next record in the config file END 2249 | * 2250 | * Write the new value to the temporary file Read the next record in the 2251 | * config file COMMENT: this is the record to be updated. COMMENT: 2252 | * discard this record. 2253 | * 2254 | * Read the next record in the config file 2255 | * 2256 | * While !(EOF) BEGIN write the record to the temporary file read the 2257 | * next record in the config file END 2258 | * 2259 | * Close Config file Close Temporary file 2260 | * 2261 | * Open Temporary file for reading Open Config file for writing 2262 | * 2263 | * Read the next record of the Temporary file 2264 | * 2265 | * While (!EOF of Temporary file) BEGIN write the record into the Config 2266 | * file read the next record of the Temporary file END 2267 | * 2268 | * Close Temporary file Close Config file 2269 | * 2270 | */ 2271 | 2272 | fclose(testPtr); 2273 | fclose(tempPtr); 2274 | 2275 | /* 2276 | * Now, flush the file pointers 2277 | */ 2278 | fflush(testPtr); 2279 | fflush(tempPtr); 2280 | 2281 | /* 2282 | * Open the temporary file for reading. Open the config file for 2283 | * writing. Write the contents of the temporary file into the config 2284 | * file. 2285 | */ 2286 | 2287 | /* 2288 | * Open the temporary file for reading ..... 2289 | */ 2290 | if ((tempPtr = fopen(tempFile, "r")) == NULL) { 2291 | printf("File \"%s\" could not be opened for reading.\n", tempFile); 2292 | die; 2293 | } 2294 | 2295 | /* 2296 | * Open the config file for writing ..... 2297 | */ 2298 | if ((testPtr = fopen(testFile, "w")) == NULL) { 2299 | printf("File \"%s\" could not be opened for writing.\n", testFile); 2300 | die; 2301 | } 2302 | 2303 | /* 2304 | * Read the first record in the temporary file. 2305 | */ 2306 | 2307 | fscanf(tempPtr, "%s", name); 2308 | fgets(value, sizeof(value), tempPtr); 2309 | printf("\nFIRST LINE: %s %s", name, value); 2310 | 2311 | 2312 | /* 2313 | * While there are records to be read in the temporary file: Write 2314 | * the current record into the test config file. Read the next record 2315 | * in the temporary file. Repeat untill the EOF has been reached. 2316 | */ 2317 | 2318 | while (!feof(tempPtr)) { 2319 | fprintf(testPtr, "%s %s", name, value); 2320 | fscanf(tempPtr, "%s", name); 2321 | fgets(value, sizeof(value), tempPtr); 2322 | } 2323 | 2324 | fclose(testPtr); 2325 | fclose(tempPtr); 2326 | 2327 | /* 2328 | * Unlock the value of the variable after setting it and writing the 2329 | * new value back to the configuration (and the dictionary) file. 2330 | * 2331 | */ 2332 | pthread_mutex_unlock(&Lock); 2333 | 2334 | } 2335 | 2336 | 2337 | void 2338 | ca_set_dirlist(int symbol) 2339 | { 2340 | /**************************************************************** 2341 | * ca_set_dirlist() * 2342 | * * 2343 | * Parameters * 2344 | * symbol -- the symbol of the variable. * 2345 | * * 2346 | * Returns * 2347 | * 1 if successful, 0 if not successful. * 2348 | * * 2349 | * Remarks * 2350 | * Writing the new value back to the config file has yet to * 2351 | * be implemented. * 2352 | * * 2353 | ****************************************************************/ 2354 | 2355 | char newDir[80]; 2356 | /* 2357 | * Declare a pointer to a values_t variable. Later, we shall assign 2358 | * this pointer to the first element of either the globals or the 2359 | * locals array, as appropriate. 2360 | */ 2361 | values_t *hereValues; 2362 | 2363 | /* 2364 | * Using the symbol, look in the appropriate place in the dictionary. 2365 | */ 2366 | #ifdef DEBUG 2367 | printf("\nca_set_dirlist() function called ..... \n"); 2368 | printf("Variable type: %s\n", dictionary[symbol].varType); 2369 | #endif 2370 | 2371 | /* 2372 | * First, flush the input stream. 2373 | */ 2374 | fflush(stdin); 2375 | 2376 | /* 2377 | * Prompt for the new value of the directory. 2378 | */ 2379 | printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName); 2380 | scanf("%s", newDir); 2381 | 2382 | /* 2383 | * Make sure that a reasonable, sensible value of the directory value 2384 | * has been read from the keyboard. 2385 | * 2386 | * How do we implement this ??? 2387 | * 2388 | */ 2389 | 2390 | 2391 | /* 2392 | * Make sure that the function is attempting to set the correct type 2393 | * of value. If not, do not set the value - and exit. 2394 | */ 2395 | 2396 | if (strcmp(dictionary[symbol].varType, "CA_DIRLIST") != 0) { 2397 | fprintf(stderr, "Error: unexpected variable type.\n"); 2398 | exit(51); 2399 | } 2400 | 2401 | /* 2402 | * Choose the appropriate values array. Assign a temporary pointer to 2403 | * this array. 2404 | */ 2405 | 2406 | switch (dictionary[symbol].varScope) { 2407 | /* 2408 | * If the variable has global scope, write it into the 2409 | * globals array. If it has local scope, write it into the 2410 | * locals array. If the scope cannot be found, report an 2411 | * error. 2412 | */ 2413 | case 1: 2414 | hereValues = globals; 2415 | break; 2416 | 2417 | case 99: 2418 | hereValues = locals; 2419 | break; 2420 | 2421 | default: 2422 | fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope); 2423 | die; 2424 | } 2425 | 2426 | 2427 | /* 2428 | * Check for the presence of the mutex lock: if present, wait until 2429 | * it is available; else get the lock and proceed with the change of 2430 | * value. 2431 | */ 2432 | 2433 | /* 2434 | * Write the new value of the variable to the correct place in the 2435 | * [appropriate] values array. 2436 | * 2437 | * Note that there is no need to check if UT_malloc() actually worked. 2438 | * 2439 | */ 2440 | 2441 | hereValues[symbol].valPtr = (char *) UT_malloc(80); 2442 | 2443 | /* 2444 | *if (hereValues[symbol].valPtr == NULL) { 2445 | * fprintf(stderr, "Cannot alllocate memory for hereValuesvlPtr\n"); 2446 | * die; 2447 | * } 2448 | */ 2449 | 2450 | strcpy(hereValues[symbol].valPtr, newDir); 2451 | 2452 | 2453 | /************************************************************ 2454 | * * 2455 | * We comment out this code. We use the GLib string * 2456 | * now. It also checks if we got the memory :-) * 2457 | * * 2458 | ************************************************************/ 2459 | /* 2460 | * hereValues[symbol].strPtr = (char *) malloc(sizeof(newDir)); 2461 | * if (hereValues[symbol].strPtr == NULL) { 2462 | * fprintf(stderr, "Cannot alllocate memory for hereValuestPtr\n"); 2463 | * die; 2464 | * } 2465 | * strcpy(hereValues[symbol].strPtr, newDir); 2466 | */ 2467 | g_string_assign(hereValues[symbol].strPtr, newDir); 2468 | 2469 | /* 2470 | * Free the temporary pointer, hereValues. 2471 | * 2472 | */ 2473 | UT_free(hereValues); 2474 | hereValues = NULL; 2475 | 2476 | /* 2477 | * Release the mutex lock. 2478 | */ 2479 | 2480 | /* 2481 | * Write the new value of this variable back to the config file. 2482 | */ 2483 | 2484 | } 2485 | 2486 | 2487 | #if 0 2488 | 2489 | XXX: Unused function? Removed because it causes warnings due to gets() 2490 | invokation. - Shane 2491 | 2492 | void 2493 | ca_set_string(int symbol) 2494 | { 2495 | 2496 | /**************************************************************** 2497 | * ca_set_string() * 2498 | * * 2499 | * Parameters * 2500 | * symbol -- the symbol of the variable. * 2501 | * * 2502 | * Returns * 2503 | * 1 if successful, 0 if not successful ? * 2504 | * * 2505 | * Remarks * 2506 | * Writing the new value back to the config file has yet to * 2507 | * be implemented. * 2508 | * * 2509 | ****************************************************************/ 2510 | 2511 | char newString[80]; /* May need to make this bigger. */ 2512 | 2513 | /* 2514 | * Declare a pointer to a values_t variable. Later, we shall assign 2515 | * this pointer to the first element of either the globals or the 2516 | * locals array, as appropriate. 2517 | */ 2518 | values_t *hereValues; 2519 | 2520 | /* 2521 | * Using the symbol, look in the appropriate place in the dictionary. 2522 | */ 2523 | #ifdef DEBUG 2524 | printf("\nca_set_string() function called ..... \n"); 2525 | printf("Variable type: %s\n", dictionary[symbol].varType); 2526 | #endif 2527 | 2528 | /* 2529 | * First, flush the input stream. 2530 | */ 2531 | fflush(stdin); 2532 | 2533 | /* 2534 | * Prompt for the new value of the string. 2535 | */ 2536 | printf("\nNew value of %s [80 characters, maximum] >>> ", dictionary[symbol].varName); 2537 | gets(newString); 2538 | 2539 | /* 2540 | * Make sure that a reasonable, sensible value of the string value 2541 | * has been read from the keyboard. 2542 | * 2543 | * How do we implement this ??? 2544 | * 2545 | */ 2546 | 2547 | 2548 | /* 2549 | * Make sure that the function is attempting to set the correct type 2550 | * of value. If not, do not set the value - and exit. 2551 | */ 2552 | 2553 | if (strcmp(dictionary[symbol].varType, "CA_STRING") != 0) { 2554 | fprintf(stderr, "Error: unexpected variable type.\n"); 2555 | exit(51); 2556 | } 2557 | 2558 | /* 2559 | * Choose the appropriate values array. Assign a temporary pointer to 2560 | * this array. 2561 | */ 2562 | 2563 | switch (dictionary[symbol].varScope) { 2564 | /* 2565 | * If the variable has global scope, write it into the 2566 | * globals array. If it has local scope, write it into the 2567 | * locals array. If the scope cannot be found, report an 2568 | * error. 2569 | */ 2570 | case 1: 2571 | hereValues = globals; 2572 | break; 2573 | 2574 | case 99: 2575 | hereValues = locals; 2576 | break; 2577 | 2578 | default: 2579 | fprintf(stderr, "Error: Unknown scope: %d\n", dictionary[symbol].varScope); 2580 | die; 2581 | } 2582 | 2583 | 2584 | /* 2585 | * Check for the presence of the mutex lock: if present, wait until 2586 | * it is available; else get the lock and proceed with the change of 2587 | * value. 2588 | */ 2589 | pthread_mutex_lock(&Lock); 2590 | 2591 | /* 2592 | * Write the new value of the variable to the correct place in the 2593 | * [appropriate] values array. Note the check to the return value of 2594 | * malloc() to see if the memory was actually obtained. 2595 | */ 2596 | 2597 | hereValues[symbol].valPtr = (char *) UT_malloc(80); 2598 | 2599 | /* 2600 | * No need to check that NULL is not returned. 2601 | * 2602 | *if (hereValues[symbol].valPtr == NULL) { 2603 | * fprintf(stderr, "Cannot allocate memory for hereValues[symbol].valPtr\n"); 2604 | * die; 2605 | * } 2606 | * 2607 | */ 2608 | 2609 | strcpy(hereValues[symbol].valPtr, newString); 2610 | 2611 | 2612 | /************************************************************ 2613 | * * 2614 | * We comment out this code. We use the GLib string * 2615 | * now. It also checks if we got the memory :-) * 2616 | * * 2617 | ************************************************************/ 2618 | /* 2619 | * hereValues[symbol].strPtr = (char *) malloc(sizeof(newString)); 2620 | * if (hereValues[symbol].strPtr == NULL) { 2621 | * fprintf(stderr, "Cannot allocate memory for hereValues[symbol].strPtr\n"); 2622 | * die; 2623 | * } 2624 | * strcpy(hereValues[symbol].strPtr, newString); 2625 | */ 2626 | 2627 | g_string_assign(hereValues[symbol].strPtr, newString); 2628 | 2629 | /* 2630 | * Free the temporary pointer, hereValues. 2631 | * 2632 | */ 2633 | UT_free(hereValues); 2634 | hereValues = NULL; 2635 | 2636 | /* 2637 | * Release the mutex lock. 2638 | */ 2639 | pthread_mutex_unlock(&Lock); 2640 | 2641 | /* 2642 | * Write the new value of this variable back to the config file. 2643 | * Implement this later ? 2644 | */ 2645 | 2646 | } 2647 | #endif /* 0 */ 2648 | 2649 | 2650 | int 2651 | ca_writeNewValue(int dictSymbol, char *newValue) 2652 | { 2653 | 2654 | FILE *confPtr; /* Pointer to config file */ 2655 | FILE *tempPtr; /* The pointer to temp file. */ 2656 | char name[STRLENGTH]; /* The name of the variable. */ 2657 | char value[STRLENGTH]; /* The value of the variable. */ 2658 | 2659 | 2660 | /* 2661 | * Find the actual name of the variable from the dictionary structure 2662 | * (use the variable symbol as an index into the array of dictionary 2663 | * structures. 2664 | */ 2665 | #ifdef DEBUG 2666 | printf("Name of variable to be changed: %s\n", dictionary[dictSymbol].varName); 2667 | printf("Type of variable to be changed: %s\n", dictionary[dictSymbol].varType); 2668 | #endif /* DEBUG */ 2669 | 2670 | /* 2671 | * Open the test config file for reading ..... 2672 | */ 2673 | if ((confPtr = fopen(testFile, "r")) == NULL) { 2674 | printf("File \"%s\" could not be opened.\n", testFile); 2675 | die; 2676 | } 2677 | 2678 | /* 2679 | * Open the temporary file for writing ..... 2680 | */ 2681 | if ((tempPtr = fopen(tempFile, "w")) == NULL) { 2682 | printf("File \"%s\" could not be opened.\n", tempFile); 2683 | die; 2684 | } 2685 | 2686 | /* 2687 | * Read the first record in the test config file. 2688 | */ 2689 | 2690 | fscanf(confPtr, "%s", name); 2691 | fgets(value, sizeof(value), confPtr); 2692 | 2693 | /* 2694 | * If the last character of "value" is '\n', replace it with '\0'. 2695 | */ 2696 | if (value[strlen(value) - 1] == '\n') { 2697 | #ifdef DEBUG 2698 | printf("The value string is %s", value); 2699 | printf("Replacing last character of \"%s\" with the NULL character\n", name); 2700 | #endif /* DEBUG */ 2701 | 2702 | value[strlen(value) - 1] = '\0'; 2703 | 2704 | #ifdef DEBUG 2705 | printf("The new value string is %s", value); 2706 | #endif /* DEBUG */ 2707 | } 2708 | 2709 | /* 2710 | * If we read the variable that we want to change, replace the value 2711 | * of this variable in the config file with the value supplied from 2712 | * the keyboard. 2713 | * 2714 | */ 2715 | if (strcmp(name, dictionary[dictSymbol].varName) == 0) { 2716 | strcpy(value, newValue); 2717 | 2718 | #ifdef DEBUG 2719 | printf("The replacement string is %s", value); 2720 | #endif /* DEBUG */ 2721 | } 2722 | 2723 | /* 2724 | * While there are records to be read in the test config file: Write 2725 | * the current record into the temporary file. Read the next record 2726 | * in the config file. Repeat untill the EOF has been reached. 2727 | */ 2728 | 2729 | while (!feof(confPtr)) { 2730 | fprintf(tempPtr, "%s %s\n", name, value); 2731 | fscanf(confPtr, "%s", name); 2732 | fgets(value, sizeof(value), confPtr); 2733 | 2734 | /* 2735 | * If the last character of "value" is '\n', replace it with 2736 | * '\0'. 2737 | */ 2738 | if (value[strlen(value) - 1] == '\n') { 2739 | #ifdef DEBUG 2740 | printf("The last character of the value string is %c", value[strlen(value) - 1]); 2741 | printf("The value string is %s", value); 2742 | printf("Replacing last character of \"%s\" with the NULL character\n", name); 2743 | #endif /* DEBUG */ 2744 | 2745 | value[strlen(value) - 1] = '\0'; 2746 | #ifdef DEBUG 2747 | printf("The new value string is %s", value); 2748 | #endif /* DEBUG */ 2749 | } 2750 | 2751 | 2752 | /* 2753 | * If we read the variable that we want to change, replace 2754 | * the value of this variable in the config file with the 2755 | * value supplied from the keyboard. 2756 | * 2757 | */ 2758 | if (strcmp(name, dictionary[dictSymbol].varName) == 0) { 2759 | strcpy(value, newValue); 2760 | 2761 | #ifdef DEBUG 2762 | printf("The replacement string is %s", value); 2763 | #endif /* DEBUG */ 2764 | } 2765 | 2766 | /* 2767 | * Flush the pointer to the test config file. 2768 | */ 2769 | fflush(confPtr); 2770 | 2771 | } 2772 | /* 2773 | * Here ends the loop that writes the config file, with the new 2774 | * variable, to the temporary file. 2775 | */ 2776 | 2777 | /* 2778 | * While !(the record to be updated) BEGIN Write the record to the 2779 | * temporary file Read the next record in the config file END 2780 | * 2781 | * Write the new value to the temporary file Read the next record in the 2782 | * config file COMMENT: this is the record to be updated. COMMENT: 2783 | * discard this record. 2784 | * 2785 | * Read the next record in the config file 2786 | * 2787 | * While !(EOF) BEGIN write the record to the temporary file read the 2788 | * next record in the config file END 2789 | * 2790 | * Close Config file Close Temporary file 2791 | * 2792 | * Open Temporary file for reading Open Config file for writing 2793 | * 2794 | * Read the next record of the Temporary file 2795 | * 2796 | * While (!EOF of Temporary file) BEGIN write the record into the Config 2797 | * file read the next record of the Temporary file END 2798 | * 2799 | * Close Temporary file Close Config file 2800 | * 2801 | */ 2802 | 2803 | fclose(confPtr); 2804 | fclose(tempPtr); 2805 | 2806 | /* 2807 | * Now, flush the file pointers 2808 | */ 2809 | fflush(confPtr); 2810 | fflush(tempPtr); 2811 | 2812 | /* 2813 | * Open the temporary file for reading. Open the config file for 2814 | * writing. Write the contents of the temporary file into the config 2815 | * file. 2816 | */ 2817 | 2818 | /* 2819 | * Open the temporary file for reading ..... 2820 | */ 2821 | if ((tempPtr = fopen(tempFile, "r")) == NULL) { 2822 | printf("File \"%s\" could not be opened for reading.\n", tempFile); 2823 | die; 2824 | } 2825 | 2826 | /* 2827 | * Open the config file for writing ..... 2828 | */ 2829 | if ((confPtr = fopen(testFile, "w")) == NULL) { 2830 | printf("File \"%s\" could not be opened for writing.\n", testFile); 2831 | die; 2832 | } 2833 | 2834 | /* 2835 | * Read the first record in the temporary file. 2836 | */ 2837 | 2838 | fscanf(tempPtr, "%s", name); 2839 | fgets(value, sizeof(value), tempPtr); 2840 | #ifdef DEBUG 2841 | printf("\nFIRST LINE: %s %s", name, value); 2842 | #endif /* DEBUG */ 2843 | 2844 | /* 2845 | * While there are records to be read in the temporary file: Write 2846 | * the current record into the test config file. Read the next record 2847 | * in the temporary file. Repeat untill the EOF has been reached. 2848 | */ 2849 | 2850 | while (!feof(tempPtr)) { 2851 | fprintf(confPtr, "%s %s", name, value); 2852 | fscanf(tempPtr, "%s", name); 2853 | fgets(value, sizeof(value), tempPtr); 2854 | } 2855 | 2856 | fclose(confPtr); 2857 | fclose(tempPtr); 2858 | unlink(tempFile); 2859 | 2860 | return (0); 2861 | } 2862 | 2863 | 2864 | int 2865 | ca_getStorageLocation(char *confVar, dict_t woordenboek[], int size) 2866 | /************************************************************* 2867 | * ca_getStorageLocation() * 2868 | * - takes the name of a config variable and searches the * 2869 | * dictionary structure for the storage location for this * 2870 | * variable. * 2871 | * * 2872 | * Parameters * 2873 | * confVar -- the string variable that contains the name * 2874 | * of the variable. * 2875 | * woordenboek -- the dictionary structure to be searched * 2876 | * size -- the size of the dictionary structure to * 2877 | * searched. * 2878 | * * 2879 | * Returns * 2880 | * the location (integer) in the values array. * 2881 | * * 2882 | *************************************************************/ 2883 | { 2884 | int i, where, found = 0; /* Whether or not the symbol has been 2885 | * found. */ 2886 | 2887 | 2888 | #ifdef DEBUG 2889 | printf("The variable name in ca_getStorageLocation is: %s\n", confVar); 2890 | #endif /* DEBUG */ 2891 | 2892 | /* 2893 | * Compares each name in the dictionary with the one for which we are 2894 | * looking. 2895 | */ 2896 | i = 0; 2897 | while (!found && i < size) { 2898 | if (strcmp(woordenboek[i].varName, confVar) == 0) { 2899 | found = 1; 2900 | } 2901 | else { 2902 | ++i; 2903 | } 2904 | } 2905 | 2906 | /* 2907 | * Returns the storage location for the given variable name or else 2908 | * returns NOT_FOUND 2909 | */ 2910 | if (found) { 2911 | /* mySymbol = atoi(woordenboek[i].varSym); */ 2912 | #ifdef DEBUG 2913 | printf("Symbol is %s\n", woordenboek[i].varSym); 2914 | printf("Storage Location is: %d\n", woordenboek[i].varNum); 2915 | #endif /* DEBUG */ 2916 | where = woordenboek[i].varNum; 2917 | } 2918 | else { 2919 | fprintf(stderr, "Error: cannot find storage location for variable %s\n", confVar); 2920 | where = NOT_FOUND; 2921 | } 2922 | return (where); 2923 | 2924 | } 2925 | 2926 | 2927 | void 2928 | ca_getConfig(values_t confVars[], int size) 2929 | /************************************************************* 2930 | * ca_getConfig -- prints the strings representing the * 2931 | * values of the configuration variables * 2932 | * * 2933 | * Parameters * 2934 | * confVars -- the values_t array which stores the * 2935 | * values of the configuration variables. * 2936 | * size -- the number of configuration variables, * 2937 | * the number of elements in the confVars array * 2938 | * * 2939 | * * 2940 | *************************************************************/ 2941 | { 2942 | int i = 0; /* A counting variable. */ 2943 | 2944 | puts("A dump of the strings of the values of the Config Vars:"); 2945 | puts("Number\t\tString"); 2946 | puts("----------"); 2947 | 2948 | while (i < size) { 2949 | printf("%d\t\t%s\n", i, (confVars[i].strPtr)->str); 2950 | ++i; 2951 | } 2952 | 2953 | } 2954 | 2955 | 2956 | int 2957 | ca_getType(char *confVar, dict_t woordenboek[], int size) 2958 | /**************************************************************** 2959 | * ca_getType -- returns the data type of the variable. * 2960 | * * 2961 | * Parameters * 2962 | * confVar -- the name of the configuration variable. * 2963 | * woordenboek -- the array of dict_t structures. * 2964 | * size -- the number of configuration variables. * 2965 | * * 2966 | * Returns * 2967 | * an integer representing the data type of the variable * 2968 | * * 2969 | ****************************************************************/ 2970 | { 2971 | int i = 0, /* Counter variable. */ 2972 | found = 0; /* Set this == 1 when we find the variable. */ 2973 | int myType; /* Integer representing the type of the config 2974 | * variable. */ 2975 | 2976 | /* 2977 | * Compare each name in the dictionary with the one for which we are 2978 | * looking. 2979 | */ 2980 | 2981 | myType = 0; 2982 | 2983 | #ifdef DEBUG 2984 | printf("ca_getType function called for variable: %s\n", confVar); 2985 | #endif /* DEBUG */ 2986 | 2987 | while (!found && i <= size) { 2988 | if (strcmp(woordenboek[i].varName, confVar) == 0) { 2989 | found = 1; 2990 | #ifdef DEBUG 2991 | printf("ca_getType function: %s, %s matched.\n", woordenboek[i].varName, confVar); 2992 | #endif /* DEBUG */ 2993 | } 2994 | else { 2995 | ++i; 2996 | } 2997 | } 2998 | 2999 | /* 3000 | * Return the type of the config variable or else return "NOT FOUND". 3001 | */ 3002 | if (found) { 3003 | if (strcmp(woordenboek[i].varType, "CA_INT") == 0) { 3004 | #ifdef DEBUG 3005 | printf("ca_getType function: %s variable of type %s is Integer type\n", woordenboek[i].varName, woordenboek[i].varType); 3006 | 3007 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3008 | #endif /* DEBUG */ 3009 | myType = 11; 3010 | #ifdef DEBUG 3011 | printf("For type CA_INT, myType is %d\n", myType); 3012 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3013 | #endif /* DEBUG */ 3014 | } 3015 | else { 3016 | if (strcmp(woordenboek[i].varType, "CA_STRING") == 0) { 3017 | #ifdef DEBUG 3018 | printf("ca_getType function: %s variable of type %s is String type\n", woordenboek[i].varName, woordenboek[i].varType); 3019 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3020 | #endif /* DEBUG */ 3021 | myType = 12; 3022 | #ifdef DEBUG 3023 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3024 | #endif /* DEBUG */ 3025 | } 3026 | else { 3027 | if (strcmp(woordenboek[i].varType, "CA_DIRLIST") == 0) { 3028 | #ifdef DEBUG 3029 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3030 | #endif /* DEBUG */ 3031 | myType = 13; 3032 | #ifdef DEBUG 3033 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3034 | #endif /* DEBUG */ 3035 | } 3036 | else { 3037 | if (strcmp(woordenboek[i].varType, "CA_BOOLEAN") == 0) { 3038 | #ifdef DEBUG 3039 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3040 | #endif /* DEBUG */ 3041 | myType = 14; 3042 | #ifdef DEBUG 3043 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3044 | #endif /* DEBUG */ 3045 | } 3046 | else { 3047 | if (strcmp(woordenboek[i].varType, "CA_SOURCETYPE") == 0) { 3048 | #ifdef DEBUG 3049 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3050 | #endif /* DEBUG */ 3051 | myType = 15; 3052 | #ifdef DEBUG 3053 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3054 | #endif /* DEBUG */ 3055 | } 3056 | else { 3057 | if (strcmp(woordenboek[i].varType, "CA_ADMIN") == 0) { 3058 | #ifdef DEBUG 3059 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3060 | #endif /* DEBUG */ 3061 | myType = 16; 3062 | #ifdef DEBUG 3063 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3064 | #endif /* DEBUG */ 3065 | 3066 | } 3067 | else { 3068 | if (strcmp(woordenboek[i].varType, "CA_UPDSOURCE") == 0) { 3069 | #ifdef DEBUG 3070 | printf("ca_getType function: %s, %s\n", woordenboek[i].varName, woordenboek[i].varType); 3071 | #endif /* DEBUG */ 3072 | myType = 17; 3073 | #ifdef DEBUG 3074 | printf("ca_getType function: %s, %s, %d\n", woordenboek[i].varName, woordenboek[i].varType, myType); 3075 | #endif /* DEBUG */ 3076 | } 3077 | } 3078 | } 3079 | } 3080 | } 3081 | } 3082 | } 3083 | } 3084 | else { 3085 | myType = NOT_FOUND; 3086 | } 3087 | return (myType); 3088 | } 3089 | 3090 | 3091 | ca_updDbSource_t ** 3092 | ca_get_UpdSourceHandle(int symbol) 3093 | /******************************************************************* 3094 | * ca_get_UpdSourceHandle * 3095 | * -- returns the handle to the Update source * 3096 | * * 3097 | * Parameters * 3098 | * -- none; there is only one Update Source in the Configuration * 3099 | * file because a single DBupdate process cannot update more * 3100 | * than one source. * 3101 | * There are now multiple Update Sources in the Configuration * 3102 | * file. This was a self imposed limit that is no longer!! * 3103 | * * 3104 | * Returns * 3105 | * -- a pointer to an array of the Update Source structure (type * 3106 | * ca_updDbSource_t) or NULL. * 3107 | * * 3108 | *******************************************************************/ 3109 | { 3110 | ca_updDbSource_t **myUpdSourcePtr; 3111 | 3112 | /* 3113 | * Make sure that we are calling the correct function. 3114 | */ 3115 | if (strcmp(dictionary[symbol].varType, "CA_UPDSOURCE") != 0) 3116 | { 3117 | fprintf(stderr, "Error: unexpected variable type.\n"); 3118 | die; 3119 | } 3120 | else 3121 | { 3122 | /* get a pointer to the array of source data pointers */ 3123 | myUpdSourcePtr = (ca_updDbSource_t **) confVars[symbol].valPtr; 3124 | } 3125 | return (myUpdSourcePtr); 3126 | } 3127 | 3128 | 3129 | char * 3130 | ca_UpdSrcHandle2StrElement(ca_updDbSource_t * uh, int srcAttrib) 3131 | /******************************************************************* 3132 | * ca_UpdSrcHandle2StrElement * 3133 | * -- returns a string which represents the attribute of an * 3134 | * update source e.g. the name, the user, etc. * 3135 | * It allocates the required memory, but it returns NULL if * 3136 | * the required memory cannot be allocated. * 3137 | * * 3138 | * * 3139 | * Parameters * 3140 | * -- the Update Source Handle, i.e. a pointer to the structure * 3141 | * which contains the data about the Update Source. * 3142 | * * 3143 | * -- srcAttrib - an integer which represents the required * 3144 | * attribute of the source. This is also used in the * 3145 | * ca_srchandle2Strelement() function. * 3146 | * * 3147 | * Returns * 3148 | * -- a string or NULL * 3149 | * * 3150 | *******************************************************************/ 3151 | { 3152 | char *myStr; 3153 | 3154 | if (uh == NULL) { 3155 | fprintf(stderr, "ca_UpdSrcHandle2StrElement(): Cannot dereference NULL pointer.\n"); 3156 | die; 3157 | } 3158 | 3159 | switch (srcAttrib) { 3160 | case 0: 3161 | /* Update Source Name */ 3162 | myStr = UT_strdup(uh->name); 3163 | break; 3164 | 3165 | case 3: 3166 | /* Machine */ 3167 | myStr = UT_strdup((uh->updDb).host); 3168 | break; 3169 | 3170 | case 5: 3171 | /* User */ 3172 | myStr = UT_strdup((uh->updDb).user); 3173 | break; 3174 | 3175 | case 6: 3176 | /* Password */ 3177 | myStr = UT_strdup((uh->updDb).password); 3178 | break; 3179 | 3180 | case 7: 3181 | /* Update DB Name */ 3182 | myStr = UT_strdup((uh->updDb).dbName); 3183 | break; 3184 | 3185 | case 15: 3186 | /* Update Source Whois Machine */ 3187 | myStr = UT_strdup((uh->whoisd_host)); 3188 | break; 3189 | 3190 | default: 3191 | puts("Cannot find this Update source attribute"); 3192 | myStr = NULL; 3193 | } 3194 | 3195 | return (myStr); 3196 | } 3197 | 3198 | 3199 | int 3200 | ca_UpdSrcHandle2IntElement(ca_updDbSource_t * uh, int srcAttrib) 3201 | /******************************************************************* 3202 | * ca_UpdSrcHandle2IntElement * 3203 | * -- a function that returns the integer value of the requested * 3204 | * attribute of the given source. * 3205 | * * 3206 | * Parameters * 3207 | * -- the Update Source Handle, i.e. a pointer to the structure * 3208 | * which contains the data about the Update Source. * 3209 | * 3210 | * -- srcAttrib - an integer which represents the required * 3211 | * attribute of the source. This is also used in the * 3212 | * ca_srchandle2Strelement() function. * 3213 | * * 3214 | * Returns * 3215 | * -- an integer. 3216 | *******************************************************************/ 3217 | { 3218 | 3219 | int myInt; /* The value of this integer is returned. */ 3220 | 3221 | if (uh == NULL) { 3222 | fprintf(stderr, "ca_srchandle2Intelement(): Cannot dereference NULL pointer\n"); 3223 | die; 3224 | } 3225 | 3226 | switch (srcAttrib) { 3227 | 3228 | case 4: 3229 | /* Update Source DB Port */ 3230 | myInt = (uh->updDb).port; 3231 | break; 3232 | 3233 | case 16: 3234 | /* Update Source QRY Port */ 3235 | myInt = (uh->qryPort); 3236 | break; 3237 | 3238 | case 17: 3239 | /* Update Source UPD Port */ 3240 | myInt = (uh->updPort); 3241 | break; 3242 | 3243 | default: 3244 | fprintf(stderr, "Could not find source-attribute %d\n", srcAttrib); 3245 | die; 3246 | } 3247 | 3248 | return (myInt); 3249 | 3250 | } 3251 | 3252 | /* 3253 | * void ca_init(dict_t theDict[], const char *configFile, values_t 3254 | * configVars[], int varNo) 3255 | */ 3256 | /* 3257 | * ca_init() -- Initialisation function. 3258 | */ 3259 | /* 3260 | * { char sourcesFile[80]; 3261 | * 3262 | * ca_populateDictionary(theDict, varNo); ca_readConfig(configFile, configVars, 3263 | * varNo); 3264 | * 3265 | * sourcesFile = ca_get_dirlist(CA_SOURCEFILE); ca_readSources(sourcesFile, 3266 | * confVars); } 3267 | */ 3268 | 3269 | int ca_sanityChk(values_t confVars[]) 3270 | /* 3271 | - does a simple sanity check 3272 | - Parameters 3273 | - confVars - the array of configuration variables 3274 | - Returns 3275 | - an integer: -1 or 0 3276 | */ 3277 | { 3278 | int symbol; /* A counting variable */ 3279 | int status = 0; /* Assume that the Configuration File is complete. */ 3280 | int undefVars = 0; /* Number of undefined variables. */ 3281 | 3282 | /* 3283 | * Instead of using VARS here, we use CA_NUMBEROFSYMBOLS. 3284 | * 3285 | */ 3286 | for(symbol = 0; symbol < CA_NUMBEROFSYMBOLS; symbol++) 3287 | { 3288 | if (!confVars[symbol].strPtr) 3289 | { 3290 | ++undefVars; 3291 | fprintf(stderr, "%s %s\n", configWarningStr, dictionary[symbol].varName); 3292 | } 3293 | } 3294 | 3295 | if (undefVars) 3296 | { 3297 | status = INCOMPLETE; 3298 | } 3299 | 3300 | fprintf(stderr, "%s\n", configError_1Str); 3301 | fprintf(stderr, "%d%s\n", undefVars, configError_2Str); 3302 | return(status); 3303 | } 3304 | 3305 | int ca_mandVarChk(void) 3306 | /**************************************************************** 3307 | * ca_mandVarChk * 3308 | * - Looks for undefined mandatory variables * 3309 | * Parameters * 3310 | * - confVars, the array of Configuration Variables * 3311 | * - dictionary, the dictionary of Configuration Variables * 3312 | * * 3313 | * Returns * 3314 | * an integer, -1 or 0. * 3315 | * * 3316 | ****************************************************************/ 3317 | { 3318 | int symbol; /* A counting variable */ 3319 | int status = 0; /* Assume that the Configuration File is complete. */ 3320 | int undefVars = 0; /* Number of undefined variables. */ 3321 | 3322 | /* 3323 | * This output does not tell us anything useful. 3324 | * Thus, we comment it out. 3325 | * 3326 | * puts("Running mandatory variables check ....."); 3327 | */ 3328 | 3329 | for(symbol = 0; symbol < CA_NUMBEROFSYMBOLS; symbol++) 3330 | { 3331 | if ( dictionary[symbol].varMandatory && (!confVars[symbol].strPtr) ) 3332 | { 3333 | ++undefVars; 3334 | fprintf(stderr, "%s %s\n", configWarningStr, dictionary[symbol].varName); 3335 | } 3336 | } 3337 | 3338 | 3339 | if (undefVars) 3340 | { 3341 | status = INCOMPLETE; 3342 | 3343 | fprintf(stderr, "%s\n", configError_1Str); 3344 | fprintf(stderr, "%d%s\n", undefVars, configError_2Str); 3345 | } 3346 | else 3347 | { 3348 | /* 3349 | * This output does not give us new information. 3350 | * Thus, we comment it out. 3351 | * 3352 | * fprintf(stderr, "%s\n", configVarChk_OK_Str); 3353 | */ 3354 | } 3355 | 3356 | return(status); 3357 | 3358 | }