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 0 : unsigned int l;
53 0 : unsigned int val;
54 0 : int i;
55 :
56 0 : 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 0 : 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 0 : return IN6PTON_DELIM;
103 : 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 0 : const char *s;
123 0 : u8 *d;
124 0 : u8 dbuf[4];
125 0 : int ret = 0;
126 0 : int i;
127 0 : int w = 0;
128 :
129 0 : if (srclen < 0)
130 0 : srclen = strlen(src);
131 : s = src;
132 : d = dbuf;
133 : i = 0;
134 0 : while (1) {
135 0 : 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 0 : goto out;
139 : }
140 0 : if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
141 0 : if (w == 0)
142 0 : goto out;
143 0 : *d++ = w & 0xff;
144 0 : w = 0;
145 0 : i++;
146 0 : if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
147 0 : if (i != 4)
148 0 : goto out;
149 0 : break;
150 : }
151 0 : goto cont;
152 : }
153 0 : w = (w * 10) + c;
154 0 : if ((w & 0xffff) > 255) {
155 0 : goto out;
156 : }
157 0 : cont:
158 0 : if (i >= 4)
159 0 : goto out;
160 0 : s++;
161 0 : srclen--;
162 : }
163 0 : ret = 1;
164 0 : memcpy(dst, dbuf, sizeof(dbuf));
165 0 : 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 0 : const char *s, *tok = NULL;
189 0 : u8 *d, *dc = NULL;
190 0 : u8 dbuf[16];
191 0 : int ret = 0;
192 0 : int i;
193 0 : int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
194 0 : int w = 0;
195 :
196 0 : memset(dbuf, 0, sizeof(dbuf));
197 :
198 0 : s = src;
199 0 : d = dbuf;
200 0 : if (srclen < 0)
201 0 : srclen = strlen(src);
202 :
203 0 : while (1) {
204 0 : int c;
205 :
206 0 : c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
207 0 : if (!(c & state))
208 0 : 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 0 : 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 0 : case IN6PTON_COLON_2:
227 0 : dc = d;
228 0 : state = IN6PTON_XDIGIT | IN6PTON_DELIM;
229 0 : if (dc - dbuf >= sizeof(dbuf))
230 0 : state |= IN6PTON_NULL;
231 : break;
232 : case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
233 : state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
234 : break;
235 0 : case IN6PTON_COLON_1:
236 0 : state = IN6PTON_XDIGIT;
237 0 : break;
238 0 : case IN6PTON_COLON_1_2:
239 0 : state = IN6PTON_COLON_2;
240 0 : break;
241 0 : default:
242 0 : 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 0 : goto out;
255 : }
256 :
257 0 : w = (w << 4) | (0xff & c);
258 0 : state = IN6PTON_COLON_1 | IN6PTON_DELIM;
259 0 : if (!(w & 0xf000)) {
260 0 : state |= IN6PTON_XDIGIT;
261 : }
262 0 : if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
263 0 : 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 0 : 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 : }
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 0 : 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 0 : 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 0 : struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
324 0 : 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 0 : struct net_device *dev;
337 0 : 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 0 : u16 port_num;
373 0 : 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 0 : case AF_INET:
384 0 : ret = inet4_pton(src, port_num, addr);
385 0 : break;
386 0 : case AF_INET6:
387 0 : ret = inet6_pton(net, src, port_num, addr);
388 0 : break;
389 0 : 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 0 : default:
395 0 : pr_err("unexpected address family %d\n", af);
396 : }
397 :
398 : 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 0 : 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 0 : struct sockaddr_in *in = (struct sockaddr_in *)addr;
414 :
415 0 : if (in->sin_addr.s_addr == htonl(INADDR_ANY))
416 0 : 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 0 : 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 0 : 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);
|
