Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  Automatic Configuration of IP -- use DHCP, BOOTP, RARP, or
0004  *  user-supplied information to configure own IP address and routes.
0005  *
0006  *  Copyright (C) 1996-1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
0007  *
0008  *  Derived from network configuration code in fs/nfs/nfsroot.c,
0009  *  originally Copyright (C) 1995, 1996 Gero Kuhlmann and me.
0010  *
0011  *  BOOTP rewritten to construct and analyse packets itself instead
0012  *  of misusing the IP layer. num_bugs_causing_wrong_arp_replies--;
0013  *                       -- MJ, December 1998
0014  *
0015  *  Fixed ip_auto_config_setup calling at startup in the new "Linker Magic"
0016  *  initialization scheme.
0017  *  - Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 08/11/1999
0018  *
0019  *  DHCP support added.  To users this looks like a whole separate
0020  *  protocol, but we know it's just a bag on the side of BOOTP.
0021  *      -- Chip Salzenberg <chip@valinux.com>, May 2000
0022  *
0023  *  Ported DHCP support from 2.2.16 to 2.4.0-test4
0024  *              -- Eric Biederman <ebiederman@lnxi.com>, 30 Aug 2000
0025  *
0026  *  Merged changes from 2.2.19 into 2.4.3
0027  *              -- Eric Biederman <ebiederman@lnxi.com>, 22 April Aug 2001
0028  *
0029  *  Multiple Nameservers in /proc/net/pnp
0030  *              --  Josef Siemes <jsiemes@web.de>, Aug 2002
0031  *
0032  *  NTP servers in /proc/net/ipconfig/ntp_servers
0033  *              --  Chris Novakovic <chris@chrisn.me.uk>, April 2018
0034  */
0035 
0036 #include <linux/types.h>
0037 #include <linux/string.h>
0038 #include <linux/kernel.h>
0039 #include <linux/jiffies.h>
0040 #include <linux/random.h>
0041 #include <linux/init.h>
0042 #include <linux/utsname.h>
0043 #include <linux/in.h>
0044 #include <linux/if.h>
0045 #include <linux/inet.h>
0046 #include <linux/inetdevice.h>
0047 #include <linux/netdevice.h>
0048 #include <linux/if_arp.h>
0049 #include <linux/skbuff.h>
0050 #include <linux/ip.h>
0051 #include <linux/socket.h>
0052 #include <linux/route.h>
0053 #include <linux/udp.h>
0054 #include <linux/proc_fs.h>
0055 #include <linux/seq_file.h>
0056 #include <linux/major.h>
0057 #include <linux/root_dev.h>
0058 #include <linux/delay.h>
0059 #include <linux/nfs_fs.h>
0060 #include <linux/slab.h>
0061 #include <linux/export.h>
0062 #include <net/net_namespace.h>
0063 #include <net/arp.h>
0064 #include <net/ip.h>
0065 #include <net/ipconfig.h>
0066 #include <net/route.h>
0067 
0068 #include <linux/uaccess.h>
0069 #include <net/checksum.h>
0070 #include <asm/processor.h>
0071 
0072 #if defined(CONFIG_IP_PNP_DHCP)
0073 #define IPCONFIG_DHCP
0074 #endif
0075 #if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_DHCP)
0076 #define IPCONFIG_BOOTP
0077 #endif
0078 #if defined(CONFIG_IP_PNP_RARP)
0079 #define IPCONFIG_RARP
0080 #endif
0081 #if defined(IPCONFIG_BOOTP) || defined(IPCONFIG_RARP)
0082 #define IPCONFIG_DYNAMIC
0083 #endif
0084 
0085 /* Define the friendly delay before and after opening net devices */
0086 #define CONF_POST_OPEN      10  /* After opening: 10 msecs */
0087 
0088 /* Define the timeout for waiting for a DHCP/BOOTP/RARP reply */
0089 #define CONF_OPEN_RETRIES   2   /* (Re)open devices twice */
0090 #define CONF_SEND_RETRIES   6   /* Send six requests per open */
0091 #define CONF_BASE_TIMEOUT   (HZ*2)  /* Initial timeout: 2 seconds */
0092 #define CONF_TIMEOUT_RANDOM (HZ)    /* Maximum amount of randomization */
0093 #define CONF_TIMEOUT_MULT   *7/4    /* Rate of timeout growth */
0094 #define CONF_TIMEOUT_MAX    (HZ*30) /* Maximum allowed timeout */
0095 #define CONF_NAMESERVERS_MAX   3       /* Maximum number of nameservers
0096                        - '3' from resolv.h */
0097 #define CONF_NTP_SERVERS_MAX   3    /* Maximum number of NTP servers */
0098 
0099 #define NONE cpu_to_be32(INADDR_NONE)
0100 #define ANY cpu_to_be32(INADDR_ANY)
0101 
0102 /* Wait for carrier timeout default in seconds */
0103 static unsigned int carrier_timeout = 120;
0104 
0105 /*
0106  * Public IP configuration
0107  */
0108 
0109 /* This is used by platforms which might be able to set the ipconfig
0110  * variables using firmware environment vars.  If this is set, it will
0111  * ignore such firmware variables.
0112  */
0113 int ic_set_manually __initdata = 0;     /* IPconfig parameters set manually */
0114 
0115 static int ic_enable __initdata;        /* IP config enabled? */
0116 
0117 /* Protocol choice */
0118 int ic_proto_enabled __initdata = 0
0119 #ifdef IPCONFIG_BOOTP
0120             | IC_BOOTP
0121 #endif
0122 #ifdef CONFIG_IP_PNP_DHCP
0123             | IC_USE_DHCP
0124 #endif
0125 #ifdef IPCONFIG_RARP
0126             | IC_RARP
0127 #endif
0128             ;
0129 
0130 static int ic_host_name_set __initdata; /* Host name set by us? */
0131 
0132 __be32 ic_myaddr = NONE;        /* My IP address */
0133 static __be32 ic_netmask = NONE;    /* Netmask for local subnet */
0134 __be32 ic_gateway = NONE;   /* Gateway IP address */
0135 
0136 #ifdef IPCONFIG_DYNAMIC
0137 static __be32 ic_addrservaddr = NONE;   /* IP Address of the IP addresses'server */
0138 #endif
0139 
0140 __be32 ic_servaddr = NONE;  /* Boot server IP address */
0141 
0142 __be32 root_server_addr = NONE; /* Address of NFS server */
0143 u8 root_server_path[256] = { 0, };  /* Path to mount as root */
0144 
0145 /* vendor class identifier */
0146 static char vendor_class_identifier[253] __initdata;
0147 
0148 #if defined(CONFIG_IP_PNP_DHCP)
0149 static char dhcp_client_identifier[253] __initdata;
0150 #endif
0151 
0152 /* Persistent data: */
0153 
0154 #ifdef IPCONFIG_DYNAMIC
0155 static int ic_proto_used;           /* Protocol used, if any */
0156 #else
0157 #define ic_proto_used 0
0158 #endif
0159 static __be32 ic_nameservers[CONF_NAMESERVERS_MAX]; /* DNS Server IP addresses */
0160 static __be32 ic_ntp_servers[CONF_NTP_SERVERS_MAX]; /* NTP server IP addresses */
0161 static u8 ic_domain[64];        /* DNS (not NIS) domain name */
0162 
0163 /*
0164  * Private state.
0165  */
0166 
0167 /* Name of user-selected boot device */
0168 static char user_dev_name[IFNAMSIZ] __initdata = { 0, };
0169 
0170 /* Protocols supported by available interfaces */
0171 static int ic_proto_have_if __initdata;
0172 
0173 /* MTU for boot device */
0174 static int ic_dev_mtu __initdata;
0175 
0176 #ifdef IPCONFIG_DYNAMIC
0177 static DEFINE_SPINLOCK(ic_recv_lock);
0178 static volatile int ic_got_reply __initdata;    /* Proto(s) that replied */
0179 #endif
0180 #ifdef IPCONFIG_DHCP
0181 static int ic_dhcp_msgtype __initdata;  /* DHCP msg type received */
0182 #endif
0183 
0184 
0185 /*
0186  *  Network devices
0187  */
0188 
0189 struct ic_device {
0190     struct ic_device *next;
0191     struct net_device *dev;
0192     unsigned short flags;
0193     short able;
0194     __be32 xid;
0195 };
0196 
0197 static struct ic_device *ic_first_dev __initdata;   /* List of open device */
0198 static struct ic_device *ic_dev __initdata;     /* Selected device */
0199 
0200 static bool __init ic_is_init_dev(struct net_device *dev)
0201 {
0202     if (dev->flags & IFF_LOOPBACK)
0203         return false;
0204     return user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :
0205         (!(dev->flags & IFF_LOOPBACK) &&
0206          (dev->flags & (IFF_POINTOPOINT|IFF_BROADCAST)) &&
0207          strncmp(dev->name, "dummy", 5));
0208 }
0209 
0210 static int __init ic_open_devs(void)
0211 {
0212     struct ic_device *d, **last;
0213     struct net_device *dev;
0214     unsigned short oflags;
0215     unsigned long start, next_msg;
0216 
0217     last = &ic_first_dev;
0218     rtnl_lock();
0219 
0220     /* bring loopback device up first */
0221     for_each_netdev(&init_net, dev) {
0222         if (!(dev->flags & IFF_LOOPBACK))
0223             continue;
0224         if (dev_change_flags(dev, dev->flags | IFF_UP, NULL) < 0)
0225             pr_err("IP-Config: Failed to open %s\n", dev->name);
0226     }
0227 
0228     for_each_netdev(&init_net, dev) {
0229         if (ic_is_init_dev(dev)) {
0230             int able = 0;
0231             if (dev->mtu >= 364)
0232                 able |= IC_BOOTP;
0233             else
0234                 pr_warn("DHCP/BOOTP: Ignoring device %s, MTU %d too small\n",
0235                     dev->name, dev->mtu);
0236             if (!(dev->flags & IFF_NOARP))
0237                 able |= IC_RARP;
0238             able &= ic_proto_enabled;
0239             if (ic_proto_enabled && !able)
0240                 continue;
0241             oflags = dev->flags;
0242             if (dev_change_flags(dev, oflags | IFF_UP, NULL) < 0) {
0243                 pr_err("IP-Config: Failed to open %s\n",
0244                        dev->name);
0245                 continue;
0246             }
0247             if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {
0248                 rtnl_unlock();
0249                 return -ENOMEM;
0250             }
0251             d->dev = dev;
0252             *last = d;
0253             last = &d->next;
0254             d->flags = oflags;
0255             d->able = able;
0256             if (able & IC_BOOTP)
0257                 get_random_bytes(&d->xid, sizeof(__be32));
0258             else
0259                 d->xid = 0;
0260             ic_proto_have_if |= able;
0261             pr_debug("IP-Config: %s UP (able=%d, xid=%08x)\n",
0262                  dev->name, able, d->xid);
0263         }
0264     }
0265     /* Devices with a complex topology like SFP ethernet interfaces needs
0266      * the rtnl_lock at init. The carrier wait-loop must therefore run
0267      * without holding it.
0268      */
0269     rtnl_unlock();
0270 
0271     /* no point in waiting if we could not bring up at least one device */
0272     if (!ic_first_dev)
0273         goto have_carrier;
0274 
0275     /* wait for a carrier on at least one device */
0276     start = jiffies;
0277     next_msg = start + msecs_to_jiffies(20000);
0278     while (time_before(jiffies, start +
0279                msecs_to_jiffies(carrier_timeout * 1000))) {
0280         int wait, elapsed;
0281 
0282         rtnl_lock();
0283         for_each_netdev(&init_net, dev)
0284             if (ic_is_init_dev(dev) && netif_carrier_ok(dev)) {
0285                 rtnl_unlock();
0286                 goto have_carrier;
0287             }
0288         rtnl_unlock();
0289 
0290         msleep(1);
0291 
0292         if (time_before(jiffies, next_msg))
0293             continue;
0294 
0295         elapsed = jiffies_to_msecs(jiffies - start);
0296         wait = (carrier_timeout * 1000 - elapsed + 500) / 1000;
0297         pr_info("Waiting up to %d more seconds for network.\n", wait);
0298         next_msg = jiffies + msecs_to_jiffies(20000);
0299     }
0300 have_carrier:
0301 
0302     *last = NULL;
0303 
0304     if (!ic_first_dev) {
0305         if (user_dev_name[0])
0306             pr_err("IP-Config: Device `%s' not found\n",
0307                    user_dev_name);
0308         else
0309             pr_err("IP-Config: No network devices available\n");
0310         return -ENODEV;
0311     }
0312     return 0;
0313 }
0314 
0315 /* Close all network interfaces except the one we've autoconfigured, and its
0316  * lowers, in case it's a stacked virtual interface.
0317  */
0318 static void __init ic_close_devs(void)
0319 {
0320     struct net_device *selected_dev = ic_dev ? ic_dev->dev : NULL;
0321     struct ic_device *d, *next;
0322     struct net_device *dev;
0323 
0324     rtnl_lock();
0325     next = ic_first_dev;
0326     while ((d = next)) {
0327         bool bring_down = (d != ic_dev);
0328         struct net_device *lower;
0329         struct list_head *iter;
0330 
0331         next = d->next;
0332         dev = d->dev;
0333 
0334         if (selected_dev) {
0335             netdev_for_each_lower_dev(selected_dev, lower, iter) {
0336                 if (dev == lower) {
0337                     bring_down = false;
0338                     break;
0339                 }
0340             }
0341         }
0342         if (bring_down) {
0343             pr_debug("IP-Config: Downing %s\n", dev->name);
0344             dev_change_flags(dev, d->flags, NULL);
0345         }
0346         kfree(d);
0347     }
0348     rtnl_unlock();
0349 }
0350 
0351 /*
0352  *  Interface to various network functions.
0353  */
0354 
0355 static inline void
0356 set_sockaddr(struct sockaddr_in *sin, __be32 addr, __be16 port)
0357 {
0358     sin->sin_family = AF_INET;
0359     sin->sin_addr.s_addr = addr;
0360     sin->sin_port = port;
0361 }
0362 
0363 /*
0364  *  Set up interface addresses and routes.
0365  */
0366 
0367 static int __init ic_setup_if(void)
0368 {
0369     struct ifreq ir;
0370     struct sockaddr_in *sin = (void *) &ir.ifr_ifru.ifru_addr;
0371     int err;
0372 
0373     memset(&ir, 0, sizeof(ir));
0374     strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->dev->name);
0375     set_sockaddr(sin, ic_myaddr, 0);
0376     if ((err = devinet_ioctl(&init_net, SIOCSIFADDR, &ir)) < 0) {
0377         pr_err("IP-Config: Unable to set interface address (%d)\n",
0378                err);
0379         return -1;
0380     }
0381     set_sockaddr(sin, ic_netmask, 0);
0382     if ((err = devinet_ioctl(&init_net, SIOCSIFNETMASK, &ir)) < 0) {
0383         pr_err("IP-Config: Unable to set interface netmask (%d)\n",
0384                err);
0385         return -1;
0386     }
0387     set_sockaddr(sin, ic_myaddr | ~ic_netmask, 0);
0388     if ((err = devinet_ioctl(&init_net, SIOCSIFBRDADDR, &ir)) < 0) {
0389         pr_err("IP-Config: Unable to set interface broadcast address (%d)\n",
0390                err);
0391         return -1;
0392     }
0393     /* Handle the case where we need non-standard MTU on the boot link (a network
0394      * using jumbo frames, for instance).  If we can't set the mtu, don't error
0395      * out, we'll try to muddle along.
0396      */
0397     if (ic_dev_mtu != 0) {
0398         rtnl_lock();
0399         if ((err = dev_set_mtu(ic_dev->dev, ic_dev_mtu)) < 0)
0400             pr_err("IP-Config: Unable to set interface mtu to %d (%d)\n",
0401                    ic_dev_mtu, err);
0402         rtnl_unlock();
0403     }
0404     return 0;
0405 }
0406 
0407 static int __init ic_setup_routes(void)
0408 {
0409     /* No need to setup device routes, only the default route... */
0410 
0411     if (ic_gateway != NONE) {
0412         struct rtentry rm;
0413         int err;
0414 
0415         memset(&rm, 0, sizeof(rm));
0416         if ((ic_gateway ^ ic_myaddr) & ic_netmask) {
0417             pr_err("IP-Config: Gateway not on directly connected network\n");
0418             return -1;
0419         }
0420         set_sockaddr((struct sockaddr_in *) &rm.rt_dst, 0, 0);
0421         set_sockaddr((struct sockaddr_in *) &rm.rt_genmask, 0, 0);
0422         set_sockaddr((struct sockaddr_in *) &rm.rt_gateway, ic_gateway, 0);
0423         rm.rt_flags = RTF_UP | RTF_GATEWAY;
0424         if ((err = ip_rt_ioctl(&init_net, SIOCADDRT, &rm)) < 0) {
0425             pr_err("IP-Config: Cannot add default route (%d)\n",
0426                    err);
0427             return -1;
0428         }
0429     }
0430 
0431     return 0;
0432 }
0433 
0434 /*
0435  *  Fill in default values for all missing parameters.
0436  */
0437 
0438 static int __init ic_defaults(void)
0439 {
0440     /*
0441      *  At this point we have no userspace running so need not
0442      *  claim locks on system_utsname
0443      */
0444 
0445     if (!ic_host_name_set)
0446         sprintf(init_utsname()->nodename, "%pI4", &ic_myaddr);
0447 
0448     if (root_server_addr == NONE)
0449         root_server_addr = ic_servaddr;
0450 
0451     if (ic_netmask == NONE) {
0452         if (IN_CLASSA(ntohl(ic_myaddr)))
0453             ic_netmask = htonl(IN_CLASSA_NET);
0454         else if (IN_CLASSB(ntohl(ic_myaddr)))
0455             ic_netmask = htonl(IN_CLASSB_NET);
0456         else if (IN_CLASSC(ntohl(ic_myaddr)))
0457             ic_netmask = htonl(IN_CLASSC_NET);
0458         else if (IN_CLASSE(ntohl(ic_myaddr)))
0459             ic_netmask = htonl(IN_CLASSE_NET);
0460         else {
0461             pr_err("IP-Config: Unable to guess netmask for address %pI4\n",
0462                    &ic_myaddr);
0463             return -1;
0464         }
0465         pr_notice("IP-Config: Guessing netmask %pI4\n",
0466               &ic_netmask);
0467     }
0468 
0469     return 0;
0470 }
0471 
0472 /*
0473  *  RARP support.
0474  */
0475 
0476 #ifdef IPCONFIG_RARP
0477 
0478 static int ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev);
0479 
0480 static struct packet_type rarp_packet_type __initdata = {
0481     .type = cpu_to_be16(ETH_P_RARP),
0482     .func = ic_rarp_recv,
0483 };
0484 
0485 static inline void __init ic_rarp_init(void)
0486 {
0487     dev_add_pack(&rarp_packet_type);
0488 }
0489 
0490 static inline void __init ic_rarp_cleanup(void)
0491 {
0492     dev_remove_pack(&rarp_packet_type);
0493 }
0494 
0495 /*
0496  *  Process received RARP packet.
0497  */
0498 static int __init
0499 ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
0500 {
0501     struct arphdr *rarp;
0502     unsigned char *rarp_ptr;
0503     __be32 sip, tip;
0504     unsigned char *tha;     /* t for "target" */
0505     struct ic_device *d;
0506 
0507     if (!net_eq(dev_net(dev), &init_net))
0508         goto drop;
0509 
0510     skb = skb_share_check(skb, GFP_ATOMIC);
0511     if (!skb)
0512         return NET_RX_DROP;
0513 
0514     if (!pskb_may_pull(skb, sizeof(struct arphdr)))
0515         goto drop;
0516 
0517     /* Basic sanity checks can be done without the lock.  */
0518     rarp = (struct arphdr *)skb_transport_header(skb);
0519 
0520     /* If this test doesn't pass, it's not IP, or we should
0521      * ignore it anyway.
0522      */
0523     if (rarp->ar_hln != dev->addr_len || dev->type != ntohs(rarp->ar_hrd))
0524         goto drop;
0525 
0526     /* If it's not a RARP reply, delete it. */
0527     if (rarp->ar_op != htons(ARPOP_RREPLY))
0528         goto drop;
0529 
0530     /* If it's not Ethernet, delete it. */
0531     if (rarp->ar_pro != htons(ETH_P_IP))
0532         goto drop;
0533 
0534     if (!pskb_may_pull(skb, arp_hdr_len(dev)))
0535         goto drop;
0536 
0537     /* OK, it is all there and looks valid, process... */
0538     rarp = (struct arphdr *)skb_transport_header(skb);
0539     rarp_ptr = (unsigned char *) (rarp + 1);
0540 
0541     /* One reply at a time, please. */
0542     spin_lock(&ic_recv_lock);
0543 
0544     /* If we already have a reply, just drop the packet */
0545     if (ic_got_reply)
0546         goto drop_unlock;
0547 
0548     /* Find the ic_device that the packet arrived on */
0549     d = ic_first_dev;
0550     while (d && d->dev != dev)
0551         d = d->next;
0552     if (!d)
0553         goto drop_unlock;   /* should never happen */
0554 
0555     /* Extract variable-width fields */
0556     rarp_ptr += dev->addr_len;
0557     memcpy(&sip, rarp_ptr, 4);
0558     rarp_ptr += 4;
0559     tha = rarp_ptr;
0560     rarp_ptr += dev->addr_len;
0561     memcpy(&tip, rarp_ptr, 4);
0562 
0563     /* Discard packets which are not meant for us. */
0564     if (memcmp(tha, dev->dev_addr, dev->addr_len))
0565         goto drop_unlock;
0566 
0567     /* Discard packets which are not from specified server. */
0568     if (ic_servaddr != NONE && ic_servaddr != sip)
0569         goto drop_unlock;
0570 
0571     /* We have a winner! */
0572     ic_dev = d;
0573     if (ic_myaddr == NONE)
0574         ic_myaddr = tip;
0575     ic_servaddr = sip;
0576     ic_addrservaddr = sip;
0577     ic_got_reply = IC_RARP;
0578 
0579 drop_unlock:
0580     /* Show's over.  Nothing to see here.  */
0581     spin_unlock(&ic_recv_lock);
0582 
0583 drop:
0584     /* Throw the packet out. */
0585     kfree_skb(skb);
0586     return 0;
0587 }
0588 
0589 
0590 /*
0591  *  Send RARP request packet over a single interface.
0592  */
0593 static void __init ic_rarp_send_if(struct ic_device *d)
0594 {
0595     struct net_device *dev = d->dev;
0596     arp_send(ARPOP_RREQUEST, ETH_P_RARP, 0, dev, 0, NULL,
0597          dev->dev_addr, dev->dev_addr);
0598 }
0599 #endif
0600 
0601 /*
0602  *  Predefine Nameservers
0603  */
0604 static inline void __init ic_nameservers_predef(void)
0605 {
0606     int i;
0607 
0608     for (i = 0; i < CONF_NAMESERVERS_MAX; i++)
0609         ic_nameservers[i] = NONE;
0610 }
0611 
0612 /* Predefine NTP servers */
0613 static inline void __init ic_ntp_servers_predef(void)
0614 {
0615     int i;
0616 
0617     for (i = 0; i < CONF_NTP_SERVERS_MAX; i++)
0618         ic_ntp_servers[i] = NONE;
0619 }
0620 
0621 /*
0622  *  DHCP/BOOTP support.
0623  */
0624 
0625 #ifdef IPCONFIG_BOOTP
0626 
0627 struct bootp_pkt {      /* BOOTP packet format */
0628     struct iphdr iph;   /* IP header */
0629     struct udphdr udph; /* UDP header */
0630     u8 op;          /* 1=request, 2=reply */
0631     u8 htype;       /* HW address type */
0632     u8 hlen;        /* HW address length */
0633     u8 hops;        /* Used only by gateways */
0634     __be32 xid;     /* Transaction ID */
0635     __be16 secs;        /* Seconds since we started */
0636     __be16 flags;       /* Just what it says */
0637     __be32 client_ip;       /* Client's IP address if known */
0638     __be32 your_ip;     /* Assigned IP address */
0639     __be32 server_ip;       /* (Next, e.g. NFS) Server's IP address */
0640     __be32 relay_ip;        /* IP address of BOOTP relay */
0641     u8 hw_addr[16];     /* Client's HW address */
0642     u8 serv_name[64];   /* Server host name */
0643     u8 boot_file[128];  /* Name of boot file */
0644     u8 exten[312];      /* DHCP options / BOOTP vendor extensions */
0645 };
0646 
0647 /* packet ops */
0648 #define BOOTP_REQUEST   1
0649 #define BOOTP_REPLY 2
0650 
0651 /* DHCP message types */
0652 #define DHCPDISCOVER    1
0653 #define DHCPOFFER   2
0654 #define DHCPREQUEST 3
0655 #define DHCPDECLINE 4
0656 #define DHCPACK     5
0657 #define DHCPNAK     6
0658 #define DHCPRELEASE 7
0659 #define DHCPINFORM  8
0660 
0661 static int ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev);
0662 
0663 static struct packet_type bootp_packet_type __initdata = {
0664     .type = cpu_to_be16(ETH_P_IP),
0665     .func = ic_bootp_recv,
0666 };
0667 
0668 /*
0669  *  Initialize DHCP/BOOTP extension fields in the request.
0670  */
0671 
0672 static const u8 ic_bootp_cookie[4] = { 99, 130, 83, 99 };
0673 
0674 #ifdef IPCONFIG_DHCP
0675 
0676 static void __init
0677 ic_dhcp_init_options(u8 *options, struct ic_device *d)
0678 {
0679     u8 mt = ((ic_servaddr == NONE)
0680          ? DHCPDISCOVER : DHCPREQUEST);
0681     u8 *e = options;
0682     int len;
0683 
0684     pr_debug("DHCP: Sending message type %d (%s)\n", mt, d->dev->name);
0685 
0686     memcpy(e, ic_bootp_cookie, 4);  /* RFC1048 Magic Cookie */
0687     e += 4;
0688 
0689     *e++ = 53;      /* DHCP message type */
0690     *e++ = 1;
0691     *e++ = mt;
0692 
0693     if (mt == DHCPREQUEST) {
0694         *e++ = 54;  /* Server ID (IP address) */
0695         *e++ = 4;
0696         memcpy(e, &ic_servaddr, 4);
0697         e += 4;
0698 
0699         *e++ = 50;  /* Requested IP address */
0700         *e++ = 4;
0701         memcpy(e, &ic_myaddr, 4);
0702         e += 4;
0703     }
0704 
0705     /* always? */
0706     {
0707         static const u8 ic_req_params[] = {
0708             1,  /* Subnet mask */
0709             3,  /* Default gateway */
0710             6,  /* DNS server */
0711             12, /* Host name */
0712             15, /* Domain name */
0713             17, /* Boot path */
0714             26, /* MTU */
0715             40, /* NIS domain name */
0716             42, /* NTP servers */
0717         };
0718 
0719         *e++ = 55;  /* Parameter request list */
0720         *e++ = sizeof(ic_req_params);
0721         memcpy(e, ic_req_params, sizeof(ic_req_params));
0722         e += sizeof(ic_req_params);
0723 
0724         if (ic_host_name_set) {
0725             *e++ = 12;  /* host-name */
0726             len = strlen(utsname()->nodename);
0727             *e++ = len;
0728             memcpy(e, utsname()->nodename, len);
0729             e += len;
0730         }
0731         if (*vendor_class_identifier) {
0732             pr_info("DHCP: sending class identifier \"%s\"\n",
0733                 vendor_class_identifier);
0734             *e++ = 60;  /* Class-identifier */
0735             len = strlen(vendor_class_identifier);
0736             *e++ = len;
0737             memcpy(e, vendor_class_identifier, len);
0738             e += len;
0739         }
0740         len = strlen(dhcp_client_identifier + 1);
0741         /* the minimum length of identifier is 2, include 1 byte type,
0742          * and can not be larger than the length of options
0743          */
0744         if (len >= 1 && len < 312 - (e - options) - 1) {
0745             *e++ = 61;
0746             *e++ = len + 1;
0747             memcpy(e, dhcp_client_identifier, len + 1);
0748             e += len + 1;
0749         }
0750     }
0751 
0752     *e++ = 255; /* End of the list */
0753 }
0754 
0755 #endif /* IPCONFIG_DHCP */
0756 
0757 static void __init ic_bootp_init_ext(u8 *e)
0758 {
0759     memcpy(e, ic_bootp_cookie, 4);  /* RFC1048 Magic Cookie */
0760     e += 4;
0761     *e++ = 1;       /* Subnet mask request */
0762     *e++ = 4;
0763     e += 4;
0764     *e++ = 3;       /* Default gateway request */
0765     *e++ = 4;
0766     e += 4;
0767 #if CONF_NAMESERVERS_MAX > 0
0768     *e++ = 6;       /* (DNS) name server request */
0769     *e++ = 4 * CONF_NAMESERVERS_MAX;
0770     e += 4 * CONF_NAMESERVERS_MAX;
0771 #endif
0772     *e++ = 12;      /* Host name request */
0773     *e++ = 32;
0774     e += 32;
0775     *e++ = 40;      /* NIS Domain name request */
0776     *e++ = 32;
0777     e += 32;
0778     *e++ = 17;      /* Boot path */
0779     *e++ = 40;
0780     e += 40;
0781 
0782     *e++ = 57;      /* set extension buffer size for reply */
0783     *e++ = 2;
0784     *e++ = 1;       /* 128+236+8+20+14, see dhcpd sources */
0785     *e++ = 150;
0786 
0787     *e++ = 255;     /* End of the list */
0788 }
0789 
0790 
0791 /*
0792  *  Initialize the DHCP/BOOTP mechanism.
0793  */
0794 static inline void __init ic_bootp_init(void)
0795 {
0796     /* Re-initialise all name servers and NTP servers to NONE, in case any
0797      * were set via the "ip=" or "nfsaddrs=" kernel command line parameters:
0798      * any IP addresses specified there will already have been decoded but
0799      * are no longer needed
0800      */
0801     ic_nameservers_predef();
0802     ic_ntp_servers_predef();
0803 
0804     dev_add_pack(&bootp_packet_type);
0805 }
0806 
0807 
0808 /*
0809  *  DHCP/BOOTP cleanup.
0810  */
0811 static inline void __init ic_bootp_cleanup(void)
0812 {
0813     dev_remove_pack(&bootp_packet_type);
0814 }
0815 
0816 
0817 /*
0818  *  Send DHCP/BOOTP request to single interface.
0819  */
0820 static void __init ic_bootp_send_if(struct ic_device *d, unsigned long jiffies_diff)
0821 {
0822     struct net_device *dev = d->dev;
0823     struct sk_buff *skb;
0824     struct bootp_pkt *b;
0825     struct iphdr *h;
0826     int hlen = LL_RESERVED_SPACE(dev);
0827     int tlen = dev->needed_tailroom;
0828 
0829     /* Allocate packet */
0830     skb = alloc_skb(sizeof(struct bootp_pkt) + hlen + tlen + 15,
0831             GFP_KERNEL);
0832     if (!skb)
0833         return;
0834     skb_reserve(skb, hlen);
0835     b = skb_put_zero(skb, sizeof(struct bootp_pkt));
0836 
0837     /* Construct IP header */
0838     skb_reset_network_header(skb);
0839     h = ip_hdr(skb);
0840     h->version = 4;
0841     h->ihl = 5;
0842     h->tot_len = htons(sizeof(struct bootp_pkt));
0843     h->frag_off = htons(IP_DF);
0844     h->ttl = 64;
0845     h->protocol = IPPROTO_UDP;
0846     h->daddr = htonl(INADDR_BROADCAST);
0847     h->check = ip_fast_csum((unsigned char *) h, h->ihl);
0848 
0849     /* Construct UDP header */
0850     b->udph.source = htons(68);
0851     b->udph.dest = htons(67);
0852     b->udph.len = htons(sizeof(struct bootp_pkt) - sizeof(struct iphdr));
0853     /* UDP checksum not calculated -- explicitly allowed in BOOTP RFC */
0854 
0855     /* Construct DHCP/BOOTP header */
0856     b->op = BOOTP_REQUEST;
0857     if (dev->type < 256) /* check for false types */
0858         b->htype = dev->type;
0859     else if (dev->type == ARPHRD_FDDI)
0860         b->htype = ARPHRD_ETHER;
0861     else {
0862         pr_warn("Unknown ARP type 0x%04x for device %s\n", dev->type,
0863             dev->name);
0864         b->htype = dev->type; /* can cause undefined behavior */
0865     }
0866 
0867     /* server_ip and your_ip address are both already zero per RFC2131 */
0868     b->hlen = dev->addr_len;
0869     memcpy(b->hw_addr, dev->dev_addr, dev->addr_len);
0870     b->secs = htons(jiffies_diff / HZ);
0871     b->xid = d->xid;
0872 
0873     /* add DHCP options or BOOTP extensions */
0874 #ifdef IPCONFIG_DHCP
0875     if (ic_proto_enabled & IC_USE_DHCP)
0876         ic_dhcp_init_options(b->exten, d);
0877     else
0878 #endif
0879         ic_bootp_init_ext(b->exten);
0880 
0881     /* Chain packet down the line... */
0882     skb->dev = dev;
0883     skb->protocol = htons(ETH_P_IP);
0884     if (dev_hard_header(skb, dev, ntohs(skb->protocol),
0885                 dev->broadcast, dev->dev_addr, skb->len) < 0) {
0886         kfree_skb(skb);
0887         printk("E");
0888         return;
0889     }
0890 
0891     if (dev_queue_xmit(skb) < 0)
0892         printk("E");
0893 }
0894 
0895 
0896 /*
0897  *  Copy BOOTP-supplied string
0898  */
0899 static int __init ic_bootp_string(char *dest, char *src, int len, int max)
0900 {
0901     if (!len)
0902         return 0;
0903     if (len > max-1)
0904         len = max-1;
0905     memcpy(dest, src, len);
0906     dest[len] = '\0';
0907     return 1;
0908 }
0909 
0910 
0911 /*
0912  *  Process BOOTP extensions.
0913  */
0914 static void __init ic_do_bootp_ext(u8 *ext)
0915 {
0916     u8 servers;
0917     int i;
0918     __be16 mtu;
0919 
0920     u8 *c;
0921 
0922     pr_debug("DHCP/BOOTP: Got extension %d:", *ext);
0923     for (c=ext+2; c<ext+2+ext[1]; c++)
0924         pr_debug(" %02x", *c);
0925     pr_debug("\n");
0926 
0927     switch (*ext++) {
0928     case 1:     /* Subnet mask */
0929         if (ic_netmask == NONE)
0930             memcpy(&ic_netmask, ext+1, 4);
0931         break;
0932     case 3:     /* Default gateway */
0933         if (ic_gateway == NONE)
0934             memcpy(&ic_gateway, ext+1, 4);
0935         break;
0936     case 6:     /* DNS server */
0937         servers= *ext/4;
0938         if (servers > CONF_NAMESERVERS_MAX)
0939             servers = CONF_NAMESERVERS_MAX;
0940         for (i = 0; i < servers; i++) {
0941             if (ic_nameservers[i] == NONE)
0942                 memcpy(&ic_nameservers[i], ext+1+4*i, 4);
0943         }
0944         break;
0945     case 12:    /* Host name */
0946         if (!ic_host_name_set) {
0947             ic_bootp_string(utsname()->nodename, ext+1, *ext,
0948                     __NEW_UTS_LEN);
0949             ic_host_name_set = 1;
0950         }
0951         break;
0952     case 15:    /* Domain name (DNS) */
0953         if (!ic_domain[0])
0954             ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
0955         break;
0956     case 17:    /* Root path */
0957         if (!root_server_path[0])
0958             ic_bootp_string(root_server_path, ext+1, *ext,
0959                     sizeof(root_server_path));
0960         break;
0961     case 26:    /* Interface MTU */
0962         memcpy(&mtu, ext+1, sizeof(mtu));
0963         ic_dev_mtu = ntohs(mtu);
0964         break;
0965     case 40:    /* NIS Domain name (_not_ DNS) */
0966         ic_bootp_string(utsname()->domainname, ext+1, *ext,
0967                 __NEW_UTS_LEN);
0968         break;
0969     case 42:    /* NTP servers */
0970         servers = *ext / 4;
0971         if (servers > CONF_NTP_SERVERS_MAX)
0972             servers = CONF_NTP_SERVERS_MAX;
0973         for (i = 0; i < servers; i++) {
0974             if (ic_ntp_servers[i] == NONE)
0975                 memcpy(&ic_ntp_servers[i], ext+1+4*i, 4);
0976         }
0977         break;
0978     }
0979 }
0980 
0981 
0982 /*
0983  *  Receive BOOTP reply.
0984  */
0985 static int __init ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
0986 {
0987     struct bootp_pkt *b;
0988     struct iphdr *h;
0989     struct ic_device *d;
0990     int len, ext_len;
0991 
0992     if (!net_eq(dev_net(dev), &init_net))
0993         goto drop;
0994 
0995     /* Perform verifications before taking the lock.  */
0996     if (skb->pkt_type == PACKET_OTHERHOST)
0997         goto drop;
0998 
0999     skb = skb_share_check(skb, GFP_ATOMIC);
1000     if (!skb)
1001         return NET_RX_DROP;
1002 
1003     if (!pskb_may_pull(skb,
1004                sizeof(struct iphdr) +
1005                sizeof(struct udphdr)))
1006         goto drop;
1007 
1008     b = (struct bootp_pkt *)skb_network_header(skb);
1009     h = &b->iph;
1010 
1011     if (h->ihl != 5 || h->version != 4 || h->protocol != IPPROTO_UDP)
1012         goto drop;
1013 
1014     /* Fragments are not supported */
1015     if (ip_is_fragment(h)) {
1016         net_err_ratelimited("DHCP/BOOTP: Ignoring fragmented reply\n");
1017         goto drop;
1018     }
1019 
1020     if (skb->len < ntohs(h->tot_len))
1021         goto drop;
1022 
1023     if (ip_fast_csum((char *) h, h->ihl))
1024         goto drop;
1025 
1026     if (b->udph.source != htons(67) || b->udph.dest != htons(68))
1027         goto drop;
1028 
1029     if (ntohs(h->tot_len) < ntohs(b->udph.len) + sizeof(struct iphdr))
1030         goto drop;
1031 
1032     len = ntohs(b->udph.len) - sizeof(struct udphdr);
1033     ext_len = len - (sizeof(*b) -
1034              sizeof(struct iphdr) -
1035              sizeof(struct udphdr) -
1036              sizeof(b->exten));
1037     if (ext_len < 0)
1038         goto drop;
1039 
1040     /* Ok the front looks good, make sure we can get at the rest.  */
1041     if (!pskb_may_pull(skb, skb->len))
1042         goto drop;
1043 
1044     b = (struct bootp_pkt *)skb_network_header(skb);
1045     h = &b->iph;
1046 
1047     /* One reply at a time, please. */
1048     spin_lock(&ic_recv_lock);
1049 
1050     /* If we already have a reply, just drop the packet */
1051     if (ic_got_reply)
1052         goto drop_unlock;
1053 
1054     /* Find the ic_device that the packet arrived on */
1055     d = ic_first_dev;
1056     while (d && d->dev != dev)
1057         d = d->next;
1058     if (!d)
1059         goto drop_unlock;  /* should never happen */
1060 
1061     /* Is it a reply to our BOOTP request? */
1062     if (b->op != BOOTP_REPLY ||
1063         b->xid != d->xid) {
1064         net_err_ratelimited("DHCP/BOOTP: Reply not for us on %s, op[%x] xid[%x]\n",
1065                     d->dev->name, b->op, b->xid);
1066         goto drop_unlock;
1067     }
1068 
1069     /* Parse extensions */
1070     if (ext_len >= 4 &&
1071         !memcmp(b->exten, ic_bootp_cookie, 4)) { /* Check magic cookie */
1072         u8 *end = (u8 *) b + ntohs(b->iph.tot_len);
1073         u8 *ext;
1074 
1075 #ifdef IPCONFIG_DHCP
1076         if (ic_proto_enabled & IC_USE_DHCP) {
1077             __be32 server_id = NONE;
1078             int mt = 0;
1079 
1080             ext = &b->exten[4];
1081             while (ext < end && *ext != 0xff) {
1082                 u8 *opt = ext++;
1083                 if (*opt == 0)  /* Padding */
1084                     continue;
1085                 ext += *ext + 1;
1086                 if (ext >= end)
1087                     break;
1088                 switch (*opt) {
1089                 case 53:    /* Message type */
1090                     if (opt[1])
1091                         mt = opt[2];
1092                     break;
1093                 case 54:    /* Server ID (IP address) */
1094                     if (opt[1] >= 4)
1095                         memcpy(&server_id, opt + 2, 4);
1096                     break;
1097                 }
1098             }
1099 
1100             pr_debug("DHCP: Got message type %d (%s)\n", mt, d->dev->name);
1101 
1102             switch (mt) {
1103             case DHCPOFFER:
1104                 /* While in the process of accepting one offer,
1105                  * ignore all others.
1106                  */
1107                 if (ic_myaddr != NONE)
1108                     goto drop_unlock;
1109 
1110                 /* Let's accept that offer. */
1111                 ic_myaddr = b->your_ip;
1112                 ic_servaddr = server_id;
1113                 pr_debug("DHCP: Offered address %pI4 by server %pI4\n",
1114                      &ic_myaddr, &b->iph.saddr);
1115                 /* The DHCP indicated server address takes
1116                  * precedence over the bootp header one if
1117                  * they are different.
1118                  */
1119                 if ((server_id != NONE) &&
1120                     (b->server_ip != server_id))
1121                     b->server_ip = ic_servaddr;
1122                 break;
1123 
1124             case DHCPACK:
1125                 if (memcmp(dev->dev_addr, b->hw_addr, dev->addr_len) != 0)
1126                     goto drop_unlock;
1127 
1128                 /* Yeah! */
1129                 break;
1130 
1131             default:
1132                 /* Urque.  Forget it*/
1133                 ic_myaddr = NONE;
1134                 ic_servaddr = NONE;
1135                 goto drop_unlock;
1136             }
1137 
1138             ic_dhcp_msgtype = mt;
1139 
1140         }
1141 #endif /* IPCONFIG_DHCP */
1142 
1143         ext = &b->exten[4];
1144         while (ext < end && *ext != 0xff) {
1145             u8 *opt = ext++;
1146             if (*opt == 0)  /* Padding */
1147                 continue;
1148             ext += *ext + 1;
1149             if (ext < end)
1150                 ic_do_bootp_ext(opt);
1151         }
1152     }
1153 
1154     /* We have a winner! */
1155     ic_dev = d;
1156     ic_myaddr = b->your_ip;
1157     ic_servaddr = b->server_ip;
1158     ic_addrservaddr = b->iph.saddr;
1159     if (ic_gateway == NONE && b->relay_ip)
1160         ic_gateway = b->relay_ip;
1161     if (ic_nameservers[0] == NONE)
1162         ic_nameservers[0] = ic_servaddr;
1163     ic_got_reply = IC_BOOTP;
1164 
1165 drop_unlock:
1166     /* Show's over.  Nothing to see here.  */
1167     spin_unlock(&ic_recv_lock);
1168 
1169 drop:
1170     /* Throw the packet out. */
1171     kfree_skb(skb);
1172 
1173     return 0;
1174 }
1175 
1176 
1177 #endif
1178 
1179 
1180 /*
1181  *  Dynamic IP configuration -- DHCP, BOOTP, RARP.
1182  */
1183 
1184 #ifdef IPCONFIG_DYNAMIC
1185 
1186 static int __init ic_dynamic(void)
1187 {
1188     int retries;
1189     struct ic_device *d;
1190     unsigned long start_jiffies, timeout, jiff;
1191     int do_bootp = ic_proto_have_if & IC_BOOTP;
1192     int do_rarp = ic_proto_have_if & IC_RARP;
1193 
1194     /*
1195      * If none of DHCP/BOOTP/RARP was selected, return with an error.
1196      * This routine gets only called when some pieces of information
1197      * are missing, and without DHCP/BOOTP/RARP we are unable to get it.
1198      */
1199     if (!ic_proto_enabled) {
1200         pr_err("IP-Config: Incomplete network configuration information\n");
1201         return -1;
1202     }
1203 
1204 #ifdef IPCONFIG_BOOTP
1205     if ((ic_proto_enabled ^ ic_proto_have_if) & IC_BOOTP)
1206         pr_err("DHCP/BOOTP: No suitable device found\n");
1207 #endif
1208 #ifdef IPCONFIG_RARP
1209     if ((ic_proto_enabled ^ ic_proto_have_if) & IC_RARP)
1210         pr_err("RARP: No suitable device found\n");
1211 #endif
1212 
1213     if (!ic_proto_have_if)
1214         /* Error message already printed */
1215         return -1;
1216 
1217     /*
1218      * Setup protocols
1219      */
1220 #ifdef IPCONFIG_BOOTP
1221     if (do_bootp)
1222         ic_bootp_init();
1223 #endif
1224 #ifdef IPCONFIG_RARP
1225     if (do_rarp)
1226         ic_rarp_init();
1227 #endif
1228 
1229     /*
1230      * Send requests and wait, until we get an answer. This loop
1231      * seems to be a terrible waste of CPU time, but actually there is
1232      * only one process running at all, so we don't need to use any
1233      * scheduler functions.
1234      * [Actually we could now, but the nothing else running note still
1235      *  applies.. - AC]
1236      */
1237     pr_notice("Sending %s%s%s requests .",
1238           do_bootp
1239           ? ((ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP") : "",
1240           (do_bootp && do_rarp) ? " and " : "",
1241           do_rarp ? "RARP" : "");
1242 
1243     start_jiffies = jiffies;
1244     d = ic_first_dev;
1245     retries = CONF_SEND_RETRIES;
1246     get_random_bytes(&timeout, sizeof(timeout));
1247     timeout = CONF_BASE_TIMEOUT + (timeout % (unsigned int) CONF_TIMEOUT_RANDOM);
1248     for (;;) {
1249 #ifdef IPCONFIG_BOOTP
1250         if (do_bootp && (d->able & IC_BOOTP))
1251             ic_bootp_send_if(d, jiffies - start_jiffies);
1252 #endif
1253 #ifdef IPCONFIG_RARP
1254         if (do_rarp && (d->able & IC_RARP))
1255             ic_rarp_send_if(d);
1256 #endif
1257 
1258         if (!d->next) {
1259             jiff = jiffies + timeout;
1260             while (time_before(jiffies, jiff) && !ic_got_reply)
1261                 schedule_timeout_uninterruptible(1);
1262         }
1263 #ifdef IPCONFIG_DHCP
1264         /* DHCP isn't done until we get a DHCPACK. */
1265         if ((ic_got_reply & IC_BOOTP) &&
1266             (ic_proto_enabled & IC_USE_DHCP) &&
1267             ic_dhcp_msgtype != DHCPACK) {
1268             ic_got_reply = 0;
1269             /* continue on device that got the reply */
1270             d = ic_dev;
1271             pr_cont(",");
1272             continue;
1273         }
1274 #endif /* IPCONFIG_DHCP */
1275 
1276         if (ic_got_reply) {
1277             pr_cont(" OK\n");
1278             break;
1279         }
1280 
1281         if ((d = d->next))
1282             continue;
1283 
1284         if (! --retries) {
1285             pr_cont(" timed out!\n");
1286             break;
1287         }
1288 
1289         d = ic_first_dev;
1290 
1291         timeout = timeout CONF_TIMEOUT_MULT;
1292         if (timeout > CONF_TIMEOUT_MAX)
1293             timeout = CONF_TIMEOUT_MAX;
1294 
1295         pr_cont(".");
1296     }
1297 
1298 #ifdef IPCONFIG_BOOTP
1299     if (do_bootp)
1300         ic_bootp_cleanup();
1301 #endif
1302 #ifdef IPCONFIG_RARP
1303     if (do_rarp)
1304         ic_rarp_cleanup();
1305 #endif
1306 
1307     if (!ic_got_reply) {
1308         ic_myaddr = NONE;
1309         return -1;
1310     }
1311 
1312     pr_info("IP-Config: Got %s answer from %pI4, my address is %pI4\n",
1313         ((ic_got_reply & IC_RARP) ? "RARP"
1314         : (ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP"),
1315         &ic_addrservaddr, &ic_myaddr);
1316 
1317     return 0;
1318 }
1319 
1320 #endif /* IPCONFIG_DYNAMIC */
1321 
1322 #ifdef CONFIG_PROC_FS
1323 /* proc_dir_entry for /proc/net/ipconfig */
1324 static struct proc_dir_entry *ipconfig_dir;
1325 
1326 /* Name servers: */
1327 static int pnp_seq_show(struct seq_file *seq, void *v)
1328 {
1329     int i;
1330 
1331     if (ic_proto_used & IC_PROTO)
1332         seq_printf(seq, "#PROTO: %s\n",
1333                (ic_proto_used & IC_RARP) ? "RARP"
1334                : (ic_proto_used & IC_USE_DHCP) ? "DHCP" : "BOOTP");
1335     else
1336         seq_puts(seq, "#MANUAL\n");
1337 
1338     if (ic_domain[0])
1339         seq_printf(seq,
1340                "domain %s\n", ic_domain);
1341     for (i = 0; i < CONF_NAMESERVERS_MAX; i++) {
1342         if (ic_nameservers[i] != NONE)
1343             seq_printf(seq, "nameserver %pI4\n",
1344                    &ic_nameservers[i]);
1345     }
1346     if (ic_servaddr != NONE)
1347         seq_printf(seq, "bootserver %pI4\n",
1348                &ic_servaddr);
1349     return 0;
1350 }
1351 
1352 /* Create the /proc/net/ipconfig directory */
1353 static int __init ipconfig_proc_net_init(void)
1354 {
1355     ipconfig_dir = proc_net_mkdir(&init_net, "ipconfig", init_net.proc_net);
1356     if (!ipconfig_dir)
1357         return -ENOMEM;
1358 
1359     return 0;
1360 }
1361 
1362 /* Create a new file under /proc/net/ipconfig */
1363 static int ipconfig_proc_net_create(const char *name,
1364                     const struct proc_ops *proc_ops)
1365 {
1366     char *pname;
1367     struct proc_dir_entry *p;
1368 
1369     if (!ipconfig_dir)
1370         return -ENOMEM;
1371 
1372     pname = kasprintf(GFP_KERNEL, "%s%s", "ipconfig/", name);
1373     if (!pname)
1374         return -ENOMEM;
1375 
1376     p = proc_create(pname, 0444, init_net.proc_net, proc_ops);
1377     kfree(pname);
1378     if (!p)
1379         return -ENOMEM;
1380 
1381     return 0;
1382 }
1383 
1384 /* Write NTP server IP addresses to /proc/net/ipconfig/ntp_servers */
1385 static int ntp_servers_show(struct seq_file *seq, void *v)
1386 {
1387     int i;
1388 
1389     for (i = 0; i < CONF_NTP_SERVERS_MAX; i++) {
1390         if (ic_ntp_servers[i] != NONE)
1391             seq_printf(seq, "%pI4\n", &ic_ntp_servers[i]);
1392     }
1393     return 0;
1394 }
1395 DEFINE_PROC_SHOW_ATTRIBUTE(ntp_servers);
1396 #endif /* CONFIG_PROC_FS */
1397 
1398 /*
1399  *  Extract IP address from the parameter string if needed. Note that we
1400  *  need to have root_server_addr set _before_ IPConfig gets called as it
1401  *  can override it.
1402  */
1403 __be32 __init root_nfs_parse_addr(char *name)
1404 {
1405     __be32 addr;
1406     int octets = 0;
1407     char *cp, *cq;
1408 
1409     cp = cq = name;
1410     while (octets < 4) {
1411         while (*cp >= '0' && *cp <= '9')
1412             cp++;
1413         if (cp == cq || cp - cq > 3)
1414             break;
1415         if (*cp == '.' || octets == 3)
1416             octets++;
1417         if (octets < 4)
1418             cp++;
1419         cq = cp;
1420     }
1421     if (octets == 4 && (*cp == ':' || *cp == '\0')) {
1422         if (*cp == ':')
1423             *cp++ = '\0';
1424         addr = in_aton(name);
1425         memmove(name, cp, strlen(cp) + 1);
1426     } else
1427         addr = NONE;
1428 
1429     return addr;
1430 }
1431 
1432 #define DEVICE_WAIT_MAX     12 /* 12 seconds */
1433 
1434 static int __init wait_for_devices(void)
1435 {
1436     int i;
1437     bool try_init_devs = true;
1438 
1439     for (i = 0; i < DEVICE_WAIT_MAX; i++) {
1440         struct net_device *dev;
1441         int found = 0;
1442 
1443         /* make sure deferred device probes are finished */
1444         wait_for_device_probe();
1445 
1446         rtnl_lock();
1447         for_each_netdev(&init_net, dev) {
1448             if (ic_is_init_dev(dev)) {
1449                 found = 1;
1450                 break;
1451             }
1452         }
1453         rtnl_unlock();
1454         if (found)
1455             return 0;
1456         if (try_init_devs &&
1457             (ROOT_DEV == Root_NFS || ROOT_DEV == Root_CIFS)) {
1458             try_init_devs = false;
1459             wait_for_init_devices_probe();
1460         }
1461         ssleep(1);
1462     }
1463     return -ENODEV;
1464 }
1465 
1466 /*
1467  *  IP Autoconfig dispatcher.
1468  */
1469 
1470 static int __init ip_auto_config(void)
1471 {
1472     __be32 addr;
1473 #ifdef IPCONFIG_DYNAMIC
1474     int retries = CONF_OPEN_RETRIES;
1475 #endif
1476     int err;
1477     unsigned int i, count;
1478 
1479     /* Initialise all name servers and NTP servers to NONE (but only if the
1480      * "ip=" or "nfsaddrs=" kernel command line parameters weren't decoded,
1481      * otherwise we'll overwrite the IP addresses specified there)
1482      */
1483     if (ic_set_manually == 0) {
1484         ic_nameservers_predef();
1485         ic_ntp_servers_predef();
1486     }
1487 
1488 #ifdef CONFIG_PROC_FS
1489     proc_create_single("pnp", 0444, init_net.proc_net, pnp_seq_show);
1490 
1491     if (ipconfig_proc_net_init() == 0)
1492         ipconfig_proc_net_create("ntp_servers", &ntp_servers_proc_ops);
1493 #endif /* CONFIG_PROC_FS */
1494 
1495     if (!ic_enable)
1496         return 0;
1497 
1498     pr_debug("IP-Config: Entered.\n");
1499 #ifdef IPCONFIG_DYNAMIC
1500  try_try_again:
1501 #endif
1502     /* Wait for devices to appear */
1503     err = wait_for_devices();
1504     if (err)
1505         return err;
1506 
1507     /* Setup all network devices */
1508     err = ic_open_devs();
1509     if (err)
1510         return err;
1511 
1512     /* Give drivers a chance to settle */
1513     msleep(CONF_POST_OPEN);
1514 
1515     /*
1516      * If the config information is insufficient (e.g., our IP address or
1517      * IP address of the boot server is missing or we have multiple network
1518      * interfaces and no default was set), use BOOTP or RARP to get the
1519      * missing values.
1520      */
1521     if (ic_myaddr == NONE ||
1522 #if defined(CONFIG_ROOT_NFS) || defined(CONFIG_CIFS_ROOT)
1523         (root_server_addr == NONE &&
1524          ic_servaddr == NONE &&
1525          (ROOT_DEV == Root_NFS || ROOT_DEV == Root_CIFS)) ||
1526 #endif
1527         ic_first_dev->next) {
1528 #ifdef IPCONFIG_DYNAMIC
1529         if (ic_dynamic() < 0) {
1530             ic_close_devs();
1531 
1532             /*
1533              * I don't know why, but sometimes the
1534              * eepro100 driver (at least) gets upset and
1535              * doesn't work the first time it's opened.
1536              * But then if you close it and reopen it, it
1537              * works just fine.  So we need to try that at
1538              * least once before giving up.
1539              *
1540              * Also, if the root will be NFS-mounted, we
1541              * have nowhere to go if DHCP fails.  So we
1542              * just have to keep trying forever.
1543              *
1544              *              -- Chip
1545              */
1546 #ifdef CONFIG_ROOT_NFS
1547             if (ROOT_DEV ==  Root_NFS) {
1548                 pr_err("IP-Config: Retrying forever (NFS root)...\n");
1549                 goto try_try_again;
1550             }
1551 #endif
1552 #ifdef CONFIG_CIFS_ROOT
1553             if (ROOT_DEV == Root_CIFS) {
1554                 pr_err("IP-Config: Retrying forever (CIFS root)...\n");
1555                 goto try_try_again;
1556             }
1557 #endif
1558 
1559             if (--retries) {
1560                 pr_err("IP-Config: Reopening network devices...\n");
1561                 goto try_try_again;
1562             }
1563 
1564             /* Oh, well.  At least we tried. */
1565             pr_err("IP-Config: Auto-configuration of network failed\n");
1566             return -1;
1567         }
1568 #else /* !DYNAMIC */
1569         pr_err("IP-Config: Incomplete network configuration information\n");
1570         ic_close_devs();
1571         return -1;
1572 #endif /* IPCONFIG_DYNAMIC */
1573     } else {
1574         /* Device selected manually or only one device -> use it */
1575         ic_dev = ic_first_dev;
1576     }
1577 
1578     addr = root_nfs_parse_addr(root_server_path);
1579     if (root_server_addr == NONE)
1580         root_server_addr = addr;
1581 
1582     /*
1583      * Use defaults wherever applicable.
1584      */
1585     if (ic_defaults() < 0)
1586         return -1;
1587 
1588     /*
1589      * Record which protocol was actually used.
1590      */
1591 #ifdef IPCONFIG_DYNAMIC
1592     ic_proto_used = ic_got_reply | (ic_proto_enabled & IC_USE_DHCP);
1593 #endif
1594 
1595 #ifndef IPCONFIG_SILENT
1596     /*
1597      * Clue in the operator.
1598      */
1599     pr_info("IP-Config: Complete:\n");
1600 
1601     pr_info("     device=%s, hwaddr=%*phC, ipaddr=%pI4, mask=%pI4, gw=%pI4\n",
1602         ic_dev->dev->name, ic_dev->dev->addr_len, ic_dev->dev->dev_addr,
1603         &ic_myaddr, &ic_netmask, &ic_gateway);
1604     pr_info("     host=%s, domain=%s, nis-domain=%s\n",
1605         utsname()->nodename, ic_domain, utsname()->domainname);
1606     pr_info("     bootserver=%pI4, rootserver=%pI4, rootpath=%s",
1607         &ic_servaddr, &root_server_addr, root_server_path);
1608     if (ic_dev_mtu)
1609         pr_cont(", mtu=%d", ic_dev_mtu);
1610     /* Name servers (if any): */
1611     for (i = 0, count = 0; i < CONF_NAMESERVERS_MAX; i++) {
1612         if (ic_nameservers[i] != NONE) {
1613             if (i == 0)
1614                 pr_info("     nameserver%u=%pI4",
1615                     i, &ic_nameservers[i]);
1616             else
1617                 pr_cont(", nameserver%u=%pI4",
1618                     i, &ic_nameservers[i]);
1619 
1620             count++;
1621         }
1622         if ((i + 1 == CONF_NAMESERVERS_MAX) && count > 0)
1623             pr_cont("\n");
1624     }
1625     /* NTP servers (if any): */
1626     for (i = 0, count = 0; i < CONF_NTP_SERVERS_MAX; i++) {
1627         if (ic_ntp_servers[i] != NONE) {
1628             if (i == 0)
1629                 pr_info("     ntpserver%u=%pI4",
1630                     i, &ic_ntp_servers[i]);
1631             else
1632                 pr_cont(", ntpserver%u=%pI4",
1633                     i, &ic_ntp_servers[i]);
1634 
1635             count++;
1636         }
1637         if ((i + 1 == CONF_NTP_SERVERS_MAX) && count > 0)
1638             pr_cont("\n");
1639     }
1640 #endif /* !SILENT */
1641 
1642     /*
1643      * Close all network devices except the device we've
1644      * autoconfigured and set up routes.
1645      */
1646     if (ic_setup_if() < 0 || ic_setup_routes() < 0)
1647         err = -1;
1648     else
1649         err = 0;
1650 
1651     ic_close_devs();
1652 
1653     return err;
1654 }
1655 
1656 late_initcall(ip_auto_config);
1657 
1658 
1659 /*
1660  *  Decode any IP configuration options in the "ip=" or "nfsaddrs=" kernel
1661  *  command line parameter.  See Documentation/admin-guide/nfs/nfsroot.rst.
1662  */
1663 static int __init ic_proto_name(char *name)
1664 {
1665     if (!strcmp(name, "on") || !strcmp(name, "any")) {
1666         return 1;
1667     }
1668     if (!strcmp(name, "off") || !strcmp(name, "none")) {
1669         return 0;
1670     }
1671 #ifdef CONFIG_IP_PNP_DHCP
1672     else if (!strncmp(name, "dhcp", 4)) {
1673         char *client_id;
1674 
1675         ic_proto_enabled &= ~IC_RARP;
1676         client_id = strstr(name, "dhcp,");
1677         if (client_id) {
1678             char *v;
1679 
1680             client_id = client_id + 5;
1681             v = strchr(client_id, ',');
1682             if (!v)
1683                 return 1;
1684             *v = 0;
1685             if (kstrtou8(client_id, 0, dhcp_client_identifier))
1686                 pr_debug("DHCP: Invalid client identifier type\n");
1687             strncpy(dhcp_client_identifier + 1, v + 1, 251);
1688             *v = ',';
1689         }
1690         return 1;
1691     }
1692 #endif
1693 #ifdef CONFIG_IP_PNP_BOOTP
1694     else if (!strcmp(name, "bootp")) {
1695         ic_proto_enabled &= ~(IC_RARP | IC_USE_DHCP);
1696         return 1;
1697     }
1698 #endif
1699 #ifdef CONFIG_IP_PNP_RARP
1700     else if (!strcmp(name, "rarp")) {
1701         ic_proto_enabled &= ~(IC_BOOTP | IC_USE_DHCP);
1702         return 1;
1703     }
1704 #endif
1705 #ifdef IPCONFIG_DYNAMIC
1706     else if (!strcmp(name, "both")) {
1707         ic_proto_enabled &= ~IC_USE_DHCP; /* backward compat :-( */
1708         return 1;
1709     }
1710 #endif
1711     return 0;
1712 }
1713 
1714 static int __init ip_auto_config_setup(char *addrs)
1715 {
1716     char *cp, *ip, *dp;
1717     int num = 0;
1718 
1719     ic_set_manually = 1;
1720     ic_enable = 1;
1721 
1722     /*
1723      * If any dhcp, bootp etc options are set, leave autoconfig on
1724      * and skip the below static IP processing.
1725      */
1726     if (ic_proto_name(addrs))
1727         return 1;
1728 
1729     /* If no static IP is given, turn off autoconfig and bail.  */
1730     if (*addrs == 0 ||
1731         strcmp(addrs, "off") == 0 ||
1732         strcmp(addrs, "none") == 0) {
1733         ic_enable = 0;
1734         return 1;
1735     }
1736 
1737     /* Initialise all name servers and NTP servers to NONE */
1738     ic_nameservers_predef();
1739     ic_ntp_servers_predef();
1740 
1741     /* Parse string for static IP assignment.  */
1742     ip = addrs;
1743     while (ip && *ip) {
1744         if ((cp = strchr(ip, ':')))
1745             *cp++ = '\0';
1746         if (strlen(ip) > 0) {
1747             pr_debug("IP-Config: Parameter #%d: `%s'\n", num, ip);
1748             switch (num) {
1749             case 0:
1750                 if ((ic_myaddr = in_aton(ip)) == ANY)
1751                     ic_myaddr = NONE;
1752                 break;
1753             case 1:
1754                 if ((ic_servaddr = in_aton(ip)) == ANY)
1755                     ic_servaddr = NONE;
1756                 break;
1757             case 2:
1758                 if ((ic_gateway = in_aton(ip)) == ANY)
1759                     ic_gateway = NONE;
1760                 break;
1761             case 3:
1762                 if ((ic_netmask = in_aton(ip)) == ANY)
1763                     ic_netmask = NONE;
1764                 break;
1765             case 4:
1766                 if ((dp = strchr(ip, '.'))) {
1767                     *dp++ = '\0';
1768                     strscpy(utsname()->domainname, dp,
1769                         sizeof(utsname()->domainname));
1770                 }
1771                 strscpy(utsname()->nodename, ip,
1772                     sizeof(utsname()->nodename));
1773                 ic_host_name_set = 1;
1774                 break;
1775             case 5:
1776                 strscpy(user_dev_name, ip, sizeof(user_dev_name));
1777                 break;
1778             case 6:
1779                 if (ic_proto_name(ip) == 0 &&
1780                     ic_myaddr == NONE) {
1781                     ic_enable = 0;
1782                 }
1783                 break;
1784             case 7:
1785                 if (CONF_NAMESERVERS_MAX >= 1) {
1786                     ic_nameservers[0] = in_aton(ip);
1787                     if (ic_nameservers[0] == ANY)
1788                         ic_nameservers[0] = NONE;
1789                 }
1790                 break;
1791             case 8:
1792                 if (CONF_NAMESERVERS_MAX >= 2) {
1793                     ic_nameservers[1] = in_aton(ip);
1794                     if (ic_nameservers[1] == ANY)
1795                         ic_nameservers[1] = NONE;
1796                 }
1797                 break;
1798             case 9:
1799                 if (CONF_NTP_SERVERS_MAX >= 1) {
1800                     ic_ntp_servers[0] = in_aton(ip);
1801                     if (ic_ntp_servers[0] == ANY)
1802                         ic_ntp_servers[0] = NONE;
1803                 }
1804                 break;
1805             }
1806         }
1807         ip = cp;
1808         num++;
1809     }
1810 
1811     return 1;
1812 }
1813 __setup("ip=", ip_auto_config_setup);
1814 
1815 static int __init nfsaddrs_config_setup(char *addrs)
1816 {
1817     return ip_auto_config_setup(addrs);
1818 }
1819 __setup("nfsaddrs=", nfsaddrs_config_setup);
1820 
1821 static int __init vendor_class_identifier_setup(char *addrs)
1822 {
1823     if (strscpy(vendor_class_identifier, addrs,
1824             sizeof(vendor_class_identifier))
1825         >= sizeof(vendor_class_identifier))
1826         pr_warn("DHCP: vendorclass too long, truncated to \"%s\"\n",
1827             vendor_class_identifier);
1828     return 1;
1829 }
1830 __setup("dhcpclass=", vendor_class_identifier_setup);
1831 
1832 static int __init set_carrier_timeout(char *str)
1833 {
1834     ssize_t ret;
1835 
1836     if (!str)
1837         return 0;
1838 
1839     ret = kstrtouint(str, 0, &carrier_timeout);
1840     if (ret)
1841         return 0;
1842 
1843     return 1;
1844 }
1845 __setup("carrier_timeout=", set_carrier_timeout);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!