C语言--配置文件解析

/*****************************************************************************

file like this :

[section]

parameter = value

*****************************************************************************

*/

#include <stdio.h>

#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>


#ifdef WIN32
#include <io.h>
#define open _open
#define read _read
#define close _close
#endif
#ifndef WIN32
#include <unistd.h>
#endif


#define BUFR_INC 1024
#define False (0)
#define True (1)
#define Auto (2)
#ifndef _BOOL
typedef int BOOL;
#define _BOOL   /* So we don't typedef BOOL again in vfs.h */
#endif


#ifndef SAFE_FREE
#define SAFE_FREE(x) do { if ((x) != NULL) {free((x)); (x)=NULL;} } while(0)
#endif


extern int global_is_multibyte_codepage;
extern int (*_skip_multibyte_char)(char c);
#define skip_multibyte_char(c) ((*_skip_multibyte_char)((c)))


#define get_character_len(x) 0
static char *bufr = NULL;
static int bSize = 0;


typedef struct {
char *buf;
char *p;
size_t size;
} myFILE;


static int mygetc(myFILE *f)
{
if (f->p >= f->buf+f->size) return EOF;
    /* be sure to return chars >127 as positive values */
return (int)( *(f->p++) & 0x00FF );
}


static void myfile_close(myFILE *f)
{
if (!f)
return;
SAFE_FREE(f->buf);
SAFE_FREE(f);
}


static int EatWhitespace( myFILE *InFile )
{
   int c;
   for( c = mygetc( InFile ); isspace( c ) && ('\n' != c); c = mygetc( InFile ) )
    ;
   return( c );
} /* EatWhitespace */


static int EatComment( myFILE *InFile )
{
   int c;
   for( c = mygetc( InFile ); ('\n'!=c) && (EOF!=c) && (c>0); c = mygetc( InFile ) )
   ;
   return( c );
} /* EatComment */


static int Continuation( char *line, int pos )
{
   int pos2 = 0;
   pos--;
   while( (pos >= 0) && isspace((int)line[pos]) )
    pos--;
   /* we should recognize if `\` is part of a multibyte character or not. */
   while(pos2 <= pos) {
       size_t skip = 0;
       skip = get_character_len(line[pos2]);
       if (skip) {
        pos2 += skip;
       } else if (pos == pos2) {
        return( ((pos >= 0) && ('\\' == line[pos])) ? pos : -1 );
       } else {
        pos2++;
       }
   }
   return (-1);
}


void *Realloc(void *p,size_t size)
{
   void *ret=NULL;
    if (size == 0) 
    {
       if (p) 
            free(p);
       //DEBUG(5,("Realloc asked for 0 bytes\n"));
       return NULL;
    }
   if (!p)
    ret = (void *)malloc(size);
   else
    ret = (void *)realloc(p,size);
    if (!ret)
        printf("Memory allocation error: failed to expand to %d bytes\n",(int)size);
   return(ret);
}
 /* ------------------------------------------------------------------------ **
 * Scan a section name, and pass the name to function sfunc().
 *
 * Input: InFile - Input source.
 * sfunc - Pointer to the function to be called if the section
 * name is successfully read.
 *
 * Output: True if the section name was read and True was returned from
 * <sfunc>. False if <sfunc> failed or if a lexical error was
 * encountered.
 *
* ------------------------------------------------------------------------ **
 */
static BOOL Section( myFILE *InFile, BOOL (*sfunc)(char *) )
{
   int c;
   int i;
   int end;
   char *func = "params.c:Section() -";
   i = 0;       /* <i> is the offset of the next free byte in bufr[] and */
   end = 0;         /* <end> is the current "end of string" offset. In most */
        /* cases these will be the same, but if the last */
        /* character written to bufr[] is a space, then <end> */
        /* will be one less than <i>. */
   c = EatWhitespace( InFile ); /* We've already got the '['. Scan */
    /* past initial white space. */
   while( (EOF != c) && (c > 0) )
   {
       /* Check that the buffer is big enough for the next character. */
       if( i > (bSize - 2) )
       {
           char *tb;
           tb = (char*)Realloc( bufr, bSize +BUFR_INC );
           if( NULL == tb )
           {
            //DEBUG(0, ("%s Memory re-allocation failure.", func) );
             return( False );
           }
           bufr = tb;
           bSize += BUFR_INC;
       }
       /* Handle a single character. */
       switch( c )
       {
           case ']': /* Found the closing bracket. */
               bufr[end] = '\0';
               if( 0 == end ) /* Don't allow an empty name. */
               {
                //DEBUG(0, ("%s Empty section name in configuration file.\n", func ));
                return( False );
               }
               //if( !sfunc( unix_to_dos(bufr) ) ) /* Got a valid name. Deal with it. */
               if( !sfunc( bufr ) ) /* Got a valid name. Deal with it. */
                return( False );
               (void)EatComment( InFile ); /* Finish off the line. */
               return( True );
           case '\n': /* Got newline before closing ']'. */
               i = Continuation( bufr, i ); /* Check for line continuation. */
               if( i < 0 )
               {
                   bufr[end] = '\0';
                   //DEBUG(0, ("%s Badly formed line in configuration file: %s\n",func, bufr ));
                   return( False );
               }
               end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
               c = mygetc( InFile ); /* Continue with next line. */
               break;
           default: /* All else are a valid name chars. */
               if( isspace( c ) ) /* One space per whitespace region. */
               {
                   bufr[end] = ' ';
                   i = end + 1;
                   c = EatWhitespace( InFile );
               }
               else /* All others copy verbatim. */
               {
                   bufr[i++] = c;
                   end = i;
                   c = mygetc( InFile );
               }
       }
   }
   /* We arrive here if we've met the EOF before the closing bracket. */
   //DEBUG(0, ("%s Unexpected EOF in the configuration file: %s\n", func, bufr ));
   return( False );
} /* Section */


static BOOL Parameter( myFILE *InFile, BOOL (*pfunc)(char *, char *), int c )
 {
   int i = 0; /* Position within bufr. */
   int end = 0; /* bufr[end] is current end-of-string. */
   int vstart = 0; /* Starting position of the parameter value. */
   char *func = "params.c:Parameter() -";
   /* Read the parameter name. */
   while( 0 == vstart ) /* Loop until we've found the start of the value. */
   {
       if( i > (bSize - 2) ) /* Ensure there's space for next char. */
       {
           char *tb;
           tb = (char*)Realloc( bufr, bSize + BUFR_INC );
           if( NULL == tb )
           {
               //DEBUG(0, ("%s Memory re-allocation failure.", func) );
               return( False );
           }
           bufr = tb;
           bSize += BUFR_INC;
       }
       switch( c )
       {
            case '=': /* Equal sign marks end of param name. */
                if( 0 == end ) /* Don't allow an empty name. */
                {
                        //DEBUG(0, ("%s Invalid parameter name in config. file.\n", func ));
                       return( False );
                    }
                    bufr[end++] = '\0'; /* Mark end of string & advance. */
                    i = end; /* New string starts here. */
                    vstart = end; /* New string is parameter value. */
                    bufr[i] = '\0'; /* New string is nul, for now. */
                    break;
            case '\n': /* Find continuation char, else error. */
                   i = Continuation( bufr, i );
                   if( i < 0 )
                   {
                        bufr[end] = '\0';
                     //DEBUG(1,("%s Ignoring badly formed line in configuration file: %s\n",func, bufr ));
                    return( True );
                   }
                   end = ( (i > 0) && (' ' == bufr[i - 1]) ) ? (i - 1) : (i);
                   c = mygetc( InFile ); /* Read past eoln. */
                   break;
            case '\0': /* Shouldn't have EOF within param name. */
            case EOF:
                   bufr[i] = '\0';
                   //DEBUG(1,("%s Unexpected end-of-file at: %s\n", func, bufr ));
                   return( True );
            default:
                   if( isspace( c ) ) /* One ' ' per whitespace region. */
                   {
                       bufr[end] = ' ';
                       i = end + 1;
                       c = EatWhitespace( InFile );
                   }
                   else /* All others verbatim. */
                   {
                       bufr[i++] = c;
                       end = i;
                       c = mygetc( InFile );
                   }
       }
   }
        /* Now parse the value. */
   c = EatWhitespace( InFile ); /* Again, trim leading whitespace. */
   while( (EOF !=c) && (c > 0) )
   {
       if( i > (bSize - 2) ) /* Make sure there's enough room. */
       {
           bSize += BUFR_INC;
           bufr = (char*)Realloc( bufr, bSize );
           if( NULL == bufr )
           {
            //DEBUG(0, ("%s Memory re-allocation failure.", func) );
            return( False );
           }
       }
       switch( c )
       {
           case '\r': /* Explicitly remove '\r' because the older */
                c = mygetc( InFile ); /* version called fgets_slash() which also */
                break; /* removes them. */
           case '\n': /* Marks end of value unless there's a '\'. */
                i = Continuation( bufr, i );
                if( i < 0 )
                    c = 0;
                else
                {
                    for( end = i; (end >= 0) && isspace((int)bufr[end]); end-- );
                    c = mygetc( InFile );
                }
                break;
            default: /* All others verbatim. Note that spaces do */
                   bufr[i++] = c; /* not advance <end>. This allows trimming */
                   if( !isspace( c ) ) /* of whitespace at the end of the line. */
                   end = i;
                   c = mygetc( InFile );
                   break;
       }
   }
   bufr[end] = '\0'; /* End of value. */
   return( pfunc( bufr, &bufr[vstart] ) ); /* Pass name & value to pfunc(). */
} /* Parameter */


static BOOL Parse( myFILE *InFile,BOOL (*sfunc)(char *),BOOL (*pfunc)(char *, char *) )
{
   int c;
   c = EatWhitespace( InFile );
   while( (EOF != c) && (c > 0) )
   {
       switch( c )
       {
           case '\n': /* Blank line. */
                c = EatWhitespace( InFile );
                break;
           case ';': /* Comment line. */
           case '#':
                c = EatComment( InFile );
                break;
           case '[': /* Section Header. */
                if( !Section( InFile, sfunc ) )
                    return( False );
                c = EatWhitespace( InFile );
                break;
           case '\\': /* Bogus backslash. */
                c = EatWhitespace( InFile );
                break;
           default: /* Parameter line. */
                if( !Parameter( InFile, pfunc, c ) )
                    return( False );
                c = EatWhitespace( InFile );
                break;
       }
   }
   return( True );
} /* Parse */


/****************************************************************************
　　load a file into memory from a fd.
****************************************************************************/ 
char *fd_load(int fd, size_t *size)
{ 
struct stat sbuf;
char *p;
if (fstat(fd, &sbuf) != 0) 
        return NULL;
p = (char *)malloc(sbuf.st_size+1);
if (!p) 
        return NULL;
if (read(fd, p, sbuf.st_size) != sbuf.st_size) {
SAFE_FREE(p);
return NULL;
}
p[sbuf.st_size] = 0;
if (size) 
        *size = sbuf.st_size;
return p;
}


/****************************************************************************
　　load a file into memory
  ****************************************************************************/
char *file_load(char *fname, size_t *size)
{
int fd;
char *p;
if (!fname || !*fname) 
        return NULL;
fd = open( fname, O_RDONLY );
if (fd == -1) 
        return NULL;
p = fd_load(fd, size);
    close(fd);
return p;
}


static myFILE *OpenConfFile( char *FileName )
{
   char *func = "params.c:OpenConfFile() -";
        //extern BOOL in_client;
        //int lvl = in_client?1:0;
   myFILE *ret;
   ret = (myFILE *)malloc(sizeof(*ret));
   if (!ret) 
        return NULL;
   ret->buf = file_load(FileName, &ret->size);
   if( NULL == ret->buf )
   {
       //DEBUG( lvl,
       // ("%s Unable to open configuration file \"%s\":\n\t%s\n",
       // func, FileName, strerror(errno)) );
       SAFE_FREE(ret);
       return NULL;
   }
   ret->p = ret->buf;
   return( ret );
} /* OpenConfFile */


BOOL pm_process( char *FileName,BOOL (*sfunc)(char *),BOOL (*pfunc)(char *, char *) )
{
   int result;
   myFILE *InFile;
   char *func = "params.c:pm_process() -";
   InFile = OpenConfFile( FileName ); /* Open the config file. */
   if( NULL == InFile )
    return( False );
        //DEBUG( 3, ("%s Processing configuration file \"%s\"\n", func, FileName) );
   if( NULL != bufr ) /* If we already have a buffer */
    result = Parse( InFile, sfunc, pfunc ); /* (recursive call), then just */
    /* use it. */
   else     /* If we don't have a buffer */
   {        /* allocate one, then parse, */
       bSize = BUFR_INC; /* then free. */
       bufr = (char *)malloc( bSize );
       if( NULL == bufr )
       {
           //DEBUG(0,("%s memory allocation failure.\n", func));
           myfile_close(InFile);
           return( False );
       }
       result = Parse( InFile, sfunc, pfunc );
       SAFE_FREE( bufr );
       bufr = NULL;
       bSize = 0;
   }
   myfile_close(InFile);
   if( !result ) /* Generic failure. */
   {
        //DEBUG(0,("%s Failed. Error returned from params.c:parse().\n", func));
     return( False );
   }
   return( True ); /* Generic success. */
} /* pm_process */
BOOL section(char *s){
  printf("[%s]\n",s);
  return True;
}
BOOL parameter(char *p,char*v){
    printf("\t %s = %s \n",p,v);
    return True;
}
int main(int argc,char*argv[])
{
    char * filename="/etc/samba/smb.conf";
    pm_process(filename,section,parameter);


}