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$";
  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(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: 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(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 */
 313 int
 314 GetBootFiles(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)                             /* cant find any boot files */
 359                 syslog(LOG_ERR, "GetBootFiles: no boot files (%s)\n", BootDir);
 360
 361         return(i);
 362 }