Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Generic address resultion entity
4 : : *
5 : : * Authors:
6 : : * net_random Alan Cox
7 : : * net_ratelimit Andi Kleen
8 : : * in{4,6}_pton YOSHIFUJI Hideaki, Copyright (C)2006 USAGI/WIDE Project
9 : : *
10 : : * Created by Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
11 : : */
12 : :
13 : : #include <linux/module.h>
14 : : #include <linux/jiffies.h>
15 : : #include <linux/kernel.h>
16 : : #include <linux/ctype.h>
17 : : #include <linux/inet.h>
18 : : #include <linux/mm.h>
19 : : #include <linux/net.h>
20 : : #include <linux/string.h>
21 : : #include <linux/types.h>
22 : : #include <linux/percpu.h>
23 : : #include <linux/init.h>
24 : : #include <linux/ratelimit.h>
25 : : #include <linux/socket.h>
26 : :
27 : : #include <net/sock.h>
28 : : #include <net/net_ratelimit.h>
29 : : #include <net/ipv6.h>
30 : :
31 : : #include <asm/byteorder.h>
32 : : #include <linux/uaccess.h>
33 : :
34 : : DEFINE_RATELIMIT_STATE(net_ratelimit_state, 5 * HZ, 10);
35 : : /*
36 : : * All net warning printk()s should be guarded by this function.
37 : : */
38 : 0 : int net_ratelimit(void)
39 : : {
40 : 0 : return __ratelimit(&net_ratelimit_state);
41 : : }
42 : : EXPORT_SYMBOL(net_ratelimit);
43 : :
44 : : /*
45 : : * Convert an ASCII string to binary IP.
46 : : * This is outside of net/ipv4/ because various code that uses IP addresses
47 : : * is otherwise not dependent on the TCP/IP stack.
48 : : */
49 : :
50 : 0 : __be32 in_aton(const char *str)
51 : : {
52 : : unsigned int l;
53 : : unsigned int val;
54 : : int i;
55 : :
56 : : l = 0;
57 : 0 : for (i = 0; i < 4; i++) {
58 : 0 : l <<= 8;
59 : 0 : if (*str != '\0') {
60 : : val = 0;
61 : 0 : while (*str != '\0' && *str != '.' && *str != '\n') {
62 : 0 : val *= 10;
63 : 0 : val += *str - '0';
64 : 0 : str++;
65 : : }
66 : 0 : l |= val;
67 : 0 : if (*str != '\0')
68 : 0 : str++;
69 : : }
70 : : }
71 : 0 : return htonl(l);
72 : : }
73 : : EXPORT_SYMBOL(in_aton);
74 : :
75 : : #define IN6PTON_XDIGIT 0x00010000
76 : : #define IN6PTON_DIGIT 0x00020000
77 : : #define IN6PTON_COLON_MASK 0x00700000
78 : : #define IN6PTON_COLON_1 0x00100000 /* single : requested */
79 : : #define IN6PTON_COLON_2 0x00200000 /* second : requested */
80 : : #define IN6PTON_COLON_1_2 0x00400000 /* :: requested */
81 : : #define IN6PTON_DOT 0x00800000 /* . */
82 : : #define IN6PTON_DELIM 0x10000000
83 : : #define IN6PTON_NULL 0x20000000 /* first/tail */
84 : : #define IN6PTON_UNKNOWN 0x40000000
85 : :
86 : 0 : static inline int xdigit2bin(char c, int delim)
87 : : {
88 : : int val;
89 : :
90 : 0 : if (c == delim || c == '\0')
91 : : return IN6PTON_DELIM;
92 : 0 : if (c == ':')
93 : : return IN6PTON_COLON_MASK;
94 : 0 : if (c == '.')
95 : : return IN6PTON_DOT;
96 : :
97 : 0 : val = hex_to_bin(c);
98 : 0 : if (val >= 0)
99 : 0 : return val | IN6PTON_XDIGIT | (val < 10 ? IN6PTON_DIGIT : 0);
100 : :
101 : 0 : if (delim == -1)
102 : : return IN6PTON_DELIM;
103 : 0 : return IN6PTON_UNKNOWN;
104 : : }
105 : :
106 : : /**
107 : : * in4_pton - convert an IPv4 address from literal to binary representation
108 : : * @src: the start of the IPv4 address string
109 : : * @srclen: the length of the string, -1 means strlen(src)
110 : : * @dst: the binary (u8[4] array) representation of the IPv4 address
111 : : * @delim: the delimiter of the IPv4 address in @src, -1 means no delimiter
112 : : * @end: A pointer to the end of the parsed string will be placed here
113 : : *
114 : : * Return one on success, return zero when any error occurs
115 : : * and @end will point to the end of the parsed string.
116 : : *
117 : : */
118 : 0 : int in4_pton(const char *src, int srclen,
119 : : u8 *dst,
120 : : int delim, const char **end)
121 : : {
122 : : const char *s;
123 : : u8 *d;
124 : : u8 dbuf[4];
125 : : int ret = 0;
126 : : int i;
127 : : int w = 0;
128 : :
129 : 0 : if (srclen < 0)
130 : 0 : srclen = strlen(src);
131 : : s = src;
132 : : d = dbuf;
133 : : i = 0;
134 : : while (1) {
135 : : int c;
136 : 0 : c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
137 : 0 : if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) {
138 : : goto out;
139 : : }
140 : 0 : if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
141 : 0 : if (w == 0)
142 : : goto out;
143 : 0 : *d++ = w & 0xff;
144 : : w = 0;
145 : 0 : i++;
146 : 0 : if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
147 : 0 : if (i != 4)
148 : : goto out;
149 : : break;
150 : : }
151 : : goto cont;
152 : : }
153 : 0 : w = (w * 10) + c;
154 : 0 : if ((w & 0xffff) > 255) {
155 : : goto out;
156 : : }
157 : : cont:
158 : 0 : if (i >= 4)
159 : : goto out;
160 : 0 : s++;
161 : 0 : srclen--;
162 : 0 : }
163 : : ret = 1;
164 : 0 : memcpy(dst, dbuf, sizeof(dbuf));
165 : : out:
166 : 0 : if (end)
167 : 0 : *end = s;
168 : 0 : return ret;
169 : : }
170 : : EXPORT_SYMBOL(in4_pton);
171 : :
172 : : /**
173 : : * in6_pton - convert an IPv6 address from literal to binary representation
174 : : * @src: the start of the IPv6 address string
175 : : * @srclen: the length of the string, -1 means strlen(src)
176 : : * @dst: the binary (u8[16] array) representation of the IPv6 address
177 : : * @delim: the delimiter of the IPv6 address in @src, -1 means no delimiter
178 : : * @end: A pointer to the end of the parsed string will be placed here
179 : : *
180 : : * Return one on success, return zero when any error occurs
181 : : * and @end will point to the end of the parsed string.
182 : : *
183 : : */
184 : 0 : int in6_pton(const char *src, int srclen,
185 : : u8 *dst,
186 : : int delim, const char **end)
187 : : {
188 : : const char *s, *tok = NULL;
189 : : u8 *d, *dc = NULL;
190 : : u8 dbuf[16];
191 : : int ret = 0;
192 : : int i;
193 : : int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
194 : : int w = 0;
195 : :
196 : 0 : memset(dbuf, 0, sizeof(dbuf));
197 : :
198 : 0 : s = src;
199 : : d = dbuf;
200 : 0 : if (srclen < 0)
201 : 0 : srclen = strlen(src);
202 : :
203 : : while (1) {
204 : : int c;
205 : :
206 : 0 : c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
207 : 0 : if (!(c & state))
208 : : goto out;
209 : 0 : if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
210 : : /* process one 16-bit word */
211 : 0 : if (!(state & IN6PTON_NULL)) {
212 : 0 : *d++ = (w >> 8) & 0xff;
213 : 0 : *d++ = w & 0xff;
214 : : }
215 : : w = 0;
216 : 0 : if (c & IN6PTON_DELIM) {
217 : : /* We've processed last word */
218 : : break;
219 : : }
220 : : /*
221 : : * COLON_1 => XDIGIT
222 : : * COLON_2 => XDIGIT|DELIM
223 : : * COLON_1_2 => COLON_2
224 : : */
225 : 0 : switch (state & IN6PTON_COLON_MASK) {
226 : : case IN6PTON_COLON_2:
227 : : dc = d;
228 : : state = IN6PTON_XDIGIT | IN6PTON_DELIM;
229 : 0 : if (dc - dbuf >= sizeof(dbuf))
230 : : state |= IN6PTON_NULL;
231 : : break;
232 : : case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
233 : : state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
234 : : break;
235 : : case IN6PTON_COLON_1:
236 : : state = IN6PTON_XDIGIT;
237 : 0 : break;
238 : : case IN6PTON_COLON_1_2:
239 : : state = IN6PTON_COLON_2;
240 : 0 : break;
241 : : default:
242 : : state = 0;
243 : : }
244 : 0 : tok = s + 1;
245 : 0 : goto cont;
246 : : }
247 : :
248 : 0 : if (c & IN6PTON_DOT) {
249 : 0 : ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
250 : 0 : if (ret > 0) {
251 : 0 : d += 4;
252 : 0 : break;
253 : : }
254 : : goto out;
255 : : }
256 : :
257 : 0 : w = (w << 4) | (0xff & c);
258 : : state = IN6PTON_COLON_1 | IN6PTON_DELIM;
259 : 0 : if (!(w & 0xf000)) {
260 : : state |= IN6PTON_XDIGIT;
261 : : }
262 : 0 : if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
263 : : state |= IN6PTON_COLON_1_2;
264 : 0 : state &= ~IN6PTON_DELIM;
265 : : }
266 : 0 : if (d + 2 >= dbuf + sizeof(dbuf)) {
267 : 0 : state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
268 : : }
269 : : cont:
270 : 0 : if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
271 : 0 : d + 4 == dbuf + sizeof(dbuf)) {
272 : 0 : state |= IN6PTON_DOT;
273 : : }
274 : 0 : if (d >= dbuf + sizeof(dbuf)) {
275 : 0 : state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
276 : : }
277 : 0 : s++;
278 : 0 : srclen--;
279 : 0 : }
280 : :
281 : 0 : i = 15; d--;
282 : :
283 : 0 : if (dc) {
284 : 0 : while (d >= dc)
285 : 0 : dst[i--] = *d--;
286 : 0 : while (i >= dc - dbuf)
287 : 0 : dst[i--] = 0;
288 : 0 : while (i >= 0)
289 : 0 : dst[i--] = *d--;
290 : : } else
291 : 0 : memcpy(dst, dbuf, sizeof(dbuf));
292 : :
293 : : ret = 1;
294 : : out:
295 : 0 : if (end)
296 : 0 : *end = s;
297 : 0 : return ret;
298 : : }
299 : : EXPORT_SYMBOL(in6_pton);
300 : :
301 : 0 : static int inet4_pton(const char *src, u16 port_num,
302 : : struct sockaddr_storage *addr)
303 : : {
304 : : struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
305 : 0 : int srclen = strlen(src);
306 : :
307 : 0 : if (srclen > INET_ADDRSTRLEN)
308 : : return -EINVAL;
309 : :
310 : 0 : if (in4_pton(src, srclen, (u8 *)&addr4->sin_addr.s_addr,
311 : : '\n', NULL) == 0)
312 : : return -EINVAL;
313 : :
314 : 0 : addr4->sin_family = AF_INET;
315 : 0 : addr4->sin_port = htons(port_num);
316 : :
317 : 0 : return 0;
318 : : }
319 : :
320 : 0 : static int inet6_pton(struct net *net, const char *src, u16 port_num,
321 : : struct sockaddr_storage *addr)
322 : : {
323 : : struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
324 : : const char *scope_delim;
325 : 0 : int srclen = strlen(src);
326 : :
327 : 0 : if (srclen > INET6_ADDRSTRLEN)
328 : : return -EINVAL;
329 : :
330 : 0 : if (in6_pton(src, srclen, (u8 *)&addr6->sin6_addr.s6_addr,
331 : : '%', &scope_delim) == 0)
332 : : return -EINVAL;
333 : :
334 : 0 : if (ipv6_addr_type(&addr6->sin6_addr) & IPV6_ADDR_LINKLOCAL &&
335 : 0 : src + srclen != scope_delim && *scope_delim == '%') {
336 : : struct net_device *dev;
337 : : char scope_id[16];
338 : 0 : size_t scope_len = min_t(size_t, sizeof(scope_id) - 1,
339 : : src + srclen - scope_delim - 1);
340 : :
341 : 0 : memcpy(scope_id, scope_delim + 1, scope_len);
342 : 0 : scope_id[scope_len] = '\0';
343 : :
344 : 0 : dev = dev_get_by_name(net, scope_id);
345 : 0 : if (dev) {
346 : 0 : addr6->sin6_scope_id = dev->ifindex;
347 : 0 : dev_put(dev);
348 : 0 : } else if (kstrtouint(scope_id, 0, &addr6->sin6_scope_id)) {
349 : 0 : return -EINVAL;
350 : : }
351 : : }
352 : :
353 : 0 : addr6->sin6_family = AF_INET6;
354 : 0 : addr6->sin6_port = htons(port_num);
355 : :
356 : 0 : return 0;
357 : : }
358 : :
359 : : /**
360 : : * inet_pton_with_scope - convert an IPv4/IPv6 and port to socket address
361 : : * @net: net namespace (used for scope handling)
362 : : * @af: address family, AF_INET, AF_INET6 or AF_UNSPEC for either
363 : : * @src: the start of the address string
364 : : * @port: the start of the port string (or NULL for none)
365 : : * @addr: output socket address
366 : : *
367 : : * Return zero on success, return errno when any error occurs.
368 : : */
369 : 0 : int inet_pton_with_scope(struct net *net, __kernel_sa_family_t af,
370 : : const char *src, const char *port, struct sockaddr_storage *addr)
371 : : {
372 : : u16 port_num;
373 : : int ret = -EINVAL;
374 : :
375 : 0 : if (port) {
376 : 0 : if (kstrtou16(port, 0, &port_num))
377 : : return -EINVAL;
378 : : } else {
379 : 0 : port_num = 0;
380 : : }
381 : :
382 : 0 : switch (af) {
383 : : case AF_INET:
384 : 0 : ret = inet4_pton(src, port_num, addr);
385 : 0 : break;
386 : : case AF_INET6:
387 : 0 : ret = inet6_pton(net, src, port_num, addr);
388 : 0 : break;
389 : : case AF_UNSPEC:
390 : 0 : ret = inet4_pton(src, port_num, addr);
391 : 0 : if (ret)
392 : 0 : ret = inet6_pton(net, src, port_num, addr);
393 : : break;
394 : : default:
395 : 0 : pr_err("unexpected address family %d\n", af);
396 : : }
397 : :
398 : 0 : return ret;
399 : : }
400 : : EXPORT_SYMBOL(inet_pton_with_scope);
401 : :
402 : 0 : bool inet_addr_is_any(struct sockaddr *addr)
403 : : {
404 : 0 : if (addr->sa_family == AF_INET6) {
405 : : struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
406 : 0 : const struct sockaddr_in6 in6_any =
407 : : { .sin6_addr = IN6ADDR_ANY_INIT };
408 : :
409 : 0 : if (!memcmp(in6->sin6_addr.s6_addr,
410 : : in6_any.sin6_addr.s6_addr, 16))
411 : 0 : return true;
412 : 0 : } else if (addr->sa_family == AF_INET) {
413 : : struct sockaddr_in *in = (struct sockaddr_in *)addr;
414 : :
415 : 0 : if (in->sin_addr.s_addr == htonl(INADDR_ANY))
416 : : return true;
417 : : } else {
418 : 0 : pr_warn("unexpected address family %u\n", addr->sa_family);
419 : : }
420 : :
421 : : return false;
422 : : }
423 : : EXPORT_SYMBOL(inet_addr_is_any);
424 : :
425 : 0 : void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb,
426 : : __be32 from, __be32 to, bool pseudohdr)
427 : : {
428 : 0 : if (skb->ip_summed != CHECKSUM_PARTIAL) {
429 : : csum_replace4(sum, from, to);
430 : 0 : if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
431 : 0 : skb->csum = ~csum_add(csum_sub(~(skb->csum),
432 : : (__force __wsum)from),
433 : : (__force __wsum)to);
434 : 0 : } else if (pseudohdr)
435 : 0 : *sum = ~csum_fold(csum_add(csum_sub(csum_unfold(*sum),
436 : : (__force __wsum)from),
437 : : (__force __wsum)to));
438 : 0 : }
439 : : EXPORT_SYMBOL(inet_proto_csum_replace4);
440 : :
441 : : /**
442 : : * inet_proto_csum_replace16 - update layer 4 header checksum field
443 : : * @sum: Layer 4 header checksum field
444 : : * @skb: sk_buff for the packet
445 : : * @from: old IPv6 address
446 : : * @to: new IPv6 address
447 : : * @pseudohdr: True if layer 4 header checksum includes pseudoheader
448 : : *
449 : : * Update layer 4 header as per the update in IPv6 src/dst address.
450 : : *
451 : : * There is no need to update skb->csum in this function, because update in two
452 : : * fields a.) IPv6 src/dst address and b.) L4 header checksum cancels each other
453 : : * for skb->csum calculation. Whereas inet_proto_csum_replace4 function needs to
454 : : * update skb->csum, because update in 3 fields a.) IPv4 src/dst address,
455 : : * b.) IPv4 Header checksum and c.) L4 header checksum results in same diff as
456 : : * L4 Header checksum for skb->csum calculation.
457 : : */
458 : 0 : void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb,
459 : : const __be32 *from, const __be32 *to,
460 : : bool pseudohdr)
461 : : {
462 : 0 : __be32 diff[] = {
463 : 0 : ~from[0], ~from[1], ~from[2], ~from[3],
464 : 0 : to[0], to[1], to[2], to[3],
465 : : };
466 : 0 : if (skb->ip_summed != CHECKSUM_PARTIAL) {
467 : 0 : *sum = csum_fold(csum_partial(diff, sizeof(diff),
468 : 0 : ~csum_unfold(*sum)));
469 : 0 : } else if (pseudohdr)
470 : 0 : *sum = ~csum_fold(csum_partial(diff, sizeof(diff),
471 : : csum_unfold(*sum)));
472 : 0 : }
473 : : EXPORT_SYMBOL(inet_proto_csum_replace16);
474 : :
475 : 0 : void inet_proto_csum_replace_by_diff(__sum16 *sum, struct sk_buff *skb,
476 : : __wsum diff, bool pseudohdr)
477 : : {
478 : 0 : if (skb->ip_summed != CHECKSUM_PARTIAL) {
479 : 0 : *sum = csum_fold(csum_add(diff, ~csum_unfold(*sum)));
480 : 0 : if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
481 : 0 : skb->csum = ~csum_add(diff, ~skb->csum);
482 : 0 : } else if (pseudohdr) {
483 : 0 : *sum = ~csum_fold(csum_add(diff, csum_unfold(*sum)));
484 : : }
485 : 0 : }
486 : : EXPORT_SYMBOL(inet_proto_csum_replace_by_diff);
|
