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  | }