!strncasecmp(argv[i], "nomount", 7) ||                     !strncasecmp(argv[i], "vnc", 3) ||                     !strncasecmp(argv[i], "vncconnect=", 11) ||                     !strncasecmp(argv[i], "headless", 8) ||                     !strncasecmp(argv[i], "usefbx", 6) ||                     !strncasecmp(argv[i], "mpath", 6) ||                     !strncasecmp(argv[i], "nompath", 8) ||                     !strncasecmp(argv[i], "dmraid", 6) ||                     !strncasecmp(argv[i], "nodmraid", 8) ||                     !strncasecmp(argv[i], "xdriver=", 8) ||                     !strncasecmp(argv[i], "vesa", 4) ||                     !strncasecmp(argv[i], "syslog=", 7)) {                 /* vnc implies graphical */                if (!strncasecmp(argv[i], "vnc", 3)) {                    logMessage(INFO, "vnc forced cmdline mode from cmdline");                    flags |= LOADER_FLAGS_GRAPHICAL;                }                if (!strncasecmp(argv[i], "vesa", 4)) {                    if (asprintf(&extraArgs[numExtraArgs],                                 "--xdriver=vesa") == -1)                        return;                    logMessage(WARNING, "\"vesa\" command line argument is deprecated.  Use \"xdriver=vesa\".");                } else {                    if (asprintf(&extraArgs[numExtraArgs],"--%s",argv[i]) == -1)                        return;                }                numExtraArgs += 1;                if (numExtraArgs > (MAX_EXTRA_ARGS - 2)) {                     logMessage(WARNING, "Too many command line arguments (max "                                "allowed is %d), rest will be dropped.",                                MAX_EXTRA_ARGS);                }            }        }    }    readNetInfo(&loaderData);    /* NULL terminates the array of extra args */    extraArgs[numExtraArgs] = NULL;    return;}#if 0/* determine if we are using a framebuffer console.  return 1 if so */static int checkFrameBuffer() {    int fd;    int rc = 0;    struct fb_fix_screeninfo fix;    if ((fd = open("/dev/fb0", O_RDONLY)) == -1) {        return 0;    }        if (ioctl(fd, FBIOGET_FSCREENINFO, &fix) >= 0) {        rc = 1;    }    close(fd);    return rc;}#endif/* make sure they have enough ram */static void checkForRam(void) {    if (totalMemory() < MIN_RAM) {        char *buf;        buf = sdupprintf(_("You do not have enough RAM to install %s "                           "on this machine."), getProductName());        startNewt();        newtWinMessage(_("Error"), _("OK"), buf);        free(buf);        stopNewt();        exit(0);    }}static int haveDeviceOfType(int type, moduleList modLoaded) {    struct device ** devices;    devices = probeDevices(type, BUS_UNSPEC, PROBE_LOADED);    if (devices) {        return 1;    }    return 0;}/* fsm for the basics of the loader. */static char *doLoaderMain(char * location,                          struct loaderData_s * loaderData,                          moduleInfoSet modInfo,                          moduleList modLoaded,                          moduleDeps * modDepsPtr) {    enum { STEP_LANG, STEP_KBD, STEP_METHOD, STEP_DRIVER,            STEP_DRIVERDISK, STEP_NETWORK, STEP_IFACE,           STEP_IP, STEP_URL, STEP_DONE } step;    char * url = NULL;    char * ret = NULL;    int dir = 1;    int rc, i;    char * installNames[10]; /* 10 install methods will be enough for anyone */    int numValidMethods = 0;    int validMethods[10];    int methodNum = -1;    int needed = -1;    int needsNetwork = 0;    int rhcdfnd = 0;    char * devName = NULL;    static struct networkDeviceConfig netDev;    char * kbdtype = NULL;    for (i = 0; i < numMethods; i++, numValidMethods++) {        installNames[numValidMethods] = installMethods[i].name;        validMethods[numValidMethods] = i;    }    installNames[numValidMethods] = NULL;    /* have we preselected this to be our install method? */    if (loaderData->method >= 0) {        methodNum = loaderData->method;        /* disable the fast path (#102652) */        flags |= LOADER_FLAGS_ASKMETHOD;    }    /* check to see if we have a CD.  If we have one, then     * we can fast-path the CD and not make people answer questions in      * text mode.  */    if (!FL_ASKMETHOD(flags) && !FL_KICKSTART(flags)) {        url = findAnacondaCD(location, modInfo, modLoaded, * modDepsPtr, !FL_RESCUE(flags));        /* if we found a CD and we're not in rescue or vnc mode return */        /* so we can short circuit straight to stage 2 from CD         */        if (url && (!FL_RESCUE(flags) && !hasGraphicalOverride()))            return url;        else {            rhcdfnd = 1;            methodNum = 0;        }    }    if (!FL_CMDLINE(flags))        startNewt();    step = STEP_LANG;    while (step != STEP_DONE) {        switch(step) {        case STEP_LANG:            if (loaderData->lang && (loaderData->lang_set == 1)) {                setLanguage(loaderData->lang);            } else {                chooseLanguage(&loaderData->lang);            }            step = STEP_KBD;            dir = 1;            break;        case STEP_KBD:            if (loaderData->kbd && (loaderData->kbd_set == 1)) {                /* JKFIXME: this is broken -- we should tell of the                  * failure; best by pulling code out in kbd.c to use */                if (isysLoadKeymap(loaderData->kbd)) {                    logMessage(WARNING, "requested keymap %s is not valid, asking", loaderData->kbd);                    loaderData->kbd = NULL;                    loaderData->kbd_set = 0;                    break;                }                rc = LOADER_NOOP;            } else {                /* JKFIXME: should handle kbdtype, too probably... but it                  * just matters for sparc */                if (!FL_CMDLINE(flags))                    rc = chooseKeyboard(loaderData, &kbdtype);                else                   rc = LOADER_NOOP;            }            if (rc == LOADER_NOOP) {                if (dir == -1)                    step = STEP_LANG;                else                    step = STEP_METHOD;                break;            }            if (rc == LOADER_BACK) {                step = STEP_LANG;                dir = -1;            } else {                step = STEP_METHOD;                dir = 1;            }            break;        case STEP_METHOD:            /* this is kind of crappy, but we want the first few questions             * to be asked when using rescue mode even if we're going             * to short-circuit to the CD.             *             * Alternately, if we're in a VNC install based from CD we             * can skip this step because we already found the CD */            if (url) {                if (FL_RESCUE(flags)) {                    return url;                } else if (rhcdfnd) {                    step = STEP_NETWORK;                    dir = 1;                    break;                }            }	                needed = -1;            if (loaderData->method != -1 && methodNum != -1) {                rc = 1;            } else {                /* we need to set these each time through so that we get                 * updated for language changes (#83672) */                for (i = 0; i < numMethods; i++) {                    installNames[i] = _(installMethods[i].name);                }                installNames[i] = NULL;                rc = newtWinMenu(FL_RESCUE(flags) ? _("Rescue Method") :                                 _("Installation Method"),                                 FL_RESCUE(flags) ?                                 _("What type of media contains the rescue "                                   "image?") :                                 _("What type of media contains the packages to "                                   "be installed?"),                                 30, 10, 20, 6, installNames, &methodNum,                                  _("OK"), _("Back"), NULL);            }             if (rc && rc != 1) {                step = STEP_KBD;                dir = -1;            } else {                needed = installMethods[validMethods[methodNum]].deviceType;                step = STEP_DRIVER;                dir = 1;            }            break;        case STEP_DRIVER: {            if (needed == -1 || haveDeviceOfType(needed, modLoaded)) {                step = STEP_NETWORK;                dir = 1;                needed = -1;                break;            }            rc = newtWinTernary(_("No driver found"), _("Select driver"),                                _("Use a driver disk"), _("Back"),                                _("Unable to find any devices of the type "                                  "needed for this installation type.  "                                  "Would you like to manually select your "                                  "driver or use a driver disk?"));            if (rc == 2) {                step = STEP_DRIVERDISK;                dir = 1;                break;            } else if (rc == 3) {                step = STEP_METHOD;                dir = -1;                break;            }                        chooseManualDriver(installMethods[validMethods[methodNum]].deviceType,                               modLoaded, modDepsPtr, modInfo);            /* it doesn't really matter what we return here; we just want             * to reprobe and make sure we have the driver */            step = STEP_DRIVER;            break;        }        case STEP_DRIVERDISK:            rc = loadDriverFromMedia(needed,                                     modLoaded, modDepsPtr, modInfo, 0, 0);            if (rc == LOADER_BACK) {                step = STEP_DRIVER;                dir = -1;                break;            }            /* need to come back to driver so that we can ensure that we found             * the right kind of driver after loading the driver disk */            step = STEP_DRIVER;            break;        case STEP_NETWORK:            if ( (installMethods[validMethods[methodNum]].deviceType !=                   CLASS_NETWORK) && (!hasGraphicalOverride()) &&                 !FL_ASKNETWORK(flags)) {                needsNetwork = 0;                if (dir == 1)                     step = STEP_URL;                else if (dir == -1)                    step = STEP_METHOD;                break;            }            needsNetwork = 1;            if (!haveDeviceOfType(CLASS_NETWORK, modLoaded)) {                needed = CLASS_NETWORK;                step = STEP_DRIVER;                break;            }            logMessage(INFO, "need to set up networking");            initLoopback();            memset(&netDev, 0, sizeof(netDev));            netDev.isDynamic = 1;            /* fall through to interface selection */        case STEP_IFACE:            logMessage(INFO, "going to pick interface");            rc = chooseNetworkInterface(loaderData);            if ((rc == LOADER_BACK) || (rc == LOADER_ERROR) ||                ((dir == -1) && (rc == LOADER_NOOP))) {                step = STEP_METHOD;                dir = -1;                break;            }            devName = loaderData->netDev;            strcpy(netDev.dev.device, devName);            /* continue to ip config */            step = STEP_IP;            dir = 1;            break;        case STEP_IP:            if (!needsNetwork) {                step = STEP_METHOD; /* only hit going back */                break;            }            if ((ret = malloc(48)) == NULL) {                logMessage(ERROR, "malloc failure for ret in STEP_IP");                exit(EXIT_FAILURE);            }            logMessage(INFO, "going to do getNetConfig");            /* populate netDev based on any kickstart data */            if (loaderData->ipinfo_set) {                netDev.preset = 1;            }            setupNetworkDeviceConfig(&netDev, loaderData);            rc = readNetConfig(devName, &netDev, loaderData->netCls, methodNum);            if ((loaderData->noipv4 = netDev.noipv4) == 1) {                loaderData->ipinfo_set = 0;            } else {                if (loaderData->ipv4 == NULL) {                    if (strcmp((char *) &(netDev.dev.ip), "")) {                        ret = (char *) inet_ntop(AF_INET,                                                 IP_ADDR(&(netDev.dev.ip)), ret,                                                 IP_STRLEN(&(netDev.dev.ip)));                    } else {                        ret = NULL;                        netDev.isDynamic = 1;                    }                    if (netDev.isDynamic || ret == NULL) {                        loaderData->ipv4 = strdup("dhcp");                    } else {                        loaderData->ipv4 = strdup(ret);                    }                }                loaderData->ipinfo_set = 1;            }            if ((loaderData->noipv6 = netDev.noipv6) == 1) {                loaderData->ipv6info_set = 0;            } else {                if (loaderData->ipv6 == NULL) {