1: /* This modules is based on the params.c module from Samba, written by Karl Auer
2: and much modifed by Christopher Hertel. */
3:
4: /*
5: * This program is free software; you can redistribute it and/or modify
6: * it under the terms of the GNU General Public License as published by
7: * the Free Software Foundation; either version 3 of the License, or
8: * (at your option) any later version.
9: *
10: * This program is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: * GNU General Public License for more details.
14: *
15: * You should have received a copy of the GNU General Public License along
16: * with this program; if not, visit the http://fsf.org website.
17: */
18:
19: /* -------------------------------------------------------------------------- **
20: *
21: * Module name: params
22: *
23: * -------------------------------------------------------------------------- **
24: *
25: * This module performs lexical analysis and initial parsing of a
26: * Windows-like parameter file. It recognizes and handles four token
27: * types: section-name, parameter-name, parameter-value, and
28: * end-of-file. Comments and line continuation are handled
29: * internally.
30: *
31: * The entry point to the module is function pm_process(). This
32: * function opens the source file, calls the Parse() function to parse
33: * the input, and then closes the file when either the EOF is reached
34: * or a fatal error is encountered.
35: *
36: * A sample parameter file might look like this:
37: *
38: * [section one]
39: * parameter one = value string
40: * parameter two = another value
41: * [section two]
42: * new parameter = some value or t'other
43: *
44: * The parameter file is divided into sections by section headers:
45: * section names enclosed in square brackets (eg. [section one]).
46: * Each section contains parameter lines, each of which consist of a
47: * parameter name and value delimited by an equal sign. Roughly, the
48: * syntax is:
49: *
50: * <file> :== { <section> } EOF
51: *
52: * <section> :== <section header> { <parameter line> }
53: *
54: * <section header> :== '[' NAME ']'
55: *
56: * <parameter line> :== NAME '=' VALUE '\n'
57: *
58: * Blank lines and comment lines are ignored. Comment lines are lines
59: * beginning with either a semicolon (';') or a pound sign ('#').
60: *
61: * All whitespace in section names and parameter names is compressed
62: * to single spaces. Leading and trailing whitespace is stipped from
63: * both names and values.
64: *
65: * Only the first equals sign in a parameter line is significant.
66: * Parameter values may contain equals signs, square brackets and
67: * semicolons. Internal whitespace is retained in parameter values,
68: * with the exception of the '\r' character, which is stripped for
69: * historic reasons. Parameter names may not start with a left square
70: * bracket, an equal sign, a pound sign, or a semicolon, because these
71: * are used to identify other tokens.
72: *
73: * -------------------------------------------------------------------------- **
74: */
75:
76: #include "rsync.h"
77: #include "ifuncs.h"
78:
79: /* -------------------------------------------------------------------------- **
80: * Constants...
81: */
82:
83: #define BUFR_INC 1024
84:
85:
86: /* -------------------------------------------------------------------------- **
87: * Variables...
88: *
89: * bufr - pointer to a global buffer. This is probably a kludge,
90: * but it was the nicest kludge I could think of (for now).
91: * bSize - The size of the global buffer <bufr>.
92: */
93:
94: static char *bufr = NULL;
95: static int bSize = 0;
96:
97: /* -------------------------------------------------------------------------- **
98: * Functions...
99: */
100:
101: static int EatWhitespace( FILE *InFile )
102: /* ------------------------------------------------------------------------ **
103: * Scan past whitespace (see ctype(3C)) and return the first non-whitespace
104: * character, or newline, or EOF.
105: *
106: * Input: InFile - Input source.
107: *
108: * Output: The next non-whitespace character in the input stream.
109: *
110: * Notes: Because the config files use a line-oriented grammar, we
111: * explicitly exclude the newline character from the list of
112: * whitespace characters.
113: * - Note that both EOF (-1) and the nul character ('\0') are
114: * considered end-of-file markers.
115: *
116: * ------------------------------------------------------------------------ **
117: */
118: {
119: int c;
120:
121: for( c = getc( InFile ); isspace( c ) && ('\n' != c); c = getc( InFile ) )
122: ;
123: return( c );
124: } /* EatWhitespace */
125:
126: static int EatComment( FILE *InFile )
127: /* ------------------------------------------------------------------------ **
128: * Scan to the end of a comment.
129: *
130: * Input: InFile - Input source.
131: *
132: * Output: The character that marks the end of the comment. Normally,
133: * this will be a newline, but it *might* be an EOF.
134: *
135: * Notes: Because the config files use a line-oriented grammar, we
136: * explicitly exclude the newline character from the list of
137: * whitespace characters.
138: * - Note that both EOF (-1) and the nul character ('\0') are
139: * considered end-of-file markers.
140: *
141: * ------------------------------------------------------------------------ **
142: */
143: {
144: int c;
145:
146: for( c = getc( InFile ); ('\n'!=c) && (EOF!=c) && (c>0); c = getc( InFile ) )
147: ;
148: return( c );
149: } /* EatComment */
150:
151: static int Continuation( char *line, int pos )
152: /* ------------------------------------------------------------------------ **
153: * Scan backards within a string to discover if the last non-whitespace
154: * character is a line-continuation character ('\\').
155: *
156: * Input: line - A pointer to a buffer containing the string to be
157: * scanned.
158: * pos - This is taken to be the offset of the end of the
159: * string. This position is *not* scanned.
160: *
161: * Output: The offset of the '\\' character if it was found, or -1 to
162: * indicate that it was not.
163: *
164: * ------------------------------------------------------------------------ **
165: */
166: {
167: pos--;
168: while( pos >= 0 && isSpace(line + pos) )
169: pos--;
170:
171: return( ((pos >= 0) && ('\\' == line[pos])) ? pos : -1 );
172: } /* Continuation */
173:
174:
175: static BOOL Section( FILE *InFile, BOOL (*sfunc)(char *) )
176: /* ------------------------------------------------------------------------ **
177: * Scan a section name, and pass the name to function sfunc().
178: *
179: * Input: InFile - Input source.
180: * sfunc - Pointer to the function to be called if the section
181: * name is successfully read.
182: *
183: * Output: True if the section name was read and True was returned from
184: * <sfunc>. False if <sfunc> failed or if a lexical error was
185: * encountered.
186: *
187: * ------------------------------------------------------------------------ **
188: */
189: {
190: int c;
191: int i;
192: int end;
193: char *func = "params.c:Section() -";
194:
195: i = 0; /* <i> is the offset of the next free byte in bufr[] and */
196: end = 0; /* <end> is the current "end of string" offset. In most */
197: /* cases these will be the same, but if the last */
198: /* character written to bufr[] is a space, then <end> */
199: /* will be one less than <i>. */
200:
201: c = EatWhitespace( InFile ); /* We've already got the '['. Scan */
202: /* past initial white space. */
203:
204: while( (EOF != c) && (c > 0) )
205: {
206:
207: /* Check that the buffer is big enough for the next character. */
208: if( i > (bSize - 2) )
209: {
210: bSize += BUFR_INC;
211: bufr = realloc_array( bufr, char, bSize );
212: if( NULL == bufr )
213: {
214: rprintf(FLOG, "%s Memory re-allocation failure.", func);
215: return( False );
216: }
217: }
218:
219: /* Handle a single character. */
220: switch( c )
221: {
222: case ']': /* Found the closing bracket. */
223: bufr[end] = '\0';
224: if( 0 == end ) /* Don't allow an empty name. */
225: {
226: rprintf(FLOG, "%s Empty section name in configuration file.\n", func );
227: return( False );
228: }
229: if( !sfunc( bufr ) ) /* Got a valid name. Deal with it. */
230: return( False );
231: (void)EatComment( InFile ); /* Finish off the line. */
232: return( True );
233:
234: case '\n': /* Got newline before closing ']'. */
235: i = Continuation( bufr, i ); /* Check for line continuation. */
236: if( i < 0 )
237: {
238: bufr[end] = '\0';
239: rprintf(FLOG, "%s Badly formed line in configuration file: %s\n",
240: func, bufr );
241: return( False );
242: }
243: end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
244: c = getc( InFile ); /* Continue with next line. */
245: break;
246:
247: default: /* All else are a valid name chars. */
248: if( isspace( c ) ) /* One space per whitespace region. */
249: {
250: bufr[end] = ' ';
251: i = end + 1;
252: c = EatWhitespace( InFile );
253: }
254: else /* All others copy verbatim. */
255: {
256: bufr[i++] = c;
257: end = i;
258: c = getc( InFile );
259: }
260: }
261: }
262:
263: /* We arrive here if we've met the EOF before the closing bracket. */
264: rprintf(FLOG, "%s Unexpected EOF in the configuration file: %s\n", func, bufr );
265: return( False );
266: } /* Section */
267:
268: static BOOL Parameter( FILE *InFile, BOOL (*pfunc)(char *, char *), int c )
269: /* ------------------------------------------------------------------------ **
270: * Scan a parameter name and value, and pass these two fields to pfunc().
271: *
272: * Input: InFile - The input source.
273: * pfunc - A pointer to the function that will be called to
274: * process the parameter, once it has been scanned.
275: * c - The first character of the parameter name, which
276: * would have been read by Parse(). Unlike a comment
277: * line or a section header, there is no lead-in
278: * character that can be discarded.
279: *
280: * Output: True if the parameter name and value were scanned and processed
281: * successfully, else False.
282: *
283: * Notes: This function is in two parts. The first loop scans the
284: * parameter name. Internal whitespace is compressed, and an
285: * equal sign (=) terminates the token. Leading and trailing
286: * whitespace is discarded. The second loop scans the parameter
287: * value. When both have been successfully identified, they are
288: * passed to pfunc() for processing.
289: *
290: * ------------------------------------------------------------------------ **
291: */
292: {
293: int i = 0; /* Position within bufr. */
294: int end = 0; /* bufr[end] is current end-of-string. */
295: int vstart = 0; /* Starting position of the parameter value. */
296: char *func = "params.c:Parameter() -";
297:
298: /* Read the parameter name. */
299: while( 0 == vstart ) /* Loop until we've found the start of the value. */
300: {
301:
302: if( i > (bSize - 2) ) /* Ensure there's space for next char. */
303: {
304: bSize += BUFR_INC;
305: bufr = realloc_array( bufr, char, bSize );
306: if( NULL == bufr )
307: {
308: rprintf(FLOG, "%s Memory re-allocation failure.", func) ;
309: return( False );
310: }
311: }
312:
313: switch( c )
314: {
315: case '=': /* Equal sign marks end of param name. */
316: if( 0 == end ) /* Don't allow an empty name. */
317: {
318: rprintf(FLOG, "%s Invalid parameter name in config. file.\n", func );
319: return( False );
320: }
321: bufr[end++] = '\0'; /* Mark end of string & advance. */
322: i = end; /* New string starts here. */
323: vstart = end; /* New string is parameter value. */
324: bufr[i] = '\0'; /* New string is nul, for now. */
325: break;
326:
327: case '\n': /* Find continuation char, else error. */
328: i = Continuation( bufr, i );
329: if( i < 0 )
330: {
331: bufr[end] = '\0';
332: rprintf(FLOG, "%s Ignoring badly formed line in configuration file: %s\n",
333: func, bufr );
334: return( True );
335: }
336: end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
337: c = getc( InFile ); /* Read past eoln. */
338: break;
339:
340: case '\0': /* Shouldn't have EOF within param name. */
341: case EOF:
342: bufr[i] = '\0';
343: rprintf(FLOG, "%s Unexpected end-of-file at: %s\n", func, bufr );
344: return( True );
345:
346: default:
347: if( isspace( c ) ) /* One ' ' per whitespace region. */
348: {
349: bufr[end] = ' ';
350: i = end + 1;
351: c = EatWhitespace( InFile );
352: }
353: else /* All others verbatim. */
354: {
355: bufr[i++] = c;
356: end = i;
357: c = getc( InFile );
358: }
359: }
360: }
361:
362: /* Now parse the value. */
363: c = EatWhitespace( InFile ); /* Again, trim leading whitespace. */
364: while( (EOF !=c) && (c > 0) )
365: {
366:
367: if( i > (bSize - 2) ) /* Make sure there's enough room. */
368: {
369: bSize += BUFR_INC;
370: bufr = realloc_array( bufr, char, bSize );
371: if( NULL == bufr )
372: {
373: rprintf(FLOG, "%s Memory re-allocation failure.", func) ;
374: return( False );
375: }
376: }
377:
378: switch( c )
379: {
380: case '\r': /* Explicitly remove '\r' because the older */
381: c = getc( InFile ); /* version called fgets_slash() which also */
382: break; /* removes them. */
383:
384: case '\n': /* Marks end of value unless there's a '\'. */
385: i = Continuation( bufr, i );
386: if( i < 0 )
387: c = 0;
388: else
389: {
390: for( end = i; end >= 0 && isSpace(bufr + end); end-- )
391: ;
392: c = getc( InFile );
393: }
394: break;
395:
396: default: /* All others verbatim. Note that spaces do */
397: bufr[i++] = c; /* not advance <end>. This allows trimming */
398: if( !isspace( c ) ) /* of whitespace at the end of the line. */
399: end = i;
400: c = getc( InFile );
401: break;
402: }
403: }
404: bufr[end] = '\0'; /* End of value. */
405:
406: return( pfunc( bufr, &bufr[vstart] ) ); /* Pass name & value to pfunc(). */
407: } /* Parameter */
408:
409: static BOOL Parse( FILE *InFile,
410: BOOL (*sfunc)(char *),
411: BOOL (*pfunc)(char *, char *) )
412: /* ------------------------------------------------------------------------ **
413: * Scan & parse the input.
414: *
415: * Input: InFile - Input source.
416: * sfunc - Function to be called when a section name is scanned.
417: * See Section().
418: * pfunc - Function to be called when a parameter is scanned.
419: * See Parameter().
420: *
421: * Output: True if the file was successfully scanned, else False.
422: *
423: * Notes: The input can be viewed in terms of 'lines'. There are four
424: * types of lines:
425: * Blank - May contain whitespace, otherwise empty.
426: * Comment - First non-whitespace character is a ';' or '#'.
427: * The remainder of the line is ignored.
428: * Section - First non-whitespace character is a '['.
429: * Parameter - The default case.
430: *
431: * ------------------------------------------------------------------------ **
432: */
433: {
434: int c;
435:
436: c = EatWhitespace( InFile );
437: while( (EOF != c) && (c > 0) )
438: {
439: switch( c )
440: {
441: case '\n': /* Blank line. */
442: c = EatWhitespace( InFile );
443: break;
444:
445: case ';': /* Comment line. */
446: case '#':
447: c = EatComment( InFile );
448: break;
449:
450: case '[': /* Section Header. */
451: if (!sfunc) return True;
452: if( !Section( InFile, sfunc ) )
453: return( False );
454: c = EatWhitespace( InFile );
455: break;
456:
457: case '\\': /* Bogus backslash. */
458: c = EatWhitespace( InFile );
459: break;
460:
461: default: /* Parameter line. */
462: if( !Parameter( InFile, pfunc, c ) )
463: return( False );
464: c = EatWhitespace( InFile );
465: break;
466: }
467: }
468: return( True );
469: } /* Parse */
470:
471: static FILE *OpenConfFile( char *FileName )
472: /* ------------------------------------------------------------------------ **
473: * Open a configuration file.
474: *
475: * Input: FileName - The pathname of the config file to be opened.
476: *
477: * Output: A pointer of type (FILE *) to the opened file, or NULL if the
478: * file could not be opened.
479: *
480: * ------------------------------------------------------------------------ **
481: */
482: {
483: FILE *OpenedFile;
484: char *func = "params.c:OpenConfFile() -";
485:
486: if( NULL == FileName || 0 == *FileName )
487: {
488: rprintf(FLOG, "%s No configuration filename specified.\n", func);
489: return( NULL );
490: }
491:
492: OpenedFile = fopen( FileName, "r" );
493: if( NULL == OpenedFile )
494: {
495: rsyserr(FLOG, errno, "unable to open configuration file \"%s\"",
496: FileName);
497: }
498:
499: return( OpenedFile );
500: } /* OpenConfFile */
501:
502: BOOL pm_process( char *FileName,
503: BOOL (*sfunc)(char *),
504: BOOL (*pfunc)(char *, char *) )
505: /* ------------------------------------------------------------------------ **
506: * Process the named parameter file.
507: *
508: * Input: FileName - The pathname of the parameter file to be opened.
509: * sfunc - A pointer to a function that will be called when
510: * a section name is discovered.
511: * pfunc - A pointer to a function that will be called when
512: * a parameter name and value are discovered.
513: *
514: * Output: TRUE if the file was successfully parsed, else FALSE.
515: *
516: * ------------------------------------------------------------------------ **
517: */
518: {
519: int result;
520: FILE *InFile;
521: char *func = "params.c:pm_process() -";
522:
523: InFile = OpenConfFile( FileName ); /* Open the config file. */
524: if( NULL == InFile )
525: return( False );
526:
527: if( NULL != bufr ) /* If we already have a buffer */
528: result = Parse( InFile, sfunc, pfunc ); /* (recursive call), then just */
529: /* use it. */
530:
531: else /* If we don't have a buffer */
532: { /* allocate one, then parse, */
533: bSize = BUFR_INC; /* then free. */
534: bufr = new_array( char, bSize );
535: if( NULL == bufr )
536: {
537: rprintf(FLOG, "%s memory allocation failure.\n", func);
538: fclose(InFile);
539: return( False );
540: }
541: result = Parse( InFile, sfunc, pfunc );
542: free( bufr );
543: bufr = NULL;
544: bSize = 0;
545: }
546:
547: fclose(InFile);
548:
549: if( !result ) /* Generic failure. */
550: {
551: rprintf(FLOG, "%s Failed. Error returned from params.c:parse().\n", func);
552: return( False );
553: }
554:
555: return( True ); /* Generic success. */
556: } /* pm_process */
557:
558: /* -------------------------------------------------------------------------- */
559:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to params.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync