net/core/utils.c

   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);