1 | /***************************************
2 | $Revision:
3 |
4 | CA module: definitions of functions that read a file of databases and
5 | sources.
6 |
7 | Status: NOT REVIEWED, NOT TESTED
8 |
9 | Author(s): Ambrose Magee
10 |
11 | ******************/ /******************
12 | Modification History:
13 |
14 | ******************/
15 |
16 | /************************************
17 | Copyright (c) 2000 RIPE NCC
18 |
19 | All Rights Reserved
20 |
21 | Permission to use, copy, modify, and distribute this software and its
22 | documentation for any purpose and without fee is hereby granted,
23 | provided that the above copyright notice appear in all copies and that
24 | both that copyright notice and this permission notice appear in
25 | supporting documentation, and that the name of the author not be
26 | used in advertising or publicity pertaining to distribution of the
27 | software without specific, written prior permission.
28 |
29 | THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
30 | ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
31 | AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
32 | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
33 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
34 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
35 | ***************************************/
36 |
37 | #include <stdio.h>
38 | #include <stdlib.h>
39 | #include <glib.h>
40 | #include <string.h>
41 | #include <stubs.h>
42 | #include <unistd.h>
43 | #include "ca_configFns.h"
44 |
45 | /* #define DEBUG */ /* Swich OFF Debugging. */
46 |
47 | /*******************************************************
48 | * This file contains the definitions of functions *
49 | * that read a file of databases and sources. *
50 | *******************************************************/
51 |
52 |
53 | void ca_readSources(const char *sourcesDefFile, values_t confVars[])
54 | /*******************************************************************
55 | * *
56 | * ca_readSources -- parses the Sources file and writes the values *
57 | * into memory. *
58 | * *
59 | * Parameters *
60 | * sourcesFile -- the file of databases, mirrors, sources *
61 | * confVars[] -- the array of values structures *
62 | * *
63 | * Returns *
64 | * Nothing -- perhaps make this return 0 on successful exit ? *
65 | * *
66 | *******************************************************************/
67 | {
68 | FILE *sourcesFilePtr; /* Pointer to Source file. */
69 | char line[80]; /* The current line of input. */
70 | const char *comment = "#"; /* Declared as a string. */
71 | #ifdef DEBUG
72 | char name[STRLENGTH_M]; /* The name of the config variable */
73 | char value[STRLENGTH_XXL]; /* The value of the variable */
74 | /* 640 characters */
75 |
76 | int location; /* Storage Location of the variable's value. */
77 | int type; /* Data type of the variable, represented by an integer. */
78 |
79 | const char *blankLine = "\n"; /* Declared as a string, not a character. */
80 |
81 | char dbcomp[16]; /* Component of a databse. */
82 | char nrtmcomp[16]; /* Component of an nrtm. */
83 | int mode; /* The mode of operation of the src */
84 | char srcOptions[16]; /* The options of a source. */
85 | char nrtMirror[STRLENGTH_M]; /* The elements of a NRTM */
86 | int updatePort; /* The update port of the source */
87 | /* N. B. This is not the same as the */
88 | /* updPort in the UPDSOURCE variables. */
89 | #endif /* DEBUG */
90 | char source[16]; /* The name of a source. */
91 | char database[16]; /* The name of a database. */
92 | char mirror[16]; /* The name of a mirror. */
93 | char varName[16]; /* Temporary variable */
94 |
95 |
96 |
97 | ca_database_t *newDbPtr; /* A pointer to a new instance of */
98 | /* ca_database_t. */
99 |
100 | ca_mirror_t *newMirrPtr; /* A pointer to a new instance of */
101 | /* ca_mirror_t. */
102 |
103 | ca_dbSource_t *newSrcPtr; /* A pointer to a new instance of */
104 | /* ca_database_list_t. */
105 |
106 | int in_DATABASE_def, in_NRTM_def, in_SOURCE_def;
107 | /* When we are reading the definition */
108 | /* of a database, nrtm, source, etc. */
109 | /* this is set to 1. Otherwise, it */
110 | /* is 0. */
111 |
112 | /*
113 | * Function prototypes of ca_parseDbLine(), ca_parseNrtmLine()
114 | * and ca_parseSrcLine(). We put them here so that it can only
115 | * be called from within the ca_readSources() function.
116 | */
117 | void ca_parseDbLine(char *, ca_database_t *);
118 | void ca_parseNrtmLine(char *, ca_mirror_t *);
119 | void ca_parseSrcLine(char *, ca_dbSource_t *);
120 |
121 |
122 | #ifdef DEBUG
123 | printf("\nInside ca_readSources() function.\n");
124 | printf("Sources file is: %s\n", sourcesDefFile);
125 | #endif /* DEBUG */
126 |
127 | /*
128 | * Open the sources file for reading .....
129 | */
130 | if ( (sourcesFilePtr = fopen(sourcesDefFile, "r")) == NULL)
131 | {
132 | printf("Error: the file %s could not be opened.\n", sourcesDefFile);
133 | die;
134 | }
135 |
136 | /* Before reading the file, we initialise all flags to 0. */
137 | in_DATABASE_def = 0;
138 | in_NRTM_def = 0;
139 | in_SOURCE_def = 0;
140 |
141 | /*
142 | * Read the first line of the file.
143 | * Remove leading and trailing blank-space characters.
144 | * if the first character of the line is a comment or if it is a
145 | * blank-line, continue.
146 | *
147 | */
148 |
149 | fgets(line, sizeof(line), sourcesFilePtr);
150 | g_strstrip(line);
151 |
152 | /*
153 | * While there are lines to be read in the sources file,
154 | * process the current line and
155 | * read the next line.
156 | */
157 |
158 | while (!feof(sourcesFilePtr) )
159 | {
160 | #ifdef DEBUG
161 | printf("line:%s:End of line\n", line);
162 | printf("Length of line: %d\n", strlen(line));
163 | #endif /* DEBUG */
164 |
165 | /*
166 | * Ignore comments and empty lines.
167 | */
168 | if ( (strncmp(line, comment, 1) == 0) || (strlen(line) == 0) )
169 | {
170 | #ifdef DEBUG
171 | printf("We are reading a comment or an empty line ..... \n");
172 | #endif /* DEBUG */
173 | fgets(line, sizeof(line), sourcesFilePtr);
174 | g_strstrip(line);
175 | continue;
176 | }
177 |
178 | /* Testing */
179 | #ifdef DEBUG
180 | printf("LINE >>>%sEND_OF_LINE\n", line);
181 | #endif /* DEBUG */
182 |
183 | /* if we are in a DATABASE definition
184 | * then have we read all of the definition ?
185 | * if yes, then commit the definition, reset the 'Database'
186 | * flag and read the next line.
187 | * Otherwise parse the line and store the details in temporary
188 | * variables.
189 | */
190 |
191 | /* If we are in a DATABASE definition */
192 | if (in_DATABASE_def)
193 | {
194 | /* If we have reached the end of a DATABASE definition,
195 | * commit the definition.
196 | */
197 |
198 | if (strcmp(line, "/DATABASE")== 0)
199 | {
200 | /* Commit the definition */
201 | /* Some code. */
202 | #ifdef DEBUG
203 | puts("We have reached the end of a DATABASE definition");
204 | puts("Testing the population of the db structure:");
205 | printf("\n%s::%d::%s::%s::%s\n", newDbPtr->host, newDbPtr->port, newDbPtr->user, newDbPtr->password, newDbPtr->dbName);
206 | #endif /* DEBUG */
207 |
208 | /* Commit the definition to the linked list of Databases. */
209 |
210 | dbList = g_slist_append(dbList, newDbPtr);
211 |
212 | /* We have reached the end of the DATABASE definition */
213 | /* Thus, reset the flag and free some memory. */
214 | in_DATABASE_def = 0;
215 |
216 |
217 | /* Read the next line and do the conditional test. */
218 | fgets(line, sizeof(line), sourcesFilePtr);
219 | g_strstrip(line);
220 | continue;
221 | }
222 |
223 | /*
224 | * Otherwise, parse the line and fill in the structure of
225 | * the Database.
226 | */
227 | ca_parseDbLine(line, newDbPtr);
228 |
229 | }
230 |
231 | /* If we have found the _beginning_ of a Database definition,
232 | * then set the in_DATABASE_def flag and allocate space, etc.
233 | * for the database.
234 | */
235 |
236 | if ( (!in_DATABASE_def) && (strncmp(line, DATABASE_KEY, strlen(DATABASE_KEY) )== 0 ) )
237 | {
238 | in_DATABASE_def = 1;
239 |
240 | /* Allocate space for the database */
241 | /* Current_db = fscanf etc.) */
242 | /* Fill in the defaults. */
243 | #ifdef DEBUG
244 | puts("Beginning of a database defintion ..... ");
245 | #endif /* DEBUG */
246 |
247 | sscanf(line, "%s %s", varName, database);
248 | g_strstrip(database);
249 |
250 | #ifdef DEBUG
251 | printf("Database name is: %s\n", database);
252 | #endif /* DEBUG */
253 |
254 | /*
255 | * Create a structure for the database.
256 | */
257 | newDbPtr = calloc(1,sizeof(ca_database_t));
258 | if (newDbPtr == NULL)
259 | {
260 | fprintf(stderr, "Cannot allocate memory to new db structure\n");
261 | die;
262 | }
263 |
264 | /* Assign the name of the database */
265 | strcpy(newDbPtr->dbName, database);
266 |
267 | }
268 |
269 |
270 | /********************
271 | * NRTM definition *
272 | ********************/
273 |
274 | /* if we are in a NRTM definition
275 | * then have we read all of the definition ?
276 | * if yes, then commit the definition and read the next line.
277 | * otherwise parse the line and store the details in temporary
278 | * variables.
279 | */
280 |
281 | /* If we are in a NRTM definition */
282 | if (in_NRTM_def)
283 | {
284 | /* If we have reached the end of a NRTM definition,
285 | * commit the definition.
286 | */
287 | if (strcmp(line, "/NRTM")== 0)
288 | {
289 | /* Commit the definition */
290 | /* Some code. */
291 | #ifdef DEBUG
292 | puts("We have reached the end of a NRTM definition");
293 | puts("Testing the population of the mirror structure:");
294 | printf("\n%s::%d::%d::%d\n", newMirrPtr->host, newMirrPtr->port, newMirrPtr->delay, newMirrPtr->protocolVer);
295 | #endif /* DEBUG */
296 |
297 | /* Commit the definition to the linked list of nrt-mirrors. */
298 |
299 | nrtmList = g_slist_append(nrtmList, newMirrPtr);
300 |
301 | /* We have reached the end of the NRTM definition */
302 | /* Thus, reset the NRTM flag. */
303 | in_NRTM_def = 0;
304 |
305 | /* Read the next line and do the conditional test. */
306 | fgets(line, sizeof(line), sourcesFilePtr);
307 | g_strstrip(line);
308 | continue;
309 | }
310 |
311 | /*
312 | * Otherwise, parse the line and fill in the structure of
313 | * the NRMT.
314 | */
315 |
316 | ca_parseNrtmLine(line, newMirrPtr);
317 | }
318 |
319 | /* If we have found the beginning of a Near-Real-Time-Mirror
320 | * definition, then set the in_NRTM_def flag and allocate
321 | * space, etc. for the Near-Real-Time-Mirror.
322 | */
323 |
324 | if ( (!in_NRTM_def) && (strncmp(line, NRTM_KEY, strlen(NRTM_KEY) )== 0 ) )
325 | {
326 | in_NRTM_def = 1;
327 | /* Allocate space for the Near-Real-Time-Mirror. */
328 | /* Current_db = fscanf etc.) */
329 | /* Fill in the defaults. */
330 | #ifdef DEBUG
331 | puts("Beginning of a Near-Real-Time-Mirror defintion ..... ");
332 | #endif /* DEBUG */
333 |
334 | sscanf(line, "%s %s", varName, mirror);
335 |
336 | /*
337 | * Create a structure for the mirror.
338 | */
339 | newMirrPtr = calloc(1,sizeof(ca_mirror_t));
340 | if (newMirrPtr == NULL)
341 | {
342 | fprintf(stderr, "Cannot allocate memory to new nrtm structure\n");
343 | die;
344 | }
345 | /* Assign the name of the mirror ? */
346 | strcpy(newMirrPtr->mrName, mirror);
347 |
348 | }
349 |
350 | /*********************
351 | * SOURCE Definition *
352 | *********************/
353 |
354 | /* if we are in a SOURCE definition
355 | * then have we read all of the definition ?
356 | * if yes, then commit the definition, reset the 'Database'
357 | * flag and read the next line.
358 | * Otherwise parse the line and store the details in temporary
359 | * variables.
360 | */
361 |
362 | /* If we are in a SOURCE definition */
363 | if (in_SOURCE_def)
364 | {
365 | /* If we have reached the end of a SOURCE definition,
366 | * commit the definition.
367 | */
368 |
369 | if (strcmp(line, "/SOURCE")== 0)
370 | {
371 | /* Commit the definition */
372 | /* Some code. */
373 | #ifdef DEBUG
374 | puts("We have reached the end of a SOURCE definition");
375 | puts("Testing the population of the new Source structure:");
376 | printf("Source name: %s\n", newSrcPtr->name);
377 | printf("\nDB == %s::%d::%s::%s::%s\n", (newSrcPtr->db).host, (newSrcPtr->db).port, (newSrcPtr->db).user, (newSrcPtr->db).password, (newSrcPtr->db).dbName);
378 | printf("Mode: %d\n", newSrcPtr->opMode);
379 | printf("NRTM == %s::%d::%d:%d\n", (newSrcPtr->nrtm).host, (newSrcPtr->nrtm).port, (newSrcPtr->nrtm).delay, (newSrcPtr->nrtm).protocolVer);
380 | printf("UpdPort: %d\n", newSrcPtr->updPort);
381 | printf("New Source Options == %s::%s\n", newSrcPtr->canupd, newSrcPtr->deflook);
382 | #endif /* DEBUG */
383 |
384 | /* Commit the definition to the linked list of Databases. */
385 |
386 | sourceList = g_slist_append(sourceList, newSrcPtr);
387 |
388 | /* We have reached the end of the DATABASE definition */
389 | /* Thus, reset the flag and free some memory. */
390 | in_SOURCE_def = 0;
391 |
392 |
393 | /* Read the next line and do the conditional test. */
394 | fgets(line, sizeof(line), sourcesFilePtr);
395 | g_strstrip(line);
396 | continue;
397 | }
398 |
399 | /*
400 | * Otherwise, parse the line and fill in the structure of
401 | * the Database.
402 | */
403 | ca_parseSrcLine(line, newSrcPtr);
404 |
405 | }
406 |
407 | /* If we have found the _beginning_ of a SOURCE definition,
408 | * then set the in_SOURCE_def flag and allocate space, etc.
409 | * for the database.
410 | */
411 |
412 | if ( (!in_SOURCE_def) && (strncmp(line, SOURCE_KEY, strlen(SOURCE_KEY) )== 0 ) )
413 | {
414 | in_SOURCE_def = 1;
415 |
416 | /* Allocate space for the Source */
417 | /* Current_source = fscanf etc.) */
418 | /* Fill in the defaults. */
419 | #ifdef DEBUG
420 | puts("Beginning of a Source defintion ..... ");
421 | #endif /* DEBUG */
422 |
423 | sscanf(line, "%s %s", varName, source);
424 | g_strstrip(source);
425 |
426 | #ifdef DEBUG
427 | printf("Source name is: %s\n", source);
428 | #endif /* DEBUG */
429 |
430 | /*
431 | * Create a structure for the source.
432 | *
433 | */
434 | newSrcPtr = calloc(1,sizeof(ca_dbSource_t));
435 | if (newSrcPtr == NULL)
436 | {
437 | fprintf(stderr, "Cannot allocate memory to new Source structure\n");
438 | die;
439 | }
440 |
441 | /* Assign the name of the Source */
442 | strcpy(newSrcPtr->name, source);
443 |
444 | }
445 |
446 | /* Read the next line. */
447 | fgets(line, sizeof(line), sourcesFilePtr);
448 | g_strstrip(line);
449 |
450 | /* End of while loop; i.e. end of processing a line. */
451 | }
452 |
453 | /* Close the sources definition file. */
454 | fclose(sourcesFilePtr);
455 |
456 | /* End of ca_readSources() function */
457 |
458 | }
459 |
460 | void ca_getAllDatabases(GSList *databases)
461 | {
462 | GSList *currentPtr; /* Pointer to the structure at which we look. */
463 |
464 | /*
465 | * Look at the first member of the linked-list of sources.
466 | */
467 | currentPtr = databases;
468 |
469 | /*
470 | * Look at each data component of the source list,
471 | * untill we reach the end of the list.
472 | */
473 | while(currentPtr != NULL)
474 | {
475 | ca_database_t *dbPtr = currentPtr->data;
476 | printf("\n%s,%d,%s,%s,%s\n", dbPtr->host, dbPtr->port, dbPtr->user, dbPtr->password, dbPtr->dbName);
477 | currentPtr = currentPtr->next;
478 | }
479 | }
480 |
481 |
482 | void ca_getAllMirrors(GSList *mirrors)
483 | {
484 | GSList *currentPtr; /* Pointer to the structure at which we look. */
485 |
486 | /*
487 | * Look at the first member of the linked-list of sources.
488 | */
489 | currentPtr = mirrors;
490 |
491 | /*
492 | * Look at each data component of the source list,
493 | * untill we reach the end of the list.
494 | */
495 | while(currentPtr != NULL)
496 | {
497 | ca_mirror_t *nrtmPtr = currentPtr->data;
498 | printf("\n%s,%d,%d,%d, %s\n", nrtmPtr->host, nrtmPtr->port, nrtmPtr->delay, nrtmPtr->protocolVer, nrtmPtr->mrName);
499 | currentPtr = currentPtr->next;
500 | }
501 | }
502 |
503 | void ca_parseDbLine(char *lineStr, ca_database_t *dbStructPtr)
504 | /*******************************************************************
505 | * *
506 | * ca_parseLine -- parses the a line in the Sources file and *
507 | * writes the values into temporary variables. *
508 | * *
509 | * Parameters *
510 | * lineStr -- the current line of the Sources file *
511 | * -- a NULL terminated string *
512 | * dbStructPtr -- the db we are filling *
513 | * -- a pointer to a ca_database_t structure. *
514 | * *
515 | * Returns *
516 | * Nothing -- perhaps make this return 0 on successful exit ? *
517 | * *
518 | *******************************************************************/
519 | {
520 | char dbComp[64]; /* Component of a database. */
521 | char varName[16]; /* The name of the variable. */
522 |
523 | gchar **tokens; /* Pointer to an array of strings. */
524 |
525 | #ifdef DEBUG
526 | int i; /* A counting variable. */
527 | #endif /* DEBUG */
528 |
529 | /*
530 | * Split the line on the ':' character.
531 | * Then, for both the name of the variable and its value,
532 | * remove leading and trailing blank-space characters.
533 | */
534 | tokens = g_strsplit(lineStr, ":", 0);
535 |
536 | #ifdef DEBUG
537 | for (i = 0; tokens[i] != NULL; i++)
538 | printf("tokens[%d] = %s\n", i, tokens[i]);
539 | #endif /* DEBUG */
540 |
541 | strcpy(varName, tokens[0]);
542 | strcpy(dbComp, tokens[1]);
543 |
544 | /* Free the memory used by the tokens array. */
545 | g_strfreev(tokens);
546 |
547 | /* Remove leading and trailing blank-space characters. */
548 | g_strstrip(varName);
549 | g_strstrip(dbComp);
550 |
551 | #ifdef DEBUG
552 | printf("VarName: %s; dbComp: %s\n", varName, dbComp);
553 | #endif /* DEBUG */
554 |
555 | if (strcmp(varName, "host") == 0)
556 | {
557 | strcpy(dbStructPtr->host, dbComp);
558 | }
559 | else
560 | {
561 | if (strcmp(varName, "port") == 0)
562 | {
563 | dbStructPtr->port = atoi(dbComp);
564 | }
565 | else
566 | {
567 | if (strcmp(varName, "user") == 0)
568 | {
569 | strcpy(dbStructPtr->user, dbComp);
570 | }
571 | else
572 | {
573 | if (strcmp(varName, "password") == 0)
574 | {
575 | strcpy(dbStructPtr->password, dbComp);
576 | }
577 | else
578 | {
579 | fprintf(stderr, "Unknown database component \"%s\".\n", dbComp);
580 | die;
581 | }
582 | }
583 | }
584 | }
585 | }
586 |
587 |
588 |
589 | void ca_parseNrtmLine(char *lineStr, ca_mirror_t *mrStructPtr)
590 | /*
591 | */
592 | {
593 | char nrtmComp[64]; /* Component of a NRTM. */
594 | char varName[16]; /* The name of the variable. */
595 |
596 | gchar **tokens; /* Pointer to an array of strings. */
597 |
598 | #ifdef DEBUG
599 | int i; /* A counting variable. */
600 | #endif /* DEBUG */
601 |
602 | /*
603 | * Split the line on the ':' character.
604 | * Then, for both the name of the variable and its value,
605 | * remove leading and trailing blank-space characters.
606 | */
607 | tokens = g_strsplit(lineStr, ":", 0);
608 |
609 | #ifdef DEBUG
610 | for (i = 0; tokens[i] != NULL; i++)
611 | printf("tokens[%d] = %s\n", i, tokens[i]);
612 | #endif /* DEBUG */
613 |
614 | strcpy(varName, tokens[0]);
615 | strcpy(nrtmComp, tokens[1]);
616 |
617 | /* Free the memory used by the tokens array. */
618 | g_strfreev(tokens);
619 |
620 | /* Remove leading and trailing blank-space characters. */
621 | g_strstrip(varName);
622 | g_strstrip(nrtmComp);
623 |
624 | #ifdef DEBUG
625 | printf("VarName: %s; nrtmComp: %s\n", varName, nrtmComp);
626 | #endif /* DEBUG */
627 |
628 |
629 | if (strcmp(varName, "host") == 0)
630 | {
631 | strcpy(mrStructPtr->host, nrtmComp);
632 | }
633 | else
634 | {
635 | if (strcmp(varName, "port") == 0)
636 | {
637 | mrStructPtr->port = atoi(nrtmComp);
638 | }
639 | else
640 | {
641 | if (strcmp(varName, "delay") == 0)
642 | {
643 | mrStructPtr->delay = atoi(nrtmComp);
644 | }
645 | else
646 | {
647 | if (strcmp(varName, "protocolVersion") == 0)
648 | {
649 | mrStructPtr->protocolVer = atoi(nrtmComp);
650 | }
651 | else
652 | {
653 | fprintf(stderr, "Unknown mirror component \"%s\".\n", nrtmComp);
654 | die;
655 | }
656 | }
657 | }
658 | }
659 | }
660 |
661 |
662 |
663 |
664 | void ca_parseSrcLine(char *lineStr, ca_dbSource_t *srcStructPtr)
665 | /*
666 | * ca_parseSrcLine() function.
667 | */
668 | {
669 | char srcComp[64]; /* Component of a database. */
670 | char varName[16]; /* The name of the variable. */
671 |
672 | gchar **tokens; /* Pointer to an array of strings. */
673 |
674 | #ifdef DEBUG
675 | int i; /* A counting variable. */
676 | #endif /* DEBUG */
677 |
678 | /*
679 | * Split the line on the ':' character.
680 | * Then, for both the name of the variable and its value,
681 | * remove leading and trailing blank-space characters.
682 | */
683 | tokens = g_strsplit(lineStr, ":", 0);
684 |
685 | #ifdef DEBUG
686 | for (i = 0; tokens[i] != NULL; i++)
687 | printf("tokens[%d] = %s\n", i, tokens[i]);
688 | #endif /* DEBUG */
689 |
690 | strcpy(varName, tokens[0]);
691 | strcpy(srcComp, tokens[1]);
692 |
693 | /* Free the memory used by the tokens array. */
694 | g_strfreev(tokens);
695 |
696 | /* Remove leading and trailing blank-space characters. */
697 | g_strstrip(varName);
698 | g_strstrip(srcComp);
699 |
700 | #ifdef DEBUG
701 | printf("VarName: %s; srcComp: %s\n", varName, srcComp);
702 | #endif /* DEBUG */
703 |
704 | /*
705 | * Parse each line of the SOURCE definition.
706 | * If we find a database or a mirror, search for it in
707 | * the appropriate linked list and make this source
708 | * point to it.
709 | */
710 | if (strcmp(varName, "database") == 0)
711 | {
712 | /* Search for the appropriate database. */
713 | /* Make this source point to it. */
714 | /* Use ca_getDbHandleByName(). */
715 | srcStructPtr->db = *ca_getDbHandleByName(srcComp);
716 | }
717 | else
718 | {
719 | if (strcmp(varName, "opMode") == 0)
720 | {
721 | srcStructPtr->opMode = atoi(srcComp);
722 | }
723 | else
724 | {
725 | if (strcmp(varName, "updPort") == 0)
726 | {
727 | srcStructPtr->updPort = atoi(srcComp);
728 | }
729 | else
730 | {
731 | if (strcmp(varName, "canupd") == 0)
732 | {
733 | strcpy(srcStructPtr->canupd, srcComp);
734 | }
735 | else
736 | {
737 | if (strcmp(varName, "deflook") == 0)
738 | {
739 | strcpy(srcStructPtr->deflook, srcComp);
740 | }
741 | else
742 | {
743 | if (strcmp(varName, "nrtm") == 0)
744 | {
745 | /* Get Mirror Handle by Name */
746 | /* Assign this mirror to */
747 | /* srcStructPtr->nrtm. */
748 | srcStructPtr->nrtm = *ca_getNrtmHandleByName(srcComp);
749 | }
750 | else
751 | {
752 | fprintf(stderr, "Unknown SOURCE component \"%s\".\n", srcComp);
753 | die;
754 | }
755 | }
756 | }
757 | }
758 | }
759 | }
760 | }
761 |
762 |
763 | ca_database_t *ca_getDbHandleByName(char *databaseNameStr)
764 | /*******************************************************************
765 | * ca_getDbHandleByName *
766 | * -- A function that compares each 'name' component of every *
767 | * element in the linked-list of databases with the name of *
768 | * the database to be found. If the required database is *
769 | * found, a pointer to the structure representing this *
770 | * database is returned. *
771 | * *
772 | * Parameters *
773 | * -- databaseNameStr - the name of the required database *
774 | * *
775 | * Returns *
776 | * -- dbasePtr - a pointer to the structure representing the *
777 | * database or a pointer to NULL, if we cannot *
778 | * find the database. *
779 | * *
780 | *******************************************************************/
781 | {
782 | /*
783 | * Define a pointer to the current element in the linked list.
784 | * Initialise it to the start of the list.
785 | */
786 | GSList *currentPtr = dbList;
787 |
788 | /*
789 | * Define and initialise a pointer that points to the 'data'
790 | * component of the GSList struct; i.e. a pointer to a
791 | * variable of type ca_database_t.
792 | */
793 | ca_database_t *dbasePtr = currentPtr->data;
794 |
795 | /*
796 | * Look at each data component of the list of databases;
797 | * (each data component is a structure of type ca_database_t).
798 | * Compare the 'name' component of each ca_database_t structure
799 | * with the value of databaseName untill we get a match or we
800 | * reach the end of the list.
801 | */
802 |
803 | /*
804 | * We first check if currentPtr is pointing to NULL;
805 | * if yes, we exit the while loop;
806 | * if no, we make dbasePtr point to the data component
807 | * of the current ca_database_t structure;
808 | * then, we check if this is the database name that we want;
809 | * if yes, we _break_ from the while loop.
810 | */
811 | while (currentPtr != NULL)
812 | {
813 | dbasePtr= currentPtr->data;
814 | if (strcmp(dbasePtr->dbName, databaseNameStr) == 0 )
815 | break;
816 | currentPtr = currentPtr->next;
817 | }
818 |
819 | /*
820 | * We return a pointer. If we found the database, this pointer
821 | * points to the ca_database_t structure which represents the
822 | * database.
823 | * If we did not find the database, we return a pointer to NULL.
824 | */
825 | if (currentPtr == NULL)
826 | {
827 | dbasePtr = NULL;
828 | return(dbasePtr);
829 | }
830 | else
831 | {
832 | return(dbasePtr);
833 | }
834 |
835 | }
836 |
837 |
838 |
839 | ca_mirror_t *ca_getNrtmHandleByName(char *nrtmNameStr)
840 | /*******************************************************************
841 | * ca_NrtmHandleByName *
842 | * -- A function that compares each 'name' component of every *
843 | * element in the linked-list of databases with the name of *
844 | * the database to be found. If the required database is *
845 | * found, a pointer to the structure representing this *
846 | * database is returned. *
847 | * *
848 | * Parameters *
849 | * -- nrtmNameStr - the name of the required database *
850 | * *
851 | * Returns *
852 | * -- nrtmPtr - a pointer to the structure representing the *
853 | * database or a pointer to NULL, if we cannot *
854 | * find the database. *
855 | * *
856 | *******************************************************************/
857 | {
858 | /*
859 | * Define a pointer to the current element in the linked list.
860 | * Initialise it to the start of the list.
861 | */
862 | GSList *currentPtr = nrtmList;
863 |
864 | /*
865 | * Define and initialise a pointer that points to the 'data'
866 | * component of the GSList struct; i.e. a pointer to a
867 | * variable of type ca_database_t.
868 | */
869 | ca_mirror_t *nrtmPtr = currentPtr->data;
870 |
871 | /*
872 | * Look at each data component of the list of databases;
873 | * (each data component is a structure of type ca_database_t).
874 | * Compare the 'name' component of each ca_database_t structure
875 | * with the value of databaseName untill we get a match or we
876 | * reach the end of the list.
877 | */
878 |
879 | /*
880 | * We first check if currentPtr is pointing to NULL;
881 | * if yes, we exit the while loop;
882 | * if no, we make nrtmPtr point to the data component
883 | * of the current ca_database_t structure;
884 | * then, we check if this is the database name that we want;
885 | * if yes, we _break_ from the while loop.
886 | */
887 | while (currentPtr != NULL)
888 | {
889 | nrtmPtr= currentPtr->data;
890 | if (strcmp(nrtmPtr->mrName, nrtmNameStr) == 0 )
891 | break;
892 | currentPtr = currentPtr->next;
893 | }
894 |
895 | /*
896 | * We return a pointer. If we found the database, this pointer
897 | * points to the ca_database_t structure which represents the
898 | * database.
899 | * If we did not find the database, we return a pointer to NULL.
900 | */
901 | if (currentPtr == NULL)
902 | {
903 | nrtmPtr = NULL;
904 | return(nrtmPtr);
905 | }
906 | else
907 | {
908 | return(nrtmPtr);
909 | }
910 |
911 | }