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