commands/service/parse.c

   1
   2 #include <stdarg.h>
   3 #include <assert.h>
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <errno.h>
   8 #include <pwd.h>
   9 #include <err.h>
  10 #include <unistd.h>
  11 #include <limits.h>
  12 #include <lib.h>
  13 #include <minix/config.h>
  14 #include <minix/com.h>
  15 #include <minix/const.h>
  16 #include <minix/type.h>
  17 #include <minix/ipc.h>
  18 #include <minix/rs.h>
  19 #include <minix/syslib.h>
  20 #include <minix/bitmap.h>
  21 #include <paths.h>
  22 #include <minix/sef.h>
  23 #include <minix/dmap.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <configfile.h>
  27
  28 #include <machine/archtypes.h>
  29 #include <timers.h>
  30 #include "kernel/proc.h"
  31
  32 #include "config.h"
  33 #include "proto.h"
  34
  35 static int class_recurs;       /* Nesting level of class statements */
  36 #define MAX_CLASS_RECURS        100     /* Max nesting level for classes */
  37
  38 #include "parse.h"
  39
  40 static void do_service(config_t *cpe, config_t *config, struct rs_config *);
  41
  42 static void do_class(config_t *cpe, config_t *config, struct rs_config *rs_config)
  43 {
  44         config_t *cp, *cp1;
  45
  46         if (class_recurs > MAX_CLASS_RECURS)
  47         {
  48                 fatal(
  49                 "do_class: nesting level too high for class '%s' at %s:%d",
  50                         cpe->word, cpe->file, cpe->line);
  51         }
  52         class_recurs++;
  53
  54         /* Process classes */
  55         for (; cpe; cpe= cpe->next)
  56         {
  57                 if (cpe->flags & CFG_SUBLIST)
  58                 {
  59                         fatal("do_class: unexpected sublist at %s:%d",
  60                                 cpe->file, cpe->line);
  61                 }
  62                 if (cpe->flags & CFG_STRING)
  63                 {
  64                         fatal("do_uid: unexpected string at %s:%d",
  65                                 cpe->file, cpe->line);
  66                 }
  67
  68                 /* Find entry for the class */
  69                 for (cp= config; cp; cp= cp->next)
  70                 {
  71                         if (!(cp->flags & CFG_SUBLIST))
  72                         {
  73                                 fatal("do_class: expected list at %s:%d",
  74                                         cp->file, cp->line);
  75                         }
  76                         cp1= cp->list;
  77                         if ((cp1->flags & CFG_STRING) ||
  78                                 (cp1->flags & CFG_SUBLIST))
  79                         {
  80                                 fatal("do_class: expected word at %s:%d",
  81                                         cp1->file, cp1->line);
  82                         }
  83
  84                         /* At this place we expect the word KW_SERVICE */
  85                         if (strcmp(cp1->word, KW_SERVICE) != 0)
  86                                 fatal("do_class: exected word '%S' at %s:%d",
  87                                         KW_SERVICE, cp1->file, cp1->line);
  88
  89                         cp1= cp1->next;
  90                         if ((cp1->flags & CFG_STRING) ||
  91                                 (cp1->flags & CFG_SUBLIST))
  92                         {
  93                                 fatal("do_class: expected word at %s:%d",
  94                                         cp1->file, cp1->line);
  95                         }
  96
  97                         /* At this place we expect the name of the service */
  98                         if (strcmp(cp1->word, cpe->word) == 0)
  99                                 break;
 100                 }
 101                 if (cp == NULL)
 102                 {
 103                         fatal(
 104                         "do_class: no entry found for class '%s' at %s:%d",
 105                                 cpe->word, cpe->file, cpe->line);
 106                 }
 107                 do_service(cp1->next, config, rs_config);
 108         }
 109
 110         class_recurs--;
 111 }
 112
 113 static void do_uid(config_t *cpe, struct rs_start *rs_start)
 114 {
 115         uid_t uid;
 116         struct passwd *pw;
 117         char *check;
 118
 119         /* Process a uid */
 120         if (cpe->next != NULL)
 121         {
 122                 fatal("do_uid: just one uid/login expected at %s:%d",
 123                         cpe->file, cpe->line);
 124         }
 125
 126         if (cpe->flags & CFG_SUBLIST)
 127         {
 128                 fatal("do_uid: unexpected sublist at %s:%d",
 129                         cpe->file, cpe->line);
 130         }
 131         if (cpe->flags & CFG_STRING)
 132         {
 133                 fatal("do_uid: unexpected string at %s:%d",
 134                         cpe->file, cpe->line);
 135         }
 136         pw= getpwnam(cpe->word);
 137         if (pw != NULL)
 138                 uid= pw->pw_uid;
 139         else
 140         {
 141                 if (!strncmp(cpe->word, KW_SELF, strlen(KW_SELF)+1))
 142                 {
 143                         uid= getuid();  /* Real uid */
 144                 }
 145                 else {
 146                         uid= strtol(cpe->word, &check, 0);
 147                         if (check[0] != '\0')
 148                         {
 149                                 fatal("do_uid: bad uid/login '%s' at %s:%d",
 150                                         cpe->word, cpe->file, cpe->line);
 151                         }
 152                 }
 153         }
 154
 155         rs_start->rss_uid= uid;
 156 }
 157
 158 static void do_sigmgr(config_t *cpe, struct rs_start *rs_start)
 159 {
 160         endpoint_t sigmgr_ep;
 161         int r;
 162
 163         /* Process a signal manager value */
 164         if (cpe->next != NULL)
 165         {
 166                 fatal("do_sigmgr: just one sigmgr value expected at %s:%d",
 167                         cpe->file, cpe->line);
 168         }
 169
 170
 171         if (cpe->flags & CFG_SUBLIST)
 172         {
 173                 fatal("do_sigmgr: unexpected sublist at %s:%d",
 174                         cpe->file, cpe->line);
 175         }
 176         if (cpe->flags & CFG_STRING)
 177         {
 178                 fatal("do_sigmgr: unexpected string at %s:%d",
 179                         cpe->file, cpe->line);
 180         }
 181
 182         if(!strcmp(cpe->word, "SELF")) {
 183                 sigmgr_ep = SELF;
 184         }
 185         else {
 186                 if((r = minix_rs_lookup(cpe->word, &sigmgr_ep))) {
 187                         fatal("do_sigmgr: unknown sigmgr %s at %s:%d",
 188                         cpe->word, cpe->file, cpe->line);
 189                 }
 190         }
 191
 192         rs_start->rss_sigmgr= sigmgr_ep;
 193 }
 194
 195 static void do_type(config_t *cpe, struct rs_config *rs_config)
 196 {
 197         if (cpe->next != NULL)
 198         {
 199                 fatal("do_type: just one type value expected at %s:%d",
 200                         cpe->file, cpe->line);
 201         }
 202
 203
 204         if (cpe->flags & CFG_SUBLIST)
 205         {
 206                 fatal("do_type: unexpected sublist at %s:%d",
 207                         cpe->file, cpe->line);
 208         }
 209         if ((cpe->flags & CFG_STRING))
 210         {
 211                 fatal("do_type: unexpected string at %s:%d",
 212                         cpe->file, cpe->line);
 213         }
 214
 215         if(rs_config->type)
 216                 fatal("do_type: another type at %s:%d",
 217                         cpe->file, cpe->line);
 218
 219         if(!strcmp(cpe->word, KW_NET))
 220                 rs_config->type = KW_NET;
 221         else
 222                 fatal("do_type: odd type at %s:%d",
 223                         cpe->file, cpe->line);
 224 }
 225
 226 static void do_descr(config_t *cpe, struct rs_config *rs_config)
 227 {
 228         if (cpe->next != NULL)
 229         {
 230                 fatal("do_descr: just one description expected at %s:%d",
 231                         cpe->file, cpe->line);
 232         }
 233
 234
 235         if (cpe->flags & CFG_SUBLIST)
 236         {
 237                 fatal("do_descr: unexpected sublist at %s:%d",
 238                         cpe->file, cpe->line);
 239         }
 240         if (!(cpe->flags & CFG_STRING))
 241         {
 242                 fatal("do_descr: expected string at %s:%d",
 243                         cpe->file, cpe->line);
 244         }
 245
 246         if(rs_config->descr)
 247                 fatal("do_descr: another descr at %s:%d",
 248                         cpe->file, cpe->line);
 249         rs_config->descr = cpe->word;
 250 }
 251
 252 static void do_scheduler(config_t *cpe, struct rs_start *rs_start)
 253 {
 254         endpoint_t scheduler_ep;
 255         int r;
 256
 257         /* Process a scheduler value */
 258         if (cpe->next != NULL)
 259         {
 260                 fatal("do_scheduler: just one scheduler value expected at %s:%d",
 261                         cpe->file, cpe->line);
 262         }
 263
 264
 265         if (cpe->flags & CFG_SUBLIST)
 266         {
 267                 fatal("do_scheduler: unexpected sublist at %s:%d",
 268                         cpe->file, cpe->line);
 269         }
 270         if (cpe->flags & CFG_STRING)
 271         {
 272                 fatal("do_scheduler: unexpected string at %s:%d",
 273                         cpe->file, cpe->line);
 274         }
 275
 276         if(!strcmp(cpe->word, "KERNEL")) {
 277                 scheduler_ep = KERNEL;
 278         }
 279         else {
 280                 if((r = minix_rs_lookup(cpe->word, &scheduler_ep))) {
 281                         fatal("do_scheduler: unknown scheduler %s at %s:%d",
 282                         cpe->word, cpe->file, cpe->line);
 283                 }
 284         }
 285
 286         rs_start->rss_scheduler= scheduler_ep;
 287 }
 288
 289 static void do_priority(config_t *cpe, struct rs_start *rs_start)
 290 {
 291         int priority_val;
 292         char *check;
 293
 294         /* Process a priority value */
 295         if (cpe->next != NULL)
 296         {
 297                 fatal("do_priority: just one priority value expected at %s:%d",
 298                         cpe->file, cpe->line);
 299         }
 300
 301
 302         if (cpe->flags & CFG_SUBLIST)
 303         {
 304                 fatal("do_priority: unexpected sublist at %s:%d",
 305                         cpe->file, cpe->line);
 306         }
 307         if (cpe->flags & CFG_STRING)
 308         {
 309                 fatal("do_priority: unexpected string at %s:%d",
 310                         cpe->file, cpe->line);
 311         }
 312         priority_val= strtol(cpe->word, &check, 0);
 313         if (check[0] != '\0')
 314         {
 315                 fatal("do_priority: bad priority value '%s' at %s:%d",
 316                         cpe->word, cpe->file, cpe->line);
 317         }
 318
 319         if (priority_val < 0 || priority_val >= NR_SCHED_QUEUES)
 320         {
 321                 fatal("do_priority: priority %d out of range at %s:%d",
 322                         priority_val, cpe->file, cpe->line);
 323         }
 324         rs_start->rss_priority= priority_val;
 325 }
 326
 327 static void do_quantum(config_t *cpe, struct rs_start *rs_start)
 328 {
 329         int quantum_val;
 330         char *check;
 331
 332         /* Process a quantum value */
 333         if (cpe->next != NULL)
 334         {
 335                 fatal("do_quantum: just one quantum value expected at %s:%d",
 336                         cpe->file, cpe->line);
 337         }
 338
 339
 340         if (cpe->flags & CFG_SUBLIST)
 341         {
 342                 fatal("do_quantum: unexpected sublist at %s:%d",
 343                         cpe->file, cpe->line);
 344         }
 345         if (cpe->flags & CFG_STRING)
 346         {
 347                 fatal("do_quantum: unexpected string at %s:%d",
 348                         cpe->file, cpe->line);
 349         }
 350         quantum_val= strtol(cpe->word, &check, 0);
 351         if (check[0] != '\0')
 352         {
 353                 fatal("do_quantum: bad quantum value '%s' at %s:%d",
 354                         cpe->word, cpe->file, cpe->line);
 355         }
 356
 357         if (quantum_val <= 0)
 358         {
 359                 fatal("do_quantum: quantum %d out of range at %s:%d",
 360                         quantum_val, cpe->file, cpe->line);
 361         }
 362         rs_start->rss_quantum= quantum_val;
 363 }
 364
 365 static void do_cpu(config_t *cpe, struct rs_start *rs_start)
 366 {
 367         int cpu;
 368         char *check;
 369
 370         /* Process a quantum value */
 371         if (cpe->next != NULL)
 372         {
 373                 fatal("do_cpu: just one value expected at %s:%d",
 374                         cpe->file, cpe->line);
 375         }
 376
 377
 378         if (cpe->flags & CFG_SUBLIST)
 379         {
 380                 fatal("do_cpu: unexpected sublist at %s:%d",
 381                         cpe->file, cpe->line);
 382         }
 383         if (cpe->flags & CFG_STRING)
 384         {
 385                 fatal("do_cpu: unexpected string at %s:%d",
 386                         cpe->file, cpe->line);
 387         }
 388         cpu= strtol(cpe->word, &check, 0);
 389         if (check[0] != '\0')
 390         {
 391                 fatal("do_cpu: bad value '%s' at %s:%d",
 392                         cpe->word, cpe->file, cpe->line);
 393         }
 394
 395         if (cpu < 0)
 396         {
 397                 fatal("do_cpu: %d out of range at %s:%d",
 398                         cpu, cpe->file, cpe->line);
 399         }
 400         rs_start->rss_cpu= cpu;
 401 }
 402
 403 static void do_irq(config_t *cpe, struct rs_start *rs_start)
 404 {
 405         int irq;
 406         int first;
 407         char *check;
 408
 409         /* Process a list of IRQs */
 410         first = TRUE;
 411         for (; cpe; cpe= cpe->next)
 412         {
 413                 if (cpe->flags & CFG_SUBLIST)
 414                 {
 415                         fatal("do_irq: unexpected sublist at %s:%d",
 416                                 cpe->file, cpe->line);
 417                 }
 418                 if (cpe->flags & CFG_STRING)
 419                 {
 420                         fatal("do_irq: unexpected string at %s:%d",
 421                                 cpe->file, cpe->line);
 422                 }
 423
 424                 /* No IRQ allowed? (default) */
 425                 if(!strcmp(cpe->word, KW_NONE)) {
 426                         if(!first || cpe->next) {
 427                                 fatal("do_irq: %s keyword not allowed in list",
 428                                 KW_NONE);
 429                         }
 430                         break;
 431                 }
 432
 433                 /* All IRQs are allowed? */
 434                 if(!strcmp(cpe->word, KW_ALL)) {
 435                         if(!first || cpe->next) {
 436                                 fatal("do_irq: %s keyword not allowed in list",
 437                                 KW_ALL);
 438                         }
 439                         rs_start->rss_nr_irq = RSS_IO_ALL;
 440                         break;
 441                 }
 442
 443                 /* Set single IRQs as specified in the configuration. */
 444                 irq= strtoul(cpe->word, &check, 0);
 445                 if (check[0] != '\0')
 446                 {
 447                         fatal("do_irq: bad irq '%s' at %s:%d",
 448                                 cpe->word, cpe->file, cpe->line);
 449                 }
 450                 if (rs_start->rss_nr_irq >= RSS_NR_IRQ)
 451                         fatal("do_irq: too many IRQs (max %d)", RSS_NR_IRQ);
 452                 rs_start->rss_irq[rs_start->rss_nr_irq]= irq;
 453                 rs_start->rss_nr_irq++;
 454                 first = FALSE;
 455         }
 456 }
 457
 458 static void do_io(config_t *cpe, struct rs_start *rs_start)
 459 {
 460         unsigned base, len;
 461         int first;
 462         char *check;
 463
 464         /* Process a list of I/O ranges */
 465         first = TRUE;
 466         for (; cpe; cpe= cpe->next)
 467         {
 468                 if (cpe->flags & CFG_SUBLIST)
 469                 {
 470                         fatal("do_io: unexpected sublist at %s:%d",
 471                                 cpe->file, cpe->line);
 472                 }
 473                 if (cpe->flags & CFG_STRING)
 474                 {
 475                         fatal("do_io: unexpected string at %s:%d",
 476                                 cpe->file, cpe->line);
 477                 }
 478
 479                 /* No range allowed? (default) */
 480                 if(!strcmp(cpe->word, KW_NONE)) {
 481                         if(!first || cpe->next) {
 482                                 fatal("do_io: %s keyword not allowed in list",
 483                                 KW_NONE);
 484                         }
 485                         break;
 486                 }
 487
 488                 /* All ranges are allowed? */
 489                 if(!strcmp(cpe->word, KW_ALL)) {
 490                         if(!first || cpe->next) {
 491                                 fatal("do_io: %s keyword not allowed in list",
 492                                 KW_ALL);
 493                         }
 494                         rs_start->rss_nr_io = RSS_IO_ALL;
 495                         break;
 496                 }
 497
 498                 /* Set single ranges as specified in the configuration. */
 499                 base= strtoul(cpe->word, &check, 0x10);
 500                 len= 1;
 501                 if (check[0] == ':')
 502                 {
 503                         len= strtoul(check+1, &check, 0x10);
 504                 }
 505                 if (check[0] != '\0')
 506                 {
 507                         fatal("do_io: bad I/O range '%s' at %s:%d",
 508                                 cpe->word, cpe->file, cpe->line);
 509                 }
 510
 511                 if (rs_start->rss_nr_io >= RSS_NR_IO)
 512                         fatal("do_io: too many I/O ranges (max %d)", RSS_NR_IO);
 513                 rs_start->rss_io[rs_start->rss_nr_io].base= base;
 514                 rs_start->rss_io[rs_start->rss_nr_io].len= len;
 515                 rs_start->rss_nr_io++;
 516                 first = FALSE;
 517         }
 518 }
 519
 520 static void do_pci_device(config_t *cpe, struct rs_start *rs_start)
 521 {
 522         u16_t vid, did;
 523         char *check, *check2;
 524
 525         /* Process a list of PCI device IDs */
 526         for (; cpe; cpe= cpe->next)
 527         {
 528                 if (cpe->flags & CFG_SUBLIST)
 529                 {
 530                         fatal("do_pci_device: unexpected sublist at %s:%d",
 531                                 cpe->file, cpe->line);
 532                 }
 533                 if (cpe->flags & CFG_STRING)
 534                 {
 535                         fatal("do_pci_device: unexpected string at %s:%d",
 536                                 cpe->file, cpe->line);
 537                 }
 538                 vid= strtoul(cpe->word, &check, 0x10);
 539                 if (check[0] == '/')
 540                         did= strtoul(check+1, &check2, 0x10);
 541                 if (check[0] != '/' || check2[0] != '\0')
 542                 {
 543                         fatal("do_pci_device: bad ID '%s' at %s:%d",
 544                                 cpe->word, cpe->file, cpe->line);
 545                 }
 546                 if (rs_start->rss_nr_pci_id >= RS_NR_PCI_DEVICE)
 547                 {
 548                         fatal("do_pci_device: too many device IDs (max %d)",
 549                                 RS_NR_PCI_DEVICE);
 550                 }
 551                 rs_start->rss_pci_id[rs_start->rss_nr_pci_id].vid= vid;
 552                 rs_start->rss_pci_id[rs_start->rss_nr_pci_id].did= did;
 553                 rs_start->rss_nr_pci_id++;
 554         }
 555 }
 556
 557 static void do_pci_class(config_t *cpe, struct rs_start *rs_start)
 558 {
 559         u8_t baseclass, subclass, interface;
 560         u32_t class_id, mask;
 561         char *check;
 562
 563         /* Process a list of PCI device class IDs */
 564         for (; cpe; cpe= cpe->next)
 565         {
 566                 if (cpe->flags & CFG_SUBLIST)
 567                 {
 568                         fatal("do_pci_device: unexpected sublist at %s:%d",
 569                                 cpe->file, cpe->line);
 570                 }
 571                 if (cpe->flags & CFG_STRING)
 572                 {
 573                         fatal("do_pci_device: unexpected string at %s:%d",
 574                                 cpe->file, cpe->line);
 575                 }
 576
 577                 baseclass= strtoul(cpe->word, &check, 0x10);
 578                 subclass= 0;
 579                 interface= 0;
 580                 mask= 0xff0000;
 581                 if (check[0] == '/')
 582                 {
 583                         subclass= strtoul(check+1, &check, 0x10);
 584                         mask= 0xffff00;
 585                         if (check[0] == '/')
 586                         {
 587                                 interface= strtoul(check+1, &check, 0x10);
 588                                 mask= 0xffffff;
 589                         }
 590                 }
 591
 592                 if (check[0] != '\0')
 593                 {
 594                         fatal("do_pci_class: bad class ID '%s' at %s:%d",
 595                                 cpe->word, cpe->file, cpe->line);
 596                 }
 597                 class_id= (baseclass << 16) | (subclass << 8) | interface;
 598                 if (rs_start->rss_nr_pci_class >= RS_NR_PCI_CLASS)
 599                 {
 600                         fatal("do_pci_class: too many class IDs (max %d)",
 601                                 RS_NR_PCI_CLASS);
 602                 }
 603                 rs_start->rss_pci_class[rs_start->rss_nr_pci_class].pciclass=
 604                         class_id;
 605                 rs_start->rss_pci_class[rs_start->rss_nr_pci_class].mask= mask;
 606                 rs_start->rss_nr_pci_class++;
 607         }
 608 }
 609
 610 static void do_pci(config_t *cpe, struct rs_start *rs_start)
 611 {
 612         if (cpe == NULL)
 613                 return; /* Empty PCI statement */
 614
 615         if (cpe->flags & CFG_SUBLIST)
 616         {
 617                 fatal("do_pci: unexpected sublist at %s:%d",
 618                         cpe->file, cpe->line);
 619         }
 620         if (cpe->flags & CFG_STRING)
 621         {
 622                 fatal("do_pci: unexpected string at %s:%d",
 623                         cpe->file, cpe->line);
 624         }
 625
 626         if (strcmp(cpe->word, KW_DEVICE) == 0)
 627         {
 628                 do_pci_device(cpe->next, rs_start);
 629                 return;
 630         }
 631         if (strcmp(cpe->word, KW_CLASS) == 0)
 632         {
 633                 do_pci_class(cpe->next, rs_start);
 634                 return;
 635         }
 636         fatal("do_pci: unexpected word '%s' at %s:%d",
 637                 cpe->word, cpe->file, cpe->line);
 638 }
 639
 640 static void do_ipc(config_t *cpe, struct rs_start *rs_start)
 641 {
 642         char *list;
 643         const char *word;
 644         char *word_all = RSS_IPC_ALL;
 645         char *word_all_sys = RSS_IPC_ALL_SYS;
 646         size_t listsize, wordlen;
 647         int first;
 648
 649         list= NULL;
 650         listsize= 1;
 651         list= malloc(listsize);
 652         if (list == NULL)
 653                 fatal("do_ipc: unable to malloc %d bytes", listsize);
 654         list[0]= '\0';
 655
 656         /* Process a list of process names that are allowed to be
 657          * contacted
 658          */
 659         first = TRUE;
 660         for (; cpe; cpe= cpe->next)
 661         {
 662                 if (cpe->flags & CFG_SUBLIST)
 663                 {
 664                         fatal("do_ipc: unexpected sublist at %s:%d",
 665                                 cpe->file, cpe->line);
 666                 }
 667                 if (cpe->flags & CFG_STRING)
 668                 {
 669                         fatal("do_ipc: unexpected string at %s:%d",
 670                                 cpe->file, cpe->line);
 671                 }
 672                 word = cpe->word;
 673
 674                 /* All (system) ipc targets are allowed? */
 675                 if(!strcmp(word, KW_ALL) || !strcmp(word, KW_ALL_SYS)) {
 676                         if(!first || cpe->next) {
 677                                 fatal("do_ipc: %s keyword not allowed in list",
 678                                 word);
 679                         }
 680                         word = !strcmp(word, KW_ALL) ? word_all : word_all_sys;
 681                 }
 682
 683                 wordlen= strlen(word);
 684
 685                 listsize += 1 + wordlen;
 686                 list= realloc(list, listsize);
 687                 if (list == NULL)
 688                 {
 689                         fatal("do_ipc: unable to realloc %d bytes",
 690                                 listsize);
 691                 }
 692                 strcat(list, " ");
 693                 strcat(list, word);
 694                 first = FALSE;
 695         }
 696 #if 0
 697         printf("do_ipc: got list '%s'\n", list);
 698 #endif
 699
 700         if (rs_start->rss_ipc)
 701                 fatal("do_ipc: req_ipc is set");
 702         rs_start->rss_ipc = list+1;
 703         rs_start->rss_ipclen= strlen(rs_start->rss_ipc);
 704 }
 705
 706
 707 struct
 708 {
 709         char *label;
 710         int call_nr;
 711 } vm_table[] =
 712 {
 713         { "EXIT",               VM_EXIT },
 714         { "FORK",               VM_FORK },
 715         { "BRK",                VM_BRK },
 716         { "EXEC_NEWMEM",        VM_EXEC_NEWMEM },
 717         { "PUSH_SIG",           0 },
 718         { "WILLEXIT",           VM_WILLEXIT },
 719         { "ADDDMA",             VM_ADDDMA },
 720         { "DELDMA",             VM_DELDMA },
 721         { "GETDMA",             VM_GETDMA },
 722         { "REMAP",              VM_REMAP },
 723         { "REMAP_RO",           VM_REMAP_RO },
 724         { "SHM_UNMAP",          VM_SHM_UNMAP },
 725         { "GETPHYS",            VM_GETPHYS },
 726         { "GETREF",             VM_GETREF },
 727         { "RS_SET_PRIV",        VM_RS_SET_PRIV },
 728         { "QUERY_EXIT",         VM_QUERY_EXIT },
 729         { "WATCH_EXIT",         VM_WATCH_EXIT },
 730         { "NOTIFY_SIG",         VM_NOTIFY_SIG },
 731         { "INFO",               VM_INFO },
 732         { "RS_UPDATE",          VM_RS_UPDATE },
 733         { "RS_MEMCTL",          VM_RS_MEMCTL },
 734         { "PROCCTL",            VM_PROCCTL },
 735         { NULL,                 0 },
 736 };
 737
 738 static void do_vm(config_t *cpe, struct rs_start *rs_start)
 739 {
 740         int i, first;
 741
 742         first = TRUE;
 743         for (; cpe; cpe = cpe->next)
 744         {
 745                 if (cpe->flags & CFG_SUBLIST)
 746                 {
 747                         fatal("do_vm: unexpected sublist at %s:%d",
 748                               cpe->file, cpe->line);
 749                 }
 750                 if (cpe->flags & CFG_STRING)
 751                 {
 752                         fatal("do_vm: unexpected string at %s:%d",
 753                               cpe->file, cpe->line);
 754                 }
 755
 756                 /* Only basic calls allowed? (default). */
 757                 if(!strcmp(cpe->word, KW_BASIC)) {
 758                         if(!first || cpe->next) {
 759                                 fatal("do_vm: %s keyword not allowed in list",
 760                                 KW_NONE);
 761                         }
 762                         break;
 763                 }
 764
 765                 /* No calls allowed? */
 766                 if(!strcmp(cpe->word, KW_NONE)) {
 767                         if(!first || cpe->next) {
 768                                 fatal("do_vm: %s keyword not allowed in list",
 769                                 KW_NONE);
 770                         }
 771                         rs_start->rss_flags &= ~RSS_VM_BASIC_CALLS;
 772                         break;
 773                 }
 774
 775                 /* All calls are allowed? */
 776                 if(!strcmp(cpe->word, KW_ALL)) {
 777                         if(!first || cpe->next) {
 778                                 fatal("do_vm: %s keyword not allowed in list",
 779                                 KW_ALL);
 780                         }
 781                         for (i = 0; i < NR_VM_CALLS; i++)
 782                                 SET_BIT(rs_start->rss_vm, i);
 783                         break;
 784                 }
 785
 786                 /* Set single calls as specified in the configuration. */
 787                 for (i = 0; vm_table[i].label != NULL; i++)
 788                         if (!strcmp(cpe->word, vm_table[i].label))
 789                                 break;
 790                 if (vm_table[i].label == NULL)
 791                         fatal("do_vm: unknown call '%s' at %s:%d",
 792                                 cpe->word, cpe->file, cpe->line);
 793
 794                 if(vm_table[i].call_nr) {
 795                         SET_BIT(rs_start->rss_vm,
 796                                 vm_table[i].call_nr - VM_RQ_BASE);
 797                 }
 798
 799                 first = FALSE;
 800         }
 801 }
 802
 803 struct
 804 {
 805         char *label;
 806         int call_nr;
 807 } system_tab[]=
 808 {
 809         { "PRIVCTL",            SYS_PRIVCTL },
 810         { "TRACE",              SYS_TRACE },
 811         { "KILL",               SYS_KILL },
 812         { "UMAP",               SYS_UMAP },
 813         { "VIRCOPY",            SYS_VIRCOPY },
 814         { "PHYSCOPY",           SYS_PHYSCOPY },
 815         { "UMAP_REMOTE",        SYS_UMAP_REMOTE },
 816         { "VUMAP",              SYS_VUMAP },
 817         { "IRQCTL",             SYS_IRQCTL },
 818         { "INT86",              SYS_INT86 },
 819         { "DEVIO",              SYS_DEVIO },
 820         { "SDEVIO",             SYS_SDEVIO },
 821         { "VDEVIO",             SYS_VDEVIO },
 822         { "ABORT",              SYS_ABORT },
 823         { "IOPENABLE",          SYS_IOPENABLE },
 824         { "READBIOS",           SYS_READBIOS },
 825         { "STIME",              SYS_STIME },
 826         { "VMCTL",              SYS_VMCTL },
 827         { "MEMSET",             SYS_MEMSET },
 828         { NULL,         0 }
 829 };
 830
 831 static void do_system(config_t *cpe, struct rs_start *rs_start)
 832 {
 833         int i, first;
 834
 835         /* Process a list of 'system' calls that are allowed */
 836         first = TRUE;
 837         for (; cpe; cpe= cpe->next)
 838         {
 839                 if (cpe->flags & CFG_SUBLIST)
 840                 {
 841                         fatal("do_system: unexpected sublist at %s:%d",
 842                                 cpe->file, cpe->line);
 843                 }
 844                 if (cpe->flags & CFG_STRING)
 845                 {
 846                         fatal("do_system: unexpected string at %s:%d",
 847                                 cpe->file, cpe->line);
 848                 }
 849
 850                 /* Only basic calls allowed? (default). */
 851                 if(!strcmp(cpe->word, KW_BASIC)) {
 852                         if(!first || cpe->next) {
 853                                 fatal("do_system: %s keyword not allowed in list",
 854                                 KW_NONE);
 855                         }
 856                         break;
 857                 }
 858
 859                 /* No calls allowed? */
 860                 if(!strcmp(cpe->word, KW_NONE)) {
 861                         if(!first || cpe->next) {
 862                                 fatal("do_system: %s keyword not allowed in list",
 863                                 KW_NONE);
 864                         }
 865                         rs_start->rss_flags &= ~RSS_SYS_BASIC_CALLS;
 866                         break;
 867                 }
 868
 869                 /* All calls are allowed? */
 870                 if(!strcmp(cpe->word, KW_ALL)) {
 871                         if(!first || cpe->next) {
 872                                 fatal("do_system: %s keyword not allowed in list",
 873                                 KW_ALL);
 874                         }
 875                         for (i = 0; i < NR_SYS_CALLS; i++)
 876                                 SET_BIT(rs_start->rss_system, i);
 877                         break;
 878                 }
 879
 880                 /* Set single calls as specified in the configuration. */
 881                 for (i = 0; system_tab[i].label != NULL; i++)
 882                         if (!strcmp(cpe->word, system_tab[i].label))
 883                                 break;
 884                 if (system_tab[i].label == NULL)
 885                         fatal("do_system: unknown call '%s' at %s:%d",
 886                                 cpe->word, cpe->file, cpe->line);
 887                 SET_BIT(rs_start->rss_system, system_tab[i].call_nr - KERNEL_CALL);
 888                 first = FALSE;
 889         }
 890 }
 891
 892 static void do_control(config_t *cpe, struct rs_start *rs_start)
 893 {
 894         int nr_control = 0;
 895
 896         /* Process a list of 'control' labels. */
 897         for (; cpe; cpe= cpe->next)
 898         {
 899                 if (cpe->flags & CFG_SUBLIST)
 900                 {
 901                         fatal("do_control: unexpected sublist at %s:%d",
 902                                 cpe->file, cpe->line);
 903                 }
 904                 if (cpe->flags & CFG_STRING)
 905                 {
 906                         fatal("do_control: unexpected string at %s:%d",
 907                                 cpe->file, cpe->line);
 908                 }
 909                 if (nr_control >= RS_NR_CONTROL)
 910                 {
 911                         fatal(
 912                         "do_control: RS_NR_CONTROL is too small (%d needed)",
 913                                 nr_control+1);
 914                 }
 915
 916                 rs_start->rss_control[nr_control].l_addr = (char*) cpe->word;
 917                 rs_start->rss_control[nr_control].l_len = strlen(cpe->word);
 918                 rs_start->rss_nr_control = ++nr_control;
 919         }
 920 }
 921
 922 static void do_service(config_t *cpe, config_t *config, struct rs_config *rs_config)
 923 {
 924         struct rs_start *rs_start = &rs_config->rs_start;
 925         config_t *cp;
 926
 927         /* At this point we expect one sublist that contains the varios
 928          * resource allocations
 929          */
 930         if (!(cpe->flags & CFG_SUBLIST))
 931         {
 932                 fatal("do_service: expected list at %s:%d",
 933                         cpe->file, cpe->line);
 934         }
 935         if (cpe->next != NULL)
 936         {
 937                 cpe= cpe->next;
 938                 fatal("do_service: expected end of list at %s:%d",
 939                         cpe->file, cpe->line);
 940         }
 941         cpe= cpe->list;
 942
 943         /* Process the list */
 944         for (cp= cpe; cp; cp= cp->next)
 945         {
 946                 if (!(cp->flags & CFG_SUBLIST))
 947                 {
 948                         fatal("do_service: expected list at %s:%d",
 949                                 cp->file, cp->line);
 950                 }
 951                 cpe= cp->list;
 952                 if ((cpe->flags & CFG_STRING) || (cpe->flags & CFG_SUBLIST))
 953                 {
 954                         fatal("do_service: expected word at %s:%d",
 955                                 cpe->file, cpe->line);
 956                 }
 957
 958                 if (strcmp(cpe->word, KW_CLASS) == 0)
 959                 {
 960                         do_class(cpe->next, config, rs_config);
 961                         continue;
 962                 }
 963                 if (strcmp(cpe->word, KW_UID) == 0)
 964                 {
 965                         do_uid(cpe->next, rs_start);
 966                         continue;
 967                 }
 968                 if (strcmp(cpe->word, KW_SIGMGR) == 0)
 969                 {
 970                         do_sigmgr(cpe->next, rs_start);
 971                         continue;
 972                 }
 973                 if (strcmp(cpe->word, KW_TYPE) == 0)
 974                 {
 975                         do_type(cpe->next, rs_config);
 976                         continue;
 977                 }
 978                 if (strcmp(cpe->word, KW_DESCR) == 0)
 979                 {
 980                         do_descr(cpe->next, rs_config);
 981                         continue;
 982                 }
 983                 if (strcmp(cpe->word, KW_SCHEDULER) == 0)
 984                 {
 985                         do_scheduler(cpe->next, rs_start);
 986                         continue;
 987                 }
 988                 if (strcmp(cpe->word, KW_PRIORITY) == 0)
 989                 {
 990                         do_priority(cpe->next, rs_start);
 991                         continue;
 992                 }
 993                 if (strcmp(cpe->word, KW_QUANTUM) == 0)
 994                 {
 995                         do_quantum(cpe->next, rs_start);
 996                         continue;
 997                 }
 998                 if (strcmp(cpe->word, KW_CPU) == 0)
 999                 {
1000                         do_cpu(cpe->next, rs_start);
1001                         continue;
1002                 }
1003                 if (strcmp(cpe->word, KW_IRQ) == 0)
1004                 {
1005                         do_irq(cpe->next, rs_start);
1006                         continue;
1007                 }
1008                 if (strcmp(cpe->word, KW_IO) == 0)
1009                 {
1010                         do_io(cpe->next, rs_start);
1011                         continue;
1012                 }
1013                 if (strcmp(cpe->word, KW_PCI) == 0)
1014                 {
1015                         do_pci(cpe->next, rs_start);
1016                         continue;
1017                 }
1018                 if (strcmp(cpe->word, KW_SYSTEM) == 0)
1019                 {
1020                         do_system(cpe->next, rs_start);
1021                         continue;
1022                 }
1023                 if (strcmp(cpe->word, KW_IPC) == 0)
1024                 {
1025                         do_ipc(cpe->next, rs_start);
1026                         continue;
1027                 }
1028                 if (strcmp(cpe->word, KW_VM) == 0)
1029                 {
1030                         do_vm(cpe->next, rs_start);
1031                         continue;
1032                 }
1033                 if (strcmp(cpe->word, KW_CONTROL) == 0)
1034                 {
1035                         do_control(cpe->next, rs_start);
1036                         continue;
1037                 }
1038         }
1039 }
1040
1041 static const char *do_config(const char *label, char *filename, struct rs_config *rs_config)
1042 {
1043         config_t *config, *cp, *cpe;
1044         struct passwd *pw;
1045         struct rs_start *rs_start = &rs_config->rs_start;
1046
1047         if(!(config= config_read(filename, 0, NULL)))
1048                 return NULL; /* config file read failed. */
1049
1050         /* Set clean rs_start defaults. */
1051         memset(rs_config, 0, sizeof(*rs_config));
1052         if(!(pw= getpwnam(SERVICE_LOGIN)))
1053                 fatal("no passwd file entry for '%s'", SERVICE_LOGIN);
1054         rs_start->rss_uid= pw->pw_uid;
1055         rs_start->rss_sigmgr= DSRV_SM;
1056         rs_start->rss_scheduler= DSRV_SCH;
1057         rs_start->rss_priority= DSRV_Q;
1058         rs_start->rss_quantum= DSRV_QT;
1059         rs_start->rss_cpu = DSRV_CPU;
1060         rs_start->rss_flags = RSS_VM_BASIC_CALLS | RSS_SYS_BASIC_CALLS;
1061
1062         /* Find an entry for our service */
1063         for (cp= config; cp; cp= cp->next)
1064         {
1065                 if (!(cp->flags & CFG_SUBLIST))
1066                 {
1067                         fatal("do_config: expected list at %s:%d",
1068                                 cp->file, cp->line);
1069                 }
1070                 cpe= cp->list;
1071                 if ((cpe->flags & CFG_STRING) || (cpe->flags & CFG_SUBLIST))
1072                 {
1073                         fatal("do_config: expected word at %s:%d",
1074                                 cpe->file, cpe->line);
1075                 }
1076
1077                 /* At this place we expect the word KW_SERVICE */
1078                 if (strcmp(cpe->word, KW_SERVICE) != 0)
1079                         fatal("do_config: exected word '%S' at %s:%d",
1080                                 KW_SERVICE, cpe->file, cpe->line);
1081
1082                 cpe= cpe->next;
1083                 if ((cpe->flags & CFG_STRING) || (cpe->flags & CFG_SUBLIST))
1084                 {
1085                         fatal("do_config: expected word at %s:%d",
1086                                 cpe->file, cpe->line);
1087                 }
1088
1089                 /* At this place we expect the name of the service. */
1090                 if (!label || strcmp(cpe->word, label) == 0) {
1091                         label = cpe->word;
1092                         break;
1093                 }
1094         }
1095         if (cp == NULL)
1096         {
1097                 fprintf(stderr, "service: service '%s' not found in '%s'\n",
1098                         label, filename);
1099                 exit(1);
1100         }
1101
1102         cpe= cpe->next;
1103
1104         do_service(cpe, config, rs_config);
1105
1106         {
1107                 char *default_ipc = RSS_IPC_ALL_SYS;
1108                 if(!rs_start->rss_ipc) {
1109                       rs_start->rss_ipc= default_ipc;
1110                       rs_start->rss_ipclen= strlen(default_ipc);
1111                 }
1112         }
1113
1114         /* config file read ok. */
1115         return label;
1116 }
1117
1118 /* returns failure */
1119 const char *parse_config(char *progname, int custom_config, char *req_config,
1120         struct rs_config *rs_config)
1121 {
1122         char *specificconfig, *specific_pkg_config;
1123         const char *l;
1124
1125         /* Config file specified? */
1126         if(custom_config)
1127           return do_config(progname, req_config, rs_config);
1128
1129         /* No specific config file. */
1130         if(asprintf(&specificconfig, "%s/%s", _PATH_SYSTEM_CONF_DIR,
1131               progname) < 0) {
1132               errx(1, "no memory");
1133         }
1134
1135         if(asprintf(&specific_pkg_config, "%s/%s", _PATH_SYSTEM_CONF_PKG_DIR,
1136               progname) < 0) {
1137               errx(1, "no memory");
1138         }
1139
1140         /* Try specific config filename first, in base system
1141          * and package locations, * and only if it fails, the global
1142          * system one.
1143          */
1144         if((l=do_config(progname, specific_pkg_config, rs_config))) return l;
1145         if((l=do_config(progname, specificconfig, rs_config))) return l;
1146         if((l=do_config(progname, req_config, rs_config))) return l;
1147
1148         return NULL;
1149 }
1150