projects/linux·blob master · refs

487 lines · 11.7 KiB

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