net.c

linux 安装程序

                           loaderData->essid);
                cfg->essid = strdup(loaderData->essid);
            }
            if (loaderData->wepkey) {
                logMessage(INFO, "setting specified wepkey");
                cfg->wepkey = strdup(loaderData->wepkey);
            }
            /* go ahead and set up the wireless interface in case 
             * we're using dhcp */
            setupWireless(cfg);
        }

        /* this is how we specify dhcp */
        if (!strncmp(loaderData->ipv4, "dhcp", 4)) {
            char *ret = NULL;

            /* JKFIXME: this soooo doesn't belong here.  and it needs to
             * be broken out into a function too */
            logMessage(INFO, "sending dhcp request through device %s",
                       loaderData->netDev);

            if (!FL_CMDLINE(flags)) {
                startNewt();
                winStatus(55, 3, NULL, 
                          _("Sending request for IP information for %s..."), 
                          loaderData->netDev, 0);
            } else {
                printf("Sending request for IP information for %s...\n", 
                       loaderData->netDev);
            }

            if (!FL_TESTING(flags)) {
                waitForLink(loaderData->netDev);
                cfg->noipv4 = loaderData->noipv4;
                cfg->noipv6 = loaderData->noipv6;
                cfg->noDns = loaderData->noDns;
                ret = doDhcp(cfg);
            }

            if (!FL_CMDLINE(flags))
                newtPopWindow();

            if (ret != NULL) {
                logMessage(DEBUGLVL, "dhcp: %s", ret);
                return;
            }

            cfg->isDynamic = 1;
            cfg->preset = 1;
        } else if (inet_pton(AF_INET, loaderData->ipv4, &addr) >= 1) {
            cfg->dev.ip = ip_addr_in(&addr);
            cfg->dev.ipv4 = ip_addr_in(&addr);
            cfg->dev.set |= PUMP_INTFINFO_HAS_IP|PUMP_INTFINFO_HAS_IPV4_IP;
            cfg->isDynamic = 0;
            cfg->preset = 1;
        } else if (inet_pton(AF_INET6, loaderData->ipv6, &addr6) >= 1) {
            cfg->dev.ip = ip_addr_in6(&addr6);
            cfg->dev.ipv6 = ip_addr_in6(&addr6);
            cfg->dev.set |= PUMP_INTFINFO_HAS_IP|PUMP_INTFINFO_HAS_IPV6_IP;
            cfg->isDynamic = 0;
            cfg->preset = 1;
        } else { /* invalid ip information, disable the setting of ip info */
            loaderData->ipinfo_set = 0;
            cfg->isDynamic = 0;
            loaderData->ipv4 = NULL;
            loaderData->ipv6 = NULL;
        }
    }

    if (loaderData->netmask && (inet_pton(AF_INET, loaderData->netmask, &addr) >= 1)) {
        cfg->dev.netmask = ip_addr_in(&addr);
        cfg->dev.set |= PUMP_INTFINFO_HAS_NETMASK;
    }

    if (loaderData->gateway && (inet_pton(AF_INET, loaderData->gateway, &addr) >= 1)) {
        cfg->dev.gateway = ip_addr_in(&addr);
        cfg->dev.set |= PUMP_NETINFO_HAS_GATEWAY;
    }

    if (loaderData->gateway && (inet_pton(AF_INET6, loaderData->gateway, &addr6) >= 1)) {
        cfg->dev.gateway = ip_addr_in6(&addr6);
        cfg->dev.set |= PUMP_NETINFO_HAS_GATEWAY;
    }

    if (loaderData->dns) {
        char * buf;
        char ret[48];
        buf = strdup(loaderData->dns);

        /* Scan the dns parameter for multiple comma-separated IP addresses */
        c = strtok(buf, ",");  
        while ((cfg->dev.numDns < MAX_DNS_SERVERS) && (c != NULL)) {
            if (inet_pton(AF_INET, c, &addr) >= 1) {
                cfg->dev.dnsServers[cfg->dev.numDns] = ip_addr_in(&addr);
                cfg->dev.numDns++;
                inet_ntop(AF_INET, &addr, ret, INET_ADDRSTRLEN);
                logMessage(DEBUGLVL, "adding dns4 %s", ret);
                c = strtok(NULL, ",");
            } else if (inet_pton(AF_INET6, c, &addr6) >= 1) {
                cfg->dev.dnsServers[cfg->dev.numDns] = ip_addr_in6(&addr6);
                cfg->dev.numDns++;
                inet_ntop(AF_INET6, &addr6, ret, INET6_ADDRSTRLEN);
                logMessage(DEBUGLVL, "adding dns6 %s", ret);
                c = strtok(NULL, ",");
            }
        }
        logMessage(INFO, "dnsservers is %s", loaderData->dns);
        if (cfg->dev.numDns)
            cfg->dev.set |= PUMP_NETINFO_HAS_DNS;
    }

    if (loaderData->hostname) {
        logMessage(INFO, "setting specified hostname of %s",
                   loaderData->hostname);
        cfg->dev.hostname = strdup(loaderData->hostname);
        cfg->dev.set |= PUMP_NETINFO_HAS_HOSTNAME;
    }

    if (loaderData->mtu) {
        cfg->mtu = loaderData->mtu;
        cfg->dev.mtu = loaderData->mtu;
        cfg->dev.set |= PUMP_INTFINFO_HAS_MTU;
    }

    if (loaderData->peerid) {
        cfg->peerid = strdup(loaderData->peerid);
    }

    if (loaderData->subchannels) {
        cfg->subchannels = strdup(loaderData->subchannels);
    }

    if (loaderData->ctcprot) {
        cfg->ctcprot = strdup(loaderData->ctcprot);
    }

    if (loaderData->portname) {
        cfg->portname = strdup(loaderData->portname);
    }

    if (loaderData->nettype) {
        cfg->nettype = strdup(loaderData->nettype);
    }

    if (loaderData->ethtool) {
        parseEthtoolSettings(loaderData);
    }

    cfg->noipv4 = loaderData->noipv4;
    cfg->noipv6 = loaderData->noipv6;
    cfg->noDns = loaderData->noDns;
}

int readNetConfig(char * device, struct networkDeviceConfig * cfg,
                  char * dhcpclass, int methodNum) {
    struct networkDeviceConfig newCfg;
    int ret;
    int i = 0;
    struct netconfopts opts;
    struct in_addr addr, nm, nw;
    struct in6_addr addr6;
    struct intfconfig_s ipcomps;

    memset(&ipcomps, '\0', sizeof(ipcomps));
    ipcomps.ipv4 = NULL;
    ipcomps.ipv6 = NULL;
    ipcomps.cidr4 = NULL;
    ipcomps.cidr6 = NULL;
    ipcomps.gw = NULL;
    ipcomps.ns = NULL;

    /* init opts */
    opts.ipv4Choice = 0;
    opts.ipv6Choice = 0;

    /* init newCfg */
    memset(&newCfg, '\0', sizeof(newCfg));
    strcpy(newCfg.dev.device, device);
    newCfg.essid = NULL;
    newCfg.wepkey = NULL;
    newCfg.isDynamic = cfg->isDynamic;
    newCfg.noDns = cfg->noDns;
    newCfg.preset = cfg->preset;
    if (dhcpclass) {
        newCfg.vendor_class = strdup(dhcpclass);
    } else {
        newCfg.vendor_class = NULL;
    }

    /* JKFIXME: we really need a way to override this and be able to change
     * our network config */
    if (!FL_TESTING(flags) && cfg->preset) {
        logMessage(INFO, "doing kickstart... setting it up");
        if (configureNetwork(cfg)) {
            newtWinMessage(_("Network Error"), _("Retry"),
                           _("There was an error configuring your network "
                             "interface."));
            return LOADER_BACK;
        }

        findHostAndDomain(cfg);

        if (!cfg->noDns)
            writeResolvConf(cfg);
        return LOADER_NOOP;
    }

    /* handle wireless device configuration */
    if (is_wireless_interface(device)) {
        logMessage(INFO, "%s is a wireless adapter", device);
        if (getWirelessConfig(cfg, device) == LOADER_BACK)
            return LOADER_BACK;

        if (cfg->essid != NULL)
            newCfg.essid = strdup(cfg->essid);

        if (cfg->wepkey != NULL)
            newCfg.wepkey = strdup(cfg->wepkey);
    } else {
        logMessage(INFO, "%s is not a wireless adapter", device);
    }

    /* dhcp/manual network configuration loop */
    i = 1;
    while (i == 1) {
        ret = configureTCPIP(device, cfg, &newCfg, &opts, methodNum);

        if (ret == LOADER_NOOP) {
            /* dhcp selected, proceed */
            i = 0;
        } else if (ret == LOADER_OK) {
            /* do manual configuration */
            ret = manualNetConfig(device, cfg, &newCfg, &ipcomps, &opts);

            if (ret == LOADER_BACK) {
                continue;
            } else if (ret == LOADER_OK) {
                i = 0;
            }
        } else if (ret == LOADER_BACK) {
            return LOADER_BACK;
        }
    }

    cfg->noipv4 = newCfg.noipv4;
    cfg->ipv4method = newCfg.ipv4method;
    cfg->noipv6 = newCfg.noipv6;
    cfg->ipv6method = newCfg.ipv6method;

    /* preserve extra dns servers for the sake of being nice */
    if (cfg->dev.numDns > newCfg.dev.numDns) {
        for (i = newCfg.dev.numDns; i < cfg->dev.numDns; i++) {
            memcpy(&newCfg.dev.dnsServers[i], &cfg->dev.dnsServers[i],
                sizeof (newCfg.dev.dnsServers[i]));
        }
        newCfg.dev.numDns = cfg->dev.numDns;
    }

    cfg->isDynamic = newCfg.isDynamic;
    memcpy(&cfg->dev,&newCfg.dev,sizeof(newCfg.dev));

    if (!(cfg->dev.set & PUMP_NETINFO_HAS_GATEWAY)) {
        if (ipcomps.gw && *ipcomps.gw) {
            if (inet_pton(AF_INET, ipcomps.gw, &addr) >= 1) {
                cfg->dev.gateway = ip_addr_in(&addr);
                cfg->dev.set |= PUMP_NETINFO_HAS_GATEWAY;
            } else if (inet_pton(AF_INET6, ipcomps.gw, &addr6) >= 1) {
                cfg->dev.gateway = ip_addr_in6(&addr6);
                cfg->dev.set |= PUMP_NETINFO_HAS_GATEWAY;
            }
        }
    }

    /* calculate any missing IPv4 pieces */
    if (opts.ipv4Choice == '*') {
        addr = ip_in_addr(&cfg->dev.ipv4);
        nm = ip_in_addr(&cfg->dev.netmask);

        if (!(cfg->dev.set & PUMP_INTFINFO_HAS_NETWORK)) {
            cfg->dev.network = ip_addr_v4(ntohl((addr.s_addr) & nm.s_addr));
            cfg->dev.set |= PUMP_INTFINFO_HAS_NETWORK;
        }

        if (!(cfg->dev.set & PUMP_INTFINFO_HAS_BROADCAST)) {
            nw = ip_in_addr(&cfg->dev.network);
            cfg->dev.broadcast = ip_addr_v4(ntohl(nw.s_addr | ~nm.s_addr));
            cfg->dev.set |= PUMP_INTFINFO_HAS_BROADCAST;
        }
    }

    /* make sure we don't have a dhcp_nic handle for static */
    if ((cfg->isDynamic == 0) && (cfg->dev.dhcp_nic != NULL)) {
        dhcp_nic_free(cfg->dev.dhcp_nic);
        cfg->dev.dhcp_nic = NULL;
    }

    /* dump some network debugging info */
    debugNetworkInfo(cfg);

    /* bring up the interface */
    if (!FL_TESTING(flags)) {
        if (configureNetwork(cfg)) {
            newtWinMessage(_("Network Error"), _("Retry"),
                           _("There was an error configuring your network "
                             "interface."));
            return LOADER_BACK;
        }

        findHostAndDomain(cfg);
        writeResolvConf(cfg);
    }

    return LOADER_OK;
}

int configureTCPIP(char * device, struct networkDeviceConfig * cfg,
                   struct networkDeviceConfig * newCfg,
                   struct netconfopts * opts, int methodNum) {
    int i = 0, z = 0;
    char *dret = NULL;
    newtComponent f, okay, back, answer;
    newtComponent ipv4Checkbox, ipv6Checkbox, v4Method[2], v6Method[3];
    newtGrid grid, checkgrid, buttons;

    /* UI WINDOW 1: ask for ipv4 choice, ipv6 choice, and conf methods */

    /* IPv4 checkbox */
    if (!opts->ipv4Choice)
        opts->ipv4Choice = '*';

    ipv4Checkbox = newtCheckbox(-1, -1, _("Enable IPv4 support"),
                                opts->ipv4Choice, NULL, &(opts->ipv4Choice));
    v4Method[0] = newtRadiobutton(-1, -1, DHCP_METHOD_STR, 1, NULL);
    v4Method[1] = newtRadiobutton(-1, -1, MANUAL_METHOD_STR, 0, v4Method[0]);

    /* IPv6 checkbox */
    if (!opts->ipv6Choice) {
        if (FL_NOIPV6(flags))
            opts->ipv6Choice = ' ';
        else
            opts->ipv6Choice = '*';
    }

    ipv6Checkbox = newtCheckbox(-1, -1, _("Enable IPv6 support"),
                                opts->ipv6Choice, NULL, &(opts->ipv6Choice));
    v6Method[0] = newtRadiobutton(-1, -1, AUTO_METHOD_STR, 1, NULL);
    v6Method[1] = newtRadiobutton(-1, -1, DHCPV6_METHOD_STR, 0, v6Method[0]);
    v6Method[2] = newtRadiobutton(-1, -1, MANUAL_METHOD_STR, 0, v6Method[1]);

    /* button bar at the bottom of the window */
    buttons = newtButtonBar(_("OK"), &okay, _("Back"), &back, NULL);

    /* checkgrid contains the toggle options for net configuration */
    checkgrid = newtCreateGrid(1, 8);

    newtGridSetField(checkgrid, 0, 0, NEWT_GRID_COMPONENT, ipv4Checkbox,
                     0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0);
    for (i = 1; i < 3; i++)
        newtGridSetField(checkgrid, 0, i, NEWT_GRID_COMPONENT, v4Method[i-1],
                         7, 0, 0, 0, NEWT_ANCHOR_LEFT, 0);

    newtGridSetField(checkgrid, 0, 4, NEWT_GRID_COMPONENT, ipv6Checkbox,
                     0, 1, 0, 0, NEWT_ANCHOR_LEFT, 0);
    for (i = 5; i < 8; i++)
        newtGridSetField(checkgrid, 0, i, NEWT_GRID_COMPONENT, v6Method[i-5],
                         7, 0, 0, 0, NEWT_ANCHOR_LEFT, 0);

    /* main window layout */
    grid = newtCreateGrid(1, 2);
    newtGridSetField(grid, 0, 0, NEWT_GRID_SUBGRID, checkgrid,
                     0, 0, 0, 1, 0, 0);
    newtGridSetField(grid, 0, 1, NEWT_GRID_SUBGRID, buttons,
                     0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX);

    f = newtForm(NULL, NULL, 0);
    newtGridAddComponentsToForm(grid, f, 1);
    newtGridWrappedWindow(grid, _("Configure TCP/IP"));
    newtGridFree(grid, 1);

    /* callbacks */
    newtComponentAddCallback(ipv4Checkbox, v4MethodCallback, &v4Method);
    newtComponentAddCallback(ipv6Checkbox, v6MethodCallback, &v6Method);

    /* match radio button sensitivity to initial checkbox choices */
    if (opts->ipv4Choice == ' ')
        setMethodSensitivity(&v4Method, 2);

    if (opts->ipv6Choice == ' ')