Loading...
1#include <linux/module.h>
2#include <linux/errno.h>
3#include <linux/socket.h>
4#include <linux/udp.h>
5#include <linux/types.h>
6#include <linux/kernel.h>
7#include <linux/in6.h>
8#include <net/udp.h>
9#include <net/udp_tunnel.h>
10#include <net/net_namespace.h>
11#include <net/netns/generic.h>
12#include <net/ip6_tunnel.h>
13#include <net/ip6_checksum.h>
14
15int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg,
16 struct socket **sockp)
17{
18 struct sockaddr_in6 udp6_addr;
19 int err;
20 struct socket *sock = NULL;
21
22 err = sock_create_kern(net, AF_INET6, SOCK_DGRAM, 0, &sock);
23 if (err < 0)
24 goto error;
25
26 if (cfg->ipv6_v6only) {
27 int val = 1;
28
29 err = kernel_setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
30 (char *) &val, sizeof(val));
31 if (err < 0)
32 goto error;
33 }
34
35 udp6_addr.sin6_family = AF_INET6;
36 memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
37 sizeof(udp6_addr.sin6_addr));
38 udp6_addr.sin6_port = cfg->local_udp_port;
39 err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
40 sizeof(udp6_addr));
41 if (err < 0)
42 goto error;
43
44 if (cfg->peer_udp_port) {
45 udp6_addr.sin6_family = AF_INET6;
46 memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
47 sizeof(udp6_addr.sin6_addr));
48 udp6_addr.sin6_port = cfg->peer_udp_port;
49 err = kernel_connect(sock,
50 (struct sockaddr *)&udp6_addr,
51 sizeof(udp6_addr), 0);
52 }
53 if (err < 0)
54 goto error;
55
56 udp_set_no_check6_tx(sock->sk, !cfg->use_udp6_tx_checksums);
57 udp_set_no_check6_rx(sock->sk, !cfg->use_udp6_rx_checksums);
58
59 *sockp = sock;
60 return 0;
61
62error:
63 if (sock) {
64 kernel_sock_shutdown(sock, SHUT_RDWR);
65 sock_release(sock);
66 }
67 *sockp = NULL;
68 return err;
69}
70EXPORT_SYMBOL_GPL(udp_sock_create6);
71
72int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,
73 struct sk_buff *skb,
74 struct net_device *dev, struct in6_addr *saddr,
75 struct in6_addr *daddr,
76 __u8 prio, __u8 ttl, __be32 label,
77 __be16 src_port, __be16 dst_port, bool nocheck)
78{
79 struct udphdr *uh;
80 struct ipv6hdr *ip6h;
81
82 __skb_push(skb, sizeof(*uh));
83 skb_reset_transport_header(skb);
84 uh = udp_hdr(skb);
85
86 uh->dest = dst_port;
87 uh->source = src_port;
88
89 uh->len = htons(skb->len);
90
91 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
92 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED
93 | IPSKB_REROUTED);
94 skb_dst_set(skb, dst);
95
96 udp6_set_csum(nocheck, skb, saddr, daddr, skb->len);
97
98 __skb_push(skb, sizeof(*ip6h));
99 skb_reset_network_header(skb);
100 ip6h = ipv6_hdr(skb);
101 ip6_flow_hdr(ip6h, prio, label);
102 ip6h->payload_len = htons(skb->len);
103 ip6h->nexthdr = IPPROTO_UDP;
104 ip6h->hop_limit = ttl;
105 ip6h->daddr = *daddr;
106 ip6h->saddr = *saddr;
107
108 ip6tunnel_xmit(sk, skb, dev);
109 return 0;
110}
111EXPORT_SYMBOL_GPL(udp_tunnel6_xmit_skb);
112
113MODULE_LICENSE("GPL");
1
2// SPDX-License-Identifier: GPL-2.0-only
3#include <linux/module.h>
4#include <linux/errno.h>
5#include <linux/socket.h>
6#include <linux/udp.h>
7#include <linux/types.h>
8#include <linux/kernel.h>
9#include <linux/in6.h>
10#include <net/udp.h>
11#include <net/udp_tunnel.h>
12#include <net/net_namespace.h>
13#include <net/netns/generic.h>
14#include <net/ip6_tunnel.h>
15#include <net/ip6_checksum.h>
16
17int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg,
18 struct socket **sockp)
19{
20 struct sockaddr_in6 udp6_addr = {};
21 int err;
22 struct socket *sock = NULL;
23
24 err = sock_create_kern(net, AF_INET6, SOCK_DGRAM, 0, &sock);
25 if (err < 0)
26 goto error;
27
28 if (cfg->ipv6_v6only) {
29 err = ip6_sock_set_v6only(sock->sk);
30 if (err < 0)
31 goto error;
32 }
33 if (cfg->bind_ifindex) {
34 err = sock_bindtoindex(sock->sk, cfg->bind_ifindex, true);
35 if (err < 0)
36 goto error;
37 }
38
39 udp6_addr.sin6_family = AF_INET6;
40 memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
41 sizeof(udp6_addr.sin6_addr));
42 udp6_addr.sin6_port = cfg->local_udp_port;
43 err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
44 sizeof(udp6_addr));
45 if (err < 0)
46 goto error;
47
48 if (cfg->peer_udp_port) {
49 memset(&udp6_addr, 0, sizeof(udp6_addr));
50 udp6_addr.sin6_family = AF_INET6;
51 memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
52 sizeof(udp6_addr.sin6_addr));
53 udp6_addr.sin6_port = cfg->peer_udp_port;
54 err = kernel_connect(sock,
55 (struct sockaddr *)&udp6_addr,
56 sizeof(udp6_addr), 0);
57 }
58 if (err < 0)
59 goto error;
60
61 udp_set_no_check6_tx(sock->sk, !cfg->use_udp6_tx_checksums);
62 udp_set_no_check6_rx(sock->sk, !cfg->use_udp6_rx_checksums);
63
64 *sockp = sock;
65 return 0;
66
67error:
68 if (sock) {
69 kernel_sock_shutdown(sock, SHUT_RDWR);
70 sock_release(sock);
71 }
72 *sockp = NULL;
73 return err;
74}
75EXPORT_SYMBOL_GPL(udp_sock_create6);
76
77int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk,
78 struct sk_buff *skb,
79 struct net_device *dev,
80 const struct in6_addr *saddr,
81 const struct in6_addr *daddr,
82 __u8 prio, __u8 ttl, __be32 label,
83 __be16 src_port, __be16 dst_port, bool nocheck)
84{
85 struct udphdr *uh;
86 struct ipv6hdr *ip6h;
87
88 __skb_push(skb, sizeof(*uh));
89 skb_reset_transport_header(skb);
90 uh = udp_hdr(skb);
91
92 uh->dest = dst_port;
93 uh->source = src_port;
94
95 uh->len = htons(skb->len);
96
97 skb_dst_set(skb, dst);
98
99 udp6_set_csum(nocheck, skb, saddr, daddr, skb->len);
100
101 __skb_push(skb, sizeof(*ip6h));
102 skb_reset_network_header(skb);
103 ip6h = ipv6_hdr(skb);
104 ip6_flow_hdr(ip6h, prio, label);
105 ip6h->payload_len = htons(skb->len);
106 ip6h->nexthdr = IPPROTO_UDP;
107 ip6h->hop_limit = ttl;
108 ip6h->daddr = *daddr;
109 ip6h->saddr = *saddr;
110
111 ip6tunnel_xmit(sk, skb, dev);
112 return 0;
113}
114EXPORT_SYMBOL_GPL(udp_tunnel6_xmit_skb);
115
116/**
117 * udp_tunnel6_dst_lookup - perform route lookup on UDP tunnel
118 * @skb: Packet for which lookup is done
119 * @dev: Tunnel device
120 * @net: Network namespace of tunnel device
121 * @sock: Socket which provides route info
122 * @oif: Index of the output interface
123 * @saddr: Memory to store the src ip address
124 * @key: Tunnel information
125 * @sport: UDP source port
126 * @dport: UDP destination port
127 * @dsfield: The traffic class field
128 * @dst_cache: The dst cache to use for lookup
129 * This function performs a route lookup on a UDP tunnel
130 *
131 * It returns a valid dst pointer and stores src address to be used in
132 * tunnel in param saddr on success, else a pointer encoded error code.
133 */
134
135struct dst_entry *udp_tunnel6_dst_lookup(struct sk_buff *skb,
136 struct net_device *dev,
137 struct net *net,
138 struct socket *sock,
139 int oif,
140 struct in6_addr *saddr,
141 const struct ip_tunnel_key *key,
142 __be16 sport, __be16 dport, u8 dsfield,
143 struct dst_cache *dst_cache)
144{
145 struct dst_entry *dst = NULL;
146 struct flowi6 fl6;
147
148#ifdef CONFIG_DST_CACHE
149 if (dst_cache) {
150 dst = dst_cache_get_ip6(dst_cache, saddr);
151 if (dst)
152 return dst;
153 }
154#endif
155 memset(&fl6, 0, sizeof(fl6));
156 fl6.flowi6_mark = skb->mark;
157 fl6.flowi6_proto = IPPROTO_UDP;
158 fl6.flowi6_oif = oif;
159 fl6.daddr = key->u.ipv6.dst;
160 fl6.saddr = key->u.ipv6.src;
161 fl6.fl6_sport = sport;
162 fl6.fl6_dport = dport;
163 fl6.flowlabel = ip6_make_flowinfo(dsfield, key->label);
164
165 dst = ipv6_stub->ipv6_dst_lookup_flow(net, sock->sk, &fl6,
166 NULL);
167 if (IS_ERR(dst)) {
168 netdev_dbg(dev, "no route to %pI6\n", &fl6.daddr);
169 return ERR_PTR(-ENETUNREACH);
170 }
171 if (dst->dev == dev) { /* is this necessary? */
172 netdev_dbg(dev, "circular route to %pI6\n", &fl6.daddr);
173 dst_release(dst);
174 return ERR_PTR(-ELOOP);
175 }
176#ifdef CONFIG_DST_CACHE
177 if (dst_cache)
178 dst_cache_set_ip6(dst_cache, dst, &fl6.saddr);
179#endif
180 *saddr = fl6.saddr;
181 return dst;
182}
183EXPORT_SYMBOL_GPL(udp_tunnel6_dst_lookup);
184
185MODULE_DESCRIPTION("IPv6 Foo over UDP tunnel driver");
186MODULE_LICENSE("GPL");