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