mip6.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C)2003-2006 Helsinki University of Technology
  4. * Copyright (C)2003-2006 USAGI/WIDE Project
  5. */
  6. /*
  7. * Authors:
  8. * Noriaki TAKAMIYA @USAGI
  9. * Masahide NAKAMURA @USAGI
  10. */
  11. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12. #include <linux/module.h>
  13. #include <linux/skbuff.h>
  14. #include <linux/time.h>
  15. #include <linux/ipv6.h>
  16. #include <linux/icmpv6.h>
  17. #include <net/sock.h>
  18. #include <net/ipv6.h>
  19. #include <net/ip6_checksum.h>
  20. #include <net/rawv6.h>
  21. #include <net/xfrm.h>
  22. #include <net/mip6.h>
  23. static inline unsigned int calc_padlen(unsigned int len, unsigned int n)
  24. {
  25. return (n - len + 16) & 0x7;
  26. }
  27. static inline void *mip6_padn(__u8 *data, __u8 padlen)
  28. {
  29. if (!data)
  30. return NULL;
  31. if (padlen == 1) {
  32. data[0] = IPV6_TLV_PAD1;
  33. } else if (padlen > 1) {
  34. data[0] = IPV6_TLV_PADN;
  35. data[1] = padlen - 2;
  36. if (padlen > 2)
  37. memset(data+2, 0, data[1]);
  38. }
  39. return data + padlen;
  40. }
  41. static inline void mip6_param_prob(struct sk_buff *skb, u8 code, int pos)
  42. {
  43. icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
  44. }
  45. static int mip6_mh_len(int type)
  46. {
  47. int len = 0;
  48. switch (type) {
  49. case IP6_MH_TYPE_BRR:
  50. len = 0;
  51. break;
  52. case IP6_MH_TYPE_HOTI:
  53. case IP6_MH_TYPE_COTI:
  54. case IP6_MH_TYPE_BU:
  55. case IP6_MH_TYPE_BACK:
  56. len = 1;
  57. break;
  58. case IP6_MH_TYPE_HOT:
  59. case IP6_MH_TYPE_COT:
  60. case IP6_MH_TYPE_BERROR:
  61. len = 2;
  62. break;
  63. }
  64. return len;
  65. }
  66. static int mip6_mh_filter(struct sock *sk, struct sk_buff *skb)
  67. {
  68. struct ip6_mh _hdr;
  69. const struct ip6_mh *mh;
  70. mh = skb_header_pointer(skb, skb_transport_offset(skb),
  71. sizeof(_hdr), &_hdr);
  72. if (!mh)
  73. return -1;
  74. if (((mh->ip6mh_hdrlen + 1) << 3) > skb->len)
  75. return -1;
  76. if (mh->ip6mh_hdrlen < mip6_mh_len(mh->ip6mh_type)) {
  77. net_dbg_ratelimited("mip6: MH message too short: %d vs >=%d\n",
  78. mh->ip6mh_hdrlen,
  79. mip6_mh_len(mh->ip6mh_type));
  80. mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_hdrlen) +
  81. skb_network_header_len(skb));
  82. return -1;
  83. }
  84. if (mh->ip6mh_proto != IPPROTO_NONE) {
  85. net_dbg_ratelimited("mip6: MH invalid payload proto = %d\n",
  86. mh->ip6mh_proto);
  87. mip6_param_prob(skb, 0, offsetof(struct ip6_mh, ip6mh_proto) +
  88. skb_network_header_len(skb));
  89. return -1;
  90. }
  91. return 0;
  92. }
  93. struct mip6_report_rate_limiter {
  94. spinlock_t lock;
  95. ktime_t stamp;
  96. int iif;
  97. struct in6_addr src;
  98. struct in6_addr dst;
  99. };
  100. static struct mip6_report_rate_limiter mip6_report_rl = {
  101. .lock = __SPIN_LOCK_UNLOCKED(mip6_report_rl.lock)
  102. };
  103. static int mip6_destopt_input(struct xfrm_state *x, struct sk_buff *skb)
  104. {
  105. const struct ipv6hdr *iph = ipv6_hdr(skb);
  106. struct ipv6_destopt_hdr *destopt = (struct ipv6_destopt_hdr *)skb->data;
  107. int err = destopt->nexthdr;
  108. spin_lock(&x->lock);
  109. if (!ipv6_addr_equal(&iph->saddr, (struct in6_addr *)x->coaddr) &&
  110. !ipv6_addr_any((struct in6_addr *)x->coaddr))
  111. err = -ENOENT;
  112. spin_unlock(&x->lock);
  113. return err;
  114. }
  115. /* Destination Option Header is inserted.
  116. * IP Header's src address is replaced with Home Address Option in
  117. * Destination Option Header.
  118. */
  119. static int mip6_destopt_output(struct xfrm_state *x, struct sk_buff *skb)
  120. {
  121. struct ipv6hdr *iph;
  122. struct ipv6_destopt_hdr *dstopt;
  123. struct ipv6_destopt_hao *hao;
  124. u8 nexthdr;
  125. int len;
  126. skb_push(skb, -skb_network_offset(skb));
  127. iph = ipv6_hdr(skb);
  128. nexthdr = *skb_mac_header(skb);
  129. *skb_mac_header(skb) = IPPROTO_DSTOPTS;
  130. dstopt = (struct ipv6_destopt_hdr *)skb_transport_header(skb);
  131. dstopt->nexthdr = nexthdr;
  132. hao = mip6_padn((char *)(dstopt + 1),
  133. calc_padlen(sizeof(*dstopt), 6));
  134. hao->type = IPV6_TLV_HAO;
  135. BUILD_BUG_ON(sizeof(*hao) != 18);
  136. hao->length = sizeof(*hao) - 2;
  137. len = ((char *)hao - (char *)dstopt) + sizeof(*hao);
  138. memcpy(&hao->addr, &iph->saddr, sizeof(hao->addr));
  139. spin_lock_bh(&x->lock);
  140. memcpy(&iph->saddr, x->coaddr, sizeof(iph->saddr));
  141. spin_unlock_bh(&x->lock);
  142. WARN_ON(len != x->props.header_len);
  143. dstopt->hdrlen = (x->props.header_len >> 3) - 1;
  144. return 0;
  145. }
  146. static inline int mip6_report_rl_allow(ktime_t stamp,
  147. const struct in6_addr *dst,
  148. const struct in6_addr *src, int iif)
  149. {
  150. int allow = 0;
  151. spin_lock_bh(&mip6_report_rl.lock);
  152. if (mip6_report_rl.stamp != stamp ||
  153. mip6_report_rl.iif != iif ||
  154. !ipv6_addr_equal(&mip6_report_rl.src, src) ||
  155. !ipv6_addr_equal(&mip6_report_rl.dst, dst)) {
  156. mip6_report_rl.stamp = stamp;
  157. mip6_report_rl.iif = iif;
  158. mip6_report_rl.src = *src;
  159. mip6_report_rl.dst = *dst;
  160. allow = 1;
  161. }
  162. spin_unlock_bh(&mip6_report_rl.lock);
  163. return allow;
  164. }
  165. static int mip6_destopt_reject(struct xfrm_state *x, struct sk_buff *skb,
  166. const struct flowi *fl)
  167. {
  168. struct net *net = xs_net(x);
  169. struct inet6_skb_parm *opt = (struct inet6_skb_parm *)skb->cb;
  170. const struct flowi6 *fl6 = &fl->u.ip6;
  171. struct ipv6_destopt_hao *hao = NULL;
  172. struct xfrm_selector sel;
  173. int offset;
  174. ktime_t stamp;
  175. int err = 0;
  176. if (unlikely(fl6->flowi6_proto == IPPROTO_MH &&
  177. fl6->fl6_mh_type <= IP6_MH_TYPE_MAX))
  178. goto out;
  179. if (likely(opt->dsthao)) {
  180. offset = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
  181. if (likely(offset >= 0))
  182. hao = (struct ipv6_destopt_hao *)
  183. (skb_network_header(skb) + offset);
  184. }
  185. stamp = skb_get_ktime(skb);
  186. if (!mip6_report_rl_allow(stamp, &ipv6_hdr(skb)->daddr,
  187. hao ? &hao->addr : &ipv6_hdr(skb)->saddr,
  188. opt->iif))
  189. goto out;
  190. memset(&sel, 0, sizeof(sel));
  191. memcpy(&sel.daddr, (xfrm_address_t *)&ipv6_hdr(skb)->daddr,
  192. sizeof(sel.daddr));
  193. sel.prefixlen_d = 128;
  194. memcpy(&sel.saddr, (xfrm_address_t *)&ipv6_hdr(skb)->saddr,
  195. sizeof(sel.saddr));
  196. sel.prefixlen_s = 128;
  197. sel.family = AF_INET6;
  198. sel.proto = fl6->flowi6_proto;
  199. sel.dport = xfrm_flowi_dport(fl, &fl6->uli);
  200. if (sel.dport)
  201. sel.dport_mask = htons(~0);
  202. sel.sport = xfrm_flowi_sport(fl, &fl6->uli);
  203. if (sel.sport)
  204. sel.sport_mask = htons(~0);
  205. sel.ifindex = fl6->flowi6_oif;
  206. err = km_report(net, IPPROTO_DSTOPTS, &sel,
  207. (hao ? (xfrm_address_t *)&hao->addr : NULL));
  208. out:
  209. return err;
  210. }
  211. static int mip6_destopt_offset(struct xfrm_state *x, struct sk_buff *skb,
  212. u8 **nexthdr)
  213. {
  214. u16 offset = sizeof(struct ipv6hdr);
  215. struct ipv6_opt_hdr *exthdr =
  216. (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1);
  217. const unsigned char *nh = skb_network_header(skb);
  218. unsigned int packet_len = skb_tail_pointer(skb) -
  219. skb_network_header(skb);
  220. int found_rhdr = 0;
  221. *nexthdr = &ipv6_hdr(skb)->nexthdr;
  222. while (offset + 1 <= packet_len) {
  223. switch (**nexthdr) {
  224. case NEXTHDR_HOP:
  225. break;
  226. case NEXTHDR_ROUTING:
  227. found_rhdr = 1;
  228. break;
  229. case NEXTHDR_DEST:
  230. /*
  231. * HAO MUST NOT appear more than once.
  232. * XXX: It is better to try to find by the end of
  233. * XXX: packet if HAO exists.
  234. */
  235. if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0) {
  236. net_dbg_ratelimited("mip6: hao exists already, override\n");
  237. return offset;
  238. }
  239. if (found_rhdr)
  240. return offset;
  241. break;
  242. default:
  243. return offset;
  244. }
  245. offset += ipv6_optlen(exthdr);
  246. *nexthdr = &exthdr->nexthdr;
  247. exthdr = (struct ipv6_opt_hdr *)(nh + offset);
  248. }
  249. return offset;
  250. }
  251. static int mip6_destopt_init_state(struct xfrm_state *x)
  252. {
  253. if (x->id.spi) {
  254. pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi);
  255. return -EINVAL;
  256. }
  257. if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) {
  258. pr_info("%s: state's mode is not %u: %u\n",
  259. __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode);
  260. return -EINVAL;
  261. }
  262. x->props.header_len = sizeof(struct ipv6_destopt_hdr) +
  263. calc_padlen(sizeof(struct ipv6_destopt_hdr), 6) +
  264. sizeof(struct ipv6_destopt_hao);
  265. WARN_ON(x->props.header_len != 24);
  266. return 0;
  267. }
  268. /*
  269. * Do nothing about destroying since it has no specific operation for
  270. * destination options header unlike IPsec protocols.
  271. */
  272. static void mip6_destopt_destroy(struct xfrm_state *x)
  273. {
  274. }
  275. static const struct xfrm_type mip6_destopt_type = {
  276. .description = "MIP6DESTOPT",
  277. .owner = THIS_MODULE,
  278. .proto = IPPROTO_DSTOPTS,
  279. .flags = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_LOCAL_COADDR,
  280. .init_state = mip6_destopt_init_state,
  281. .destructor = mip6_destopt_destroy,
  282. .input = mip6_destopt_input,
  283. .output = mip6_destopt_output,
  284. .reject = mip6_destopt_reject,
  285. .hdr_offset = mip6_destopt_offset,
  286. };
  287. static int mip6_rthdr_input(struct xfrm_state *x, struct sk_buff *skb)
  288. {
  289. const struct ipv6hdr *iph = ipv6_hdr(skb);
  290. struct rt2_hdr *rt2 = (struct rt2_hdr *)skb->data;
  291. int err = rt2->rt_hdr.nexthdr;
  292. spin_lock(&x->lock);
  293. if (!ipv6_addr_equal(&iph->daddr, (struct in6_addr *)x->coaddr) &&
  294. !ipv6_addr_any((struct in6_addr *)x->coaddr))
  295. err = -ENOENT;
  296. spin_unlock(&x->lock);
  297. return err;
  298. }
  299. /* Routing Header type 2 is inserted.
  300. * IP Header's dst address is replaced with Routing Header's Home Address.
  301. */
  302. static int mip6_rthdr_output(struct xfrm_state *x, struct sk_buff *skb)
  303. {
  304. struct ipv6hdr *iph;
  305. struct rt2_hdr *rt2;
  306. u8 nexthdr;
  307. skb_push(skb, -skb_network_offset(skb));
  308. iph = ipv6_hdr(skb);
  309. nexthdr = *skb_mac_header(skb);
  310. *skb_mac_header(skb) = IPPROTO_ROUTING;
  311. rt2 = (struct rt2_hdr *)skb_transport_header(skb);
  312. rt2->rt_hdr.nexthdr = nexthdr;
  313. rt2->rt_hdr.hdrlen = (x->props.header_len >> 3) - 1;
  314. rt2->rt_hdr.type = IPV6_SRCRT_TYPE_2;
  315. rt2->rt_hdr.segments_left = 1;
  316. memset(&rt2->reserved, 0, sizeof(rt2->reserved));
  317. WARN_ON(rt2->rt_hdr.hdrlen != 2);
  318. memcpy(&rt2->addr, &iph->daddr, sizeof(rt2->addr));
  319. spin_lock_bh(&x->lock);
  320. memcpy(&iph->daddr, x->coaddr, sizeof(iph->daddr));
  321. spin_unlock_bh(&x->lock);
  322. return 0;
  323. }
  324. static int mip6_rthdr_offset(struct xfrm_state *x, struct sk_buff *skb,
  325. u8 **nexthdr)
  326. {
  327. u16 offset = sizeof(struct ipv6hdr);
  328. struct ipv6_opt_hdr *exthdr =
  329. (struct ipv6_opt_hdr *)(ipv6_hdr(skb) + 1);
  330. const unsigned char *nh = skb_network_header(skb);
  331. unsigned int packet_len = skb_tail_pointer(skb) -
  332. skb_network_header(skb);
  333. int found_rhdr = 0;
  334. *nexthdr = &ipv6_hdr(skb)->nexthdr;
  335. while (offset + 1 <= packet_len) {
  336. switch (**nexthdr) {
  337. case NEXTHDR_HOP:
  338. break;
  339. case NEXTHDR_ROUTING:
  340. if (offset + 3 <= packet_len) {
  341. struct ipv6_rt_hdr *rt;
  342. rt = (struct ipv6_rt_hdr *)(nh + offset);
  343. if (rt->type != 0)
  344. return offset;
  345. }
  346. found_rhdr = 1;
  347. break;
  348. case NEXTHDR_DEST:
  349. if (ipv6_find_tlv(skb, offset, IPV6_TLV_HAO) >= 0)
  350. return offset;
  351. if (found_rhdr)
  352. return offset;
  353. break;
  354. default:
  355. return offset;
  356. }
  357. offset += ipv6_optlen(exthdr);
  358. *nexthdr = &exthdr->nexthdr;
  359. exthdr = (struct ipv6_opt_hdr *)(nh + offset);
  360. }
  361. return offset;
  362. }
  363. static int mip6_rthdr_init_state(struct xfrm_state *x)
  364. {
  365. if (x->id.spi) {
  366. pr_info("%s: spi is not 0: %u\n", __func__, x->id.spi);
  367. return -EINVAL;
  368. }
  369. if (x->props.mode != XFRM_MODE_ROUTEOPTIMIZATION) {
  370. pr_info("%s: state's mode is not %u: %u\n",
  371. __func__, XFRM_MODE_ROUTEOPTIMIZATION, x->props.mode);
  372. return -EINVAL;
  373. }
  374. x->props.header_len = sizeof(struct rt2_hdr);
  375. return 0;
  376. }
  377. /*
  378. * Do nothing about destroying since it has no specific operation for routing
  379. * header type 2 unlike IPsec protocols.
  380. */
  381. static void mip6_rthdr_destroy(struct xfrm_state *x)
  382. {
  383. }
  384. static const struct xfrm_type mip6_rthdr_type = {
  385. .description = "MIP6RT",
  386. .owner = THIS_MODULE,
  387. .proto = IPPROTO_ROUTING,
  388. .flags = XFRM_TYPE_NON_FRAGMENT | XFRM_TYPE_REMOTE_COADDR,
  389. .init_state = mip6_rthdr_init_state,
  390. .destructor = mip6_rthdr_destroy,
  391. .input = mip6_rthdr_input,
  392. .output = mip6_rthdr_output,
  393. .hdr_offset = mip6_rthdr_offset,
  394. };
  395. static int __init mip6_init(void)
  396. {
  397. pr_info("Mobile IPv6\n");
  398. if (xfrm_register_type(&mip6_destopt_type, AF_INET6) < 0) {
  399. pr_info("%s: can't add xfrm type(destopt)\n", __func__);
  400. goto mip6_destopt_xfrm_fail;
  401. }
  402. if (xfrm_register_type(&mip6_rthdr_type, AF_INET6) < 0) {
  403. pr_info("%s: can't add xfrm type(rthdr)\n", __func__);
  404. goto mip6_rthdr_xfrm_fail;
  405. }
  406. if (rawv6_mh_filter_register(mip6_mh_filter) < 0) {
  407. pr_info("%s: can't add rawv6 mh filter\n", __func__);
  408. goto mip6_rawv6_mh_fail;
  409. }
  410. return 0;
  411. mip6_rawv6_mh_fail:
  412. xfrm_unregister_type(&mip6_rthdr_type, AF_INET6);
  413. mip6_rthdr_xfrm_fail:
  414. xfrm_unregister_type(&mip6_destopt_type, AF_INET6);
  415. mip6_destopt_xfrm_fail:
  416. return -EAGAIN;
  417. }
  418. static void __exit mip6_fini(void)
  419. {
  420. if (rawv6_mh_filter_unregister(mip6_mh_filter) < 0)
  421. pr_info("%s: can't remove rawv6 mh filter\n", __func__);
  422. xfrm_unregister_type(&mip6_rthdr_type, AF_INET6);
  423. xfrm_unregister_type(&mip6_destopt_type, AF_INET6);
  424. }
  425. module_init(mip6_init);
  426. module_exit(mip6_fini);
  427. MODULE_LICENSE("GPL");
  428. MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_DSTOPTS);
  429. MODULE_ALIAS_XFRM_TYPE(AF_INET6, XFRM_PROTO_ROUTING);