Initial import from FreeBSD RELENG_4:
[dragonfly.git] / libexec / rbootd / parseconf.c
1 /*
2  * Copyright (c) 1988, 1992 The University of Utah and the Center
3  *      for Software Science (CSS).
4  * Copyright (c) 1992, 1993
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * the Center for Software Science of the University of Utah Computer
9  * Science Department.  CSS requests users of this software to return
10  * to css-dist@cs.utah.edu any improvements that they make and grant
11  * CSS redistribution rights.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. All advertising materials mentioning features or use of this software
22  *    must display the following acknowledgement:
23  *      This product includes software developed by the University of
24  *      California, Berkeley and its contributors.
25  * 4. Neither the name of the University nor the names of its contributors
26  *    may be used to endorse or promote products derived from this software
27  *    without specific prior written permission.
28  *
29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39  * SUCH DAMAGE.
40  *
41  *      from: @(#)parseconf.c   8.1 (Berkeley) 6/4/93
42  *
43  * From: Utah Hdr: parseconf.c 3.1 92/07/06
44  * Author: Jeff Forys, University of Utah CSS
45  */
46
47 #ifndef lint
48 #if 0
49 static const char sccsid[] = "@(#)parseconf.c   8.1 (Berkeley) 6/4/93";
50 #endif
51 static const char rcsid[] =
52   "$FreeBSD: src/libexec/rbootd/parseconf.c,v 1.9.2.1 2001/03/05 11:17:52 kris Exp $";
53 #endif /* not lint */
54
55 #include <sys/param.h>
56 #include <sys/stat.h>
57 #include <sys/time.h>
58
59 #include <ctype.h>
60 #include <dirent.h>
61 #include <fcntl.h>
62 #include <signal.h>
63 #include <stdio.h>
64 #include <stdlib.h>
65 #include <string.h>
66 #include <syslog.h>
67 #include "defs.h"
68
69 /*
70 **  ParseConfig -- parse the config file into linked list of clients.
71 **
72 **      Parameters:
73 **              None.
74 **
75 **      Returns:
76 **              1 on success, 0 otherwise.
77 **
78 **      Side Effects:
79 **              - Linked list of clients will be (re)allocated.
80 **
81 **      Warnings:
82 **              - GetBootFiles() must be called before this routine
83 **                to create a linked list of default boot files.
84 */
85 int
86 ParseConfig()
87 {
88         FILE *fp;
89         CLIENT *client;
90         u_int8_t *addr;
91         char line[C_LINELEN];
92         char *cp, *bcp;
93         int i, j;
94         int omask, linecnt = 0;
95
96         if (BootAny)                            /* ignore config file */
97                 return(1);
98
99         FreeClients();                          /* delete old list of clients */
100
101         if ((fp = fopen(ConfigFile, "r")) == NULL) {
102                 syslog(LOG_ERR, "ParseConfig: can't open config file (%s)",
103                        ConfigFile);
104                 return(0);
105         }
106
107         /*
108          *  We've got to block SIGHUP to prevent reconfiguration while
109          *  dealing with the linked list of Clients.  This can be done
110          *  when actually linking the new client into the list, but
111          *  this could have unexpected results if the server was HUP'd
112          *  whilst reconfiguring.  Hence, it is done here.
113          */
114         omask = sigblock(sigmask(SIGHUP));
115
116         /*
117          *  GETSTR positions `bcp' at the start of the current token,
118          *  and null terminates it.  `cp' is positioned at the start
119          *  of the next token.  spaces & commas are separators.
120          */
121 #define GETSTR  while (isspace(*cp) || *cp == ',') cp++;        \
122                 bcp = cp;                                       \
123                 while (*cp && *cp!=',' && !isspace(*cp)) cp++;  \
124                 if (*cp) *cp++ = '\0'
125
126         /*
127          *  For each line, parse it into a new CLIENT struct.
128          */
129         while (fgets(line, C_LINELEN, fp) != NULL) {
130                 linecnt++;                              /* line counter */
131
132                 if (*line == '\0' || *line == '#')      /* ignore comment */
133                         continue;
134
135                 if ((cp = strchr(line,'#')) != NULL)    /* trash comments */
136                         *cp = '\0';
137
138                 cp = line;                              /* init `cp' */
139                 GETSTR;                                 /* get RMP addr */
140                 if (bcp == cp)                          /* all delimiters */
141                         continue;
142
143                 /*
144                  *  Get an RMP address from a string.  Abort on failure.
145                  */
146                 if ((addr = ParseAddr(bcp)) == NULL) {
147                         syslog(LOG_ERR,
148                                "ParseConfig: line %d: cant parse <%s>",
149                                linecnt, bcp);
150                         continue;
151                 }
152
153                 if ((client = NewClient(addr)) == NULL) /* alloc new client */
154                         continue;
155
156                 GETSTR;                                 /* get first file */
157
158                 /*
159                  *  If no boot files are spec'd, use the default list.
160                  *  Otherwise, validate each file (`bcp') against the
161                  *  list of boot-able files.
162                  */
163                 i = 0;
164                 if (bcp == cp)                          /* no files spec'd */
165                         for (; i < C_MAXFILE && BootFiles[i] != NULL; i++)
166                                 client->files[i] = BootFiles[i];
167                 else {
168                         do {
169                                 /*
170                                  *  For each boot file spec'd, make sure it's
171                                  *  in our list.  If so, include a pointer to
172                                  *  it in the CLIENT's list of boot files.
173                                  */
174                                 for (j = 0; ; j++) {
175                                         if (j==C_MAXFILE||BootFiles[j]==NULL) {
176                                                 syslog(LOG_ERR, "ParseConfig: line %d: no boot file (%s)",
177                                                        linecnt, bcp);
178                                                 break;
179                                         }
180                                         if (STREQN(BootFiles[j], bcp)) {
181                                                 if (i < C_MAXFILE)
182                                                         client->files[i++] =
183                                                             BootFiles[j];
184                                                 else
185                                                         syslog(LOG_ERR, "ParseConfig: line %d: too many boot files (%s)",
186                                                                linecnt, bcp);
187                                                 break;
188                                         }
189                                 }
190                                 GETSTR;                 /* get next file */
191                         } while (bcp != cp);
192
193                         /*
194                          *  Restricted list of boot files were spec'd,
195                          *  however, none of them were found.  Since we
196                          *  apparently cant let them boot "just anything",
197                          *  the entire record is invalidated.
198                          */
199                         if (i == 0) {
200                                 FreeClient(client);
201                                 continue;
202                         }
203                 }
204
205                 /*
206                  *  Link this client into the linked list of clients.
207                  *  SIGHUP has already been blocked.
208                  */
209                 if (Clients)
210                         client->next = Clients;
211                 Clients = client;
212         }
213
214         (void) fclose(fp);                              /* close config file */
215
216         (void) sigsetmask(omask);                       /* reset signal mask */
217
218         return(1);                                      /* return success */
219 }
220
221 /*
222 **  ParseAddr -- Parse a string containing an RMP address.
223 **
224 **      This routine is fairly liberal at parsing an RMP address.  The
225 **      address must contain 6 octets consisting of between 0 and 2 hex
226 **      chars (upper/lower case) separated by colons.  If two colons are
227 **      together (e.g. "::", the octet between them is recorded as being
228 **      zero.  Hence, the following addrs are all valid and parse to the
229 **      same thing:
230 **
231 **              08:00:09:00:66:ad       8::9:0:66:AD    8::9::66:aD
232 **
233 **      For clarity, an RMP address is really an Ethernet address, but
234 **      since the HP boot code uses IEEE 802.3, it's really an IEEE
235 **      802.3 address.  Of course, all of these are identical.
236 **
237 **      Parameters:
238 **              str - string representation of an RMP address.
239 **
240 **      Returns:
241 **              pointer to a static array of RMP_ADDRLEN bytes.
242 **
243 **      Side Effects:
244 **              None.
245 **
246 **      Warnings:
247 **              - The return value points to a static buffer; it must
248 **                be copied if it's to be saved.
249 */
250 u_int8_t *
251 ParseAddr(str)
252         char *str;
253 {
254         static u_int8_t addr[RMP_ADDRLEN];
255         char *cp;
256         unsigned i;
257         int part, subpart;
258
259         memset((char *)&addr[0], 0, RMP_ADDRLEN);       /* zero static buffer */
260
261         part = subpart = 0;
262         for (cp = str; *cp; cp++) {
263                 /*
264                  *  A colon (`:') must be used to delimit each octet.
265                  */
266                 if (*cp == ':') {
267                         if (++part == RMP_ADDRLEN)      /* too many parts */
268                                 return(NULL);
269                         subpart = 0;
270                         continue;
271                 }
272
273                 /*
274                  *  Convert hex character to an integer.
275                  */
276                 if (isdigit(*cp))
277                         i = *cp - '0';
278                 else {
279                         i = (isupper(*cp)? tolower(*cp): *cp) - 'a' + 10;
280                         if (i < 10 || i > 15)           /* not a hex char */
281                                 return(NULL);
282                 }
283
284                 if (subpart++) {
285                         if (subpart > 2)                /* too many hex chars */
286                                 return(NULL);
287                         addr[part] <<= 4;
288                 }
289                 addr[part] |= i;
290         }
291
292         if (part != (RMP_ADDRLEN-1))                    /* too few parts */
293                 return(NULL);
294
295         return(&addr[0]);
296 }
297
298 /*
299 **  GetBootFiles -- record list of files in current (boot) directory.
300 **
301 **      Parameters:
302 **              None.
303 **
304 **      Returns:
305 **              Number of boot files on success, 0 on failure.
306 **
307 **      Side Effects:
308 **              Strings in `BootFiles' are freed/allocated.
309 **
310 **      Warnings:
311 **              - After this routine is called, ParseConfig() must be
312 **                called to re-order it's list of boot file pointers.
313 */
314 int
315 GetBootFiles()
316 {
317         DIR *dfd;
318         struct stat statb;
319         struct dirent *dp;
320         int i;
321
322         /*
323          *  Free the current list of boot files.
324          */
325         for (i = 0; i < C_MAXFILE && BootFiles[i] != NULL; i++) {
326                 FreeStr(BootFiles[i]);
327                 BootFiles[i] = NULL;
328         }
329
330         /*
331          *  Open current directory to read boot file names.
332          */
333         if ((dfd = opendir(".")) == NULL) {     /* open BootDir */
334                 syslog(LOG_ERR, "GetBootFiles: can't open directory (%s)\n",
335                        BootDir);
336                 return(0);
337         }
338
339         /*
340          *  Read each boot file name and allocate space for it in the
341          *  list of boot files (BootFiles).  All boot files read after
342          *  C_MAXFILE will be ignored.
343          */
344         i = 0;
345         for (dp = readdir(dfd); dp != NULL; dp = readdir(dfd)) {
346                 if (stat(dp->d_name, &statb) < 0 ||
347                     (statb.st_mode & S_IFMT) != S_IFREG)
348                         continue;
349                 if (i == C_MAXFILE)
350                         syslog(LOG_ERR,
351                                "GetBootFiles: too many boot files (%s ignored)",
352                                dp->d_name);
353                 else if ((BootFiles[i] = NewStr(dp->d_name)) != NULL)
354                         i++;
355         }
356
357         (void) closedir(dfd);                   /* close BootDir */
358
359         if (i == 0)                             /* cant find any boot files */
360                 syslog(LOG_ERR, "GetBootFiles: no boot files (%s)\n", BootDir);
361
362         return(i);
363 }