usr.sbin/config/mkoptions.c

   1 /*
   2  * Copyright (c) 1995  Peter Wemm
   3  * Copyright (c) 1980, 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by the University of
  17  *      California, Berkeley and its contributors.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * @(#)mkheaders.c      8.1 (Berkeley) 6/6/93
  35  * $FreeBSD: src/usr.sbin/config/mkoptions.c,v 1.17.2.3 2001/12/13 19:18:01 dillon Exp $
  36  * $DragonFly: src/usr.sbin/config/mkoptions.c,v 1.4 2003/11/16 11:51:14 eirikn Exp $
  37  */
  38
  39 /*
  40  * Make all the .h files for the optional entries
  41  */
  42
  43 #include <ctype.h>
  44 #include <err.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <sys/param.h>
  48 #include "config.h"
  49 #include "y.tab.h"
  50
  51 static  struct users {
  52         int     u_default;
  53         int     u_min;
  54         int     u_max;
  55 } users[] = {
  56         { 8, 2, 512 },                  /* MACHINE_I386 */
  57         { 8, 2, 512 },                  /* MACHINE_PC98 */
  58         { 8, 2, 512 },                  /* MACHINE_ALPHA */
  59 };
  60 #define NUSERS  (sizeof (users) / sizeof (users[0]))
  61
  62 static char *lower(char *);
  63 static void read_options(void);
  64 static void do_option(char *);
  65 static char *tooption(char *);
  66
  67 void
  68 options(void)
  69 {
  70         char buf[40];
  71         struct cputype *cp;
  72         struct opt_list *ol;
  73         struct opt *op;
  74         struct users *up;
  75
  76         /* Fake the cpu types as options. */
  77         for (cp = cputype; cp != NULL; cp = cp->cpu_next) {
  78                 op = (struct opt *)malloc(sizeof(*op));
  79                 memset(op, 0, sizeof(*op));
  80                 op->op_name = ns(cp->cpu_name);
  81                 op->op_next = opt;
  82                 opt = op;
  83         }
  84
  85         /* Initialize `maxusers'. */
  86         if ((unsigned)machine > NUSERS) {
  87                 printf("maxusers config info isn't present, using i386\n");
  88                 up = &users[MACHINE_I386 - 1];
  89         } else
  90                 up = &users[machine - 1];
  91         if (maxusers == 0) {
  92                 /* printf("maxusers not specified; will auto-size\n"); */
  93                 /* maxusers = 0; */
  94         } else if (maxusers < up->u_min) {
  95                 printf("minimum of %d maxusers assumed\n", up->u_min);
  96                 maxusers = up->u_min;
  97         } else if (maxusers > up->u_max)
  98                 printf("warning: maxusers > %d (%d)\n", up->u_max, maxusers);
  99
 100         /* Fake MAXUSERS as an option. */
 101         op = (struct opt *)malloc(sizeof(*op));
 102         memset(op, 0, sizeof(*op));
 103         op->op_name = "MAXUSERS";
 104         snprintf(buf, sizeof(buf), "%d", maxusers);
 105         op->op_value = ns(buf);
 106         op->op_next = opt;
 107         opt = op;
 108
 109         read_options();
 110         for (ol = otab; ol != 0; ol = ol->o_next)
 111                 do_option(ol->o_name);
 112         for (op = opt; op; op = op->op_next) {
 113                 if (!op->op_ownfile) {
 114                         printf("%s:%d: unknown option \"%s\"\n",
 115                                PREFIX, op->op_line, op->op_name);
 116                         exit(1);
 117                 }
 118         }
 119 }
 120
 121 /*
 122  * Generate an <options>.h file
 123  */
 124
 125 static void
 126 do_option(char *name)
 127 {
 128         char *basefile, *file, *inw;
 129         struct opt_list *ol;
 130         struct opt *op, *op_head, *topp;
 131         FILE *inf, *outf;
 132         char *value;
 133         char *oldvalue;
 134         int seen;
 135         int tidy;
 136
 137         file = tooption(name);
 138
 139         /*
 140          * Check to see if the option was specified..
 141          */
 142         value = NULL;
 143         for (op = opt; op; op = op->op_next) {
 144                 if (eq(name, op->op_name)) {
 145                         oldvalue = value;
 146                         value = op->op_value;
 147                         if (value == NULL)
 148                                 value = ns("1");
 149                         if (oldvalue != NULL && !eq(value, oldvalue))
 150                                 printf(
 151                             "%s:%d: option \"%s\" redefined from %s to %s\n",
 152                                    PREFIX, op->op_line, op->op_name, oldvalue,
 153                                    value);
 154                         op->op_ownfile++;
 155                 }
 156         }
 157
 158         inf = fopen(file, "r");
 159         if (inf == 0) {
 160                 outf = fopen(file, "w");
 161                 if (outf == 0)
 162                         err(1, "%s", file);
 163
 164                 /* was the option in the config file? */
 165                 if (value) {
 166                         fprintf(outf, "#define %s %s\n", name, value);
 167                 } /* else empty file */
 168
 169                 (void) fclose(outf);
 170                 return;
 171         }
 172         basefile = "";
 173         for (ol = otab; ol != 0; ol = ol->o_next)
 174                 if (eq(name, ol->o_name)) {
 175                         basefile = ol->o_file;
 176                         break;
 177                 }
 178         oldvalue = NULL;
 179         op_head = NULL;
 180         seen = 0;
 181         tidy = 0;
 182         for (;;) {
 183                 char *cp;
 184                 char *invalue;
 185
 186                 /* get the #define */
 187                 if ((inw = get_word(inf)) == 0 || inw == (char *)EOF)
 188                         break;
 189                 /* get the option name */
 190                 if ((inw = get_word(inf)) == 0 || inw == (char *)EOF)
 191                         break;
 192                 inw = ns(inw);
 193                 /* get the option value */
 194                 if ((cp = get_word(inf)) == 0 || cp == (char *)EOF)
 195                         break;
 196                 /* option value */
 197                 invalue = ns(cp); /* malloced */
 198                 if (eq(inw, name)) {
 199                         oldvalue = invalue;
 200                         invalue = value;
 201                         seen++;
 202                 }
 203                 for (ol = otab; ol != 0; ol = ol->o_next)
 204                         if (eq(inw, ol->o_name))
 205                                 break;
 206                 if (!eq(inw, name) && !ol) {
 207                         printf("WARNING: unknown option `%s' removed from %s\n",
 208                                 inw, file);
 209                         tidy++;
 210                 } else if (ol != NULL && !eq(basefile, ol->o_file)) {
 211                         printf("WARNING: option `%s' moved from %s to %s\n",
 212                                 inw, basefile, ol->o_file);
 213                         tidy++;
 214                 } else {
 215                         op = (struct opt *) malloc(sizeof *op);
 216                         bzero(op, sizeof(*op));
 217                         op->op_name = inw;
 218                         op->op_value = invalue;
 219                         op->op_next = op_head;
 220                         op_head = op;
 221                 }
 222
 223                 /* EOL? */
 224                 cp = get_word(inf);
 225                 if (cp == (char *)EOF)
 226                         break;
 227         }
 228         (void) fclose(inf);
 229         if (!tidy && ((value == NULL && oldvalue == NULL) ||
 230             (value && oldvalue && eq(value, oldvalue)))) {
 231                 for (op = op_head; op != NULL; op = topp) {
 232                         topp = op->op_next;
 233                         free(op->op_name);
 234                         free(op->op_value);
 235                         free(op);
 236                 }
 237                 return;
 238         }
 239
 240         if (value && !seen) {
 241                 /* New option appears */
 242                 op = (struct opt *) malloc(sizeof *op);
 243                 bzero(op, sizeof(*op));
 244                 op->op_name = ns(name);
 245                 op->op_value = value ? ns(value) : NULL;
 246                 op->op_next = op_head;
 247                 op_head = op;
 248         }
 249
 250         outf = fopen(file, "w");
 251         if (outf == 0)
 252                 err(1, "%s", file);
 253         for (op = op_head; op != NULL; op = topp) {
 254                 /* was the option in the config file? */
 255                 if (op->op_value) {
 256                         fprintf(outf, "#define %s %s\n",
 257                                 op->op_name, op->op_value);
 258                 }
 259                 topp = op->op_next;
 260                 free(op->op_name);
 261                 free(op->op_value);
 262                 free(op);
 263         }
 264         (void) fclose(outf);
 265 }
 266
 267 /*
 268  * Find the filename to store the option spec into.
 269  */
 270 static char *
 271 tooption(char *name)
 272 {
 273         static char hbuf[MAXPATHLEN];
 274         char nbuf[MAXPATHLEN];
 275         struct opt_list *po;
 276
 277         /* "cannot happen"?  the otab list should be complete.. */
 278         (void) strlcpy(nbuf, "options.h", sizeof(nbuf));
 279
 280         for (po = otab ; po != 0; po = po->o_next) {
 281                 if (eq(po->o_name, name)) {
 282                         strlcpy(nbuf, po->o_file, sizeof(nbuf));
 283                         break;
 284                 }
 285         }
 286
 287         (void) strlcpy(hbuf, path(nbuf), sizeof(hbuf));
 288         return (hbuf);
 289 }
 290
 291 /*
 292  * read the options and options.<machine> files
 293  */
 294 static void
 295 read_options(void)
 296 {
 297         FILE *fp;
 298         char fname[MAXPATHLEN];
 299         char *wd, *this, *val;
 300         struct opt_list *po;
 301         int first = 1;
 302         char genopt[MAXPATHLEN];
 303
 304         otab = 0;
 305         if (ident == NULL) {
 306                 printf("no ident line specified\n");
 307                 exit(1);
 308         }
 309         (void) snprintf(fname, sizeof(fname), "../../conf/options");
 310 openit:
 311         fp = fopen(fname, "r");
 312         if (fp == 0) {
 313                 return;
 314         }
 315 next:
 316         wd = get_word(fp);
 317         if (wd == (char *)EOF) {
 318                 (void) fclose(fp);
 319                 if (first == 1) {
 320                         first++;
 321                         (void) snprintf(fname, sizeof fname, "../../conf/options.%s", machinename);
 322                         fp = fopen(fname, "r");
 323                         if (fp != 0)
 324                                 goto next;
 325                         (void) snprintf(fname, sizeof fname, "options.%s", machinename);
 326                         goto openit;
 327                 }
 328                 if (first == 2) {
 329                         first++;
 330                         (void) snprintf(fname, sizeof fname, "options.%s", raisestr(ident));
 331                         fp = fopen(fname, "r");
 332                         if (fp != 0)
 333                                 goto next;
 334                 }
 335                 return;
 336         }
 337         if (wd == 0)
 338                 goto next;
 339         if (wd[0] == '#')
 340         {
 341                 while (((wd = get_word(fp)) != (char *)EOF) && wd)
 342                 ;
 343                 goto next;
 344         }
 345         this = ns(wd);
 346         val = get_word(fp);
 347         if (val == (char *)EOF)
 348                 return;
 349         if (val == 0) {
 350                 char *s = ns(this);
 351                 (void) snprintf(genopt, sizeof(genopt), "opt_%s.h", lower(s));
 352                 val = genopt;
 353                 free(s);
 354         }
 355         val = ns(val);
 356
 357         for (po = otab ; po != 0; po = po->o_next) {
 358                 if (eq(po->o_name, this)) {
 359                         printf("%s: Duplicate option %s.\n",
 360                                fname, this);
 361                         exit(1);
 362                 }
 363         }
 364
 365         po = (struct opt_list *) malloc(sizeof *po);
 366         bzero(po, sizeof(*po));
 367         po->o_name = this;
 368         po->o_file = val;
 369         po->o_next = otab;
 370         otab = po;
 371
 372         goto next;
 373 }
 374
 375 static char *
 376 lower(register char *str)
 377 {
 378         register char *cp = str;
 379
 380         while (*str) {
 381                 if (isupper(*str))
 382                         *str = tolower(*str);
 383                 str++;
 384         }
 385         return (cp);
 386 }
 387