release/src/router/igmpproxy/src/confread.c

   1 /*
   2 **  igmpproxy - IGMP proxy based multicast router
   3 **  Copyright (C) 2005 Johnny Egeland <johnny@rlo.org>
   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 2 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
  16 **  along with this program; if not, write to the Free Software
  17 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 **
  19 **----------------------------------------------------------------------------
  20 **
  21 **  This software is derived work from the following software. The original
  22 **  source code has been modified from it's original state by the author
  23 **  of igmpproxy.
  24 **
  25 **  smcroute 0.92 - Copyright (C) 2001 Carsten Schill <carsten@cschill.de>
  26 **  - Licensed under the GNU General Public License, version 2
  27 **
  28 **  mrouted 3.9-beta3 - COPYRIGHT 1989 by The Board of Trustees of
  29 **  Leland Stanford Junior University.
  30 **  - Original license can be found in the Stanford.txt file.
  31 **
  32 */
  33 /**
  34 *   confread.c
  35 *
  36 *   Generic config file reader. Used to open a config file,
  37 *   and read the tokens from it. The parser is really simple,
  38 *   and does no backlogging. This means that no form of
  39 *   text escaping and qouting is currently supported.
  40 *   '#' chars are read as comments, and the comment lasts until
  41 *   a newline or EOF
  42 *
  43 */
  44
  45 #include "igmpproxy.h"
  46
  47 #define     READ_BUFFER_SIZE    512   // Inputbuffer size...
  48
  49 #ifndef MAX_TOKEN_LENGTH
  50   #define MAX_TOKEN_LENGTH  30     // Default max token length
  51 #endif
  52
  53 FILE            *confFilePtr;       // File handle pointer
  54 char            *iBuffer;           // Inputbuffer for reading...
  55 unsigned int    bufPtr;             // Buffer position pointer.
  56 unsigned int    readSize;           // Number of bytes in buffer after last read...
  57 char    cToken[MAX_TOKEN_LENGTH];   // Token buffer...
  58 short   validToken;
  59
  60 /**
  61 *   Opens config file specified by filename.
  62 */
  63 int openConfigFile(char *filename) {
  64
  65     // Set the buffer to null initially...
  66     iBuffer = NULL;
  67
  68     // Open the file for reading...
  69     confFilePtr = fopen(filename, "r");
  70
  71     // On error, return false
  72     if(confFilePtr == NULL) {
  73         return 0;
  74     }
  75
  76     // Allocate memory for inputbuffer...
  77     iBuffer = (char*) malloc( sizeof(char) * READ_BUFFER_SIZE );
  78
  79     if(iBuffer == NULL) {
  80         closeConfigFile();
  81         return 0;
  82     }
  83
  84     // Reset bufferpointer and readsize
  85     bufPtr = 0;
  86     readSize = 0;
  87
  88     return 1;
  89 }
  90
  91 /**
  92 *   Closes the currently open config file.
  93 */
  94 void closeConfigFile() {
  95     // Close the file.
  96     if(confFilePtr!=NULL) {
  97         fclose(confFilePtr);
  98     }
  99     // Free input buffer memory...
 100     if(iBuffer != NULL) {
 101         free(iBuffer);
 102     }
 103 }
 104
 105 /**
 106 *   Returns the next token from the configfile. The function
 107 *   return NULL if there are no more tokens in the file.
 108 */
 109 char *nextConfigToken() {
 110
 111     validToken = 0;
 112
 113     // If no file or buffer, return NULL
 114     if(confFilePtr == NULL || iBuffer == NULL) {
 115         return NULL;
 116     }
 117
 118     {
 119         unsigned int tokenPtr       = 0;
 120         unsigned short finished     = 0;
 121         unsigned short commentFound = 0;
 122
 123         // Outer buffer fill loop...
 124         while ( !finished ) {
 125             // If readpointer is at the end of the buffer, we should read next chunk...
 126             if(bufPtr == readSize) {
 127                 // Fill up the buffer...
 128                 readSize = fread (iBuffer, sizeof(char), READ_BUFFER_SIZE, confFilePtr);
 129                 bufPtr = 0;
 130
 131                 // If the readsize is 0, we should just return...
 132                 if(readSize == 0) {
 133                     return NULL;
 134                 }
 135             }
 136
 137             // Inner char loop...
 138             while ( bufPtr < readSize && !finished ) {
 139
 140                 //printf("Char %s", iBuffer[bufPtr]);
 141
 142                 // Break loop on \0
 143                 if(iBuffer[bufPtr] == '\0') {
 144                     break;
 145                 }
 146
 147                 if( commentFound ) {
 148                     if( iBuffer[bufPtr] == '\n' ) {
 149                         commentFound = 0;
 150                     }
 151                 } else {
 152
 153                     // Check current char...
 154                     switch(iBuffer[bufPtr]) {
 155                     case '#':
 156                         // Found a comment start...
 157                         commentFound = 1;
 158                         break;
 159
 160                     case '\n':
 161                     case '\r':
 162                     case '\t':
 163                     case ' ':
 164                         // Newline, CR, Tab and space are end of token, or ignored.
 165                         if(tokenPtr > 0) {
 166                             cToken[tokenPtr] = '\0';    // EOL
 167                             finished = 1;
 168                         }
 169                         break;
 170
 171                     default:
 172                         // Append char to token...
 173                         cToken[tokenPtr++] = iBuffer[bufPtr];
 174                         break;
 175                     }
 176
 177                 }
 178
 179                 // Check end of token buffer !!!
 180                 if(tokenPtr == MAX_TOKEN_LENGTH - 1) {
 181                     // Prevent buffer overrun...
 182                     cToken[tokenPtr] = '\0';
 183                     finished = 1;
 184                 }
 185
 186                 // Next char...
 187                 bufPtr++;
 188             }
 189             // If the readsize is less than buffersize, we assume EOF.
 190             if(readSize < READ_BUFFER_SIZE && bufPtr == readSize) {
 191                 if (tokenPtr > 0)
 192                     finished = 1;
 193                 else
 194                     return NULL;
 195             }
 196         }
 197         if(tokenPtr>0) {
 198             validToken = 1;
 199             return cToken;
 200         }
 201     }
 202     return NULL;
 203 }
 204
 205
 206 /**
 207 *   Returns the currently active token, or null
 208 *   if no tokens are availible.
 209 */
 210 char *getCurrentConfigToken() {
 211     return validToken ? cToken : NULL;
 212 }
 213