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