Main Page   Modules   Data Structures   File List   Data Fields   Globals   Related Pages  

fileconf.c

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 1987, 1993, 1994
00003  *      The Regents of the University of California.  All rights reserved.
00004  *
00005  * Redistribution and use in source and binary forms, with or without
00006  * modification, are permitted provided that the following conditions
00007  * are met:
00008  * 1. Redistributions of source code must retain the above copyright
00009  *    notice, this list of conditions and the following disclaimer.
00010  * 2. Redistributions in binary form must reproduce the above copyright
00011  *    notice, this list of conditions and the following disclaimer in the
00012  *    documentation and/or other materials provided with the distribution.
00013  * 3. All advertising materials mentioning features or use of this software
00014  *    must display the following acknowledgement:
00015  *      This product includes software developed by the University of
00016  *      California, Berkeley and its contributors.
00017  * 4. Neither the name of the University nor the names of its contributors
00018  *    may be used to endorse or promote products derived from this software
00019  *    without specific prior written permission.
00020  *
00021  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
00022  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00023  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00024  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
00025  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00026  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
00027  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
00028  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00029  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
00030  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00031  * SUCH DAMAGE.
00032  */
00033 
00034 
00035 #include <stdio.h>
00036 #include <string.h>
00037 #include <signal.h>
00038 #include <pcap.h>       // for PCAP_ERRBUF_SIZE
00039 #include "rpcapd.h"
00040 #include "pcap-remote.h"
00041 #include "sockutils.h"  // for SOCK_ASSERT
00042 
00043 
00044 extern char hostlist[MAX_HOST_LIST + 1];        
00045 extern struct active_pars activelist[MAX_ACTIVE_LIST];      
00046 extern int nullAuthAllowed;                 
00047 extern char loadfile[MAX_LINE + 1];         
00048 
00049 
00050 
00051 int strrem(char *string, char chr);
00052 
00053 
00054 
00055 void fileconf_read(int sign)
00056 {
00057 FILE *fp;
00058 char msg[PCAP_ERRBUF_SIZE + 1];
00059 int i;
00060 
00061 #ifndef WIN32
00062     signal(SIGHUP, fileconf_read);
00063 #endif
00064 
00065     if ((fp= fopen(loadfile, "r") ) != NULL)
00066     {
00067     char line[MAX_LINE + 1];
00068     char *ptr;
00069 
00070         hostlist[0]= 0;
00071         i= 0;
00072 
00073         while ( fgets(line, MAX_LINE, fp) != NULL )
00074         {
00075             if (line[0] == '\n') continue;  // Blank line
00076             if (line[0] == '\r') continue;  // Blank line
00077             if (line[0] == '#') continue;   // Comment
00078 
00079             if ( (ptr= strstr(line, "ActiveClient")) )
00080             {
00081             char *address, *port;
00082 
00083                 ptr= strchr(ptr, '=') + 1;
00084                 address= strtok(ptr, RPCAP_HOSTLIST_SEP);
00085 
00086                 if ( (address != NULL) && (i < MAX_ACTIVE_LIST) )
00087                 {
00088                     port = strtok(NULL, RPCAP_HOSTLIST_SEP);
00089                     snprintf(activelist[i].address, MAX_LINE, address);
00090 
00091                     if (strcmp(port, "DEFAULT") == 0) // the user choose a custom port
00092                         snprintf(activelist[i].port, MAX_LINE, RPCAP_DEFAULT_NETPORT_ACTIVE);
00093                     else
00094                         snprintf(activelist[i].port, MAX_LINE, port);
00095 
00096                     activelist[i].address[MAX_LINE] = 0;
00097                     activelist[i].port[MAX_LINE] = 0;
00098                 }
00099                 else
00100                     SOCK_ASSERT("Only MAX_ACTIVE_LIST active connections are currently supported.", 1);
00101 
00102                 i++;
00103                 continue;
00104             }
00105 
00106             if ( (ptr= strstr(line, "PassiveClient")) )
00107             {
00108                 ptr= strchr(ptr, '=') + 1;
00109                 strncat(hostlist, ptr, MAX_HOST_LIST);
00110                 strncat(hostlist, ",", MAX_HOST_LIST);
00111                 continue;
00112             }
00113 
00114             if ( (ptr= strstr(line, "NullAuthPermit")) )
00115             {
00116                 ptr= strstr(ptr, "YES");
00117                 if (ptr)
00118                     nullAuthAllowed= 1;
00119                 else
00120                     nullAuthAllowed= 0;
00121                 continue;
00122             }
00123         }
00124 
00125         // clear the remaining fields of the active list 
00126         while (i < MAX_ACTIVE_LIST)
00127         {
00128             activelist[i].address[0] = 0;
00129             activelist[i].port[0] = 0;
00130             i++;
00131         }
00132 
00133         // Remove all '\n' and '\r' from the strings
00134         strrem(hostlist, '\r');
00135         strrem(hostlist, '\n');
00136 
00137         snprintf(msg, PCAP_ERRBUF_SIZE, "New passive host list: %s\n\n", hostlist);
00138         SOCK_ASSERT(msg, 1);
00139         fclose(fp);
00140     }
00141 }
00142 
00143 
00144 
00145 int fileconf_save(const char *savefile)
00146 {
00147 FILE *fp;
00148 
00149     if ((fp= fopen(savefile, "w") ) != NULL)
00150     {
00151     char *token; /*, *port;*/                   // temp, needed to separate items into the hostlist
00152     char temphostlist[MAX_HOST_LIST + 1];
00153     int i= 0;
00154 
00155         fprintf(fp, "# Configuration file help.\n\n");
00156 
00157         // Save list of clients which are allowed to connect to us in passive mode
00158         fprintf(fp, "# Hosts which are allowed to connect to this server (passive mode)\n");
00159         fprintf(fp, "# Format: PassiveClient = <name or address>\n\n");
00160 
00161         strncpy(temphostlist, hostlist, MAX_HOST_LIST);
00162         temphostlist[MAX_HOST_LIST]= 0;
00163     
00164         token= strtok(temphostlist, RPCAP_HOSTLIST_SEP);
00165         while( token != NULL )
00166         {
00167             fprintf(fp, "PassiveClient = %s\n", token);
00168             token = strtok(NULL, RPCAP_HOSTLIST_SEP);
00169         }
00170 
00171 
00172         // Save list of clients which are allowed to connect to us in active mode
00173         fprintf(fp, "\n\n");
00174         fprintf(fp, "# Hosts to which this server is trying to connect to (active mode)\n");
00175         fprintf(fp, "# Format: ActiveClient = <name or address>, <port | DEFAULT>\n\n");
00176 
00177 
00178         while ( (activelist[i].address[0] != 0) && (i < MAX_ACTIVE_LIST) )
00179         {
00180             fprintf(fp, "ActiveClient = %s, %s\n", activelist[i].address, activelist[i].port);
00181             i++;
00182         }
00183 
00184         // Save if we want to permit NULL authentication
00185         fprintf(fp, "\n\n");
00186         fprintf(fp, "# Permit NULL authentication: YES or NOT\n\n");
00187 
00188         if (nullAuthAllowed)
00189             fprintf(fp, "NullAuthPermit = YES\n");
00190         else
00191             fprintf(fp, "NullAuthPermit = NO\n");
00192 
00193         fclose(fp);
00194         return 0;
00195     }
00196     else
00197     {
00198         return -1;
00199     }
00200 
00201 }
00202 
00203 
00204 
00205 int strrem(char *string, char chr)
00206 {
00207 char *pos;
00208 int num= 0;
00209 int len, i;
00210 
00211     while ( (pos= strchr(string, chr) ) != NULL)
00212     {
00213         num++;
00214         len= strlen(pos);
00215         for (i=0; i<len; i++)
00216             pos[i]= pos[i+1];
00217     }
00218 
00219     return num;
00220 }

documentation. Copyright (c) 2002-2003 Politecnico di Torino. All rights reserved.