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
49static const char sccsid[] = "@(#)parseconf.c	8.1 (Berkeley) 6/4/93";
50#endif
51static const char rcsid[] =
52  "$FreeBSD$";
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*/
85int
86ParseConfig(void)
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: can't 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 can't 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*/
250u_int8_t *
251ParseAddr(char *str)
252{
253	static u_int8_t addr[RMP_ADDRLEN];
254	char *cp;
255	unsigned i;
256	int part, subpart;
257
258	memset((char *)&addr[0], 0, RMP_ADDRLEN);	/* zero static buffer */
259
260	part = subpart = 0;
261	for (cp = str; *cp; cp++) {
262		/*
263		 *  A colon (`:') must be used to delimit each octet.
264		 */
265		if (*cp == ':') {
266			if (++part == RMP_ADDRLEN)	/* too many parts */
267				return(NULL);
268			subpart = 0;
269			continue;
270		}
271
272		/*
273		 *  Convert hex character to an integer.
274		 */
275		if (isdigit(*cp))
276			i = *cp - '0';
277		else {
278			i = (isupper(*cp)? tolower(*cp): *cp) - 'a' + 10;
279			if (i < 10 || i > 15)		/* not a hex char */
280				return(NULL);
281		}
282
283		if (subpart++) {
284			if (subpart > 2)		/* too many hex chars */
285				return(NULL);
286			addr[part] <<= 4;
287		}
288		addr[part] |= i;
289	}
290
291	if (part != (RMP_ADDRLEN-1))			/* too few parts */
292		return(NULL);
293
294	return(&addr[0]);
295}
296
297/*
298**  GetBootFiles -- record list of files in current (boot) directory.
299**
300**	Parameters:
301**		None.
302**
303**	Returns:
304**		Number of boot files on success, 0 on failure.
305**
306**	Side Effects:
307**		Strings in `BootFiles' are freed/allocated.
308**
309**	Warnings:
310**		- After this routine is called, ParseConfig() must be
311**		  called to re-order it's list of boot file pointers.
312*/
313int
314GetBootFiles(void)
315{
316	DIR *dfd;
317	struct stat statb;
318	struct dirent *dp;
319	int i;
320
321	/*
322	 *  Free the current list of boot files.
323	 */
324	for (i = 0; i < C_MAXFILE && BootFiles[i] != NULL; i++) {
325		FreeStr(BootFiles[i]);
326		BootFiles[i] = NULL;
327	}
328
329	/*
330	 *  Open current directory to read boot file names.
331	 */
332	if ((dfd = opendir(".")) == NULL) {	/* open BootDir */
333		syslog(LOG_ERR, "GetBootFiles: can't open directory (%s)\n",
334		       BootDir);
335		return(0);
336	}
337
338	/*
339	 *  Read each boot file name and allocate space for it in the
340	 *  list of boot files (BootFiles).  All boot files read after
341	 *  C_MAXFILE will be ignored.
342	 */
343	i = 0;
344	for (dp = readdir(dfd); dp != NULL; dp = readdir(dfd)) {
345		if (stat(dp->d_name, &statb) < 0 ||
346		    (statb.st_mode & S_IFMT) != S_IFREG)
347			continue;
348		if (i == C_MAXFILE)
349			syslog(LOG_ERR,
350			       "GetBootFiles: too many boot files (%s ignored)",
351			       dp->d_name);
352		else if ((BootFiles[i] = NewStr(dp->d_name)) != NULL)
353			i++;
354	}
355
356	(void) closedir(dfd);			/* close BootDir */
357
358	if (i == 0)				/* can't find any boot files */
359		syslog(LOG_ERR, "GetBootFiles: no boot files (%s)\n", BootDir);
360
361	return(i);
362}
363