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