modules/ca/ca_sourceLoader.c
/* [<][>][^][v][top][bottom][index][help] */
FUNCTIONS
This source file includes following functions.
- ca_readSources
- ca_getAllDatabases
- ca_getAllMirrors
- ca_parseDbLine
- ca_parseNrtmLine
- ca_parseSrcLine
- ca_getDbHandleByName
- ca_getNrtmHandleByName
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[])
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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 }