/* * net.c * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Red Hat, Inc. * All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Author(s): David Cantrell */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../isys/isys.h" #include "../isys/net.h" #include "../isys/wireless.h" #include "../isys/iface.h" #include "../isys/str.h" #include "lang.h" #include "loader.h" #include "loadermisc.h" #include "log.h" #include "method.h" #include "net.h" #include "windows.h" /* boot flags */ extern uint64_t flags; /** * Callback function for the CIDR entry boxes on the manual TCP/IP * configuration window. * * @param co The entry field that triggered the callback. * @param dptr Pointer to intfconfig_s data structure for this field. * @see intfconfig_s */ static void cidrCallback(newtComponent co, void * dptr) { struct intfconfig_s * data = dptr; int cidr, upper = 0; struct in_addr addr; if (co == data->cidr4Entry) { if (data->cidr4 == NULL && data->ipv4 == NULL) return; if (inet_pton(AF_INET, data->cidr4, &addr) >= 1) return; cidr = atoi(data->cidr4); if (strcmp(data->ipv4, "")) upper = 32; } else if (co == data->cidr6Entry) { if (data->cidr6 == NULL && data->ipv6 == NULL) return; cidr = atoi(data->cidr6); if (strcmp(data->ipv6, "")) upper = 128; } if (upper != 0) { if (cidr < 1 || cidr > upper) { newtWinMessage(_("Invalid Prefix"), _("Retry"), _("Prefix must be between 1 and 32 " "for IPv4 networks or between 1 and 128 " "for IPv6 networks")); } } } static void ipCallback(newtComponent co, void * dptr) { int i; char *buf, *octet; struct intfconfig_s * data = dptr; if (co == data->ipv4Entry) { /* do we need to guess a netmask for the user? */ if (data->cidr4 == NULL && data->ipv4 != NULL) { buf = strdup(data->ipv4); octet = strtok(buf, "."); i = atoi(octet); free(buf); free(octet); if (i >= 0 && i <= 127) newtEntrySet(data->cidr4Entry, "8", 1); else if (i >= 128 && i <= 191) newtEntrySet(data->cidr4Entry, "16", 1); else if (i >= 192 && i <= 222) newtEntrySet(data->cidr4Entry, "24", 1); } return; } else if (co == data->ipv6Entry) { /* users must provide a mask, we can't guess for ipv6 */ return; } } static void setMethodSensitivity(void *dptr, int radio_button_count) { int i = 0; for (i = 0; i < radio_button_count; i++) { newtCheckboxSetFlags(*((newtComponent *) dptr), NEWT_FLAG_DISABLED, NEWT_FLAGS_TOGGLE); dptr += sizeof (newtComponent); } return; } static void v4MethodCallback(newtComponent co, void *dptr) { setMethodSensitivity(dptr, 2); return; } static void v6MethodCallback(newtComponent co, void *dptr) { setMethodSensitivity(dptr, 3); return; } static int waitForLink(char * dev) { extern int num_link_checks; extern int post_link_sleep; int tries = 0; /* try to wait for a valid link -- if the status is unknown or * up continue, else sleep for 1 second and try again for up * to five times */ logMessage(DEBUGLVL, "waiting for link %s...", dev); while (tries < num_link_checks) { if (get_link_status(dev) != 0) break; sleep(1); tries++; } logMessage(DEBUGLVL, " %d seconds.", tries); if (tries < num_link_checks){ /* Networks with STP set up will give link when the port * is isolated from the network, and won't forward packets * until they decide we're not a switch. */ logMessage(DEBUGLVL, "sleep (nicdelay) for %d secs first", post_link_sleep); sleep(post_link_sleep); logMessage(DEBUGLVL, "continuing..."); return 0; } logMessage(WARNING, " no network link detected on %s", dev); return 1; } static void parseEthtoolSettings(struct loaderData_s * loaderData) { char * option, * buf; ethtool_duplex duplex = ETHTOOL_DUPLEX_UNSPEC; ethtool_speed speed = ETHTOOL_SPEED_UNSPEC; buf = strdup(loaderData->ethtool); option = strtok(buf, " "); while (option) { if (option[strlen(option) - 1] == '\"') option[strlen(option) - 1] = '\0'; if (option[0] == '\"') option++; if (!strncmp(option, "duplex", 6)) { if (!strncmp(option + 7, "full", 4)) duplex = ETHTOOL_DUPLEX_FULL; else if (!strncmp(option + 7, "half", 4)) duplex = ETHTOOL_DUPLEX_HALF; else logMessage(WARNING, "Unknown duplex setting: %s", option + 7); option = strtok(NULL, " "); } else if (!strncmp("speed", option, 5)) { if (!strncmp(option + 6, "1000", 4)) speed = ETHTOOL_SPEED_1000; else if (!strncmp(option + 6, "100", 3)) speed = ETHTOOL_SPEED_100; else if (!strncmp(option + 6, "10", 2)) speed = ETHTOOL_SPEED_10; else logMessage(WARNING, "Unknown speed setting: %s", option + 6); option = strtok(NULL, " "); } else { logMessage(WARNING, "Unknown ethtool setting: %s", option); } option = strtok(NULL, " "); } setEthtoolSettings(loaderData->netDev, speed, duplex); free(buf); } void initLoopback(void) { struct ifreq req; int s; s = socket(AF_INET, SOCK_DGRAM, 0); memset(&req, 0, sizeof(req)); strcpy(req.ifr_name, "lo"); if (ioctl(s, SIOCGIFFLAGS, &req)) { logMessage(LOG_ERR, "ioctl SIOCGIFFLAGS failed: %d %s\n", errno, strerror(errno)); close(s); return; } req.ifr_flags |= (IFF_UP | IFF_RUNNING); if (ioctl(s, SIOCSIFFLAGS, &req)) { logMessage(LOG_ERR, "ioctl SIOCSIFFLAGS failed: %d %s\n", errno, strerror(errno)); close(s); return; } close(s); return; } static int getWirelessConfig(struct networkDeviceConfig *cfg, char * ifname) { char * wepkey = ""; char * essid = ""; int rc = 0; char * buf; if (cfg->wepkey != NULL) { wepkey = strdup(cfg->wepkey); } if (cfg->essid != NULL) { essid = strdup(cfg->essid); } else { essid = get_essid(ifname); } rc = asprintf(&buf, _("%s is a wireless network adapter. Please " "provide the ESSID and encryption key needed " "to access your wireless network. If no key " "is needed, leave this field blank and the " "install will continue."), ifname); do { struct newtWinEntry entry[] = { { N_("ESSID"), (const char **)&essid, 0 }, { N_("Encryption Key"), (const char **) &wepkey, 0 }, { NULL, NULL, 0 } }; rc = newtWinEntries(_("Wireless Settings"), buf, 40, 5, 10, 30, entry, _("OK"), _("Back"), NULL); if (rc == 2) { free(buf); return LOADER_BACK; } /* set stuff up */ } while (rc == 2); free(buf); if (cfg->wepkey != NULL) free(cfg->wepkey); if (wepkey && (strlen(wepkey) > 0)) cfg->wepkey = strdup(wepkey); else cfg->wepkey = NULL; if (cfg->essid != NULL) free(cfg->essid); if (essid && (strlen(essid) > 0)) cfg->essid = strdup(essid); else cfg->essid = NULL; return LOADER_OK; } static int getDnsServers(struct networkDeviceConfig * cfg) { int rc; struct in_addr addr; struct in6_addr addr6; const char * ns = ""; struct newtWinEntry entry[] = { { N_("Nameserver IP"), &ns, 0 }, { NULL, NULL, 0 } }; do { rc = newtWinEntries(_("Missing Nameserver"), _("Your IP address request returned configuration " "information, but it did not include a nameserver address. " "If you do not have this information, you can leave " "the field blank and the install will continue."), 61, 0, 0, 45, entry, _("OK"), _("Back"), NULL); if (rc == 2) return LOADER_BACK; rc = 0; if (!ns || !*ns) { cfg->dev.numDns = 0; break; } else { if (inet_pton(AF_INET, ns, &addr) >= 1) cfg->dev.dnsServers[0] = ip_addr_in(&addr); else if (inet_pton(AF_INET6, ns, &addr6) >= 1) cfg->dev.dnsServers[0] = ip_addr_in6(&addr6); else rc = 2; } if (rc) { newtWinMessage(_("Invalid IP Information"), _("Retry"), _("You entered an invalid IP address.")); } else { cfg->dev.set |= PUMP_NETINFO_HAS_DNS; cfg->dev.numDns = 1; } } while (rc == 2); return LOADER_OK; } void printLoaderDataIPINFO(struct loaderData_s *loaderData) { logMessage(DEBUGLVL, "loaderData->ipinfo_set = |%d|", loaderData->ipinfo_set); logMessage(DEBUGLVL, "loaderData->ipv4 = |%s|", loaderData->ipv4); logMessage(DEBUGLVL, "loaderData->ipv6info_set = |%d|", loaderData->ipv6info_set); logMessage(DEBUGLVL, "loaderData->ipv6 = |%s|", loaderData->ipv6); logMessage(DEBUGLVL, "loaderData->dhcpTimeout = |%d|", loaderData->dhcpTimeout); logMessage(DEBUGLVL, "loaderData->netmask = |%s|", loaderData->netmask); logMessage(DEBUGLVL, "loaderData->gateway = |%s|", loaderData->gateway); logMessage(DEBUGLVL, "loaderData->dns = |%s|", loaderData->dns); logMessage(DEBUGLVL, "loaderData->hostname = |%s|", loaderData->hostname); logMessage(DEBUGLVL, "loaderData->noDns = |%d|", loaderData->noDns); logMessage(DEBUGLVL, "loaderData->netDev_set = |%d|", loaderData->netDev_set); logMessage(DEBUGLVL, "loaderData->netDev = |%s|", loaderData->netDev); logMessage(DEBUGLVL, "loaderData->netCls_set = |%d|", loaderData->netCls_set); logMessage(DEBUGLVL, "loaderData->netCls = |%s|", loaderData->netCls); } /* given loader data from kickstart, populate network configuration struct */ void setupNetworkDeviceConfig(struct networkDeviceConfig * cfg, struct loaderData_s * loaderData) { struct in_addr addr; struct in6_addr addr6; char * c; /* set to 1 to get ks network struct logged */ #if 0 printLoaderDataIPINFO(loaderData); #endif if (loaderData->ethtool) { parseEthtoolSettings(loaderData); } if (loaderData->netCls_set) { cfg->vendor_class = loaderData->netCls; } else { cfg->vendor_class = NULL; } if (loaderData->ipinfo_set) { if (is_wireless_interface(loaderData->netDev)) { if (loaderData->essid) { logMessage(INFO, "setting specified essid of %s", 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->noDns = loaderData->noDns; cfg->dhcpTimeout = loaderData->dhcpTimeout; 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 (loaderData->ipv4) { 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 (loaderData->ipv6) { 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 < MAXNS) && (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->noDns = loaderData->noDns; cfg->dhcpTimeout = loaderData->dhcpTimeout; } 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.dhcpTimeout = cfg->dhcpTimeout; 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->ipv4method = newCfg.ipv4method; 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, skipForm = 0; char *dret = NULL; newtComponent f, okay, back, answer; newtComponent ipv4Checkbox, ipv6Checkbox, v4Method[2], v6Method[3]; newtGrid grid, checkgrid, buttons; newCfg->ipv4method = -1; newCfg->ipv6method = -1; /* UI WINDOW 1: ask for ipv4 choice, ipv6 choice, and conf methods */ /* IPv4 checkbox */ if (!opts->ipv4Choice) { if (FL_NOIPV4(flags) && !FL_IP_PARAM(flags)) opts->ipv4Choice = ' '; else 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) && !FL_IPV6_PARAM(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 == ' ') setMethodSensitivity(&v6Method, 3); /* If the user provided any of the following boot paramters, skip * prompting for network configuration information: * ip= ipv6= * noipv4 noipv6 * ip= noipv6 * ipv6= noipv4 * we also skip this form for anyone doing a kickstart install */ if ((FL_IP_PARAM(flags) && FL_IPV6_PARAM(flags)) || (FL_IP_PARAM(flags) && FL_NOIPV6(flags)) || (FL_IPV6_PARAM(flags) && FL_NOIPV4(flags)) || (FL_NOIPV4(flags) && FL_NOIPV6(flags)) || (FL_IS_KICKSTART(flags))) { skipForm = 1; newtPopWindow(); } /* run the form */ do { if (!skipForm) { answer = newtRunForm(f); if (answer == back) { newtFormDestroy(f); newtPopWindow(); return LOADER_BACK; } /* need at least one stack */ if (opts->ipv4Choice == ' ' && opts->ipv6Choice == ' ') { newtWinMessage(_("Missing Protocol"), _("Retry"), _("You must select at least one protocol (IPv4 " "or IPv6).")); continue; } /* NFS only works over IPv4 */ if (opts->ipv4Choice == ' ' && methodNum == METHOD_NFS) { newtWinMessage(_("IPv4 Needed for NFS"), _("Retry"), _("NFS installation method requires IPv4 support.")); continue; } } /* what TCP/IP stacks do we use? what conf methods? */ if (opts->ipv4Choice == '*') { flags &= ~LOADER_FLAGS_NOIPV4; for (z = 0; z < 2; z++) if (newtRadioGetCurrent(v4Method[0]) == v4Method[z]) newCfg->ipv4method = z; } else { flags |= LOADER_FLAGS_NOIPV4; } if (opts->ipv6Choice == '*') { flags &= ~LOADER_FLAGS_NOIPV6; for (z = 0; z < 3; z++) if (newtRadioGetCurrent(v6Method[0]) == v6Method[z]) newCfg->ipv6method = z; } else { flags |= LOADER_FLAGS_NOIPV6; } /* do interface configuration (call DHCP here, or return for manual) */ if ((!FL_NOIPV4(flags) && newCfg->ipv4method == IPV4_DHCP_METHOD) || (!FL_NOIPV6(flags) && (newCfg->ipv6method == IPV6_AUTO_METHOD || newCfg->ipv6method == IPV6_DHCP_METHOD))) { /* do DHCP if selected */ if (!FL_TESTING(flags)) { winStatus(55, 3, NULL, _("Sending request for IP information for %s..."), device, 0); waitForLink(device); dret = doDhcp(newCfg); newtPopWindow(); } if (dret == NULL) { newCfg->isDynamic = 1; if (!(newCfg->dev.set & PUMP_NETINFO_HAS_DNS)) { logMessage(WARNING, "dhcp worked, but did not return a DNS server"); /* * prompt for a nameserver IP address when: * - DHCP for IPv4, DHCP/AUTO for IPv6 and both enabled * - IPv4 disabled and DHCP/AUTO for IPv6 * - IPv6 disabled and DHCP for IPv4 */ if ((newCfg->ipv4method == IPV4_DHCP_METHOD && (newCfg->ipv6method == IPV6_AUTO_METHOD || newCfg->ipv6method == IPV6_DHCP_METHOD)) || (newCfg->ipv4method == IPV4_DHCP_METHOD && FL_NOIPV6(flags)) || (FL_NOIPV4(flags) && (newCfg->ipv6method == IPV6_AUTO_METHOD || newCfg->ipv6method == IPV6_DHCP_METHOD))) { i = getDnsServers(newCfg); i = i ? 0 : 1; } else { i = 1; } } else { i = 1; } } else { logMessage(DEBUGLVL, "dhcp: %s", dret); i = 0; } } else { /* manual IP configuration for IPv4 and IPv6 */ newtFormDestroy(f); newtPopWindow(); return LOADER_OK; } } while (i != 1); newtFormDestroy(f); newtPopWindow(); if ((!FL_NOIPV4(flags) && newCfg->ipv4method == IPV4_MANUAL_METHOD) || (!FL_NOIPV6(flags) && newCfg->ipv6method == IPV6_MANUAL_METHOD)) return LOADER_OK; else return LOADER_NOOP; } int manualNetConfig(char * device, struct networkDeviceConfig * cfg, struct networkDeviceConfig * newCfg, struct intfconfig_s * ipcomps, struct netconfopts * opts) { int i, rows, pos, prefix, cidr, q, have[2], stack[2]; char *buf = NULL; char ret[48]; ip_addr_t *tip; struct in_addr addr; struct in6_addr addr6; newtComponent f, okay, back, answer; newtGrid egrid = NULL; newtGrid qgrid = NULL; newtGrid rgrid = NULL; newtGrid buttons, grid; newtComponent text = NULL; /* so we don't perform this test over and over */ stack[IPV4] = opts->ipv4Choice == '*' && newCfg->ipv4method == IPV4_MANUAL_METHOD; stack[IPV6] = opts->ipv6Choice == '*' && newCfg->ipv6method == IPV6_MANUAL_METHOD; /* UI WINDOW 2 (optional): manual IP config for non-DHCP installs */ rows = 2; for (i = 0; i < 2; i++) if (stack[i]) rows++; egrid = newtCreateGrid(4, rows); pos = 0; /* IPv4 entry items */ if (stack[IPV4]) { newtGridSetField(egrid, 0, pos, NEWT_GRID_COMPONENT, newtLabel(-1, -1, _("IPv4 address:")), 0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); ipcomps->ipv4Entry = newtEntry(-1, -1, NULL, 16, &ipcomps->ipv4, 0); ipcomps->cidr4Entry = newtEntry(-1, -1, NULL, 16, &ipcomps->cidr4, 0); /* use a nested grid for ipv4 addr & netmask */ qgrid = newtCreateGrid(3, 1); newtGridSetField(qgrid, 0, 0, NEWT_GRID_COMPONENT, ipcomps->ipv4Entry, 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(qgrid, 1, 0, NEWT_GRID_COMPONENT, newtLabel(-1, -1, _("/")), 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(qgrid, 2, 0, NEWT_GRID_COMPONENT, ipcomps->cidr4Entry, 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(egrid, 1, pos, NEWT_GRID_SUBGRID, qgrid, 0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtComponentAddCallback(ipcomps->ipv4Entry, ipCallback, ipcomps); newtComponentAddCallback(ipcomps->cidr4Entry, cidrCallback, ipcomps); /* populate fields if we have data already */ tip = NULL; if (cfg->dev.set & PUMP_INTFINFO_HAS_IPV4_IP) tip = &(cfg->dev.ipv4); else if (newCfg->dev.set & PUMP_INTFINFO_HAS_IPV4_IP) tip = &(newCfg->dev.ipv4); if (tip) { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); newtEntrySet(ipcomps->ipv4Entry, ret, 1); } tip = NULL; if (cfg->dev.set & PUMP_INTFINFO_HAS_NETMASK) tip = &(cfg->dev.netmask); else if (newCfg->dev.set & PUMP_INTFINFO_HAS_NETMASK) tip = &(newCfg->dev.netmask); if (tip) { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); newtEntrySet(ipcomps->cidr4Entry, ret, 1); } pos++; } /* IPv6 entry items */ if (stack[IPV6]) { newtGridSetField(egrid, 0, pos, NEWT_GRID_COMPONENT, newtLabel(-1, -1, _("IPv6 address:")), 0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); ipcomps->ipv6Entry = newtEntry(-1, -1, NULL, 41, &ipcomps->ipv6, 0); ipcomps->cidr6Entry = newtEntry(-1, -1, NULL, 4, &ipcomps->cidr6, 0); /* use a nested grid for ipv6 addr & netmask */ rgrid = newtCreateGrid(3, 1); newtGridSetField(rgrid, 0, 0, NEWT_GRID_COMPONENT, ipcomps->ipv6Entry, 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(rgrid, 1, 0, NEWT_GRID_COMPONENT, newtLabel(-1, -1, _("/")), 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(rgrid, 2, 0, NEWT_GRID_COMPONENT, ipcomps->cidr6Entry, 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(egrid, 1, pos, NEWT_GRID_SUBGRID, rgrid, 0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtComponentAddCallback(ipcomps->ipv6Entry, ipCallback, ipcomps); newtComponentAddCallback(ipcomps->cidr6Entry, cidrCallback, ipcomps); /* populate fields if we have data already */ tip = NULL; if (cfg->dev.set & PUMP_INTFINFO_HAS_IPV6_IP) tip = &(cfg->dev.ipv6); else if (newCfg->dev.set & PUMP_INTFINFO_HAS_IPV6_IP) tip = &(newCfg->dev.ipv6); if (tip) { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); newtEntrySet(ipcomps->ipv6Entry, ret, 1); } if (cfg->dev.set & PUMP_INTFINFO_HAS_IPV6_PREFIX) q = asprintf(&buf, "%d", cfg->dev.ipv6_prefixlen); else if (newCfg->dev.set & PUMP_INTFINFO_HAS_IPV6_PREFIX) q = asprintf(&buf, "%d", newCfg->dev.ipv6_prefixlen); if (buf) { newtEntrySet(ipcomps->cidr6Entry, buf, 1); free(buf); } pos++; } /* common entry items */ ipcomps->gwEntry = newtEntry(-1, -1, NULL, 41, &ipcomps->gw, 0); ipcomps->nsEntry = newtEntry(-1, -1, NULL, 41, &ipcomps->ns, 0); newtGridSetField(egrid, 0, pos, NEWT_GRID_COMPONENT, newtLabel(-1, -1, _("Gateway:")), 0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(egrid, 1, pos, NEWT_GRID_COMPONENT, ipcomps->gwEntry, 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); pos++; newtGridSetField(egrid, 0, pos, NEWT_GRID_COMPONENT, newtLabel(-1, -1, _("Name Server:")), 0, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); newtGridSetField(egrid, 1, pos, NEWT_GRID_COMPONENT, ipcomps->nsEntry, 1, 0, 0, 0, NEWT_ANCHOR_LEFT, 0); tip = NULL; if (cfg->dev.set & PUMP_NETINFO_HAS_GATEWAY) tip = &(cfg->dev.gateway); else if (newCfg->dev.set & PUMP_NETINFO_HAS_GATEWAY) tip = &(newCfg->dev.gateway); if (tip) { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); newtEntrySet(ipcomps->gwEntry, ret, 1); } tip = NULL; if (cfg->dev.numDns) tip = &(cfg->dev.dnsServers[0]); else if (newCfg->dev.numDns) tip = &(newCfg->dev.dnsServers[0]); if (tip) { inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); newtEntrySet(ipcomps->nsEntry, ret, 1); } newtComponentAddCallback(ipcomps->gwEntry, ipCallback, ipcomps); newtComponentAddCallback(ipcomps->nsEntry, ipCallback, ipcomps); /* button bar at the bottom of the window */ buttons = newtButtonBar(_("OK"), &okay, _("Back"), &back, NULL); /* main window layout */ grid = newtCreateGrid(1, 3); i = asprintf(&buf, _("Enter the IPv4 and/or the IPv6 address and prefix " "(address / prefix). For IPv4, the dotted-quad " "netmask or the CIDR-style prefix are acceptable. " "The gateway and name server fields must be valid IPv4 " "or IPv6 addresses.")); text = newtTextboxReflowed(-1, -1, buf, 52, 0, 10, 0); newtGridSetField(grid, 0, 0, NEWT_GRID_COMPONENT, text, 0, 0, 0, 1, NEWT_ANCHOR_LEFT, 0); newtGridSetField(grid, 0, 1, NEWT_GRID_SUBGRID, egrid, 0, 0, 0, 1, NEWT_ANCHOR_LEFT, 0); newtGridSetField(grid, 0, 2, NEWT_GRID_SUBGRID, buttons, 0, 0, 0, 0, 0, NEWT_GRID_FLAG_GROWX); f = newtForm(NULL, NULL, 0); newtGridAddComponentsToForm(grid, f, 1); newtGridWrappedWindow(grid, _("Manual TCP/IP Configuration")); newtGridFree(grid, 1); /* run the form */ while ((have[IPV4] != 2) || (have[IPV6] != 2)) { have[IPV4] = 0; have[IPV6] = 0; for (i = 0; i < 2; i++) if (!stack[i]) have[i] = 2; answer = newtRunForm(f); /* memset(newCfg, 0, sizeof(*newCfg)); */ /* collect IPv4 data */ if (stack[IPV4]) { if (ipcomps->ipv4) { if (inet_pton(AF_INET, ipcomps->ipv4, &addr) >= 1) { newCfg->dev.ipv4 = ip_addr_in(&addr); newCfg->dev.set |= PUMP_INTFINFO_HAS_IPV4_IP; have[IPV4]++; } } if (ipcomps->cidr4) { if (inet_pton(AF_INET, ipcomps->cidr4, &addr) >= 1) { newCfg->dev.netmask = ip_addr_in(&addr); newCfg->dev.set |= PUMP_INTFINFO_HAS_NETMASK; have[IPV4]++; } else { cidr = atoi(ipcomps->cidr4); if (cidr >= 1 && cidr <= 32) { if (inet_pton(AF_INET, "255.255.255.255", &addr) >= 1) { addr.s_addr = htonl(ntohl(addr.s_addr) << (32 - cidr)); newCfg->dev.netmask = ip_addr_in(&addr); newCfg->dev.set |= PUMP_INTFINFO_HAS_NETMASK; have[IPV4]++; } } } } } /* collect IPv6 data */ if (stack[IPV6]) { if (ipcomps->ipv6) { if (inet_pton(AF_INET6, ipcomps->ipv6, &addr6) >= 1) { newCfg->dev.ipv6 = ip_addr_in6(&addr6); newCfg->dev.set |= PUMP_INTFINFO_HAS_IPV6_IP; have[IPV6]++; } } if (ipcomps->cidr6) { prefix = atoi(ipcomps->cidr6); if (prefix > 0 || prefix <= 128) { newCfg->dev.ipv6_prefixlen = prefix; newCfg->dev.set |= PUMP_INTFINFO_HAS_IPV6_PREFIX; have[IPV6]++; } } } /* collect common network settings */ if (ipcomps->gw) { if (inet_pton(AF_INET, ipcomps->gw, &addr) >= 1) { newCfg->dev.gateway = ip_addr_in(&addr); newCfg->dev.set |= PUMP_NETINFO_HAS_GATEWAY; } else if (inet_pton(AF_INET6, ipcomps->gw, &addr6) >= 1) { newCfg->dev.gateway = ip_addr_in6(&addr6); newCfg->dev.set |= PUMP_NETINFO_HAS_GATEWAY; } } /* The cfg->dev.ip field needs to store the IPv4 address if * there is one. */ if (ipcomps->ipv4) { if (inet_pton(AF_INET, ipcomps->ipv4, &addr) >= 1) { newCfg->dev.ip = ip_addr_in(&addr); newCfg->dev.set |= PUMP_INTFINFO_HAS_IP; } } /* gather nameservers */ if (ipcomps->ns) { if (inet_pton(AF_INET, ipcomps->ns, &addr) >= 1) { cfg->dev.dnsServers[0] = ip_addr_in(&addr); cfg->dev.set |= PUMP_NETINFO_HAS_DNS; if (cfg->dev.numDns < 1) cfg->dev.numDns = 1; } else if (inet_pton(AF_INET6, ipcomps->ns, &addr6) >= 1) { cfg->dev.dnsServers[0] = ip_addr_in6(&addr6); cfg->dev.set |= PUMP_NETINFO_HAS_DNS; if (cfg->dev.numDns < 1) cfg->dev.numDns = 1; } } /* user selected back, but we've saved what they entered already */ if (answer == back) { newtFormDestroy(f); newtPopWindow(); free(buf); return LOADER_BACK; } /* we might be done now */ if (have[IPV4] != 2) { newtWinMessage(_("Missing Information"), _("Retry"), _("You must enter both a valid IPv4 address and a " "network mask or CIDR prefix.")); } if (have[IPV6] != 2) { newtWinMessage(_("Missing Information"), _("Retry"), _("You must enter both a valid IPv6 address and a " "CIDR prefix.")); } strcpy(newCfg->dev.device, device); newCfg->isDynamic = 0; } free(buf); newtFormDestroy(f); newtPopWindow(); return LOADER_OK; } void debugNetworkInfo(struct networkDeviceConfig *cfg) { int i; char *buf = NULL; logMessage(DEBUGLVL, "device = %s", cfg->dev.device); if (cfg->dev.set & PUMP_INTFINFO_HAS_IPV4_IP) logMessage(DEBUGLVL, "ipv4 = %s", ip_text(cfg->dev.ipv4, buf, 0)); if (cfg->dev.set & PUMP_INTFINFO_HAS_BROADCAST) logMessage(DEBUGLVL,"broadcast = %s",ip_text(cfg->dev.broadcast,buf,0)); if (cfg->dev.set & PUMP_INTFINFO_HAS_NETMASK) logMessage(DEBUGLVL, "netmask = %s", ip_text(cfg->dev.netmask, buf, 0)); if (cfg->dev.set & PUMP_INTFINFO_HAS_NETWORK) logMessage(DEBUGLVL, "network = %s", ip_text(cfg->dev.network, buf, 0)); if (cfg->dev.set & PUMP_INTFINFO_HAS_IPV6_IP) logMessage(DEBUGLVL, "ipv6 = %s", ip_text(cfg->dev.ipv6, buf, 0)); if (cfg->dev.set & PUMP_INTFINFO_HAS_IPV6_PREFIX) logMessage(DEBUGLVL, "ipv6_prefixlen = %d", cfg->dev.ipv6_prefixlen); if (cfg->dev.set & PUMP_NETINFO_HAS_GATEWAY) logMessage(DEBUGLVL, "gateway = %s", ip_text(cfg->dev.gateway, buf, 0)); if (cfg->dev.set & PUMP_NETINFO_HAS_DNS) for (i=0; i < cfg->dev.numDns; i++) logMessage(DEBUGLVL, "dns[%d] = %s", i, ip_text(cfg->dev.dnsServers[i], buf, 0)); } int setupWireless(struct networkDeviceConfig *dev) { /* wireless config needs to be set up before we can bring the interface * up */ if (!is_wireless_interface(dev->dev.device)) return 0; if (dev->essid) { logMessage(INFO, "setting essid for %s to %s", dev->dev.device, dev->essid); if (set_essid(dev->dev.device, dev->essid) < 0) { logMessage(ERROR, "failed to set essid: %s", strerror(errno)); } if (dev->wepkey) { logMessage(INFO, "setting encryption key for %s", dev->dev.device); if (set_wep_key(dev->dev.device, dev->wepkey) < 0) { logMessage(ERROR, "failed to set wep key: %s", strerror(errno)); } } } return 0; } void netlogger(void *arg, int priority, char *fmt, va_list va) { int p; char *buf = NULL; if (priority == LOG_ERR) p = ERROR; else if (priority == LOG_INFO) p = INFO; else if (priority == LOG_DEBUG) p = DEBUGLVL; else if (priority == LOG_FATAL) p = CRITICAL; else p = INFO; if (vasprintf(&buf, fmt, va) != -1) { logMessage(p, "%s", buf); free(buf); } else { logMessage(ERROR, "unable to log network message"); } return; } char *doDhcp(struct networkDeviceConfig *dev) { struct pumpNetIntf *i; char *r = NULL, *class = NULL; time_t timeout; int loglevel; DHCP_Preference pref = 0; struct utsname kv; i = &dev->dev; if (dev->dhcpTimeout < 0) timeout = 45; else timeout = dev->dhcpTimeout; if (dev->vendor_class != NULL) { class = dev->vendor_class; } else { if (uname(&kv) == -1) { logMessage(ERROR, "failure running uname() in doDhcp()"); class = "anaconda"; } else { int ret; ret = asprintf(&class, "anaconda-%s %s %s", kv.sysname, kv.release, kv.machine); logMessage(DEBUGLVL, "sending %s as dhcp vendor-class", class); } } if (getLogLevel() == DEBUGLVL) loglevel = LOG_DEBUG; else loglevel = LOG_INFO; /* dhcp preferences are in /usr/include/libdhcp/dhcp_nic.h */ /* calling function should catch ipv4Choice & ipv6Choice both being ' ' */ if (FL_NOIPV4(flags) || dev->ipv4method == IPV4_MANUAL_METHOD) { /* IPv4 disabled entirely -or- manual IPv4 config selected */ pref |= DHCPv4_DISABLE; } /* IPv6 enabled -and- auto neighbor discovery selected */ /* IPv6 disabled entirely -or- manual IPv6 config selected */ if ((!FL_NOIPV6(flags) && dev->ipv6method == IPV6_AUTO_METHOD) || (FL_NOIPV6(flags) || dev->ipv6method == IPV6_MANUAL_METHOD)) { pref |= DHCPv6_DISABLE | DHCPv6_DISABLE_ADDRESSES; } /* disable some things for this DHCP call */ pref |= DHCPv6_DISABLE_RESOLVER | DHCPv4_DISABLE_HOSTNAME_SET; /* don't try to run the client if DHCPv4 and DHCPv6 are disabled */ if (!(pref & DHCPv4_DISABLE) || !(pref & DHCPv6_DISABLE)){ logMessage(loglevel, "requesting dhcp timeout %ld", (long)timeout); r = pumpDhcpClassRun(i,0L,class,pref,0,timeout,netlogger,loglevel); } /* set hostname if we have that */ if (dev->dev.hostname) { if (sethostname(dev->dev.hostname, strlen(dev->dev.hostname))) { logMessage(ERROR,"error setting hostname to %s",dev->dev.hostname); } } return r; } int configureNetwork(struct networkDeviceConfig * dev) { char *rc; setupWireless(dev); rc = pumpSetupInterface(&dev->dev); if (rc != NULL) { logMessage(INFO, "result of pumpSetupInterface is %s", rc); return 1; } /* we need to wait for a link after setting up the interface as some * switches decide to reconfigure themselves after that (#115825) */ waitForLink((char *)&dev->dev.device); return 0; } int writeNetInfo(const char * fn, struct networkDeviceConfig * dev) { FILE * f; int i; struct device ** devices; char ret[48]; ip_addr_t *tip; devices = getDevices(DEVICE_NETWORK); if (!devices) return 0; for (i = 0; devices[i]; i++) if (!strcmp(devices[i]->device, dev->dev.device)) break; if (!(f = fopen(fn, "w"))) return -1; fprintf(f, "DEVICE=%s\n", dev->dev.device); fprintf(f, "ONBOOT=yes\n"); if (dev->isDynamic) { fprintf(f, "BOOTPROTO=dhcp\n"); } else { fprintf(f, "BOOTPROTO=static\n"); tip = &(dev->dev.ipv4); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); fprintf(f, "IPADDR=%s\n", ret); tip = &(dev->dev.netmask); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); fprintf(f, "NETMASK=%s\n", ret); if (dev->dev.set & PUMP_NETINFO_HAS_GATEWAY) { tip = &(dev->dev.gateway); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); fprintf(f, "GATEWAY=%s\n", ret); } if (dev->dev.set & PUMP_INTFINFO_HAS_BROADCAST) { tip = &(dev->dev.broadcast); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); fprintf(f, "BROADCAST=%s\n", ret); } } if (!FL_NOIPV6(flags)) { if (dev->ipv6method == IPV6_AUTO_METHOD) { fprintf(f, "IPV6_AUTOCONF=yes\n"); } else if (dev->ipv6method == IPV6_DHCP_METHOD) { fprintf(f, "IPV6ADDR=dhcp\n"); } else { tip = &(dev->dev.ipv6); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); fprintf(f, "IPV6ADDR=%s/%d\n", ret, dev->dev.ipv6_prefixlen); } } if (dev->dev.set & PUMP_NETINFO_HAS_HOSTNAME) fprintf(f, "HOSTNAME=%s\n", dev->dev.hostname); if (dev->dev.set & PUMP_NETINFO_HAS_DOMAIN) fprintf(f, "DOMAIN=%s\n", dev->dev.domain); if (dev->mtu) fprintf(f, "MTU=%d\n", dev->mtu); if (dev->peerid) fprintf(f, "PEERID=%s\n", dev->peerid); if (dev->subchannels) fprintf(f, "SUBCHANNELS=%s\n", dev->subchannels); if (dev->portname) fprintf(f, "PORTNAME=%s\n", dev->portname); if (dev->nettype) fprintf(f, "NETTYPE=%s\n", dev->nettype); if (dev->ctcprot) fprintf(f, "CTCPROT=%s\n", dev->ctcprot); if (dev->essid) fprintf(f, "ESSID=%s\n", dev->essid); if (dev->wepkey) fprintf(f, "KEY=%s\n", dev->wepkey); fclose(f); return 0; } int writeResolvConf(struct networkDeviceConfig * net) { char * filename = "/etc/resolv.conf"; FILE * f; int i; char ret[48]; ip_addr_t *tip; #if defined(__s390__) || defined(__s390x__) return 0; #endif if (!(net->dev.set & PUMP_NETINFO_HAS_DOMAIN) && !net->dev.numDns) return LOADER_ERROR; f = fopen(filename, "w"); if (!f) { logMessage(ERROR, "Cannot create %s: %s\n", filename, strerror(errno)); return LOADER_ERROR; } if (net->dev.set & PUMP_NETINFO_HAS_DOMAIN) fprintf(f, "search %s\n", net->dev.domain); for (i = 0; i < net->dev.numDns; i++) { tip = &(net->dev.dnsServers[i]); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); fprintf(f, "nameserver %s\n", ret); } fclose(f); res_init(); /* reinit the resolver so DNS changes take affect */ return 0; } int findHostAndDomain(struct networkDeviceConfig * dev) { char * name, * chptr; char ret[48]; ip_addr_t *tip; struct hostent *host; if (!FL_TESTING(flags)) { writeResolvConf(dev); } if (dev->dev.numDns == 0) { logMessage(ERROR, "no DNS servers, can't look up hostname"); return 1; } if (!(dev->dev.set & PUMP_NETINFO_HAS_HOSTNAME)) { if (!FL_CMDLINE(flags)) winStatus(50, 3, NULL, _("Determining host name and domain...")); else printf("Determining host name and domain...\n"); tip = &(dev->dev.ip); inet_ntop(tip->sa_family, IP_ADDR(tip), ret, IP_STRLEN(tip)); host = gethostbyaddr(IP_ADDR(tip), IP_STRLEN(tip), tip->sa_family); if (!FL_CMDLINE(flags)) newtPopWindow(); if (!host) { logMessage(WARNING, "reverse name lookup of %s failed", ret); return 1; } name = strdup(host->h_name); logMessage(INFO, "reverse name lookup worked (hostname is %s)", name); dev->dev.hostname = strdup(name); dev->dev.set |= PUMP_NETINFO_HAS_HOSTNAME; } else { name = dev->dev.hostname; } if (!(dev->dev.set & PUMP_NETINFO_HAS_DOMAIN)) { for (chptr = name; *chptr && (*chptr != '.'); chptr++) ; if (*chptr == '.') { if (dev->dev.domain) free(dev->dev.domain); dev->dev.domain = strdup(chptr + 1); dev->dev.set |= PUMP_NETINFO_HAS_DOMAIN; } } return 0; } void setKickstartNetwork(struct loaderData_s * loaderData, int argc, char ** argv) { char * arg, * bootProto = NULL, * device = NULL, *ethtool = NULL, * class = NULL; char * essid = NULL, * wepkey = NULL, * onboot = NULL; int noDns = 0, noksdev = 0, rc, mtu = 0, noipv4 = 0, noipv6 = 0, dhcpTimeout = -1; poptContext optCon; struct networkDeviceConfig cfg; struct poptOption ksOptions[] = { { "bootproto", '\0', POPT_ARG_STRING, &bootProto, 0, NULL, NULL }, { "device", '\0', POPT_ARG_STRING, &device, 0, NULL, NULL }, { "dhcpclass", '\0', POPT_ARG_STRING, &class, 0, NULL, NULL }, { "gateway", '\0', POPT_ARG_STRING, NULL, 'g', NULL, NULL }, { "ip", '\0', POPT_ARG_STRING, NULL, 'i', NULL, NULL }, { "mtu", '\0', POPT_ARG_INT, &mtu, 0, NULL, NULL }, { "nameserver", '\0', POPT_ARG_STRING, NULL, 'n', NULL, NULL }, { "netmask", '\0', POPT_ARG_STRING, NULL, 'm', NULL, NULL }, { "noipv4", '\0', POPT_ARG_NONE, &noipv4, 0, NULL, NULL }, { "noipv6", '\0', POPT_ARG_NONE, &noipv6, 0, NULL, NULL }, { "nodns", '\0', POPT_ARG_NONE, &noDns, 0, NULL, NULL }, { "hostname", '\0', POPT_ARG_STRING, NULL, 'h', NULL, NULL}, { "ethtool", '\0', POPT_ARG_STRING, ðtool, 0, NULL, NULL }, { "essid", '\0', POPT_ARG_STRING, &essid, 0, NULL, NULL }, { "wepkey", '\0', POPT_ARG_STRING, &wepkey, 0, NULL, NULL }, { "onboot", '\0', POPT_ARG_STRING, &onboot, 0, NULL, NULL }, { "notksdevice", '\0', POPT_ARG_NONE, &noksdev, 0, NULL, NULL }, { "dhcptimeout", '\0', POPT_ARG_INT, &dhcpTimeout, 0, NULL, NULL }, { 0, 0, 0, 0, 0, 0, 0 } }; optCon = poptGetContext(NULL, argc, (const char **) argv, ksOptions, 0); while ((rc = poptGetNextOpt(optCon)) >= 0) { arg = (char *) poptGetOptArg(optCon); switch (rc) { case 'g': loaderData->gateway = strdup(arg); break; case 'i': loaderData->ipv4 = strdup(arg); break; case 'n': loaderData->dns = strdup(arg); break; case 'm': loaderData->netmask = strdup(arg); break; case 'h': if (loaderData->hostname) free(loaderData->hostname); loaderData->hostname = strdup(arg); break; } } if (rc < -1) { newtWinMessage(_("Kickstart Error"), _("OK"), _("Bad argument to kickstart network command %s: %s"), poptBadOption(optCon, POPT_BADOPTION_NOALIAS), poptStrerror(rc)); } else { poptFreeContext(optCon); } /* if they've specified dhcp/bootp or haven't specified anything, * use dhcp for the interface */ if ((bootProto && (!strncmp(bootProto, "dhcp", 4) || !strncmp(bootProto, "bootp", 4))) || (!bootProto && !loaderData->ipv4)) { loaderData->ipv4 = strdup("dhcp"); loaderData->ipinfo_set = 1; } else if (loaderData->ipv4) { /* JKFIXME: this assumes a bit... */ loaderData->ipinfo_set = 1; } /* now make sure the specified bootproto is valid */ if (bootProto && strcmp(bootProto, "dhcp") && strcmp(bootProto, "bootp") && strcmp(bootProto, "static") && strcmp(bootProto, "query")) { newtWinMessage(_("Kickstart Error"), _("OK"), _("Bad bootproto %s specified in network command"), bootProto); } if (!noksdev) { if (device) { loaderData->netDev = strdup(device); loaderData->netDev_set = 1; } if (class) { loaderData->netCls = strdup(class); loaderData->netCls_set = 1; } if (ethtool) { if (loaderData->ethtool) free(loaderData->ethtool); loaderData->ethtool = strdup(ethtool); free(ethtool); } if (essid) { if (loaderData->essid) free(loaderData->essid); loaderData->essid = strdup(essid); free(essid); } if (wepkey) { if (loaderData->wepkey) free(loaderData->wepkey); loaderData->wepkey = strdup(wepkey); free(wepkey); } if (mtu) { loaderData->mtu = mtu; } if (noipv4) flags |= LOADER_FLAGS_NOIPV4; if (noipv6) flags |= LOADER_FLAGS_NOIPV6; } if (noDns) { loaderData->noDns = 1; } /* Make sure the network is always up if there's a network line in the * kickstart file, as %post/%pre scripts might require that. */ if (loaderData->method != METHOD_NFS && loaderData->method != METHOD_URL) { initLoopback(); if (kickstartNetworkUp(loaderData, &cfg)) logMessage(ERROR, "unable to bring up network"); } } /* if multiple interfaces get one to use from user. */ /* NOTE - uses kickstart data available in loaderData */ int chooseNetworkInterface(struct loaderData_s * loaderData) { int i, rc; unsigned int max = 40; int deviceNums = 0; int deviceNum; char ** devices; char ** deviceNames; int foundDev = 0; struct device ** devs; char * ksMacAddr = NULL; devs = getDevices(DEVICE_NETWORK); if (!devs) { logMessage(ERROR, "no network devices in choose network device!"); return LOADER_ERROR; } for (i = 0; devs[i]; i++); devices = alloca((i + 1) * sizeof(*devices)); deviceNames = alloca((i + 1) * sizeof(*devices)); if (loaderData->netDev && (loaderData->netDev_set) == 1) { if ((loaderData->bootIf && (loaderData->bootIf_set) == 1) && !strcasecmp(loaderData->netDev, "bootif")) { ksMacAddr = strdup(loaderData->bootIf); } else { ksMacAddr = strdup(loaderData->netDev); } ksMacAddr = str2upper(ksMacAddr); } for (i = 0; devs[i]; i++) { if (!devs[i]->device) continue; /* require passing a flag for wireless while our wireless support * sucks */ if (is_wireless_interface(devs[i]->device) && !FL_ALLOW_WIRELESS(flags)) continue; if (devs[i]->description) { deviceNames[deviceNums] = alloca(strlen(devs[i]->device) + strlen(devs[i]->description) + 4); sprintf(deviceNames[deviceNums],"%s - %s", devs[i]->device, devs[i]->description); if (strlen(deviceNames[deviceNums]) > max) max = strlen(deviceNames[deviceNums]); devices[deviceNums] = devs[i]->device; } else { devices[deviceNums] = devs[i]->device; deviceNames[deviceNums] = devs[i]->device; } deviceNums++; /* this device has been set and we don't really need to ask * about it again... */ if (loaderData->netDev && (loaderData->netDev_set == 1)) { if (!strcmp(loaderData->netDev, devs[i]->device)) { foundDev = 1; } else if (ksMacAddr != NULL) { /* maybe it's a mac address */ char *devmacaddr = NULL; devmacaddr = iface_mac2str(devs[i]->device); if ((devmacaddr != NULL) && !strcmp(ksMacAddr, devmacaddr)) { foundDev = 1; free(loaderData->netDev); loaderData->netDev = devs[i]->device; if (devmacaddr != NULL) free(devmacaddr); break; } if (devmacaddr != NULL) free(devmacaddr); } } } if (ksMacAddr) free(ksMacAddr); if (foundDev == 1) return LOADER_NOOP; devices[deviceNums] = NULL; deviceNames[deviceNums] = NULL; qsort(devices, deviceNums, sizeof(*devices), simpleStringCmp); qsort(deviceNames, deviceNums, sizeof(*devices), simpleStringCmp); /* ASSERT: we should *ALWAYS* have a network device when we get here */ if (!deviceNums) { logMessage(CRITICAL, "no network device in chooseNetworkInterface"); return LOADER_ERROR; } /* JKFIXME: if we only have one interface and it doesn't have link, * do we go ahead? */ if (deviceNums == 1) { logMessage(INFO, "only have one network device: %s", devices[0]); loaderData->netDev = devices[0]; return LOADER_NOOP; } if ((loaderData->netDev && (loaderData->netDev_set == 1)) && !strcmp(loaderData->netDev, "link")) { logMessage(INFO, "looking for first netDev with link"); for (rc = 0; rc < 5; rc++) { for (i = 0; i < deviceNums; i++) { if (get_link_status(devices[i]) == 1) { loaderData->netDev = devices[i]; logMessage(INFO, "%s has link, using it", devices[i]); return LOADER_NOOP; } } sleep(1); } logMessage(WARNING, "wanted netdev with link, but none present. prompting"); } startNewt(); if (max > 70) max = 70; /* JKFIXME: should display link status */ deviceNum = 0; rc = newtWinMenu(_("Networking Device"), _("You have multiple network devices on this system. " "Which would you like to install through?"), max, 10, 10, deviceNums < 6 ? deviceNums : 6, deviceNames, &deviceNum, _("OK"), _("Back"), NULL); if (rc == 2) return LOADER_BACK; loaderData->netDev = devices[deviceNum]; /* turn off the non-active interface. this should keep things from * breaking when we need the interface to do the install as long as * you keep using that device */ for (i = 0; devs[i]; i++) { if (strcmp(loaderData->netDev, devices[i])) if (!FL_TESTING(flags)) pumpDisableInterface(devs[i]->device); } return LOADER_OK; } /* JKFIXME: bad name. this function brings up networking early on a * kickstart install so that we can do things like grab the ks.cfg from * the network */ int kickstartNetworkUp(struct loaderData_s * loaderData, struct networkDeviceConfig *netCfgPtr) { int rc; /* we may have networking already, so return to the caller */ if ((loaderData->ipinfo_set == 1) || (loaderData->ipv6info_set == 1)) return 0; initLoopback(); memset(netCfgPtr, 0, sizeof(*netCfgPtr)); do { do { /* this is smart and does the right thing based on whether or not * we have ksdevice= specified */ rc = chooseNetworkInterface(loaderData); if (rc == LOADER_ERROR) { /* JKFIXME: ask for a driver disk? */ logMessage(ERROR, "no network drivers for doing kickstart"); return -1; } else if (rc == LOADER_BACK) { return -1; } /* insert device into pump structure */ strcpy(netCfgPtr->dev.device, loaderData->netDev); break; } while (1); /* we don't want to end up asking about interface more than once * if we're in a kickstart-ish case (#100724) */ loaderData->netDev_set = 1; /* JKFIXME: this is kind of crufty, we depend on the fact that the * ip is set and then just get the network up. we should probably * add a way to do asking about static here and not be such a hack */ if (!loaderData->ipv4) { loaderData->ipv4 = strdup("dhcp"); } loaderData->ipinfo_set = 1; setupNetworkDeviceConfig(netCfgPtr, loaderData); rc = readNetConfig(loaderData->netDev, netCfgPtr, loaderData->netCls, loaderData->method); if (rc == LOADER_ERROR) { logMessage(ERROR, "unable to setup networking"); return -1; } else if (rc == LOADER_BACK) { /* Going back to the interface selection screen, so unset anything * we set before attempting to bring the incorrect interface up. */ loaderData->netDev_set = 0; free(loaderData->ipv4); loaderData->ipinfo_set = 0; } else break; } while (1); return 0; } void splitHostname (char *str, char **host, char **port) { char *rightbrack = strchr(str, ']'); *host = NULL; *port = NULL; if (*str == '[' && rightbrack) { /* An IPv6 address surrounded by brackets, optionally with a colon and * port number. */ char *colon = strrchr(rightbrack, ':'); if (colon) { *host = strndup(str+1, rightbrack-1-str); *port = strdup(colon+1); } else *host = strndup(str+1, rightbrack-1-str); } else if (strcount(str, ':') > 1) { /* An IPv6 address without brackets. Don't make the user surround the * address with brackets if there's no port number. */ *host = strdup(str); } else { /* An IPv4 address, optionally with a colon and port number. */ char *colon = strrchr(str, ':'); if (colon) { *host = strndup(str, colon-str); *port = strdup(colon+1); } else *host = strdup(str); } } /* vim:set shiftwidth=4 softtabstop=4: */