home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / misc / src / install / net.c < prev    next >
C/C++ Source or Header  |  1997-10-24  |  31KB  |  1,220 lines
  1. #include <net/if.h>
  2. #include <net/route.h>
  3. #include <sys/ioctl.h>
  4. #include <sys/time.h>
  5. #include <sys/types.h>
  6.  
  7. #include <ctype.h>
  8. #include <errno.h>
  9. #include <netinet/in.h>
  10. #include <netinet/ip.h>
  11. #include <arpa/inet.h>
  12. #include <resolv.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <unistd.h>
  17.  
  18. #include "bootpc.h"
  19. #include "devices.h"
  20. #include "install.h"
  21. #include "log.h"
  22. #include "newt.h"
  23. #include "net.h"
  24. #include "perror.h"
  25. #include "windows.h"
  26.  
  27. struct intfconfig_s {
  28.     newtComponent ipLabel, nmLabel, gwLabel, nsLabel;
  29.     newtComponent ipEntry, nmEntry, gwEntry, nsEntry;
  30.     char * ip, * nm, * gw, * ns;
  31.     char * bootpState;
  32. };
  33.  
  34. struct netconfig_s {
  35.     newtComponent nsLabels[3], hnLabel, dnLabel;
  36.     newtComponent nsEntrys[3], hnEntry, dnEntry;
  37.     char * ns[3], * gw, * hn, * dn;
  38. };
  39.  
  40. static void ipCallback(newtComponent co, void * data);
  41. static void hnCallback(newtComponent co, void * data);
  42.  
  43. /* It's a bit gross, but setupNetworkInterface() will setup your general
  44.    networking information if bootp is used */
  45. static int setupNetworkInterface(struct netInterface * intf,
  46.                  struct netConfig * netc,
  47.                      struct driversLoaded ** dl, int justConfig);
  48. static int doBringUpNetworking(struct netInterface * intf, 
  49.                    struct netConfig * netc,
  50.                    struct driversLoaded ** dl, int justConfig);
  51. static int configureNetDevice(struct netInterface * intf);
  52. /* intf in configureNetwork is optional */
  53. static int configureNetwork(struct netConfig * netc, 
  54.                 struct netInterface * intf);
  55. static char * findAvailableNetDevice(void);
  56.  
  57. static int doBootp(char * device, struct netInterface * intf,
  58.            struct netConfig * netc) {
  59.     struct netInterface minInterface;
  60.     int rc;
  61.  
  62.     /* This is a bit of a hack, but it lets us use Jon Peatfield's bootp
  63.        code w/o hacking at it. It's written to allow test mode to work
  64.        as long as the runner sets the proper magic env variables. */
  65.  
  66.     if (!testing) {
  67.     logMessage("using bootp for device %s", device);
  68.  
  69.     minInterface.ip = minInterface.netmask = minInterface.network = 0;
  70.     minInterface.broadcast = 0xffffffff; 
  71.     strcpy(minInterface.dev, device);
  72.  
  73.     if (configureNetDevice(&minInterface)) {
  74.         logMessage("failed to setup minimal bootp interface %s", device);
  75.         return 1;
  76.     }
  77.  
  78.     winStatus(40, 3, "BOOTP", "Sending BOOTP request...");
  79.     rc = performBootp(device, "255.255.255.255", "", 10, 0, NULL, 0, 1,
  80.                 BP_PUT_ENV);
  81.     newtPopWindow();
  82.  
  83.     if (rc) {
  84.         logMessage("performBootp() failed w/ return %d", rc);
  85.         return 1;
  86.     }
  87.     }
  88.  
  89.     if (!getenv("BOOTP_IPADDR")) {
  90.     errorWindow("bootp query did not return an IP address");
  91.     return 1;
  92.     }
  93.     
  94.     /* These will be generated by bootpc.c even if they're not in the
  95.        bootp reply */
  96.  
  97.     inet_aton(getenv("BOOTP_IPADDR"), (struct in_addr *) &intf->ip);
  98.     inet_aton(getenv("BOOTP_NETMASK"), (struct in_addr *) &intf->netmask);
  99.     inet_aton(getenv("BOOTP_BROADCAST"), (struct in_addr *) 
  100.             &intf->broadcast);
  101.     inet_aton(getenv("BOOTP_NETWORK"), (struct in_addr *) 
  102.             &intf->network);
  103.  
  104.     intf->useBootp = 1;
  105.     intf->isConfigured = 1;
  106.     strcpy(intf->dev, device);
  107.  
  108.     if (getenv("BOOTP_GATEWAYS_1")) {
  109.     strcpy(netc->defaultGateway, getenv("BOOTP_GATEWAYS_1"));
  110.     netc->isConfigured = 1;
  111.     }
  112.  
  113.     if (getenv("BOOTP_DNSSRVS_1")) {
  114.     netc->nameserver[0] = strdup(getenv("BOOTP_DNSSRVS_1"));
  115.     netc->isConfigured = 1;
  116.     if (getenv("BOOTP_DNSSRVS_2"))  {
  117.         netc->nameserver[1] = strdup(getenv("BOOTP_DNSSRVS_2"));
  118.         if (getenv("BOOTP_DNSSRVS_3")) 
  119.         netc->nameserver[2] = strdup(getenv("BOOTP_DNSSRVS_3"));
  120.     }
  121.     }
  122.  
  123.     /* 
  124.     If bootp gave us a hostname and domain, use those. Otherwise,
  125.     we'll try and query the nameserver a bit later on. If that fails
  126.     as well, we'll try and use just the hostname BOOTP gave us.
  127.     */
  128.  
  129.     if (getenv("BOOTP_HOSTNAME") && getenv("BOOTP_DOMAIN")) {
  130.     logMessage("bootp returned hostname and domain name");
  131.     strcpy(netc->hostname, getenv("BOOTP_HOSTNAME"));
  132.     netc->isConfigured = 1;
  133.  
  134.     strcpy(netc->domainname, getenv("BOOTP_DOMAIN"));
  135.  
  136.     if (strcmp(netc->hostname, netc->domainname) &&
  137.         !strstr(netc->hostname, netc->domainname)) {
  138.         strcat(netc->hostname, ".");
  139.         strcat(netc->hostname, netc->domainname);
  140.     }
  141.     } 
  142.  
  143.     return 0;
  144. }
  145.  
  146. /* The interface/gateway needs to be configured before this will work! */
  147. static int guessHostname(struct netInterface * intf, struct netConfig * netc) {
  148.     struct in_addr addr;
  149.     char ips[50];
  150.  
  151.     if ((testing || intf->isUp) && netc->nameserver[0]) {
  152.     logMessage("using nameserver to find host and domain name");
  153.     writeResolvConf("/etc", netc);
  154.     memcpy(&addr, &intf->ip, sizeof(addr));
  155.     strcpy(ips, inet_ntoa(addr));
  156.     winStatus(40, 3, "Hostname", "Determing host name and domain...");
  157.         if (in2host(ips, BP_PUT_ENV)) {
  158.         newtPopWindow();
  159.         logMessage("reverse name lookup failed");
  160.  
  161.         if (getenv("BOOTP_HOSTNAME")) {
  162.         strcpy(netc->hostname, getenv("BOOTP_HOSTNAME"));
  163.         } 
  164.  
  165.         return 1;
  166.     } else {
  167.         newtPopWindow();
  168.         logMessage("reverse name lookup worked");
  169.         strcpy(netc->hostname, getenv("BOOTP_HOSTFULL"));
  170.         strcpy(netc->domainname, getenv("BOOTP_HOSTDOMAIN"));
  171.  
  172.         return 0;
  173.     }
  174.     }
  175.  
  176.     return 1;
  177. }
  178.  
  179. int addDefaultRoute(struct netConfig netc) {
  180.     int s;
  181.     struct rtentry route;
  182.     struct sockaddr_in addr;
  183.  
  184.     if (testing) return 0;
  185.  
  186.     if (!strlen(netc.defaultGateway)) return 0;
  187.  
  188.     s = socket(AF_INET, SOCK_DGRAM, 0);
  189.     if (s < 0) {
  190.     close(s);
  191.     errorWindow("socket: %s");
  192.     return 1;
  193.     }
  194.  
  195.     memset(&route, 0, sizeof(route));
  196.  
  197.     addr.sin_family = AF_INET;
  198.     addr.sin_port = 0;
  199.     inet_aton(netc.defaultGateway, &addr.sin_addr);
  200.     memcpy(&route.rt_gateway, &addr, sizeof(addr));
  201.  
  202.     addr.sin_addr.s_addr = INADDR_ANY;
  203.     memcpy(&route.rt_dst, &addr, sizeof(addr));
  204.     memcpy(&route.rt_genmask, &addr, sizeof(addr));
  205.  
  206.     route.rt_flags = RTF_UP | RTF_GATEWAY;
  207.     route.rt_metric = 0;
  208.  
  209.     if (ioctl(s, SIOCADDRT, &route)) {
  210.     close(s);
  211.     errorWindow("SIOCADDRT: %s");
  212.     return 1;
  213.     }
  214.  
  215.     return 0;
  216. }
  217.  
  218. static int configureNetDevice(struct netInterface * intf) {
  219.     struct ifreq req;
  220.     struct rtentry route;
  221.     int s;
  222.     struct sockaddr_in addr;
  223.     struct in_addr ia;
  224.     char ip[20], nm[20], nw[20], bc[20];
  225.  
  226.     addr.sin_family = AF_INET;
  227.     addr.sin_port = 0;
  228.  
  229.     memcpy(&ia, &intf->ip, sizeof(intf->ip));
  230.     strcpy(ip, inet_ntoa(ia));
  231.  
  232.     memcpy(&ia, &intf->netmask, sizeof(intf->netmask));
  233.     strcpy(nm, inet_ntoa(ia));
  234.  
  235.     memcpy(&ia, &intf->broadcast, sizeof(intf->broadcast));
  236.     strcpy(bc, inet_ntoa(ia));
  237.  
  238.     memcpy(&ia, &intf->network, sizeof(intf->network));
  239.     strcpy(nw, inet_ntoa(ia));
  240.  
  241.     logMessage("configuring %s ip: %s nm: %s nw: %s bc: %s", intf->dev,
  242.         ip, nm, nw, bc);
  243.  
  244.     if (testing) return 0;
  245.     
  246.     strcpy(req.ifr_name, intf->dev);
  247.     addr.sin_family = AF_INET;
  248.     addr.sin_port = 0;
  249.     memcpy(&addr.sin_addr, &intf->ip, sizeof(intf->ip));
  250.  
  251.     s = socket(AF_INET, SOCK_DGRAM, 0);
  252.     if (s < 0) {
  253.     errorWindow("socket: %s");
  254.     return 1;
  255.     }
  256.  
  257.     memcpy(&req.ifr_addr, &addr, sizeof(addr));
  258.     if (ioctl(s, SIOCSIFADDR, &req)) {
  259.     close(s);
  260.     errorWindow("SIOCSIFADDR: %s");
  261.     return 1;
  262.     }
  263.  
  264.     memcpy(&addr.sin_addr, &intf->broadcast, sizeof(intf->broadcast));
  265.     memcpy(&req.ifr_broadaddr, &addr, sizeof(addr));
  266.     if (ioctl(s, SIOCSIFBRDADDR, &req)) {
  267.     close(s);
  268.     errorWindow("SIOCSIFNETMASK: %s");
  269.     return 1;
  270.     }
  271.  
  272.     memcpy(&addr.sin_addr, &intf->netmask, sizeof(intf->netmask));
  273.     memcpy(&req.ifr_netmask, &addr, sizeof(addr));
  274.     if (ioctl(s, SIOCSIFNETMASK, &req)) {
  275.     close(s);
  276.     errorWindow("SIOCSIFNETMASK: %s");
  277.     return 1;
  278.     }
  279.  
  280.     if (intf->isPtp)
  281.     req.ifr_flags = IFF_UP | IFF_RUNNING | IFF_POINTOPOINT | IFF_NOARP;
  282.     else
  283.     req.ifr_flags = IFF_UP | IFF_RUNNING | IFF_BROADCAST;
  284.  
  285.     if (ioctl(s, SIOCSIFFLAGS, &req)) {
  286.     close(s);
  287.     errorWindow("SIOCSIFFLAGS: %s");
  288.     return 1;
  289.     }
  290.  
  291.     memset(&route, 0, sizeof(route));
  292.     route.rt_dev = intf->dev;
  293.     route.rt_flags = RTF_UP;
  294.  
  295.     memcpy(&addr.sin_addr, &intf->network, sizeof(intf->netmask));
  296.     memcpy(&route.rt_dst, &addr, sizeof(addr));
  297.  
  298.     memcpy(&addr.sin_addr, &intf->netmask, sizeof(intf->netmask));
  299.     memcpy(&route.rt_genmask, &addr, sizeof(addr));
  300.  
  301.     if (ioctl(s, SIOCADDRT, &route)) {
  302.     close(s);
  303.     errorWindow("SIOCADDRT: %s");
  304.     return 1;
  305.     }
  306.  
  307.     intf->isUp = 1;
  308.  
  309.     return 0;
  310. }
  311.  
  312. int netDeviceAvailable(char * device) {
  313.     struct ifreq req;
  314.     int s;
  315.     
  316.     s = socket(AF_INET, SOCK_DGRAM, 0);
  317.     if (s < 0) {
  318.     close(s);
  319.     errorWindow("socket: %s");
  320.     return 1;
  321.     }
  322.  
  323.     strcpy(req.ifr_name, device);
  324.  
  325.     if (ioctl(s, SIOCGIFFLAGS, &req)) {
  326.     /* if we can't get the flags, the networking device isn't available */
  327.     close(s);
  328.     return 0;
  329.     }
  330.   
  331.     return 1;
  332. }
  333.  
  334. static void interfaceConfigToggle(newtComponent co, void * arg) {
  335.     struct intfconfig_s * info = arg;
  336.     int sense = NEWT_FLAGS_SET;
  337.  
  338.     if (*info->bootpState == ' ') 
  339.     sense = NEWT_FLAGS_RESET;
  340.  
  341.     newtEntrySetFlags(info->ipEntry, NEWT_ENTRY_DISABLED, sense);
  342.     newtEntrySetFlags(info->nmEntry, NEWT_ENTRY_DISABLED, sense);
  343.     newtEntrySetFlags(info->gwEntry, NEWT_ENTRY_DISABLED, sense);
  344.     newtEntrySetFlags(info->nsEntry, NEWT_ENTRY_DISABLED, sense);
  345.  
  346.     newtRefresh();
  347. }
  348.  
  349. static char * findAvailableNetDevice(void) {
  350.     char * devices[] = { "eth0", "tr0", "plip0", "plip1", "plip2", 
  351.              "fddi0", NULL };
  352.     char * device = NULL;
  353.     char ** deviceptr;
  354.  
  355.     /* I should probably ask which device to use if multiple ones are
  356.        available -- oh well :-( */
  357.     for (deviceptr = devices; *deviceptr; deviceptr++) {
  358.     if (netDeviceAvailable(*deviceptr)) {
  359.         device = *deviceptr;
  360.         logMessage("%s is available -- using it for networking", device);
  361.         break;
  362.     }
  363.     }
  364.  
  365.     return device;
  366. }
  367.  
  368. static int setupNetworkInterface(struct netInterface * intf,
  369.                  struct netConfig * netc,
  370.                      struct driversLoaded ** dl, int justConfig) {
  371.     newtComponent okay, cancel, bootp, f, answer;
  372.     int top = 4;
  373.     struct intfconfig_s c;
  374.     struct in_addr addr;
  375.     int32 ptpNetmask;
  376.     int rc;
  377.     int done = 0;
  378.     char useBootp;
  379.     char * device;
  380.     struct driversLoaded * adriver;
  381.  
  382.     device = findAvailableNetDevice();
  383.  
  384.     if (!device) {
  385.     if ((rc = loadDeviceDriver(DRIVER_NET, dl, 0)))
  386.         return rc;
  387.  
  388.     for (adriver = *dl; adriver && adriver->type != DRIVER_NET; 
  389.         adriver = adriver->next);
  390.     if (!adriver) {
  391.         logMessage("ack! loadDriveDriver() worked but didn't load a "
  392.             "DRIVE_NET!!");
  393.         return INST_ERROR;
  394.     }
  395.  
  396.     switch (adriver->minor) {
  397.       case DRIVER_MINOR_ETHERNET:    device = "eth0"; break;
  398.       case DRIVER_MINOR_TR:        device = "tr0"; break;
  399.       case DRIVER_MINOR_PLIP:    device = getPlipDeviceName(); break;
  400.       default:            exit(1); /* ack! */
  401.     }
  402.     }
  403.  
  404.     newtCenteredWindow(50, 15, "Configure TCP/IP");
  405.  
  406.     c.ipLabel = newtLabel(1, top + 2, "IP address:");
  407.     c.nmLabel = newtLabel(1, top + 3, "Netmask:");
  408.     c.gwLabel = newtLabel(1, top + 4, "Default gateway (IP):");
  409.     c.nsLabel = newtLabel(1, top + 5, "Primary nameserver:");
  410.    
  411.     if (!intf->ip){
  412.     c.ipEntry = newtEntry(25, top + 2, "", 16, &c.ip, 0);
  413.     } else {
  414.     memcpy(&addr, &intf->ip, sizeof(intf->ip));
  415.     c.ipEntry = newtEntry(25, top + 2, inet_ntoa(addr), 16, &c.ip, 0);
  416.     }
  417.  
  418.     if (!intf->netmask){
  419.     c.nmEntry = newtEntry(25, top + 3, "", 16, &c.nm, 0);
  420.     } else {
  421.     memcpy(&addr, &intf->netmask, sizeof(intf->netmask));
  422.     c.nmEntry = newtEntry(25, top + 3, inet_ntoa(addr), 16, &c.nm, 0);
  423.     }
  424.  
  425.     if (!netc->defaultGateway) 
  426.     c.gwEntry = newtEntry(25, top + 4, "", 16, &c.gw, 0);
  427.     else
  428.     c.gwEntry = newtEntry(25, top + 4, netc->defaultGateway, 16, &c.gw, 0);
  429.  
  430.  
  431.     if (!netc->nameserver[0]) 
  432.     c.nsEntry = newtEntry(25, top + 5, "", 16, &c.ns, 0);
  433.     else
  434.     c.nsEntry = newtEntry(25, top + 5, netc->nameserver[0], 16, &c.ns, 0);
  435.     
  436.     c.bootpState = &useBootp;
  437.    
  438.     f = newtForm(NULL, NULL, 0);
  439.  
  440.     bootp = newtCheckbox(1, top, "Configure device with bootp", 
  441.              (intf->isConfigured && intf->useBootp) ? '*' : ' ', 
  442.              NULL, &useBootp);
  443.  
  444.     newtComponentAddCallback(bootp, interfaceConfigToggle, &c);
  445.  
  446.     newtFormAddComponents(f, bootp, c.ipLabel, c.nmLabel, c.gwLabel, c.nsLabel, 
  447.                  c.ipEntry, c.nmEntry, c.gwEntry, c.nsEntry, NULL);
  448.  
  449.     if (c.bootpState)
  450.     newtFormSetCurrent(f, c.ipEntry);
  451.  
  452.     newtComponentAddCallback(c.ipEntry, ipCallback, &c);
  453.     newtComponentAddCallback(c.nmEntry, ipCallback, &c);
  454.  
  455.     okay = newtButton(8, top + 7, "Ok");
  456.     cancel = newtButton(28, top + 7, "Cancel");
  457.  
  458.     newtFormAddComponents(f, okay, cancel, NULL);
  459.  
  460.     do {
  461.     answer = newtRunForm(f);
  462.  
  463.     if (answer == cancel) {
  464.         newtFormDestroy(f);
  465.         newtPopWindow();
  466.  
  467.         return INST_CANCEL;
  468.     }
  469.  
  470.     if (useBootp != ' ') {
  471.         logMessage("Configuring device %s via bootp", device);
  472.         if (justConfig) {
  473.         done = 1;
  474.         intf->useBootp = 1;
  475.         intf->isConfigured = 1;
  476.         } else if (!doBootp(device, intf, netc)) {
  477.         done = 1;
  478.         }
  479.     } else {
  480.         strcpy(intf->dev, device);
  481.         inet_aton(c.ip, (struct in_addr *) &intf->ip);
  482.         inet_aton(c.nm, (struct in_addr *) &intf->netmask);
  483.         intf->broadcast = (intf->ip & intf->netmask) | (~intf->netmask);
  484.  
  485.         inet_aton("255.255.255.255", (struct in_addr *) &ptpNetmask);
  486.  
  487.         if (ptpNetmask == intf->netmask) {
  488.         logMessage("configuring point to point device");
  489.         inet_aton(c.gw, (struct in_addr *) &intf->network);
  490.         intf->isPtp = 1;
  491.         } else {
  492.         intf->network = intf->ip & intf->netmask;
  493.         intf->isPtp = 0;
  494.         }
  495.  
  496.         intf->isConfigured = 1;
  497.         intf->useBootp = 0;
  498.  
  499.         strcpy(netc->defaultGateway, c.gw);
  500.  
  501.         if (netc->nameserver[0]) free(netc->nameserver[0]);
  502.  
  503.         if (strlen(c.ns))
  504.         netc->nameserver[0] = strdup(c.ns);
  505.         else
  506.         netc->nameserver[0] = NULL;
  507.         
  508.         netc->isConfigured = 1;
  509.  
  510.         done = 1;
  511.     }
  512.     } while (!done);
  513.  
  514.     newtFormDestroy(f);
  515.     newtPopWindow();
  516.  
  517.     if (!justConfig) {
  518.     if (configureNetDevice(intf)) return INST_ERROR;
  519.     if (addDefaultRoute(*netc)) return INST_ERROR;
  520.     }
  521.  
  522.     return 0;
  523. } 
  524.  
  525. static void hnCallback(newtComponent co, void * dptr) {
  526.     char * buf;
  527.     struct netconfig_s * data = dptr;
  528.  
  529.     if (strlen(data->hn)) return;
  530.     if (!strlen(data->dn)) return;
  531.  
  532.     buf = alloca(strlen(data->dn) + 5);
  533.     strcpy(buf, ".");
  534.     strcat(buf, data->dn);
  535.     
  536.     newtEntrySet(data->hnEntry, buf, 0);
  537. }
  538.  
  539. static void ipCallback(newtComponent co, void * dptr) {
  540.     struct intfconfig_s * data = dptr;
  541.     struct in_addr ipaddr, nmaddr, addr;
  542.     char * ascii;
  543.     int32 broadcast, network;
  544.  
  545.     if (co == data->ipEntry) {
  546.     if (strlen(data->ip) && !strlen(data->nm)) {
  547.         if (inet_aton(data->ip, &ipaddr)) {
  548.         ipaddr.s_addr = ntohl(ipaddr.s_addr);
  549.         if (((ipaddr.s_addr & 0xFF000000) >> 24) <= 127)
  550.             ascii = "255.0.0.0";
  551.         else if (((ipaddr.s_addr & 0xFF000000) >> 24) <= 191)
  552.             ascii = "255.255.0.0";
  553.         else 
  554.             ascii = "255.255.255.0";
  555.         newtEntrySet(data->nmEntry, ascii, 1);
  556.         }
  557.     }
  558.     } else if (co == data->nmEntry) {
  559.     if (!strlen(data->ip) || !strlen(data->nm)) return;
  560.     if (!inet_aton(data->ip, &ipaddr)) return;
  561.     if (!inet_aton(data->nm, &nmaddr)) return;
  562.  
  563.         network = ipaddr.s_addr & nmaddr.s_addr;
  564.     broadcast = (ipaddr.s_addr & nmaddr.s_addr) | (~nmaddr.s_addr);
  565.  
  566.     addr.s_addr = htonl(ntohl(broadcast) - 1);
  567.     newtEntrySet(data->gwEntry, inet_ntoa(addr), 1);
  568.  
  569.     /* I'm such a lazy bastard */
  570.     if ((ntohl(network) & 0xFFFFFF00) == 0xc7b71800) {
  571.         newtEntrySet(data->nsEntry, "199.183.24.1", 1);
  572.     } else {
  573.         addr.s_addr = htonl(ntohl(network) + 1);
  574.         newtEntrySet(data->nsEntry, inet_ntoa(addr), 1);
  575.     }
  576.     }
  577. }
  578.  
  579. int writeNetConfig(char * prefix, struct netConfig * netc, 
  580.            struct netInterface * gwdev, int verbose) {
  581.     char filename[100];
  582.     FILE * f;
  583.  
  584.     if (testing) return 0;
  585.  
  586.     sprintf(filename, "%s/network", prefix);
  587.  
  588.     f = fopen(filename, "w");
  589.     if (!f) {
  590.     errorWindow("cannot create network config file: %s");
  591.     return INST_ERROR;
  592.     }
  593.  
  594.     fprintf(f, "NETWORKING=yes\n");
  595.     fprintf(f, "FORWARD_IPV4=false\n");
  596.  
  597.     logMessage("writing network information to %s", filename);
  598.  
  599.     if (netc->hostname && strlen(netc->hostname)) {
  600.     logMessage("\tnetwork is configured, writing complete information");
  601.  
  602.     fprintf(f, "HOSTNAME=%s\n", netc->hostname);
  603.     fprintf(f, "DOMAINNAME=%s\n", netc->domainname);
  604.  
  605.     if (gwdev && strlen(netc->defaultGateway)) {
  606.         fprintf(f, "GATEWAY=%s\n", netc->defaultGateway);
  607.         fprintf(f, "GATEWAYDEV=%s\n", gwdev->dev);
  608.     }
  609.  
  610.     if (verbose) {
  611.         if (netc->nameserver[0])
  612.         fprintf(f, "NS1=%s\n", netc->nameserver[0]);
  613.         
  614.         if (netc->nameserver[1])
  615.         fprintf(f, "NS2=%s\n", netc->nameserver[1]);
  616.         
  617.         if (netc->nameserver[2])
  618.         fprintf(f, "NS3=%s\n", netc->nameserver[2]);
  619.     }
  620.     } else {
  621.     logMessage("\tnetwork is not configured");
  622.     fprintf(f, "HOSTNAME=localhost.localdomain\n");
  623.     }
  624.  
  625.     fclose(f);
  626.  
  627.     return 0;
  628. }
  629.  
  630. int writeHosts(char * prefix, struct netConfig * netc, 
  631.            struct netInterface * intf) {
  632.     char filename[100];
  633.     FILE * f;
  634.     struct in_addr * addrptr;
  635.     char * nickname;
  636.     int i;
  637.  
  638.     if (testing) return 1;
  639.  
  640.     sprintf(filename, "%s/hosts", prefix);
  641.  
  642.     /* if /etc/hosts already exists, don't bother creating one */
  643.     if (!access(filename, R_OK)) {
  644.     logMessage("%s already exists -- won't crunch it", filename);
  645.     return 0;
  646.     }
  647.     logMessage("%s doesn not exist -- creating", filename);
  648.  
  649.     f = fopen(filename, "w");
  650.     if (!f) {
  651.     errorWindow("cannot create /etc/hosts: %s");
  652.     return INST_ERROR;
  653.     }
  654.  
  655.     logMessage("writing host information to %s", filename);
  656.  
  657.     fprintf(f, "127.0.0.1\t\tlocalhost localhost.localdomain\n");
  658.     if (netc->hostname && strlen(netc->hostname)) {
  659.     addrptr = (struct in_addr *) &intf->ip;
  660.     i = strlen(netc->hostname) - strlen(netc->domainname);
  661.     if (i > 1 && !strcmp(netc->hostname + i, netc->domainname)
  662.         && netc->hostname[i - 1] == '.') {
  663.         nickname = strdup(netc->hostname);
  664.         nickname[i - 1] = '\0';
  665.         fprintf(f, "%s\t\t%s %s\n", inet_ntoa(*addrptr),
  666.             netc->hostname, nickname);
  667.         free(nickname);
  668.     } else {
  669.         fprintf(f, "%s\t\t%s\n", inet_ntoa(*addrptr),
  670.             netc->hostname);
  671.     }
  672.  
  673.     sethostname(netc->hostname, strlen(netc->hostname));
  674.     }
  675.  
  676.     fclose(f);
  677.  
  678.     res_init();        /* reinit the resolver so DNS changes take affect */
  679.  
  680.     return 0;
  681. }
  682.  
  683. int writeResolvConf(char * prefix, struct netConfig * netc) {
  684.     char filename[100];
  685.     FILE * f;
  686.  
  687.     if (testing) return 1;
  688.  
  689.     if (!netc->domainname && !netc->nameserver[0]) {
  690.     logMessage("networking is not configured - not writing resolv.conf");
  691.     return 0;
  692.     }
  693.  
  694.     sprintf(filename, "%s/resolv.conf", prefix);
  695.  
  696.     f = fopen(filename, "w");
  697.     if (!f) {
  698.     errorWindow("cannot create resolv.conf: %s");
  699.     return INST_ERROR;
  700.     }
  701.  
  702.     logMessage("writing nameservices information to %s", filename);
  703.  
  704.     if (netc->domainname)
  705.     fprintf(f, "search %s\n", netc->domainname);
  706.  
  707.     if (netc->nameserver[0])
  708.     fprintf(f, "nameserver %s\n", netc->nameserver[0]);
  709.     
  710.     if (netc->nameserver[1])
  711.     fprintf(f, "nameserver %s\n", netc->nameserver[1]);
  712.     
  713.     if (netc->nameserver[2])
  714.     fprintf(f, "nameserver %s\n", netc->nameserver[2]);
  715.  
  716.     fclose(f);
  717.  
  718.     res_init();        /* reinit the resolver so DNS changes take affect */
  719.  
  720.     return 0;
  721. }
  722.  
  723. int writeNetInterfaceConfig(char * prefix, struct netInterface * intf) {
  724.     char filename[100];
  725.     FILE * f;
  726.     struct in_addr * addrptr;
  727.  
  728.     if (testing) return 0;
  729.  
  730.     if (!intf->isConfigured) {
  731.     logMessage("network interface is not configured - not creating "
  732.            "ifcfg-*");
  733.     return(0);
  734.     }
  735.  
  736.     sprintf(filename, "%s/ifcfg-%s", prefix, intf->dev);
  737.  
  738.     f = fopen(filename, "w");
  739.     if (!f) {
  740.     errorWindow("cannot create network device config file: %s");
  741.     return INST_ERROR;
  742.     }
  743.  
  744.     logMessage("writing network information to %s", filename);
  745.     
  746.     fprintf(f, "DEVICE=%s\n", intf->dev);
  747.  
  748.     if (intf->useBootp) 
  749.     fprintf(f, "BOOTPROTO=bootp\n");
  750.  
  751.     if (!strcmp(prefix, "/tmp") || !intf->useBootp) {
  752.     addrptr = (struct in_addr *) &intf->ip;
  753.     fprintf(f, "IPADDR=%s\n", inet_ntoa(*addrptr));
  754.  
  755.     addrptr = (struct in_addr *) &intf->netmask;
  756.     fprintf(f, "NETMASK=%s\n", inet_ntoa(*addrptr));
  757.  
  758.     addrptr = (struct in_addr *) &intf->network;
  759.     fprintf(f, "NETWORK=%s\n", inet_ntoa(*addrptr));
  760.  
  761.     addrptr = (struct in_addr *) &intf->broadcast;
  762.     fprintf(f, "BROADCAST=%s\n", inet_ntoa(*addrptr));
  763.     }
  764.  
  765.     fprintf(f, "ONBOOT=yes\n");
  766.  
  767.     fclose(f);
  768.  
  769.     return 0;
  770. }
  771.  
  772. int readNetInterfaceConfig(char * prefix, char * device, 
  773.                 struct netInterface * intf) {
  774.     FILE * f;
  775.     char * start, * end;
  776.     char buf[250];
  777.     int line = 0;
  778.  
  779.     intf->isConfigured = 0;
  780.  
  781.     if (testing) {
  782.     return 0;
  783.     }
  784.  
  785.     sprintf(buf, "%s/ifcfg-%s", prefix, device);
  786.  
  787.     f = fopen(buf, "r");
  788.     if (!f) {
  789.     if (errno != ENOENT) {
  790.         errorWindow("cannot open file: %s");
  791.         return INST_ERROR;
  792.     } else {
  793.         intf->ip = 0;
  794.         return 0;
  795.     }
  796.     }
  797.  
  798.     while (fgets(buf, sizeof(buf) - 1, f)) {
  799.     line++;
  800.  
  801.     start = buf;
  802.  
  803.     /* skipping leading spaces */
  804.     while (*start && isspace(*start)) start++;
  805.     if (!*start) continue;
  806.  
  807.     /* skip comments */
  808.     if (*start == '#') continue;
  809.  
  810.     /* cut off trailing spaces and \n */
  811.     end = start + strlen(start) - 2;
  812.     while (isspace(*end)) end--;
  813.     end++;
  814.     *end = '\0';    
  815.     end--;
  816.     
  817.     if (!strncmp("IPADDR=", start, 7)) {
  818.         start += 7;
  819.         inet_aton(start, (struct in_addr *) &intf->ip);
  820.     } else if (!strncmp("DEVICE=", start, 7)) {
  821.         start += 7;
  822.         strcpy(intf->dev, start);
  823.     } else if (!strncmp("BOOTPROTO=bootp", start, 15)) {
  824.         intf->useBootp = 1;
  825.     } else if (!strncmp("NETMASK=", start, 8)) {
  826.         start += 8;
  827.         inet_aton(start, (struct in_addr *) &intf->netmask);
  828.     } else if (!strncmp("NETWORK=", start, 8)) {
  829.         start += 8;
  830.         inet_aton(start, (struct in_addr *) &intf->network);
  831.         if (!strcmp(start, "255.255.255.255"))
  832.         intf->isPtp = 1;
  833.     } else if (!strncmp("BROADCAST=", start, 10)) {
  834.         start += 10;
  835.         inet_aton(start, (struct in_addr *) &intf->broadcast);
  836.     }
  837.     }
  838.  
  839.     fclose(f);
  840.  
  841.     intf->isConfigured = 1;
  842.  
  843.     return 0;
  844. }
  845.  
  846. int configureNetwork(struct netConfig * netc, 
  847.              struct netInterface * intf) {
  848.     struct netconfig_s n;
  849.     int top = 3;
  850.     newtComponent f, okay, cancel, answer;
  851.     int i;
  852.  
  853.     n.dnLabel = newtLabel(1, top    , "Domain name:");
  854.     n.hnLabel = newtLabel(1, top + 1, "Host name:");
  855.     n.nsLabels[1] = newtLabel(1, top + 2, "Secondary nameserver (IP):");
  856.     n.nsLabels[2] = newtLabel(1, top + 3, "Tertiary nameserver (IP):");
  857.  
  858.     n.dnEntry = newtEntry(28, top    , "", 20, &n.dn, NEWT_ENTRY_SCROLL);
  859.     n.hnEntry = newtEntry(28, top + 1, "", 20, &n.hn, NEWT_ENTRY_SCROLL);
  860.     n.nsEntrys[1] = newtEntry(28, top + 2, "", 20, &n.ns[1], NEWT_ENTRY_SCROLL);
  861.     n.nsEntrys[2] = newtEntry(28, top + 3, "", 20, &n.ns[2], NEWT_ENTRY_SCROLL);
  862.  
  863.     if (!strlen(netc->hostname) && !strlen(netc->domainname) && 
  864.         (testing || intf->isUp) && netc->nameserver[0]) {
  865.     guessHostname(intf, netc);
  866.  
  867.     if (netc->hostname[0] && netc->domainname[0] && !expert) {
  868.         logMessage("reverse name lookup worked; skipping hostname config");
  869.         return 0;
  870.     }
  871.     } 
  872.  
  873.     newtCenteredWindow(50, 15, "Configure Network");
  874.  
  875.     if (netc->hostname)
  876.     newtEntrySet(n.hnEntry, netc->hostname, 0);
  877.  
  878.     if (netc->domainname)
  879.     newtEntrySet(n.dnEntry, netc->domainname, 0);
  880.  
  881.     if (netc->nameserver[1])
  882.     newtEntrySet(n.nsEntrys[1], netc->nameserver[1], 0);
  883.     if (netc->nameserver[2])
  884.     newtEntrySet(n.nsEntrys[2], netc->nameserver[2], 0);
  885.  
  886.     newtComponentAddCallback(n.dnEntry, hnCallback, &n);
  887.  
  888.     f = newtForm(NULL, NULL, 0);
  889.     newtFormAddComponents(f, n.dnLabel, n.hnLabel, n.nsLabels[1], 
  890.               n.nsLabels[2], NULL);
  891.     newtFormAddComponents(f, n.dnEntry, n.hnEntry, n.nsEntrys[1], 
  892.               n.nsEntrys[2], NULL);
  893.  
  894.     okay = newtButton(11, 11, "Ok");
  895.     cancel = newtButton(30, 11, "Cancel");
  896.  
  897.     newtFormAddComponents(f, okay, cancel, NULL);
  898.  
  899.     answer = newtRunForm(f);
  900.  
  901.     strcpy(netc->hostname, n.hn);
  902.     strcpy(netc->domainname, n.dn);
  903.  
  904.     for (i = 1; i < 3; i++) {
  905.     if (netc->nameserver[i]) 
  906.         free(netc->nameserver[i]);
  907.     netc->nameserver[i] = *n.ns[i] ? strdup(n.ns[i]) : NULL;
  908.     }
  909.  
  910.     newtFormDestroy(f);
  911.     newtPopWindow();
  912.  
  913.     if (answer == cancel) return INST_CANCEL;
  914.  
  915.     netc->isConfigured = 1;
  916.  
  917.     return 0;
  918. }
  919.  
  920. int readNetConfig(char * prefix, struct netConfig * netc) {
  921.     FILE * f;
  922.     char * start, * end;
  923.     char buf[250];
  924.     int line = 0;
  925.  
  926.     if (testing) {
  927.     return 0;
  928.     }
  929.  
  930.     sprintf(buf, "%s/network", prefix);
  931.  
  932.     f = fopen(buf, "r");
  933.     if (!f) {
  934.     if (errno != ENOENT) {
  935.         errorWindow("cannot open file: %s");
  936.         return INST_ERROR;
  937.     } else {
  938.         netc->hostname[0] = '\0';
  939.         return 0;
  940.     }
  941.     }
  942.  
  943.     memset(netc, 0, sizeof(*netc));
  944.  
  945.     while (fgets(buf, sizeof(buf) - 1, f)) {
  946.     line++;
  947.  
  948.     start = buf;
  949.  
  950.     /* skipping leading spaces */
  951.     while (*start && isspace(*start)) start++;
  952.     if (!*start) continue;
  953.  
  954.     /* skip comments */
  955.     if (*start == '#') continue;
  956.  
  957.     /* cut off trailing spaces and \n */
  958.     end = start + strlen(start) - 2;
  959.     while (isspace(*end)) end--;
  960.     end++;
  961.     *end = '\0';    
  962.     end--;
  963.     
  964.     if (!strncmp("HOSTNAME=", start, 9)) {
  965.         start += 9;
  966.         strcpy(netc->hostname, start);
  967.     } else if (!strncmp("DOMAINNAME=", start, 11)) {
  968.         start += 11;
  969.         strcpy(netc->domainname, start);
  970.     } else if (!strncmp("GATEWAY=", start, 8)) {
  971.         start += 8;
  972.         strcpy(netc->defaultGateway, start);
  973.     } else if (!strncmp("NS1=", start, 4)) {
  974.         start += 4;
  975.         netc->nameserver[0] = strdup(start);
  976.     } else if (!strncmp("NS2=", start, 4)) {
  977.         start += 4;
  978.         netc->nameserver[1] = strdup(start);
  979.     } else if (!strncmp("NS3=", start, 4)) {
  980.         start += 4;
  981.         netc->nameserver[2] = strdup(start);
  982.     }
  983.     }
  984.  
  985.     fclose(f);
  986.  
  987.     netc->isConfigured = 1;
  988.  
  989.     return 0;
  990. }
  991.  
  992.  
  993. int bringUpNetworking(struct netInterface * intf, struct netConfig * netc,
  994.               struct driversLoaded ** dl) {
  995.     return doBringUpNetworking(intf, netc, dl, 0);
  996. }
  997.  
  998. #define BRINGUP_NET     1
  999. #define BRINGUP_CONF    2
  1000. #define BRINGUP_ROUTE    3
  1001. #define BRINGUP_DONE    4
  1002.  
  1003. static int doBringUpNetworking(struct netInterface * intf, 
  1004.                    struct netConfig * netc,
  1005.                    struct driversLoaded ** dl, int justConfig) {
  1006.     int where = BRINGUP_NET;
  1007.     int rc;
  1008.     char * device;
  1009.  
  1010.     if (kickstart) {
  1011.     if (intf->isConfigured && netc->isConfigured) return 0;
  1012.  
  1013.     /* justConfig must be zero, we have to actually do something for this
  1014.        to happen automatically */
  1015.  
  1016.     device = findAvailableNetDevice();
  1017.  
  1018.     if (!device) {
  1019.         if ((rc = loadDeviceDriver(DRIVER_NET, dl, 1))) { 
  1020.         newtWinMessage("Ethernet Probe", "Ok", 
  1021.             "The Ethernet probe failed "
  1022.             "to find a card on your system. Press <Enter> to manually "
  1023.             "configure one.");
  1024.  
  1025.         while (setupNetworkInterface(intf, netc, dl, 0)) ;
  1026.         }
  1027.  
  1028.         if (!(device = findAvailableNetDevice()))  {
  1029.         newtWinMessage("Network Failed", "Hang", "No networking "
  1030.                 "devices are available. You should never "
  1031.                 "have gotten this far.");
  1032.         }
  1033.     }
  1034.  
  1035.     while (doBootp(device, intf, netc)) {
  1036.         newtWinMessage("Bootp Failed", "Retry", "Bootp failed to find an "
  1037.         "IP address. Press <Enter> to retry.");
  1038.     }
  1039.  
  1040.     configureNetDevice(intf);
  1041.     addDefaultRoute(*netc);
  1042.  
  1043.     while (guessHostname(intf, netc)) {
  1044.         newtWinMessage("Hostname Lookup", "Retry", 
  1045.         "I cannot find by hostname via DNS. Press <Enter> to retry.");
  1046.      }
  1047.  
  1048.     return addDefaultRoute(*netc);
  1049.     }
  1050.  
  1051.     while (where != BRINGUP_DONE) {
  1052.     switch (where) {
  1053.       case BRINGUP_NET:
  1054.         rc = setupNetworkInterface(intf, netc, dl, justConfig);
  1055.         if (rc) return rc;
  1056.         where = BRINGUP_CONF;
  1057.         break;
  1058.  
  1059.       case BRINGUP_CONF:
  1060.         rc = configureNetwork(netc, intf);
  1061.         if (rc == INST_CANCEL)
  1062.         where = BRINGUP_NET;
  1063.         else if (rc)
  1064.         return INST_ERROR;
  1065.         else
  1066.         where = BRINGUP_ROUTE;
  1067.         break;
  1068.  
  1069.       case BRINGUP_ROUTE:
  1070.         if (justConfig)
  1071.         rc = 0;
  1072.         else
  1073.         rc = addDefaultRoute(*netc);
  1074.  
  1075.         if (rc) return rc;
  1076.         where = BRINGUP_DONE;
  1077.         break;
  1078.     }
  1079.     }
  1080.  
  1081.     /* write out the /etc/resolv.conf, as we'll need that to use name services
  1082.        properly */
  1083.     writeResolvConf("/etc", netc);
  1084.  
  1085.     return 0;
  1086. }
  1087.  
  1088. #define CHECKNET_CONFIG        1
  1089. #define CHECKNET_KEEP        2
  1090. #define CHECKNET_NONE        3
  1091. #define CHECKNET_NOBOOTP    4
  1092.  
  1093. static int checkNetConfigPanel(int isConfigured, int useBootp, int * choice) {
  1094.     newtComponent text, okay, cancel;
  1095.     newtComponent f, answer, yes, no, listbox;
  1096.     int which;
  1097.  
  1098.     if (isConfigured && kickstart) {
  1099.     *choice = CHECKNET_KEEP;
  1100.     return 0;
  1101.     } else if (isConfigured) {
  1102.     newtCenteredWindow(42, 13, "Network Configuration");
  1103.     text = newtTextbox(1, 1, 40, 2, NEWT_TEXTBOX_WRAP);
  1104.     newtTextboxSetText(text,
  1105.         "LAN networking has already been configured. Do you "
  1106.         "want to:");
  1107.  
  1108.     listbox = newtListbox(8, 4, 0, NEWT_LISTBOX_RETURNEXIT);
  1109.  
  1110.     if (useBootp) {
  1111.         newtListboxAddEntry(listbox, "Use bootp at startup", (void *) 1);
  1112.         newtListboxAddEntry(listbox, "Use the current IP information", 
  1113.                       (void *) 4);
  1114.         newtListboxAddEntry(listbox, "Reconfigure network now",
  1115.                       (void *) 2);
  1116.         newtListboxAddEntry(listbox, "Don't setup networking", (void *) 3);
  1117.     } else {
  1118.         newtListboxAddEntry(listbox, "Keep this setup", (void *) 1);
  1119.         newtListboxAddEntry(listbox, "Reconfigure network now",
  1120.                       (void *) 2);
  1121.         newtListboxAddEntry(listbox, "Don't setup networking", (void *) 3);
  1122.     }
  1123.  
  1124.     okay = newtButton(6, 9, "Ok");
  1125.     cancel = newtButton(23, 9, "Cancel");
  1126.  
  1127.     f = newtForm(NULL, NULL, 0);
  1128.  
  1129.     newtFormAddComponents(f, text, listbox, okay, cancel, NULL);
  1130.  
  1131.     answer = newtRunForm(f);
  1132.     if (answer == cancel) {
  1133.         newtPopWindow();
  1134.         newtFormDestroy(f);
  1135.  
  1136.         return INST_CANCEL;
  1137.     }
  1138.  
  1139.     which = (int) newtListboxGetCurrent(listbox);
  1140.  
  1141.     newtPopWindow();
  1142.     newtFormDestroy(f);
  1143.  
  1144.     if (which == 1)
  1145.         *choice = CHECKNET_KEEP;
  1146.     else if (which == 3)
  1147.         *choice = CHECKNET_NONE;
  1148.     else if (which == 4)
  1149.         *choice = CHECKNET_NOBOOTP;
  1150.     else
  1151.         *choice = CHECKNET_CONFIG;
  1152.     } else if (kickstart) {
  1153.     /* XXX this ought to be configurable */
  1154.     *choice = CHECKNET_NONE;
  1155.     } else {
  1156.     newtCenteredWindow(42, 10, "Network Configuration");
  1157.  
  1158.     text = newtTextbox(1, 1, 40, 3, NEWT_TEXTBOX_WRAP);
  1159.     newtTextboxSetText(text,
  1160.         "Do you want to configure LAN (not dialup) networking "
  1161.         "for your installed system?");
  1162.  
  1163.     yes = newtButton(3, 6, " Yes ");
  1164.     no = newtButton(16, 6, "  No  ");
  1165.     cancel = newtButton(29, 6, "Cancel");
  1166.  
  1167.     f = newtForm(NULL, NULL, 0);
  1168.     newtFormAddComponents(f, text, yes, no, cancel, NULL);
  1169.  
  1170.     answer = newtRunForm(f);
  1171.     if (answer == f) 
  1172.         answer = newtFormGetCurrent(f);
  1173.  
  1174.     newtPopWindow();
  1175.     newtFormDestroy(f);
  1176.  
  1177.     if (answer == yes) {
  1178.         *choice = CHECKNET_CONFIG;
  1179.     } else if (answer == cancel) {
  1180.         return INST_CANCEL;
  1181.     } else {
  1182.         *choice = CHECKNET_NONE;
  1183.     }
  1184.     }
  1185.  
  1186.     return 0;
  1187. }
  1188.  
  1189. int checkNetConfig(struct netInterface * intf, struct netConfig * netc,
  1190.            struct driversLoaded ** dl) {
  1191.     int choice, rc;
  1192.  
  1193.     /* this doesn't handle cancel very well as the dl makes it difficult :-( */
  1194.  
  1195.     do {
  1196.     rc = checkNetConfigPanel(netc->isConfigured && intf->isConfigured,
  1197.                  intf->useBootp, &choice);
  1198.     if (rc) return rc;
  1199.  
  1200.     switch (choice) {
  1201.       case CHECKNET_NOBOOTP:
  1202.         intf->useBootp = 0;
  1203.         rc = 0;
  1204.         break;
  1205.  
  1206.       case CHECKNET_CONFIG:
  1207.         rc = doBringUpNetworking(intf, netc, dl, 1);
  1208.         if (rc == INST_ERROR) return rc;
  1209.         break;
  1210.  
  1211.       case CHECKNET_NONE:
  1212.         intf->isConfigured = netc->isConfigured = 0;
  1213.         rc = 0;
  1214.         break;
  1215.     }
  1216.     } while (rc);
  1217.  
  1218.     return 0;
  1219. }
  1220.