af_inet.c 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * PF_INET protocol family socket handler.
  7. *
  8. * Version: $Id: af_inet.c,v 1.1.1.1 2007/06/12 07:27:14 eyryu Exp $
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Florian La Roche, <flla@stud.uni-sb.de>
  13. * Alan Cox, <A.Cox@swansea.ac.uk>
  14. *
  15. * Changes (see also sock.c)
  16. *
  17. * piggy,
  18. * Karl Knutson : Socket protocol table
  19. * A.N.Kuznetsov : Socket death error in accept().
  20. * John Richardson : Fix non blocking error in connect()
  21. * so sockets that fail to connect
  22. * don't return -EINPROGRESS.
  23. * Alan Cox : Asynchronous I/O support
  24. * Alan Cox : Keep correct socket pointer on sock
  25. * structures
  26. * when accept() ed
  27. * Alan Cox : Semantics of SO_LINGER aren't state
  28. * moved to close when you look carefully.
  29. * With this fixed and the accept bug fixed
  30. * some RPC stuff seems happier.
  31. * Niibe Yutaka : 4.4BSD style write async I/O
  32. * Alan Cox,
  33. * Tony Gale : Fixed reuse semantics.
  34. * Alan Cox : bind() shouldn't abort existing but dead
  35. * sockets. Stops FTP netin:.. I hope.
  36. * Alan Cox : bind() works correctly for RAW sockets.
  37. * Note that FreeBSD at least was broken
  38. * in this respect so be careful with
  39. * compatibility tests...
  40. * Alan Cox : routing cache support
  41. * Alan Cox : memzero the socket structure for
  42. * compactness.
  43. * Matt Day : nonblock connect error handler
  44. * Alan Cox : Allow large numbers of pending sockets
  45. * (eg for big web sites), but only if
  46. * specifically application requested.
  47. * Alan Cox : New buffering throughout IP. Used
  48. * dumbly.
  49. * Alan Cox : New buffering now used smartly.
  50. * Alan Cox : BSD rather than common sense
  51. * interpretation of listen.
  52. * Germano Caronni : Assorted small races.
  53. * Alan Cox : sendmsg/recvmsg basic support.
  54. * Alan Cox : Only sendmsg/recvmsg now supported.
  55. * Alan Cox : Locked down bind (see security list).
  56. * Alan Cox : Loosened bind a little.
  57. * Mike McLagan : ADD/DEL DLCI Ioctls
  58. * Willy Konynenberg : Transparent proxying support.
  59. * David S. Miller : New socket lookup architecture.
  60. * Some other random speedups.
  61. * Cyrus Durgin : Cleaned up file for kmod hacks.
  62. * Andi Kleen : Fix inet_stream_connect TCP race.
  63. *
  64. * This program is free software; you can redistribute it and/or
  65. * modify it under the terms of the GNU General Public License
  66. * as published by the Free Software Foundation; either version
  67. * 2 of the License, or (at your option) any later version.
  68. */
  69. #include <linux/err.h>
  70. #include <linux/errno.h>
  71. #include <linux/types.h>
  72. #include <linux/socket.h>
  73. #include <linux/in.h>
  74. #include <linux/kernel.h>
  75. #include <linux/module.h>
  76. #include <linux/sched.h>
  77. #include <linux/timer.h>
  78. #include <linux/string.h>
  79. #include <linux/sockios.h>
  80. #include <linux/net.h>
  81. #include <linux/capability.h>
  82. #include <linux/fcntl.h>
  83. #include <linux/mm.h>
  84. #include <linux/interrupt.h>
  85. #include <linux/stat.h>
  86. #include <linux/init.h>
  87. #include <linux/poll.h>
  88. #include <linux/netfilter_ipv4.h>
  89. #include <asm/uaccess.h>
  90. #include <asm/system.h>
  91. #include <linux/smp_lock.h>
  92. #include <linux/inet.h>
  93. #include <linux/igmp.h>
  94. #include <linux/inetdevice.h>
  95. #include <linux/netdevice.h>
  96. #include <net/ip.h>
  97. #include <net/protocol.h>
  98. #include <net/arp.h>
  99. #include <net/route.h>
  100. #include <net/ip_fib.h>
  101. #include <net/inet_connection_sock.h>
  102. #include <net/tcp.h>
  103. #include <net/udp.h>
  104. #include <net/udplite.h>
  105. #include <linux/skbuff.h>
  106. #include <net/sock.h>
  107. #include <net/raw.h>
  108. #include <net/icmp.h>
  109. #include <net/ipip.h>
  110. #include <net/inet_common.h>
  111. #include <net/xfrm.h>
  112. #ifdef CONFIG_IP_MROUTE
  113. #include <linux/mroute.h>
  114. #endif
  115. DEFINE_SNMP_STAT(struct linux_mib, net_statistics) __read_mostly;
  116. extern void ip_mc_drop_socket(struct sock *sk);
  117. /* The inetsw table contains everything that inet_create needs to
  118. * build a new socket.
  119. */
  120. static struct list_head inetsw[SOCK_MAX];
  121. static DEFINE_SPINLOCK(inetsw_lock);
  122. /* New destruction routine */
  123. void inet_sock_destruct(struct sock *sk)
  124. {
  125. struct inet_sock *inet = inet_sk(sk);
  126. __skb_queue_purge(&sk->sk_receive_queue);
  127. __skb_queue_purge(&sk->sk_error_queue);
  128. if (sk->sk_type == SOCK_STREAM && sk->sk_state != TCP_CLOSE) {
  129. printk("Attempt to release TCP socket in state %d %p\n",
  130. sk->sk_state, sk);
  131. return;
  132. }
  133. if (!sock_flag(sk, SOCK_DEAD)) {
  134. printk("Attempt to release alive inet socket %p\n", sk);
  135. return;
  136. }
  137. BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
  138. BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
  139. BUG_TRAP(!sk->sk_wmem_queued);
  140. BUG_TRAP(!sk->sk_forward_alloc);
  141. kfree(inet->opt);
  142. dst_release(sk->sk_dst_cache);
  143. sk_refcnt_debug_dec(sk);
  144. }
  145. /*
  146. * The routines beyond this point handle the behaviour of an AF_INET
  147. * socket object. Mostly it punts to the subprotocols of IP to do
  148. * the work.
  149. */
  150. /*
  151. * Automatically bind an unbound socket.
  152. */
  153. static int inet_autobind(struct sock *sk)
  154. {
  155. struct inet_sock *inet;
  156. /* We may need to bind the socket. */
  157. lock_sock(sk);
  158. inet = inet_sk(sk);
  159. if (!inet->num) {
  160. if (sk->sk_prot->get_port(sk, 0)) {
  161. release_sock(sk);
  162. return -EAGAIN;
  163. }
  164. inet->sport = htons(inet->num);
  165. }
  166. release_sock(sk);
  167. return 0;
  168. }
  169. /*
  170. * Move a socket into listening state.
  171. */
  172. int inet_listen(struct socket *sock, int backlog)
  173. {
  174. struct sock *sk = sock->sk;
  175. unsigned char old_state;
  176. int err;
  177. lock_sock(sk);
  178. err = -EINVAL;
  179. if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)
  180. goto out;
  181. old_state = sk->sk_state;
  182. if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN)))
  183. goto out;
  184. /* Really, if the socket is already in listen state
  185. * we can only allow the backlog to be adjusted.
  186. */
  187. if (old_state != TCP_LISTEN) {
  188. err = inet_csk_listen_start(sk, backlog);
  189. if (err)
  190. goto out;
  191. }
  192. sk->sk_max_ack_backlog = backlog;
  193. err = 0;
  194. out:
  195. release_sock(sk);
  196. return err;
  197. }
  198. /*
  199. * Create an inet socket.
  200. */
  201. static int inet_create(struct socket *sock, int protocol)
  202. {
  203. struct sock *sk;
  204. struct list_head *p;
  205. struct inet_protosw *answer;
  206. struct inet_sock *inet;
  207. struct proto *answer_prot;
  208. unsigned char answer_flags;
  209. char answer_no_check;
  210. int try_loading_module = 0;
  211. int err;
  212. sock->state = SS_UNCONNECTED;
  213. /* Look for the requested type/protocol pair. */
  214. answer = NULL;
  215. lookup_protocol:
  216. err = -ESOCKTNOSUPPORT;
  217. rcu_read_lock();
  218. list_for_each_rcu(p, &inetsw[sock->type]) {
  219. answer = list_entry(p, struct inet_protosw, list);
  220. /* Check the non-wild match. */
  221. if (protocol == answer->protocol) {
  222. if (protocol != IPPROTO_IP)
  223. break;
  224. } else {
  225. /* Check for the two wild cases. */
  226. if (IPPROTO_IP == protocol) {
  227. protocol = answer->protocol;
  228. break;
  229. }
  230. if (IPPROTO_IP == answer->protocol)
  231. break;
  232. }
  233. err = -EPROTONOSUPPORT;
  234. answer = NULL;
  235. }
  236. if (unlikely(answer == NULL)) {
  237. if (try_loading_module < 2) {
  238. rcu_read_unlock();
  239. /*
  240. * Be more specific, e.g. net-pf-2-proto-132-type-1
  241. * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
  242. */
  243. if (++try_loading_module == 1)
  244. request_module("net-pf-%d-proto-%d-type-%d",
  245. PF_INET, protocol, sock->type);
  246. /*
  247. * Fall back to generic, e.g. net-pf-2-proto-132
  248. * (net-pf-PF_INET-proto-IPPROTO_SCTP)
  249. */
  250. else
  251. request_module("net-pf-%d-proto-%d",
  252. PF_INET, protocol);
  253. goto lookup_protocol;
  254. } else
  255. goto out_rcu_unlock;
  256. }
  257. err = -EPERM;
  258. if (answer->capability > 0 && !capable(answer->capability))
  259. goto out_rcu_unlock;
  260. sock->ops = answer->ops;
  261. answer_prot = answer->prot;
  262. answer_no_check = answer->no_check;
  263. answer_flags = answer->flags;
  264. rcu_read_unlock();
  265. BUG_TRAP(answer_prot->slab != NULL);
  266. err = -ENOBUFS;
  267. sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);
  268. if (sk == NULL)
  269. goto out;
  270. err = 0;
  271. sk->sk_no_check = answer_no_check;
  272. if (INET_PROTOSW_REUSE & answer_flags)
  273. sk->sk_reuse = 1;
  274. inet = inet_sk(sk);
  275. inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
  276. if (SOCK_RAW == sock->type) {
  277. inet->num = protocol;
  278. if (IPPROTO_RAW == protocol)
  279. inet->hdrincl = 1;
  280. }
  281. if (ipv4_config.no_pmtu_disc)
  282. inet->pmtudisc = IP_PMTUDISC_DONT;
  283. else
  284. inet->pmtudisc = IP_PMTUDISC_WANT;
  285. inet->id = 0;
  286. sock_init_data(sock, sk);
  287. sk->sk_destruct = inet_sock_destruct;
  288. sk->sk_family = PF_INET;
  289. sk->sk_protocol = protocol;
  290. sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
  291. inet->uc_ttl = -1;
  292. inet->mc_loop = 1;
  293. inet->mc_ttl = 1;
  294. inet->mc_index = 0;
  295. inet->mc_list = NULL;
  296. sk_refcnt_debug_inc(sk);
  297. if (inet->num) {
  298. /* It assumes that any protocol which allows
  299. * the user to assign a number at socket
  300. * creation time automatically
  301. * shares.
  302. */
  303. inet->sport = htons(inet->num);
  304. /* Add to protocol hash chains. */
  305. sk->sk_prot->hash(sk);
  306. }
  307. if (sk->sk_prot->init) {
  308. err = sk->sk_prot->init(sk);
  309. if (err)
  310. sk_common_release(sk);
  311. }
  312. out:
  313. return err;
  314. out_rcu_unlock:
  315. rcu_read_unlock();
  316. goto out;
  317. }
  318. /*
  319. * The peer socket should always be NULL (or else). When we call this
  320. * function we are destroying the object and from then on nobody
  321. * should refer to it.
  322. */
  323. int inet_release(struct socket *sock)
  324. {
  325. struct sock *sk = sock->sk;
  326. if (sk) {
  327. long timeout;
  328. /* Applications forget to leave groups before exiting */
  329. ip_mc_drop_socket(sk);
  330. /* If linger is set, we don't return until the close
  331. * is complete. Otherwise we return immediately. The
  332. * actually closing is done the same either way.
  333. *
  334. * If the close is due to the process exiting, we never
  335. * linger..
  336. */
  337. timeout = 0;
  338. if (sock_flag(sk, SOCK_LINGER) &&
  339. !(current->flags & PF_EXITING))
  340. timeout = sk->sk_lingertime;
  341. sock->sk = NULL;
  342. sk->sk_prot->close(sk, timeout);
  343. }
  344. return 0;
  345. }
  346. /* It is off by default, see below. */
  347. int sysctl_ip_nonlocal_bind __read_mostly;
  348. int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  349. {
  350. struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
  351. struct sock *sk = sock->sk;
  352. struct inet_sock *inet = inet_sk(sk);
  353. unsigned short snum;
  354. int chk_addr_ret;
  355. int err;
  356. /* If the socket has its own bind function then use it. (RAW) */
  357. if (sk->sk_prot->bind) {
  358. err = sk->sk_prot->bind(sk, uaddr, addr_len);
  359. goto out;
  360. }
  361. err = -EINVAL;
  362. if (addr_len < sizeof(struct sockaddr_in))
  363. goto out;
  364. chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr);
  365. /* Not specified by any standard per-se, however it breaks too
  366. * many applications when removed. It is unfortunate since
  367. * allowing applications to make a non-local bind solves
  368. * several problems with systems using dynamic addressing.
  369. * (ie. your servers still start up even if your ISDN link
  370. * is temporarily down)
  371. */
  372. err = -EADDRNOTAVAIL;
  373. if (!sysctl_ip_nonlocal_bind &&
  374. !inet->freebind &&
  375. addr->sin_addr.s_addr != INADDR_ANY &&
  376. chk_addr_ret != RTN_LOCAL &&
  377. chk_addr_ret != RTN_MULTICAST &&
  378. chk_addr_ret != RTN_BROADCAST)
  379. goto out;
  380. snum = ntohs(addr->sin_port);
  381. err = -EACCES;
  382. if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
  383. goto out;
  384. /* We keep a pair of addresses. rcv_saddr is the one
  385. * used by hash lookups, and saddr is used for transmit.
  386. *
  387. * In the BSD API these are the same except where it
  388. * would be illegal to use them (multicast/broadcast) in
  389. * which case the sending device address is used.
  390. */
  391. lock_sock(sk);
  392. /* Check these errors (active socket, double bind). */
  393. err = -EINVAL;
  394. if (sk->sk_state != TCP_CLOSE || inet->num)
  395. goto out_release_sock;
  396. inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
  397. if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
  398. inet->saddr = 0; /* Use device */
  399. /* Make sure we are allowed to bind here. */
  400. if (sk->sk_prot->get_port(sk, snum)) {
  401. inet->saddr = inet->rcv_saddr = 0;
  402. err = -EADDRINUSE;
  403. goto out_release_sock;
  404. }
  405. if (inet->rcv_saddr)
  406. sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
  407. if (snum)
  408. sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
  409. inet->sport = htons(inet->num);
  410. inet->daddr = 0;
  411. inet->dport = 0;
  412. sk_dst_reset(sk);
  413. err = 0;
  414. out_release_sock:
  415. release_sock(sk);
  416. out:
  417. return err;
  418. }
  419. int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
  420. int addr_len, int flags)
  421. {
  422. struct sock *sk = sock->sk;
  423. if (uaddr->sa_family == AF_UNSPEC)
  424. return sk->sk_prot->disconnect(sk, flags);
  425. if (!inet_sk(sk)->num && inet_autobind(sk))
  426. return -EAGAIN;
  427. return sk->sk_prot->connect(sk, (struct sockaddr *)uaddr, addr_len);
  428. }
  429. static long inet_wait_for_connect(struct sock *sk, long timeo)
  430. {
  431. DEFINE_WAIT(wait);
  432. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  433. /* Basic assumption: if someone sets sk->sk_err, he _must_
  434. * change state of the socket from TCP_SYN_*.
  435. * Connect() does not allow to get error notifications
  436. * without closing the socket.
  437. */
  438. while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
  439. release_sock(sk);
  440. timeo = schedule_timeout(timeo);
  441. lock_sock(sk);
  442. if (signal_pending(current) || !timeo)
  443. break;
  444. prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
  445. }
  446. finish_wait(sk->sk_sleep, &wait);
  447. return timeo;
  448. }
  449. /*
  450. * Connect to a remote host. There is regrettably still a little
  451. * TCP 'magic' in here.
  452. */
  453. int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
  454. int addr_len, int flags)
  455. {
  456. struct sock *sk = sock->sk;
  457. int err;
  458. long timeo;
  459. lock_sock(sk);
  460. if (uaddr->sa_family == AF_UNSPEC) {
  461. err = sk->sk_prot->disconnect(sk, flags);
  462. sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
  463. goto out;
  464. }
  465. switch (sock->state) {
  466. default:
  467. err = -EINVAL;
  468. goto out;
  469. case SS_CONNECTED:
  470. err = -EISCONN;
  471. goto out;
  472. case SS_CONNECTING:
  473. err = -EALREADY;
  474. /* Fall out of switch with err, set for this state */
  475. break;
  476. case SS_UNCONNECTED:
  477. err = -EISCONN;
  478. if (sk->sk_state != TCP_CLOSE)
  479. goto out;
  480. err = sk->sk_prot->connect(sk, uaddr, addr_len);
  481. if (err < 0)
  482. goto out;
  483. sock->state = SS_CONNECTING;
  484. /* Just entered SS_CONNECTING state; the only
  485. * difference is that return value in non-blocking
  486. * case is EINPROGRESS, rather than EALREADY.
  487. */
  488. err = -EINPROGRESS;
  489. break;
  490. }
  491. timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
  492. if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
  493. /* Error code is set above */
  494. if (!timeo || !inet_wait_for_connect(sk, timeo))
  495. goto out;
  496. err = sock_intr_errno(timeo);
  497. if (signal_pending(current))
  498. goto out;
  499. }
  500. /* Connection was closed by RST, timeout, ICMP error
  501. * or another process disconnected us.
  502. */
  503. if (sk->sk_state == TCP_CLOSE)
  504. goto sock_error;
  505. /* sk->sk_err may be not zero now, if RECVERR was ordered by user
  506. * and error was received after socket entered established state.
  507. * Hence, it is handled normally after connect() return successfully.
  508. */
  509. sock->state = SS_CONNECTED;
  510. err = 0;
  511. out:
  512. release_sock(sk);
  513. return err;
  514. sock_error:
  515. err = sock_error(sk) ? : -ECONNABORTED;
  516. sock->state = SS_UNCONNECTED;
  517. if (sk->sk_prot->disconnect(sk, flags))
  518. sock->state = SS_DISCONNECTING;
  519. goto out;
  520. }
  521. /*
  522. * Accept a pending connection. The TCP layer now gives BSD semantics.
  523. */
  524. int inet_accept(struct socket *sock, struct socket *newsock, int flags)
  525. {
  526. struct sock *sk1 = sock->sk;
  527. int err = -EINVAL;
  528. struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err);
  529. if (!sk2)
  530. goto do_err;
  531. lock_sock(sk2);
  532. BUG_TRAP((1 << sk2->sk_state) &
  533. (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE));
  534. sock_graft(sk2, newsock);
  535. newsock->state = SS_CONNECTED;
  536. err = 0;
  537. release_sock(sk2);
  538. do_err:
  539. return err;
  540. }
  541. /*
  542. * This does both peername and sockname.
  543. */
  544. int inet_getname(struct socket *sock, struct sockaddr *uaddr,
  545. int *uaddr_len, int peer)
  546. {
  547. struct sock *sk = sock->sk;
  548. struct inet_sock *inet = inet_sk(sk);
  549. struct sockaddr_in *sin = (struct sockaddr_in *)uaddr;
  550. sin->sin_family = AF_INET;
  551. if (peer) {
  552. if (!inet->dport ||
  553. (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
  554. peer == 1))
  555. return -ENOTCONN;
  556. sin->sin_port = inet->dport;
  557. sin->sin_addr.s_addr = inet->daddr;
  558. } else {
  559. __be32 addr = inet->rcv_saddr;
  560. if (!addr)
  561. addr = inet->saddr;
  562. sin->sin_port = inet->sport;
  563. sin->sin_addr.s_addr = addr;
  564. }
  565. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  566. *uaddr_len = sizeof(*sin);
  567. return 0;
  568. }
  569. int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
  570. size_t size)
  571. {
  572. struct sock *sk = sock->sk;
  573. /* We may need to bind the socket. */
  574. if (!inet_sk(sk)->num && inet_autobind(sk))
  575. return -EAGAIN;
  576. return sk->sk_prot->sendmsg(iocb, sk, msg, size);
  577. }
  578. static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
  579. {
  580. struct sock *sk = sock->sk;
  581. /* We may need to bind the socket. */
  582. if (!inet_sk(sk)->num && inet_autobind(sk))
  583. return -EAGAIN;
  584. if (sk->sk_prot->sendpage)
  585. return sk->sk_prot->sendpage(sk, page, offset, size, flags);
  586. return sock_no_sendpage(sock, page, offset, size, flags);
  587. }
  588. int inet_shutdown(struct socket *sock, int how)
  589. {
  590. struct sock *sk = sock->sk;
  591. int err = 0;
  592. /* This should really check to make sure
  593. * the socket is a TCP socket. (WHY AC...)
  594. */
  595. how++; /* maps 0->1 has the advantage of making bit 1 rcvs and
  596. 1->2 bit 2 snds.
  597. 2->3 */
  598. if ((how & ~SHUTDOWN_MASK) || !how) /* MAXINT->0 */
  599. return -EINVAL;
  600. lock_sock(sk);
  601. if (sock->state == SS_CONNECTING) {
  602. if ((1 << sk->sk_state) &
  603. (TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_CLOSE))
  604. sock->state = SS_DISCONNECTING;
  605. else
  606. sock->state = SS_CONNECTED;
  607. }
  608. switch (sk->sk_state) {
  609. case TCP_CLOSE:
  610. err = -ENOTCONN;
  611. /* Hack to wake up other listeners, who can poll for
  612. POLLHUP, even on eg. unconnected UDP sockets -- RR */
  613. default:
  614. sk->sk_shutdown |= how;
  615. if (sk->sk_prot->shutdown)
  616. sk->sk_prot->shutdown(sk, how);
  617. break;
  618. /* Remaining two branches are temporary solution for missing
  619. * close() in multithreaded environment. It is _not_ a good idea,
  620. * but we have no choice until close() is repaired at VFS level.
  621. */
  622. case TCP_LISTEN:
  623. if (!(how & RCV_SHUTDOWN))
  624. break;
  625. /* Fall through */
  626. case TCP_SYN_SENT:
  627. err = sk->sk_prot->disconnect(sk, O_NONBLOCK);
  628. sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
  629. break;
  630. }
  631. /* Wake up anyone sleeping in poll. */
  632. sk->sk_state_change(sk);
  633. release_sock(sk);
  634. return err;
  635. }
  636. /*
  637. * ioctl() calls you can issue on an INET socket. Most of these are
  638. * device configuration and stuff and very rarely used. Some ioctls
  639. * pass on to the socket itself.
  640. *
  641. * NOTE: I like the idea of a module for the config stuff. ie ifconfig
  642. * loads the devconfigure module does its configuring and unloads it.
  643. * There's a good 20K of config code hanging around the kernel.
  644. */
  645. int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  646. {
  647. struct sock *sk = sock->sk;
  648. int err = 0;
  649. switch (cmd) {
  650. case SIOCGSTAMP:
  651. err = sock_get_timestamp(sk, (struct timeval __user *)arg);
  652. break;
  653. case SIOCADDRT:
  654. case SIOCDELRT:
  655. case SIOCRTMSG:
  656. err = ip_rt_ioctl(cmd, (void __user *)arg);
  657. break;
  658. case SIOCDARP:
  659. case SIOCGARP:
  660. case SIOCSARP:
  661. err = arp_ioctl(cmd, (void __user *)arg);
  662. break;
  663. case SIOCGIFADDR:
  664. case SIOCSIFADDR:
  665. case SIOCGIFBRDADDR:
  666. case SIOCSIFBRDADDR:
  667. case SIOCGIFNETMASK:
  668. case SIOCSIFNETMASK:
  669. case SIOCGIFDSTADDR:
  670. case SIOCSIFDSTADDR:
  671. case SIOCSIFPFLAGS:
  672. case SIOCGIFPFLAGS:
  673. case SIOCSIFFLAGS:
  674. err = devinet_ioctl(cmd, (void __user *)arg);
  675. break;
  676. default:
  677. if (sk->sk_prot->ioctl)
  678. err = sk->sk_prot->ioctl(sk, cmd, arg);
  679. else
  680. err = -ENOIOCTLCMD;
  681. break;
  682. }
  683. return err;
  684. }
  685. const struct proto_ops inet_stream_ops = {
  686. .family = PF_INET,
  687. .owner = THIS_MODULE,
  688. .release = inet_release,
  689. .bind = inet_bind,
  690. .connect = inet_stream_connect,
  691. .socketpair = sock_no_socketpair,
  692. .accept = inet_accept,
  693. .getname = inet_getname,
  694. .poll = tcp_poll,
  695. .ioctl = inet_ioctl,
  696. .listen = inet_listen,
  697. .shutdown = inet_shutdown,
  698. .setsockopt = sock_common_setsockopt,
  699. .getsockopt = sock_common_getsockopt,
  700. .sendmsg = inet_sendmsg,
  701. .recvmsg = sock_common_recvmsg,
  702. .mmap = sock_no_mmap,
  703. .sendpage = tcp_sendpage,
  704. #ifdef CONFIG_COMPAT
  705. .compat_setsockopt = compat_sock_common_setsockopt,
  706. .compat_getsockopt = compat_sock_common_getsockopt,
  707. #endif
  708. };
  709. const struct proto_ops inet_dgram_ops = {
  710. .family = PF_INET,
  711. .owner = THIS_MODULE,
  712. .release = inet_release,
  713. .bind = inet_bind,
  714. .connect = inet_dgram_connect,
  715. .socketpair = sock_no_socketpair,
  716. .accept = sock_no_accept,
  717. .getname = inet_getname,
  718. .poll = udp_poll,
  719. .ioctl = inet_ioctl,
  720. .listen = sock_no_listen,
  721. .shutdown = inet_shutdown,
  722. .setsockopt = sock_common_setsockopt,
  723. .getsockopt = sock_common_getsockopt,
  724. .sendmsg = inet_sendmsg,
  725. .recvmsg = sock_common_recvmsg,
  726. .mmap = sock_no_mmap,
  727. .sendpage = inet_sendpage,
  728. #ifdef CONFIG_COMPAT
  729. .compat_setsockopt = compat_sock_common_setsockopt,
  730. .compat_getsockopt = compat_sock_common_getsockopt,
  731. #endif
  732. };
  733. /*
  734. * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
  735. * udp_poll
  736. */
  737. static const struct proto_ops inet_sockraw_ops = {
  738. .family = PF_INET,
  739. .owner = THIS_MODULE,
  740. .release = inet_release,
  741. .bind = inet_bind,
  742. .connect = inet_dgram_connect,
  743. .socketpair = sock_no_socketpair,
  744. .accept = sock_no_accept,
  745. .getname = inet_getname,
  746. .poll = datagram_poll,
  747. .ioctl = inet_ioctl,
  748. .listen = sock_no_listen,
  749. .shutdown = inet_shutdown,
  750. .setsockopt = sock_common_setsockopt,
  751. .getsockopt = sock_common_getsockopt,
  752. .sendmsg = inet_sendmsg,
  753. .recvmsg = sock_common_recvmsg,
  754. .mmap = sock_no_mmap,
  755. .sendpage = inet_sendpage,
  756. #ifdef CONFIG_COMPAT
  757. .compat_setsockopt = compat_sock_common_setsockopt,
  758. .compat_getsockopt = compat_sock_common_getsockopt,
  759. #endif
  760. };
  761. static struct net_proto_family inet_family_ops = {
  762. .family = PF_INET,
  763. .create = inet_create,
  764. .owner = THIS_MODULE,
  765. };
  766. /* Upon startup we insert all the elements in inetsw_array[] into
  767. * the linked list inetsw.
  768. */
  769. static struct inet_protosw inetsw_array[] =
  770. {
  771. {
  772. .type = SOCK_STREAM,
  773. .protocol = IPPROTO_TCP,
  774. .prot = &tcp_prot,
  775. .ops = &inet_stream_ops,
  776. .capability = -1,
  777. .no_check = 0,
  778. .flags = INET_PROTOSW_PERMANENT |
  779. INET_PROTOSW_ICSK,
  780. },
  781. {
  782. .type = SOCK_DGRAM,
  783. .protocol = IPPROTO_UDP,
  784. .prot = &udp_prot,
  785. .ops = &inet_dgram_ops,
  786. .capability = -1,
  787. .no_check = UDP_CSUM_DEFAULT,
  788. .flags = INET_PROTOSW_PERMANENT,
  789. },
  790. {
  791. .type = SOCK_RAW,
  792. .protocol = IPPROTO_IP, /* wild card */
  793. .prot = &raw_prot,
  794. .ops = &inet_sockraw_ops,
  795. .capability = CAP_NET_RAW,
  796. .no_check = UDP_CSUM_DEFAULT,
  797. .flags = INET_PROTOSW_REUSE,
  798. }
  799. };
  800. #define INETSW_ARRAY_LEN (sizeof(inetsw_array) / sizeof(struct inet_protosw))
  801. void inet_register_protosw(struct inet_protosw *p)
  802. {
  803. struct list_head *lh;
  804. struct inet_protosw *answer;
  805. int protocol = p->protocol;
  806. struct list_head *last_perm;
  807. spin_lock_bh(&inetsw_lock);
  808. if (p->type >= SOCK_MAX)
  809. goto out_illegal;
  810. /* If we are trying to override a permanent protocol, bail. */
  811. answer = NULL;
  812. last_perm = &inetsw[p->type];
  813. list_for_each(lh, &inetsw[p->type]) {
  814. answer = list_entry(lh, struct inet_protosw, list);
  815. /* Check only the non-wild match. */
  816. if (INET_PROTOSW_PERMANENT & answer->flags) {
  817. if (protocol == answer->protocol)
  818. break;
  819. last_perm = lh;
  820. }
  821. answer = NULL;
  822. }
  823. if (answer)
  824. goto out_permanent;
  825. /* Add the new entry after the last permanent entry if any, so that
  826. * the new entry does not override a permanent entry when matched with
  827. * a wild-card protocol. But it is allowed to override any existing
  828. * non-permanent entry. This means that when we remove this entry, the
  829. * system automatically returns to the old behavior.
  830. */
  831. list_add_rcu(&p->list, last_perm);
  832. out:
  833. spin_unlock_bh(&inetsw_lock);
  834. synchronize_net();
  835. return;
  836. out_permanent:
  837. printk(KERN_ERR "Attempt to override permanent protocol %d.\n",
  838. protocol);
  839. goto out;
  840. out_illegal:
  841. printk(KERN_ERR
  842. "Ignoring attempt to register invalid socket type %d.\n",
  843. p->type);
  844. goto out;
  845. }
  846. void inet_unregister_protosw(struct inet_protosw *p)
  847. {
  848. if (INET_PROTOSW_PERMANENT & p->flags) {
  849. printk(KERN_ERR
  850. "Attempt to unregister permanent protocol %d.\n",
  851. p->protocol);
  852. } else {
  853. spin_lock_bh(&inetsw_lock);
  854. list_del_rcu(&p->list);
  855. spin_unlock_bh(&inetsw_lock);
  856. synchronize_net();
  857. }
  858. }
  859. /*
  860. * Shall we try to damage output packets if routing dev changes?
  861. */
  862. int sysctl_ip_dynaddr __read_mostly;
  863. static int inet_sk_reselect_saddr(struct sock *sk)
  864. {
  865. struct inet_sock *inet = inet_sk(sk);
  866. int err;
  867. struct rtable *rt;
  868. __be32 old_saddr = inet->saddr;
  869. __be32 new_saddr;
  870. __be32 daddr = inet->daddr;
  871. if (inet->opt && inet->opt->srr)
  872. daddr = inet->opt->faddr;
  873. /* Query new route. */
  874. err = ip_route_connect(&rt, daddr, 0,
  875. RT_CONN_FLAGS(sk),
  876. sk->sk_bound_dev_if,
  877. sk->sk_protocol,
  878. inet->sport, inet->dport, sk, 0);
  879. if (err)
  880. return err;
  881. sk_setup_caps(sk, &rt->u.dst);
  882. new_saddr = rt->rt_src;
  883. if (new_saddr == old_saddr)
  884. return 0;
  885. if (sysctl_ip_dynaddr > 1) {
  886. printk(KERN_INFO "%s(): shifting inet->"
  887. "saddr from %d.%d.%d.%d to %d.%d.%d.%d\n",
  888. __FUNCTION__,
  889. NIPQUAD(old_saddr),
  890. NIPQUAD(new_saddr));
  891. }
  892. inet->saddr = inet->rcv_saddr = new_saddr;
  893. /*
  894. * XXX The only one ugly spot where we need to
  895. * XXX really change the sockets identity after
  896. * XXX it has entered the hashes. -DaveM
  897. *
  898. * Besides that, it does not check for connection
  899. * uniqueness. Wait for troubles.
  900. */
  901. __sk_prot_rehash(sk);
  902. return 0;
  903. }
  904. int inet_sk_rebuild_header(struct sock *sk)
  905. {
  906. struct inet_sock *inet = inet_sk(sk);
  907. struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
  908. __be32 daddr;
  909. int err;
  910. /* Route is OK, nothing to do. */
  911. if (rt)
  912. return 0;
  913. /* Reroute. */
  914. daddr = inet->daddr;
  915. if (inet->opt && inet->opt->srr)
  916. daddr = inet->opt->faddr;
  917. {
  918. struct flowi fl = {
  919. .oif = sk->sk_bound_dev_if,
  920. .nl_u = {
  921. .ip4_u = {
  922. .daddr = daddr,
  923. .saddr = inet->saddr,
  924. .tos = RT_CONN_FLAGS(sk),
  925. },
  926. },
  927. .proto = sk->sk_protocol,
  928. .uli_u = {
  929. .ports = {
  930. .sport = inet->sport,
  931. .dport = inet->dport,
  932. },
  933. },
  934. };
  935. security_sk_classify_flow(sk, &fl);
  936. err = ip_route_output_flow(&rt, &fl, sk, 0);
  937. }
  938. if (!err)
  939. sk_setup_caps(sk, &rt->u.dst);
  940. else {
  941. /* Routing failed... */
  942. sk->sk_route_caps = 0;
  943. /*
  944. * Other protocols have to map its equivalent state to TCP_SYN_SENT.
  945. * DCCP maps its DCCP_REQUESTING state to TCP_SYN_SENT. -acme
  946. */
  947. if (!sysctl_ip_dynaddr ||
  948. sk->sk_state != TCP_SYN_SENT ||
  949. (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
  950. (err = inet_sk_reselect_saddr(sk)) != 0)
  951. sk->sk_err_soft = -err;
  952. }
  953. return err;
  954. }
  955. EXPORT_SYMBOL(inet_sk_rebuild_header);
  956. static int inet_gso_send_check(struct sk_buff *skb)
  957. {
  958. struct iphdr *iph;
  959. struct net_protocol *ops;
  960. int proto;
  961. int ihl;
  962. int err = -EINVAL;
  963. if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
  964. goto out;
  965. iph = skb->nh.iph;
  966. ihl = iph->ihl * 4;
  967. if (ihl < sizeof(*iph))
  968. goto out;
  969. if (unlikely(!pskb_may_pull(skb, ihl)))
  970. goto out;
  971. skb->h.raw = __skb_pull(skb, ihl);
  972. iph = skb->nh.iph;
  973. proto = iph->protocol & (MAX_INET_PROTOS - 1);
  974. err = -EPROTONOSUPPORT;
  975. rcu_read_lock();
  976. ops = rcu_dereference(inet_protos[proto]);
  977. if (likely(ops && ops->gso_send_check))
  978. err = ops->gso_send_check(skb);
  979. rcu_read_unlock();
  980. out:
  981. return err;
  982. }
  983. static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int features)
  984. {
  985. struct sk_buff *segs = ERR_PTR(-EINVAL);
  986. struct iphdr *iph;
  987. struct net_protocol *ops;
  988. int proto;
  989. int ihl;
  990. int id;
  991. if (unlikely(skb_shinfo(skb)->gso_type &
  992. ~(SKB_GSO_TCPV4 |
  993. SKB_GSO_UDP |
  994. SKB_GSO_DODGY |
  995. SKB_GSO_TCP_ECN |
  996. 0)))
  997. goto out;
  998. if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
  999. goto out;
  1000. iph = skb->nh.iph;
  1001. ihl = iph->ihl * 4;
  1002. if (ihl < sizeof(*iph))
  1003. goto out;
  1004. if (unlikely(!pskb_may_pull(skb, ihl)))
  1005. goto out;
  1006. skb->h.raw = __skb_pull(skb, ihl);
  1007. iph = skb->nh.iph;
  1008. id = ntohs(iph->id);
  1009. proto = iph->protocol & (MAX_INET_PROTOS - 1);
  1010. segs = ERR_PTR(-EPROTONOSUPPORT);
  1011. rcu_read_lock();
  1012. ops = rcu_dereference(inet_protos[proto]);
  1013. if (likely(ops && ops->gso_segment))
  1014. segs = ops->gso_segment(skb, features);
  1015. rcu_read_unlock();
  1016. if (!segs || unlikely(IS_ERR(segs)))
  1017. goto out;
  1018. skb = segs;
  1019. do {
  1020. iph = skb->nh.iph;
  1021. iph->id = htons(id++);
  1022. iph->tot_len = htons(skb->len - skb->mac_len);
  1023. iph->check = 0;
  1024. iph->check = ip_fast_csum(skb->nh.raw, iph->ihl);
  1025. } while ((skb = skb->next));
  1026. out:
  1027. return segs;
  1028. }
  1029. #ifdef CONFIG_IP_MULTICAST
  1030. static struct net_protocol igmp_protocol = {
  1031. .handler = igmp_rcv,
  1032. };
  1033. #endif
  1034. static struct net_protocol tcp_protocol = {
  1035. .handler = tcp_v4_rcv,
  1036. .err_handler = tcp_v4_err,
  1037. .gso_send_check = tcp_v4_gso_send_check,
  1038. .gso_segment = tcp_tso_segment,
  1039. .no_policy = 1,
  1040. };
  1041. static struct net_protocol udp_protocol = {
  1042. .handler = udp_rcv,
  1043. .err_handler = udp_err,
  1044. .no_policy = 1,
  1045. };
  1046. static struct net_protocol icmp_protocol = {
  1047. .handler = icmp_rcv,
  1048. };
  1049. static int __init init_ipv4_mibs(void)
  1050. {
  1051. net_statistics[0] = alloc_percpu(struct linux_mib);
  1052. net_statistics[1] = alloc_percpu(struct linux_mib);
  1053. ip_statistics[0] = alloc_percpu(struct ipstats_mib);
  1054. ip_statistics[1] = alloc_percpu(struct ipstats_mib);
  1055. icmp_statistics[0] = alloc_percpu(struct icmp_mib);
  1056. icmp_statistics[1] = alloc_percpu(struct icmp_mib);
  1057. tcp_statistics[0] = alloc_percpu(struct tcp_mib);
  1058. tcp_statistics[1] = alloc_percpu(struct tcp_mib);
  1059. udp_statistics[0] = alloc_percpu(struct udp_mib);
  1060. udp_statistics[1] = alloc_percpu(struct udp_mib);
  1061. udplite_statistics[0] = alloc_percpu(struct udp_mib);
  1062. udplite_statistics[1] = alloc_percpu(struct udp_mib);
  1063. if (!
  1064. (net_statistics[0] && net_statistics[1] && ip_statistics[0]
  1065. && ip_statistics[1] && tcp_statistics[0] && tcp_statistics[1]
  1066. && udp_statistics[0] && udp_statistics[1]
  1067. && udplite_statistics[0] && udplite_statistics[1] ) )
  1068. return -ENOMEM;
  1069. (void) tcp_mib_init();
  1070. return 0;
  1071. }
  1072. static int ipv4_proc_init(void);
  1073. /*
  1074. * IP protocol layer initialiser
  1075. */
  1076. static struct packet_type ip_packet_type = {
  1077. .type = __constant_htons(ETH_P_IP),
  1078. .func = ip_rcv,
  1079. .gso_send_check = inet_gso_send_check,
  1080. .gso_segment = inet_gso_segment,
  1081. };
  1082. static int __init inet_init(void)
  1083. {
  1084. struct sk_buff *dummy_skb;
  1085. struct inet_protosw *q;
  1086. struct list_head *r;
  1087. int rc = -EINVAL;
  1088. BUILD_BUG_ON(sizeof(struct inet_skb_parm) > sizeof(dummy_skb->cb));
  1089. rc = proto_register(&tcp_prot, 1);
  1090. if (rc)
  1091. goto out;
  1092. rc = proto_register(&udp_prot, 1);
  1093. if (rc)
  1094. goto out_unregister_tcp_proto;
  1095. rc = proto_register(&raw_prot, 1);
  1096. if (rc)
  1097. goto out_unregister_udp_proto;
  1098. /*
  1099. * Tell SOCKET that we are alive...
  1100. */
  1101. (void)sock_register(&inet_family_ops);
  1102. /*
  1103. * Add all the base protocols.
  1104. */
  1105. if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
  1106. printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
  1107. if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
  1108. printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
  1109. if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
  1110. printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
  1111. #ifdef CONFIG_IP_MULTICAST
  1112. if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
  1113. printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n");
  1114. #endif
  1115. /* Register the socket-side information for inet_create. */
  1116. for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
  1117. INIT_LIST_HEAD(r);
  1118. for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
  1119. inet_register_protosw(q);
  1120. /*
  1121. * Set the ARP module up
  1122. */
  1123. arp_init();
  1124. /*
  1125. * Set the IP module up
  1126. */
  1127. ip_init();
  1128. tcp_v4_init(&inet_family_ops);
  1129. /* Setup TCP slab cache for open requests. */
  1130. tcp_init();
  1131. /* Add UDP-Lite (RFC 3828) */
  1132. udplite4_register();
  1133. /*
  1134. * Set the ICMP layer up
  1135. */
  1136. icmp_init(&inet_family_ops);
  1137. /*
  1138. * Initialise the multicast router
  1139. */
  1140. #if defined(CONFIG_IP_MROUTE)
  1141. ip_mr_init();
  1142. #endif
  1143. /*
  1144. * Initialise per-cpu ipv4 mibs
  1145. */
  1146. if(init_ipv4_mibs())
  1147. printk(KERN_CRIT "inet_init: Cannot init ipv4 mibs\n"); ;
  1148. ipv4_proc_init();
  1149. ipfrag_init();
  1150. dev_add_pack(&ip_packet_type);
  1151. rc = 0;
  1152. out:
  1153. return rc;
  1154. out_unregister_udp_proto:
  1155. proto_unregister(&udp_prot);
  1156. out_unregister_tcp_proto:
  1157. proto_unregister(&tcp_prot);
  1158. goto out;
  1159. }
  1160. fs_initcall(inet_init);
  1161. /* ------------------------------------------------------------------------ */
  1162. #ifdef CONFIG_PROC_FS
  1163. static int __init ipv4_proc_init(void)
  1164. {
  1165. int rc = 0;
  1166. if (raw_proc_init())
  1167. goto out_raw;
  1168. if (tcp4_proc_init())
  1169. goto out_tcp;
  1170. if (udp4_proc_init())
  1171. goto out_udp;
  1172. if (fib_proc_init())
  1173. goto out_fib;
  1174. if (ip_misc_proc_init())
  1175. goto out_misc;
  1176. out:
  1177. return rc;
  1178. out_misc:
  1179. fib_proc_exit();
  1180. out_fib:
  1181. udp4_proc_exit();
  1182. out_udp:
  1183. tcp4_proc_exit();
  1184. out_tcp:
  1185. raw_proc_exit();
  1186. out_raw:
  1187. rc = -ENOMEM;
  1188. goto out;
  1189. }
  1190. #else /* CONFIG_PROC_FS */
  1191. static int __init ipv4_proc_init(void)
  1192. {
  1193. return 0;
  1194. }
  1195. #endif /* CONFIG_PROC_FS */
  1196. MODULE_ALIAS_NETPROTO(PF_INET);
  1197. EXPORT_SYMBOL(inet_accept);
  1198. EXPORT_SYMBOL(inet_bind);
  1199. EXPORT_SYMBOL(inet_dgram_connect);
  1200. EXPORT_SYMBOL(inet_dgram_ops);
  1201. EXPORT_SYMBOL(inet_getname);
  1202. EXPORT_SYMBOL(inet_ioctl);
  1203. EXPORT_SYMBOL(inet_listen);
  1204. EXPORT_SYMBOL(inet_register_protosw);
  1205. EXPORT_SYMBOL(inet_release);
  1206. EXPORT_SYMBOL(inet_sendmsg);
  1207. EXPORT_SYMBOL(inet_shutdown);
  1208. EXPORT_SYMBOL(inet_sock_destruct);
  1209. EXPORT_SYMBOL(inet_stream_connect);
  1210. EXPORT_SYMBOL(inet_stream_ops);
  1211. EXPORT_SYMBOL(inet_unregister_protosw);
  1212. EXPORT_SYMBOL(net_statistics);
  1213. EXPORT_SYMBOL(sysctl_ip_nonlocal_bind);