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