LCOV - code coverage report
Current view: top level - net/ipv4 - ipconfig.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 34 700 4.9 %
Date: 2022-04-01 14:58:12 Functions: 5 31 16.1 %
Branches: 11 481 2.3 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  Automatic Configuration of IP -- use DHCP, BOOTP, RARP, or
       4                 :            :  *  user-supplied information to configure own IP address and routes.
       5                 :            :  *
       6                 :            :  *  Copyright (C) 1996-1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
       7                 :            :  *
       8                 :            :  *  Derived from network configuration code in fs/nfs/nfsroot.c,
       9                 :            :  *  originally Copyright (C) 1995, 1996 Gero Kuhlmann and me.
      10                 :            :  *
      11                 :            :  *  BOOTP rewritten to construct and analyse packets itself instead
      12                 :            :  *  of misusing the IP layer. num_bugs_causing_wrong_arp_replies--;
      13                 :            :  *                                           -- MJ, December 1998
      14                 :            :  *
      15                 :            :  *  Fixed ip_auto_config_setup calling at startup in the new "Linker Magic"
      16                 :            :  *  initialization scheme.
      17                 :            :  *      - Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 08/11/1999
      18                 :            :  *
      19                 :            :  *  DHCP support added.  To users this looks like a whole separate
      20                 :            :  *  protocol, but we know it's just a bag on the side of BOOTP.
      21                 :            :  *              -- Chip Salzenberg <chip@valinux.com>, May 2000
      22                 :            :  *
      23                 :            :  *  Ported DHCP support from 2.2.16 to 2.4.0-test4
      24                 :            :  *              -- Eric Biederman <ebiederman@lnxi.com>, 30 Aug 2000
      25                 :            :  *
      26                 :            :  *  Merged changes from 2.2.19 into 2.4.3
      27                 :            :  *              -- Eric Biederman <ebiederman@lnxi.com>, 22 April Aug 2001
      28                 :            :  *
      29                 :            :  *  Multiple Nameservers in /proc/net/pnp
      30                 :            :  *              --  Josef Siemes <jsiemes@web.de>, Aug 2002
      31                 :            :  *
      32                 :            :  *  NTP servers in /proc/net/ipconfig/ntp_servers
      33                 :            :  *              --  Chris Novakovic <chris@chrisn.me.uk>, April 2018
      34                 :            :  */
      35                 :            : 
      36                 :            : #include <linux/types.h>
      37                 :            : #include <linux/string.h>
      38                 :            : #include <linux/kernel.h>
      39                 :            : #include <linux/jiffies.h>
      40                 :            : #include <linux/random.h>
      41                 :            : #include <linux/init.h>
      42                 :            : #include <linux/utsname.h>
      43                 :            : #include <linux/in.h>
      44                 :            : #include <linux/if.h>
      45                 :            : #include <linux/inet.h>
      46                 :            : #include <linux/inetdevice.h>
      47                 :            : #include <linux/netdevice.h>
      48                 :            : #include <linux/if_arp.h>
      49                 :            : #include <linux/skbuff.h>
      50                 :            : #include <linux/ip.h>
      51                 :            : #include <linux/socket.h>
      52                 :            : #include <linux/route.h>
      53                 :            : #include <linux/udp.h>
      54                 :            : #include <linux/proc_fs.h>
      55                 :            : #include <linux/seq_file.h>
      56                 :            : #include <linux/major.h>
      57                 :            : #include <linux/root_dev.h>
      58                 :            : #include <linux/delay.h>
      59                 :            : #include <linux/nfs_fs.h>
      60                 :            : #include <linux/slab.h>
      61                 :            : #include <linux/export.h>
      62                 :            : #include <net/net_namespace.h>
      63                 :            : #include <net/arp.h>
      64                 :            : #include <net/dsa.h>
      65                 :            : #include <net/ip.h>
      66                 :            : #include <net/ipconfig.h>
      67                 :            : #include <net/route.h>
      68                 :            : 
      69                 :            : #include <linux/uaccess.h>
      70                 :            : #include <net/checksum.h>
      71                 :            : #include <asm/processor.h>
      72                 :            : 
      73                 :            : #if defined(CONFIG_IP_PNP_DHCP)
      74                 :            : #define IPCONFIG_DHCP
      75                 :            : #endif
      76                 :            : #if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_DHCP)
      77                 :            : #define IPCONFIG_BOOTP
      78                 :            : #endif
      79                 :            : #if defined(CONFIG_IP_PNP_RARP)
      80                 :            : #define IPCONFIG_RARP
      81                 :            : #endif
      82                 :            : #if defined(IPCONFIG_BOOTP) || defined(IPCONFIG_RARP)
      83                 :            : #define IPCONFIG_DYNAMIC
      84                 :            : #endif
      85                 :            : 
      86                 :            : /* Define the friendly delay before and after opening net devices */
      87                 :            : #define CONF_POST_OPEN          10      /* After opening: 10 msecs */
      88                 :            : 
      89                 :            : /* Define the timeout for waiting for a DHCP/BOOTP/RARP reply */
      90                 :            : #define CONF_OPEN_RETRIES       2       /* (Re)open devices twice */
      91                 :            : #define CONF_SEND_RETRIES       6       /* Send six requests per open */
      92                 :            : #define CONF_BASE_TIMEOUT       (HZ*2)  /* Initial timeout: 2 seconds */
      93                 :            : #define CONF_TIMEOUT_RANDOM     (HZ)    /* Maximum amount of randomization */
      94                 :            : #define CONF_TIMEOUT_MULT       *7/4    /* Rate of timeout growth */
      95                 :            : #define CONF_TIMEOUT_MAX        (HZ*30) /* Maximum allowed timeout */
      96                 :            : #define CONF_NAMESERVERS_MAX   3       /* Maximum number of nameservers
      97                 :            :                                            - '3' from resolv.h */
      98                 :            : #define CONF_NTP_SERVERS_MAX   3        /* Maximum number of NTP servers */
      99                 :            : 
     100                 :            : #define NONE cpu_to_be32(INADDR_NONE)
     101                 :            : #define ANY cpu_to_be32(INADDR_ANY)
     102                 :            : 
     103                 :            : /* Wait for carrier timeout default in seconds */
     104                 :            : static unsigned int carrier_timeout = 120;
     105                 :            : 
     106                 :            : /*
     107                 :            :  * Public IP configuration
     108                 :            :  */
     109                 :            : 
     110                 :            : /* This is used by platforms which might be able to set the ipconfig
     111                 :            :  * variables using firmware environment vars.  If this is set, it will
     112                 :            :  * ignore such firmware variables.
     113                 :            :  */
     114                 :            : int ic_set_manually __initdata = 0;             /* IPconfig parameters set manually */
     115                 :            : 
     116                 :            : static int ic_enable __initdata;                /* IP config enabled? */
     117                 :            : 
     118                 :            : /* Protocol choice */
     119                 :            : int ic_proto_enabled __initdata = 0
     120                 :            : #ifdef IPCONFIG_BOOTP
     121                 :            :                         | IC_BOOTP
     122                 :            : #endif
     123                 :            : #ifdef CONFIG_IP_PNP_DHCP
     124                 :            :                         | IC_USE_DHCP
     125                 :            : #endif
     126                 :            : #ifdef IPCONFIG_RARP
     127                 :            :                         | IC_RARP
     128                 :            : #endif
     129                 :            :                         ;
     130                 :            : 
     131                 :            : static int ic_host_name_set __initdata; /* Host name set by us? */
     132                 :            : 
     133                 :            : __be32 ic_myaddr = NONE;                /* My IP address */
     134                 :            : static __be32 ic_netmask = NONE;        /* Netmask for local subnet */
     135                 :            : __be32 ic_gateway = NONE;       /* Gateway IP address */
     136                 :            : 
     137                 :            : #ifdef IPCONFIG_DYNAMIC
     138                 :            : static __be32 ic_addrservaddr = NONE;   /* IP Address of the IP addresses'server */
     139                 :            : #endif
     140                 :            : 
     141                 :            : __be32 ic_servaddr = NONE;      /* Boot server IP address */
     142                 :            : 
     143                 :            : __be32 root_server_addr = NONE; /* Address of NFS server */
     144                 :            : u8 root_server_path[256] = { 0, };      /* Path to mount as root */
     145                 :            : 
     146                 :            : /* vendor class identifier */
     147                 :            : static char vendor_class_identifier[253] __initdata;
     148                 :            : 
     149                 :            : #if defined(CONFIG_IP_PNP_DHCP)
     150                 :            : static char dhcp_client_identifier[253] __initdata;
     151                 :            : #endif
     152                 :            : 
     153                 :            : /* Persistent data: */
     154                 :            : 
     155                 :            : #ifdef IPCONFIG_DYNAMIC
     156                 :            : static int ic_proto_used;                       /* Protocol used, if any */
     157                 :            : #else
     158                 :            : #define ic_proto_used 0
     159                 :            : #endif
     160                 :            : static __be32 ic_nameservers[CONF_NAMESERVERS_MAX]; /* DNS Server IP addresses */
     161                 :            : static __be32 ic_ntp_servers[CONF_NTP_SERVERS_MAX]; /* NTP server IP addresses */
     162                 :            : static u8 ic_domain[64];                /* DNS (not NIS) domain name */
     163                 :            : 
     164                 :            : /*
     165                 :            :  * Private state.
     166                 :            :  */
     167                 :            : 
     168                 :            : /* Name of user-selected boot device */
     169                 :            : static char user_dev_name[IFNAMSIZ] __initdata = { 0, };
     170                 :            : 
     171                 :            : /* Protocols supported by available interfaces */
     172                 :            : static int ic_proto_have_if __initdata;
     173                 :            : 
     174                 :            : /* MTU for boot device */
     175                 :            : static int ic_dev_mtu __initdata;
     176                 :            : 
     177                 :            : #ifdef IPCONFIG_DYNAMIC
     178                 :            : static DEFINE_SPINLOCK(ic_recv_lock);
     179                 :            : static volatile int ic_got_reply __initdata;    /* Proto(s) that replied */
     180                 :            : #endif
     181                 :            : #ifdef IPCONFIG_DHCP
     182                 :            : static int ic_dhcp_msgtype __initdata;  /* DHCP msg type received */
     183                 :            : #endif
     184                 :            : 
     185                 :            : 
     186                 :            : /*
     187                 :            :  *      Network devices
     188                 :            :  */
     189                 :            : 
     190                 :            : struct ic_device {
     191                 :            :         struct ic_device *next;
     192                 :            :         struct net_device *dev;
     193                 :            :         unsigned short flags;
     194                 :            :         short able;
     195                 :            :         __be32 xid;
     196                 :            : };
     197                 :            : 
     198                 :            : static struct ic_device *ic_first_dev __initdata;       /* List of open device */
     199                 :            : static struct ic_device *ic_dev __initdata;             /* Selected device */
     200                 :            : 
     201                 :          0 : static bool __init ic_is_init_dev(struct net_device *dev)
     202                 :            : {
     203         [ #  # ]:          0 :         if (dev->flags & IFF_LOOPBACK)
     204                 :            :                 return false;
     205         [ #  # ]:          0 :         return user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :
     206                 :          0 :             (!(dev->flags & IFF_LOOPBACK) &&
     207         [ #  # ]:          0 :              (dev->flags & (IFF_POINTOPOINT|IFF_BROADCAST)) &&
     208         [ #  # ]:          0 :              strncmp(dev->name, "dummy", 5));
     209                 :            : }
     210                 :            : 
     211                 :          0 : static int __init ic_open_devs(void)
     212                 :            : {
     213                 :          0 :         struct ic_device *d, **last;
     214                 :          0 :         struct net_device *dev;
     215                 :          0 :         unsigned short oflags;
     216                 :          0 :         unsigned long start, next_msg;
     217                 :            : 
     218                 :          0 :         last = &ic_first_dev;
     219                 :          0 :         rtnl_lock();
     220                 :            : 
     221                 :            :         /* bring loopback and DSA master network devices up first */
     222         [ #  # ]:          0 :         for_each_netdev(&init_net, dev) {
     223         [ #  # ]:          0 :                 if (!(dev->flags & IFF_LOOPBACK) && !netdev_uses_dsa(dev))
     224                 :          0 :                         continue;
     225         [ #  # ]:          0 :                 if (dev_change_flags(dev, dev->flags | IFF_UP, NULL) < 0)
     226                 :          0 :                         pr_err("IP-Config: Failed to open %s\n", dev->name);
     227                 :            :         }
     228                 :            : 
     229         [ #  # ]:          0 :         for_each_netdev(&init_net, dev) {
     230         [ #  # ]:          0 :                 if (ic_is_init_dev(dev)) {
     231                 :          0 :                         int able = 0;
     232         [ #  # ]:          0 :                         if (dev->mtu >= 364)
     233                 :            :                                 able |= IC_BOOTP;
     234                 :            :                         else
     235                 :          0 :                                 pr_warn("DHCP/BOOTP: Ignoring device %s, MTU %d too small\n",
     236                 :            :                                         dev->name, dev->mtu);
     237         [ #  # ]:          0 :                         if (!(dev->flags & IFF_NOARP))
     238                 :          0 :                                 able |= IC_RARP;
     239                 :          0 :                         able &= ic_proto_enabled;
     240   [ #  #  #  # ]:          0 :                         if (ic_proto_enabled && !able)
     241                 :          0 :                                 continue;
     242                 :          0 :                         oflags = dev->flags;
     243         [ #  # ]:          0 :                         if (dev_change_flags(dev, oflags | IFF_UP, NULL) < 0) {
     244                 :          0 :                                 pr_err("IP-Config: Failed to open %s\n",
     245                 :            :                                        dev->name);
     246                 :          0 :                                 continue;
     247                 :            :                         }
     248         [ #  # ]:          0 :                         if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {
     249                 :          0 :                                 rtnl_unlock();
     250                 :          0 :                                 return -ENOMEM;
     251                 :            :                         }
     252                 :          0 :                         d->dev = dev;
     253                 :          0 :                         *last = d;
     254                 :          0 :                         last = &d->next;
     255                 :          0 :                         d->flags = oflags;
     256                 :          0 :                         d->able = able;
     257         [ #  # ]:          0 :                         if (able & IC_BOOTP)
     258                 :          0 :                                 get_random_bytes(&d->xid, sizeof(__be32));
     259                 :            :                         else
     260                 :          0 :                                 d->xid = 0;
     261                 :          0 :                         ic_proto_have_if |= able;
     262                 :          0 :                         pr_debug("IP-Config: %s UP (able=%d, xid=%08x)\n",
     263                 :            :                                  dev->name, able, d->xid);
     264                 :            :                 }
     265                 :            :         }
     266                 :            : 
     267                 :            :         /* no point in waiting if we could not bring up at least one device */
     268         [ #  # ]:          0 :         if (!ic_first_dev)
     269                 :          0 :                 goto have_carrier;
     270                 :            : 
     271                 :            :         /* wait for a carrier on at least one device */
     272                 :          0 :         start = jiffies;
     273                 :          0 :         next_msg = start + msecs_to_jiffies(20000);
     274   [ #  #  #  # ]:          0 :         while (time_before(jiffies, start +
     275                 :            :                            msecs_to_jiffies(carrier_timeout * 1000))) {
     276                 :          0 :                 int wait, elapsed;
     277                 :            : 
     278         [ #  # ]:          0 :                 for_each_netdev(&init_net, dev)
     279   [ #  #  #  # ]:          0 :                         if (ic_is_init_dev(dev) && netif_carrier_ok(dev))
     280                 :          0 :                                 goto have_carrier;
     281                 :            : 
     282                 :          0 :                 msleep(1);
     283                 :            : 
     284         [ #  # ]:          0 :                 if (time_before(jiffies, next_msg))
     285                 :          0 :                         continue;
     286                 :            : 
     287                 :          0 :                 elapsed = jiffies_to_msecs(jiffies - start);
     288                 :          0 :                 wait = (carrier_timeout * 1000 - elapsed + 500) / 1000;
     289                 :          0 :                 pr_info("Waiting up to %d more seconds for network.\n", wait);
     290                 :          0 :                 next_msg = jiffies + msecs_to_jiffies(20000);
     291                 :            :         }
     292                 :          0 : have_carrier:
     293                 :          0 :         rtnl_unlock();
     294                 :            : 
     295                 :          0 :         *last = NULL;
     296                 :            : 
     297         [ #  # ]:          0 :         if (!ic_first_dev) {
     298         [ #  # ]:          0 :                 if (user_dev_name[0])
     299                 :          0 :                         pr_err("IP-Config: Device `%s' not found\n",
     300                 :            :                                user_dev_name);
     301                 :            :                 else
     302                 :          0 :                         pr_err("IP-Config: No network devices available\n");
     303                 :          0 :                 return -ENODEV;
     304                 :            :         }
     305                 :            :         return 0;
     306                 :            : }
     307                 :            : 
     308                 :          0 : static void __init ic_close_devs(void)
     309                 :            : {
     310                 :          0 :         struct ic_device *d, *next;
     311                 :          0 :         struct net_device *dev;
     312                 :            : 
     313                 :          0 :         rtnl_lock();
     314                 :          0 :         next = ic_first_dev;
     315         [ #  # ]:          0 :         while ((d = next)) {
     316                 :          0 :                 next = d->next;
     317                 :          0 :                 dev = d->dev;
     318         [ #  # ]:          0 :                 if (d != ic_dev && !netdev_uses_dsa(dev)) {
     319                 :          0 :                         pr_debug("IP-Config: Downing %s\n", dev->name);
     320                 :          0 :                         dev_change_flags(dev, d->flags, NULL);
     321                 :            :                 }
     322                 :          0 :                 kfree(d);
     323                 :            :         }
     324                 :          0 :         rtnl_unlock();
     325                 :          0 : }
     326                 :            : 
     327                 :            : /*
     328                 :            :  *      Interface to various network functions.
     329                 :            :  */
     330                 :            : 
     331                 :            : static inline void
     332                 :          0 : set_sockaddr(struct sockaddr_in *sin, __be32 addr, __be16 port)
     333                 :            : {
     334                 :          0 :         sin->sin_family = AF_INET;
     335                 :          0 :         sin->sin_addr.s_addr = addr;
     336                 :          0 :         sin->sin_port = port;
     337                 :            : }
     338                 :            : 
     339                 :            : /*
     340                 :            :  *      Set up interface addresses and routes.
     341                 :            :  */
     342                 :            : 
     343                 :          0 : static int __init ic_setup_if(void)
     344                 :            : {
     345                 :          0 :         struct ifreq ir;
     346                 :          0 :         struct sockaddr_in *sin = (void *) &ir.ifr_ifru.ifru_addr;
     347                 :          0 :         int err;
     348                 :            : 
     349                 :          0 :         memset(&ir, 0, sizeof(ir));
     350                 :          0 :         strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->dev->name);
     351                 :          0 :         set_sockaddr(sin, ic_myaddr, 0);
     352         [ #  # ]:          0 :         if ((err = devinet_ioctl(&init_net, SIOCSIFADDR, &ir)) < 0) {
     353                 :          0 :                 pr_err("IP-Config: Unable to set interface address (%d)\n",
     354                 :            :                        err);
     355                 :          0 :                 return -1;
     356                 :            :         }
     357                 :          0 :         set_sockaddr(sin, ic_netmask, 0);
     358         [ #  # ]:          0 :         if ((err = devinet_ioctl(&init_net, SIOCSIFNETMASK, &ir)) < 0) {
     359                 :          0 :                 pr_err("IP-Config: Unable to set interface netmask (%d)\n",
     360                 :            :                        err);
     361                 :          0 :                 return -1;
     362                 :            :         }
     363                 :          0 :         set_sockaddr(sin, ic_myaddr | ~ic_netmask, 0);
     364         [ #  # ]:          0 :         if ((err = devinet_ioctl(&init_net, SIOCSIFBRDADDR, &ir)) < 0) {
     365                 :          0 :                 pr_err("IP-Config: Unable to set interface broadcast address (%d)\n",
     366                 :            :                        err);
     367                 :          0 :                 return -1;
     368                 :            :         }
     369                 :            :         /* Handle the case where we need non-standard MTU on the boot link (a network
     370                 :            :          * using jumbo frames, for instance).  If we can't set the mtu, don't error
     371                 :            :          * out, we'll try to muddle along.
     372                 :            :          */
     373         [ #  # ]:          0 :         if (ic_dev_mtu != 0) {
     374                 :          0 :                 rtnl_lock();
     375         [ #  # ]:          0 :                 if ((err = dev_set_mtu(ic_dev->dev, ic_dev_mtu)) < 0)
     376                 :          0 :                         pr_err("IP-Config: Unable to set interface mtu to %d (%d)\n",
     377                 :            :                                ic_dev_mtu, err);
     378                 :          0 :                 rtnl_unlock();
     379                 :            :         }
     380                 :            :         return 0;
     381                 :            : }
     382                 :            : 
     383                 :          0 : static int __init ic_setup_routes(void)
     384                 :            : {
     385                 :            :         /* No need to setup device routes, only the default route... */
     386                 :            : 
     387         [ #  # ]:          0 :         if (ic_gateway != NONE) {
     388                 :          0 :                 struct rtentry rm;
     389                 :          0 :                 int err;
     390                 :            : 
     391                 :          0 :                 memset(&rm, 0, sizeof(rm));
     392         [ #  # ]:          0 :                 if ((ic_gateway ^ ic_myaddr) & ic_netmask) {
     393                 :          0 :                         pr_err("IP-Config: Gateway not on directly connected network\n");
     394                 :          0 :                         return -1;
     395                 :            :                 }
     396                 :          0 :                 set_sockaddr((struct sockaddr_in *) &rm.rt_dst, 0, 0);
     397                 :          0 :                 set_sockaddr((struct sockaddr_in *) &rm.rt_genmask, 0, 0);
     398                 :          0 :                 set_sockaddr((struct sockaddr_in *) &rm.rt_gateway, ic_gateway, 0);
     399                 :          0 :                 rm.rt_flags = RTF_UP | RTF_GATEWAY;
     400         [ #  # ]:          0 :                 if ((err = ip_rt_ioctl(&init_net, SIOCADDRT, &rm)) < 0) {
     401                 :          0 :                         pr_err("IP-Config: Cannot add default route (%d)\n",
     402                 :            :                                err);
     403                 :          0 :                         return -1;
     404                 :            :                 }
     405                 :            :         }
     406                 :            : 
     407                 :            :         return 0;
     408                 :            : }
     409                 :            : 
     410                 :            : /*
     411                 :            :  *      Fill in default values for all missing parameters.
     412                 :            :  */
     413                 :            : 
     414                 :          0 : static int __init ic_defaults(void)
     415                 :            : {
     416                 :            :         /*
     417                 :            :          *      At this point we have no userspace running so need not
     418                 :            :          *      claim locks on system_utsname
     419                 :            :          */
     420                 :            : 
     421         [ #  # ]:          0 :         if (!ic_host_name_set)
     422                 :          0 :                 sprintf(init_utsname()->nodename, "%pI4", &ic_myaddr);
     423                 :            : 
     424         [ #  # ]:          0 :         if (root_server_addr == NONE)
     425                 :          0 :                 root_server_addr = ic_servaddr;
     426                 :            : 
     427         [ #  # ]:          0 :         if (ic_netmask == NONE) {
     428         [ #  # ]:          0 :                 if (IN_CLASSA(ntohl(ic_myaddr)))
     429                 :          0 :                         ic_netmask = htonl(IN_CLASSA_NET);
     430         [ #  # ]:          0 :                 else if (IN_CLASSB(ntohl(ic_myaddr)))
     431                 :          0 :                         ic_netmask = htonl(IN_CLASSB_NET);
     432         [ #  # ]:          0 :                 else if (IN_CLASSC(ntohl(ic_myaddr)))
     433                 :          0 :                         ic_netmask = htonl(IN_CLASSC_NET);
     434         [ #  # ]:          0 :                 else if (IN_CLASSE(ntohl(ic_myaddr)))
     435                 :          0 :                         ic_netmask = htonl(IN_CLASSE_NET);
     436                 :            :                 else {
     437                 :          0 :                         pr_err("IP-Config: Unable to guess netmask for address %pI4\n",
     438                 :            :                                &ic_myaddr);
     439                 :          0 :                         return -1;
     440                 :            :                 }
     441                 :          0 :                 pr_notice("IP-Config: Guessing netmask %pI4\n",
     442                 :            :                           &ic_netmask);
     443                 :            :         }
     444                 :            : 
     445                 :            :         return 0;
     446                 :            : }
     447                 :            : 
     448                 :            : /*
     449                 :            :  *      RARP support.
     450                 :            :  */
     451                 :            : 
     452                 :            : #ifdef IPCONFIG_RARP
     453                 :            : 
     454                 :            : static int ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev);
     455                 :            : 
     456                 :            : static struct packet_type rarp_packet_type __initdata = {
     457                 :            :         .type = cpu_to_be16(ETH_P_RARP),
     458                 :            :         .func = ic_rarp_recv,
     459                 :            : };
     460                 :            : 
     461                 :          0 : static inline void __init ic_rarp_init(void)
     462                 :            : {
     463                 :          0 :         dev_add_pack(&rarp_packet_type);
     464                 :          0 : }
     465                 :            : 
     466                 :          0 : static inline void __init ic_rarp_cleanup(void)
     467                 :            : {
     468                 :          0 :         dev_remove_pack(&rarp_packet_type);
     469                 :          0 : }
     470                 :            : 
     471                 :            : /*
     472                 :            :  *  Process received RARP packet.
     473                 :            :  */
     474                 :            : static int __init
     475                 :          0 : ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
     476                 :            : {
     477                 :          0 :         struct arphdr *rarp;
     478                 :          0 :         unsigned char *rarp_ptr;
     479                 :          0 :         __be32 sip, tip;
     480                 :          0 :         unsigned char *tha;             /* t for "target" */
     481                 :          0 :         struct ic_device *d;
     482                 :            : 
     483         [ #  # ]:          0 :         if (!net_eq(dev_net(dev), &init_net))
     484                 :          0 :                 goto drop;
     485                 :            : 
     486                 :          0 :         skb = skb_share_check(skb, GFP_ATOMIC);
     487         [ #  # ]:          0 :         if (!skb)
     488                 :            :                 return NET_RX_DROP;
     489                 :            : 
     490         [ #  # ]:          0 :         if (!pskb_may_pull(skb, sizeof(struct arphdr)))
     491                 :          0 :                 goto drop;
     492                 :            : 
     493                 :            :         /* Basic sanity checks can be done without the lock.  */
     494         [ #  # ]:          0 :         rarp = (struct arphdr *)skb_transport_header(skb);
     495                 :            : 
     496                 :            :         /* If this test doesn't pass, it's not IP, or we should
     497                 :            :          * ignore it anyway.
     498                 :            :          */
     499   [ #  #  #  # ]:          0 :         if (rarp->ar_hln != dev->addr_len || dev->type != ntohs(rarp->ar_hrd))
     500                 :          0 :                 goto drop;
     501                 :            : 
     502                 :            :         /* If it's not a RARP reply, delete it. */
     503         [ #  # ]:          0 :         if (rarp->ar_op != htons(ARPOP_RREPLY))
     504                 :          0 :                 goto drop;
     505                 :            : 
     506                 :            :         /* If it's not Ethernet, delete it. */
     507         [ #  # ]:          0 :         if (rarp->ar_pro != htons(ETH_P_IP))
     508                 :          0 :                 goto drop;
     509                 :            : 
     510         [ #  # ]:          0 :         if (!pskb_may_pull(skb, arp_hdr_len(dev)))
     511                 :          0 :                 goto drop;
     512                 :            : 
     513                 :            :         /* OK, it is all there and looks valid, process... */
     514                 :          0 :         rarp = (struct arphdr *)skb_transport_header(skb);
     515                 :          0 :         rarp_ptr = (unsigned char *) (rarp + 1);
     516                 :            : 
     517                 :            :         /* One reply at a time, please. */
     518                 :          0 :         spin_lock(&ic_recv_lock);
     519                 :            : 
     520                 :            :         /* If we already have a reply, just drop the packet */
     521         [ #  # ]:          0 :         if (ic_got_reply)
     522                 :          0 :                 goto drop_unlock;
     523                 :            : 
     524                 :            :         /* Find the ic_device that the packet arrived on */
     525                 :          0 :         d = ic_first_dev;
     526   [ #  #  #  # ]:          0 :         while (d && d->dev != dev)
     527                 :          0 :                 d = d->next;
     528         [ #  # ]:          0 :         if (!d)
     529                 :          0 :                 goto drop_unlock;       /* should never happen */
     530                 :            : 
     531                 :            :         /* Extract variable-width fields */
     532                 :          0 :         rarp_ptr += dev->addr_len;
     533                 :          0 :         memcpy(&sip, rarp_ptr, 4);
     534                 :          0 :         rarp_ptr += 4;
     535                 :          0 :         tha = rarp_ptr;
     536                 :          0 :         rarp_ptr += dev->addr_len;
     537                 :          0 :         memcpy(&tip, rarp_ptr, 4);
     538                 :            : 
     539                 :            :         /* Discard packets which are not meant for us. */
     540         [ #  # ]:          0 :         if (memcmp(tha, dev->dev_addr, dev->addr_len))
     541                 :          0 :                 goto drop_unlock;
     542                 :            : 
     543                 :            :         /* Discard packets which are not from specified server. */
     544   [ #  #  #  # ]:          0 :         if (ic_servaddr != NONE && ic_servaddr != sip)
     545                 :          0 :                 goto drop_unlock;
     546                 :            : 
     547                 :            :         /* We have a winner! */
     548                 :          0 :         ic_dev = d;
     549         [ #  # ]:          0 :         if (ic_myaddr == NONE)
     550                 :          0 :                 ic_myaddr = tip;
     551                 :          0 :         ic_servaddr = sip;
     552                 :          0 :         ic_addrservaddr = sip;
     553                 :          0 :         ic_got_reply = IC_RARP;
     554                 :            : 
     555                 :          0 : drop_unlock:
     556                 :            :         /* Show's over.  Nothing to see here.  */
     557                 :          0 :         spin_unlock(&ic_recv_lock);
     558                 :            : 
     559                 :          0 : drop:
     560                 :            :         /* Throw the packet out. */
     561                 :          0 :         kfree_skb(skb);
     562                 :          0 :         return 0;
     563                 :            : }
     564                 :            : 
     565                 :            : 
     566                 :            : /*
     567                 :            :  *  Send RARP request packet over a single interface.
     568                 :            :  */
     569                 :            : static void __init ic_rarp_send_if(struct ic_device *d)
     570                 :            : {
     571                 :            :         struct net_device *dev = d->dev;
     572                 :            :         arp_send(ARPOP_RREQUEST, ETH_P_RARP, 0, dev, 0, NULL,
     573                 :            :                  dev->dev_addr, dev->dev_addr);
     574                 :            : }
     575                 :            : #endif
     576                 :            : 
     577                 :            : /*
     578                 :            :  *  Predefine Nameservers
     579                 :            :  */
     580                 :          3 : static inline void __init ic_nameservers_predef(void)
     581                 :            : {
     582                 :          3 :         int i;
     583                 :            : 
     584         [ +  + ]:         12 :         for (i = 0; i < CONF_NAMESERVERS_MAX; i++)
     585                 :          9 :                 ic_nameservers[i] = NONE;
     586                 :          3 : }
     587                 :            : 
     588                 :            : /* Predefine NTP servers */
     589                 :          3 : static inline void __init ic_ntp_servers_predef(void)
     590                 :            : {
     591                 :          3 :         int i;
     592                 :            : 
     593         [ +  + ]:         12 :         for (i = 0; i < CONF_NTP_SERVERS_MAX; i++)
     594                 :          9 :                 ic_ntp_servers[i] = NONE;
     595                 :          3 : }
     596                 :            : 
     597                 :            : /*
     598                 :            :  *      DHCP/BOOTP support.
     599                 :            :  */
     600                 :            : 
     601                 :            : #ifdef IPCONFIG_BOOTP
     602                 :            : 
     603                 :            : struct bootp_pkt {              /* BOOTP packet format */
     604                 :            :         struct iphdr iph;       /* IP header */
     605                 :            :         struct udphdr udph;     /* UDP header */
     606                 :            :         u8 op;                  /* 1=request, 2=reply */
     607                 :            :         u8 htype;               /* HW address type */
     608                 :            :         u8 hlen;                /* HW address length */
     609                 :            :         u8 hops;                /* Used only by gateways */
     610                 :            :         __be32 xid;             /* Transaction ID */
     611                 :            :         __be16 secs;            /* Seconds since we started */
     612                 :            :         __be16 flags;           /* Just what it says */
     613                 :            :         __be32 client_ip;               /* Client's IP address if known */
     614                 :            :         __be32 your_ip;         /* Assigned IP address */
     615                 :            :         __be32 server_ip;               /* (Next, e.g. NFS) Server's IP address */
     616                 :            :         __be32 relay_ip;                /* IP address of BOOTP relay */
     617                 :            :         u8 hw_addr[16];         /* Client's HW address */
     618                 :            :         u8 serv_name[64];       /* Server host name */
     619                 :            :         u8 boot_file[128];      /* Name of boot file */
     620                 :            :         u8 exten[312];          /* DHCP options / BOOTP vendor extensions */
     621                 :            : };
     622                 :            : 
     623                 :            : /* packet ops */
     624                 :            : #define BOOTP_REQUEST   1
     625                 :            : #define BOOTP_REPLY     2
     626                 :            : 
     627                 :            : /* DHCP message types */
     628                 :            : #define DHCPDISCOVER    1
     629                 :            : #define DHCPOFFER       2
     630                 :            : #define DHCPREQUEST     3
     631                 :            : #define DHCPDECLINE     4
     632                 :            : #define DHCPACK         5
     633                 :            : #define DHCPNAK         6
     634                 :            : #define DHCPRELEASE     7
     635                 :            : #define DHCPINFORM      8
     636                 :            : 
     637                 :            : static int ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev);
     638                 :            : 
     639                 :            : static struct packet_type bootp_packet_type __initdata = {
     640                 :            :         .type = cpu_to_be16(ETH_P_IP),
     641                 :            :         .func = ic_bootp_recv,
     642                 :            : };
     643                 :            : 
     644                 :            : /*
     645                 :            :  *  Initialize DHCP/BOOTP extension fields in the request.
     646                 :            :  */
     647                 :            : 
     648                 :            : static const u8 ic_bootp_cookie[4] = { 99, 130, 83, 99 };
     649                 :            : 
     650                 :            : #ifdef IPCONFIG_DHCP
     651                 :            : 
     652                 :            : static void __init
     653                 :            : ic_dhcp_init_options(u8 *options, struct ic_device *d)
     654                 :            : {
     655                 :            :         u8 mt = ((ic_servaddr == NONE)
     656                 :            :                  ? DHCPDISCOVER : DHCPREQUEST);
     657                 :            :         u8 *e = options;
     658                 :            :         int len;
     659                 :            : 
     660                 :            :         pr_debug("DHCP: Sending message type %d (%s)\n", mt, d->dev->name);
     661                 :            : 
     662                 :            :         memcpy(e, ic_bootp_cookie, 4);  /* RFC1048 Magic Cookie */
     663                 :            :         e += 4;
     664                 :            : 
     665                 :            :         *e++ = 53;              /* DHCP message type */
     666                 :            :         *e++ = 1;
     667                 :            :         *e++ = mt;
     668                 :            : 
     669                 :            :         if (mt == DHCPREQUEST) {
     670                 :            :                 *e++ = 54;      /* Server ID (IP address) */
     671                 :            :                 *e++ = 4;
     672                 :            :                 memcpy(e, &ic_servaddr, 4);
     673                 :            :                 e += 4;
     674                 :            : 
     675                 :            :                 *e++ = 50;      /* Requested IP address */
     676                 :            :                 *e++ = 4;
     677                 :            :                 memcpy(e, &ic_myaddr, 4);
     678                 :            :                 e += 4;
     679                 :            :         }
     680                 :            : 
     681                 :            :         /* always? */
     682                 :            :         {
     683                 :            :                 static const u8 ic_req_params[] = {
     684                 :            :                         1,      /* Subnet mask */
     685                 :            :                         3,      /* Default gateway */
     686                 :            :                         6,      /* DNS server */
     687                 :            :                         12,     /* Host name */
     688                 :            :                         15,     /* Domain name */
     689                 :            :                         17,     /* Boot path */
     690                 :            :                         26,     /* MTU */
     691                 :            :                         40,     /* NIS domain name */
     692                 :            :                         42,     /* NTP servers */
     693                 :            :                 };
     694                 :            : 
     695                 :            :                 *e++ = 55;      /* Parameter request list */
     696                 :            :                 *e++ = sizeof(ic_req_params);
     697                 :            :                 memcpy(e, ic_req_params, sizeof(ic_req_params));
     698                 :            :                 e += sizeof(ic_req_params);
     699                 :            : 
     700                 :            :                 if (ic_host_name_set) {
     701                 :            :                         *e++ = 12;      /* host-name */
     702                 :            :                         len = strlen(utsname()->nodename);
     703                 :            :                         *e++ = len;
     704                 :            :                         memcpy(e, utsname()->nodename, len);
     705                 :            :                         e += len;
     706                 :            :                 }
     707                 :            :                 if (*vendor_class_identifier) {
     708                 :            :                         pr_info("DHCP: sending class identifier \"%s\"\n",
     709                 :            :                                 vendor_class_identifier);
     710                 :            :                         *e++ = 60;      /* Class-identifier */
     711                 :            :                         len = strlen(vendor_class_identifier);
     712                 :            :                         *e++ = len;
     713                 :            :                         memcpy(e, vendor_class_identifier, len);
     714                 :            :                         e += len;
     715                 :            :                 }
     716                 :            :                 len = strlen(dhcp_client_identifier + 1);
     717                 :            :                 /* the minimum length of identifier is 2, include 1 byte type,
     718                 :            :                  * and can not be larger than the length of options
     719                 :            :                  */
     720                 :            :                 if (len >= 1 && len < 312 - (e - options) - 1) {
     721                 :            :                         *e++ = 61;
     722                 :            :                         *e++ = len + 1;
     723                 :            :                         memcpy(e, dhcp_client_identifier, len + 1);
     724                 :            :                         e += len + 1;
     725                 :            :                 }
     726                 :            :         }
     727                 :            : 
     728                 :            :         *e++ = 255;     /* End of the list */
     729                 :            : }
     730                 :            : 
     731                 :            : #endif /* IPCONFIG_DHCP */
     732                 :            : 
     733                 :          0 : static void __init ic_bootp_init_ext(u8 *e)
     734                 :            : {
     735                 :          0 :         memcpy(e, ic_bootp_cookie, 4);  /* RFC1048 Magic Cookie */
     736                 :          0 :         e += 4;
     737                 :          0 :         *e++ = 1;               /* Subnet mask request */
     738                 :          0 :         *e++ = 4;
     739                 :          0 :         e += 4;
     740                 :          0 :         *e++ = 3;               /* Default gateway request */
     741                 :          0 :         *e++ = 4;
     742                 :          0 :         e += 4;
     743                 :            : #if CONF_NAMESERVERS_MAX > 0
     744                 :          0 :         *e++ = 6;               /* (DNS) name server request */
     745                 :          0 :         *e++ = 4 * CONF_NAMESERVERS_MAX;
     746                 :          0 :         e += 4 * CONF_NAMESERVERS_MAX;
     747                 :            : #endif
     748                 :          0 :         *e++ = 12;              /* Host name request */
     749                 :          0 :         *e++ = 32;
     750                 :          0 :         e += 32;
     751                 :          0 :         *e++ = 40;              /* NIS Domain name request */
     752                 :          0 :         *e++ = 32;
     753                 :          0 :         e += 32;
     754                 :          0 :         *e++ = 17;              /* Boot path */
     755                 :          0 :         *e++ = 40;
     756                 :          0 :         e += 40;
     757                 :            : 
     758                 :          0 :         *e++ = 57;              /* set extension buffer size for reply */
     759                 :          0 :         *e++ = 2;
     760                 :          0 :         *e++ = 1;               /* 128+236+8+20+14, see dhcpd sources */
     761                 :          0 :         *e++ = 150;
     762                 :            : 
     763                 :          0 :         *e++ = 255;             /* End of the list */
     764                 :          0 : }
     765                 :            : 
     766                 :            : 
     767                 :            : /*
     768                 :            :  *  Initialize the DHCP/BOOTP mechanism.
     769                 :            :  */
     770                 :          0 : static inline void __init ic_bootp_init(void)
     771                 :            : {
     772                 :            :         /* Re-initialise all name servers and NTP servers to NONE, in case any
     773                 :            :          * were set via the "ip=" or "nfsaddrs=" kernel command line parameters:
     774                 :            :          * any IP addresses specified there will already have been decoded but
     775                 :            :          * are no longer needed
     776                 :            :          */
     777                 :          0 :         ic_nameservers_predef();
     778                 :          0 :         ic_ntp_servers_predef();
     779                 :            : 
     780                 :          0 :         dev_add_pack(&bootp_packet_type);
     781                 :          0 : }
     782                 :            : 
     783                 :            : 
     784                 :            : /*
     785                 :            :  *  DHCP/BOOTP cleanup.
     786                 :            :  */
     787                 :          0 : static inline void __init ic_bootp_cleanup(void)
     788                 :            : {
     789                 :          0 :         dev_remove_pack(&bootp_packet_type);
     790                 :          0 : }
     791                 :            : 
     792                 :            : 
     793                 :            : /*
     794                 :            :  *  Send DHCP/BOOTP request to single interface.
     795                 :            :  */
     796                 :            : static void __init ic_bootp_send_if(struct ic_device *d, unsigned long jiffies_diff)
     797                 :            : {
     798                 :            :         struct net_device *dev = d->dev;
     799                 :            :         struct sk_buff *skb;
     800                 :            :         struct bootp_pkt *b;
     801                 :            :         struct iphdr *h;
     802                 :            :         int hlen = LL_RESERVED_SPACE(dev);
     803                 :            :         int tlen = dev->needed_tailroom;
     804                 :            : 
     805                 :            :         /* Allocate packet */
     806                 :            :         skb = alloc_skb(sizeof(struct bootp_pkt) + hlen + tlen + 15,
     807                 :            :                         GFP_KERNEL);
     808                 :            :         if (!skb)
     809                 :            :                 return;
     810                 :            :         skb_reserve(skb, hlen);
     811                 :            :         b = skb_put_zero(skb, sizeof(struct bootp_pkt));
     812                 :            : 
     813                 :            :         /* Construct IP header */
     814                 :            :         skb_reset_network_header(skb);
     815                 :            :         h = ip_hdr(skb);
     816                 :            :         h->version = 4;
     817                 :            :         h->ihl = 5;
     818                 :            :         h->tot_len = htons(sizeof(struct bootp_pkt));
     819                 :            :         h->frag_off = htons(IP_DF);
     820                 :            :         h->ttl = 64;
     821                 :            :         h->protocol = IPPROTO_UDP;
     822                 :            :         h->daddr = htonl(INADDR_BROADCAST);
     823                 :            :         h->check = ip_fast_csum((unsigned char *) h, h->ihl);
     824                 :            : 
     825                 :            :         /* Construct UDP header */
     826                 :            :         b->udph.source = htons(68);
     827                 :            :         b->udph.dest = htons(67);
     828                 :            :         b->udph.len = htons(sizeof(struct bootp_pkt) - sizeof(struct iphdr));
     829                 :            :         /* UDP checksum not calculated -- explicitly allowed in BOOTP RFC */
     830                 :            : 
     831                 :            :         /* Construct DHCP/BOOTP header */
     832                 :            :         b->op = BOOTP_REQUEST;
     833                 :            :         if (dev->type < 256) /* check for false types */
     834                 :            :                 b->htype = dev->type;
     835                 :            :         else if (dev->type == ARPHRD_FDDI)
     836                 :            :                 b->htype = ARPHRD_ETHER;
     837                 :            :         else {
     838                 :            :                 pr_warn("Unknown ARP type 0x%04x for device %s\n", dev->type,
     839                 :            :                         dev->name);
     840                 :            :                 b->htype = dev->type; /* can cause undefined behavior */
     841                 :            :         }
     842                 :            : 
     843                 :            :         /* server_ip and your_ip address are both already zero per RFC2131 */
     844                 :            :         b->hlen = dev->addr_len;
     845                 :            :         memcpy(b->hw_addr, dev->dev_addr, dev->addr_len);
     846                 :            :         b->secs = htons(jiffies_diff / HZ);
     847                 :            :         b->xid = d->xid;
     848                 :            : 
     849                 :            :         /* add DHCP options or BOOTP extensions */
     850                 :            : #ifdef IPCONFIG_DHCP
     851                 :            :         if (ic_proto_enabled & IC_USE_DHCP)
     852                 :            :                 ic_dhcp_init_options(b->exten, d);
     853                 :            :         else
     854                 :            : #endif
     855                 :            :                 ic_bootp_init_ext(b->exten);
     856                 :            : 
     857                 :            :         /* Chain packet down the line... */
     858                 :            :         skb->dev = dev;
     859                 :            :         skb->protocol = htons(ETH_P_IP);
     860                 :            :         if (dev_hard_header(skb, dev, ntohs(skb->protocol),
     861                 :            :                             dev->broadcast, dev->dev_addr, skb->len) < 0) {
     862                 :            :                 kfree_skb(skb);
     863                 :            :                 printk("E");
     864                 :            :                 return;
     865                 :            :         }
     866                 :            : 
     867                 :            :         if (dev_queue_xmit(skb) < 0)
     868                 :            :                 printk("E");
     869                 :            : }
     870                 :            : 
     871                 :            : 
     872                 :            : /*
     873                 :            :  *  Copy BOOTP-supplied string if not already set.
     874                 :            :  */
     875                 :          0 : static int __init ic_bootp_string(char *dest, char *src, int len, int max)
     876                 :            : {
     877         [ #  # ]:          0 :         if (!len)
     878                 :            :                 return 0;
     879                 :          0 :         if (len > max-1)
     880                 :            :                 len = max-1;
     881                 :          0 :         memcpy(dest, src, len);
     882                 :          0 :         dest[len] = '\0';
     883                 :          0 :         return 1;
     884                 :            : }
     885                 :            : 
     886                 :            : 
     887                 :            : /*
     888                 :            :  *  Process BOOTP extensions.
     889                 :            :  */
     890                 :          0 : static void __init ic_do_bootp_ext(u8 *ext)
     891                 :            : {
     892                 :          0 :         u8 servers;
     893                 :          0 :         int i;
     894                 :          0 :         __be16 mtu;
     895                 :            : 
     896                 :          0 :         u8 *c;
     897                 :            : 
     898                 :          0 :         pr_debug("DHCP/BOOTP: Got extension %d:", *ext);
     899         [ #  # ]:          0 :         for (c=ext+2; c<ext+2+ext[1]; c++)
     900                 :          0 :                 pr_debug(" %02x", *c);
     901                 :          0 :         pr_debug("\n");
     902                 :            : 
     903   [ #  #  #  #  :          0 :         switch (*ext++) {
          #  #  #  #  #  
                      # ]
     904                 :          0 :         case 1:         /* Subnet mask */
     905         [ #  # ]:          0 :                 if (ic_netmask == NONE)
     906                 :          0 :                         memcpy(&ic_netmask, ext+1, 4);
     907                 :            :                 break;
     908                 :          0 :         case 3:         /* Default gateway */
     909         [ #  # ]:          0 :                 if (ic_gateway == NONE)
     910                 :          0 :                         memcpy(&ic_gateway, ext+1, 4);
     911                 :            :                 break;
     912                 :          0 :         case 6:         /* DNS server */
     913                 :          0 :                 servers= *ext/4;
     914         [ #  # ]:          0 :                 if (servers > CONF_NAMESERVERS_MAX)
     915                 :          0 :                         servers = CONF_NAMESERVERS_MAX;
     916         [ #  # ]:          0 :                 for (i = 0; i < servers; i++) {
     917         [ #  # ]:          0 :                         if (ic_nameservers[i] == NONE)
     918                 :          0 :                                 memcpy(&ic_nameservers[i], ext+1+4*i, 4);
     919                 :            :                 }
     920                 :            :                 break;
     921                 :          0 :         case 12:        /* Host name */
     922                 :          0 :                 ic_bootp_string(utsname()->nodename, ext+1, *ext,
     923                 :            :                                 __NEW_UTS_LEN);
     924                 :          0 :                 ic_host_name_set = 1;
     925                 :          0 :                 break;
     926                 :          0 :         case 15:        /* Domain name (DNS) */
     927                 :          0 :                 ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
     928                 :          0 :                 break;
     929                 :          0 :         case 17:        /* Root path */
     930         [ #  # ]:          0 :                 if (!root_server_path[0])
     931                 :          0 :                         ic_bootp_string(root_server_path, ext+1, *ext,
     932                 :            :                                         sizeof(root_server_path));
     933                 :            :                 break;
     934                 :          0 :         case 26:        /* Interface MTU */
     935                 :          0 :                 memcpy(&mtu, ext+1, sizeof(mtu));
     936                 :          0 :                 ic_dev_mtu = ntohs(mtu);
     937                 :          0 :                 break;
     938                 :          0 :         case 40:        /* NIS Domain name (_not_ DNS) */
     939                 :          0 :                 ic_bootp_string(utsname()->domainname, ext+1, *ext,
     940                 :            :                                 __NEW_UTS_LEN);
     941                 :          0 :                 break;
     942                 :          0 :         case 42:        /* NTP servers */
     943                 :          0 :                 servers = *ext / 4;
     944         [ #  # ]:          0 :                 if (servers > CONF_NTP_SERVERS_MAX)
     945                 :          0 :                         servers = CONF_NTP_SERVERS_MAX;
     946         [ #  # ]:          0 :                 for (i = 0; i < servers; i++) {
     947         [ #  # ]:          0 :                         if (ic_ntp_servers[i] == NONE)
     948                 :          0 :                                 memcpy(&ic_ntp_servers[i], ext+1+4*i, 4);
     949                 :            :                 }
     950                 :            :                 break;
     951                 :            :         }
     952                 :          0 : }
     953                 :            : 
     954                 :            : 
     955                 :            : /*
     956                 :            :  *  Receive BOOTP reply.
     957                 :            :  */
     958                 :          0 : static int __init ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
     959                 :            : {
     960                 :          0 :         struct bootp_pkt *b;
     961                 :          0 :         struct iphdr *h;
     962                 :          0 :         struct ic_device *d;
     963                 :          0 :         int len, ext_len;
     964                 :            : 
     965         [ #  # ]:          0 :         if (!net_eq(dev_net(dev), &init_net))
     966                 :          0 :                 goto drop;
     967                 :            : 
     968                 :            :         /* Perform verifications before taking the lock.  */
     969         [ #  # ]:          0 :         if (skb->pkt_type == PACKET_OTHERHOST)
     970                 :          0 :                 goto drop;
     971                 :            : 
     972                 :          0 :         skb = skb_share_check(skb, GFP_ATOMIC);
     973         [ #  # ]:          0 :         if (!skb)
     974                 :            :                 return NET_RX_DROP;
     975                 :            : 
     976         [ #  # ]:          0 :         if (!pskb_may_pull(skb,
     977                 :            :                            sizeof(struct iphdr) +
     978                 :            :                            sizeof(struct udphdr)))
     979                 :          0 :                 goto drop;
     980                 :            : 
     981         [ #  # ]:          0 :         b = (struct bootp_pkt *)skb_network_header(skb);
     982                 :          0 :         h = &b->iph;
     983                 :            : 
     984   [ #  #  #  # ]:          0 :         if (h->ihl != 5 || h->version != 4 || h->protocol != IPPROTO_UDP)
     985                 :          0 :                 goto drop;
     986                 :            : 
     987                 :            :         /* Fragments are not supported */
     988         [ #  # ]:          0 :         if (ip_is_fragment(h)) {
     989         [ #  # ]:          0 :                 net_err_ratelimited("DHCP/BOOTP: Ignoring fragmented reply\n");
     990                 :          0 :                 goto drop;
     991                 :            :         }
     992                 :            : 
     993         [ #  # ]:          0 :         if (skb->len < ntohs(h->tot_len))
     994                 :          0 :                 goto drop;
     995                 :            : 
     996         [ #  # ]:          0 :         if (ip_fast_csum((char *) h, h->ihl))
     997                 :          0 :                 goto drop;
     998                 :            : 
     999         [ #  # ]:          0 :         if (b->udph.source != htons(67) || b->udph.dest != htons(68))
    1000                 :          0 :                 goto drop;
    1001                 :            : 
    1002         [ #  # ]:          0 :         if (ntohs(h->tot_len) < ntohs(b->udph.len) + sizeof(struct iphdr))
    1003                 :          0 :                 goto drop;
    1004                 :            : 
    1005                 :          0 :         len = ntohs(b->udph.len) - sizeof(struct udphdr);
    1006                 :          0 :         ext_len = len - (sizeof(*b) -
    1007                 :            :                          sizeof(struct iphdr) -
    1008                 :            :                          sizeof(struct udphdr) -
    1009                 :            :                          sizeof(b->exten));
    1010         [ #  # ]:          0 :         if (ext_len < 0)
    1011                 :          0 :                 goto drop;
    1012                 :            : 
    1013                 :            :         /* Ok the front looks good, make sure we can get at the rest.  */
    1014         [ #  # ]:          0 :         if (!pskb_may_pull(skb, skb->len))
    1015                 :          0 :                 goto drop;
    1016                 :            : 
    1017                 :          0 :         b = (struct bootp_pkt *)skb_network_header(skb);
    1018                 :          0 :         h = &b->iph;
    1019                 :            : 
    1020                 :            :         /* One reply at a time, please. */
    1021                 :          0 :         spin_lock(&ic_recv_lock);
    1022                 :            : 
    1023                 :            :         /* If we already have a reply, just drop the packet */
    1024         [ #  # ]:          0 :         if (ic_got_reply)
    1025                 :          0 :                 goto drop_unlock;
    1026                 :            : 
    1027                 :            :         /* Find the ic_device that the packet arrived on */
    1028                 :          0 :         d = ic_first_dev;
    1029   [ #  #  #  # ]:          0 :         while (d && d->dev != dev)
    1030                 :          0 :                 d = d->next;
    1031         [ #  # ]:          0 :         if (!d)
    1032                 :          0 :                 goto drop_unlock;  /* should never happen */
    1033                 :            : 
    1034                 :            :         /* Is it a reply to our BOOTP request? */
    1035         [ #  # ]:          0 :         if (b->op != BOOTP_REPLY ||
    1036         [ #  # ]:          0 :             b->xid != d->xid) {
    1037         [ #  # ]:          0 :                 net_err_ratelimited("DHCP/BOOTP: Reply not for us on %s, op[%x] xid[%x]\n",
    1038                 :            :                                     d->dev->name, b->op, b->xid);
    1039                 :          0 :                 goto drop_unlock;
    1040                 :            :         }
    1041                 :            : 
    1042                 :            :         /* Parse extensions */
    1043         [ #  # ]:          0 :         if (ext_len >= 4 &&
    1044         [ #  # ]:          0 :             !memcmp(b->exten, ic_bootp_cookie, 4)) { /* Check magic cookie */
    1045                 :          0 :                 u8 *end = (u8 *) b + ntohs(b->iph.tot_len);
    1046                 :          0 :                 u8 *ext;
    1047                 :            : 
    1048                 :            : #ifdef IPCONFIG_DHCP
    1049         [ #  # ]:          0 :                 if (ic_proto_enabled & IC_USE_DHCP) {
    1050                 :          0 :                         __be32 server_id = NONE;
    1051                 :          0 :                         int mt = 0;
    1052                 :            : 
    1053                 :          0 :                         ext = &b->exten[4];
    1054   [ #  #  #  # ]:          0 :                         while (ext < end && *ext != 0xff) {
    1055                 :          0 :                                 u8 *opt = ext++;
    1056         [ #  # ]:          0 :                                 if (*opt == 0)  /* Padding */
    1057                 :          0 :                                         continue;
    1058                 :          0 :                                 ext += *ext + 1;
    1059         [ #  # ]:          0 :                                 if (ext >= end)
    1060                 :            :                                         break;
    1061      [ #  #  # ]:          0 :                                 switch (*opt) {
    1062                 :          0 :                                 case 53:        /* Message type */
    1063         [ #  # ]:          0 :                                         if (opt[1])
    1064                 :          0 :                                                 mt = opt[2];
    1065                 :            :                                         break;
    1066                 :          0 :                                 case 54:        /* Server ID (IP address) */
    1067         [ #  # ]:          0 :                                         if (opt[1] >= 4)
    1068                 :          0 :                                                 memcpy(&server_id, opt + 2, 4);
    1069                 :            :                                         break;
    1070                 :            :                                 }
    1071                 :            :                         }
    1072                 :            : 
    1073                 :          0 :                         pr_debug("DHCP: Got message type %d (%s)\n", mt, d->dev->name);
    1074                 :            : 
    1075      [ #  #  # ]:          0 :                         switch (mt) {
    1076                 :          0 :                         case DHCPOFFER:
    1077                 :            :                                 /* While in the process of accepting one offer,
    1078                 :            :                                  * ignore all others.
    1079                 :            :                                  */
    1080         [ #  # ]:          0 :                                 if (ic_myaddr != NONE)
    1081                 :          0 :                                         goto drop_unlock;
    1082                 :            : 
    1083                 :            :                                 /* Let's accept that offer. */
    1084                 :          0 :                                 ic_myaddr = b->your_ip;
    1085                 :          0 :                                 ic_servaddr = server_id;
    1086                 :          0 :                                 pr_debug("DHCP: Offered address %pI4 by server %pI4\n",
    1087                 :            :                                          &ic_myaddr, &b->iph.saddr);
    1088                 :            :                                 /* The DHCP indicated server address takes
    1089                 :            :                                  * precedence over the bootp header one if
    1090                 :            :                                  * they are different.
    1091                 :            :                                  */
    1092         [ #  # ]:          0 :                                 if ((server_id != NONE) &&
    1093         [ #  # ]:          0 :                                     (b->server_ip != server_id))
    1094                 :          0 :                                         b->server_ip = ic_servaddr;
    1095                 :            :                                 break;
    1096                 :            : 
    1097                 :          0 :                         case DHCPACK:
    1098         [ #  # ]:          0 :                                 if (memcmp(dev->dev_addr, b->hw_addr, dev->addr_len) != 0)
    1099                 :          0 :                                         goto drop_unlock;
    1100                 :            : 
    1101                 :            :                                 /* Yeah! */
    1102                 :            :                                 break;
    1103                 :            : 
    1104                 :          0 :                         default:
    1105                 :            :                                 /* Urque.  Forget it*/
    1106                 :          0 :                                 ic_myaddr = NONE;
    1107                 :          0 :                                 ic_servaddr = NONE;
    1108                 :          0 :                                 goto drop_unlock;
    1109                 :            :                         }
    1110                 :            : 
    1111                 :          0 :                         ic_dhcp_msgtype = mt;
    1112                 :            : 
    1113                 :            :                 }
    1114                 :            : #endif /* IPCONFIG_DHCP */
    1115                 :            : 
    1116                 :          0 :                 ext = &b->exten[4];
    1117   [ #  #  #  # ]:          0 :                 while (ext < end && *ext != 0xff) {
    1118                 :          0 :                         u8 *opt = ext++;
    1119         [ #  # ]:          0 :                         if (*opt == 0)  /* Padding */
    1120                 :          0 :                                 continue;
    1121                 :          0 :                         ext += *ext + 1;
    1122         [ #  # ]:          0 :                         if (ext < end)
    1123                 :          0 :                                 ic_do_bootp_ext(opt);
    1124                 :            :                 }
    1125                 :            :         }
    1126                 :            : 
    1127                 :            :         /* We have a winner! */
    1128                 :          0 :         ic_dev = d;
    1129                 :          0 :         ic_myaddr = b->your_ip;
    1130                 :          0 :         ic_servaddr = b->server_ip;
    1131                 :          0 :         ic_addrservaddr = b->iph.saddr;
    1132   [ #  #  #  # ]:          0 :         if (ic_gateway == NONE && b->relay_ip)
    1133                 :          0 :                 ic_gateway = b->relay_ip;
    1134         [ #  # ]:          0 :         if (ic_nameservers[0] == NONE)
    1135                 :          0 :                 ic_nameservers[0] = ic_servaddr;
    1136                 :          0 :         ic_got_reply = IC_BOOTP;
    1137                 :            : 
    1138                 :          0 : drop_unlock:
    1139                 :            :         /* Show's over.  Nothing to see here.  */
    1140                 :          0 :         spin_unlock(&ic_recv_lock);
    1141                 :            : 
    1142                 :          0 : drop:
    1143                 :            :         /* Throw the packet out. */
    1144                 :          0 :         kfree_skb(skb);
    1145                 :            : 
    1146                 :          0 :         return 0;
    1147                 :            : }
    1148                 :            : 
    1149                 :            : 
    1150                 :            : #endif
    1151                 :            : 
    1152                 :            : 
    1153                 :            : /*
    1154                 :            :  *      Dynamic IP configuration -- DHCP, BOOTP, RARP.
    1155                 :            :  */
    1156                 :            : 
    1157                 :            : #ifdef IPCONFIG_DYNAMIC
    1158                 :            : 
    1159                 :          0 : static int __init ic_dynamic(void)
    1160                 :            : {
    1161                 :          0 :         int retries;
    1162                 :          0 :         struct ic_device *d;
    1163                 :          0 :         unsigned long start_jiffies, timeout, jiff;
    1164                 :          0 :         int do_bootp = ic_proto_have_if & IC_BOOTP;
    1165                 :          0 :         int do_rarp = ic_proto_have_if & IC_RARP;
    1166                 :            : 
    1167                 :            :         /*
    1168                 :            :          * If none of DHCP/BOOTP/RARP was selected, return with an error.
    1169                 :            :          * This routine gets only called when some pieces of information
    1170                 :            :          * are missing, and without DHCP/BOOTP/RARP we are unable to get it.
    1171                 :            :          */
    1172         [ #  # ]:          0 :         if (!ic_proto_enabled) {
    1173                 :          0 :                 pr_err("IP-Config: Incomplete network configuration information\n");
    1174                 :          0 :                 return -1;
    1175                 :            :         }
    1176                 :            : 
    1177                 :            : #ifdef IPCONFIG_BOOTP
    1178         [ #  # ]:          0 :         if ((ic_proto_enabled ^ ic_proto_have_if) & IC_BOOTP)
    1179                 :          0 :                 pr_err("DHCP/BOOTP: No suitable device found\n");
    1180                 :            : #endif
    1181                 :            : #ifdef IPCONFIG_RARP
    1182         [ #  # ]:          0 :         if ((ic_proto_enabled ^ ic_proto_have_if) & IC_RARP)
    1183                 :          0 :                 pr_err("RARP: No suitable device found\n");
    1184                 :            : #endif
    1185                 :            : 
    1186         [ #  # ]:          0 :         if (!ic_proto_have_if)
    1187                 :            :                 /* Error message already printed */
    1188                 :            :                 return -1;
    1189                 :            : 
    1190                 :            :         /*
    1191                 :            :          * Setup protocols
    1192                 :            :          */
    1193                 :            : #ifdef IPCONFIG_BOOTP
    1194         [ #  # ]:          0 :         if (do_bootp)
    1195                 :          0 :                 ic_bootp_init();
    1196                 :            : #endif
    1197                 :            : #ifdef IPCONFIG_RARP
    1198         [ #  # ]:          0 :         if (do_rarp)
    1199                 :          0 :                 ic_rarp_init();
    1200                 :            : #endif
    1201                 :            : 
    1202                 :            :         /*
    1203                 :            :          * Send requests and wait, until we get an answer. This loop
    1204                 :            :          * seems to be a terrible waste of CPU time, but actually there is
    1205                 :            :          * only one process running at all, so we don't need to use any
    1206                 :            :          * scheduler functions.
    1207                 :            :          * [Actually we could now, but the nothing else running note still
    1208                 :            :          *  applies.. - AC]
    1209                 :            :          */
    1210   [ #  #  #  #  :          0 :         pr_notice("Sending %s%s%s requests .",
             #  #  #  # ]
    1211                 :            :                   do_bootp
    1212                 :            :                   ? ((ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP") : "",
    1213                 :            :                   (do_bootp && do_rarp) ? " and " : "",
    1214                 :            :                   do_rarp ? "RARP" : "");
    1215                 :            : 
    1216                 :          0 :         start_jiffies = jiffies;
    1217                 :          0 :         d = ic_first_dev;
    1218                 :          0 :         retries = CONF_SEND_RETRIES;
    1219                 :          0 :         get_random_bytes(&timeout, sizeof(timeout));
    1220                 :          0 :         timeout = CONF_BASE_TIMEOUT + (timeout % (unsigned int) CONF_TIMEOUT_RANDOM);
    1221                 :          0 :         for (;;) {
    1222                 :            : #ifdef IPCONFIG_BOOTP
    1223   [ #  #  #  # ]:          0 :                 if (do_bootp && (d->able & IC_BOOTP))
    1224                 :          0 :                         ic_bootp_send_if(d, jiffies - start_jiffies);
    1225                 :            : #endif
    1226                 :            : #ifdef IPCONFIG_RARP
    1227   [ #  #  #  # ]:          0 :                 if (do_rarp && (d->able & IC_RARP))
    1228                 :          0 :                         ic_rarp_send_if(d);
    1229                 :            : #endif
    1230                 :            : 
    1231         [ #  # ]:          0 :                 if (!d->next) {
    1232                 :          0 :                         jiff = jiffies + timeout;
    1233   [ #  #  #  # ]:          0 :                         while (time_before(jiffies, jiff) && !ic_got_reply)
    1234                 :          0 :                                 schedule_timeout_uninterruptible(1);
    1235                 :            :                 }
    1236                 :            : #ifdef IPCONFIG_DHCP
    1237                 :            :                 /* DHCP isn't done until we get a DHCPACK. */
    1238         [ #  # ]:          0 :                 if ((ic_got_reply & IC_BOOTP) &&
    1239         [ #  # ]:          0 :                     (ic_proto_enabled & IC_USE_DHCP) &&
    1240         [ #  # ]:          0 :                     ic_dhcp_msgtype != DHCPACK) {
    1241                 :          0 :                         ic_got_reply = 0;
    1242                 :            :                         /* continue on device that got the reply */
    1243                 :          0 :                         d = ic_dev;
    1244                 :          0 :                         pr_cont(",");
    1245                 :          0 :                         continue;
    1246                 :            :                 }
    1247                 :            : #endif /* IPCONFIG_DHCP */
    1248                 :            : 
    1249         [ #  # ]:          0 :                 if (ic_got_reply) {
    1250                 :          0 :                         pr_cont(" OK\n");
    1251                 :          0 :                         break;
    1252                 :            :                 }
    1253                 :            : 
    1254         [ #  # ]:          0 :                 if ((d = d->next))
    1255                 :          0 :                         continue;
    1256                 :            : 
    1257         [ #  # ]:          0 :                 if (! --retries) {
    1258                 :          0 :                         pr_cont(" timed out!\n");
    1259                 :          0 :                         break;
    1260                 :            :                 }
    1261                 :            : 
    1262                 :          0 :                 d = ic_first_dev;
    1263                 :            : 
    1264                 :          0 :                 timeout = timeout CONF_TIMEOUT_MULT;
    1265         [ #  # ]:          0 :                 if (timeout > CONF_TIMEOUT_MAX)
    1266                 :          0 :                         timeout = CONF_TIMEOUT_MAX;
    1267                 :            : 
    1268                 :          0 :                 pr_cont(".");
    1269                 :            :         }
    1270                 :            : 
    1271                 :            : #ifdef IPCONFIG_BOOTP
    1272         [ #  # ]:          0 :         if (do_bootp)
    1273                 :          0 :                 ic_bootp_cleanup();
    1274                 :            : #endif
    1275                 :            : #ifdef IPCONFIG_RARP
    1276         [ #  # ]:          0 :         if (do_rarp)
    1277                 :          0 :                 ic_rarp_cleanup();
    1278                 :            : #endif
    1279                 :            : 
    1280         [ #  # ]:          0 :         if (!ic_got_reply) {
    1281                 :          0 :                 ic_myaddr = NONE;
    1282                 :          0 :                 return -1;
    1283                 :            :         }
    1284                 :            : 
    1285   [ #  #  #  # ]:          0 :         pr_info("IP-Config: Got %s answer from %pI4, my address is %pI4\n",
    1286                 :            :                 ((ic_got_reply & IC_RARP) ? "RARP"
    1287                 :            :                 : (ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP"),
    1288                 :            :                 &ic_addrservaddr, &ic_myaddr);
    1289                 :            : 
    1290                 :          0 :         return 0;
    1291                 :            : }
    1292                 :            : 
    1293                 :            : #endif /* IPCONFIG_DYNAMIC */
    1294                 :            : 
    1295                 :            : #ifdef CONFIG_PROC_FS
    1296                 :            : /* proc_dir_entry for /proc/net/ipconfig */
    1297                 :            : static struct proc_dir_entry *ipconfig_dir;
    1298                 :            : 
    1299                 :            : /* Name servers: */
    1300                 :          0 : static int pnp_seq_show(struct seq_file *seq, void *v)
    1301                 :            : {
    1302                 :          0 :         int i;
    1303                 :            : 
    1304         [ #  # ]:          0 :         if (ic_proto_used & IC_PROTO)
    1305                 :          0 :                 seq_printf(seq, "#PROTO: %s\n",
    1306         [ #  # ]:          0 :                            (ic_proto_used & IC_RARP) ? "RARP"
    1307         [ #  # ]:          0 :                            : (ic_proto_used & IC_USE_DHCP) ? "DHCP" : "BOOTP");
    1308                 :            :         else
    1309                 :          0 :                 seq_puts(seq, "#MANUAL\n");
    1310                 :            : 
    1311         [ #  # ]:          0 :         if (ic_domain[0])
    1312                 :          0 :                 seq_printf(seq,
    1313                 :            :                            "domain %s\n", ic_domain);
    1314         [ #  # ]:          0 :         for (i = 0; i < CONF_NAMESERVERS_MAX; i++) {
    1315         [ #  # ]:          0 :                 if (ic_nameservers[i] != NONE)
    1316                 :          0 :                         seq_printf(seq, "nameserver %pI4\n",
    1317                 :            :                                    &ic_nameservers[i]);
    1318                 :            :         }
    1319         [ #  # ]:          0 :         if (ic_servaddr != NONE)
    1320                 :          0 :                 seq_printf(seq, "bootserver %pI4\n",
    1321                 :            :                            &ic_servaddr);
    1322                 :          0 :         return 0;
    1323                 :            : }
    1324                 :            : 
    1325                 :            : /* Create the /proc/net/ipconfig directory */
    1326                 :          3 : static int __init ipconfig_proc_net_init(void)
    1327                 :            : {
    1328                 :          3 :         ipconfig_dir = proc_net_mkdir(&init_net, "ipconfig", init_net.proc_net);
    1329         [ -  + ]:          3 :         if (!ipconfig_dir)
    1330                 :          0 :                 return -ENOMEM;
    1331                 :            : 
    1332                 :            :         return 0;
    1333                 :            : }
    1334                 :            : 
    1335                 :            : /* Create a new file under /proc/net/ipconfig */
    1336                 :          3 : static int ipconfig_proc_net_create(const char *name,
    1337                 :            :                                     const struct proc_ops *proc_ops)
    1338                 :            : {
    1339                 :          3 :         char *pname;
    1340                 :          3 :         struct proc_dir_entry *p;
    1341                 :            : 
    1342         [ +  - ]:          3 :         if (!ipconfig_dir)
    1343                 :            :                 return -ENOMEM;
    1344                 :            : 
    1345                 :          3 :         pname = kasprintf(GFP_KERNEL, "%s%s", "ipconfig/", name);
    1346         [ +  - ]:          3 :         if (!pname)
    1347                 :            :                 return -ENOMEM;
    1348                 :            : 
    1349                 :          3 :         p = proc_create(pname, 0444, init_net.proc_net, proc_ops);
    1350                 :          3 :         kfree(pname);
    1351         [ -  + ]:          3 :         if (!p)
    1352                 :          0 :                 return -ENOMEM;
    1353                 :            : 
    1354                 :            :         return 0;
    1355                 :            : }
    1356                 :            : 
    1357                 :            : /* Write NTP server IP addresses to /proc/net/ipconfig/ntp_servers */
    1358                 :          0 : static int ntp_servers_show(struct seq_file *seq, void *v)
    1359                 :            : {
    1360                 :          0 :         int i;
    1361                 :            : 
    1362         [ #  # ]:          0 :         for (i = 0; i < CONF_NTP_SERVERS_MAX; i++) {
    1363         [ #  # ]:          0 :                 if (ic_ntp_servers[i] != NONE)
    1364                 :          0 :                         seq_printf(seq, "%pI4\n", &ic_ntp_servers[i]);
    1365                 :            :         }
    1366                 :          0 :         return 0;
    1367                 :            : }
    1368                 :          0 : DEFINE_PROC_SHOW_ATTRIBUTE(ntp_servers);
    1369                 :            : #endif /* CONFIG_PROC_FS */
    1370                 :            : 
    1371                 :            : /*
    1372                 :            :  *  Extract IP address from the parameter string if needed. Note that we
    1373                 :            :  *  need to have root_server_addr set _before_ IPConfig gets called as it
    1374                 :            :  *  can override it.
    1375                 :            :  */
    1376                 :          0 : __be32 __init root_nfs_parse_addr(char *name)
    1377                 :            : {
    1378                 :          0 :         __be32 addr;
    1379                 :          0 :         int octets = 0;
    1380                 :          0 :         char *cp, *cq;
    1381                 :            : 
    1382                 :          0 :         cp = cq = name;
    1383         [ #  # ]:          0 :         while (octets < 4) {
    1384         [ #  # ]:          0 :                 while (*cp >= '0' && *cp <= '9')
    1385                 :          0 :                         cp++;
    1386   [ #  #  #  # ]:          0 :                 if (cp == cq || cp - cq > 3)
    1387                 :            :                         break;
    1388   [ #  #  #  # ]:          0 :                 if (*cp == '.' || octets == 3)
    1389                 :          0 :                         octets++;
    1390         [ #  # ]:          0 :                 if (octets < 4)
    1391                 :          0 :                         cp++;
    1392                 :            :                 cq = cp;
    1393                 :            :         }
    1394   [ #  #  #  # ]:          0 :         if (octets == 4 && (*cp == ':' || *cp == '\0')) {
    1395         [ #  # ]:          0 :                 if (*cp == ':')
    1396                 :          0 :                         *cp++ = '\0';
    1397                 :          0 :                 addr = in_aton(name);
    1398                 :          0 :                 memmove(name, cp, strlen(cp) + 1);
    1399                 :            :         } else
    1400                 :            :                 addr = NONE;
    1401                 :            : 
    1402                 :          0 :         return addr;
    1403                 :            : }
    1404                 :            : 
    1405                 :            : #define DEVICE_WAIT_MAX         12 /* 12 seconds */
    1406                 :            : 
    1407                 :          0 : static int __init wait_for_devices(void)
    1408                 :            : {
    1409                 :          0 :         int i;
    1410                 :            : 
    1411         [ #  # ]:          0 :         for (i = 0; i < DEVICE_WAIT_MAX; i++) {
    1412                 :          0 :                 struct net_device *dev;
    1413                 :          0 :                 int found = 0;
    1414                 :            : 
    1415                 :            :                 /* make sure deferred device probes are finished */
    1416                 :          0 :                 wait_for_device_probe();
    1417                 :            : 
    1418                 :          0 :                 rtnl_lock();
    1419         [ #  # ]:          0 :                 for_each_netdev(&init_net, dev) {
    1420         [ #  # ]:          0 :                         if (ic_is_init_dev(dev)) {
    1421                 :            :                                 found = 1;
    1422                 :            :                                 break;
    1423                 :            :                         }
    1424                 :            :                 }
    1425                 :          0 :                 rtnl_unlock();
    1426         [ #  # ]:          0 :                 if (found)
    1427                 :            :                         return 0;
    1428                 :          0 :                 ssleep(1);
    1429                 :            :         }
    1430                 :            :         return -ENODEV;
    1431                 :            : }
    1432                 :            : 
    1433                 :            : /*
    1434                 :            :  *      IP Autoconfig dispatcher.
    1435                 :            :  */
    1436                 :            : 
    1437                 :          3 : static int __init ip_auto_config(void)
    1438                 :            : {
    1439                 :          3 :         __be32 addr;
    1440                 :            : #ifdef IPCONFIG_DYNAMIC
    1441                 :          3 :         int retries = CONF_OPEN_RETRIES;
    1442                 :            : #endif
    1443                 :          3 :         int err;
    1444                 :          3 :         unsigned int i;
    1445                 :            : 
    1446                 :            :         /* Initialise all name servers and NTP servers to NONE (but only if the
    1447                 :            :          * "ip=" or "nfsaddrs=" kernel command line parameters weren't decoded,
    1448                 :            :          * otherwise we'll overwrite the IP addresses specified there)
    1449                 :            :          */
    1450         [ +  - ]:          3 :         if (ic_set_manually == 0) {
    1451                 :          3 :                 ic_nameservers_predef();
    1452                 :          3 :                 ic_ntp_servers_predef();
    1453                 :            :         }
    1454                 :            : 
    1455                 :            : #ifdef CONFIG_PROC_FS
    1456                 :          3 :         proc_create_single("pnp", 0444, init_net.proc_net, pnp_seq_show);
    1457                 :            : 
    1458         [ +  - ]:          3 :         if (ipconfig_proc_net_init() == 0)
    1459                 :          3 :                 ipconfig_proc_net_create("ntp_servers", &ntp_servers_proc_ops);
    1460                 :            : #endif /* CONFIG_PROC_FS */
    1461                 :            : 
    1462         [ -  + ]:          3 :         if (!ic_enable)
    1463                 :            :                 return 0;
    1464                 :            : 
    1465                 :            :         pr_debug("IP-Config: Entered.\n");
    1466                 :            : #ifdef IPCONFIG_DYNAMIC
    1467                 :            :  try_try_again:
    1468                 :            : #endif
    1469                 :            :         /* Wait for devices to appear */
    1470                 :          0 :         err = wait_for_devices();
    1471         [ #  # ]:          0 :         if (err)
    1472                 :          0 :                 return err;
    1473                 :            : 
    1474                 :            :         /* Setup all network devices */
    1475                 :          0 :         err = ic_open_devs();
    1476         [ #  # ]:          0 :         if (err)
    1477                 :          0 :                 return err;
    1478                 :            : 
    1479                 :            :         /* Give drivers a chance to settle */
    1480                 :          0 :         msleep(CONF_POST_OPEN);
    1481                 :            : 
    1482                 :            :         /*
    1483                 :            :          * If the config information is insufficient (e.g., our IP address or
    1484                 :            :          * IP address of the boot server is missing or we have multiple network
    1485                 :            :          * interfaces and no default was set), use BOOTP or RARP to get the
    1486                 :            :          * missing values.
    1487                 :            :          */
    1488         [ #  # ]:          0 :         if (ic_myaddr == NONE ||
    1489                 :            : #if defined(CONFIG_ROOT_NFS) || defined(CONFIG_CIFS_ROOT)
    1490         [ #  # ]:          0 :             (root_server_addr == NONE &&
    1491         [ #  # ]:          0 :              ic_servaddr == NONE &&
    1492         [ #  # ]:          0 :              (ROOT_DEV == Root_NFS || ROOT_DEV == Root_CIFS)) ||
    1493                 :            : #endif
    1494         [ #  # ]:          0 :             ic_first_dev->next) {
    1495                 :            : #ifdef IPCONFIG_DYNAMIC
    1496         [ #  # ]:          0 :                 if (ic_dynamic() < 0) {
    1497                 :          0 :                         ic_close_devs();
    1498                 :            : 
    1499                 :            :                         /*
    1500                 :            :                          * I don't know why, but sometimes the
    1501                 :            :                          * eepro100 driver (at least) gets upset and
    1502                 :            :                          * doesn't work the first time it's opened.
    1503                 :            :                          * But then if you close it and reopen it, it
    1504                 :            :                          * works just fine.  So we need to try that at
    1505                 :            :                          * least once before giving up.
    1506                 :            :                          *
    1507                 :            :                          * Also, if the root will be NFS-mounted, we
    1508                 :            :                          * have nowhere to go if DHCP fails.  So we
    1509                 :            :                          * just have to keep trying forever.
    1510                 :            :                          *
    1511                 :            :                          *                              -- Chip
    1512                 :            :                          */
    1513                 :            : #ifdef CONFIG_ROOT_NFS
    1514         [ #  # ]:          0 :                         if (ROOT_DEV ==  Root_NFS) {
    1515                 :          0 :                                 pr_err("IP-Config: Retrying forever (NFS root)...\n");
    1516                 :          0 :                                 goto try_try_again;
    1517                 :            :                         }
    1518                 :            : #endif
    1519                 :            : #ifdef CONFIG_CIFS_ROOT
    1520                 :            :                         if (ROOT_DEV == Root_CIFS) {
    1521                 :            :                                 pr_err("IP-Config: Retrying forever (CIFS root)...\n");
    1522                 :            :                                 goto try_try_again;
    1523                 :            :                         }
    1524                 :            : #endif
    1525                 :            : 
    1526         [ #  # ]:          0 :                         if (--retries) {
    1527                 :          0 :                                 pr_err("IP-Config: Reopening network devices...\n");
    1528                 :          0 :                                 goto try_try_again;
    1529                 :            :                         }
    1530                 :            : 
    1531                 :            :                         /* Oh, well.  At least we tried. */
    1532                 :          0 :                         pr_err("IP-Config: Auto-configuration of network failed\n");
    1533                 :          0 :                         return -1;
    1534                 :            :                 }
    1535                 :            : #else /* !DYNAMIC */
    1536                 :            :                 pr_err("IP-Config: Incomplete network configuration information\n");
    1537                 :            :                 ic_close_devs();
    1538                 :            :                 return -1;
    1539                 :            : #endif /* IPCONFIG_DYNAMIC */
    1540                 :            :         } else {
    1541                 :            :                 /* Device selected manually or only one device -> use it */
    1542                 :          0 :                 ic_dev = ic_first_dev;
    1543                 :            :         }
    1544                 :            : 
    1545                 :          0 :         addr = root_nfs_parse_addr(root_server_path);
    1546         [ #  # ]:          0 :         if (root_server_addr == NONE)
    1547                 :          0 :                 root_server_addr = addr;
    1548                 :            : 
    1549                 :            :         /*
    1550                 :            :          * Use defaults wherever applicable.
    1551                 :            :          */
    1552         [ #  # ]:          0 :         if (ic_defaults() < 0)
    1553                 :            :                 return -1;
    1554                 :            : 
    1555                 :            :         /*
    1556                 :            :          * Record which protocol was actually used.
    1557                 :            :          */
    1558                 :            : #ifdef IPCONFIG_DYNAMIC
    1559                 :          0 :         ic_proto_used = ic_got_reply | (ic_proto_enabled & IC_USE_DHCP);
    1560                 :            : #endif
    1561                 :            : 
    1562                 :            : #ifndef IPCONFIG_SILENT
    1563                 :            :         /*
    1564                 :            :          * Clue in the operator.
    1565                 :            :          */
    1566                 :          0 :         pr_info("IP-Config: Complete:\n");
    1567                 :            : 
    1568                 :          0 :         pr_info("     device=%s, hwaddr=%*phC, ipaddr=%pI4, mask=%pI4, gw=%pI4\n",
    1569                 :            :                 ic_dev->dev->name, ic_dev->dev->addr_len, ic_dev->dev->dev_addr,
    1570                 :            :                 &ic_myaddr, &ic_netmask, &ic_gateway);
    1571                 :          0 :         pr_info("     host=%s, domain=%s, nis-domain=%s\n",
    1572                 :            :                 utsname()->nodename, ic_domain, utsname()->domainname);
    1573                 :          0 :         pr_info("     bootserver=%pI4, rootserver=%pI4, rootpath=%s",
    1574                 :            :                 &ic_servaddr, &root_server_addr, root_server_path);
    1575         [ #  # ]:          0 :         if (ic_dev_mtu)
    1576                 :          0 :                 pr_cont(", mtu=%d", ic_dev_mtu);
    1577                 :            :         /* Name servers (if any): */
    1578         [ #  # ]:          0 :         for (i = 0; i < CONF_NAMESERVERS_MAX; i++) {
    1579         [ #  # ]:          0 :                 if (ic_nameservers[i] != NONE) {
    1580         [ #  # ]:          0 :                         if (i == 0)
    1581                 :          0 :                                 pr_info("     nameserver%u=%pI4",
    1582                 :            :                                         i, &ic_nameservers[i]);
    1583                 :            :                         else
    1584                 :          0 :                                 pr_cont(", nameserver%u=%pI4",
    1585                 :            :                                         i, &ic_nameservers[i]);
    1586                 :            :                 }
    1587         [ #  # ]:          0 :                 if (i + 1 == CONF_NAMESERVERS_MAX)
    1588                 :          0 :                         pr_cont("\n");
    1589                 :            :         }
    1590                 :            :         /* NTP servers (if any): */
    1591         [ #  # ]:          0 :         for (i = 0; i < CONF_NTP_SERVERS_MAX; i++) {
    1592         [ #  # ]:          0 :                 if (ic_ntp_servers[i] != NONE) {
    1593         [ #  # ]:          0 :                         if (i == 0)
    1594                 :          0 :                                 pr_info("     ntpserver%u=%pI4",
    1595                 :            :                                         i, &ic_ntp_servers[i]);
    1596                 :            :                         else
    1597                 :          0 :                                 pr_cont(", ntpserver%u=%pI4",
    1598                 :            :                                         i, &ic_ntp_servers[i]);
    1599                 :            :                 }
    1600         [ #  # ]:          0 :                 if (i + 1 == CONF_NTP_SERVERS_MAX)
    1601                 :          0 :                         pr_cont("\n");
    1602                 :            :         }
    1603                 :            : #endif /* !SILENT */
    1604                 :            : 
    1605                 :            :         /*
    1606                 :            :          * Close all network devices except the device we've
    1607                 :            :          * autoconfigured and set up routes.
    1608                 :            :          */
    1609   [ #  #  #  # ]:          0 :         if (ic_setup_if() < 0 || ic_setup_routes() < 0)
    1610                 :            :                 err = -1;
    1611                 :            :         else
    1612                 :            :                 err = 0;
    1613                 :            : 
    1614                 :          0 :         ic_close_devs();
    1615                 :            : 
    1616                 :          0 :         return err;
    1617                 :            : }
    1618                 :            : 
    1619                 :            : late_initcall(ip_auto_config);
    1620                 :            : 
    1621                 :            : 
    1622                 :            : /*
    1623                 :            :  *  Decode any IP configuration options in the "ip=" or "nfsaddrs=" kernel
    1624                 :            :  *  command line parameter.  See Documentation/filesystems/nfs/nfsroot.txt.
    1625                 :            :  */
    1626                 :          0 : static int __init ic_proto_name(char *name)
    1627                 :            : {
    1628   [ #  #  #  # ]:          0 :         if (!strcmp(name, "on") || !strcmp(name, "any")) {
    1629                 :            :                 return 1;
    1630                 :            :         }
    1631   [ #  #  #  # ]:          0 :         if (!strcmp(name, "off") || !strcmp(name, "none")) {
    1632                 :            :                 return 0;
    1633                 :            :         }
    1634                 :            : #ifdef CONFIG_IP_PNP_DHCP
    1635         [ #  # ]:          0 :         else if (!strncmp(name, "dhcp", 4)) {
    1636                 :          0 :                 char *client_id;
    1637                 :            : 
    1638                 :          0 :                 ic_proto_enabled &= ~IC_RARP;
    1639                 :          0 :                 client_id = strstr(name, "dhcp,");
    1640         [ #  # ]:          0 :                 if (client_id) {
    1641                 :          0 :                         char *v;
    1642                 :            : 
    1643                 :          0 :                         client_id = client_id + 5;
    1644                 :          0 :                         v = strchr(client_id, ',');
    1645         [ #  # ]:          0 :                         if (!v)
    1646                 :            :                                 return 1;
    1647                 :          0 :                         *v = 0;
    1648                 :          0 :                         if (kstrtou8(client_id, 0, dhcp_client_identifier))
    1649                 :            :                                 pr_debug("DHCP: Invalid client identifier type\n");
    1650                 :          0 :                         strncpy(dhcp_client_identifier + 1, v + 1, 251);
    1651                 :          0 :                         *v = ',';
    1652                 :            :                 }
    1653                 :          0 :                 return 1;
    1654                 :            :         }
    1655                 :            : #endif
    1656                 :            : #ifdef CONFIG_IP_PNP_BOOTP
    1657         [ #  # ]:          0 :         else if (!strcmp(name, "bootp")) {
    1658                 :          0 :                 ic_proto_enabled &= ~(IC_RARP | IC_USE_DHCP);
    1659                 :          0 :                 return 1;
    1660                 :            :         }
    1661                 :            : #endif
    1662                 :            : #ifdef CONFIG_IP_PNP_RARP
    1663         [ #  # ]:          0 :         else if (!strcmp(name, "rarp")) {
    1664                 :          0 :                 ic_proto_enabled &= ~(IC_BOOTP | IC_USE_DHCP);
    1665                 :          0 :                 return 1;
    1666                 :            :         }
    1667                 :            : #endif
    1668                 :            : #ifdef IPCONFIG_DYNAMIC
    1669         [ #  # ]:          0 :         else if (!strcmp(name, "both")) {
    1670                 :          0 :                 ic_proto_enabled &= ~IC_USE_DHCP; /* backward compat :-( */
    1671                 :          0 :                 return 1;
    1672                 :            :         }
    1673                 :            : #endif
    1674                 :            :         return 0;
    1675                 :            : }
    1676                 :            : 
    1677                 :          0 : static int __init ip_auto_config_setup(char *addrs)
    1678                 :            : {
    1679                 :          0 :         char *cp, *ip, *dp;
    1680                 :          0 :         int num = 0;
    1681                 :            : 
    1682                 :          0 :         ic_set_manually = 1;
    1683                 :          0 :         ic_enable = 1;
    1684                 :            : 
    1685                 :            :         /*
    1686                 :            :          * If any dhcp, bootp etc options are set, leave autoconfig on
    1687                 :            :          * and skip the below static IP processing.
    1688                 :            :          */
    1689         [ #  # ]:          0 :         if (ic_proto_name(addrs))
    1690                 :            :                 return 1;
    1691                 :            : 
    1692                 :            :         /* If no static IP is given, turn off autoconfig and bail.  */
    1693         [ #  # ]:          0 :         if (*addrs == 0 ||
    1694         [ #  # ]:          0 :             strcmp(addrs, "off") == 0 ||
    1695         [ #  # ]:          0 :             strcmp(addrs, "none") == 0) {
    1696                 :          0 :                 ic_enable = 0;
    1697                 :          0 :                 return 1;
    1698                 :            :         }
    1699                 :            : 
    1700                 :            :         /* Initialise all name servers and NTP servers to NONE */
    1701                 :          0 :         ic_nameservers_predef();
    1702                 :          0 :         ic_ntp_servers_predef();
    1703                 :            : 
    1704                 :            :         /* Parse string for static IP assignment.  */
    1705                 :          0 :         ip = addrs;
    1706   [ #  #  #  # ]:          0 :         while (ip && *ip) {
    1707         [ #  # ]:          0 :                 if ((cp = strchr(ip, ':')))
    1708                 :          0 :                         *cp++ = '\0';
    1709         [ #  # ]:          0 :                 if (strlen(ip) > 0) {
    1710                 :          0 :                         pr_debug("IP-Config: Parameter #%d: `%s'\n", num, ip);
    1711   [ #  #  #  #  :          0 :                         switch (num) {
          #  #  #  #  #  
                   #  # ]
    1712                 :          0 :                         case 0:
    1713         [ #  # ]:          0 :                                 if ((ic_myaddr = in_aton(ip)) == ANY)
    1714                 :          0 :                                         ic_myaddr = NONE;
    1715                 :            :                                 break;
    1716                 :          0 :                         case 1:
    1717         [ #  # ]:          0 :                                 if ((ic_servaddr = in_aton(ip)) == ANY)
    1718                 :          0 :                                         ic_servaddr = NONE;
    1719                 :            :                                 break;
    1720                 :          0 :                         case 2:
    1721         [ #  # ]:          0 :                                 if ((ic_gateway = in_aton(ip)) == ANY)
    1722                 :          0 :                                         ic_gateway = NONE;
    1723                 :            :                                 break;
    1724                 :          0 :                         case 3:
    1725         [ #  # ]:          0 :                                 if ((ic_netmask = in_aton(ip)) == ANY)
    1726                 :          0 :                                         ic_netmask = NONE;
    1727                 :            :                                 break;
    1728                 :          0 :                         case 4:
    1729         [ #  # ]:          0 :                                 if ((dp = strchr(ip, '.'))) {
    1730                 :          0 :                                         *dp++ = '\0';
    1731                 :          0 :                                         strlcpy(utsname()->domainname, dp,
    1732                 :            :                                                 sizeof(utsname()->domainname));
    1733                 :            :                                 }
    1734                 :          0 :                                 strlcpy(utsname()->nodename, ip,
    1735                 :            :                                         sizeof(utsname()->nodename));
    1736                 :          0 :                                 ic_host_name_set = 1;
    1737                 :          0 :                                 break;
    1738                 :          0 :                         case 5:
    1739                 :          0 :                                 strlcpy(user_dev_name, ip, sizeof(user_dev_name));
    1740                 :          0 :                                 break;
    1741                 :          0 :                         case 6:
    1742         [ #  # ]:          0 :                                 if (ic_proto_name(ip) == 0 &&
    1743         [ #  # ]:          0 :                                     ic_myaddr == NONE) {
    1744                 :          0 :                                         ic_enable = 0;
    1745                 :            :                                 }
    1746                 :            :                                 break;
    1747                 :            :                         case 7:
    1748                 :          0 :                                 if (CONF_NAMESERVERS_MAX >= 1) {
    1749                 :          0 :                                         ic_nameservers[0] = in_aton(ip);
    1750         [ #  # ]:          0 :                                         if (ic_nameservers[0] == ANY)
    1751                 :          0 :                                                 ic_nameservers[0] = NONE;
    1752                 :            :                                 }
    1753                 :            :                                 break;
    1754                 :            :                         case 8:
    1755                 :          0 :                                 if (CONF_NAMESERVERS_MAX >= 2) {
    1756                 :          0 :                                         ic_nameservers[1] = in_aton(ip);
    1757         [ #  # ]:          0 :                                         if (ic_nameservers[1] == ANY)
    1758                 :          0 :                                                 ic_nameservers[1] = NONE;
    1759                 :            :                                 }
    1760                 :            :                                 break;
    1761                 :            :                         case 9:
    1762                 :          0 :                                 if (CONF_NTP_SERVERS_MAX >= 1) {
    1763                 :          0 :                                         ic_ntp_servers[0] = in_aton(ip);
    1764         [ #  # ]:          0 :                                         if (ic_ntp_servers[0] == ANY)
    1765                 :          0 :                                                 ic_ntp_servers[0] = NONE;
    1766                 :            :                                 }
    1767                 :            :                                 break;
    1768                 :            :                         }
    1769                 :          0 :                 }
    1770                 :          0 :                 ip = cp;
    1771                 :          0 :                 num++;
    1772                 :            :         }
    1773                 :            : 
    1774                 :            :         return 1;
    1775                 :            : }
    1776                 :            : __setup("ip=", ip_auto_config_setup);
    1777                 :            : 
    1778                 :          0 : static int __init nfsaddrs_config_setup(char *addrs)
    1779                 :            : {
    1780                 :          0 :         return ip_auto_config_setup(addrs);
    1781                 :            : }
    1782                 :            : __setup("nfsaddrs=", nfsaddrs_config_setup);
    1783                 :            : 
    1784                 :          0 : static int __init vendor_class_identifier_setup(char *addrs)
    1785                 :            : {
    1786         [ #  # ]:          0 :         if (strlcpy(vendor_class_identifier, addrs,
    1787                 :            :                     sizeof(vendor_class_identifier))
    1788                 :            :             >= sizeof(vendor_class_identifier))
    1789                 :          0 :                 pr_warn("DHCP: vendorclass too long, truncated to \"%s\"\n",
    1790                 :            :                         vendor_class_identifier);
    1791                 :          0 :         return 1;
    1792                 :            : }
    1793                 :            : __setup("dhcpclass=", vendor_class_identifier_setup);
    1794                 :            : 
    1795                 :          0 : static int __init set_carrier_timeout(char *str)
    1796                 :            : {
    1797                 :          0 :         ssize_t ret;
    1798                 :            : 
    1799         [ #  # ]:          0 :         if (!str)
    1800                 :            :                 return 0;
    1801                 :            : 
    1802                 :          0 :         ret = kstrtouint(str, 0, &carrier_timeout);
    1803         [ #  # ]:          0 :         if (ret)
    1804                 :          0 :                 return 0;
    1805                 :            : 
    1806                 :            :         return 1;
    1807                 :            : }
    1808                 :            : __setup("carrier_timeout=", set_carrier_timeout);

Generated by: LCOV version 1.14