开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ipconfig.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：34k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ipconfig.c：源码内容
  1. /*
  2.  *  $Id: ipconfig.c,v 1.43.2.1 2001/12/13 10:39:53 davem Exp $
  3.  *
  4.  *  Automatic Configuration of IP -- use DHCP, BOOTP, RARP, or
  5.  *  user-supplied information to configure own IP address and routes.
  6.  *
  7.  *  Copyright (C) 1996-1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
  8.  *
  9.  *  Derived from network configuration code in fs/nfs/nfsroot.c,
  10.  *  originally Copyright (C) 1995, 1996 Gero Kuhlmann and me.
  11.  *
  12.  *  BOOTP rewritten to construct and analyse packets itself instead
  13.  *  of misusing the IP layer. num_bugs_causing_wrong_arp_replies--;
  14.  *      -- MJ, December 1998
  15.  *  
  16.  *  Fixed ip_auto_config_setup calling at startup in the new "Linker Magic"
  17.  *  initialization scheme.
  18.  * - Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 08/11/1999
  19.  *
  20.  *  DHCP support added.  To users this looks like a whole separate
  21.  *  protocol, but we know it's just a bag on the side of BOOTP.
  22.  * -- Chip Salzenberg <chip@valinux.com>, May 2000
  23.  *
  24.  *  Ported DHCP support from 2.2.16 to 2.4.0-test4
  25.  *              -- Eric Biederman <ebiederman@lnxi.com>, 30 Aug 2000
  26.  *
  27.  *  Merged changes from 2.2.19 into 2.4.3
  28.  *              -- Eric Biederman <ebiederman@lnxi.com>, 22 April Aug 2001
  29.  *
  30.  *  Multipe Nameservers in /proc/net/pnp
  31.  *              --  Josef Siemes <jsiemes@web.de>, Aug 2002
  32.  */
  34. #include <linux/config.h>
  35. #include <linux/types.h>
  36. #include <linux/string.h>
  37. #include <linux/kernel.h>
  38. #include <linux/sched.h>
  39. #include <linux/random.h>
  40. #include <linux/init.h>
  41. #include <linux/utsname.h>
  42. #include <linux/in.h>
  43. #include <linux/if.h>
  44. #include <linux/inet.h>
  45. #include <linux/netdevice.h>
  46. #include <linux/if_arp.h>
  47. #include <linux/skbuff.h>
  48. #include <linux/ip.h>
  49. #include <linux/socket.h>
  50. #include <linux/route.h>
  51. #include <linux/udp.h>
  52. #include <linux/proc_fs.h>
  53. #include <linux/major.h>
  54. #include <net/arp.h>
  55. #include <net/ip.h>
  56. #include <net/ipconfig.h>
  58. #include <asm/uaccess.h>
  59. #include <asm/checksum.h>
  60. #include <asm/processor.h>
  62. /* Define this to allow debugging output */
  63. #undef IPCONFIG_DEBUG
  65. #ifdef IPCONFIG_DEBUG
  66. #define DBG(x) printk x
  67. #else
  68. #define DBG(x) do { } while(0)
  69. #endif
  71. #if defined(CONFIG_IP_PNP_DHCP)
  72. #define IPCONFIG_DHCP
  73. #endif
  74. #if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_DHCP)
  75. #define IPCONFIG_BOOTP
  76. #endif
  77. #if defined(CONFIG_IP_PNP_RARP)
  78. #define IPCONFIG_RARP
  79. #endif
  80. #if defined(IPCONFIG_BOOTP) || defined(IPCONFIG_RARP)
  81. #define IPCONFIG_DYNAMIC
  82. #endif
  84. /* Define the friendly delay before and after opening net devices */
  85. #define CONF_PRE_OPEN (HZ/2) /* Before opening: 1/2 second */
  86. #define CONF_POST_OPEN (1*HZ) /* After opening: 1 second */
  88. /* Define the timeout for waiting for a DHCP/BOOTP/RARP reply */
  89. #define CONF_OPEN_RETRIES  2 /* (Re)open devices twice */
  90. #define CONF_SEND_RETRIES  6 /* Send six requests per open */
  91. #define CONF_INTER_TIMEOUT (HZ/2) /* Inter-device timeout: 1/2 second */
  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 */
  100. /*
  101.  * Public IP configuration
  102.  */
  104. /* This is used by platforms which might be able to set the ipconfig
  105.  * variables using firmware environment vars.  If this is set, it will
  106.  * ignore such firmware variables.
  107.  */
  108. int ic_set_manually __initdata = 0; /* IPconfig parameters set manually */
  110. int ic_enable __initdata = 0; /* IP config enabled? */
  112. /* Protocol choice */
  113. int ic_proto_enabled __initdata = 0
  114. #ifdef IPCONFIG_BOOTP
  115. | IC_BOOTP
  116. #endif
  117. #ifdef CONFIG_IP_PNP_DHCP
  118. | IC_USE_DHCP
  119. #endif
  120. #ifdef IPCONFIG_RARP
  121. | IC_RARP
  122. #endif
  123. ;
  125. int ic_host_name_set __initdata = 0; /* Host name set by us? */
  127. u32 ic_myaddr __initdata = INADDR_NONE; /* My IP address */
  128. u32 ic_netmask __initdata = INADDR_NONE; /* Netmask for local subnet */
  129. u32 ic_gateway __initdata = INADDR_NONE; /* Gateway IP address */
  131. u32 ic_servaddr __initdata = INADDR_NONE; /* Boot server IP address */
  133. u32 root_server_addr __initdata = INADDR_NONE; /* Address of NFS server */
  134. u8 root_server_path[256] __initdata = { 0, }; /* Path to mount as root */
  136. /* Persistent data: */
  138. int ic_proto_used; /* Protocol used, if any */
  139. u32 ic_nameservers[CONF_NAMESERVERS_MAX]; /* DNS Server IP addresses */
  140. u8 ic_domain[64]; /* DNS (not NIS) domain name */
  142. /*
  143.  * Private state.
  144.  */
  146. /* Name of user-selected boot device */
  147. static char user_dev_name[IFNAMSIZ] __initdata = { 0, };
  149. /* Protocols supported by available interfaces */
  150. static int ic_proto_have_if __initdata = 0;
  152. #ifdef IPCONFIG_DYNAMIC
  153. static spinlock_t ic_recv_lock = SPIN_LOCK_UNLOCKED;
  154. static volatile int ic_got_reply __initdata = 0;    /* Proto(s) that replied */
  155. #endif
  156. #ifdef IPCONFIG_DHCP
  157. static int ic_dhcp_msgtype __initdata = 0; /* DHCP msg type received */
  158. #endif
  161. /*
  162.  * Network devices
  163.  */
  165. struct ic_device {
  166. struct ic_device *next;
  167. struct net_device *dev;
  168. unsigned short flags;
  169. short able;
  170. u32 xid;
  171. };
  173. static struct ic_device *ic_first_dev __initdata = NULL;/* List of open device */
  174. static struct net_device *ic_dev __initdata = NULL; /* Selected device */
  176. static int __init ic_open_devs(void)
  177. {
  178. struct ic_device *d, **last;
  179. struct net_device *dev;
  180. unsigned short oflags;
  182. last = &ic_first_dev;
  183. rtnl_shlock();
  184. for (dev = dev_base; dev; dev = dev->next) {
  185. if (user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :
  186.     (!(dev->flags & IFF_LOOPBACK) &&
  187.      (dev->flags & (IFF_POINTOPOINT|IFF_BROADCAST)) &&
  188.      strncmp(dev->name, "dummy", 5))) {
  189. int able = 0;
  190. if (dev->mtu >= 364)
  191. able |= IC_BOOTP;
  192. else
  193. printk(KERN_WARNING "DHCP/BOOTP: Ignoring device %s, MTU %d too small", dev->name, dev->mtu);
  194. if (!(dev->flags & IFF_NOARP))
  195. able |= IC_RARP;
  196. able &= ic_proto_enabled;
  197. if (ic_proto_enabled && !able)
  198. continue;
  199. oflags = dev->flags;
  200. if (dev_change_flags(dev, oflags | IFF_UP) < 0) {
  201. printk(KERN_ERR "IP-Config: Failed to open %sn", dev->name);
  202. continue;
  203. }
  204. if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {
  205. rtnl_shunlock();
  206. return -1;
  207. }
  208. d->dev = dev;
  209. *last = d;
  210. last = &d->next;
  211. d->flags = oflags;
  212. d->able = able;
  213. if (able & IC_BOOTP)
  214. get_random_bytes(&d->xid, sizeof(u32));
  215. else
  216. d->xid = 0;
  217. ic_proto_have_if |= able;
  218. DBG(("IP-Config: %s UP (able=%d, xid=%08x)n",
  219. dev->name, able, d->xid));
  220. }
  221. }
  222. rtnl_shunlock();
  224. *last = NULL;
  226. if (!ic_first_dev) {
  227. if (user_dev_name[0])
  228. printk(KERN_ERR "IP-Config: Device `%s' not found.n", user_dev_name);
  229. else
  230. printk(KERN_ERR "IP-Config: No network devices available.n");
  231. return -1;
  232. }
  233. return 0;
  234. }
  236. static void __init ic_close_devs(void)
  237. {
  238. struct ic_device *d, *next;
  239. struct net_device *dev;
  241. rtnl_shlock();
  242. next = ic_first_dev;
  243. while ((d = next)) {
  244. next = d->next;
  245. dev = d->dev;
  246. if (dev != ic_dev) {
  247. DBG(("IP-Config: Downing %sn", dev->name));
  248. dev_change_flags(dev, d->flags);
  249. }
  250. kfree(d);
  251. }
  252. rtnl_shunlock();
  253. }
  255. /*
  256.  * Interface to various network functions.
  257.  */
  259. static inline void
  260. set_sockaddr(struct sockaddr_in *sin, u32 addr, u16 port)
  261. {
  262. sin->sin_family = AF_INET;
  263. sin->sin_addr.s_addr = addr;
  264. sin->sin_port = port;
  265. }
  267. static int __init ic_dev_ioctl(unsigned int cmd, struct ifreq *arg)
  268. {
  269. int res;
  271. mm_segment_t oldfs = get_fs();
  272. set_fs(get_ds());
  273. res = devinet_ioctl(cmd, arg);
  274. set_fs(oldfs);
  275. return res;
  276. }
  278. static int __init ic_route_ioctl(unsigned int cmd, struct rtentry *arg)
  279. {
  280. int res;
  282. mm_segment_t oldfs = get_fs();
  283. set_fs(get_ds());
  284. res = ip_rt_ioctl(cmd, arg);
  285. set_fs(oldfs);
  286. return res;
  287. }
  289. /*
  290.  * Set up interface addresses and routes.
  291.  */
  293. static int __init ic_setup_if(void)
  294. {
  295. struct ifreq ir;
  296. struct sockaddr_in *sin = (void *) &ir.ifr_ifru.ifru_addr;
  297. int err;
  299. memset(&ir, 0, sizeof(ir));
  300. strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->name);
  301. set_sockaddr(sin, ic_myaddr, 0);
  302. if ((err = ic_dev_ioctl(SIOCSIFADDR, &ir)) < 0) {
  303. printk(KERN_ERR "IP-Config: Unable to set interface address (%d).n", err);
  304. return -1;
  305. }
  306. set_sockaddr(sin, ic_netmask, 0);
  307. if ((err = ic_dev_ioctl(SIOCSIFNETMASK, &ir)) < 0) {
  308. printk(KERN_ERR "IP-Config: Unable to set interface netmask (%d).n", err);
  309. return -1;
  310. }
  311. set_sockaddr(sin, ic_myaddr | ~ic_netmask, 0);
  312. if ((err = ic_dev_ioctl(SIOCSIFBRDADDR, &ir)) < 0) {
  313. printk(KERN_ERR "IP-Config: Unable to set interface broadcast address (%d).n", err);
  314. return -1;
  315. }
  316. return 0;
  317. }
  319. static int __init ic_setup_routes(void)
  320. {
  321. /* No need to setup device routes, only the default route... */
  323. if (ic_gateway != INADDR_NONE) {
  324. struct rtentry rm;
  325. int err;
  327. memset(&rm, 0, sizeof(rm));
  328. if ((ic_gateway ^ ic_myaddr) & ic_netmask) {
  329. printk(KERN_ERR "IP-Config: Gateway not on directly connected network.n");
  330. return -1;
  331. }
  332. set_sockaddr((struct sockaddr_in *) &rm.rt_dst, 0, 0);
  333. set_sockaddr((struct sockaddr_in *) &rm.rt_genmask, 0, 0);
  334. set_sockaddr((struct sockaddr_in *) &rm.rt_gateway, ic_gateway, 0);
  335. rm.rt_flags = RTF_UP | RTF_GATEWAY;
  336. if ((err = ic_route_ioctl(SIOCADDRT, &rm)) < 0) {
  337. printk(KERN_ERR "IP-Config: Cannot add default route (%d).n", err);
  338. return -1;
  339. }
  340. }
  342. return 0;
  343. }
  345. /*
  346.  * Fill in default values for all missing parameters.
  347.  */
  349. static int __init ic_defaults(void)
  350. {
  351. /*
  352.  * At this point we have no userspace running so need not
  353.  * claim locks on system_utsname
  354.  */
  355.  
  356. if (!ic_host_name_set)
  357. sprintf(system_utsname.nodename, "%u.%u.%u.%u", NIPQUAD(ic_myaddr));
  359. if (root_server_addr == INADDR_NONE)
  360. root_server_addr = ic_servaddr;
  362. if (ic_netmask == INADDR_NONE) {
  363. if (IN_CLASSA(ntohl(ic_myaddr)))
  364. ic_netmask = htonl(IN_CLASSA_NET);
  365. else if (IN_CLASSB(ntohl(ic_myaddr)))
  366. ic_netmask = htonl(IN_CLASSB_NET);
  367. else if (IN_CLASSC(ntohl(ic_myaddr)))
  368. ic_netmask = htonl(IN_CLASSC_NET);
  369. else {
  370. printk(KERN_ERR "IP-Config: Unable to guess netmask for address %u.%u.%u.%un",
  371. NIPQUAD(ic_myaddr));
  372. return -1;
  373. }
  374. printk("IP-Config: Guessing netmask %u.%u.%u.%un", NIPQUAD(ic_netmask));
  375. }
  377. return 0;
  378. }
  380. /*
  381.  * RARP support.
  382.  */
  384. #ifdef IPCONFIG_RARP
  386. static int ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt);
  388. static struct packet_type rarp_packet_type __initdata = {
  389. type: __constant_htons(ETH_P_RARP),
  390. func: ic_rarp_recv,
  391. };
  393. static inline void ic_rarp_init(void)
  394. {
  395. dev_add_pack(&rarp_packet_type);
  396. }
  398. static inline void ic_rarp_cleanup(void)
  399. {
  400. dev_remove_pack(&rarp_packet_type);
  401. }
  403. /*
  404.  *  Process received RARP packet.
  405.  */
  406. static int __init
  407. ic_rarp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
  408. {
  409. struct arphdr *rarp = (struct arphdr *)skb->h.raw;
  410. unsigned char *rarp_ptr = (unsigned char *) (rarp + 1);
  411. unsigned long sip, tip;
  412. unsigned char *sha, *tha; /* s for "source", t for "target" */
  413. struct ic_device *d;
  415. /* One reply at a time, please. */
  416. spin_lock(&ic_recv_lock);
  418. /* If we already have a reply, just drop the packet */
  419. if (ic_got_reply)
  420. goto drop;
  422. /* Find the ic_device that the packet arrived on */
  423. d = ic_first_dev;
  424. while (d && d->dev != dev)
  425. d = d->next;
  426. if (!d)
  427. goto drop; /* should never happen */
  429. /* If this test doesn't pass, it's not IP, or we should ignore it anyway */
  430. if (rarp->ar_hln != dev->addr_len || dev->type != ntohs(rarp->ar_hrd))
  431. goto drop;
  433. /* If it's not a RARP reply, delete it. */
  434. if (rarp->ar_op != htons(ARPOP_RREPLY))
  435. goto drop;
  437. /* If it's not Ethernet, delete it. */
  438. if (rarp->ar_pro != htons(ETH_P_IP))
  439. goto drop;
  441. /* Extract variable-width fields */
  442. sha = rarp_ptr;
  443. rarp_ptr += dev->addr_len;
  444. memcpy(&sip, rarp_ptr, 4);
  445. rarp_ptr += 4;
  446. tha = rarp_ptr;
  447. rarp_ptr += dev->addr_len;
  448. memcpy(&tip, rarp_ptr, 4);
  450. /* Discard packets which are not meant for us. */
  451. if (memcmp(tha, dev->dev_addr, dev->addr_len))
  452. goto drop;
  454. /* Discard packets which are not from specified server. */
  455. if (ic_servaddr != INADDR_NONE && ic_servaddr != sip)
  456. goto drop;
  458. /* We have a winner! */
  459. ic_dev = dev;
  460. if (ic_myaddr == INADDR_NONE)
  461. ic_myaddr = tip;
  462. ic_servaddr = sip;
  463. ic_got_reply = IC_RARP;
  465. drop:
  466. /* Show's over.  Nothing to see here.  */
  467. spin_unlock(&ic_recv_lock);
  469. /* Throw the packet out. */
  470. kfree_skb(skb);
  471. return 0;
  472. }
  475. /*
  476.  *  Send RARP request packet over a single interface.
  477.  */
  478. static void __init ic_rarp_send_if(struct ic_device *d)
  479. {
  480. struct net_device *dev = d->dev;
  481. arp_send(ARPOP_RREQUEST, ETH_P_RARP, 0, dev, 0, NULL,
  482.  dev->dev_addr, dev->dev_addr);
  483. }
  484. #endif
  486. /*
  487.  * DHCP/BOOTP support.
  488.  */
  490. #ifdef IPCONFIG_BOOTP
  492. struct bootp_pkt { /* BOOTP packet format */
  493. struct iphdr iph; /* IP header */
  494. struct udphdr udph; /* UDP header */
  495. u8 op; /* 1=request, 2=reply */
  496. u8 htype; /* HW address type */
  497. u8 hlen; /* HW address length */
  498. u8 hops; /* Used only by gateways */
  499. u32 xid; /* Transaction ID */
  500. u16 secs; /* Seconds since we started */
  501. u16 flags; /* Just what it says */
  502. u32 client_ip; /* Client's IP address if known */
  503. u32 your_ip; /* Assigned IP address */
  504. u32 server_ip; /* (Next, e.g. NFS) Server's IP address */
  505. u32 relay_ip; /* IP address of BOOTP relay */
  506. u8 hw_addr[16]; /* Client's HW address */
  507. u8 serv_name[64]; /* Server host name */
  508. u8 boot_file[128]; /* Name of boot file */
  509. u8 exten[312]; /* DHCP options / BOOTP vendor extensions */
  510. };
  512. /* packet ops */
  513. #define BOOTP_REQUEST 1
  514. #define BOOTP_REPLY 2
  516. /* DHCP message types */
  517. #define DHCPDISCOVER 1
  518. #define DHCPOFFER 2
  519. #define DHCPREQUEST 3
  520. #define DHCPDECLINE 4
  521. #define DHCPACK 5
  522. #define DHCPNAK 6
  523. #define DHCPRELEASE 7
  524. #define DHCPINFORM 8
  526. static int ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt);
  528. static struct packet_type bootp_packet_type __initdata = {
  529. type: __constant_htons(ETH_P_IP),
  530. func: ic_bootp_recv,
  531. };
  534. /*
  535.  *  Initialize DHCP/BOOTP extension fields in the request.
  536.  */
  538. static const u8 ic_bootp_cookie[4] = { 99, 130, 83, 99 };
  540. #ifdef IPCONFIG_DHCP
  542. static void __init
  543. ic_dhcp_init_options(u8 *options)
  544. {
  545. u8 mt = ((ic_servaddr == INADDR_NONE)
  546.  ? DHCPDISCOVER : DHCPREQUEST);
  547. u8 *e = options;
  549. #ifdef IPCONFIG_DEBUG
  550. printk("DHCP: Sending message type %dn", mt);
  551. #endif
  553. memcpy(e, ic_bootp_cookie, 4); /* RFC1048 Magic Cookie */
  554. e += 4;
  556. *e++ = 53; /* DHCP message type */
  557. *e++ = 1;
  558. *e++ = mt;
  560. if (mt == DHCPREQUEST) {
  561. *e++ = 54; /* Server ID (IP address) */
  562. *e++ = 4;
  563. memcpy(e, &ic_servaddr, 4);
  564. e += 4;
  566. *e++ = 50; /* Requested IP address */
  567. *e++ = 4;
  568. memcpy(e, &ic_myaddr, 4);
  569. e += 4;
  570. }
  572. /* always? */
  573. {
  574. static const u8 ic_req_params[] = {
  575. 1, /* Subnet mask */
  576. 3, /* Default gateway */
  577. 6, /* DNS server */
  578. 12, /* Host name */
  579. 15, /* Domain name */
  580. 17, /* Boot path */
  581. 40, /* NIS domain name */
  582. };
  584. *e++ = 55; /* Parameter request list */
  585. *e++ = sizeof(ic_req_params);
  586. memcpy(e, ic_req_params, sizeof(ic_req_params));
  587. e += sizeof(ic_req_params);
  588. }
  590. *e++ = 255; /* End of the list */
  591. }
  593. #endif /* IPCONFIG_DHCP */
  595. static void __init ic_bootp_init_ext(u8 *e)
  596. {
  597. memcpy(e, ic_bootp_cookie, 4); /* RFC1048 Magic Cookie */
  598. e += 4;
  599. *e++ = 1; /* Subnet mask request */
  600. *e++ = 4;
  601. e += 4;
  602. *e++ = 3; /* Default gateway request */
  603. *e++ = 4;
  604. e += 4;
  605. *e++ = 5; /* Name server reqeust */
  606. *e++ = 8;
  607. e += 8;
  608. *e++ = 12; /* Host name request */
  609. *e++ = 32;
  610. e += 32;
  611. *e++ = 40; /* NIS Domain name request */
  612. *e++ = 32;
  613. e += 32;
  614. *e++ = 17; /* Boot path */
  615. *e++ = 40;
  616. e += 40;
  618. *e++ = 57; /* set extension buffer size for reply */ 
  619. *e++ = 2;
  620. *e++ = 1; /* 128+236+8+20+14, see dhcpd sources */ 
  621. *e++ = 150;
  623. *e++ = 255; /* End of the list */
  624. }
  627. /*
  628.  *  Initialize the DHCP/BOOTP mechanism.
  629.  */
  630. static inline void ic_bootp_init(void)
  631. {
  632. int i;
  634. for (i = 0; i < CONF_NAMESERVERS_MAX; i++)
  635. ic_nameservers[i] = INADDR_NONE;
  637. dev_add_pack(&bootp_packet_type);
  638. }
  641. /*
  642.  *  DHCP/BOOTP cleanup.
  643.  */
  644. static inline void ic_bootp_cleanup(void)
  645. {
  646. dev_remove_pack(&bootp_packet_type);
  647. }
  650. /*
  651.  *  Send DHCP/BOOTP request to single interface.
  652.  */
  653. static void __init ic_bootp_send_if(struct ic_device *d, unsigned long jiffies_diff)
  654. {
  655. struct net_device *dev = d->dev;
  656. struct sk_buff *skb;
  657. struct bootp_pkt *b;
  658. int hh_len = (dev->hard_header_len + 15) & ~15;
  659. struct iphdr *h;
  661. /* Allocate packet */
  662. skb = alloc_skb(sizeof(struct bootp_pkt) + hh_len + 15, GFP_KERNEL);
  663. if (!skb)
  664. return;
  665. skb_reserve(skb, hh_len);
  666. b = (struct bootp_pkt *) skb_put(skb, sizeof(struct bootp_pkt));
  667. memset(b, 0, sizeof(struct bootp_pkt));
  669. /* Construct IP header */
  670. skb->nh.iph = h = &b->iph;
  671. h->version = 4;
  672. h->ihl = 5;
  673. h->tot_len = htons(sizeof(struct bootp_pkt));
  674. h->frag_off = htons(IP_DF);
  675. h->ttl = 64;
  676. h->protocol = IPPROTO_UDP;
  677. h->daddr = INADDR_BROADCAST;
  678. h->check = ip_fast_csum((unsigned char *) h, h->ihl);
  680. /* Construct UDP header */
  681. b->udph.source = htons(68);
  682. b->udph.dest = htons(67);
  683. b->udph.len = htons(sizeof(struct bootp_pkt) - sizeof(struct iphdr));
  684. /* UDP checksum not calculated -- explicitly allowed in BOOTP RFC */
  686. /* Construct DHCP/BOOTP header */
  687. b->op = BOOTP_REQUEST;
  688. if (dev->type < 256) /* check for false types */
  689. b->htype = dev->type;
  690. else if (dev->type == ARPHRD_IEEE802_TR) /* fix for token ring */
  691. b->htype = ARPHRD_IEEE802;
  692. else {
  693. printk("Unknown ARP type 0x%04x for device %sn", dev->type, dev->name);
  694. b->htype = dev->type; /* can cause undefined behavior */
  695. }
  696. b->hlen = dev->addr_len;
  697. b->your_ip = INADDR_NONE;
  698. b->server_ip = INADDR_NONE;
  699. memcpy(b->hw_addr, dev->dev_addr, dev->addr_len);
  700. b->secs = htons(jiffies_diff / HZ);
  701. b->xid = d->xid;
  703. /* add DHCP options or BOOTP extensions */
  704. #ifdef IPCONFIG_DHCP
  705. if (ic_proto_enabled & IC_USE_DHCP)
  706. ic_dhcp_init_options(b->exten);
  707. else
  708. #endif
  709. ic_bootp_init_ext(b->exten);
  711. /* Chain packet down the line... */
  712. skb->dev = dev;
  713. skb->protocol = htons(ETH_P_IP);
  714. if ((dev->hard_header &&
  715.      dev->hard_header(skb, dev, ntohs(skb->protocol), dev->broadcast, dev->dev_addr, skb->len) < 0) ||
  716.     dev_queue_xmit(skb) < 0)
  717. printk("E");
  718. }
  721. /*
  722.  *  Copy BOOTP-supplied string if not already set.
  723.  */
  724. static int __init ic_bootp_string(char *dest, char *src, int len, int max)
  725. {
  726. if (!len)
  727. return 0;
  728. if (len > max-1)
  729. len = max-1;
  730. memcpy(dest, src, len);
  731. dest[len] = '';
  732. return 1;
  733. }
  736. /*
  737.  *  Process BOOTP extensions.
  738.  */
  739. static void __init ic_do_bootp_ext(u8 *ext)
  740. {
  741. u8 servers;
  742. int i;
  744. #ifdef IPCONFIG_DEBUG
  745. u8 *c;
  747. printk("DHCP/BOOTP: Got extension %d:",*ext);
  748. for(c=ext+2; c<ext+2+ext[1]; c++)
  749. printk(" %02x", *c);
  750. printk("n");
  751. #endif
  753. switch (*ext++) {
  754. case 1: /* Subnet mask */
  755. if (ic_netmask == INADDR_NONE)
  756. memcpy(&ic_netmask, ext+1, 4);
  757. break;
  758. case 3: /* Default gateway */
  759. if (ic_gateway == INADDR_NONE)
  760. memcpy(&ic_gateway, ext+1, 4);
  761. break;
  762. case 6: /* DNS server */
  763. servers= *ext/4;
  764. if (servers > CONF_NAMESERVERS_MAX)
  765. servers = CONF_NAMESERVERS_MAX;
  766. for (i = 0; i < servers; i++) {
  767. if (ic_nameservers[i] == INADDR_NONE)
  768. memcpy(&ic_nameservers[i], ext+1+4*i, 4);
  769. }
  770. break;
  771. case 12: /* Host name */
  772. ic_bootp_string(system_utsname.nodename, ext+1, *ext, __NEW_UTS_LEN);
  773. ic_host_name_set = 1;
  774. break;
  775. case 15: /* Domain name (DNS) */
  776. ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
  777. break;
  778. case 17: /* Root path */
  779. if (!root_server_path[0])
  780. ic_bootp_string(root_server_path, ext+1, *ext, sizeof(root_server_path));
  781. break;
  782. case 40: /* NIS Domain name (_not_ DNS) */
  783. ic_bootp_string(system_utsname.domainname, ext+1, *ext, __NEW_UTS_LEN);
  784. break;
  785. }
  786. }
  789. /*
  790.  *  Receive BOOTP reply.
  791.  */
  792. static int __init ic_bootp_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
  793. {
  794. struct bootp_pkt *b = (struct bootp_pkt *) skb->nh.iph;
  795. struct iphdr *h = &b->iph;
  796. struct ic_device *d;
  797. int len;
  799. /* One reply at a time, please. */
  800. spin_lock(&ic_recv_lock);
  802. /* If we already have a reply, just drop the packet */
  803. if (ic_got_reply)
  804. goto drop;
  806. /* Find the ic_device that the packet arrived on */
  807. d = ic_first_dev;
  808. while (d && d->dev != dev)
  809. d = d->next;
  810. if (!d)
  811. goto drop;  /* should never happen */
  813. /* Check whether it's a BOOTP packet */
  814. if (skb->pkt_type == PACKET_OTHERHOST ||
  815.     skb->len < sizeof(struct udphdr) + sizeof(struct iphdr) ||
  816.     h->ihl != 5 ||
  817.     h->version != 4 ||
  818.     ip_fast_csum((char *) h, h->ihl) != 0 ||
  819.     skb->len < ntohs(h->tot_len) ||
  820.     h->protocol != IPPROTO_UDP ||
  821.     b->udph.source != htons(67) ||
  822.     b->udph.dest != htons(68) ||
  823.     ntohs(h->tot_len) < ntohs(b->udph.len) + sizeof(struct iphdr))
  824. goto drop;
  826. /* Fragments are not supported */
  827. if (h->frag_off & htons(IP_OFFSET | IP_MF)) {
  828. printk(KERN_ERR "DHCP/BOOTP: Ignoring fragmented reply.n");
  829. goto drop;
  830. }
  832. /* Is it a reply to our BOOTP request? */
  833. len = ntohs(b->udph.len) - sizeof(struct udphdr);
  834. if (len < 300 ||     /* See RFC 951:2.1 */
  835.     b->op != BOOTP_REPLY ||
  836.     b->xid != d->xid) {
  837. printk("?");
  838. goto drop;
  839. }
  841. /* Parse extensions */
  842. if (!memcmp(b->exten, ic_bootp_cookie, 4)) { /* Check magic cookie */
  843.                 u8 *end = (u8 *) b + ntohs(b->iph.tot_len);
  844. u8 *ext;
  846. #ifdef IPCONFIG_DHCP
  847. if (ic_proto_enabled & IC_USE_DHCP) {
  848. u32 server_id = INADDR_NONE;
  849. int mt = 0;
  851. ext = &b->exten[4];
  852. while (ext < end && *ext != 0xff) {
  853. u8 *opt = ext++;
  854. if (*opt == 0) /* Padding */
  855. continue;
  856. ext += *ext + 1;
  857. if (ext >= end)
  858. break;
  859. switch (*opt) {
  860. case 53: /* Message type */
  861. if (opt[1])
  862. mt = opt[2];
  863. break;
  864. case 54: /* Server ID (IP address) */
  865. if (opt[1] >= 4)
  866. memcpy(&server_id, opt + 2, 4);
  867. break;
  868. };
  869. }
  871. #ifdef IPCONFIG_DEBUG
  872. printk("DHCP: Got message type %dn", mt);
  873. #endif
  875. switch (mt) {
  876. case DHCPOFFER:
  877. /* While in the process of accepting one offer,
  878.  * ignore all others.
  879.  */
  880. if (ic_myaddr != INADDR_NONE)
  881. goto drop;
  883. /* Let's accept that offer. */
  884. ic_myaddr = b->your_ip;
  885. ic_servaddr = server_id;
  886. #ifdef IPCONFIG_DEBUG
  887. printk("DHCP: Offered address %u.%u.%u.%u",
  888.        NIPQUAD(ic_myaddr));
  889. printk(" by server %u.%u.%u.%un",
  890.        NIPQUAD(ic_servaddr));
  891. #endif
  892. /* The DHCP indicated server address takes
  893.  * precedence over the bootp header one if
  894.  * they are different.
  895.  */
  896. if ((server_id != INADDR_NONE) &&
  897.     (b->server_ip != server_id))
  898. b->server_ip = ic_servaddr;
  899. break;
  901. case DHCPACK:
  902. /* Yeah! */
  903. break;
  905. default:
  906. /* Urque.  Forget it*/
  907. ic_myaddr = INADDR_NONE;
  908. ic_servaddr = INADDR_NONE;
  909. goto drop;
  910. };
  912. ic_dhcp_msgtype = mt;
  914. }
  915. #endif /* IPCONFIG_DHCP */
  917. ext = &b->exten[4];
  918. while (ext < end && *ext != 0xff) {
  919. u8 *opt = ext++;
  920. if (*opt == 0) /* Padding */
  921. continue;
  922. ext += *ext + 1;
  923. if (ext < end)
  924. ic_do_bootp_ext(opt);
  925. }
  926. }
  928. /* We have a winner! */
  929. ic_dev = dev;
  930. ic_myaddr = b->your_ip;
  931. ic_servaddr = b->server_ip;
  932. if (ic_gateway == INADDR_NONE && b->relay_ip)
  933. ic_gateway = b->relay_ip;
  934. if (ic_nameservers[0] == INADDR_NONE)
  935. ic_nameservers[0] = ic_servaddr;
  936. ic_got_reply = IC_BOOTP;
  938. drop:
  939. /* Show's over.  Nothing to see here.  */
  940. spin_unlock(&ic_recv_lock);
  942. /* Throw the packet out. */
  943. kfree_skb(skb);
  945. return 0;
  946. }
  949. #endif
  952. /*
  953.  * Dynamic IP configuration -- DHCP, BOOTP, RARP.
  954.  */
  956. #ifdef IPCONFIG_DYNAMIC
  958. static int __init ic_dynamic(void)
  959. {
  960. int retries;
  961. struct ic_device *d;
  962. unsigned long start_jiffies, timeout, jiff;
  963. int do_bootp = ic_proto_have_if & IC_BOOTP;
  964. int do_rarp = ic_proto_have_if & IC_RARP;
  966. /*
  967.  * If none of DHCP/BOOTP/RARP was selected, return with an error.
  968.  * This routine gets only called when some pieces of information
  969.  * are missing, and without DHCP/BOOTP/RARP we are unable to get it.
  970.  */
  971. if (!ic_proto_enabled) {
  972. printk(KERN_ERR "IP-Config: Incomplete network configuration information.n");
  973. return -1;
  974. }
  976. #ifdef IPCONFIG_BOOTP
  977. if ((ic_proto_enabled ^ ic_proto_have_if) & IC_BOOTP)
  978. printk(KERN_ERR "DHCP/BOOTP: No suitable device found.n");
  979. #endif
  980. #ifdef IPCONFIG_RARP
  981. if ((ic_proto_enabled ^ ic_proto_have_if) & IC_RARP)
  982. printk(KERN_ERR "RARP: No suitable device found.n");
  983. #endif
  985. if (!ic_proto_have_if)
  986. /* Error message already printed */
  987. return -1;
  989. /*
  990.  * Setup protocols
  991.  */
  992. #ifdef IPCONFIG_BOOTP
  993. if (do_bootp)
  994. ic_bootp_init();
  995. #endif
  996. #ifdef IPCONFIG_RARP
  997. if (do_rarp)
  998. ic_rarp_init();
  999. #endif
  1001. /*
  1002.  * Send requests and wait, until we get an answer. This loop
  1003.  * seems to be a terrible waste of CPU time, but actually there is
  1004.  * only one process running at all, so we don't need to use any
  1005.  * scheduler functions.
  1006.  * [Actually we could now, but the nothing else running note still 
  1007.  *  applies.. - AC]
  1008.  */
  1009. printk(KERN_NOTICE "Sending %s%s%s requests .",
  1010.        do_bootp
  1011. ? ((ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP") : "",
  1012.        (do_bootp && do_rarp) ? " and " : "",
  1013.        do_rarp ? "RARP" : "");
  1015. start_jiffies = jiffies;
  1016. d = ic_first_dev;
  1017. retries = CONF_SEND_RETRIES;
  1018. get_random_bytes(&timeout, sizeof(timeout));
  1019. timeout = CONF_BASE_TIMEOUT + (timeout % (unsigned) CONF_TIMEOUT_RANDOM);
  1020. for(;;) {
  1021. #ifdef IPCONFIG_BOOTP
  1022. if (do_bootp && (d->able & IC_BOOTP))
  1023. ic_bootp_send_if(d, jiffies - start_jiffies);
  1024. #endif
  1025. #ifdef IPCONFIG_RARP
  1026. if (do_rarp && (d->able & IC_RARP))
  1027. ic_rarp_send_if(d);
  1028. #endif
  1030. jiff = jiffies + (d->next ? CONF_INTER_TIMEOUT : timeout);
  1031. while (time_before(jiffies, jiff) && !ic_got_reply) {
  1032. barrier();
  1033. cpu_relax();
  1034. }
  1035. #ifdef IPCONFIG_DHCP
  1036. /* DHCP isn't done until we get a DHCPACK. */
  1037. if ((ic_got_reply & IC_BOOTP)
  1038.     && (ic_proto_enabled & IC_USE_DHCP)
  1039.     && ic_dhcp_msgtype != DHCPACK)
  1040. {
  1041. ic_got_reply = 0;
  1042. printk(",");
  1043. continue;
  1044. }
  1045. #endif /* IPCONFIG_DHCP */
  1047. if (ic_got_reply) {
  1048. printk(" OKn");
  1049. break;
  1050. }
  1052. if ((d = d->next))
  1053. continue;
  1055. if (! --retries) {
  1056. printk(" timed out!n");
  1057. break;
  1058. }
  1060. d = ic_first_dev;
  1062. timeout = timeout CONF_TIMEOUT_MULT;
  1063. if (timeout > CONF_TIMEOUT_MAX)
  1064. timeout = CONF_TIMEOUT_MAX;
  1066. printk(".");
  1067. }
  1069. #ifdef IPCONFIG_BOOTP
  1070. if (do_bootp)
  1071. ic_bootp_cleanup();
  1072. #endif
  1073. #ifdef IPCONFIG_RARP
  1074. if (do_rarp)
  1075. ic_rarp_cleanup();
  1076. #endif
  1078. if (!ic_got_reply)
  1079. return -1;
  1081. printk("IP-Config: Got %s answer from %u.%u.%u.%u, ",
  1082. ((ic_got_reply & IC_RARP) ? "RARP" 
  1083.  : (ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP"),
  1084. NIPQUAD(ic_servaddr));
  1085. printk("my address is %u.%u.%u.%un", NIPQUAD(ic_myaddr));
  1087. return 0;
  1088. }
  1090. #endif /* IPCONFIG_DYNAMIC */
  1092. #ifdef CONFIG_PROC_FS
  1094. static int pnp_get_info(char *buffer, char **start,
  1095. off_t offset, int length)
  1096. {
  1097. int len;
  1098. int i;
  1100. if (ic_proto_used & IC_PROTO)
  1101.     sprintf(buffer, "#PROTO: %sn",
  1102.     (ic_proto_used & IC_RARP) ? "RARP"
  1103.     : (ic_proto_used & IC_USE_DHCP) ? "DHCP" : "BOOTP");
  1104. else
  1105.     strcpy(buffer, "#MANUALn");
  1106. len = strlen(buffer);
  1108. if (ic_domain[0])
  1109. len += sprintf(buffer + len,
  1110.        "domain %sn", ic_domain);
  1111. for (i = 0; i < CONF_NAMESERVERS_MAX; i++) {
  1112. if (ic_nameservers[i] != INADDR_NONE)
  1113. len += sprintf(buffer + len,
  1114.        "nameserver %u.%u.%u.%un",
  1115.        NIPQUAD(ic_nameservers[i]));
  1116. }
  1118. if (offset > len)
  1119. offset = len;
  1120. *start = buffer + offset;
  1122. if (offset + length > len)
  1123. length = len - offset;
  1124. return length;
  1125. }
  1127. #endif /* CONFIG_PROC_FS */
  1129. /*
  1130.  *  Extract IP address from the parameter string if needed. Note that we
  1131.  *  need to have root_server_addr set _before_ IPConfig gets called as it
  1132.  *  can override it.
  1133.  */
  1134. u32 __init root_nfs_parse_addr(char *name)
  1135. {
  1136. u32 addr;
  1137. int octets = 0;
  1138. char *cp, *cq;
  1140. cp = cq = name;
  1141. while (octets < 4) {
  1142. while (*cp >= '0' && *cp <= '9')
  1143. cp++;
  1144. if (cp == cq || cp - cq > 3)
  1145. break;
  1146. if (*cp == '.' || octets == 3)
  1147. octets++;
  1148. if (octets < 4)
  1149. cp++;
  1150. cq = cp;
  1151. }
  1152. if (octets == 4 && (*cp == ':' || *cp == '')) {
  1153. if (*cp == ':')
  1154. *cp++ = '';
  1155. addr = in_aton(name);
  1156. strcpy(name, cp);
  1157. } else
  1158. addr = INADDR_NONE;
  1160. return addr;
  1161. }
  1163. /*
  1164.  * IP Autoconfig dispatcher.
  1165.  */
  1167. static int __init ip_auto_config(void)
  1168. {
  1169. unsigned long jiff;
  1170. u32 addr;
  1172. #ifdef CONFIG_PROC_FS
  1173. proc_net_create("pnp", 0, pnp_get_info);
  1174. #endif /* CONFIG_PROC_FS */
  1176. if (!ic_enable)
  1177. return 0;
  1179. DBG(("IP-Config: Entered.n"));
  1181. #ifdef IPCONFIG_DYNAMIC
  1182.  try_try_again:
  1183. #endif
  1184. /* Give hardware a chance to settle */
  1185. jiff = jiffies + CONF_PRE_OPEN;
  1186. while (time_before(jiffies, jiff))
  1187. ;
  1189. /* Setup all network devices */
  1190. if (ic_open_devs() < 0)
  1191. return -1;
  1193. /* Give drivers a chance to settle */
  1194. jiff = jiffies + CONF_POST_OPEN;
  1195. while (time_before(jiffies, jiff))
  1196. ;
  1198. /*
  1199.  * If the config information is insufficient (e.g., our IP address or
  1200.  * IP address of the boot server is missing or we have multiple network
  1201.  * interfaces and no default was set), use BOOTP or RARP to get the
  1202.  * missing values.
  1203.  */
  1204. if (ic_myaddr == INADDR_NONE ||
  1205. #ifdef CONFIG_ROOT_NFS
  1206.     (MAJOR(ROOT_DEV) == UNNAMED_MAJOR
  1207.      && root_server_addr == INADDR_NONE
  1208.      && ic_servaddr == INADDR_NONE) ||
  1209. #endif
  1210.     ic_first_dev->next) {
  1211. #ifdef IPCONFIG_DYNAMIC
  1213. int retries = CONF_OPEN_RETRIES;
  1215. if (ic_dynamic() < 0) {
  1216. ic_close_devs();
  1218. /*
  1219.  * I don't know why, but sometimes the
  1220.  * eepro100 driver (at least) gets upset and
  1221.  * doesn't work the first time it's opened.
  1222.  * But then if you close it and reopen it, it
  1223.  * works just fine.  So we need to try that at
  1224.  * least once before giving up.
  1225.  *
  1226.  * Also, if the root will be NFS-mounted, we
  1227.  * have nowhere to go if DHCP fails.  So we
  1228.  * just have to keep trying forever.
  1229.  *
  1230.  *  -- Chip
  1231.  */
  1232. #ifdef CONFIG_ROOT_NFS
  1233. if (ROOT_DEV == MKDEV(UNNAMED_MAJOR, 255)) {
  1234. printk(KERN_ERR 
  1235. "IP-Config: Retrying forever (NFS root)...n");
  1236. goto try_try_again;
  1237. }
  1238. #endif
  1240. if (--retries) {
  1241. printk(KERN_ERR 
  1242.        "IP-Config: Reopening network devices...n");
  1243. goto try_try_again;
  1244. }
  1246. /* Oh, well.  At least we tried. */
  1247. printk(KERN_ERR "IP-Config: Auto-configuration of network failed.n");
  1248. return -1;
  1249. }
  1250. #else /* !DYNAMIC */
  1251. printk(KERN_ERR "IP-Config: Incomplete network configuration information.n");
  1252. ic_close_devs();
  1253. return -1;
  1254. #endif /* IPCONFIG_DYNAMIC */
  1255. } else {
  1256. /* Device selected manually or only one device -> use it */
  1257. ic_dev = ic_first_dev->dev;
  1258. }
  1260. addr = root_nfs_parse_addr(root_server_path);
  1261. if (root_server_addr == INADDR_NONE)
  1262. root_server_addr = addr;
  1264. /*
  1265.  * Use defaults whereever applicable.
  1266.  */
  1267. if (ic_defaults() < 0)
  1268. return -1;
  1270. /*
  1271.  * Close all network devices except the device we've
  1272.  * autoconfigured and set up routes.
  1273.  */
  1274. ic_close_devs();
  1275. if (ic_setup_if() < 0 || ic_setup_routes() < 0)
  1276. return -1;
  1278. /*
  1279.  * Record which protocol was actually used.
  1280.  */
  1281. #ifdef IPCONFIG_DYNAMIC
  1282. ic_proto_used = ic_got_reply | (ic_proto_enabled & IC_USE_DHCP);
  1283. #endif
  1285. #ifndef IPCONFIG_SILENT
  1286. /*
  1287.  * Clue in the operator.
  1288.  */
  1289. printk("IP-Config: Complete:");
  1290. printk("n      device=%s", ic_dev->name);
  1291. printk(", addr=%u.%u.%u.%u", NIPQUAD(ic_myaddr));
  1292. printk(", mask=%u.%u.%u.%u", NIPQUAD(ic_netmask));
  1293. printk(", gw=%u.%u.%u.%u", NIPQUAD(ic_gateway));
  1294. printk(",n     host=%s, domain=%s, nis-domain=%s",
  1295.        system_utsname.nodename, ic_domain, system_utsname.domainname);
  1296. printk(",n     bootserver=%u.%u.%u.%u", NIPQUAD(ic_servaddr));
  1297. printk(", rootserver=%u.%u.%u.%u", NIPQUAD(root_server_addr));
  1298. printk(", rootpath=%s", root_server_path);
  1299. printk("n");
  1300. #endif /* !SILENT */
  1302. return 0;
  1303. }
  1305. module_init(ip_auto_config);
  1308. /*
  1309.  *  Decode any IP configuration options in the "ip=" or "nfsaddrs=" kernel
  1310.  *  command line parameter. It consists of option fields separated by colons in
  1311.  *  the following order:
  1312.  *
  1313.  *  <client-ip>:<server-ip>:<gw-ip>:<netmask>:<host name>:<device>:<PROTO>
  1314.  *
  1315.  *  Any of the fields can be empty which means to use a default value:
  1316.  * <client-ip> - address given by BOOTP or RARP
  1317.  * <server-ip> - address of host returning BOOTP or RARP packet
  1318.  * <gw-ip> - none, or the address returned by BOOTP
  1319.  * <netmask> - automatically determined from <client-ip>, or the
  1320.  *   one returned by BOOTP
  1321.  * <host name> - <client-ip> in ASCII notation, or the name returned
  1322.  *   by BOOTP
  1323.  * <device> - use all available devices
  1324.  * <PROTO>:
  1325.  *    off|none     - don't do autoconfig at all (DEFAULT)
  1326.  *    on|any           - use any configured protocol
  1327.  *    dhcp|bootp|rarp  - use only the specified protocol
  1328.  *    both             - use both BOOTP and RARP (not DHCP)
  1329.  */
  1330. static int __init ic_proto_name(char *name)
  1331. {
  1332. if (!strcmp(name, "on") || !strcmp(name, "any")) {
  1333. return 1;
  1334. }
  1335. #ifdef CONFIG_IP_PNP_DHCP
  1336. else if (!strcmp(name, "dhcp")) {
  1337. ic_proto_enabled &= ~IC_RARP;
  1338. return 1;
  1339. }
  1340. #endif
  1341. #ifdef CONFIG_IP_PNP_BOOTP
  1342. else if (!strcmp(name, "bootp")) {
  1343. ic_proto_enabled &= ~(IC_RARP | IC_USE_DHCP);
  1344. return 1;
  1345. }
  1346. #endif
  1347. #ifdef CONFIG_IP_PNP_RARP
  1348. else if (!strcmp(name, "rarp")) {
  1349. ic_proto_enabled &= ~(IC_BOOTP | IC_USE_DHCP);
  1350. return 1;
  1351. }
  1352. #endif
  1353. #ifdef IPCONFIG_DYNAMIC
  1354. else if (!strcmp(name, "both")) {
  1355. ic_proto_enabled &= ~IC_USE_DHCP; /* backward compat :-( */
  1356. return 1;
  1357. }
  1358. #endif
  1359. return 0;
  1360. }
  1362. static int __init ip_auto_config_setup(char *addrs)
  1363. {
  1364. char *cp, *ip, *dp;
  1365. int num = 0;
  1367. ic_set_manually = 1;
  1369. ic_enable = (*addrs && 
  1370. (strcmp(addrs, "off") != 0) && 
  1371. (strcmp(addrs, "none") != 0));
  1372. if (!ic_enable)
  1373. return 1;
  1375. if (ic_proto_name(addrs))
  1376. return 1;
  1378. /* Parse the whole string */
  1379. ip = addrs;
  1380. while (ip && *ip) {
  1381. if ((cp = strchr(ip, ':')))
  1382. *cp++ = '';
  1383. if (strlen(ip) > 0) {
  1384. DBG(("IP-Config: Parameter #%d: `%s'n", num, ip));
  1385. switch (num) {
  1386. case 0:
  1387. if ((ic_myaddr = in_aton(ip)) == INADDR_ANY)
  1388. ic_myaddr = INADDR_NONE;
  1389. break;
  1390. case 1:
  1391. if ((ic_servaddr = in_aton(ip)) == INADDR_ANY)
  1392. ic_servaddr = INADDR_NONE;
  1393. break;
  1394. case 2:
  1395. if ((ic_gateway = in_aton(ip)) == INADDR_ANY)
  1396. ic_gateway = INADDR_NONE;
  1397. break;
  1398. case 3:
  1399. if ((ic_netmask = in_aton(ip)) == INADDR_ANY)
  1400. ic_netmask = INADDR_NONE;
  1401. break;
  1402. case 4:
  1403. if ((dp = strchr(ip, '.'))) {
  1404. *dp++ = '';
  1405. strncpy(system_utsname.domainname, dp, __NEW_UTS_LEN);
  1406. system_utsname.domainname[__NEW_UTS_LEN] = '';
  1407. }
  1408. strncpy(system_utsname.nodename, ip, __NEW_UTS_LEN);
  1409. system_utsname.nodename[__NEW_UTS_LEN] = '';
  1410. ic_host_name_set = 1;
  1411. break;
  1412. case 5:
  1413. strncpy(user_dev_name, ip, IFNAMSIZ);
  1414. user_dev_name[IFNAMSIZ-1] = '';
  1415. break;
  1416. case 6:
  1417. ic_proto_name(ip);
  1418. break;
  1419. }
  1420. }
  1421. ip = cp;
  1422. num++;
  1423. }
  1425. return 1;
  1426. }
  1428. static int __init nfsaddrs_config_setup(char *addrs)
  1429. {
  1430. return ip_auto_config_setup(addrs);
  1431. }
  1433. __setup("ip=", ip_auto_config_setup);
  1434. __setup("nfsaddrs=", nfsaddrs_config_setup);