home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / misc / src / install / .#kickstart.c.1.4 < prev    next >
Text File  |  1997-09-18  |  3KB  |  154 lines
  1. #include <alloca.h>
  2. #include <ctype.h>
  3. #include <errno.h>
  4. #include <fcntl.h>
  5. #include <sys/stat.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <newt.h>
  9. #include <popt.h>
  10. #include <unistd.h>
  11.  
  12. #include "install.h"
  13. #include "kickstart.h"
  14.  
  15. struct ksCommandNames {
  16.     int code;
  17.     char * name;
  18. } ;
  19.  
  20. struct ksCommand {
  21.     int code, argc;
  22.     char ** argv;
  23. };
  24.  
  25. struct ksCommandNames ksTable[] = {
  26.     { KS_CMD_NFS, "nfs" },
  27.     { KS_CMD_INSTALL, "install" },
  28.     { KS_CMD_UPGRADE, "upgrade" },
  29.     { KS_CMD_ROOTPW, "rootpw" },
  30. #if defined(__i386__)
  31.     { KS_CMD_LILO, "lilo" },
  32. #else if defined(__sparc__)
  33.     { KS_CMD_LILO, "silo" },
  34. #endif
  35.     { KS_CMD_PART, "part" },
  36.     { KS_CMD_CLEARPART, "clearpart" },
  37.     { KS_CMD_KEYBOARD, "keyboard" },
  38.     { KS_CMD_MOUSE, "mouse" },
  39.     { KS_CMD_TIMEZONE, "timezone" },
  40.     { KS_CMD_NONE, NULL }
  41. };
  42.  
  43. struct ksCommand * commands = NULL;
  44. int numCommands = 0;
  45.  
  46. int ksReadCommands(char * cmdFile) {
  47.     int fd;
  48.     char * buf;
  49.     struct stat sb;
  50.     char * start, * end;
  51.     char oldch;
  52.     int line = 0;
  53.     char ** argv; 
  54.     int argc;
  55.     struct ksCommandNames * cmd;
  56.     int numAlloced = 5;
  57.  
  58.     if ((fd = open(cmdFile, O_RDONLY)) < 0) {
  59.     newtWinMessage("Kickstart Error", "Ok", 
  60.             "Error opening: kickstart file %s: %s", cmdFile, 
  61.             strerror(errno));
  62.     return INST_ERROR;
  63.     }
  64.  
  65.     fstat(fd, &sb);
  66.  
  67.     buf = alloca(sb.st_size + 1);
  68.     if (read(fd, buf, sb.st_size) != sb.st_size) {
  69.     newtWinMessage("Kickstart Error", "Ok", 
  70.             "Error reading contents of kickstart file %s: %s",
  71.             cmdFile, strerror(errno));
  72.     close(fd);
  73.     return INST_ERROR;
  74.     }
  75.  
  76.     close(fd);
  77.  
  78.     buf[sb.st_size] = '\0';
  79.  
  80.     commands = malloc(sizeof(*commands) * numAlloced);
  81.  
  82.     start = buf;
  83.     while (*start) {
  84.     line++;
  85.  
  86.     if (!(end = strchr(start, '\n')))
  87.         end = start + strlen(start);
  88.  
  89.     oldch = *end;
  90.     *end = '\0';
  91.  
  92.     while (*start && isspace(*start)) start++;
  93.  
  94.     if (*start && *start != '#') {
  95.         if (poptParseArgvString(start, &argc, &argv) || !argc) {
  96.         newtWinMessage("Kickstart Error", "Ok", 
  97.                 "Error on line %d of kickstart file %s.",
  98.                 argv[0], line, cmdFile);
  99.         } else {
  100.         for (cmd = ksTable; cmd->name; cmd++)
  101.             if (!strcmp(cmd->name, argv[0])) break;
  102.  
  103.         if (!cmd->name) {
  104.             newtWinMessage("Kickstart Error", "Ok", 
  105.                    "Unknown command %s on line %d of "
  106.                    "kickstart file %s.", argv[0], line, 
  107.                    cmdFile);
  108.         } else {
  109.             if (numCommands == numAlloced) {
  110.             numAlloced += 5;
  111.             commands = realloc(commands,
  112.                        sizeof(*commands) * numAlloced);
  113.             }
  114.  
  115.             commands[numCommands].code = cmd->code;
  116.             commands[numCommands].argc = argc;
  117.             commands[numCommands].argv = argv;
  118.             numCommands++;
  119.         }
  120.         }
  121.     }
  122.  
  123.     if (oldch)
  124.         start = end + 1;
  125.     else
  126.         start = end;
  127.     }
  128.  
  129.     return 0;
  130. }
  131.  
  132. int ksGetCommand(int cmd, char ** last, int * argc, char *** argv) {
  133.     int i = 0;
  134.  
  135.     if (last) {
  136.     for (i = 0; i < numCommands; i++) {
  137.         if (commands[i].argv == last) break;
  138.     }
  139.  
  140.     i++;
  141.     }
  142.  
  143.     while (i < numCommands) {
  144.     if (commands[i].code == cmd) {
  145.         if (argv) *argv = commands[i].argv;
  146.         if (argc) *argc = commands[i].argc;
  147.         return 0;
  148.     }
  149.     i++;
  150.     }
  151.  
  152.     return 1;
  153. }
  154.