xref: /openbmc/linux/net/core/utils.c (revision 22d55f02)
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  int net_ratelimit(void)
39  {
40  	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  __be32 in_aton(const char *str)
51  {
52  	unsigned int l;
53  	unsigned int val;
54  	int i;
55  
56  	l = 0;
57  	for (i = 0; i < 4; i++)	{
58  		l <<= 8;
59  		if (*str != '\0') {
60  			val = 0;
61  			while (*str != '\0' && *str != '.' && *str != '\n') {
62  				val *= 10;
63  				val += *str - '0';
64  				str++;
65  			}
66  			l |= val;
67  			if (*str != '\0')
68  				str++;
69  		}
70  	}
71  	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  static inline int xdigit2bin(char c, int delim)
87  {
88  	int val;
89  
90  	if (c == delim || c == '\0')
91  		return IN6PTON_DELIM;
92  	if (c == ':')
93  		return IN6PTON_COLON_MASK;
94  	if (c == '.')
95  		return IN6PTON_DOT;
96  
97  	val = hex_to_bin(c);
98  	if (val >= 0)
99  		return val | IN6PTON_XDIGIT | (val < 10 ? IN6PTON_DIGIT : 0);
100  
101  	if (delim == -1)
102  		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  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  	if (srclen < 0)
130  		srclen = strlen(src);
131  	s = src;
132  	d = dbuf;
133  	i = 0;
134  	while (1) {
135  		int c;
136  		c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
137  		if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) {
138  			goto out;
139  		}
140  		if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
141  			if (w == 0)
142  				goto out;
143  			*d++ = w & 0xff;
144  			w = 0;
145  			i++;
146  			if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
147  				if (i != 4)
148  					goto out;
149  				break;
150  			}
151  			goto cont;
152  		}
153  		w = (w * 10) + c;
154  		if ((w & 0xffff) > 255) {
155  			goto out;
156  		}
157  cont:
158  		if (i >= 4)
159  			goto out;
160  		s++;
161  		srclen--;
162  	}
163  	ret = 1;
164  	memcpy(dst, dbuf, sizeof(dbuf));
165  out:
166  	if (end)
167  		*end = s;
168  	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  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  	memset(dbuf, 0, sizeof(dbuf));
197  
198  	s = src;
199  	d = dbuf;
200  	if (srclen < 0)
201  		srclen = strlen(src);
202  
203  	while (1) {
204  		int c;
205  
206  		c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
207  		if (!(c & state))
208  			goto out;
209  		if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
210  			/* process one 16-bit word */
211  			if (!(state & IN6PTON_NULL)) {
212  				*d++ = (w >> 8) & 0xff;
213  				*d++ = w & 0xff;
214  			}
215  			w = 0;
216  			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  			switch (state & IN6PTON_COLON_MASK) {
226  			case IN6PTON_COLON_2:
227  				dc = d;
228  				state = IN6PTON_XDIGIT | IN6PTON_DELIM;
229  				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  				break;
238  			case IN6PTON_COLON_1_2:
239  				state = IN6PTON_COLON_2;
240  				break;
241  			default:
242  				state = 0;
243  			}
244  			tok = s + 1;
245  			goto cont;
246  		}
247  
248  		if (c & IN6PTON_DOT) {
249  			ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
250  			if (ret > 0) {
251  				d += 4;
252  				break;
253  			}
254  			goto out;
255  		}
256  
257  		w = (w << 4) | (0xff & c);
258  		state = IN6PTON_COLON_1 | IN6PTON_DELIM;
259  		if (!(w & 0xf000)) {
260  			state |= IN6PTON_XDIGIT;
261  		}
262  		if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
263  			state |= IN6PTON_COLON_1_2;
264  			state &= ~IN6PTON_DELIM;
265  		}
266  		if (d + 2 >= dbuf + sizeof(dbuf)) {
267  			state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
268  		}
269  cont:
270  		if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
271  		    d + 4 == dbuf + sizeof(dbuf)) {
272  			state |= IN6PTON_DOT;
273  		}
274  		if (d >= dbuf + sizeof(dbuf)) {
275  			state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
276  		}
277  		s++;
278  		srclen--;
279  	}
280  
281  	i = 15; d--;
282  
283  	if (dc) {
284  		while (d >= dc)
285  			dst[i--] = *d--;
286  		while (i >= dc - dbuf)
287  			dst[i--] = 0;
288  		while (i >= 0)
289  			dst[i--] = *d--;
290  	} else
291  		memcpy(dst, dbuf, sizeof(dbuf));
292  
293  	ret = 1;
294  out:
295  	if (end)
296  		*end = s;
297  	return ret;
298  }
299  EXPORT_SYMBOL(in6_pton);
300  
301  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  	int srclen = strlen(src);
306  
307  	if (srclen > INET_ADDRSTRLEN)
308  		return -EINVAL;
309  
310  	if (in4_pton(src, srclen, (u8 *)&addr4->sin_addr.s_addr,
311  		     '\n', NULL) == 0)
312  		return -EINVAL;
313  
314  	addr4->sin_family = AF_INET;
315  	addr4->sin_port = htons(port_num);
316  
317  	return 0;
318  }
319  
320  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  	int srclen = strlen(src);
326  
327  	if (srclen > INET6_ADDRSTRLEN)
328  		return -EINVAL;
329  
330  	if (in6_pton(src, srclen, (u8 *)&addr6->sin6_addr.s6_addr,
331  		     '%', &scope_delim) == 0)
332  		return -EINVAL;
333  
334  	if (ipv6_addr_type(&addr6->sin6_addr) & IPV6_ADDR_LINKLOCAL &&
335  	    src + srclen != scope_delim && *scope_delim == '%') {
336  		struct net_device *dev;
337  		char scope_id[16];
338  		size_t scope_len = min_t(size_t, sizeof(scope_id) - 1,
339  					 src + srclen - scope_delim - 1);
340  
341  		memcpy(scope_id, scope_delim + 1, scope_len);
342  		scope_id[scope_len] = '\0';
343  
344  		dev = dev_get_by_name(net, scope_id);
345  		if (dev) {
346  			addr6->sin6_scope_id = dev->ifindex;
347  			dev_put(dev);
348  		} else if (kstrtouint(scope_id, 0, &addr6->sin6_scope_id)) {
349  			return -EINVAL;
350  		}
351  	}
352  
353  	addr6->sin6_family = AF_INET6;
354  	addr6->sin6_port = htons(port_num);
355  
356  	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  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  	if (port) {
376  		if (kstrtou16(port, 0, &port_num))
377  			return -EINVAL;
378  	} else {
379  		port_num = 0;
380  	}
381  
382  	switch (af) {
383  	case AF_INET:
384  		ret = inet4_pton(src, port_num, addr);
385  		break;
386  	case AF_INET6:
387  		ret = inet6_pton(net, src, port_num, addr);
388  		break;
389  	case AF_UNSPEC:
390  		ret = inet4_pton(src, port_num, addr);
391  		if (ret)
392  			ret = inet6_pton(net, src, port_num, addr);
393  		break;
394  	default:
395  		pr_err("unexpected address family %d\n", af);
396  	}
397  
398  	return ret;
399  }
400  EXPORT_SYMBOL(inet_pton_with_scope);
401  
402  bool inet_addr_is_any(struct sockaddr *addr)
403  {
404  	if (addr->sa_family == AF_INET6) {
405  		struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
406  		const struct sockaddr_in6 in6_any =
407  			{ .sin6_addr = IN6ADDR_ANY_INIT };
408  
409  		if (!memcmp(in6->sin6_addr.s6_addr,
410  			    in6_any.sin6_addr.s6_addr, 16))
411  			return true;
412  	} else if (addr->sa_family == AF_INET) {
413  		struct sockaddr_in *in = (struct sockaddr_in *)addr;
414  
415  		if (in->sin_addr.s_addr == htonl(INADDR_ANY))
416  			return true;
417  	} else {
418  		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  void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb,
426  			      __be32 from, __be32 to, bool pseudohdr)
427  {
428  	if (skb->ip_summed != CHECKSUM_PARTIAL) {
429  		csum_replace4(sum, from, to);
430  		if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
431  			skb->csum = ~csum_add(csum_sub(~(skb->csum),
432  						       (__force __wsum)from),
433  					      (__force __wsum)to);
434  	} else if (pseudohdr)
435  		*sum = ~csum_fold(csum_add(csum_sub(csum_unfold(*sum),
436  						    (__force __wsum)from),
437  					   (__force __wsum)to));
438  }
439  EXPORT_SYMBOL(inet_proto_csum_replace4);
440  
441  void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb,
442  			       const __be32 *from, const __be32 *to,
443  			       bool pseudohdr)
444  {
445  	__be32 diff[] = {
446  		~from[0], ~from[1], ~from[2], ~from[3],
447  		to[0], to[1], to[2], to[3],
448  	};
449  	if (skb->ip_summed != CHECKSUM_PARTIAL) {
450  		*sum = csum_fold(csum_partial(diff, sizeof(diff),
451  				 ~csum_unfold(*sum)));
452  		if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
453  			skb->csum = ~csum_partial(diff, sizeof(diff),
454  						  ~skb->csum);
455  	} else if (pseudohdr)
456  		*sum = ~csum_fold(csum_partial(diff, sizeof(diff),
457  				  csum_unfold(*sum)));
458  }
459  EXPORT_SYMBOL(inet_proto_csum_replace16);
460  
461  void inet_proto_csum_replace_by_diff(__sum16 *sum, struct sk_buff *skb,
462  				     __wsum diff, bool pseudohdr)
463  {
464  	if (skb->ip_summed != CHECKSUM_PARTIAL) {
465  		*sum = csum_fold(csum_add(diff, ~csum_unfold(*sum)));
466  		if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
467  			skb->csum = ~csum_add(diff, ~skb->csum);
468  	} else if (pseudohdr) {
469  		*sum = ~csum_fold(csum_add(diff, csum_unfold(*sum)));
470  	}
471  }
472  EXPORT_SYMBOL(inet_proto_csum_replace_by_diff);
473