sit.c 40 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763
  1. /*
  2. * IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
  3. * Linux INET6 implementation
  4. *
  5. * Authors:
  6. * Pedro Roque <roque@di.fc.ul.pt>
  7. * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  8. *
  9. * This program is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU General Public License
  11. * as published by the Free Software Foundation; either version
  12. * 2 of the License, or (at your option) any later version.
  13. *
  14. * Changes:
  15. * Roger Venning <r.venning@telstra.com>: 6to4 support
  16. * Nate Thompson <nate@thebog.net>: 6to4 support
  17. * Fred Templin <fred.l.templin@boeing.com>: isatap support
  18. */
  19. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  20. #include <linux/module.h>
  21. #include <linux/capability.h>
  22. #include <linux/errno.h>
  23. #include <linux/types.h>
  24. #include <linux/socket.h>
  25. #include <linux/sockios.h>
  26. #include <linux/net.h>
  27. #include <linux/in6.h>
  28. #include <linux/netdevice.h>
  29. #include <linux/if_arp.h>
  30. #include <linux/icmp.h>
  31. #include <linux/slab.h>
  32. #include <asm/uaccess.h>
  33. #include <linux/init.h>
  34. #include <linux/netfilter_ipv4.h>
  35. #include <linux/if_ether.h>
  36. #include <net/sock.h>
  37. #include <net/snmp.h>
  38. #include <net/ipv6.h>
  39. #include <net/protocol.h>
  40. #include <net/transp_v6.h>
  41. #include <net/ip6_fib.h>
  42. #include <net/ip6_route.h>
  43. #include <net/ndisc.h>
  44. #include <net/addrconf.h>
  45. #include <net/ip.h>
  46. #include <net/udp.h>
  47. #include <net/icmp.h>
  48. #include <net/ip_tunnels.h>
  49. #include <net/inet_ecn.h>
  50. #include <net/xfrm.h>
  51. #include <net/dsfield.h>
  52. #include <net/net_namespace.h>
  53. #include <net/netns/generic.h>
  54. /*
  55. This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c
  56. For comments look at net/ipv4/ip_gre.c --ANK
  57. */
  58. #define HASH_SIZE 16
  59. #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
  60. static bool log_ecn_error = true;
  61. module_param(log_ecn_error, bool, 0644);
  62. MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  63. static int ipip6_tunnel_init(struct net_device *dev);
  64. static void ipip6_tunnel_setup(struct net_device *dev);
  65. static void ipip6_dev_free(struct net_device *dev);
  66. static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
  67. __be32 *v4dst);
  68. static struct rtnl_link_ops sit_link_ops __read_mostly;
  69. static int sit_net_id __read_mostly;
  70. struct sit_net {
  71. struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
  72. struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
  73. struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
  74. struct ip_tunnel __rcu *tunnels_wc[1];
  75. struct ip_tunnel __rcu **tunnels[4];
  76. struct net_device *fb_tunnel_dev;
  77. };
  78. /*
  79. * Must be invoked with rcu_read_lock
  80. */
  81. static struct ip_tunnel *ipip6_tunnel_lookup(struct net *net,
  82. struct net_device *dev, __be32 remote, __be32 local)
  83. {
  84. unsigned int h0 = HASH(remote);
  85. unsigned int h1 = HASH(local);
  86. struct ip_tunnel *t;
  87. struct sit_net *sitn = net_generic(net, sit_net_id);
  88. for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) {
  89. if (local == t->parms.iph.saddr &&
  90. remote == t->parms.iph.daddr &&
  91. (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
  92. (t->dev->flags & IFF_UP))
  93. return t;
  94. }
  95. for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) {
  96. if (remote == t->parms.iph.daddr &&
  97. (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
  98. (t->dev->flags & IFF_UP))
  99. return t;
  100. }
  101. for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) {
  102. if (local == t->parms.iph.saddr &&
  103. (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
  104. (t->dev->flags & IFF_UP))
  105. return t;
  106. }
  107. t = rcu_dereference(sitn->tunnels_wc[0]);
  108. if ((t != NULL) && (t->dev->flags & IFF_UP))
  109. return t;
  110. return NULL;
  111. }
  112. static struct ip_tunnel __rcu **__ipip6_bucket(struct sit_net *sitn,
  113. struct ip_tunnel_parm *parms)
  114. {
  115. __be32 remote = parms->iph.daddr;
  116. __be32 local = parms->iph.saddr;
  117. unsigned int h = 0;
  118. int prio = 0;
  119. if (remote) {
  120. prio |= 2;
  121. h ^= HASH(remote);
  122. }
  123. if (local) {
  124. prio |= 1;
  125. h ^= HASH(local);
  126. }
  127. return &sitn->tunnels[prio][h];
  128. }
  129. static inline struct ip_tunnel __rcu **ipip6_bucket(struct sit_net *sitn,
  130. struct ip_tunnel *t)
  131. {
  132. return __ipip6_bucket(sitn, &t->parms);
  133. }
  134. static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t)
  135. {
  136. struct ip_tunnel __rcu **tp;
  137. struct ip_tunnel *iter;
  138. for (tp = ipip6_bucket(sitn, t);
  139. (iter = rtnl_dereference(*tp)) != NULL;
  140. tp = &iter->next) {
  141. if (t == iter) {
  142. rcu_assign_pointer(*tp, t->next);
  143. break;
  144. }
  145. }
  146. }
  147. static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t)
  148. {
  149. struct ip_tunnel __rcu **tp = ipip6_bucket(sitn, t);
  150. rcu_assign_pointer(t->next, rtnl_dereference(*tp));
  151. rcu_assign_pointer(*tp, t);
  152. }
  153. static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn)
  154. {
  155. #ifdef CONFIG_IPV6_SIT_6RD
  156. struct ip_tunnel *t = netdev_priv(dev);
  157. if (t->dev == sitn->fb_tunnel_dev) {
  158. ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0);
  159. t->ip6rd.relay_prefix = 0;
  160. t->ip6rd.prefixlen = 16;
  161. t->ip6rd.relay_prefixlen = 0;
  162. } else {
  163. struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev);
  164. memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd));
  165. }
  166. #endif
  167. }
  168. static int ipip6_tunnel_create(struct net_device *dev)
  169. {
  170. struct ip_tunnel *t = netdev_priv(dev);
  171. struct net *net = dev_net(dev);
  172. struct sit_net *sitn = net_generic(net, sit_net_id);
  173. int err;
  174. err = ipip6_tunnel_init(dev);
  175. if (err < 0)
  176. goto out;
  177. ipip6_tunnel_clone_6rd(dev, sitn);
  178. if ((__force u16)t->parms.i_flags & SIT_ISATAP)
  179. dev->priv_flags |= IFF_ISATAP;
  180. err = register_netdevice(dev);
  181. if (err < 0)
  182. goto out;
  183. strcpy(t->parms.name, dev->name);
  184. dev->rtnl_link_ops = &sit_link_ops;
  185. dev_hold(dev);
  186. ipip6_tunnel_link(sitn, t);
  187. return 0;
  188. out:
  189. return err;
  190. }
  191. static struct ip_tunnel *ipip6_tunnel_locate(struct net *net,
  192. struct ip_tunnel_parm *parms, int create)
  193. {
  194. __be32 remote = parms->iph.daddr;
  195. __be32 local = parms->iph.saddr;
  196. struct ip_tunnel *t, *nt;
  197. struct ip_tunnel __rcu **tp;
  198. struct net_device *dev;
  199. char name[IFNAMSIZ];
  200. struct sit_net *sitn = net_generic(net, sit_net_id);
  201. for (tp = __ipip6_bucket(sitn, parms);
  202. (t = rtnl_dereference(*tp)) != NULL;
  203. tp = &t->next) {
  204. if (local == t->parms.iph.saddr &&
  205. remote == t->parms.iph.daddr &&
  206. parms->link == t->parms.link) {
  207. if (create)
  208. return NULL;
  209. else
  210. return t;
  211. }
  212. }
  213. if (!create)
  214. goto failed;
  215. if (parms->name[0])
  216. strlcpy(name, parms->name, IFNAMSIZ);
  217. else
  218. strcpy(name, "sit%d");
  219. dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
  220. if (dev == NULL)
  221. return NULL;
  222. dev_net_set(dev, net);
  223. nt = netdev_priv(dev);
  224. nt->parms = *parms;
  225. if (ipip6_tunnel_create(dev) < 0)
  226. goto failed_free;
  227. return nt;
  228. failed_free:
  229. ipip6_dev_free(dev);
  230. failed:
  231. return NULL;
  232. }
  233. #define for_each_prl_rcu(start) \
  234. for (prl = rcu_dereference(start); \
  235. prl; \
  236. prl = rcu_dereference(prl->next))
  237. static struct ip_tunnel_prl_entry *
  238. __ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
  239. {
  240. struct ip_tunnel_prl_entry *prl;
  241. for_each_prl_rcu(t->prl)
  242. if (prl->addr == addr)
  243. break;
  244. return prl;
  245. }
  246. static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
  247. struct ip_tunnel_prl __user *a)
  248. {
  249. struct ip_tunnel_prl kprl, *kp;
  250. struct ip_tunnel_prl_entry *prl;
  251. unsigned int cmax, c = 0, ca, len;
  252. int ret = 0;
  253. if (copy_from_user(&kprl, a, sizeof(kprl)))
  254. return -EFAULT;
  255. cmax = kprl.datalen / sizeof(kprl);
  256. if (cmax > 1 && kprl.addr != htonl(INADDR_ANY))
  257. cmax = 1;
  258. /* For simple GET or for root users,
  259. * we try harder to allocate.
  260. */
  261. kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
  262. kcalloc(cmax, sizeof(*kp), GFP_KERNEL) :
  263. NULL;
  264. rcu_read_lock();
  265. ca = t->prl_count < cmax ? t->prl_count : cmax;
  266. if (!kp) {
  267. /* We don't try hard to allocate much memory for
  268. * non-root users.
  269. * For root users, retry allocating enough memory for
  270. * the answer.
  271. */
  272. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC);
  273. if (!kp) {
  274. ret = -ENOMEM;
  275. goto out;
  276. }
  277. }
  278. c = 0;
  279. for_each_prl_rcu(t->prl) {
  280. if (c >= cmax)
  281. break;
  282. if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
  283. continue;
  284. kp[c].addr = prl->addr;
  285. kp[c].flags = prl->flags;
  286. c++;
  287. if (kprl.addr != htonl(INADDR_ANY))
  288. break;
  289. }
  290. out:
  291. rcu_read_unlock();
  292. len = sizeof(*kp) * c;
  293. ret = 0;
  294. if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
  295. ret = -EFAULT;
  296. kfree(kp);
  297. return ret;
  298. }
  299. static int
  300. ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
  301. {
  302. struct ip_tunnel_prl_entry *p;
  303. int err = 0;
  304. if (a->addr == htonl(INADDR_ANY))
  305. return -EINVAL;
  306. ASSERT_RTNL();
  307. for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) {
  308. if (p->addr == a->addr) {
  309. if (chg) {
  310. p->flags = a->flags;
  311. goto out;
  312. }
  313. err = -EEXIST;
  314. goto out;
  315. }
  316. }
  317. if (chg) {
  318. err = -ENXIO;
  319. goto out;
  320. }
  321. p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
  322. if (!p) {
  323. err = -ENOBUFS;
  324. goto out;
  325. }
  326. p->next = t->prl;
  327. p->addr = a->addr;
  328. p->flags = a->flags;
  329. t->prl_count++;
  330. rcu_assign_pointer(t->prl, p);
  331. out:
  332. return err;
  333. }
  334. static void prl_list_destroy_rcu(struct rcu_head *head)
  335. {
  336. struct ip_tunnel_prl_entry *p, *n;
  337. p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
  338. do {
  339. n = rcu_dereference_protected(p->next, 1);
  340. kfree(p);
  341. p = n;
  342. } while (p);
  343. }
  344. static int
  345. ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
  346. {
  347. struct ip_tunnel_prl_entry *x;
  348. struct ip_tunnel_prl_entry __rcu **p;
  349. int err = 0;
  350. ASSERT_RTNL();
  351. if (a && a->addr != htonl(INADDR_ANY)) {
  352. for (p = &t->prl;
  353. (x = rtnl_dereference(*p)) != NULL;
  354. p = &x->next) {
  355. if (x->addr == a->addr) {
  356. *p = x->next;
  357. kfree_rcu(x, rcu_head);
  358. t->prl_count--;
  359. goto out;
  360. }
  361. }
  362. err = -ENXIO;
  363. } else {
  364. x = rtnl_dereference(t->prl);
  365. if (x) {
  366. t->prl_count = 0;
  367. call_rcu(&x->rcu_head, prl_list_destroy_rcu);
  368. t->prl = NULL;
  369. }
  370. }
  371. out:
  372. return err;
  373. }
  374. static int
  375. isatap_chksrc(struct sk_buff *skb, const struct iphdr *iph, struct ip_tunnel *t)
  376. {
  377. struct ip_tunnel_prl_entry *p;
  378. int ok = 1;
  379. rcu_read_lock();
  380. p = __ipip6_tunnel_locate_prl(t, iph->saddr);
  381. if (p) {
  382. if (p->flags & PRL_DEFAULT)
  383. skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
  384. else
  385. skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
  386. } else {
  387. const struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;
  388. if (ipv6_addr_is_isatap(addr6) &&
  389. (addr6->s6_addr32[3] == iph->saddr) &&
  390. ipv6_chk_prefix(addr6, t->dev))
  391. skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
  392. else
  393. ok = 0;
  394. }
  395. rcu_read_unlock();
  396. return ok;
  397. }
  398. static void ipip6_tunnel_uninit(struct net_device *dev)
  399. {
  400. struct ip_tunnel *tunnel = netdev_priv(dev);
  401. struct sit_net *sitn = net_generic(tunnel->net, sit_net_id);
  402. if (dev == sitn->fb_tunnel_dev) {
  403. RCU_INIT_POINTER(sitn->tunnels_wc[0], NULL);
  404. } else {
  405. ipip6_tunnel_unlink(sitn, tunnel);
  406. ipip6_tunnel_del_prl(tunnel, NULL);
  407. }
  408. dev_put(dev);
  409. }
  410. static int ipip6_err(struct sk_buff *skb, u32 info)
  411. {
  412. /* All the routers (except for Linux) return only
  413. 8 bytes of packet payload. It means, that precise relaying of
  414. ICMP in the real Internet is absolutely infeasible.
  415. */
  416. const struct iphdr *iph = (const struct iphdr *)skb->data;
  417. const int type = icmp_hdr(skb)->type;
  418. const int code = icmp_hdr(skb)->code;
  419. struct ip_tunnel *t;
  420. int err;
  421. switch (type) {
  422. default:
  423. case ICMP_PARAMETERPROB:
  424. return 0;
  425. case ICMP_DEST_UNREACH:
  426. switch (code) {
  427. case ICMP_SR_FAILED:
  428. case ICMP_PORT_UNREACH:
  429. /* Impossible event. */
  430. return 0;
  431. default:
  432. /* All others are translated to HOST_UNREACH.
  433. rfc2003 contains "deep thoughts" about NET_UNREACH,
  434. I believe they are just ether pollution. --ANK
  435. */
  436. break;
  437. }
  438. break;
  439. case ICMP_TIME_EXCEEDED:
  440. if (code != ICMP_EXC_TTL)
  441. return 0;
  442. break;
  443. case ICMP_REDIRECT:
  444. break;
  445. }
  446. err = -ENOENT;
  447. t = ipip6_tunnel_lookup(dev_net(skb->dev),
  448. skb->dev,
  449. iph->daddr,
  450. iph->saddr);
  451. if (t == NULL)
  452. goto out;
  453. if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
  454. ipv4_update_pmtu(skb, dev_net(skb->dev), info,
  455. t->dev->ifindex, 0, IPPROTO_IPV6, 0);
  456. err = 0;
  457. goto out;
  458. }
  459. if (type == ICMP_REDIRECT) {
  460. ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
  461. IPPROTO_IPV6, 0);
  462. err = 0;
  463. goto out;
  464. }
  465. if (t->parms.iph.daddr == 0)
  466. goto out;
  467. err = 0;
  468. if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
  469. goto out;
  470. if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
  471. t->err_count++;
  472. else
  473. t->err_count = 1;
  474. t->err_time = jiffies;
  475. out:
  476. return err;
  477. }
  478. static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
  479. const struct in6_addr *v6addr)
  480. {
  481. __be32 v4embed = 0;
  482. if (check_6rd(tunnel, v6addr, &v4embed) && v4addr != v4embed)
  483. return true;
  484. return false;
  485. }
  486. /* Checks if an address matches an address on the tunnel interface.
  487. * Used to detect the NAT of proto 41 packets and let them pass spoofing test.
  488. * Long story:
  489. * This function is called after we considered the packet as spoofed
  490. * in is_spoofed_6rd.
  491. * We may have a router that is doing NAT for proto 41 packets
  492. * for an internal station. Destination a.a.a.a/PREFIX:bbbb:bbbb
  493. * will be translated to n.n.n.n/PREFIX:bbbb:bbbb. And is_spoofed_6rd
  494. * function will return true, dropping the packet.
  495. * But, we can still check if is spoofed against the IP
  496. * addresses associated with the interface.
  497. */
  498. static bool only_dnatted(const struct ip_tunnel *tunnel,
  499. const struct in6_addr *v6dst)
  500. {
  501. int prefix_len;
  502. #ifdef CONFIG_IPV6_SIT_6RD
  503. prefix_len = tunnel->ip6rd.prefixlen + 32
  504. - tunnel->ip6rd.relay_prefixlen;
  505. #else
  506. prefix_len = 48;
  507. #endif
  508. return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
  509. }
  510. /* Returns true if a packet is spoofed */
  511. static bool packet_is_spoofed(struct sk_buff *skb,
  512. const struct iphdr *iph,
  513. struct ip_tunnel *tunnel)
  514. {
  515. const struct ipv6hdr *ipv6h;
  516. if (tunnel->dev->priv_flags & IFF_ISATAP) {
  517. if (!isatap_chksrc(skb, iph, tunnel))
  518. return true;
  519. return false;
  520. }
  521. if (tunnel->dev->flags & IFF_POINTOPOINT)
  522. return false;
  523. ipv6h = ipv6_hdr(skb);
  524. if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
  525. net_warn_ratelimited("Src spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
  526. &iph->saddr, &ipv6h->saddr,
  527. &iph->daddr, &ipv6h->daddr);
  528. return true;
  529. }
  530. if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
  531. return false;
  532. if (only_dnatted(tunnel, &ipv6h->daddr))
  533. return false;
  534. net_warn_ratelimited("Dst spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
  535. &iph->saddr, &ipv6h->saddr,
  536. &iph->daddr, &ipv6h->daddr);
  537. return true;
  538. }
  539. static int ipip6_rcv(struct sk_buff *skb)
  540. {
  541. const struct iphdr *iph = ip_hdr(skb);
  542. struct ip_tunnel *tunnel;
  543. int err;
  544. tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
  545. iph->saddr, iph->daddr);
  546. if (tunnel != NULL) {
  547. struct pcpu_tstats *tstats;
  548. if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
  549. tunnel->parms.iph.protocol != 0)
  550. goto out;
  551. skb->mac_header = skb->network_header;
  552. skb_reset_network_header(skb);
  553. IPCB(skb)->flags = 0;
  554. skb->protocol = htons(ETH_P_IPV6);
  555. if (packet_is_spoofed(skb, iph, tunnel)) {
  556. tunnel->dev->stats.rx_errors++;
  557. goto out;
  558. }
  559. __skb_tunnel_rx(skb, tunnel->dev, tunnel->net);
  560. err = IP_ECN_decapsulate(iph, skb);
  561. if (unlikely(err)) {
  562. if (log_ecn_error)
  563. net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
  564. &iph->saddr, iph->tos);
  565. if (err > 1) {
  566. ++tunnel->dev->stats.rx_frame_errors;
  567. ++tunnel->dev->stats.rx_errors;
  568. goto out;
  569. }
  570. }
  571. tstats = this_cpu_ptr(tunnel->dev->tstats);
  572. tstats->rx_packets++;
  573. tstats->rx_bytes += skb->len;
  574. netif_rx(skb);
  575. return 0;
  576. }
  577. /* no tunnel matched, let upstream know, ipsec may handle it */
  578. return 1;
  579. out:
  580. kfree_skb(skb);
  581. return 0;
  582. }
  583. static const struct tnl_ptk_info tpi = {
  584. /* no tunnel info required for ipip. */
  585. .proto = htons(ETH_P_IP),
  586. };
  587. static int ipip_rcv(struct sk_buff *skb)
  588. {
  589. const struct iphdr *iph;
  590. struct ip_tunnel *tunnel;
  591. iph = ip_hdr(skb);
  592. tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
  593. iph->saddr, iph->daddr);
  594. if (tunnel != NULL) {
  595. if (tunnel->parms.iph.protocol != IPPROTO_IPIP &&
  596. tunnel->parms.iph.protocol != 0)
  597. goto drop;
  598. if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
  599. goto drop;
  600. if (iptunnel_pull_header(skb, 0, tpi.proto))
  601. goto drop;
  602. return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
  603. }
  604. return 1;
  605. drop:
  606. kfree_skb(skb);
  607. return 0;
  608. }
  609. /*
  610. * If the IPv6 address comes from 6rd / 6to4 (RFC 3056) addr space this function
  611. * stores the embedded IPv4 address in v4dst and returns true.
  612. */
  613. static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
  614. __be32 *v4dst)
  615. {
  616. #ifdef CONFIG_IPV6_SIT_6RD
  617. if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
  618. tunnel->ip6rd.prefixlen)) {
  619. unsigned int pbw0, pbi0;
  620. int pbi1;
  621. u32 d;
  622. pbw0 = tunnel->ip6rd.prefixlen >> 5;
  623. pbi0 = tunnel->ip6rd.prefixlen & 0x1f;
  624. d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
  625. tunnel->ip6rd.relay_prefixlen;
  626. pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
  627. if (pbi1 > 0)
  628. d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
  629. (32 - pbi1);
  630. *v4dst = tunnel->ip6rd.relay_prefix | htonl(d);
  631. return true;
  632. }
  633. #else
  634. if (v6dst->s6_addr16[0] == htons(0x2002)) {
  635. /* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
  636. memcpy(v4dst, &v6dst->s6_addr16[1], 4);
  637. return true;
  638. }
  639. #endif
  640. return false;
  641. }
  642. static inline __be32 try_6rd(struct ip_tunnel *tunnel,
  643. const struct in6_addr *v6dst)
  644. {
  645. __be32 dst = 0;
  646. check_6rd(tunnel, v6dst, &dst);
  647. return dst;
  648. }
  649. /*
  650. * This function assumes it is being called from dev_queue_xmit()
  651. * and that skb is filled properly by that function.
  652. */
  653. static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
  654. struct net_device *dev)
  655. {
  656. struct ip_tunnel *tunnel = netdev_priv(dev);
  657. const struct iphdr *tiph = &tunnel->parms.iph;
  658. const struct ipv6hdr *iph6 = ipv6_hdr(skb);
  659. u8 tos = tunnel->parms.iph.tos;
  660. __be16 df = tiph->frag_off;
  661. struct rtable *rt; /* Route to the other host */
  662. struct net_device *tdev; /* Device to other host */
  663. unsigned int max_headroom; /* The extra header space needed */
  664. __be32 dst = tiph->daddr;
  665. struct flowi4 fl4;
  666. int mtu;
  667. const struct in6_addr *addr6;
  668. int addr_type;
  669. u8 ttl;
  670. int err;
  671. if (skb->protocol != htons(ETH_P_IPV6))
  672. goto tx_error;
  673. if (tos == 1)
  674. tos = ipv6_get_dsfield(iph6);
  675. /* ISATAP (RFC4214) - must come before 6to4 */
  676. if (dev->priv_flags & IFF_ISATAP) {
  677. struct neighbour *neigh = NULL;
  678. bool do_tx_error = false;
  679. if (skb_dst(skb))
  680. neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
  681. if (neigh == NULL) {
  682. net_dbg_ratelimited("nexthop == NULL\n");
  683. goto tx_error;
  684. }
  685. addr6 = (const struct in6_addr *)&neigh->primary_key;
  686. addr_type = ipv6_addr_type(addr6);
  687. if ((addr_type & IPV6_ADDR_UNICAST) &&
  688. ipv6_addr_is_isatap(addr6))
  689. dst = addr6->s6_addr32[3];
  690. else
  691. do_tx_error = true;
  692. neigh_release(neigh);
  693. if (do_tx_error)
  694. goto tx_error;
  695. }
  696. if (!dst)
  697. dst = try_6rd(tunnel, &iph6->daddr);
  698. if (!dst) {
  699. struct neighbour *neigh = NULL;
  700. bool do_tx_error = false;
  701. if (skb_dst(skb))
  702. neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
  703. if (neigh == NULL) {
  704. net_dbg_ratelimited("nexthop == NULL\n");
  705. goto tx_error;
  706. }
  707. addr6 = (const struct in6_addr *)&neigh->primary_key;
  708. addr_type = ipv6_addr_type(addr6);
  709. if (addr_type == IPV6_ADDR_ANY) {
  710. addr6 = &ipv6_hdr(skb)->daddr;
  711. addr_type = ipv6_addr_type(addr6);
  712. }
  713. if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
  714. dst = addr6->s6_addr32[3];
  715. else
  716. do_tx_error = true;
  717. neigh_release(neigh);
  718. if (do_tx_error)
  719. goto tx_error;
  720. }
  721. rt = ip_route_output_ports(tunnel->net, &fl4, NULL,
  722. dst, tiph->saddr,
  723. 0, 0,
  724. IPPROTO_IPV6, RT_TOS(tos),
  725. tunnel->parms.link);
  726. if (IS_ERR(rt)) {
  727. dev->stats.tx_carrier_errors++;
  728. goto tx_error_icmp;
  729. }
  730. if (rt->rt_type != RTN_UNICAST) {
  731. ip_rt_put(rt);
  732. dev->stats.tx_carrier_errors++;
  733. goto tx_error_icmp;
  734. }
  735. tdev = rt->dst.dev;
  736. if (tdev == dev) {
  737. ip_rt_put(rt);
  738. dev->stats.collisions++;
  739. goto tx_error;
  740. }
  741. if (df) {
  742. mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
  743. if (mtu < 68) {
  744. dev->stats.collisions++;
  745. ip_rt_put(rt);
  746. goto tx_error;
  747. }
  748. if (mtu < IPV6_MIN_MTU) {
  749. mtu = IPV6_MIN_MTU;
  750. df = 0;
  751. }
  752. if (tunnel->parms.iph.daddr && skb_dst(skb))
  753. skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
  754. if (skb->len > mtu) {
  755. icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
  756. ip_rt_put(rt);
  757. goto tx_error;
  758. }
  759. }
  760. if (tunnel->err_count > 0) {
  761. if (time_before(jiffies,
  762. tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
  763. tunnel->err_count--;
  764. dst_link_failure(skb);
  765. } else
  766. tunnel->err_count = 0;
  767. }
  768. /*
  769. * Okay, now see if we can stuff it in the buffer as-is.
  770. */
  771. max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);
  772. if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
  773. (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
  774. struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
  775. if (!new_skb) {
  776. ip_rt_put(rt);
  777. dev->stats.tx_dropped++;
  778. dev_kfree_skb(skb);
  779. return NETDEV_TX_OK;
  780. }
  781. if (skb->sk)
  782. skb_set_owner_w(new_skb, skb->sk);
  783. dev_kfree_skb(skb);
  784. skb = new_skb;
  785. iph6 = ipv6_hdr(skb);
  786. }
  787. ttl = tiph->ttl;
  788. if (ttl == 0)
  789. ttl = iph6->hop_limit;
  790. tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
  791. if (likely(!skb->encapsulation)) {
  792. skb_reset_inner_headers(skb);
  793. skb->encapsulation = 1;
  794. }
  795. err = iptunnel_xmit(rt, skb, fl4.saddr, fl4.daddr, IPPROTO_IPV6, tos,
  796. ttl, df, !net_eq(tunnel->net, dev_net(dev)));
  797. iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
  798. return NETDEV_TX_OK;
  799. tx_error_icmp:
  800. dst_link_failure(skb);
  801. tx_error:
  802. dev->stats.tx_errors++;
  803. dev_kfree_skb(skb);
  804. return NETDEV_TX_OK;
  805. }
  806. static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
  807. {
  808. struct ip_tunnel *tunnel = netdev_priv(dev);
  809. const struct iphdr *tiph = &tunnel->parms.iph;
  810. if (likely(!skb->encapsulation)) {
  811. skb_reset_inner_headers(skb);
  812. skb->encapsulation = 1;
  813. }
  814. ip_tunnel_xmit(skb, dev, tiph, IPPROTO_IPIP);
  815. return NETDEV_TX_OK;
  816. }
  817. static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
  818. struct net_device *dev)
  819. {
  820. switch (skb->protocol) {
  821. case htons(ETH_P_IP):
  822. ipip_tunnel_xmit(skb, dev);
  823. break;
  824. case htons(ETH_P_IPV6):
  825. ipip6_tunnel_xmit(skb, dev);
  826. break;
  827. default:
  828. goto tx_err;
  829. }
  830. return NETDEV_TX_OK;
  831. tx_err:
  832. dev->stats.tx_errors++;
  833. dev_kfree_skb(skb);
  834. return NETDEV_TX_OK;
  835. }
  836. static void ipip6_tunnel_bind_dev(struct net_device *dev)
  837. {
  838. struct net_device *tdev = NULL;
  839. struct ip_tunnel *tunnel;
  840. const struct iphdr *iph;
  841. struct flowi4 fl4;
  842. tunnel = netdev_priv(dev);
  843. iph = &tunnel->parms.iph;
  844. if (iph->daddr) {
  845. struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
  846. NULL,
  847. iph->daddr, iph->saddr,
  848. 0, 0,
  849. IPPROTO_IPV6,
  850. RT_TOS(iph->tos),
  851. tunnel->parms.link);
  852. if (!IS_ERR(rt)) {
  853. tdev = rt->dst.dev;
  854. ip_rt_put(rt);
  855. }
  856. dev->flags |= IFF_POINTOPOINT;
  857. }
  858. if (!tdev && tunnel->parms.link)
  859. tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
  860. if (tdev) {
  861. dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
  862. dev->mtu = tdev->mtu - sizeof(struct iphdr);
  863. if (dev->mtu < IPV6_MIN_MTU)
  864. dev->mtu = IPV6_MIN_MTU;
  865. }
  866. dev->iflink = tunnel->parms.link;
  867. }
  868. static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
  869. {
  870. struct net *net = t->net;
  871. struct sit_net *sitn = net_generic(net, sit_net_id);
  872. ipip6_tunnel_unlink(sitn, t);
  873. synchronize_net();
  874. t->parms.iph.saddr = p->iph.saddr;
  875. t->parms.iph.daddr = p->iph.daddr;
  876. memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
  877. memcpy(t->dev->broadcast, &p->iph.daddr, 4);
  878. ipip6_tunnel_link(sitn, t);
  879. t->parms.iph.ttl = p->iph.ttl;
  880. t->parms.iph.tos = p->iph.tos;
  881. if (t->parms.link != p->link) {
  882. t->parms.link = p->link;
  883. ipip6_tunnel_bind_dev(t->dev);
  884. }
  885. netdev_state_change(t->dev);
  886. }
  887. #ifdef CONFIG_IPV6_SIT_6RD
  888. static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
  889. struct ip_tunnel_6rd *ip6rd)
  890. {
  891. struct in6_addr prefix;
  892. __be32 relay_prefix;
  893. if (ip6rd->relay_prefixlen > 32 ||
  894. ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
  895. return -EINVAL;
  896. ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
  897. if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
  898. return -EINVAL;
  899. if (ip6rd->relay_prefixlen)
  900. relay_prefix = ip6rd->relay_prefix &
  901. htonl(0xffffffffUL <<
  902. (32 - ip6rd->relay_prefixlen));
  903. else
  904. relay_prefix = 0;
  905. if (relay_prefix != ip6rd->relay_prefix)
  906. return -EINVAL;
  907. t->ip6rd.prefix = prefix;
  908. t->ip6rd.relay_prefix = relay_prefix;
  909. t->ip6rd.prefixlen = ip6rd->prefixlen;
  910. t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
  911. netdev_state_change(t->dev);
  912. return 0;
  913. }
  914. #endif
  915. static int
  916. ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
  917. {
  918. int err = 0;
  919. struct ip_tunnel_parm p;
  920. struct ip_tunnel_prl prl;
  921. struct ip_tunnel *t;
  922. struct net *net = dev_net(dev);
  923. struct sit_net *sitn = net_generic(net, sit_net_id);
  924. #ifdef CONFIG_IPV6_SIT_6RD
  925. struct ip_tunnel_6rd ip6rd;
  926. #endif
  927. switch (cmd) {
  928. case SIOCGETTUNNEL:
  929. #ifdef CONFIG_IPV6_SIT_6RD
  930. case SIOCGET6RD:
  931. #endif
  932. t = NULL;
  933. if (dev == sitn->fb_tunnel_dev) {
  934. if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
  935. err = -EFAULT;
  936. break;
  937. }
  938. t = ipip6_tunnel_locate(net, &p, 0);
  939. }
  940. if (t == NULL)
  941. t = netdev_priv(dev);
  942. err = -EFAULT;
  943. if (cmd == SIOCGETTUNNEL) {
  944. memcpy(&p, &t->parms, sizeof(p));
  945. if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
  946. sizeof(p)))
  947. goto done;
  948. #ifdef CONFIG_IPV6_SIT_6RD
  949. } else {
  950. ip6rd.prefix = t->ip6rd.prefix;
  951. ip6rd.relay_prefix = t->ip6rd.relay_prefix;
  952. ip6rd.prefixlen = t->ip6rd.prefixlen;
  953. ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
  954. if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
  955. sizeof(ip6rd)))
  956. goto done;
  957. #endif
  958. }
  959. err = 0;
  960. break;
  961. case SIOCADDTUNNEL:
  962. case SIOCCHGTUNNEL:
  963. err = -EPERM;
  964. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  965. goto done;
  966. err = -EFAULT;
  967. if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
  968. goto done;
  969. err = -EINVAL;
  970. if (p.iph.protocol != IPPROTO_IPV6 &&
  971. p.iph.protocol != IPPROTO_IPIP &&
  972. p.iph.protocol != 0)
  973. goto done;
  974. if (p.iph.version != 4 ||
  975. p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
  976. goto done;
  977. if (p.iph.ttl)
  978. p.iph.frag_off |= htons(IP_DF);
  979. t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
  980. if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
  981. if (t != NULL) {
  982. if (t->dev != dev) {
  983. err = -EEXIST;
  984. break;
  985. }
  986. } else {
  987. if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
  988. (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
  989. err = -EINVAL;
  990. break;
  991. }
  992. t = netdev_priv(dev);
  993. }
  994. ipip6_tunnel_update(t, &p);
  995. }
  996. if (t) {
  997. err = 0;
  998. if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
  999. err = -EFAULT;
  1000. } else
  1001. err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
  1002. break;
  1003. case SIOCDELTUNNEL:
  1004. err = -EPERM;
  1005. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  1006. goto done;
  1007. if (dev == sitn->fb_tunnel_dev) {
  1008. err = -EFAULT;
  1009. if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
  1010. goto done;
  1011. err = -ENOENT;
  1012. if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL)
  1013. goto done;
  1014. err = -EPERM;
  1015. if (t == netdev_priv(sitn->fb_tunnel_dev))
  1016. goto done;
  1017. dev = t->dev;
  1018. }
  1019. unregister_netdevice(dev);
  1020. err = 0;
  1021. break;
  1022. case SIOCGETPRL:
  1023. err = -EINVAL;
  1024. if (dev == sitn->fb_tunnel_dev)
  1025. goto done;
  1026. err = -ENOENT;
  1027. if (!(t = netdev_priv(dev)))
  1028. goto done;
  1029. err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
  1030. break;
  1031. case SIOCADDPRL:
  1032. case SIOCDELPRL:
  1033. case SIOCCHGPRL:
  1034. err = -EPERM;
  1035. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  1036. goto done;
  1037. err = -EINVAL;
  1038. if (dev == sitn->fb_tunnel_dev)
  1039. goto done;
  1040. err = -EFAULT;
  1041. if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
  1042. goto done;
  1043. err = -ENOENT;
  1044. if (!(t = netdev_priv(dev)))
  1045. goto done;
  1046. switch (cmd) {
  1047. case SIOCDELPRL:
  1048. err = ipip6_tunnel_del_prl(t, &prl);
  1049. break;
  1050. case SIOCADDPRL:
  1051. case SIOCCHGPRL:
  1052. err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
  1053. break;
  1054. }
  1055. netdev_state_change(dev);
  1056. break;
  1057. #ifdef CONFIG_IPV6_SIT_6RD
  1058. case SIOCADD6RD:
  1059. case SIOCCHG6RD:
  1060. case SIOCDEL6RD:
  1061. err = -EPERM;
  1062. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  1063. goto done;
  1064. err = -EFAULT;
  1065. if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
  1066. sizeof(ip6rd)))
  1067. goto done;
  1068. t = netdev_priv(dev);
  1069. if (cmd != SIOCDEL6RD) {
  1070. err = ipip6_tunnel_update_6rd(t, &ip6rd);
  1071. if (err < 0)
  1072. goto done;
  1073. } else
  1074. ipip6_tunnel_clone_6rd(dev, sitn);
  1075. err = 0;
  1076. break;
  1077. #endif
  1078. default:
  1079. err = -EINVAL;
  1080. }
  1081. done:
  1082. return err;
  1083. }
  1084. static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
  1085. {
  1086. if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
  1087. return -EINVAL;
  1088. dev->mtu = new_mtu;
  1089. return 0;
  1090. }
  1091. static const struct net_device_ops ipip6_netdev_ops = {
  1092. .ndo_uninit = ipip6_tunnel_uninit,
  1093. .ndo_start_xmit = sit_tunnel_xmit,
  1094. .ndo_do_ioctl = ipip6_tunnel_ioctl,
  1095. .ndo_change_mtu = ipip6_tunnel_change_mtu,
  1096. .ndo_get_stats64 = ip_tunnel_get_stats64,
  1097. };
  1098. static void ipip6_dev_free(struct net_device *dev)
  1099. {
  1100. free_percpu(dev->tstats);
  1101. free_netdev(dev);
  1102. }
  1103. static void ipip6_tunnel_setup(struct net_device *dev)
  1104. {
  1105. dev->netdev_ops = &ipip6_netdev_ops;
  1106. dev->destructor = ipip6_dev_free;
  1107. dev->type = ARPHRD_SIT;
  1108. dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
  1109. dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
  1110. dev->flags = IFF_NOARP;
  1111. dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
  1112. dev->iflink = 0;
  1113. dev->addr_len = 4;
  1114. dev->features |= NETIF_F_LLTX;
  1115. }
  1116. static int ipip6_tunnel_init(struct net_device *dev)
  1117. {
  1118. struct ip_tunnel *tunnel = netdev_priv(dev);
  1119. tunnel->dev = dev;
  1120. tunnel->net = dev_net(dev);
  1121. memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
  1122. memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
  1123. ipip6_tunnel_bind_dev(dev);
  1124. dev->tstats = alloc_percpu(struct pcpu_tstats);
  1125. if (!dev->tstats)
  1126. return -ENOMEM;
  1127. return 0;
  1128. }
  1129. static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
  1130. {
  1131. struct ip_tunnel *tunnel = netdev_priv(dev);
  1132. struct iphdr *iph = &tunnel->parms.iph;
  1133. struct net *net = dev_net(dev);
  1134. struct sit_net *sitn = net_generic(net, sit_net_id);
  1135. tunnel->dev = dev;
  1136. tunnel->net = dev_net(dev);
  1137. strcpy(tunnel->parms.name, dev->name);
  1138. iph->version = 4;
  1139. iph->protocol = IPPROTO_IPV6;
  1140. iph->ihl = 5;
  1141. iph->ttl = 64;
  1142. dev->tstats = alloc_percpu(struct pcpu_tstats);
  1143. if (!dev->tstats)
  1144. return -ENOMEM;
  1145. dev_hold(dev);
  1146. rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
  1147. return 0;
  1148. }
  1149. static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[])
  1150. {
  1151. u8 proto;
  1152. if (!data || !data[IFLA_IPTUN_PROTO])
  1153. return 0;
  1154. proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
  1155. if (proto != IPPROTO_IPV6 &&
  1156. proto != IPPROTO_IPIP &&
  1157. proto != 0)
  1158. return -EINVAL;
  1159. return 0;
  1160. }
  1161. static void ipip6_netlink_parms(struct nlattr *data[],
  1162. struct ip_tunnel_parm *parms)
  1163. {
  1164. memset(parms, 0, sizeof(*parms));
  1165. parms->iph.version = 4;
  1166. parms->iph.protocol = IPPROTO_IPV6;
  1167. parms->iph.ihl = 5;
  1168. parms->iph.ttl = 64;
  1169. if (!data)
  1170. return;
  1171. if (data[IFLA_IPTUN_LINK])
  1172. parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
  1173. if (data[IFLA_IPTUN_LOCAL])
  1174. parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
  1175. if (data[IFLA_IPTUN_REMOTE])
  1176. parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
  1177. if (data[IFLA_IPTUN_TTL]) {
  1178. parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
  1179. if (parms->iph.ttl)
  1180. parms->iph.frag_off = htons(IP_DF);
  1181. }
  1182. if (data[IFLA_IPTUN_TOS])
  1183. parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
  1184. if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
  1185. parms->iph.frag_off = htons(IP_DF);
  1186. if (data[IFLA_IPTUN_FLAGS])
  1187. parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
  1188. if (data[IFLA_IPTUN_PROTO])
  1189. parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
  1190. }
  1191. #ifdef CONFIG_IPV6_SIT_6RD
  1192. /* This function returns true when 6RD attributes are present in the nl msg */
  1193. static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
  1194. struct ip_tunnel_6rd *ip6rd)
  1195. {
  1196. bool ret = false;
  1197. memset(ip6rd, 0, sizeof(*ip6rd));
  1198. if (!data)
  1199. return ret;
  1200. if (data[IFLA_IPTUN_6RD_PREFIX]) {
  1201. ret = true;
  1202. nla_memcpy(&ip6rd->prefix, data[IFLA_IPTUN_6RD_PREFIX],
  1203. sizeof(struct in6_addr));
  1204. }
  1205. if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
  1206. ret = true;
  1207. ip6rd->relay_prefix =
  1208. nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
  1209. }
  1210. if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
  1211. ret = true;
  1212. ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
  1213. }
  1214. if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
  1215. ret = true;
  1216. ip6rd->relay_prefixlen =
  1217. nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
  1218. }
  1219. return ret;
  1220. }
  1221. #endif
  1222. static int ipip6_newlink(struct net *src_net, struct net_device *dev,
  1223. struct nlattr *tb[], struct nlattr *data[])
  1224. {
  1225. struct net *net = dev_net(dev);
  1226. struct ip_tunnel *nt;
  1227. #ifdef CONFIG_IPV6_SIT_6RD
  1228. struct ip_tunnel_6rd ip6rd;
  1229. #endif
  1230. int err;
  1231. nt = netdev_priv(dev);
  1232. ipip6_netlink_parms(data, &nt->parms);
  1233. if (ipip6_tunnel_locate(net, &nt->parms, 0))
  1234. return -EEXIST;
  1235. err = ipip6_tunnel_create(dev);
  1236. if (err < 0)
  1237. return err;
  1238. #ifdef CONFIG_IPV6_SIT_6RD
  1239. if (ipip6_netlink_6rd_parms(data, &ip6rd))
  1240. err = ipip6_tunnel_update_6rd(nt, &ip6rd);
  1241. #endif
  1242. return err;
  1243. }
  1244. static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
  1245. struct nlattr *data[])
  1246. {
  1247. struct ip_tunnel *t = netdev_priv(dev);
  1248. struct ip_tunnel_parm p;
  1249. struct net *net = t->net;
  1250. struct sit_net *sitn = net_generic(net, sit_net_id);
  1251. #ifdef CONFIG_IPV6_SIT_6RD
  1252. struct ip_tunnel_6rd ip6rd;
  1253. #endif
  1254. if (dev == sitn->fb_tunnel_dev)
  1255. return -EINVAL;
  1256. ipip6_netlink_parms(data, &p);
  1257. if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
  1258. (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
  1259. return -EINVAL;
  1260. t = ipip6_tunnel_locate(net, &p, 0);
  1261. if (t) {
  1262. if (t->dev != dev)
  1263. return -EEXIST;
  1264. } else
  1265. t = netdev_priv(dev);
  1266. ipip6_tunnel_update(t, &p);
  1267. #ifdef CONFIG_IPV6_SIT_6RD
  1268. if (ipip6_netlink_6rd_parms(data, &ip6rd))
  1269. return ipip6_tunnel_update_6rd(t, &ip6rd);
  1270. #endif
  1271. return 0;
  1272. }
  1273. static size_t ipip6_get_size(const struct net_device *dev)
  1274. {
  1275. return
  1276. /* IFLA_IPTUN_LINK */
  1277. nla_total_size(4) +
  1278. /* IFLA_IPTUN_LOCAL */
  1279. nla_total_size(4) +
  1280. /* IFLA_IPTUN_REMOTE */
  1281. nla_total_size(4) +
  1282. /* IFLA_IPTUN_TTL */
  1283. nla_total_size(1) +
  1284. /* IFLA_IPTUN_TOS */
  1285. nla_total_size(1) +
  1286. /* IFLA_IPTUN_PMTUDISC */
  1287. nla_total_size(1) +
  1288. /* IFLA_IPTUN_FLAGS */
  1289. nla_total_size(2) +
  1290. /* IFLA_IPTUN_PROTO */
  1291. nla_total_size(1) +
  1292. #ifdef CONFIG_IPV6_SIT_6RD
  1293. /* IFLA_IPTUN_6RD_PREFIX */
  1294. nla_total_size(sizeof(struct in6_addr)) +
  1295. /* IFLA_IPTUN_6RD_RELAY_PREFIX */
  1296. nla_total_size(4) +
  1297. /* IFLA_IPTUN_6RD_PREFIXLEN */
  1298. nla_total_size(2) +
  1299. /* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
  1300. nla_total_size(2) +
  1301. #endif
  1302. 0;
  1303. }
  1304. static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
  1305. {
  1306. struct ip_tunnel *tunnel = netdev_priv(dev);
  1307. struct ip_tunnel_parm *parm = &tunnel->parms;
  1308. if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
  1309. nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
  1310. nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
  1311. nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
  1312. nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
  1313. nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
  1314. !!(parm->iph.frag_off & htons(IP_DF))) ||
  1315. nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
  1316. nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags))
  1317. goto nla_put_failure;
  1318. #ifdef CONFIG_IPV6_SIT_6RD
  1319. if (nla_put(skb, IFLA_IPTUN_6RD_PREFIX, sizeof(struct in6_addr),
  1320. &tunnel->ip6rd.prefix) ||
  1321. nla_put_be32(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
  1322. tunnel->ip6rd.relay_prefix) ||
  1323. nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
  1324. tunnel->ip6rd.prefixlen) ||
  1325. nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
  1326. tunnel->ip6rd.relay_prefixlen))
  1327. goto nla_put_failure;
  1328. #endif
  1329. return 0;
  1330. nla_put_failure:
  1331. return -EMSGSIZE;
  1332. }
  1333. static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
  1334. [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
  1335. [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
  1336. [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
  1337. [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
  1338. [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
  1339. [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
  1340. [IFLA_IPTUN_FLAGS] = { .type = NLA_U16 },
  1341. [IFLA_IPTUN_PROTO] = { .type = NLA_U8 },
  1342. #ifdef CONFIG_IPV6_SIT_6RD
  1343. [IFLA_IPTUN_6RD_PREFIX] = { .len = sizeof(struct in6_addr) },
  1344. [IFLA_IPTUN_6RD_RELAY_PREFIX] = { .type = NLA_U32 },
  1345. [IFLA_IPTUN_6RD_PREFIXLEN] = { .type = NLA_U16 },
  1346. [IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
  1347. #endif
  1348. };
  1349. static struct rtnl_link_ops sit_link_ops __read_mostly = {
  1350. .kind = "sit",
  1351. .maxtype = IFLA_IPTUN_MAX,
  1352. .policy = ipip6_policy,
  1353. .priv_size = sizeof(struct ip_tunnel),
  1354. .setup = ipip6_tunnel_setup,
  1355. .validate = ipip6_validate,
  1356. .newlink = ipip6_newlink,
  1357. .changelink = ipip6_changelink,
  1358. .get_size = ipip6_get_size,
  1359. .fill_info = ipip6_fill_info,
  1360. };
  1361. static struct xfrm_tunnel sit_handler __read_mostly = {
  1362. .handler = ipip6_rcv,
  1363. .err_handler = ipip6_err,
  1364. .priority = 1,
  1365. };
  1366. static struct xfrm_tunnel ipip_handler __read_mostly = {
  1367. .handler = ipip_rcv,
  1368. .err_handler = ipip6_err,
  1369. .priority = 2,
  1370. };
  1371. static void __net_exit sit_destroy_tunnels(struct sit_net *sitn, struct list_head *head)
  1372. {
  1373. struct net *net = dev_net(sitn->fb_tunnel_dev);
  1374. struct net_device *dev, *aux;
  1375. int prio;
  1376. for_each_netdev_safe(net, dev, aux)
  1377. if (dev->rtnl_link_ops == &sit_link_ops)
  1378. unregister_netdevice_queue(dev, head);
  1379. for (prio = 1; prio < 4; prio++) {
  1380. int h;
  1381. for (h = 0; h < HASH_SIZE; h++) {
  1382. struct ip_tunnel *t;
  1383. t = rtnl_dereference(sitn->tunnels[prio][h]);
  1384. while (t != NULL) {
  1385. /* If dev is in the same netns, it has already
  1386. * been added to the list by the previous loop.
  1387. */
  1388. if (!net_eq(dev_net(t->dev), net))
  1389. unregister_netdevice_queue(t->dev,
  1390. head);
  1391. t = rtnl_dereference(t->next);
  1392. }
  1393. }
  1394. }
  1395. }
  1396. static int __net_init sit_init_net(struct net *net)
  1397. {
  1398. struct sit_net *sitn = net_generic(net, sit_net_id);
  1399. struct ip_tunnel *t;
  1400. int err;
  1401. sitn->tunnels[0] = sitn->tunnels_wc;
  1402. sitn->tunnels[1] = sitn->tunnels_l;
  1403. sitn->tunnels[2] = sitn->tunnels_r;
  1404. sitn->tunnels[3] = sitn->tunnels_r_l;
  1405. sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
  1406. ipip6_tunnel_setup);
  1407. if (!sitn->fb_tunnel_dev) {
  1408. err = -ENOMEM;
  1409. goto err_alloc_dev;
  1410. }
  1411. dev_net_set(sitn->fb_tunnel_dev, net);
  1412. sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
  1413. /* FB netdevice is special: we have one, and only one per netns.
  1414. * Allowing to move it to another netns is clearly unsafe.
  1415. */
  1416. sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
  1417. err = ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
  1418. if (err)
  1419. goto err_dev_free;
  1420. ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
  1421. if ((err = register_netdev(sitn->fb_tunnel_dev)))
  1422. goto err_reg_dev;
  1423. t = netdev_priv(sitn->fb_tunnel_dev);
  1424. strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
  1425. return 0;
  1426. err_reg_dev:
  1427. dev_put(sitn->fb_tunnel_dev);
  1428. err_dev_free:
  1429. ipip6_dev_free(sitn->fb_tunnel_dev);
  1430. err_alloc_dev:
  1431. return err;
  1432. }
  1433. static void __net_exit sit_exit_net(struct net *net)
  1434. {
  1435. struct sit_net *sitn = net_generic(net, sit_net_id);
  1436. LIST_HEAD(list);
  1437. rtnl_lock();
  1438. sit_destroy_tunnels(sitn, &list);
  1439. unregister_netdevice_many(&list);
  1440. rtnl_unlock();
  1441. }
  1442. static struct pernet_operations sit_net_ops = {
  1443. .init = sit_init_net,
  1444. .exit = sit_exit_net,
  1445. .id = &sit_net_id,
  1446. .size = sizeof(struct sit_net),
  1447. };
  1448. static void __exit sit_cleanup(void)
  1449. {
  1450. rtnl_link_unregister(&sit_link_ops);
  1451. xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
  1452. xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
  1453. unregister_pernet_device(&sit_net_ops);
  1454. rcu_barrier(); /* Wait for completion of call_rcu()'s */
  1455. }
  1456. static int __init sit_init(void)
  1457. {
  1458. int err;
  1459. pr_info("IPv6 over IPv4 tunneling driver\n");
  1460. err = register_pernet_device(&sit_net_ops);
  1461. if (err < 0)
  1462. return err;
  1463. err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
  1464. if (err < 0) {
  1465. pr_info("%s: can't register ip6ip4\n", __func__);
  1466. goto xfrm_tunnel_failed;
  1467. }
  1468. err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
  1469. if (err < 0) {
  1470. pr_info("%s: can't register ip4ip4\n", __func__);
  1471. goto xfrm_tunnel4_failed;
  1472. }
  1473. err = rtnl_link_register(&sit_link_ops);
  1474. if (err < 0)
  1475. goto rtnl_link_failed;
  1476. out:
  1477. return err;
  1478. rtnl_link_failed:
  1479. xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
  1480. xfrm_tunnel4_failed:
  1481. xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
  1482. xfrm_tunnel_failed:
  1483. unregister_pernet_device(&sit_net_ops);
  1484. goto out;
  1485. }
  1486. module_init(sit_init);
  1487. module_exit(sit_cleanup);
  1488. MODULE_LICENSE("GPL");
  1489. MODULE_ALIAS_NETDEV("sit0");