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