protocol.c 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395
  1. /* SCTP kernel implementation
  2. * (C) Copyright IBM Corp. 2001, 2004
  3. * Copyright (c) 1999-2000 Cisco, Inc.
  4. * Copyright (c) 1999-2001 Motorola, Inc.
  5. * Copyright (c) 2001 Intel Corp.
  6. * Copyright (c) 2001 Nokia, Inc.
  7. * Copyright (c) 2001 La Monte H.P. Yarroll
  8. *
  9. * This file is part of the SCTP kernel implementation
  10. *
  11. * Initialization/cleanup for SCTP protocol support.
  12. *
  13. * This SCTP implementation is free software;
  14. * you can redistribute it and/or modify it under the terms of
  15. * the GNU General Public License as published by
  16. * the Free Software Foundation; either version 2, or (at your option)
  17. * any later version.
  18. *
  19. * This SCTP implementation is distributed in the hope that it
  20. * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  21. * ************************
  22. * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. * See the GNU General Public License for more details.
  24. *
  25. * You should have received a copy of the GNU General Public License
  26. * along with GNU CC; see the file COPYING. If not, write to
  27. * the Free Software Foundation, 59 Temple Place - Suite 330,
  28. * Boston, MA 02111-1307, USA.
  29. *
  30. * Please send any bug reports or fixes you make to the
  31. * email address(es):
  32. * lksctp developers <lksctp-developers@lists.sourceforge.net>
  33. *
  34. * Or submit a bug report through the following website:
  35. * http://www.sf.net/projects/lksctp
  36. *
  37. * Written or modified by:
  38. * La Monte H.P. Yarroll <piggy@acm.org>
  39. * Karl Knutson <karl@athena.chicago.il.us>
  40. * Jon Grimm <jgrimm@us.ibm.com>
  41. * Sridhar Samudrala <sri@us.ibm.com>
  42. * Daisy Chang <daisyc@us.ibm.com>
  43. * Ardelle Fan <ardelle.fan@intel.com>
  44. *
  45. * Any bugs reported given to us we will try to fix... any fixes shared will
  46. * be incorporated into the next SCTP release.
  47. */
  48. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  49. #include <linux/module.h>
  50. #include <linux/init.h>
  51. #include <linux/netdevice.h>
  52. #include <linux/inetdevice.h>
  53. #include <linux/seq_file.h>
  54. #include <linux/bootmem.h>
  55. #include <linux/highmem.h>
  56. #include <linux/swap.h>
  57. #include <linux/slab.h>
  58. #include <net/net_namespace.h>
  59. #include <net/protocol.h>
  60. #include <net/ip.h>
  61. #include <net/ipv6.h>
  62. #include <net/route.h>
  63. #include <net/sctp/sctp.h>
  64. #include <net/addrconf.h>
  65. #include <net/inet_common.h>
  66. #include <net/inet_ecn.h>
  67. /* Global data structures. */
  68. struct sctp_globals sctp_globals __read_mostly;
  69. DEFINE_SNMP_STAT(struct sctp_mib, sctp_statistics) __read_mostly;
  70. #ifdef CONFIG_PROC_FS
  71. struct proc_dir_entry *proc_net_sctp;
  72. #endif
  73. struct idr sctp_assocs_id;
  74. DEFINE_SPINLOCK(sctp_assocs_id_lock);
  75. /* This is the global socket data structure used for responding to
  76. * the Out-of-the-blue (OOTB) packets. A control sock will be created
  77. * for this socket at the initialization time.
  78. */
  79. static struct sock *sctp_ctl_sock;
  80. static struct sctp_pf *sctp_pf_inet6_specific;
  81. static struct sctp_pf *sctp_pf_inet_specific;
  82. static struct sctp_af *sctp_af_v4_specific;
  83. static struct sctp_af *sctp_af_v6_specific;
  84. struct kmem_cache *sctp_chunk_cachep __read_mostly;
  85. struct kmem_cache *sctp_bucket_cachep __read_mostly;
  86. long sysctl_sctp_mem[3];
  87. int sysctl_sctp_rmem[3];
  88. int sysctl_sctp_wmem[3];
  89. /* Return the address of the control sock. */
  90. struct sock *sctp_get_ctl_sock(void)
  91. {
  92. return sctp_ctl_sock;
  93. }
  94. /* Set up the proc fs entry for the SCTP protocol. */
  95. static __init int sctp_proc_init(void)
  96. {
  97. if (percpu_counter_init(&sctp_sockets_allocated, 0))
  98. goto out_nomem;
  99. #ifdef CONFIG_PROC_FS
  100. if (!proc_net_sctp) {
  101. proc_net_sctp = proc_mkdir("sctp", init_net.proc_net);
  102. if (!proc_net_sctp)
  103. goto out_free_percpu;
  104. }
  105. if (sctp_snmp_proc_init())
  106. goto out_snmp_proc_init;
  107. if (sctp_eps_proc_init())
  108. goto out_eps_proc_init;
  109. if (sctp_assocs_proc_init())
  110. goto out_assocs_proc_init;
  111. if (sctp_remaddr_proc_init())
  112. goto out_remaddr_proc_init;
  113. return 0;
  114. out_remaddr_proc_init:
  115. sctp_assocs_proc_exit();
  116. out_assocs_proc_init:
  117. sctp_eps_proc_exit();
  118. out_eps_proc_init:
  119. sctp_snmp_proc_exit();
  120. out_snmp_proc_init:
  121. if (proc_net_sctp) {
  122. proc_net_sctp = NULL;
  123. remove_proc_entry("sctp", init_net.proc_net);
  124. }
  125. out_free_percpu:
  126. percpu_counter_destroy(&sctp_sockets_allocated);
  127. #else
  128. return 0;
  129. #endif /* CONFIG_PROC_FS */
  130. out_nomem:
  131. return -ENOMEM;
  132. }
  133. /* Clean up the proc fs entry for the SCTP protocol.
  134. * Note: Do not make this __exit as it is used in the init error
  135. * path.
  136. */
  137. static void sctp_proc_exit(void)
  138. {
  139. #ifdef CONFIG_PROC_FS
  140. sctp_snmp_proc_exit();
  141. sctp_eps_proc_exit();
  142. sctp_assocs_proc_exit();
  143. sctp_remaddr_proc_exit();
  144. if (proc_net_sctp) {
  145. proc_net_sctp = NULL;
  146. remove_proc_entry("sctp", init_net.proc_net);
  147. }
  148. #endif
  149. percpu_counter_destroy(&sctp_sockets_allocated);
  150. }
  151. /* Private helper to extract ipv4 address and stash them in
  152. * the protocol structure.
  153. */
  154. static void sctp_v4_copy_addrlist(struct list_head *addrlist,
  155. struct net_device *dev)
  156. {
  157. struct in_device *in_dev;
  158. struct in_ifaddr *ifa;
  159. struct sctp_sockaddr_entry *addr;
  160. rcu_read_lock();
  161. if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
  162. rcu_read_unlock();
  163. return;
  164. }
  165. for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
  166. /* Add the address to the local list. */
  167. addr = t_new(struct sctp_sockaddr_entry, GFP_ATOMIC);
  168. if (addr) {
  169. addr->a.v4.sin_family = AF_INET;
  170. addr->a.v4.sin_port = 0;
  171. addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
  172. addr->valid = 1;
  173. INIT_LIST_HEAD(&addr->list);
  174. list_add_tail(&addr->list, addrlist);
  175. }
  176. }
  177. rcu_read_unlock();
  178. }
  179. /* Extract our IP addresses from the system and stash them in the
  180. * protocol structure.
  181. */
  182. static void sctp_get_local_addr_list(void)
  183. {
  184. struct net_device *dev;
  185. struct list_head *pos;
  186. struct sctp_af *af;
  187. rcu_read_lock();
  188. for_each_netdev_rcu(&init_net, dev) {
  189. __list_for_each(pos, &sctp_address_families) {
  190. af = list_entry(pos, struct sctp_af, list);
  191. af->copy_addrlist(&sctp_local_addr_list, dev);
  192. }
  193. }
  194. rcu_read_unlock();
  195. }
  196. /* Free the existing local addresses. */
  197. static void sctp_free_local_addr_list(void)
  198. {
  199. struct sctp_sockaddr_entry *addr;
  200. struct list_head *pos, *temp;
  201. list_for_each_safe(pos, temp, &sctp_local_addr_list) {
  202. addr = list_entry(pos, struct sctp_sockaddr_entry, list);
  203. list_del(pos);
  204. kfree(addr);
  205. }
  206. }
  207. void sctp_local_addr_free(struct rcu_head *head)
  208. {
  209. struct sctp_sockaddr_entry *e = container_of(head,
  210. struct sctp_sockaddr_entry, rcu);
  211. kfree(e);
  212. }
  213. /* Copy the local addresses which are valid for 'scope' into 'bp'. */
  214. int sctp_copy_local_addr_list(struct sctp_bind_addr *bp, sctp_scope_t scope,
  215. gfp_t gfp, int copy_flags)
  216. {
  217. struct sctp_sockaddr_entry *addr;
  218. int error = 0;
  219. rcu_read_lock();
  220. list_for_each_entry_rcu(addr, &sctp_local_addr_list, list) {
  221. if (!addr->valid)
  222. continue;
  223. if (sctp_in_scope(&addr->a, scope)) {
  224. /* Now that the address is in scope, check to see if
  225. * the address type is really supported by the local
  226. * sock as well as the remote peer.
  227. */
  228. if ((((AF_INET == addr->a.sa.sa_family) &&
  229. (copy_flags & SCTP_ADDR4_PEERSUPP))) ||
  230. (((AF_INET6 == addr->a.sa.sa_family) &&
  231. (copy_flags & SCTP_ADDR6_ALLOWED) &&
  232. (copy_flags & SCTP_ADDR6_PEERSUPP)))) {
  233. error = sctp_add_bind_addr(bp, &addr->a,
  234. SCTP_ADDR_SRC, GFP_ATOMIC);
  235. if (error)
  236. goto end_copy;
  237. }
  238. }
  239. }
  240. end_copy:
  241. rcu_read_unlock();
  242. return error;
  243. }
  244. /* Initialize a sctp_addr from in incoming skb. */
  245. static void sctp_v4_from_skb(union sctp_addr *addr, struct sk_buff *skb,
  246. int is_saddr)
  247. {
  248. void *from;
  249. __be16 *port;
  250. struct sctphdr *sh;
  251. port = &addr->v4.sin_port;
  252. addr->v4.sin_family = AF_INET;
  253. sh = sctp_hdr(skb);
  254. if (is_saddr) {
  255. *port = sh->source;
  256. from = &ip_hdr(skb)->saddr;
  257. } else {
  258. *port = sh->dest;
  259. from = &ip_hdr(skb)->daddr;
  260. }
  261. memcpy(&addr->v4.sin_addr.s_addr, from, sizeof(struct in_addr));
  262. }
  263. /* Initialize an sctp_addr from a socket. */
  264. static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
  265. {
  266. addr->v4.sin_family = AF_INET;
  267. addr->v4.sin_port = 0;
  268. addr->v4.sin_addr.s_addr = inet_sk(sk)->inet_rcv_saddr;
  269. }
  270. /* Initialize sk->sk_rcv_saddr from sctp_addr. */
  271. static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
  272. {
  273. inet_sk(sk)->inet_rcv_saddr = addr->v4.sin_addr.s_addr;
  274. }
  275. /* Initialize sk->sk_daddr from sctp_addr. */
  276. static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
  277. {
  278. inet_sk(sk)->inet_daddr = addr->v4.sin_addr.s_addr;
  279. }
  280. /* Initialize a sctp_addr from an address parameter. */
  281. static void sctp_v4_from_addr_param(union sctp_addr *addr,
  282. union sctp_addr_param *param,
  283. __be16 port, int iif)
  284. {
  285. addr->v4.sin_family = AF_INET;
  286. addr->v4.sin_port = port;
  287. addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
  288. }
  289. /* Initialize an address parameter from a sctp_addr and return the length
  290. * of the address parameter.
  291. */
  292. static int sctp_v4_to_addr_param(const union sctp_addr *addr,
  293. union sctp_addr_param *param)
  294. {
  295. int length = sizeof(sctp_ipv4addr_param_t);
  296. param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
  297. param->v4.param_hdr.length = htons(length);
  298. param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;
  299. return length;
  300. }
  301. /* Initialize a sctp_addr from a dst_entry. */
  302. static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct dst_entry *dst,
  303. __be16 port)
  304. {
  305. struct rtable *rt = (struct rtable *)dst;
  306. saddr->v4.sin_family = AF_INET;
  307. saddr->v4.sin_port = port;
  308. saddr->v4.sin_addr.s_addr = rt->rt_src;
  309. }
  310. /* Compare two addresses exactly. */
  311. static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
  312. const union sctp_addr *addr2)
  313. {
  314. if (addr1->sa.sa_family != addr2->sa.sa_family)
  315. return 0;
  316. if (addr1->v4.sin_port != addr2->v4.sin_port)
  317. return 0;
  318. if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
  319. return 0;
  320. return 1;
  321. }
  322. /* Initialize addr struct to INADDR_ANY. */
  323. static void sctp_v4_inaddr_any(union sctp_addr *addr, __be16 port)
  324. {
  325. addr->v4.sin_family = AF_INET;
  326. addr->v4.sin_addr.s_addr = htonl(INADDR_ANY);
  327. addr->v4.sin_port = port;
  328. }
  329. /* Is this a wildcard address? */
  330. static int sctp_v4_is_any(const union sctp_addr *addr)
  331. {
  332. return htonl(INADDR_ANY) == addr->v4.sin_addr.s_addr;
  333. }
  334. /* This function checks if the address is a valid address to be used for
  335. * SCTP binding.
  336. *
  337. * Output:
  338. * Return 0 - If the address is a non-unicast or an illegal address.
  339. * Return 1 - If the address is a unicast.
  340. */
  341. static int sctp_v4_addr_valid(union sctp_addr *addr,
  342. struct sctp_sock *sp,
  343. const struct sk_buff *skb)
  344. {
  345. /* IPv4 addresses not allowed */
  346. if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
  347. return 0;
  348. /* Is this a non-unicast address or a unusable SCTP address? */
  349. if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr))
  350. return 0;
  351. /* Is this a broadcast address? */
  352. if (skb && skb_rtable(skb)->rt_flags & RTCF_BROADCAST)
  353. return 0;
  354. return 1;
  355. }
  356. /* Should this be available for binding? */
  357. static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
  358. {
  359. int ret = inet_addr_type(&init_net, addr->v4.sin_addr.s_addr);
  360. if (addr->v4.sin_addr.s_addr != htonl(INADDR_ANY) &&
  361. ret != RTN_LOCAL &&
  362. !sp->inet.freebind &&
  363. !sysctl_ip_nonlocal_bind)
  364. return 0;
  365. if (ipv6_only_sock(sctp_opt2sk(sp)))
  366. return 0;
  367. return 1;
  368. }
  369. /* Checking the loopback, private and other address scopes as defined in
  370. * RFC 1918. The IPv4 scoping is based on the draft for SCTP IPv4
  371. * scoping <draft-stewart-tsvwg-sctp-ipv4-00.txt>.
  372. *
  373. * Level 0 - unusable SCTP addresses
  374. * Level 1 - loopback address
  375. * Level 2 - link-local addresses
  376. * Level 3 - private addresses.
  377. * Level 4 - global addresses
  378. * For INIT and INIT-ACK address list, let L be the level of
  379. * of requested destination address, sender and receiver
  380. * SHOULD include all of its addresses with level greater
  381. * than or equal to L.
  382. *
  383. * IPv4 scoping can be controlled through sysctl option
  384. * net.sctp.addr_scope_policy
  385. */
  386. static sctp_scope_t sctp_v4_scope(union sctp_addr *addr)
  387. {
  388. sctp_scope_t retval;
  389. /* Check for unusable SCTP addresses. */
  390. if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr)) {
  391. retval = SCTP_SCOPE_UNUSABLE;
  392. } else if (ipv4_is_loopback(addr->v4.sin_addr.s_addr)) {
  393. retval = SCTP_SCOPE_LOOPBACK;
  394. } else if (ipv4_is_linklocal_169(addr->v4.sin_addr.s_addr)) {
  395. retval = SCTP_SCOPE_LINK;
  396. } else if (ipv4_is_private_10(addr->v4.sin_addr.s_addr) ||
  397. ipv4_is_private_172(addr->v4.sin_addr.s_addr) ||
  398. ipv4_is_private_192(addr->v4.sin_addr.s_addr)) {
  399. retval = SCTP_SCOPE_PRIVATE;
  400. } else {
  401. retval = SCTP_SCOPE_GLOBAL;
  402. }
  403. return retval;
  404. }
  405. /* Returns a valid dst cache entry for the given source and destination ip
  406. * addresses. If an association is passed, trys to get a dst entry with a
  407. * source address that matches an address in the bind address list.
  408. */
  409. static void sctp_v4_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
  410. struct flowi *fl, struct sock *sk)
  411. {
  412. struct sctp_association *asoc = t->asoc;
  413. struct rtable *rt;
  414. struct flowi4 *fl4 = &fl->u.ip4;
  415. struct sctp_bind_addr *bp;
  416. struct sctp_sockaddr_entry *laddr;
  417. struct dst_entry *dst = NULL;
  418. union sctp_addr *daddr = &t->ipaddr;
  419. union sctp_addr dst_saddr;
  420. memset(fl4, 0x0, sizeof(struct flowi4));
  421. fl4->daddr = daddr->v4.sin_addr.s_addr;
  422. fl4->fl4_dport = daddr->v4.sin_port;
  423. fl4->flowi4_proto = IPPROTO_SCTP;
  424. if (asoc) {
  425. fl4->flowi4_tos = RT_CONN_FLAGS(asoc->base.sk);
  426. fl4->flowi4_oif = asoc->base.sk->sk_bound_dev_if;
  427. fl4->fl4_sport = htons(asoc->base.bind_addr.port);
  428. }
  429. if (saddr) {
  430. fl4->saddr = saddr->v4.sin_addr.s_addr;
  431. fl4->fl4_sport = saddr->v4.sin_port;
  432. }
  433. SCTP_DEBUG_PRINTK("%s: DST:%pI4, SRC:%pI4 - ",
  434. __func__, &fl4->daddr, &fl4->saddr);
  435. rt = ip_route_output_key(&init_net, fl4);
  436. if (!IS_ERR(rt))
  437. dst = &rt->dst;
  438. /* If there is no association or if a source address is passed, no
  439. * more validation is required.
  440. */
  441. if (!asoc || saddr)
  442. goto out;
  443. bp = &asoc->base.bind_addr;
  444. if (dst) {
  445. /* Walk through the bind address list and look for a bind
  446. * address that matches the source address of the returned dst.
  447. */
  448. sctp_v4_dst_saddr(&dst_saddr, dst, htons(bp->port));
  449. rcu_read_lock();
  450. list_for_each_entry_rcu(laddr, &bp->address_list, list) {
  451. if (!laddr->valid || (laddr->state != SCTP_ADDR_SRC))
  452. continue;
  453. if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
  454. goto out_unlock;
  455. }
  456. rcu_read_unlock();
  457. /* None of the bound addresses match the source address of the
  458. * dst. So release it.
  459. */
  460. dst_release(dst);
  461. dst = NULL;
  462. }
  463. /* Walk through the bind address list and try to get a dst that
  464. * matches a bind address as the source address.
  465. */
  466. rcu_read_lock();
  467. list_for_each_entry_rcu(laddr, &bp->address_list, list) {
  468. if (!laddr->valid)
  469. continue;
  470. if ((laddr->state == SCTP_ADDR_SRC) &&
  471. (AF_INET == laddr->a.sa.sa_family)) {
  472. fl4->saddr = laddr->a.v4.sin_addr.s_addr;
  473. fl4->fl4_sport = laddr->a.v4.sin_port;
  474. rt = ip_route_output_key(&init_net, fl4);
  475. if (!IS_ERR(rt)) {
  476. dst = &rt->dst;
  477. goto out_unlock;
  478. }
  479. }
  480. }
  481. out_unlock:
  482. rcu_read_unlock();
  483. out:
  484. t->dst = dst;
  485. if (dst)
  486. SCTP_DEBUG_PRINTK("rt_dst:%pI4, rt_src:%pI4\n",
  487. &rt->rt_dst, &rt->rt_src);
  488. else
  489. SCTP_DEBUG_PRINTK("NO ROUTE\n");
  490. }
  491. /* For v4, the source address is cached in the route entry(dst). So no need
  492. * to cache it separately and hence this is an empty routine.
  493. */
  494. static void sctp_v4_get_saddr(struct sctp_sock *sk,
  495. struct sctp_transport *t,
  496. struct flowi *fl)
  497. {
  498. union sctp_addr *saddr = &t->saddr;
  499. struct rtable *rt = (struct rtable *)t->dst;
  500. if (rt) {
  501. saddr->v4.sin_family = AF_INET;
  502. saddr->v4.sin_addr.s_addr = rt->rt_src;
  503. }
  504. }
  505. /* What interface did this skb arrive on? */
  506. static int sctp_v4_skb_iif(const struct sk_buff *skb)
  507. {
  508. return skb_rtable(skb)->rt_iif;
  509. }
  510. /* Was this packet marked by Explicit Congestion Notification? */
  511. static int sctp_v4_is_ce(const struct sk_buff *skb)
  512. {
  513. return INET_ECN_is_ce(ip_hdr(skb)->tos);
  514. }
  515. /* Create and initialize a new sk for the socket returned by accept(). */
  516. static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
  517. struct sctp_association *asoc)
  518. {
  519. struct sock *newsk = sk_alloc(sock_net(sk), PF_INET, GFP_KERNEL,
  520. sk->sk_prot);
  521. struct inet_sock *newinet;
  522. if (!newsk)
  523. goto out;
  524. sock_init_data(NULL, newsk);
  525. sctp_copy_sock(newsk, sk, asoc);
  526. sock_reset_flag(newsk, SOCK_ZAPPED);
  527. newinet = inet_sk(newsk);
  528. newinet->inet_daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
  529. sk_refcnt_debug_inc(newsk);
  530. if (newsk->sk_prot->init(newsk)) {
  531. sk_common_release(newsk);
  532. newsk = NULL;
  533. }
  534. out:
  535. return newsk;
  536. }
  537. /* Map address, empty for v4 family */
  538. static void sctp_v4_addr_v4map(struct sctp_sock *sp, union sctp_addr *addr)
  539. {
  540. /* Empty */
  541. }
  542. /* Dump the v4 addr to the seq file. */
  543. static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
  544. {
  545. seq_printf(seq, "%pI4 ", &addr->v4.sin_addr);
  546. }
  547. static void sctp_v4_ecn_capable(struct sock *sk)
  548. {
  549. INET_ECN_xmit(sk);
  550. }
  551. /* Event handler for inet address addition/deletion events.
  552. * The sctp_local_addr_list needs to be protocted by a spin lock since
  553. * multiple notifiers (say IPv4 and IPv6) may be running at the same
  554. * time and thus corrupt the list.
  555. * The reader side is protected with RCU.
  556. */
  557. static int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
  558. void *ptr)
  559. {
  560. struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
  561. struct sctp_sockaddr_entry *addr = NULL;
  562. struct sctp_sockaddr_entry *temp;
  563. int found = 0;
  564. if (!net_eq(dev_net(ifa->ifa_dev->dev), &init_net))
  565. return NOTIFY_DONE;
  566. switch (ev) {
  567. case NETDEV_UP:
  568. addr = kmalloc(sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
  569. if (addr) {
  570. addr->a.v4.sin_family = AF_INET;
  571. addr->a.v4.sin_port = 0;
  572. addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
  573. addr->valid = 1;
  574. spin_lock_bh(&sctp_local_addr_lock);
  575. list_add_tail_rcu(&addr->list, &sctp_local_addr_list);
  576. spin_unlock_bh(&sctp_local_addr_lock);
  577. }
  578. break;
  579. case NETDEV_DOWN:
  580. spin_lock_bh(&sctp_local_addr_lock);
  581. list_for_each_entry_safe(addr, temp,
  582. &sctp_local_addr_list, list) {
  583. if (addr->a.sa.sa_family == AF_INET &&
  584. addr->a.v4.sin_addr.s_addr ==
  585. ifa->ifa_local) {
  586. found = 1;
  587. addr->valid = 0;
  588. list_del_rcu(&addr->list);
  589. break;
  590. }
  591. }
  592. spin_unlock_bh(&sctp_local_addr_lock);
  593. if (found)
  594. call_rcu(&addr->rcu, sctp_local_addr_free);
  595. break;
  596. }
  597. return NOTIFY_DONE;
  598. }
  599. /*
  600. * Initialize the control inode/socket with a control endpoint data
  601. * structure. This endpoint is reserved exclusively for the OOTB processing.
  602. */
  603. static int sctp_ctl_sock_init(void)
  604. {
  605. int err;
  606. sa_family_t family = PF_INET;
  607. if (sctp_get_pf_specific(PF_INET6))
  608. family = PF_INET6;
  609. err = inet_ctl_sock_create(&sctp_ctl_sock, family,
  610. SOCK_SEQPACKET, IPPROTO_SCTP, &init_net);
  611. /* If IPv6 socket could not be created, try the IPv4 socket */
  612. if (err < 0 && family == PF_INET6)
  613. err = inet_ctl_sock_create(&sctp_ctl_sock, AF_INET,
  614. SOCK_SEQPACKET, IPPROTO_SCTP,
  615. &init_net);
  616. if (err < 0) {
  617. pr_err("Failed to create the SCTP control socket\n");
  618. return err;
  619. }
  620. return 0;
  621. }
  622. /* Register address family specific functions. */
  623. int sctp_register_af(struct sctp_af *af)
  624. {
  625. switch (af->sa_family) {
  626. case AF_INET:
  627. if (sctp_af_v4_specific)
  628. return 0;
  629. sctp_af_v4_specific = af;
  630. break;
  631. case AF_INET6:
  632. if (sctp_af_v6_specific)
  633. return 0;
  634. sctp_af_v6_specific = af;
  635. break;
  636. default:
  637. return 0;
  638. }
  639. INIT_LIST_HEAD(&af->list);
  640. list_add_tail(&af->list, &sctp_address_families);
  641. return 1;
  642. }
  643. /* Get the table of functions for manipulating a particular address
  644. * family.
  645. */
  646. struct sctp_af *sctp_get_af_specific(sa_family_t family)
  647. {
  648. switch (family) {
  649. case AF_INET:
  650. return sctp_af_v4_specific;
  651. case AF_INET6:
  652. return sctp_af_v6_specific;
  653. default:
  654. return NULL;
  655. }
  656. }
  657. /* Common code to initialize a AF_INET msg_name. */
  658. static void sctp_inet_msgname(char *msgname, int *addr_len)
  659. {
  660. struct sockaddr_in *sin;
  661. sin = (struct sockaddr_in *)msgname;
  662. *addr_len = sizeof(struct sockaddr_in);
  663. sin->sin_family = AF_INET;
  664. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  665. }
  666. /* Copy the primary address of the peer primary address as the msg_name. */
  667. static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
  668. int *addr_len)
  669. {
  670. struct sockaddr_in *sin, *sinfrom;
  671. if (msgname) {
  672. struct sctp_association *asoc;
  673. asoc = event->asoc;
  674. sctp_inet_msgname(msgname, addr_len);
  675. sin = (struct sockaddr_in *)msgname;
  676. sinfrom = &asoc->peer.primary_addr.v4;
  677. sin->sin_port = htons(asoc->peer.port);
  678. sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
  679. }
  680. }
  681. /* Initialize and copy out a msgname from an inbound skb. */
  682. static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
  683. {
  684. if (msgname) {
  685. struct sctphdr *sh = sctp_hdr(skb);
  686. struct sockaddr_in *sin = (struct sockaddr_in *)msgname;
  687. sctp_inet_msgname(msgname, len);
  688. sin->sin_port = sh->source;
  689. sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
  690. }
  691. }
  692. /* Do we support this AF? */
  693. static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
  694. {
  695. /* PF_INET only supports AF_INET addresses. */
  696. return AF_INET == family;
  697. }
  698. /* Address matching with wildcards allowed. */
  699. static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
  700. const union sctp_addr *addr2,
  701. struct sctp_sock *opt)
  702. {
  703. /* PF_INET only supports AF_INET addresses. */
  704. if (addr1->sa.sa_family != addr2->sa.sa_family)
  705. return 0;
  706. if (htonl(INADDR_ANY) == addr1->v4.sin_addr.s_addr ||
  707. htonl(INADDR_ANY) == addr2->v4.sin_addr.s_addr)
  708. return 1;
  709. if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
  710. return 1;
  711. return 0;
  712. }
  713. /* Verify that provided sockaddr looks bindable. Common verification has
  714. * already been taken care of.
  715. */
  716. static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
  717. {
  718. return sctp_v4_available(addr, opt);
  719. }
  720. /* Verify that sockaddr looks sendable. Common verification has already
  721. * been taken care of.
  722. */
  723. static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
  724. {
  725. return 1;
  726. }
  727. /* Fill in Supported Address Type information for INIT and INIT-ACK
  728. * chunks. Returns number of addresses supported.
  729. */
  730. static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
  731. __be16 *types)
  732. {
  733. types[0] = SCTP_PARAM_IPV4_ADDRESS;
  734. return 1;
  735. }
  736. /* Wrapper routine that calls the ip transmit routine. */
  737. static inline int sctp_v4_xmit(struct sk_buff *skb,
  738. struct sctp_transport *transport)
  739. {
  740. struct inet_sock *inet = inet_sk(skb->sk);
  741. SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n",
  742. __func__, skb, skb->len,
  743. &skb_rtable(skb)->rt_src,
  744. &skb_rtable(skb)->rt_dst);
  745. inet->pmtudisc = transport->param_flags & SPP_PMTUD_ENABLE ?
  746. IP_PMTUDISC_DO : IP_PMTUDISC_DONT;
  747. SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
  748. return ip_queue_xmit(skb);
  749. }
  750. static struct sctp_af sctp_af_inet;
  751. static struct sctp_pf sctp_pf_inet = {
  752. .event_msgname = sctp_inet_event_msgname,
  753. .skb_msgname = sctp_inet_skb_msgname,
  754. .af_supported = sctp_inet_af_supported,
  755. .cmp_addr = sctp_inet_cmp_addr,
  756. .bind_verify = sctp_inet_bind_verify,
  757. .send_verify = sctp_inet_send_verify,
  758. .supported_addrs = sctp_inet_supported_addrs,
  759. .create_accept_sk = sctp_v4_create_accept_sk,
  760. .addr_v4map = sctp_v4_addr_v4map,
  761. .af = &sctp_af_inet
  762. };
  763. /* Notifier for inetaddr addition/deletion events. */
  764. static struct notifier_block sctp_inetaddr_notifier = {
  765. .notifier_call = sctp_inetaddr_event,
  766. };
  767. /* Socket operations. */
  768. static const struct proto_ops inet_seqpacket_ops = {
  769. .family = PF_INET,
  770. .owner = THIS_MODULE,
  771. .release = inet_release, /* Needs to be wrapped... */
  772. .bind = inet_bind,
  773. .connect = inet_dgram_connect,
  774. .socketpair = sock_no_socketpair,
  775. .accept = inet_accept,
  776. .getname = inet_getname, /* Semantics are different. */
  777. .poll = sctp_poll,
  778. .ioctl = inet_ioctl,
  779. .listen = sctp_inet_listen,
  780. .shutdown = inet_shutdown, /* Looks harmless. */
  781. .setsockopt = sock_common_setsockopt, /* IP_SOL IP_OPTION is a problem */
  782. .getsockopt = sock_common_getsockopt,
  783. .sendmsg = inet_sendmsg,
  784. .recvmsg = sock_common_recvmsg,
  785. .mmap = sock_no_mmap,
  786. .sendpage = sock_no_sendpage,
  787. #ifdef CONFIG_COMPAT
  788. .compat_setsockopt = compat_sock_common_setsockopt,
  789. .compat_getsockopt = compat_sock_common_getsockopt,
  790. #endif
  791. };
  792. /* Registration with AF_INET family. */
  793. static struct inet_protosw sctp_seqpacket_protosw = {
  794. .type = SOCK_SEQPACKET,
  795. .protocol = IPPROTO_SCTP,
  796. .prot = &sctp_prot,
  797. .ops = &inet_seqpacket_ops,
  798. .no_check = 0,
  799. .flags = SCTP_PROTOSW_FLAG
  800. };
  801. static struct inet_protosw sctp_stream_protosw = {
  802. .type = SOCK_STREAM,
  803. .protocol = IPPROTO_SCTP,
  804. .prot = &sctp_prot,
  805. .ops = &inet_seqpacket_ops,
  806. .no_check = 0,
  807. .flags = SCTP_PROTOSW_FLAG
  808. };
  809. /* Register with IP layer. */
  810. static const struct net_protocol sctp_protocol = {
  811. .handler = sctp_rcv,
  812. .err_handler = sctp_v4_err,
  813. .no_policy = 1,
  814. };
  815. /* IPv4 address related functions. */
  816. static struct sctp_af sctp_af_inet = {
  817. .sa_family = AF_INET,
  818. .sctp_xmit = sctp_v4_xmit,
  819. .setsockopt = ip_setsockopt,
  820. .getsockopt = ip_getsockopt,
  821. .get_dst = sctp_v4_get_dst,
  822. .get_saddr = sctp_v4_get_saddr,
  823. .copy_addrlist = sctp_v4_copy_addrlist,
  824. .from_skb = sctp_v4_from_skb,
  825. .from_sk = sctp_v4_from_sk,
  826. .to_sk_saddr = sctp_v4_to_sk_saddr,
  827. .to_sk_daddr = sctp_v4_to_sk_daddr,
  828. .from_addr_param = sctp_v4_from_addr_param,
  829. .to_addr_param = sctp_v4_to_addr_param,
  830. .cmp_addr = sctp_v4_cmp_addr,
  831. .addr_valid = sctp_v4_addr_valid,
  832. .inaddr_any = sctp_v4_inaddr_any,
  833. .is_any = sctp_v4_is_any,
  834. .available = sctp_v4_available,
  835. .scope = sctp_v4_scope,
  836. .skb_iif = sctp_v4_skb_iif,
  837. .is_ce = sctp_v4_is_ce,
  838. .seq_dump_addr = sctp_v4_seq_dump_addr,
  839. .ecn_capable = sctp_v4_ecn_capable,
  840. .net_header_len = sizeof(struct iphdr),
  841. .sockaddr_len = sizeof(struct sockaddr_in),
  842. #ifdef CONFIG_COMPAT
  843. .compat_setsockopt = compat_ip_setsockopt,
  844. .compat_getsockopt = compat_ip_getsockopt,
  845. #endif
  846. };
  847. struct sctp_pf *sctp_get_pf_specific(sa_family_t family) {
  848. switch (family) {
  849. case PF_INET:
  850. return sctp_pf_inet_specific;
  851. case PF_INET6:
  852. return sctp_pf_inet6_specific;
  853. default:
  854. return NULL;
  855. }
  856. }
  857. /* Register the PF specific function table. */
  858. int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
  859. {
  860. switch (family) {
  861. case PF_INET:
  862. if (sctp_pf_inet_specific)
  863. return 0;
  864. sctp_pf_inet_specific = pf;
  865. break;
  866. case PF_INET6:
  867. if (sctp_pf_inet6_specific)
  868. return 0;
  869. sctp_pf_inet6_specific = pf;
  870. break;
  871. default:
  872. return 0;
  873. }
  874. return 1;
  875. }
  876. static inline int init_sctp_mibs(void)
  877. {
  878. return snmp_mib_init((void __percpu **)sctp_statistics,
  879. sizeof(struct sctp_mib),
  880. __alignof__(struct sctp_mib));
  881. }
  882. static inline void cleanup_sctp_mibs(void)
  883. {
  884. snmp_mib_free((void __percpu **)sctp_statistics);
  885. }
  886. static void sctp_v4_pf_init(void)
  887. {
  888. /* Initialize the SCTP specific PF functions. */
  889. sctp_register_pf(&sctp_pf_inet, PF_INET);
  890. sctp_register_af(&sctp_af_inet);
  891. }
  892. static void sctp_v4_pf_exit(void)
  893. {
  894. list_del(&sctp_af_inet.list);
  895. }
  896. static int sctp_v4_protosw_init(void)
  897. {
  898. int rc;
  899. rc = proto_register(&sctp_prot, 1);
  900. if (rc)
  901. return rc;
  902. /* Register SCTP(UDP and TCP style) with socket layer. */
  903. inet_register_protosw(&sctp_seqpacket_protosw);
  904. inet_register_protosw(&sctp_stream_protosw);
  905. return 0;
  906. }
  907. static void sctp_v4_protosw_exit(void)
  908. {
  909. inet_unregister_protosw(&sctp_stream_protosw);
  910. inet_unregister_protosw(&sctp_seqpacket_protosw);
  911. proto_unregister(&sctp_prot);
  912. }
  913. static int sctp_v4_add_protocol(void)
  914. {
  915. /* Register notifier for inet address additions/deletions. */
  916. register_inetaddr_notifier(&sctp_inetaddr_notifier);
  917. /* Register SCTP with inet layer. */
  918. if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0)
  919. return -EAGAIN;
  920. return 0;
  921. }
  922. static void sctp_v4_del_protocol(void)
  923. {
  924. inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
  925. unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
  926. }
  927. /* Initialize the universe into something sensible. */
  928. SCTP_STATIC __init int sctp_init(void)
  929. {
  930. int i;
  931. int status = -EINVAL;
  932. unsigned long goal;
  933. unsigned long limit;
  934. unsigned long nr_pages;
  935. int max_share;
  936. int order;
  937. /* SCTP_DEBUG sanity check. */
  938. if (!sctp_sanity_check())
  939. goto out;
  940. /* Allocate bind_bucket and chunk caches. */
  941. status = -ENOBUFS;
  942. sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
  943. sizeof(struct sctp_bind_bucket),
  944. 0, SLAB_HWCACHE_ALIGN,
  945. NULL);
  946. if (!sctp_bucket_cachep)
  947. goto out;
  948. sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
  949. sizeof(struct sctp_chunk),
  950. 0, SLAB_HWCACHE_ALIGN,
  951. NULL);
  952. if (!sctp_chunk_cachep)
  953. goto err_chunk_cachep;
  954. /* Allocate and initialise sctp mibs. */
  955. status = init_sctp_mibs();
  956. if (status)
  957. goto err_init_mibs;
  958. /* Initialize proc fs directory. */
  959. status = sctp_proc_init();
  960. if (status)
  961. goto err_init_proc;
  962. /* Initialize object count debugging. */
  963. sctp_dbg_objcnt_init();
  964. /*
  965. * 14. Suggested SCTP Protocol Parameter Values
  966. */
  967. /* The following protocol parameters are RECOMMENDED: */
  968. /* RTO.Initial - 3 seconds */
  969. sctp_rto_initial = SCTP_RTO_INITIAL;
  970. /* RTO.Min - 1 second */
  971. sctp_rto_min = SCTP_RTO_MIN;
  972. /* RTO.Max - 60 seconds */
  973. sctp_rto_max = SCTP_RTO_MAX;
  974. /* RTO.Alpha - 1/8 */
  975. sctp_rto_alpha = SCTP_RTO_ALPHA;
  976. /* RTO.Beta - 1/4 */
  977. sctp_rto_beta = SCTP_RTO_BETA;
  978. /* Valid.Cookie.Life - 60 seconds */
  979. sctp_valid_cookie_life = SCTP_DEFAULT_COOKIE_LIFE;
  980. /* Whether Cookie Preservative is enabled(1) or not(0) */
  981. sctp_cookie_preserve_enable = 1;
  982. /* Max.Burst - 4 */
  983. sctp_max_burst = SCTP_DEFAULT_MAX_BURST;
  984. /* Association.Max.Retrans - 10 attempts
  985. * Path.Max.Retrans - 5 attempts (per destination address)
  986. * Max.Init.Retransmits - 8 attempts
  987. */
  988. sctp_max_retrans_association = 10;
  989. sctp_max_retrans_path = 5;
  990. sctp_max_retrans_init = 8;
  991. /* Sendbuffer growth - do per-socket accounting */
  992. sctp_sndbuf_policy = 0;
  993. /* Rcvbuffer growth - do per-socket accounting */
  994. sctp_rcvbuf_policy = 0;
  995. /* HB.interval - 30 seconds */
  996. sctp_hb_interval = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
  997. /* delayed SACK timeout */
  998. sctp_sack_timeout = SCTP_DEFAULT_TIMEOUT_SACK;
  999. /* Implementation specific variables. */
  1000. /* Initialize default stream count setup information. */
  1001. sctp_max_instreams = SCTP_DEFAULT_INSTREAMS;
  1002. sctp_max_outstreams = SCTP_DEFAULT_OUTSTREAMS;
  1003. /* Initialize handle used for association ids. */
  1004. idr_init(&sctp_assocs_id);
  1005. /* Set the pressure threshold to be a fraction of global memory that
  1006. * is up to 1/2 at 256 MB, decreasing toward zero with the amount of
  1007. * memory, with a floor of 128 pages.
  1008. * Note this initializes the data in sctpv6_prot too
  1009. * Unabashedly stolen from tcp_init
  1010. */
  1011. nr_pages = totalram_pages - totalhigh_pages;
  1012. limit = min(nr_pages, 1UL<<(28-PAGE_SHIFT)) >> (20-PAGE_SHIFT);
  1013. limit = (limit * (nr_pages >> (20-PAGE_SHIFT))) >> (PAGE_SHIFT-11);
  1014. limit = max(limit, 128UL);
  1015. sysctl_sctp_mem[0] = limit / 4 * 3;
  1016. sysctl_sctp_mem[1] = limit;
  1017. sysctl_sctp_mem[2] = sysctl_sctp_mem[0] * 2;
  1018. /* Set per-socket limits to no more than 1/128 the pressure threshold*/
  1019. limit = (sysctl_sctp_mem[1]) << (PAGE_SHIFT - 7);
  1020. max_share = min(4UL*1024*1024, limit);
  1021. sysctl_sctp_rmem[0] = SK_MEM_QUANTUM; /* give each asoc 1 page min */
  1022. sysctl_sctp_rmem[1] = (1500 *(sizeof(struct sk_buff) + 1));
  1023. sysctl_sctp_rmem[2] = max(sysctl_sctp_rmem[1], max_share);
  1024. sysctl_sctp_wmem[0] = SK_MEM_QUANTUM;
  1025. sysctl_sctp_wmem[1] = 16*1024;
  1026. sysctl_sctp_wmem[2] = max(64*1024, max_share);
  1027. /* Size and allocate the association hash table.
  1028. * The methodology is similar to that of the tcp hash tables.
  1029. */
  1030. if (totalram_pages >= (128 * 1024))
  1031. goal = totalram_pages >> (22 - PAGE_SHIFT);
  1032. else
  1033. goal = totalram_pages >> (24 - PAGE_SHIFT);
  1034. for (order = 0; (1UL << order) < goal; order++)
  1035. ;
  1036. do {
  1037. sctp_assoc_hashsize = (1UL << order) * PAGE_SIZE /
  1038. sizeof(struct sctp_hashbucket);
  1039. if ((sctp_assoc_hashsize > (64 * 1024)) && order > 0)
  1040. continue;
  1041. sctp_assoc_hashtable = (struct sctp_hashbucket *)
  1042. __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
  1043. } while (!sctp_assoc_hashtable && --order > 0);
  1044. if (!sctp_assoc_hashtable) {
  1045. pr_err("Failed association hash alloc\n");
  1046. status = -ENOMEM;
  1047. goto err_ahash_alloc;
  1048. }
  1049. for (i = 0; i < sctp_assoc_hashsize; i++) {
  1050. rwlock_init(&sctp_assoc_hashtable[i].lock);
  1051. INIT_HLIST_HEAD(&sctp_assoc_hashtable[i].chain);
  1052. }
  1053. /* Allocate and initialize the endpoint hash table. */
  1054. sctp_ep_hashsize = 64;
  1055. sctp_ep_hashtable = (struct sctp_hashbucket *)
  1056. kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL);
  1057. if (!sctp_ep_hashtable) {
  1058. pr_err("Failed endpoint_hash alloc\n");
  1059. status = -ENOMEM;
  1060. goto err_ehash_alloc;
  1061. }
  1062. for (i = 0; i < sctp_ep_hashsize; i++) {
  1063. rwlock_init(&sctp_ep_hashtable[i].lock);
  1064. INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);
  1065. }
  1066. /* Allocate and initialize the SCTP port hash table. */
  1067. do {
  1068. sctp_port_hashsize = (1UL << order) * PAGE_SIZE /
  1069. sizeof(struct sctp_bind_hashbucket);
  1070. if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
  1071. continue;
  1072. sctp_port_hashtable = (struct sctp_bind_hashbucket *)
  1073. __get_free_pages(GFP_ATOMIC|__GFP_NOWARN, order);
  1074. } while (!sctp_port_hashtable && --order > 0);
  1075. if (!sctp_port_hashtable) {
  1076. pr_err("Failed bind hash alloc\n");
  1077. status = -ENOMEM;
  1078. goto err_bhash_alloc;
  1079. }
  1080. for (i = 0; i < sctp_port_hashsize; i++) {
  1081. spin_lock_init(&sctp_port_hashtable[i].lock);
  1082. INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);
  1083. }
  1084. pr_info("Hash tables configured (established %d bind %d)\n",
  1085. sctp_assoc_hashsize, sctp_port_hashsize);
  1086. /* Disable ADDIP by default. */
  1087. sctp_addip_enable = 0;
  1088. sctp_addip_noauth = 0;
  1089. /* Enable PR-SCTP by default. */
  1090. sctp_prsctp_enable = 1;
  1091. /* Disable AUTH by default. */
  1092. sctp_auth_enable = 0;
  1093. /* Set SCOPE policy to enabled */
  1094. sctp_scope_policy = SCTP_SCOPE_POLICY_ENABLE;
  1095. /* Set the default rwnd update threshold */
  1096. sctp_rwnd_upd_shift = SCTP_DEFAULT_RWND_SHIFT;
  1097. sctp_sysctl_register();
  1098. INIT_LIST_HEAD(&sctp_address_families);
  1099. sctp_v4_pf_init();
  1100. sctp_v6_pf_init();
  1101. /* Initialize the local address list. */
  1102. INIT_LIST_HEAD(&sctp_local_addr_list);
  1103. spin_lock_init(&sctp_local_addr_lock);
  1104. sctp_get_local_addr_list();
  1105. status = sctp_v4_protosw_init();
  1106. if (status)
  1107. goto err_protosw_init;
  1108. status = sctp_v6_protosw_init();
  1109. if (status)
  1110. goto err_v6_protosw_init;
  1111. /* Initialize the control inode/socket for handling OOTB packets. */
  1112. if ((status = sctp_ctl_sock_init())) {
  1113. pr_err("Failed to initialize the SCTP control sock\n");
  1114. goto err_ctl_sock_init;
  1115. }
  1116. status = sctp_v4_add_protocol();
  1117. if (status)
  1118. goto err_add_protocol;
  1119. /* Register SCTP with inet6 layer. */
  1120. status = sctp_v6_add_protocol();
  1121. if (status)
  1122. goto err_v6_add_protocol;
  1123. status = 0;
  1124. out:
  1125. return status;
  1126. err_v6_add_protocol:
  1127. sctp_v4_del_protocol();
  1128. err_add_protocol:
  1129. inet_ctl_sock_destroy(sctp_ctl_sock);
  1130. err_ctl_sock_init:
  1131. sctp_v6_protosw_exit();
  1132. err_v6_protosw_init:
  1133. sctp_v4_protosw_exit();
  1134. err_protosw_init:
  1135. sctp_free_local_addr_list();
  1136. sctp_v4_pf_exit();
  1137. sctp_v6_pf_exit();
  1138. sctp_sysctl_unregister();
  1139. free_pages((unsigned long)sctp_port_hashtable,
  1140. get_order(sctp_port_hashsize *
  1141. sizeof(struct sctp_bind_hashbucket)));
  1142. err_bhash_alloc:
  1143. kfree(sctp_ep_hashtable);
  1144. err_ehash_alloc:
  1145. free_pages((unsigned long)sctp_assoc_hashtable,
  1146. get_order(sctp_assoc_hashsize *
  1147. sizeof(struct sctp_hashbucket)));
  1148. err_ahash_alloc:
  1149. sctp_dbg_objcnt_exit();
  1150. sctp_proc_exit();
  1151. err_init_proc:
  1152. cleanup_sctp_mibs();
  1153. err_init_mibs:
  1154. kmem_cache_destroy(sctp_chunk_cachep);
  1155. err_chunk_cachep:
  1156. kmem_cache_destroy(sctp_bucket_cachep);
  1157. goto out;
  1158. }
  1159. /* Exit handler for the SCTP protocol. */
  1160. SCTP_STATIC __exit void sctp_exit(void)
  1161. {
  1162. /* BUG. This should probably do something useful like clean
  1163. * up all the remaining associations and all that memory.
  1164. */
  1165. /* Unregister with inet6/inet layers. */
  1166. sctp_v6_del_protocol();
  1167. sctp_v4_del_protocol();
  1168. /* Free the control endpoint. */
  1169. inet_ctl_sock_destroy(sctp_ctl_sock);
  1170. /* Free protosw registrations */
  1171. sctp_v6_protosw_exit();
  1172. sctp_v4_protosw_exit();
  1173. /* Free the local address list. */
  1174. sctp_free_local_addr_list();
  1175. /* Unregister with socket layer. */
  1176. sctp_v6_pf_exit();
  1177. sctp_v4_pf_exit();
  1178. sctp_sysctl_unregister();
  1179. free_pages((unsigned long)sctp_assoc_hashtable,
  1180. get_order(sctp_assoc_hashsize *
  1181. sizeof(struct sctp_hashbucket)));
  1182. kfree(sctp_ep_hashtable);
  1183. free_pages((unsigned long)sctp_port_hashtable,
  1184. get_order(sctp_port_hashsize *
  1185. sizeof(struct sctp_bind_hashbucket)));
  1186. sctp_dbg_objcnt_exit();
  1187. sctp_proc_exit();
  1188. cleanup_sctp_mibs();
  1189. rcu_barrier(); /* Wait for completion of call_rcu()'s */
  1190. kmem_cache_destroy(sctp_chunk_cachep);
  1191. kmem_cache_destroy(sctp_bucket_cachep);
  1192. }
  1193. module_init(sctp_init);
  1194. module_exit(sctp_exit);
  1195. /*
  1196. * __stringify doesn't likes enums, so use IPPROTO_SCTP value (132) directly.
  1197. */
  1198. MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
  1199. MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-132");
  1200. MODULE_AUTHOR("Linux Kernel SCTP developers <lksctp-developers@lists.sourceforge.net>");
  1201. MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
  1202. module_param_named(no_checksums, sctp_checksum_disable, bool, 0644);
  1203. MODULE_PARM_DESC(no_checksums, "Disable checksums computing and verification");
  1204. MODULE_LICENSE("GPL");