loader.c~

linux 安装程序

    int i;
    struct device ** devices;

    devices = probeDevices(CLASS_HD, BUS_UNSPEC, PROBE_LOADED);
    if (devices)
        return;

    return;

    /* If they're using kickstart, assume they might know what they're doing.
     * Worst case is we fail later */
    if (FL_KICKSTART(flags)) {
        logMessage(WARNING, "no hard drives found, but in kickstart so continuing anyway");
        return;
    }
    
    startNewt();
    i = newtWinChoice(_("Warning"), _("Yes"), _("No"),
                      _("No hard drives have been found.  You probably need "
                        "to manually choose device drivers for the "
                        "installation to succeed.  Would you like to "
                        "select drivers now?"));
    if (i != 2)
        flags |= LOADER_FLAGS_ISA;

    return;
}

static void writeVNCPasswordFile(char *pfile, char *password) {
    FILE *f;

    f = fopen(pfile, "w+");
    fprintf(f, "%s\n", password);
    fclose(f);
}

/* read information from /tmp/netinfo (written by linuxrc) */
static void readNetInfo(struct loaderData_s ** ld) {
    int i;
    struct loaderData_s * loaderData = *ld;
    FILE *f;
    /* FIXME: arbitrary size that works, but could blow up in the future */
    int bufsiz = 100;
    char buf[bufsiz], *vname, *vparm;

    f = fopen("/tmp/netinfo", "r");
    if (!f)
        return;

    /* FIXME: static buffers lead to pain */
    vname = (char *)malloc(sizeof(char)*15);
    vparm = (char *)malloc(sizeof(char)*85);

    /*
     * The /tmp/netinfo file is written out by /sbin/init on s390x (which is
     * really the linuxrc.s390 script).  It's a shell-sourcable file with
     * various system settings needing for the system instance.
     *
     * The goal of this function is to read in only the network settings
     * and populate the loaderData structure.
     */
    while(fgets(buf, bufsiz, f)) {
        /* trim whitespace from end */
        i = 0;
        while (!isspace(buf[i]) && i < (bufsiz-1))
            i++;
        buf[i] = '\0';

        /* break up var name and value */
        if (strstr(buf, "=")) {
            vname = strtok(buf, "=");
            if (vname == NULL)
                continue;

            vparm = strtok(NULL, "=");
            if (vparm == NULL)
                continue;

            if (!strncmp(vname, "IPADDR", 6)) {
                loaderData->ipv4 = strdup(vparm);
                loaderData->ipinfo_set = 1;
            }

            if (!strncmp(vname, "NETMASK", 7))
                loaderData->netmask = strdup(vparm);

            if (!strncmp(vname, "GATEWAY", 7))
                loaderData->gateway = strdup(vparm);

            if (!strncmp(vname, "DNS", 3))
                loaderData->dns = strdup(vparm);

            if (!strncmp(vname, "MTU", 3))
                loaderData->mtu = atoi(vparm);

            if (!strncmp(vname, "PEERID", 6))
                loaderData->peerid = strdup(vparm);

            if (!strncmp(vname, "SUBCHANNELS", 12))
                loaderData->subchannels = strdup(vparm);

            if (!strncmp(vname, "PORTNAME", 8))
                loaderData->portname = strdup(vparm);

            if (!strncmp(vname, "NETTYPE", 7))
                loaderData->nettype = strdup(vparm);

            if (!strncmp(vname, "CTCPROT", 7))
                loaderData->ctcprot = strdup(vparm);
        }
    }

    fclose(f);
}

/* parse anaconda or pxelinux-style ip= arguments
 * pxelinux format: ip=<client-ip>:<boot-server-ip>:<gw-ip>:<netmask>
 * anaconda format: ip=<client-ip> netmask=<netmask> gateway=<gw-ip>
*/
static void parseCmdLineIp(struct loaderData_s * loaderData, char *argv)
{
  /* Detect pxelinux */
  if (strstr(argv, ":") != NULL) {
    char *start, *end;

    /* IP */
    start = argv + 3;
    end = strstr(start, ":");
    loaderData->ipv4 = strndup(start, end-start);
    loaderData->ipinfo_set = 0;

    /* Boot server */
    if (end + 1 == '\0')
      return;
    start = end + 1;
    end = strstr(start, ":");
    if (end == NULL)
      return;

    /* Gateway */
    if (end + 1 == '\0')
      return;
    start = end + 1;
    end = strstr(start, ":");
    if (end == NULL) {
      loaderData->gateway = strdup (start);
      return;
    } else 
      loaderData->gateway = strndup(start, end-start);

    /* Netmask */
    if (end + 1 == '\0')
      return;
    start = end + 1;
    loaderData->netmask = strdup(start);
  } else {
    loaderData->ipv4 = strdup(argv + 3);
    loaderData->ipinfo_set = 0;
  }
}

/*
 * parse anaconda ipv6= arguments
 */
static void parseCmdLineIpv6(struct loaderData_s * loaderData, char *argv)
{
    /* right now we only accept ipv6= arguments equal to:
     *     dhcp     DHCPv6 call
     *     auto     RFC 2461 neighbor discovery
     */
    if (!strncmp(str2lower(argv), "dhcp", 4)) {
        loaderData->ipv6 = strdup("dhcp");
        loaderData->ipv6info_set = 1;
    } else if (!strncmp(str2lower(argv), "auto", 4)) {
        loaderData->ipv6 = strdup("auto");
        loaderData->ipv6info_set = 1;
    }

    return;
}

/* parses /proc/cmdline for any arguments which are important to us.  
 * NOTE: in test mode, can specify a cmdline with --cmdline
 */
static void parseCmdLineFlags(struct loaderData_s * loaderData,
                              char * cmdLine) {
    int fd;
    char buf[1024];
    int len;
    char ** argv;
    int argc;
    int numExtraArgs = 0;
    int i;
    char *front;

    /* we want to default to graphical and allow override with 'text' */
    flags |= LOADER_FLAGS_GRAPHICAL;

    /* if we have any explicit cmdline (probably test mode), we don't want
     * to parse /proc/cmdline */
    if (!cmdLine) {
        if ((fd = open("/proc/cmdline", O_RDONLY)) < 0) return;
        len = read(fd, buf, sizeof(buf) - 1);
        close(fd);
        if (len <= 0) {
            logMessage(INFO, "kernel command line was empty");
            return;
        }
        
        buf[len] = '\0';
        cmdLine = buf;
    }

    logMessage(INFO, "kernel command line: %s", cmdLine);
    
    if (poptParseArgvString(cmdLine, &argc, (const char ***) &argv))
        return;

    for (i=0; i < argc; i++) {
        if (!strcasecmp(argv[i], "expert")) {
            flags |= LOADER_FLAGS_EXPERT;
            logMessage(INFO, "expert got used, ignoring");
            /* flags |= (LOADER_FLAGS_EXPERT | LOADER_FLAGS_MODDISK | 
                        LOADER_FLAGS_ASKMETHOD);*/
        } else if (!strcasecmp(argv[i], "askmethod"))
            flags |= LOADER_FLAGS_ASKMETHOD;
        else if (!strcasecmp(argv[i], "asknetwork"))
            flags |= LOADER_FLAGS_ASKNETWORK;
        else if (!strcasecmp(argv[i], "noshell"))
            flags |= LOADER_FLAGS_NOSHELL;
        else if (!strcasecmp(argv[i], "mediacheck"))
            flags |= LOADER_FLAGS_MEDIACHECK;
        else if (!strcasecmp(argv[i], "nousbstorage"))
            flags |= LOADER_FLAGS_NOUSBSTORAGE;
        else if (!strcasecmp(argv[i], "nousb"))
            flags |= LOADER_FLAGS_NOUSB;
        /*        else if (!strcasecmp(argv[i], "ub"))
                  flags |= LOADER_FLAGS_UB;*/
        else if (!strcasecmp(argv[i], "libata.ignore_hpa=1"))
            flags |= LOADER_FLAGS_IGNOREHPA;
        else if (!strcasecmp(argv[i], "telnet"))
            flags |= LOADER_FLAGS_TELNETD;
        else if (!strcasecmp(argv[i], "nofirewire"))
            flags |= LOADER_FLAGS_NOIEEE1394;
        else if (!strcasecmp(argv[i], "nonet"))
            flags |= LOADER_FLAGS_NONET;
        else if (!strcasecmp(argv[i], "nostorage"))
            flags |= LOADER_FLAGS_NOSTORAGE;
        else if (!strcasecmp(argv[i], "noprobe"))
            flags |= (LOADER_FLAGS_NONET | LOADER_FLAGS_NOSTORAGE | LOADER_FLAGS_NOUSB | LOADER_FLAGS_NOIEEE1394);
        else if (!strcasecmp(argv[i], "nopcmcia"))
            flags |= LOADER_FLAGS_NOPCMCIA;
        else if (!strcasecmp(argv[i], "text")) {
            logMessage(INFO, "text mode forced from cmdline");
            flags |= LOADER_FLAGS_TEXT;
            flags &= ~LOADER_FLAGS_GRAPHICAL;
        }
        else if (!strcasecmp(argv[i], "graphical")) {
            logMessage(INFO, "graphical mode forced from cmdline");
            flags |= LOADER_FLAGS_GRAPHICAL;
        } else if (!strcasecmp(argv[i], "cmdline")) {
            logMessage(INFO, "cmdline mode forced from cmdline");
            flags |= LOADER_FLAGS_CMDLINE;
        } else if (!strncasecmp(argv[i], "updates=", 8))
            loaderData->updatessrc = strdup(argv[i] + 8);
        else if (!strncasecmp(argv[i], "updates", 7))
            flags |= LOADER_FLAGS_UPDATES;
        else if (!strcasecmp(argv[i], "isa"))
            flags |= LOADER_FLAGS_ISA;
        else if (!strncasecmp(argv[i], "dd=", 3) || 
                 !strncasecmp(argv[i], "driverdisk=", 11)) {
            loaderData->ddsrc = strdup(argv[i] + 
                                       (argv[i][1] == 'r' ? 11 : 3));
        }
        else if (!strcasecmp(argv[i], "dd") || 
                 !strcasecmp(argv[i], "driverdisk"))
            flags |= LOADER_FLAGS_MODDISK;
        else if (!strcasecmp(argv[i], "rescue"))
            flags |= LOADER_FLAGS_RESCUE;
        else if (!strcasecmp(argv[i], "nopass"))
            flags |= LOADER_FLAGS_NOPASS;
        else if (!strcasecmp(argv[i], "serial")) 
            flags |= LOADER_FLAGS_SERIAL;
        else if (!strcasecmp(argv[i], "nofb"))
            flags |= LOADER_FLAGS_NOFB;
        else if (!strcasecmp(argv[i], "noipv6")) {
            flags |= LOADER_FLAGS_NOIPV6;
            loaderData->noipv6 = 1;
        } else if (!strcasecmp(argv[i], "kssendmac"))
            flags |= LOADER_FLAGS_KICKSTART_SEND_MAC;
        else if (!strncasecmp(argv[i], "loglevel=", 9)) {
            if (!strcasecmp(argv[i]+9, "debug")) {
                loaderData->logLevel = strdup(argv[i]+9);
                setLogLevel(DEBUGLVL);
            }
            else if (!strcasecmp(argv[i]+9, "info")) {
                loaderData->logLevel = strdup(argv[i]+9);
                setLogLevel(INFO);
            }
            else if (!strcasecmp(argv[i]+9, "warning")) {
                loaderData->logLevel = strdup(argv[i]+9);
                setLogLevel(WARNING);
            }
            else if (!strcasecmp(argv[i]+9, "error")) {
                loaderData->logLevel = strdup(argv[i]+9);
                setLogLevel(ERROR);
            }
            else if (!strcasecmp(argv[i]+9, "critical")) {
                loaderData->logLevel = strdup(argv[i]+9);
                setLogLevel(CRITICAL);
            }
        }
        else if (!strncasecmp(argv[i], "ksdevice=", 9)) {
            loaderData->netDev = strdup(argv[i] + 9);
            loaderData->netDev_set = 1;
        }
        else if (!strncmp(argv[i], "BOOTIF=", 7)) {
            /* +10 so that we skip over the leading 01- */
            loaderData->bootIf = strdup(argv[i] + 10);

            /* scan the BOOTIF value and replace '-' with ':' */
            front = loaderData->bootIf;
            if (front) {
                while (*front != '\0') {
                    if (*front == '-')
                        *front = ':';
                    front++;
                }
            }

            loaderData->bootIf_set = 1;
        } else if (!strncasecmp(argv[i], "dhcpclass=", 10)) {
            loaderData->netCls = strdup(argv[i] + 10);
            loaderData->netCls_set = 1;
        }
        else if (!strcasecmp(argv[i], "ks") || !strncasecmp(argv[i], "ks=", 3))
            loaderData->ksFile = strdup(argv[i]);
        else if (!strncasecmp(argv[i], "display=", 8))
            setenv("DISPLAY", argv[i] + 8, 1);
        else if ((!strncasecmp(argv[i], "lang=", 5)) && 
                 (strlen(argv[i]) > 5))  {
            loaderData->lang = strdup(argv[i] + 5);
            loaderData->lang_set = 1;
        }
        else if (!strncasecmp(argv[i], "keymap=", 7) &&
                   (strlen(argv[i]) > 7)) {
            loaderData->kbd = strdup(argv[i] + 7);
            loaderData->kbd_set = 1;
        }
        else if (!strncasecmp(argv[i], "method=", 7))
            setMethodFromCmdline(argv[i] + 7, loaderData);
        else if (!strncasecmp(argv[i], "ip=", 3))
            parseCmdLineIp(loaderData, argv[i]);
        else if (!strncasecmp(argv[i], "ipv6=", 5))
            parseCmdLineIpv6(loaderData, argv[i]);
        else if (!strncasecmp(argv[i], "netmask=", 8)) 
            loaderData->netmask = strdup(argv[i] + 8);
        else if (!strncasecmp(argv[i], "gateway=", 8))
            loaderData->gateway = strdup(argv[i] + 8);
        else if (!strncasecmp(argv[i], "dns=", 4))
            loaderData->dns = strdup(argv[i] + 4);
        else if (!strncasecmp(argv[i], "ethtool=", 8))
            loaderData->ethtool = strdup(argv[i] + 8);
        else if (!strncasecmp(argv[i], "essid=", 6))
            loaderData->essid = strdup(argv[i] + 6);
        else if (!strncasecmp(argv[i], "mtu=", 4))
            loaderData->mtu = atoi(argv[i] + 4);
        else if (!strncasecmp(argv[i], "wepkey=", 7))
            loaderData->wepkey = strdup(argv[i] + 7);
        else if (!strncasecmp(argv[i], "linksleep=", 10))
            num_link_checks = atoi(argv[i] + 10);
        else if (!strncasecmp(argv[i], "selinux=0", 9))
            flags &= ~LOADER_FLAGS_SELINUX;
        else if (!strncasecmp(argv[i], "selinux", 7))
            flags |= LOADER_FLAGS_SELINUX;
        else if (numExtraArgs < (MAX_EXTRA_ARGS - 1)) {
            /* go through and append args we just want to pass on to */
            /* the anaconda script, but don't want to represent as a */
            /* LOADER_FLAGS_XXX since loader doesn't care about these */
            /* particular options.                                   */
            /* do vncpassword case first */
            if (!strncasecmp(argv[i], "vncpassword=", 12)) {
                if (!FL_TESTING(flags))
                    writeVNCPasswordFile("/tmp/vncpassword.dat", argv[i]+12);
            }
            else if (!strncasecmp(argv[i], "resolution=", 11) ||
                     !strncasecmp(argv[i], "lowres", 6) ||