l2tp_ip6.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* L2TPv3 IP encapsulation support for IPv6
  3. *
  4. * Copyright (c) 2012 Katalix Systems Ltd
  5. */
  6. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  7. #include <linux/icmp.h>
  8. #include <linux/module.h>
  9. #include <linux/skbuff.h>
  10. #include <linux/random.h>
  11. #include <linux/socket.h>
  12. #include <linux/l2tp.h>
  13. #include <linux/in.h>
  14. #include <linux/in6.h>
  15. #include <net/sock.h>
  16. #include <net/ip.h>
  17. #include <net/icmp.h>
  18. #include <net/udp.h>
  19. #include <net/inet_common.h>
  20. #include <net/tcp_states.h>
  21. #include <net/protocol.h>
  22. #include <net/xfrm.h>
  23. #include <net/transp_v6.h>
  24. #include <net/addrconf.h>
  25. #include <net/ip6_route.h>
  26. #include "l2tp_core.h"
  27. struct l2tp_ip6_sock {
  28. /* inet_sock has to be the first member of l2tp_ip6_sock */
  29. struct inet_sock inet;
  30. u32 conn_id;
  31. u32 peer_conn_id;
  32. /* ipv6_pinfo has to be the last member of l2tp_ip6_sock, see
  33. * inet6_sk_generic
  34. */
  35. struct ipv6_pinfo inet6;
  36. };
  37. static DEFINE_RWLOCK(l2tp_ip6_lock);
  38. static struct hlist_head l2tp_ip6_table;
  39. static struct hlist_head l2tp_ip6_bind_table;
  40. static inline struct l2tp_ip6_sock *l2tp_ip6_sk(const struct sock *sk)
  41. {
  42. return (struct l2tp_ip6_sock *)sk;
  43. }
  44. static struct sock *__l2tp_ip6_bind_lookup(const struct net *net,
  45. const struct in6_addr *laddr,
  46. const struct in6_addr *raddr,
  47. int dif, u32 tunnel_id)
  48. {
  49. struct sock *sk;
  50. sk_for_each_bound(sk, &l2tp_ip6_bind_table) {
  51. const struct in6_addr *sk_laddr = inet6_rcv_saddr(sk);
  52. const struct in6_addr *sk_raddr = &sk->sk_v6_daddr;
  53. const struct l2tp_ip6_sock *l2tp = l2tp_ip6_sk(sk);
  54. if (!net_eq(sock_net(sk), net))
  55. continue;
  56. if (sk->sk_bound_dev_if && dif && sk->sk_bound_dev_if != dif)
  57. continue;
  58. if (sk_laddr && !ipv6_addr_any(sk_laddr) &&
  59. !ipv6_addr_any(laddr) && !ipv6_addr_equal(sk_laddr, laddr))
  60. continue;
  61. if (!ipv6_addr_any(sk_raddr) && raddr &&
  62. !ipv6_addr_any(raddr) && !ipv6_addr_equal(sk_raddr, raddr))
  63. continue;
  64. if (l2tp->conn_id != tunnel_id)
  65. continue;
  66. goto found;
  67. }
  68. sk = NULL;
  69. found:
  70. return sk;
  71. }
  72. /* When processing receive frames, there are two cases to
  73. * consider. Data frames consist of a non-zero session-id and an
  74. * optional cookie. Control frames consist of a regular L2TP header
  75. * preceded by 32-bits of zeros.
  76. *
  77. * L2TPv3 Session Header Over IP
  78. *
  79. * 0 1 2 3
  80. * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  81. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  82. * | Session ID |
  83. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  84. * | Cookie (optional, maximum 64 bits)...
  85. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  86. * |
  87. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  88. *
  89. * L2TPv3 Control Message Header Over IP
  90. *
  91. * 0 1 2 3
  92. * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  93. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  94. * | (32 bits of zeros) |
  95. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  96. * |T|L|x|x|S|x|x|x|x|x|x|x| Ver | Length |
  97. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  98. * | Control Connection ID |
  99. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  100. * | Ns | Nr |
  101. * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  102. *
  103. * All control frames are passed to userspace.
  104. */
  105. static int l2tp_ip6_recv(struct sk_buff *skb)
  106. {
  107. struct net *net = dev_net(skb->dev);
  108. struct sock *sk;
  109. u32 session_id;
  110. u32 tunnel_id;
  111. unsigned char *ptr, *optr;
  112. struct l2tp_session *session;
  113. struct l2tp_tunnel *tunnel = NULL;
  114. struct ipv6hdr *iph;
  115. if (!pskb_may_pull(skb, 4))
  116. goto discard;
  117. /* Point to L2TP header */
  118. optr = skb->data;
  119. ptr = skb->data;
  120. session_id = ntohl(*((__be32 *)ptr));
  121. ptr += 4;
  122. /* RFC3931: L2TP/IP packets have the first 4 bytes containing
  123. * the session_id. If it is 0, the packet is a L2TP control
  124. * frame and the session_id value can be discarded.
  125. */
  126. if (session_id == 0) {
  127. __skb_pull(skb, 4);
  128. goto pass_up;
  129. }
  130. /* Ok, this is a data packet. Lookup the session. */
  131. session = l2tp_session_get(net, session_id);
  132. if (!session)
  133. goto discard;
  134. tunnel = session->tunnel;
  135. if (!tunnel)
  136. goto discard_sess;
  137. if (l2tp_v3_ensure_opt_in_linear(session, skb, &ptr, &optr))
  138. goto discard_sess;
  139. l2tp_recv_common(session, skb, ptr, optr, 0, skb->len);
  140. l2tp_session_dec_refcount(session);
  141. return 0;
  142. pass_up:
  143. /* Get the tunnel_id from the L2TP header */
  144. if (!pskb_may_pull(skb, 12))
  145. goto discard;
  146. if ((skb->data[0] & 0xc0) != 0xc0)
  147. goto discard;
  148. tunnel_id = ntohl(*(__be32 *)&skb->data[4]);
  149. iph = ipv6_hdr(skb);
  150. read_lock_bh(&l2tp_ip6_lock);
  151. sk = __l2tp_ip6_bind_lookup(net, &iph->daddr, &iph->saddr,
  152. inet6_iif(skb), tunnel_id);
  153. if (!sk) {
  154. read_unlock_bh(&l2tp_ip6_lock);
  155. goto discard;
  156. }
  157. sock_hold(sk);
  158. read_unlock_bh(&l2tp_ip6_lock);
  159. if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
  160. goto discard_put;
  161. nf_reset_ct(skb);
  162. return sk_receive_skb(sk, skb, 1);
  163. discard_sess:
  164. l2tp_session_dec_refcount(session);
  165. goto discard;
  166. discard_put:
  167. sock_put(sk);
  168. discard:
  169. kfree_skb(skb);
  170. return 0;
  171. }
  172. static int l2tp_ip6_hash(struct sock *sk)
  173. {
  174. if (sk_unhashed(sk)) {
  175. write_lock_bh(&l2tp_ip6_lock);
  176. sk_add_node(sk, &l2tp_ip6_table);
  177. write_unlock_bh(&l2tp_ip6_lock);
  178. }
  179. return 0;
  180. }
  181. static void l2tp_ip6_unhash(struct sock *sk)
  182. {
  183. if (sk_unhashed(sk))
  184. return;
  185. write_lock_bh(&l2tp_ip6_lock);
  186. sk_del_node_init(sk);
  187. write_unlock_bh(&l2tp_ip6_lock);
  188. }
  189. static int l2tp_ip6_open(struct sock *sk)
  190. {
  191. /* Prevent autobind. We don't have ports. */
  192. inet_sk(sk)->inet_num = IPPROTO_L2TP;
  193. l2tp_ip6_hash(sk);
  194. return 0;
  195. }
  196. static void l2tp_ip6_close(struct sock *sk, long timeout)
  197. {
  198. write_lock_bh(&l2tp_ip6_lock);
  199. hlist_del_init(&sk->sk_bind_node);
  200. sk_del_node_init(sk);
  201. write_unlock_bh(&l2tp_ip6_lock);
  202. sk_common_release(sk);
  203. }
  204. static void l2tp_ip6_destroy_sock(struct sock *sk)
  205. {
  206. struct l2tp_tunnel *tunnel = l2tp_sk_to_tunnel(sk);
  207. lock_sock(sk);
  208. ip6_flush_pending_frames(sk);
  209. release_sock(sk);
  210. if (tunnel)
  211. l2tp_tunnel_delete(tunnel);
  212. inet6_destroy_sock(sk);
  213. }
  214. static int l2tp_ip6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
  215. {
  216. struct inet_sock *inet = inet_sk(sk);
  217. struct ipv6_pinfo *np = inet6_sk(sk);
  218. struct sockaddr_l2tpip6 *addr = (struct sockaddr_l2tpip6 *)uaddr;
  219. struct net *net = sock_net(sk);
  220. __be32 v4addr = 0;
  221. int bound_dev_if;
  222. int addr_type;
  223. int err;
  224. if (addr->l2tp_family != AF_INET6)
  225. return -EINVAL;
  226. if (addr_len < sizeof(*addr))
  227. return -EINVAL;
  228. addr_type = ipv6_addr_type(&addr->l2tp_addr);
  229. /* l2tp_ip6 sockets are IPv6 only */
  230. if (addr_type == IPV6_ADDR_MAPPED)
  231. return -EADDRNOTAVAIL;
  232. /* L2TP is point-point, not multicast */
  233. if (addr_type & IPV6_ADDR_MULTICAST)
  234. return -EADDRNOTAVAIL;
  235. lock_sock(sk);
  236. err = -EINVAL;
  237. if (!sock_flag(sk, SOCK_ZAPPED))
  238. goto out_unlock;
  239. if (sk->sk_state != TCP_CLOSE)
  240. goto out_unlock;
  241. bound_dev_if = sk->sk_bound_dev_if;
  242. /* Check if the address belongs to the host. */
  243. rcu_read_lock();
  244. if (addr_type != IPV6_ADDR_ANY) {
  245. struct net_device *dev = NULL;
  246. if (addr_type & IPV6_ADDR_LINKLOCAL) {
  247. if (addr->l2tp_scope_id)
  248. bound_dev_if = addr->l2tp_scope_id;
  249. /* Binding to link-local address requires an
  250. * interface.
  251. */
  252. if (!bound_dev_if)
  253. goto out_unlock_rcu;
  254. err = -ENODEV;
  255. dev = dev_get_by_index_rcu(sock_net(sk), bound_dev_if);
  256. if (!dev)
  257. goto out_unlock_rcu;
  258. }
  259. /* ipv4 addr of the socket is invalid. Only the
  260. * unspecified and mapped address have a v4 equivalent.
  261. */
  262. v4addr = LOOPBACK4_IPV6;
  263. err = -EADDRNOTAVAIL;
  264. if (!ipv6_chk_addr(sock_net(sk), &addr->l2tp_addr, dev, 0))
  265. goto out_unlock_rcu;
  266. }
  267. rcu_read_unlock();
  268. write_lock_bh(&l2tp_ip6_lock);
  269. if (__l2tp_ip6_bind_lookup(net, &addr->l2tp_addr, NULL, bound_dev_if,
  270. addr->l2tp_conn_id)) {
  271. write_unlock_bh(&l2tp_ip6_lock);
  272. err = -EADDRINUSE;
  273. goto out_unlock;
  274. }
  275. inet->inet_saddr = v4addr;
  276. inet->inet_rcv_saddr = v4addr;
  277. sk->sk_bound_dev_if = bound_dev_if;
  278. sk->sk_v6_rcv_saddr = addr->l2tp_addr;
  279. np->saddr = addr->l2tp_addr;
  280. l2tp_ip6_sk(sk)->conn_id = addr->l2tp_conn_id;
  281. sk_add_bind_node(sk, &l2tp_ip6_bind_table);
  282. sk_del_node_init(sk);
  283. write_unlock_bh(&l2tp_ip6_lock);
  284. sock_reset_flag(sk, SOCK_ZAPPED);
  285. release_sock(sk);
  286. return 0;
  287. out_unlock_rcu:
  288. rcu_read_unlock();
  289. out_unlock:
  290. release_sock(sk);
  291. return err;
  292. }
  293. static int l2tp_ip6_connect(struct sock *sk, struct sockaddr *uaddr,
  294. int addr_len)
  295. {
  296. struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)uaddr;
  297. struct sockaddr_in6 *usin = (struct sockaddr_in6 *)uaddr;
  298. struct in6_addr *daddr;
  299. int addr_type;
  300. int rc;
  301. if (addr_len < sizeof(*lsa))
  302. return -EINVAL;
  303. if (usin->sin6_family != AF_INET6)
  304. return -EINVAL;
  305. addr_type = ipv6_addr_type(&usin->sin6_addr);
  306. if (addr_type & IPV6_ADDR_MULTICAST)
  307. return -EINVAL;
  308. if (addr_type & IPV6_ADDR_MAPPED) {
  309. daddr = &usin->sin6_addr;
  310. if (ipv4_is_multicast(daddr->s6_addr32[3]))
  311. return -EINVAL;
  312. }
  313. lock_sock(sk);
  314. /* Must bind first - autobinding does not work */
  315. if (sock_flag(sk, SOCK_ZAPPED)) {
  316. rc = -EINVAL;
  317. goto out_sk;
  318. }
  319. rc = __ip6_datagram_connect(sk, uaddr, addr_len);
  320. if (rc < 0)
  321. goto out_sk;
  322. l2tp_ip6_sk(sk)->peer_conn_id = lsa->l2tp_conn_id;
  323. write_lock_bh(&l2tp_ip6_lock);
  324. hlist_del_init(&sk->sk_bind_node);
  325. sk_add_bind_node(sk, &l2tp_ip6_bind_table);
  326. write_unlock_bh(&l2tp_ip6_lock);
  327. out_sk:
  328. release_sock(sk);
  329. return rc;
  330. }
  331. static int l2tp_ip6_disconnect(struct sock *sk, int flags)
  332. {
  333. if (sock_flag(sk, SOCK_ZAPPED))
  334. return 0;
  335. return __udp_disconnect(sk, flags);
  336. }
  337. static int l2tp_ip6_getname(struct socket *sock, struct sockaddr *uaddr,
  338. int peer)
  339. {
  340. struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)uaddr;
  341. struct sock *sk = sock->sk;
  342. struct ipv6_pinfo *np = inet6_sk(sk);
  343. struct l2tp_ip6_sock *lsk = l2tp_ip6_sk(sk);
  344. lsa->l2tp_family = AF_INET6;
  345. lsa->l2tp_flowinfo = 0;
  346. lsa->l2tp_scope_id = 0;
  347. lsa->l2tp_unused = 0;
  348. if (peer) {
  349. if (!lsk->peer_conn_id)
  350. return -ENOTCONN;
  351. lsa->l2tp_conn_id = lsk->peer_conn_id;
  352. lsa->l2tp_addr = sk->sk_v6_daddr;
  353. if (np->sndflow)
  354. lsa->l2tp_flowinfo = np->flow_label;
  355. } else {
  356. if (ipv6_addr_any(&sk->sk_v6_rcv_saddr))
  357. lsa->l2tp_addr = np->saddr;
  358. else
  359. lsa->l2tp_addr = sk->sk_v6_rcv_saddr;
  360. lsa->l2tp_conn_id = lsk->conn_id;
  361. }
  362. if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
  363. lsa->l2tp_scope_id = sk->sk_bound_dev_if;
  364. return sizeof(*lsa);
  365. }
  366. static int l2tp_ip6_backlog_recv(struct sock *sk, struct sk_buff *skb)
  367. {
  368. int rc;
  369. /* Charge it to the socket, dropping if the queue is full. */
  370. rc = sock_queue_rcv_skb(sk, skb);
  371. if (rc < 0)
  372. goto drop;
  373. return 0;
  374. drop:
  375. IP_INC_STATS(sock_net(sk), IPSTATS_MIB_INDISCARDS);
  376. kfree_skb(skb);
  377. return -1;
  378. }
  379. static int l2tp_ip6_push_pending_frames(struct sock *sk)
  380. {
  381. struct sk_buff *skb;
  382. __be32 *transhdr = NULL;
  383. int err = 0;
  384. skb = skb_peek(&sk->sk_write_queue);
  385. if (!skb)
  386. goto out;
  387. transhdr = (__be32 *)skb_transport_header(skb);
  388. *transhdr = 0;
  389. err = ip6_push_pending_frames(sk);
  390. out:
  391. return err;
  392. }
  393. /* Userspace will call sendmsg() on the tunnel socket to send L2TP
  394. * control frames.
  395. */
  396. static int l2tp_ip6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
  397. {
  398. struct ipv6_txoptions opt_space;
  399. DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name);
  400. struct in6_addr *daddr, *final_p, final;
  401. struct ipv6_pinfo *np = inet6_sk(sk);
  402. struct ipv6_txoptions *opt_to_free = NULL;
  403. struct ipv6_txoptions *opt = NULL;
  404. struct ip6_flowlabel *flowlabel = NULL;
  405. struct dst_entry *dst = NULL;
  406. struct flowi6 fl6;
  407. struct ipcm6_cookie ipc6;
  408. int addr_len = msg->msg_namelen;
  409. int transhdrlen = 4; /* zero session-id */
  410. int ulen = len + transhdrlen;
  411. int err;
  412. /* Rough check on arithmetic overflow,
  413. * better check is made in ip6_append_data().
  414. */
  415. if (len > INT_MAX)
  416. return -EMSGSIZE;
  417. /* Mirror BSD error message compatibility */
  418. if (msg->msg_flags & MSG_OOB)
  419. return -EOPNOTSUPP;
  420. /* Get and verify the address */
  421. memset(&fl6, 0, sizeof(fl6));
  422. fl6.flowi6_mark = sk->sk_mark;
  423. fl6.flowi6_uid = sk->sk_uid;
  424. ipcm6_init(&ipc6);
  425. if (lsa) {
  426. if (addr_len < SIN6_LEN_RFC2133)
  427. return -EINVAL;
  428. if (lsa->l2tp_family && lsa->l2tp_family != AF_INET6)
  429. return -EAFNOSUPPORT;
  430. daddr = &lsa->l2tp_addr;
  431. if (np->sndflow) {
  432. fl6.flowlabel = lsa->l2tp_flowinfo & IPV6_FLOWINFO_MASK;
  433. if (fl6.flowlabel & IPV6_FLOWLABEL_MASK) {
  434. flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
  435. if (IS_ERR(flowlabel))
  436. return -EINVAL;
  437. }
  438. }
  439. /* Otherwise it will be difficult to maintain
  440. * sk->sk_dst_cache.
  441. */
  442. if (sk->sk_state == TCP_ESTABLISHED &&
  443. ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
  444. daddr = &sk->sk_v6_daddr;
  445. if (addr_len >= sizeof(struct sockaddr_in6) &&
  446. lsa->l2tp_scope_id &&
  447. ipv6_addr_type(daddr) & IPV6_ADDR_LINKLOCAL)
  448. fl6.flowi6_oif = lsa->l2tp_scope_id;
  449. } else {
  450. if (sk->sk_state != TCP_ESTABLISHED)
  451. return -EDESTADDRREQ;
  452. daddr = &sk->sk_v6_daddr;
  453. fl6.flowlabel = np->flow_label;
  454. }
  455. if (fl6.flowi6_oif == 0)
  456. fl6.flowi6_oif = sk->sk_bound_dev_if;
  457. if (msg->msg_controllen) {
  458. opt = &opt_space;
  459. memset(opt, 0, sizeof(struct ipv6_txoptions));
  460. opt->tot_len = sizeof(struct ipv6_txoptions);
  461. ipc6.opt = opt;
  462. err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, &ipc6);
  463. if (err < 0) {
  464. fl6_sock_release(flowlabel);
  465. return err;
  466. }
  467. if ((fl6.flowlabel & IPV6_FLOWLABEL_MASK) && !flowlabel) {
  468. flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
  469. if (IS_ERR(flowlabel))
  470. return -EINVAL;
  471. }
  472. if (!(opt->opt_nflen | opt->opt_flen))
  473. opt = NULL;
  474. }
  475. if (!opt) {
  476. opt = txopt_get(np);
  477. opt_to_free = opt;
  478. }
  479. if (flowlabel)
  480. opt = fl6_merge_options(&opt_space, flowlabel, opt);
  481. opt = ipv6_fixup_options(&opt_space, opt);
  482. ipc6.opt = opt;
  483. fl6.flowi6_proto = sk->sk_protocol;
  484. if (!ipv6_addr_any(daddr))
  485. fl6.daddr = *daddr;
  486. else
  487. fl6.daddr.s6_addr[15] = 0x1; /* :: means loopback (BSD'ism) */
  488. if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
  489. fl6.saddr = np->saddr;
  490. final_p = fl6_update_dst(&fl6, opt, &final);
  491. if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
  492. fl6.flowi6_oif = np->mcast_oif;
  493. else if (!fl6.flowi6_oif)
  494. fl6.flowi6_oif = np->ucast_oif;
  495. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
  496. if (ipc6.tclass < 0)
  497. ipc6.tclass = np->tclass;
  498. fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
  499. dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
  500. if (IS_ERR(dst)) {
  501. err = PTR_ERR(dst);
  502. goto out;
  503. }
  504. if (ipc6.hlimit < 0)
  505. ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
  506. if (ipc6.dontfrag < 0)
  507. ipc6.dontfrag = np->dontfrag;
  508. if (msg->msg_flags & MSG_CONFIRM)
  509. goto do_confirm;
  510. back_from_confirm:
  511. lock_sock(sk);
  512. err = ip6_append_data(sk, ip_generic_getfrag, msg,
  513. ulen, transhdrlen, &ipc6,
  514. &fl6, (struct rt6_info *)dst,
  515. msg->msg_flags);
  516. if (err)
  517. ip6_flush_pending_frames(sk);
  518. else if (!(msg->msg_flags & MSG_MORE))
  519. err = l2tp_ip6_push_pending_frames(sk);
  520. release_sock(sk);
  521. done:
  522. dst_release(dst);
  523. out:
  524. fl6_sock_release(flowlabel);
  525. txopt_put(opt_to_free);
  526. return err < 0 ? err : len;
  527. do_confirm:
  528. if (msg->msg_flags & MSG_PROBE)
  529. dst_confirm_neigh(dst, &fl6.daddr);
  530. if (!(msg->msg_flags & MSG_PROBE) || len)
  531. goto back_from_confirm;
  532. err = 0;
  533. goto done;
  534. }
  535. static int l2tp_ip6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
  536. int noblock, int flags, int *addr_len)
  537. {
  538. struct ipv6_pinfo *np = inet6_sk(sk);
  539. DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name);
  540. size_t copied = 0;
  541. int err = -EOPNOTSUPP;
  542. struct sk_buff *skb;
  543. if (flags & MSG_OOB)
  544. goto out;
  545. if (flags & MSG_ERRQUEUE)
  546. return ipv6_recv_error(sk, msg, len, addr_len);
  547. skb = skb_recv_datagram(sk, flags, noblock, &err);
  548. if (!skb)
  549. goto out;
  550. copied = skb->len;
  551. if (len < copied) {
  552. msg->msg_flags |= MSG_TRUNC;
  553. copied = len;
  554. }
  555. err = skb_copy_datagram_msg(skb, 0, msg, copied);
  556. if (err)
  557. goto done;
  558. sock_recv_timestamp(msg, sk, skb);
  559. /* Copy the address. */
  560. if (lsa) {
  561. lsa->l2tp_family = AF_INET6;
  562. lsa->l2tp_unused = 0;
  563. lsa->l2tp_addr = ipv6_hdr(skb)->saddr;
  564. lsa->l2tp_flowinfo = 0;
  565. lsa->l2tp_scope_id = 0;
  566. lsa->l2tp_conn_id = 0;
  567. if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
  568. lsa->l2tp_scope_id = inet6_iif(skb);
  569. *addr_len = sizeof(*lsa);
  570. }
  571. if (np->rxopt.all)
  572. ip6_datagram_recv_ctl(sk, msg, skb);
  573. if (flags & MSG_TRUNC)
  574. copied = skb->len;
  575. done:
  576. skb_free_datagram(sk, skb);
  577. out:
  578. return err ? err : copied;
  579. }
  580. static struct proto l2tp_ip6_prot = {
  581. .name = "L2TP/IPv6",
  582. .owner = THIS_MODULE,
  583. .init = l2tp_ip6_open,
  584. .close = l2tp_ip6_close,
  585. .bind = l2tp_ip6_bind,
  586. .connect = l2tp_ip6_connect,
  587. .disconnect = l2tp_ip6_disconnect,
  588. .ioctl = l2tp_ioctl,
  589. .destroy = l2tp_ip6_destroy_sock,
  590. .setsockopt = ipv6_setsockopt,
  591. .getsockopt = ipv6_getsockopt,
  592. .sendmsg = l2tp_ip6_sendmsg,
  593. .recvmsg = l2tp_ip6_recvmsg,
  594. .backlog_rcv = l2tp_ip6_backlog_recv,
  595. .hash = l2tp_ip6_hash,
  596. .unhash = l2tp_ip6_unhash,
  597. .obj_size = sizeof(struct l2tp_ip6_sock),
  598. };
  599. static const struct proto_ops l2tp_ip6_ops = {
  600. .family = PF_INET6,
  601. .owner = THIS_MODULE,
  602. .release = inet6_release,
  603. .bind = inet6_bind,
  604. .connect = inet_dgram_connect,
  605. .socketpair = sock_no_socketpair,
  606. .accept = sock_no_accept,
  607. .getname = l2tp_ip6_getname,
  608. .poll = datagram_poll,
  609. .ioctl = inet6_ioctl,
  610. .gettstamp = sock_gettstamp,
  611. .listen = sock_no_listen,
  612. .shutdown = inet_shutdown,
  613. .setsockopt = sock_common_setsockopt,
  614. .getsockopt = sock_common_getsockopt,
  615. .sendmsg = inet_sendmsg,
  616. .recvmsg = sock_common_recvmsg,
  617. .mmap = sock_no_mmap,
  618. .sendpage = sock_no_sendpage,
  619. #ifdef CONFIG_COMPAT
  620. .compat_ioctl = inet6_compat_ioctl,
  621. #endif
  622. };
  623. static struct inet_protosw l2tp_ip6_protosw = {
  624. .type = SOCK_DGRAM,
  625. .protocol = IPPROTO_L2TP,
  626. .prot = &l2tp_ip6_prot,
  627. .ops = &l2tp_ip6_ops,
  628. };
  629. static struct inet6_protocol l2tp_ip6_protocol __read_mostly = {
  630. .handler = l2tp_ip6_recv,
  631. };
  632. static int __init l2tp_ip6_init(void)
  633. {
  634. int err;
  635. pr_info("L2TP IP encapsulation support for IPv6 (L2TPv3)\n");
  636. err = proto_register(&l2tp_ip6_prot, 1);
  637. if (err != 0)
  638. goto out;
  639. err = inet6_add_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
  640. if (err)
  641. goto out1;
  642. inet6_register_protosw(&l2tp_ip6_protosw);
  643. return 0;
  644. out1:
  645. proto_unregister(&l2tp_ip6_prot);
  646. out:
  647. return err;
  648. }
  649. static void __exit l2tp_ip6_exit(void)
  650. {
  651. inet6_unregister_protosw(&l2tp_ip6_protosw);
  652. inet6_del_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
  653. proto_unregister(&l2tp_ip6_prot);
  654. }
  655. module_init(l2tp_ip6_init);
  656. module_exit(l2tp_ip6_exit);
  657. MODULE_LICENSE("GPL");
  658. MODULE_AUTHOR("Chris Elston <celston@katalix.com>");
  659. MODULE_DESCRIPTION("L2TP IP encapsulation for IPv6");
  660. MODULE_VERSION("1.0");
  661. /* Use the value of SOCK_DGRAM (2) directory, because __stringify doesn't like
  662. * enums
  663. */
  664. MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 2, IPPROTO_L2TP);
  665. MODULE_ALIAS_NET_PF_PROTO(PF_INET6, IPPROTO_L2TP);