root/kern/subr_userconf.c

DEFINITIONS

1. userconf_init
2. userconf_more
3. userconf_hist_cmd
4. userconf_hist_int
5. userconf_hist_eoc
6. userconf_pnum
7. userconf_pdevnam
8. userconf_pdev
9. userconf_number
10. userconf_device
11. userconf_attr
12. userconf_modify
13. userconf_change
14. userconf_disable
15. userconf_enable
16. userconf_help
17. userconf_list
18. userconf_show
19. userconf_common_attr_val
20. userconf_show_attr
21. userconf_common_dev
22. userconf_common_attr
23. userconf_add_read
24. userconf_add
25. userconf_parse
26. user_config

    1 /*      $OpenBSD: subr_userconf.c,v 1.34 2005/12/09 09:09:52 jsg Exp $  */
    3 /*
    4  * Copyright (c) 1996-2001 Mats O Jansson <moj@stacken.kth.se>
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
   17  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/device.h>
   32 #include <sys/malloc.h>
   33 #include <sys/time.h>
   35 #include <dev/cons.h>
   37 extern char *locnames[];
   38 extern short locnamp[];
   39 extern short cfroots[];
   40 extern int cfroots_size;
   41 extern int pv_size;
   42 extern short pv[];
   43 extern struct timezone tz;
   44 extern char *pdevnames[];
   45 extern int pdevnames_size;
   46 extern struct pdevinit pdevinit[];
   48 int userconf_base = 16;                         /* Base for "large" numbers */
   49 int userconf_maxdev = -1;                       /* # of used device slots   */
   50 int userconf_totdev = -1;                       /* # of device slots        */
   51 int userconf_maxlocnames = -1;                  /* # of locnames            */
   52 int userconf_cnt = -1;                          /* Line counter for ...     */
   53 int userconf_lines = 12;                        /* ... # of lines per page  */
   54 int userconf_histlen = 0;
   55 int userconf_histcur = 0;
   56 char userconf_history[1024];
   57 int userconf_histsz = sizeof(userconf_history);
   58 char userconf_argbuf[40];                       /* Additional input         */
   59 char userconf_cmdbuf[40];                       /* Command line             */
   60 char userconf_histbuf[40];
   62 void userconf_init(void);
   63 int userconf_more(void);
   64 void userconf_modify(char *, int *);
   65 void userconf_hist_cmd(char);
   66 void userconf_hist_int(int);
   67 void userconf_hist_eoc(void);
   68 void userconf_pnum(int);
   69 void userconf_pdevnam(short);
   70 void userconf_pdev(short);
   71 int userconf_number(char *, int *);
   72 int userconf_device(char *, int *, short *, short *);
   73 int userconf_attr(char *, int *);
   74 void userconf_modify(char *, int *);
   75 void userconf_change(int);
   76 void userconf_disable(int);
   77 void userconf_enable(int);
   78 void userconf_help(void);
   79 void userconf_list(void);
   80 void userconf_show(void);
   81 void userconf_common_attr_val(short, int *, char);
   82 void userconf_show_attr(char *);
   83 void userconf_common_dev(char *, int, short, short, char);
   84 void userconf_common_attr(char *, int, char);
   85 void userconf_add_read(char *, char, char *, int, int *);
   86 void userconf_add(char *, int, short, short);
   87 int userconf_parse(char *);
   89 #define UC_CHANGE 'c'
   90 #define UC_DISABLE 'd'
   91 #define UC_ENABLE 'e'
   92 #define UC_FIND 'f'
   93 #define UC_SHOW 's'
   95 char *userconf_cmds[] = {
   96         "add",          "a",
   97         "base",         "b",
   98         "change",       "c",
   99 #if defined(DDB)
  100         "ddb",          "D",
  101 #endif
  102         "disable",      "d",
  103         "enable",       "e",
  104         "exit",         "q",
  105         "find",         "f",
  106         "help",         "h",
  107         "list",         "l",
  108         "lines",        "L",
  109         "quit",         "q",
  110         "show",         "s",
  111         "timezone",     "t",
  112         "verbose",      "v",
  113         "?",            "h",
  114         "",              "",
  115 };
  117 void
userconf_init(void)
  119 {
  120         int i = 0;
  121         struct cfdata *cd;
  122         int   ln;
  124         while (cfdata[i].cf_attach != 0) {
userconf_maxdev = i;
userconf_totdev = i;
cd = &cfdata[i];
ln = cd->cf_locnames;
  130                 while (locnamp[ln] != -1) {
  131                         if (locnamp[ln] > userconf_maxlocnames)
userconf_maxlocnames = locnamp[ln];
ln++;
  134                 }
i++;
  136         }
  138         while (cfdata[i].cf_attach == 0) {
userconf_totdev = i;
i++;
  141         }
userconf_totdev = userconf_totdev - 1;
  143 }
  145 int
userconf_more(void)
  147 {
  148         int quit = 0;
  149         char c = '\0';
  151         if (userconf_cnt != -1) {
  152                 if (userconf_cnt == userconf_lines) {
printf("--- more ---");
c = cngetc();
userconf_cnt = 0;
printf("\r            \r");
  157                 }
userconf_cnt++;
  159                 if (c == 'q' || c == 'Q')
quit = 1;
  161         }
  162         return (quit);
  163 }
  165 void
userconf_hist_cmd(char cmd)
  167 {
userconf_histcur = userconf_histlen;
  169         if (userconf_histcur < userconf_histsz) {
userconf_history[userconf_histcur] = cmd;
userconf_histcur++;
  172         }
  173 }
  175 void
userconf_hist_int(int val)
  177 {
snprintf(userconf_histbuf, sizeof userconf_histbuf, " %d",val);
  179         if (userconf_histcur + strlen(userconf_histbuf) < userconf_histsz) {
bcopy(userconf_histbuf,
  181                     &userconf_history[userconf_histcur],
strlen(userconf_histbuf));
userconf_histcur = userconf_histcur + strlen(userconf_histbuf);
  184         }
  185 }
  187 void
userconf_hist_eoc(void)
  189 {
  190         if (userconf_histcur < userconf_histsz) {
userconf_history[userconf_histcur] = '\n';
userconf_histcur++;
userconf_histlen = userconf_histcur;
  194         }
  195 }
  197 void
userconf_pnum(int val)
  199 {
  200         if (val > -2 && val < 16) {
printf("%d",val);
  202                 return;
  203         }
  205         switch (userconf_base) {
  206         case 8:
printf("0%o",val);
  208                 break;
  209         case 10:
printf("%d",val);
  211                 break;
  212         case 16:
  213         default:
printf("0x%x",val);
  215                 break;
  216         }
  217 }
  219 void
userconf_pdevnam(short dev)
  221 {
  222         struct cfdata *cd;
cd = &cfdata[dev];
printf("%s", cd->cf_driver->cd_name);
  226         switch (cd->cf_fstate) {
  227         case FSTATE_NOTFOUND:
  228         case FSTATE_DNOTFOUND:
printf("%d", cd->cf_unit);
  230                 break;
  231         case FSTATE_FOUND:
printf("*FOUND*");
  233                 break;
  234         case FSTATE_STAR:
  235         case FSTATE_DSTAR:
printf("*");
  237                 break;
  238         default:
printf("*UNKNOWN*");
  240                 break;
  241         }
  242 }
  244 void
userconf_pdev(short devno)
  246 {
  247         struct cfdata *cd;
  248         short *p;
  249         int   *l;
  250         int   ln;
  251         char c;
  253         if (devno > userconf_maxdev && devno <= userconf_totdev) {
printf("%3d free slot (for add)\n", devno);
  255                 return;
  256         }
  258         if (devno > userconf_totdev &&
devno <= userconf_totdev+pdevnames_size) {
printf("%3d %s count %d (pseudo device)\n", devno,
pdevnames[devno-userconf_totdev-1],
pdevinit[devno-userconf_totdev-1].pdev_count);
  263                 return;
  264         }
  266         if (devno >  userconf_maxdev) {
printf("Unknown devno (max is %d)\n", userconf_maxdev);
  268                 return;
  269         }
cd = &cfdata[devno];
printf("%3d ", devno);
userconf_pdevnam(devno);
printf(" at");
c = ' ';
p = cd->cf_parents;
  278         if (*p == -1)
printf(" root");
  280         while (*p != -1) {
printf("%c", c);
userconf_pdevnam(*p++);
c = '|';
  284         }
  285         switch (cd->cf_fstate) {
  286         case FSTATE_NOTFOUND:
  287         case FSTATE_FOUND:
  288         case FSTATE_STAR:
  289                 break;
  290         case FSTATE_DNOTFOUND:
  291         case FSTATE_DSTAR:
printf(" disable");
  293                 break;
  294         default:
printf(" ???");
  296                 break;
  297         }
l = cd->cf_loc;
ln = cd->cf_locnames;
  300         while (locnamp[ln] != -1) {
printf(" %s ", locnames[locnamp[ln]]);
ln++;
userconf_pnum(*l++);
  304         }
printf(" flags 0x%x\n", cd->cf_flags);
  306 }
  308 int
userconf_number(char *c, int *val)
  310 {
u_int num = 0;
  312         int neg = 0;
  313         int base = 10;
  315         if (*c == '-') {
neg = 1;
c++;
  318         }
  319         if (*c == '0') {
base = 8;
c++;
  322                 if (*c == 'x' || *c == 'X') {
base = 16;
c++;
  325                 }
  326         }
  327         while (*c != '\n' && *c != '\t' && *c != ' ' && *c != '\0') {
u_char cc = *c;
  330                 if (cc >= '0' && cc <= '9')
cc = cc - '0';
  332                 else if (cc >= 'a' && cc <= 'f')
cc = cc - 'a' + 10;
  334                 else if (cc >= 'A' && cc <= 'F')
cc = cc - 'A' + 10;
  336                 else
  337                         return (-1);
  339                 if (cc > base)
  340                         return (-1);
num = num * base + cc;
c++;
  343         }
  345         if (neg && num > INT_MAX)       /* overflow */
  346                 return (1);
  347         *val = neg ? - num : num;
  348         return (0);
  349 }
  351 int
userconf_device(char *cmd, int *len, short *unit, short *state)
  353 {
  354         short u = 0, s = FSTATE_FOUND;
  355         int l = 0;
  356         char *c;
c = cmd;
  359         while (*c >= 'a' && *c <= 'z') {
l++;
c++;
  362         }
  363         if (*c == '*') {
s = FSTATE_STAR;
c++;
  366         } else {
  367                 while (*c >= '0' && *c <= '9') {
s = FSTATE_NOTFOUND;
u = u*10 + *c - '0';
c++;
  371                 }
  372         }
  373         while (*c == ' ' || *c == '\t' || *c == '\n')
c++;
  376         if (*c == '\0') {
  377                 *len = l;
  378                 *unit = u;
  379                 *state = s;
  380                 return(0);
  381         }
  383         return(-1);
  384 }
  386 int
userconf_attr(char *cmd, int *val)
  388 {
  389         char *c;
  390         short attr = -1, i = 0, l = 0;
c = cmd;
  393         while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
c++;
l++;
  396         }
  398         while (i <= userconf_maxlocnames) {
  399                 if (strlen(locnames[i]) == l) {
  400                         if (strncasecmp(cmd, locnames[i], l) == 0)
attr = i;
  402                 }
i++;
  404         }
  406         if (attr == -1) {
  407                 return (-1);
  408         }
  410         *val = attr;
  412         return(0);
  413 }
  415 void
userconf_modify(char *item, int *val)
  417 {
  418         int ok = 0;
  419         int a;
  420         char *c;
  421         int i;
  423         while (!ok) {
printf("%s [", item);
userconf_pnum(*val);
printf("] ? ");
i = getsn(userconf_argbuf, sizeof(userconf_argbuf));
c = userconf_argbuf;
  431                 while (*c == ' ' || *c == '\t' || *c == '\n') c++;
  433                 if (*c != '\0') {
  434                         if (userconf_number(c, &a) == 0) {
  435                                 *val = a;
ok = 1;
  437                         } else {
printf("Unknown argument\n");
  439                         }
  440                 } else {
ok = 1;
  442                 }
  443         }
  444 }
  446 void
userconf_change(int devno)
  448 {
  449         struct cfdata *cd;
  450         char c = '\0';
  451         int   *l;
  452         int   ln;
  454         if (devno <=  userconf_maxdev) {
userconf_pdev(devno);
  457                 while (c != 'y' && c != 'Y' && c != 'n' && c != 'N') {
printf("change (y/n) ?");
c = cngetc();
printf("\n");
  461                 }
  463                 if (c == 'y' || c == 'Y') {
  464                         int share = 0, i, *lk;
  466                         /* XXX add cmd 'c' <devno> */
userconf_hist_cmd('c');
userconf_hist_int(devno);
cd = &cfdata[devno];
l = cd->cf_loc;
ln = cd->cf_locnames;
  474                         /*
  475                          * Search for some other driver sharing this
  476                          * locator table. if one does, we may need to
  477                          * replace the locators with a malloc'd copy.
  478                          */
  479                         for (i = 0; cfdata[i].cf_driver; i++)
  480                                 if (i != devno && cfdata[i].cf_loc == l)
share = 1;
  482                         if (share) {
  483                                 for (i = 0; locnamp[ln+i] != -1 ; i++)
  484                                         ;
lk = l = (int *)malloc(sizeof(int) * i,
M_TEMP, M_NOWAIT);
  487                                 if (lk == NULL) {
printf("out of memory.\n");
  489                                         return;
  490                                 }
bcopy(cd->cf_loc, l, sizeof(int) * i);
  492                         }
  494                         while (locnamp[ln] != -1) {
userconf_modify(locnames[locnamp[ln]], l);
  497                                 /* XXX add *l */
userconf_hist_int(*l);
ln++;
l++;
  502                         }
userconf_modify("flags", &cd->cf_flags);
userconf_hist_int(cd->cf_flags);
  506                         if (share) {
  507                                 if (bcmp(cd->cf_loc, lk, sizeof(int) * i))
cd->cf_loc = lk;
  509                                 else
free(lk, M_TEMP);
  511                         }
printf("%3d ", devno);
userconf_pdevnam(devno);
printf(" changed\n");
userconf_pdev(devno);
  517                 }
  518                 return;
  519         }
  521         if (devno > userconf_maxdev && devno <= userconf_totdev) {
printf("%3d can't change free slot\n", devno);
  523                 return;
  524         }
  526         if (devno > userconf_totdev &&
devno <= userconf_totdev+pdevnames_size) {
userconf_pdev(devno);
  529                 while (c != 'y' && c != 'Y' && c != 'n' && c != 'N') {
printf("change (y/n) ?");
c = cngetc();
printf("\n");
  533                 }
  535                 if (c == 'y' || c == 'Y') {
  536                         /* XXX add cmd 'c' <devno> */
userconf_hist_cmd('c');
userconf_hist_int(devno);
userconf_modify("count",
  541                             &pdevinit[devno-userconf_totdev-1].pdev_count);
userconf_hist_int(pdevinit[devno-userconf_totdev-1].pdev_count);
printf("%3d %s changed\n", devno,
pdevnames[devno-userconf_totdev-1]);
userconf_pdev(devno);
  548                         /* XXX add eoc */
userconf_hist_eoc();
  550                 }
  551                 return;
  552         }
printf("Unknown devno (max is %d)\n", userconf_totdev+pdevnames_size);
  555 }
  557 void
userconf_disable(int devno)
  559 {
  560         int done = 0;
  562         if (devno <= userconf_maxdev) {
  563                 switch (cfdata[devno].cf_fstate) {
  564                 case FSTATE_NOTFOUND:
cfdata[devno].cf_fstate = FSTATE_DNOTFOUND;
  566                         break;
  567                 case FSTATE_STAR:
cfdata[devno].cf_fstate = FSTATE_DSTAR;
  569                         break;
  570                 case FSTATE_DNOTFOUND:
  571                 case FSTATE_DSTAR:
done = 1;
  573                         break;
  574                 default:
printf("Error unknown state\n");
  576                         break;
  577                 }
printf("%3d ", devno);
userconf_pdevnam(devno);
  581                 if (done) {
printf(" already");
  583                 } else {
  584                         /* XXX add cmd 'd' <devno> eoc */
userconf_hist_cmd('d');
userconf_hist_int(devno);
userconf_hist_eoc();
  588                 }
printf(" disabled\n");
  591                 return;
  592         }
  594         if (devno > userconf_maxdev && devno <= userconf_totdev) {
printf("%3d can't disable free slot\n", devno);
  596                 return;
  597         }
  599         if (devno > userconf_totdev &&
devno <= userconf_totdev+pdevnames_size) {
printf("%3d %s can't disable pseudo device\n", devno,
pdevnames[devno-userconf_totdev-1]);
  603                 return;
  604         }
printf("Unknown devno (max is %d)\n", userconf_totdev+pdevnames_size);
  607 }
  609 void
userconf_enable(int devno)
  611 {
  612         int done = 0;
  614         if (devno <= userconf_maxdev) {
  615                 switch (cfdata[devno].cf_fstate) {
  616                 case FSTATE_DNOTFOUND:
cfdata[devno].cf_fstate = FSTATE_NOTFOUND;
  618                         break;
  619                 case FSTATE_DSTAR:
cfdata[devno].cf_fstate = FSTATE_STAR;
  621                         break;
  622                 case FSTATE_NOTFOUND:
  623                 case FSTATE_STAR:
done = 1;
  625                         break;
  626                 default:
printf("Error unknown state\n");
  628                         break;
  629                 }
printf("%3d ", devno);
userconf_pdevnam(devno);
  633                 if (done) {
printf(" already");
  635                 } else {
  636                         /* XXX add cmd 'e' <devno> eoc */
userconf_hist_cmd('e');
userconf_hist_int(devno);
userconf_hist_eoc();
  640                 }
printf(" enabled\n");
  642                 return;
  643         }
  645         if (devno > userconf_maxdev && devno <= userconf_totdev) {
printf("%3d can't enable free slot\n", devno);
  647                 return;
  648         }
  650         if (devno > userconf_totdev &&
devno <= userconf_totdev+pdevnames_size) {
printf("%3d %s can't enable pseudo device\n", devno,
pdevnames[devno-userconf_totdev-1]);
  654                 return;
  655         }
printf("Unknown devno (max is %d)\n", userconf_totdev+pdevnames_size);
  658 }
  660 void
userconf_help(void)
  662 {
  663         int j = 0, k;
printf("command   args                description\n");
  666         while (*userconf_cmds[j] != '\0') {
printf(userconf_cmds[j]);
k = strlen(userconf_cmds[j]);
  669                 while (k < 10) {
printf(" ");
k++;
  672                 }
  673                 switch (*userconf_cmds[j+1]) {
  674                 case 'L':
printf("[count]             number of lines before more");
  676                         break;
  677                 case 'a':
printf("dev                 add a device");
  679                         break;
  680                 case 'b':
printf("8|10|16             base on large numbers");
  682                         break;
  683                 case 'c':
printf("devno|dev           change devices");
  685                         break;
  686 #if defined(DDB)
  687                 case 'D':
printf("                    enter ddb");
  689                         break;
  690 #endif
  691                 case 'd':
printf("attr val|devno|dev  disable devices");
  693                         break;
  694                 case 'e':
printf("attr val|devno|dev  enable devices");
  696                         break;
  697                 case 'f':
printf("devno|dev           find devices");
  699                         break;
  700                 case 'h':
printf("                    this message");
  702                         break;
  703                 case 'l':
printf("                    list configuration");
  705                         break;
  706                 case 'q':
printf("                    leave UKC");
  708                         break;
  709                 case 's':
printf("[attr [val]]        "
  711                            "show attributes (or devices with an attribute)");
  712                         break;
  713                 case 't':
printf("[mins [dst]]        set timezone/dst");
  715                         break;
  716                 case 'v':
printf("                    toggle verbose booting");
  718                         break;
  719                 default:
printf("                    don't know");
  721                         break;
  722                 }
printf("\n");
j += 2;
  725         }
  726 }
  728 void
userconf_list(void)
  730 {
  731         int i = 0;
userconf_cnt = 0;
  735         while (i <= (userconf_totdev+pdevnames_size)) {
  736                 if (userconf_more())
  737                         break;
userconf_pdev(i++);
  739         }
userconf_cnt = -1;
  742 }
  744 void
userconf_show(void)
  746 {
  747         int i = 0;
userconf_cnt = 0;
  751         while (i <= userconf_maxlocnames) {
  752                 if (userconf_more())
  753                         break;
printf("%s\n", locnames[i++]);
  755         }
userconf_cnt = -1;
  758 }
  760 void
userconf_common_attr_val(short attr, int *val, char routine)
  762 {
  763         struct cfdata *cd;
  764         int   *l;
  765         int   ln;
  766         int i = 0, quit = 0;
userconf_cnt = 0;
  770         while (i <= userconf_maxdev) {
cd = &cfdata[i];
l = cd->cf_loc;
ln = cd->cf_locnames;
  774                 while (locnamp[ln] != -1) {
  775                         if (locnamp[ln] == attr) {
  776                                 if (val == NULL) {
quit = userconf_more();
userconf_pdev(i);
  779                                 } else {
  780                                         if (*val == *l) {
quit = userconf_more();
  782                                                 switch (routine) {
  783                                                 case UC_ENABLE:
userconf_enable(i);
  785                                                         break;
  786                                                 case UC_DISABLE:
userconf_disable(i);
  788                                                         break;
  789                                                 case UC_SHOW:
userconf_pdev(i);
  791                                                         break;
  792                                                 default:
printf("Unknown routine /%c/\n",
routine);
  795                                                         break;
  796                                                 }
  797                                         }
  798                                 }
  799                         }
  800                         if (quit)
  801                                 break;
ln++;
l++;
  804                 }
  805                 if (quit)
  806                         break;
i++;
  808         }
userconf_cnt = -1;
  811 }
  813 void
userconf_show_attr(char *cmd)
  815 {
  816         char *c;
  817         short attr = -1, i = 0, l = 0;
  818         int a;
c = cmd;
  821         while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
c++;
l++;
  824         }
  825         while (*c == ' ' || *c == '\t' || *c == '\n') {
c++;
  827         }
  828         while (i <= userconf_maxlocnames) {
  829                 if (strlen(locnames[i]) == l) {
  830                         if (strncasecmp(cmd, locnames[i], l) == 0) {
attr = i;
  832                         }
  833                 }
i++;
  835         }
  837         if (attr == -1) {
printf("Unknown attribute\n");
  839                 return;
  840         }
  842         if (*c == '\0') {
userconf_common_attr_val(attr, NULL, UC_SHOW);
  844         } else {
  845                 if (userconf_number(c, &a) == 0) {
userconf_common_attr_val(attr, &a, UC_SHOW);
  847                 } else {
printf("Unknown argument\n");
  849                 }
  850         }
  851 }
  853 void
userconf_common_dev(char *dev, int len, short unit, short state, char routine)
  855 {
  856         int i = 0;
  858         switch (routine) {
  859         case UC_CHANGE:
  860                 break;
  861         default:
userconf_cnt = 0;
  863                 break;
  864         }
  866         while (cfdata[i].cf_attach != 0) {
  867                 if (strlen(cfdata[i].cf_driver->cd_name) == len) {
  869                         /*
  870                          * Ok, if device name is correct
  871                          *  If state == FSTATE_FOUND, look for "dev"
  872                          *  If state == FSTATE_STAR, look for "dev*"
  873                          *  If state == FSTATE_NOTFOUND, look for "dev0"
  874                          */
  875                         if (strncasecmp(dev, cfdata[i].cf_driver->cd_name,
len) == 0 &&
  877                             (state == FSTATE_FOUND ||
  878                              (state == FSTATE_STAR &&
  879                               (cfdata[i].cf_fstate == FSTATE_STAR ||
cfdata[i].cf_fstate == FSTATE_DSTAR)) ||
  881                              (state == FSTATE_NOTFOUND &&
cfdata[i].cf_unit == unit &&
  883                               (cfdata[i].cf_fstate == FSTATE_NOTFOUND ||
cfdata[i].cf_fstate == FSTATE_DNOTFOUND)))) {
  885                                 if (userconf_more())
  886                                         break;
  887                                 switch (routine) {
  888                                 case UC_CHANGE:
userconf_change(i);
  890                                         break;
  891                                 case UC_ENABLE:
userconf_enable(i);
  893                                         break;
  894                                 case UC_DISABLE:
userconf_disable(i);
  896                                         break;
  897                                 case UC_FIND:
userconf_pdev(i);
  899                                         break;
  900                                 default:
printf("Unknown routine /%c/\n",
routine);
  903                                         break;
  904                                 }
  905                         }
  906                 }
i++;
  908         }
  910         for (i = 0; i < pdevnames_size; i++) {
  911                 if (strncasecmp(dev, pdevnames[i], len) == 0 &&
state == FSTATE_FOUND) {
  913                         switch(routine) {
  914                         case UC_CHANGE:
userconf_change(userconf_totdev+1+i);
  916                                 break;
  917                         case UC_ENABLE:
userconf_enable(userconf_totdev+1+i);
  919                                 break;
  920                         case UC_DISABLE:
userconf_disable(userconf_totdev+1+i);
  922                                 break;
  923                         case UC_FIND:
userconf_pdev(userconf_totdev+1+i);
  925                                 break;
  926                         default:
printf("Unknown pseudo routine /%c/\n",routine);
  928                                 break;
  929                         }
  930                 }
  931         }
  933         switch (routine) {
  934         case UC_CHANGE:
  935                 break;
  936         default:
userconf_cnt = -1;
  938                 break;
  939         }
  940 }
  942 void
userconf_common_attr(char *cmd, int attr, char routine)
  944 {
  945         char *c;
  946         short l = 0;
  947         int a;
c = cmd;
  950         while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
c++;
l++;
  953         }
  954         while (*c == ' ' || *c == '\t' || *c == '\n')
c++;
  957         if (*c == '\0') {
printf("Value missing for attribute\n");
  959                 return;
  960         }
  962         if (userconf_number(c, &a) == 0) {
userconf_common_attr_val(attr, &a, routine);
  964         } else {
printf("Unknown argument\n");
  966         }
  967 }
  969 void
userconf_add_read(char *prompt, char field, char *dev, int len, int *val)
  971 {
  972         int ok = 0;
  973         int a;
  974         char *c;
  975         int i;
  977         *val = -1;
  979         while (!ok) {
printf("%s ? ", prompt);
i = getsn(userconf_argbuf, sizeof(userconf_argbuf));
c = userconf_argbuf;
  985                 while (*c == ' ' || *c == '\t' || *c == '\n')
c++;
  988                 if (*c != '\0') {
  989                         if (userconf_number(c, &a) == 0) {
  990                                 if (a > userconf_maxdev) {
printf("Unknown devno (max is %d)\n",
userconf_maxdev);
  993                                 } else if (strncasecmp(dev,
cfdata[a].cf_driver->cd_name, len) != 0 &&
field == 'a') {
printf("Not same device type\n");
  997                                 } else {
  998                                         *val = a;
ok = 1;
 1000                                 }
 1001                         } else if (*c == '?') {
userconf_common_dev(dev, len, 0,
FSTATE_FOUND, UC_FIND);
 1004                         } else if (*c == 'q' || *c == 'Q') {
ok = 1;
 1006                         } else {
printf("Unknown argument\n");
 1008                         }
 1009                 } else {
ok = 1;
 1011                 }
 1012         }
 1013 }
 1015 void
userconf_add(char *dev, int len, short unit, short state)
 1017 {
 1018         int i = 0, found = 0;
 1019         struct cfdata new;
 1020         int  val, max_unit, star_unit, orig;
bzero(&new, sizeof(struct cfdata));
 1024         if (userconf_maxdev == userconf_totdev) {
printf("No more space for new devices.\n");
 1026                 return;
 1027         }
 1029         if (state == FSTATE_FOUND) {
printf("Device not complete number or * is missing\n");
 1031                 return;
 1032         }
 1034         for (i = 0; cfdata[i].cf_driver; i++)
 1035                 if (strlen(cfdata[i].cf_driver->cd_name) == len &&
strncasecmp(dev, cfdata[i].cf_driver->cd_name, len) == 0)
found = 1;
 1039         if (!found) {
printf("No device of this type exists.\n");
 1041                 return;
 1042         }
userconf_add_read("Clone Device (DevNo, 'q' or '?')",
 1045             'a', dev, len, &val);
 1047         if (val != -1) {
orig = val;
new = cfdata[val];
new.cf_unit = unit;
new.cf_fstate = state;
userconf_add_read("Insert before Device (DevNo, 'q' or '?')",
 1053                     'i', dev, len, &val);
 1054         }
 1056         if (val != -1) {
 1057                 /* XXX add cmd 'a' <orig> <val> eoc */
userconf_hist_cmd('a');
userconf_hist_int(orig);
userconf_hist_int(unit);
userconf_hist_int(state);
userconf_hist_int(val);
userconf_hist_eoc();
 1065                 /* Insert the new record */
 1066                 for (i = userconf_maxdev; val <= i; i--)
cfdata[i+1] = cfdata[i];
cfdata[val] = new;
 1070                 /* Fix indexs in pv */
 1071                 for (i = 0; i < pv_size; i++) {
 1072                         if (pv[i] != -1 && pv[i] >= val)
pv[i]++;
 1074                 }
 1076                 /* Fix indexs in cfroots */
 1077                 for (i = 0; i < cfroots_size; i++) {
 1078                         if (cfroots[i] != -1 && cfroots[i] >= val)
cfroots[i]++;
 1080                 }
userconf_maxdev++;
max_unit = -1;
 1086                 /* Find max unit number of the device type */
i = 0;
 1089                 while (cfdata[i].cf_attach != 0) {
 1090                         if (strlen(cfdata[i].cf_driver->cd_name) == len &&
strncasecmp(dev, cfdata[i].cf_driver->cd_name,
len) == 0) {
 1093                                 switch (cfdata[i].cf_fstate) {
 1094                                 case FSTATE_NOTFOUND:
 1095                                 case FSTATE_DNOTFOUND:
 1096                                         if (cfdata[i].cf_unit > max_unit)
max_unit = cfdata[i].cf_unit;
 1098                                         break;
 1099                                 default:
 1100                                         break;
 1101                                 }
 1102                         }
i++;
 1104                 }
 1106                 /*
 1107                  * For all * entries set unit number to max+1, and update
 1108                  * cf_starunit1 if necessary.
 1109                  */
max_unit++;
star_unit = -1;
i = 0;
 1114                 while (cfdata[i].cf_attach != 0) {
 1115                         if (strlen(cfdata[i].cf_driver->cd_name) == len &&
strncasecmp(dev, cfdata[i].cf_driver->cd_name,
len) == 0) {
 1118                                 switch (cfdata[i].cf_fstate) {
 1119                                 case FSTATE_NOTFOUND:
 1120                                 case FSTATE_DNOTFOUND:
 1121                                         if (cfdata[i].cf_unit > star_unit)
star_unit = cfdata[i].cf_unit;
 1123                                         break;
 1124                                 default:
 1125                                         break;
 1126                                 }
 1127                         }
i++;
 1129                 }
star_unit++;
i = 0;
 1133                 while (cfdata[i].cf_attach != 0) {
 1134                         if (strlen(cfdata[i].cf_driver->cd_name) == len &&
strncasecmp(dev, cfdata[i].cf_driver->cd_name,
len) == 0) {
 1137                                 switch (cfdata[i].cf_fstate) {
 1138                                 case FSTATE_STAR:
 1139                                 case FSTATE_DSTAR:
cfdata[i].cf_unit = max_unit;
 1141                                         if (cfdata[i].cf_starunit1 < star_unit)
cfdata[i].cf_starunit1 =
star_unit;
 1144                                         break;
 1145                                 default:
 1146                                         break;
 1147                                 }
 1148                         }
i++;
 1150                 }
userconf_pdev(val);
 1152         }
 1154         /* cf_attach, cf_driver, cf_unit, cf_fstate, cf_loc, cf_flags,
 1155            cf_parents, cf_locnames, cf_locnames and cf_ivstubs */
 1156 }
 1158 int
userconf_parse(char *cmd)
 1160 {
 1161         char *c, *v;
 1162         int i = 0, j = 0, k, a;
 1163         short unit, state;
c = cmd;
 1166         while (*c == ' ' || *c == '\t')
c++;
v = c;
 1169         while (*c != ' ' && *c != '\t' && *c != '\n' && *c != '\0') {
c++;
i++;
 1172         }
k = -1;
 1175         while (*userconf_cmds[j] != '\0') {
 1176                 if (strlen(userconf_cmds[j]) == i) {
 1177                         if (strncasecmp(v, userconf_cmds[j], i) == 0)
k = j;
 1179                 }
j += 2;
 1181         }
 1183         while (*c == ' ' || *c == '\t' || *c == '\n')
c++;
 1186         if (k == -1) {
 1187                 if (*v != '\n')
printf("Unknown command, try help\n");
 1189         } else {
 1190                 switch (*userconf_cmds[k+1]) {
 1191                 case 'L':
 1192                         if (*c == '\0')
printf("Argument expected\n");
 1194                         else if (userconf_number(c, &a) == 0)
userconf_lines = a;
 1196                         else
printf("Unknown argument\n");
 1198                         break;
 1199                 case 'a':
 1200                         if (*c == '\0')
printf("Dev expected\n");
 1202                         else if (userconf_device(c, &a, &unit, &state) == 0)
userconf_add(c, a, unit, state);
 1204                         else
printf("Unknown argument\n");
 1206                         break;
 1207                 case 'b':
 1208                         if (*c == '\0')
printf("8|10|16 expected\n");
 1210                         else if (userconf_number(c, &a) == 0) {
 1211                                 if (a == 8 || a == 10 || a == 16) {
userconf_base = a;
 1213                                 } else {
printf("8|10|16 expected\n");
 1215                                 }
 1216                         } else
printf("Unknown argument\n");
 1218                         break;
 1219                 case 'c':
 1220                         if (*c == '\0')
printf("DevNo or Dev expected\n");
 1222                         else if (userconf_number(c, &a) == 0)
userconf_change(a);
 1224                         else if (userconf_device(c, &a, &unit, &state) == 0)
userconf_common_dev(c, a, unit, state, UC_CHANGE);
 1226                         else
printf("Unknown argument\n");
 1228                         break;
 1229 #if defined(DDB)
 1230                 case 'D':
Debugger();
 1232                         break;
 1233 #endif
 1234                 case 'd':
 1235                         if (*c == '\0')
printf("Attr, DevNo or Dev expected\n");
 1237                         else if (userconf_attr(c, &a) == 0)
userconf_common_attr(c, a, UC_DISABLE);
 1239                         else if (userconf_number(c, &a) == 0)
userconf_disable(a);
 1241                         else if (userconf_device(c, &a, &unit, &state) == 0)
userconf_common_dev(c, a, unit, state, UC_DISABLE);
 1243                         else
printf("Unknown argument\n");
 1245                         break;
 1246                 case 'e':
 1247                         if (*c == '\0')
printf("Attr, DevNo or Dev expected\n");
 1249                         else if (userconf_attr(c, &a) == 0)
userconf_common_attr(c, a, UC_ENABLE);
 1251                         else if (userconf_number(c, &a) == 0)
userconf_enable(a);
 1253                         else if (userconf_device(c, &a, &unit, &state) == 0)
userconf_common_dev(c, a, unit, state, UC_ENABLE);
 1255                         else
printf("Unknown argument\n");
 1257                         break;
 1258                 case 'f':
 1259                         if (*c == '\0')
printf("DevNo or Dev expected\n");
 1261                         else if (userconf_number(c, &a) == 0)
userconf_pdev(a);
 1263                         else if (userconf_device(c, &a, &unit, &state) == 0)
userconf_common_dev(c, a, unit, state, UC_FIND);
 1265                         else
printf("Unknown argument\n");
 1267                         break;
 1268                 case 'h':
userconf_help();
 1270                         break;
 1271                 case 'l':
 1272                         if (*c == '\0')
userconf_list();
 1274                         else
printf("Unknown argument\n");
 1276                         break;
 1277                 case 'q':
 1278                         /* XXX add cmd 'q' eoc */
userconf_hist_cmd('q');
userconf_hist_eoc();
 1281                         return(-1);
 1282                         break;
 1283                 case 's':
 1284                         if (*c == '\0')
userconf_show();
 1286                         else
userconf_show_attr(c);
 1288                         break;
 1289                 case 't':
 1290                         if (*c == '\0' || userconf_number(c, &a) == 0) {
 1291                                 if (*c != '\0') {
tz.tz_minuteswest = a;
 1293                                         while (*c != '\n' && *c != '\t' &&
 1294                                             *c != ' ' && *c != '\0')
c++;
 1296                                         while (*c == '\t' || *c == ' ')
c++;
 1298                                         if (*c != '\0' &&
userconf_number(c, &a) == 0)
tz.tz_dsttime = a;
userconf_hist_cmd('t');
userconf_hist_int(tz.tz_minuteswest);
userconf_hist_int(tz.tz_dsttime);
userconf_hist_eoc();
 1305                                 }
printf("timezone = %d, dst = %d\n",
tz.tz_minuteswest, tz.tz_dsttime);
 1308                         } else
printf("Unknown argument\n");
 1310                         break;
 1311                 case 'v':
autoconf_verbose = !autoconf_verbose;
printf("autoconf verbose %sabled\n",
autoconf_verbose ? "en" : "dis");
 1315                         break;
 1316                 default:
printf("Unknown command\n");
 1318                         break;
 1319                 }
 1320         }
 1321         return(0);
 1322 }
 1324 void
user_config(void)
 1326 {
userconf_init();
printf("User Kernel Config\n");
 1330         while (1) {
printf("UKC> ");
 1332                 if (getsn(userconf_cmdbuf, sizeof(userconf_cmdbuf)) > 0 &&
userconf_parse(userconf_cmdbuf))
 1334                         break;
 1335         }
printf("Continuing...\n");
 1337 }