bfa0fee1bc291e7a484c6c1636285d31289546a5
[tinc] / src / conf.c
1 /*
2     conf.c -- configuration code
3     Copyright (C) 1998 Emphyrio,
4     Copyright (C) 1998,1999,2000 Ivo Timmermans <itimmermans@bigfoot.com>
5                             2000 Guus Sliepen <guus@sliepen.warande.net>
6                             2000 Cris van Pelt <tribbel@arise.dhs.org>
7
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
10     the Free Software Foundation; either version 2 of the License, or
11     (at your option) any later version.
12
13     This program is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17
18     You should have received a copy of the GNU General Public License
19     along with this program; if not, write to the Free Software
20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
22     $Id: conf.c,v 1.9.4.8 2000/08/09 14:02:15 guus Exp $
23 */
24
25
26 #include "config.h"
27
28 #include <ctype.h>
29 #include <errno.h>
30 #include <netdb.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #include <xalloc.h>
36
37 #include "conf.h"
38 #include "netutl.h" /* for strtoip */
39 #include <utils.h> /* for cp */
40
41 #include "system.h"
42
43 config_t *config;
44 int debug_lvl = 0;
45 int timeout = 0; /* seconds before timeout */
46 char *configfilename = NULL;
47
48 /* Will be set if HUP signal is received. It will be processed when it is safe. */
49 int sighup = 0;
50
51 typedef struct internal_config_t {
52   char *name;
53   enum which_t which;
54   int argtype;
55 } internal_config_t;
56
57 /*
58   These are all the possible configurable values
59 */
60 static internal_config_t hazahaza[] = {
61   { "AllowConnect", allowconnect,   TYPE_BOOL },   /* Is not used anywhere. Remove? */
62   { "ConnectTo",    upstreamip,     TYPE_NAME },
63   { "ConnectPort",  upstreamport,   TYPE_INT },
64   { "ListenPort",   listenport,     TYPE_INT },
65   { "MyOwnVPNIP",   myvpnip,        TYPE_IP },
66   { "MyVirtualIP",  myvpnip,        TYPE_IP },   /* an alias */
67   { "Passphrases",  passphrasesdir, TYPE_NAME },
68   { "PingTimeout",  pingtimeout,    TYPE_INT },
69   { "TapDevice",    tapdevice,      TYPE_NAME },
70   { "KeyExpire",    keyexpire,      TYPE_INT },
71   { "VpnMask",      vpnmask,        TYPE_IP },
72   { "Hostnames",    resolve_dns,    TYPE_BOOL },
73   { "IndirectData", indirectdata,   TYPE_BOOL },
74   { "TCPonly",      tcponly,        TYPE_BOOL },
75   { "Interface",    interface,      TYPE_NAME },
76   { "InterfaceIP",  interfaceip,    TYPE_IP },
77   { NULL, 0, 0 }
78 };
79
80 /*
81   Add given value to the list of configs cfg
82 */
83 config_t *
84 add_config_val(config_t **cfg, int argtype, char *val)
85 {
86   config_t *p, *r;
87   char *q;
88 cp
89   p = (config_t*)xmalloc(sizeof(*p));
90   p->data.val = 0;
91   
92   switch(argtype)
93     {
94     case TYPE_INT:
95       p->data.val = strtol(val, &q, 0);
96       if(q && *q)
97         p->data.val = 0;
98       break;
99     case TYPE_NAME:
100       p->data.ptr = xmalloc(strlen(val) + 1);
101       strcpy(p->data.ptr, val);
102       break;
103     case TYPE_IP:
104       p->data.ip = strtoip(val);
105       break;
106     case TYPE_BOOL:
107       if(!strcasecmp("yes", val))
108         p->data.val = stupid_true;
109       else if(!strcasecmp("no", val))
110         p->data.val = stupid_false;
111       else
112         p->data.val = 0;
113     }
114
115   p->argtype = argtype;
116
117   if(p->data.val)
118     {
119       if(*cfg)
120         {
121           r = *cfg;
122           while(r->next)
123             r = r->next;
124           r->next = p;
125         }
126       else
127         *cfg = p;
128       p->next = NULL;
129       return p;
130     }
131
132   free(p);
133 cp
134   return NULL;
135 }
136
137 /*
138   Get variable from a section in a configfile. returns -1 on failure.
139 */
140 int
141 readconfig(const char *fname, FILE *fp)
142 {
143   char *line, *temp_buf;
144   char *p, *q;
145   int i, lineno = 0;
146   config_t *cfg;
147 cp
148   line = (char *)xmalloc(80 * sizeof(char));
149   temp_buf = (char *)xmalloc(80 * sizeof(char));
150         
151   for(;;)
152     {
153       if(fgets(line, 80, fp) == NULL)
154         return 0;
155
156       while(!index(line, '\n'))
157         {
158           fgets(temp_buf, (strlen(line)+1) * 80, fp);
159           if(!temp_buf)
160             break;
161           strcat(line, temp_buf);
162           line = (char *)xrealloc(line, (strlen(line)+1) * sizeof(char));
163         }        
164       lineno++;
165
166       if((p = strtok(line, "\t\n\r =")) == NULL)
167         continue; /* no tokens on this line */
168
169       if(p[0] == '#')
170         continue; /* comment: ignore */
171
172       for(i = 0; hazahaza[i].name != NULL; i++)
173         if(!strcasecmp(hazahaza[i].name, p))
174           break;
175
176       if(!hazahaza[i].name)
177         {
178           fprintf(stderr, _("%s: %d: Invalid variable name `%s'.\n"),
179                   fname, lineno, p);
180           return -1;
181         }
182
183       if(((q = strtok(NULL, "\t\n\r =")) == NULL) || q[0] == '#')
184         {
185           fprintf(stderr, _("%s: %d: No value given for `%s'.\n"),
186                   fname, lineno, hazahaza[i].name);
187           return -1;
188         }
189
190       cfg = add_config_val(&config, hazahaza[i].argtype, q);
191       if(cfg == NULL)
192         {
193           fprintf(stderr, _("%s: %d: Invalid value `%s' for variable `%s'.\n"),
194                   fname, lineno, q, hazahaza[i].name);
195           return -1;
196         }
197
198       cfg->which = hazahaza[i].which;
199       if(!config)
200         config = cfg;
201     }
202 cp
203   return 0;
204 }
205
206 /*
207   wrapper function for readconfig
208 */
209 int
210 read_config_file(const char *fname)
211 {
212   int err;
213   FILE *fp;
214 cp
215   if((fp = fopen (fname, "r")) == NULL)
216     {
217       fprintf(stderr, _("Could not open %s: %s\n"), fname, sys_errlist[errno]);
218       return 1;
219     }
220
221   err = readconfig(fname, fp);
222   fclose (fp);
223 cp
224   return err;
225 }
226
227 /*
228   Look up the value of the config option type
229 */
230 const config_t *
231 get_config_val(which_t type)
232 {
233   config_t *p;
234 cp
235   for(p = config; p != NULL; p = p->next)
236     if(p->which == type)
237       return p;
238 cp
239   /* Not found */
240   return NULL;
241 }
242
243 /*
244   Support for multiple config lines.
245   Index is used to get a specific value, 0 being the first, 1 the second etc.
246 */
247 const config_t *
248 get_next_config_val(which_t type, int index)
249 {
250   config_t *p;
251 cp  
252   for(p = config; p != NULL; p = p->next)
253     if(p->which == type)
254       if(--index < 0)
255         return p;
256 cp  
257   /* Not found */
258   return NULL;
259 }
260
261 /*
262   Remove the complete configuration tree.
263 */
264 void clear_config()
265 {
266   config_t *p, *next;
267 cp
268   for(p = config; p != NULL; p = next)
269     {
270       next = p->next;
271       if(p->data.ptr && (p->argtype == TYPE_NAME))
272         {
273           free(p->data.ptr);
274         }
275       free(p);
276     }
277   config = NULL;
278 cp
279 }