net/core/utils.c

   1 /*
   2  *      Generic address resultion entity
   3  *
   4  *      Authors:
   5  *      net_random Alan Cox
   6  *      net_ratelimit Andi Kleen
   7  *      in{4,6}_pton YOSHIFUJI Hideaki, Copyright (C)2006 USAGI/WIDE Project
   8  *
   9  *      Created by Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  10  *
  11  *      This program is free software; you can redistribute it and/or
  12  *      modify it under the terms of the GNU General Public License
  13  *      as published by the Free Software Foundation; either version
  14  *      2 of the License, or (at your option) any later version.
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/jiffies.h>
  19 #include <linux/kernel.h>
  20 #include <linux/ctype.h>
  21 #include <linux/inet.h>
  22 #include <linux/mm.h>
  23 #include <linux/net.h>
  24 #include <linux/string.h>
  25 #include <linux/types.h>
  26 #include <linux/percpu.h>
  27 #include <linux/init.h>
  28 #include <linux/ratelimit.h>
  29
  30 #include <net/sock.h>
  31 #include <net/net_ratelimit.h>
  32
  33 #include <asm/byteorder.h>
  34 #include <asm/uaccess.h>
  35
  36 DEFINE_RATELIMIT_STATE(net_ratelimit_state, 5 * HZ, 10);
  37 /*
  38  * All net warning printk()s should be guarded by this function.
  39  */
  40 int net_ratelimit(void)
  41 {
  42         return __ratelimit(&net_ratelimit_state);
  43 }
  44 EXPORT_SYMBOL(net_ratelimit);
  45
  46 /*
  47  * Convert an ASCII string to binary IP.
  48  * This is outside of net/ipv4/ because various code that uses IP addresses
  49  * is otherwise not dependent on the TCP/IP stack.
  50  */
  51
  52 __be32 in_aton(const char *str)
  53 {
  54         unsigned long l;
  55         unsigned int val;
  56         int i;
  57
  58         l = 0;
  59         for (i = 0; i < 4; i++) {
  60                 l <<= 8;
  61                 if (*str != '\0') {
  62                         val = 0;
  63                         while (*str != '\0' && *str != '.' && *str != '\n') {
  64                                 val *= 10;
  65                                 val += *str - '0';
  66                                 str++;
  67                         }
  68                         l |= val;
  69                         if (*str != '\0')
  70                                 str++;
  71                 }
  72         }
  73         return htonl(l);
  74 }
  75 EXPORT_SYMBOL(in_aton);
  76
  77 #define IN6PTON_XDIGIT          0x00010000
  78 #define IN6PTON_DIGIT           0x00020000
  79 #define IN6PTON_COLON_MASK      0x00700000
  80 #define IN6PTON_COLON_1         0x00100000      /* single : requested */
  81 #define IN6PTON_COLON_2         0x00200000      /* second : requested */
  82 #define IN6PTON_COLON_1_2       0x00400000      /* :: requested */
  83 #define IN6PTON_DOT             0x00800000      /* . */
  84 #define IN6PTON_DELIM           0x10000000
  85 #define IN6PTON_NULL            0x20000000      /* first/tail */
  86 #define IN6PTON_UNKNOWN         0x40000000
  87
  88 static inline int xdigit2bin(char c, int delim)
  89 {
  90         int val;
  91
  92         if (c == delim || c == '\0')
  93                 return IN6PTON_DELIM;
  94         if (c == ':')
  95                 return IN6PTON_COLON_MASK;
  96         if (c == '.')
  97                 return IN6PTON_DOT;
  98
  99         val = hex_to_bin(c);
 100         if (val >= 0)
 101                 return val | IN6PTON_XDIGIT | (val < 10 ? IN6PTON_DIGIT : 0);
 102
 103         if (delim == -1)
 104                 return IN6PTON_DELIM;
 105         return IN6PTON_UNKNOWN;
 106 }
 107
 108 /**
 109  * in4_pton - convert an IPv4 address from literal to binary representation
 110  * @src: the start of the IPv4 address string
 111  * @srclen: the length of the string, -1 means strlen(src)
 112  * @dst: the binary (u8[4] array) representation of the IPv4 address
 113  * @delim: the delimiter of the IPv4 address in @src, -1 means no delimiter
 114  * @end: A pointer to the end of the parsed string will be placed here
 115  *
 116  * Return one on success, return zero when any error occurs
 117  * and @end will point to the end of the parsed string.
 118  *
 119  */
 120 int in4_pton(const char *src, int srclen,
 121              u8 *dst,
 122              int delim, const char **end)
 123 {
 124         const char *s;
 125         u8 *d;
 126         u8 dbuf[4];
 127         int ret = 0;
 128         int i;
 129         int w = 0;
 130
 131         if (srclen < 0)
 132                 srclen = strlen(src);
 133         s = src;
 134         d = dbuf;
 135         i = 0;
 136         while(1) {
 137                 int c;
 138                 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
 139                 if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) {
 140                         goto out;
 141                 }
 142                 if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
 143                         if (w == 0)
 144                                 goto out;
 145                         *d++ = w & 0xff;
 146                         w = 0;
 147                         i++;
 148                         if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
 149                                 if (i != 4)
 150                                         goto out;
 151                                 break;
 152                         }
 153                         goto cont;
 154                 }
 155                 w = (w * 10) + c;
 156                 if ((w & 0xffff) > 255) {
 157                         goto out;
 158                 }
 159 cont:
 160                 if (i >= 4)
 161                         goto out;
 162                 s++;
 163                 srclen--;
 164         }
 165         ret = 1;
 166         memcpy(dst, dbuf, sizeof(dbuf));
 167 out:
 168         if (end)
 169                 *end = s;
 170         return ret;
 171 }
 172 EXPORT_SYMBOL(in4_pton);
 173
 174 /**
 175  * in6_pton - convert an IPv6 address from literal to binary representation
 176  * @src: the start of the IPv6 address string
 177  * @srclen: the length of the string, -1 means strlen(src)
 178  * @dst: the binary (u8[16] array) representation of the IPv6 address
 179  * @delim: the delimiter of the IPv6 address in @src, -1 means no delimiter
 180  * @end: A pointer to the end of the parsed string will be placed here
 181  *
 182  * Return one on success, return zero when any error occurs
 183  * and @end will point to the end of the parsed string.
 184  *
 185  */
 186 int in6_pton(const char *src, int srclen,
 187              u8 *dst,
 188              int delim, const char **end)
 189 {
 190         const char *s, *tok = NULL;
 191         u8 *d, *dc = NULL;
 192         u8 dbuf[16];
 193         int ret = 0;
 194         int i;
 195         int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
 196         int w = 0;
 197
 198         memset(dbuf, 0, sizeof(dbuf));
 199
 200         s = src;
 201         d = dbuf;
 202         if (srclen < 0)
 203                 srclen = strlen(src);
 204
 205         while (1) {
 206                 int c;
 207
 208                 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
 209                 if (!(c & state))
 210                         goto out;
 211                 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
 212                         /* process one 16-bit word */
 213                         if (!(state & IN6PTON_NULL)) {
 214                                 *d++ = (w >> 8) & 0xff;
 215                                 *d++ = w & 0xff;
 216                         }
 217                         w = 0;
 218                         if (c & IN6PTON_DELIM) {
 219                                 /* We've processed last word */
 220                                 break;
 221                         }
 222                         /*
 223                          * COLON_1 => XDIGIT
 224                          * COLON_2 => XDIGIT|DELIM
 225                          * COLON_1_2 => COLON_2
 226                          */
 227                         switch (state & IN6PTON_COLON_MASK) {
 228                         case IN6PTON_COLON_2:
 229                                 dc = d;
 230                                 state = IN6PTON_XDIGIT | IN6PTON_DELIM;
 231                                 if (dc - dbuf >= sizeof(dbuf))
 232                                         state |= IN6PTON_NULL;
 233                                 break;
 234                         case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
 235                                 state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
 236                                 break;
 237                         case IN6PTON_COLON_1:
 238                                 state = IN6PTON_XDIGIT;
 239                                 break;
 240                         case IN6PTON_COLON_1_2:
 241                                 state = IN6PTON_COLON_2;
 242                                 break;
 243                         default:
 244                                 state = 0;
 245                         }
 246                         tok = s + 1;
 247                         goto cont;
 248                 }
 249
 250                 if (c & IN6PTON_DOT) {
 251                         ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
 252                         if (ret > 0) {
 253                                 d += 4;
 254                                 break;
 255                         }
 256                         goto out;
 257                 }
 258
 259                 w = (w << 4) | (0xff & c);
 260                 state = IN6PTON_COLON_1 | IN6PTON_DELIM;
 261                 if (!(w & 0xf000)) {
 262                         state |= IN6PTON_XDIGIT;
 263                 }
 264                 if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
 265                         state |= IN6PTON_COLON_1_2;
 266                         state &= ~IN6PTON_DELIM;
 267                 }
 268                 if (d + 2 >= dbuf + sizeof(dbuf)) {
 269                         state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
 270                 }
 271 cont:
 272                 if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
 273                     d + 4 == dbuf + sizeof(dbuf)) {
 274                         state |= IN6PTON_DOT;
 275                 }
 276                 if (d >= dbuf + sizeof(dbuf)) {
 277                         state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
 278                 }
 279                 s++;
 280                 srclen--;
 281         }
 282
 283         i = 15; d--;
 284
 285         if (dc) {
 286                 while(d >= dc)
 287                         dst[i--] = *d--;
 288                 while(i >= dc - dbuf)
 289                         dst[i--] = 0;
 290                 while(i >= 0)
 291                         dst[i--] = *d--;
 292         } else
 293                 memcpy(dst, dbuf, sizeof(dbuf));
 294
 295         ret = 1;
 296 out:
 297         if (end)
 298                 *end = s;
 299         return ret;
 300 }
 301 EXPORT_SYMBOL(in6_pton);
 302
 303 void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb,
 304                               __be32 from, __be32 to, bool pseudohdr)
 305 {
 306         if (skb->ip_summed != CHECKSUM_PARTIAL) {
 307                 csum_replace4(sum, from, to);
 308                 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
 309                         skb->csum = ~csum_add(csum_sub(~(skb->csum),
 310                                                        (__force __wsum)from),
 311                                               (__force __wsum)to);
 312         } else if (pseudohdr)
 313                 *sum = ~csum_fold(csum_add(csum_sub(csum_unfold(*sum),
 314                                                     (__force __wsum)from),
 315                                            (__force __wsum)to));
 316 }
 317 EXPORT_SYMBOL(inet_proto_csum_replace4);
 318
 319 void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb,
 320                                const __be32 *from, const __be32 *to,
 321                                bool pseudohdr)
 322 {
 323         __be32 diff[] = {
 324                 ~from[0], ~from[1], ~from[2], ~from[3],
 325                 to[0], to[1], to[2], to[3],
 326         };
 327         if (skb->ip_summed != CHECKSUM_PARTIAL) {
 328                 *sum = csum_fold(csum_partial(diff, sizeof(diff),
 329                                  ~csum_unfold(*sum)));
 330                 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
 331                         skb->csum = ~csum_partial(diff, sizeof(diff),
 332                                                   ~skb->csum);
 333         } else if (pseudohdr)
 334                 *sum = ~csum_fold(csum_partial(diff, sizeof(diff),
 335                                   csum_unfold(*sum)));
 336 }
 337 EXPORT_SYMBOL(inet_proto_csum_replace16);
 338
 339 void inet_proto_csum_replace_by_diff(__sum16 *sum, struct sk_buff *skb,
 340                                      __wsum diff, bool pseudohdr)
 341 {
 342         if (skb->ip_summed != CHECKSUM_PARTIAL) {
 343                 *sum = csum_fold(csum_add(diff, ~csum_unfold(*sum)));
 344                 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
 345                         skb->csum = ~csum_add(diff, ~skb->csum);
 346         } else if (pseudohdr) {
 347                 *sum = ~csum_fold(csum_add(diff, csum_unfold(*sum)));
 348         }
 349 }
 350 EXPORT_SYMBOL(inet_proto_csum_replace_by_diff);
 351
 352 struct __net_random_once_work {
 353         struct work_struct work;
 354         struct static_key *key;
 355 };
 356
 357 static void __net_random_once_deferred(struct work_struct *w)
 358 {
 359         struct __net_random_once_work *work =
 360                 container_of(w, struct __net_random_once_work, work);
 361         BUG_ON(!static_key_enabled(work->key));
 362         static_key_slow_dec(work->key);
 363         kfree(work);
 364 }
 365
 366 static void __net_random_once_disable_jump(struct static_key *key)
 367 {
 368         struct __net_random_once_work *w;
 369
 370         w = kmalloc(sizeof(*w), GFP_ATOMIC);
 371         if (!w)
 372                 return;
 373
 374         INIT_WORK(&w->work, __net_random_once_deferred);
 375         w->key = key;
 376         schedule_work(&w->work);
 377 }
 378
 379 bool __net_get_random_once(void *buf, int nbytes, bool *done,
 380                            struct static_key *once_key)
 381 {
 382         static DEFINE_SPINLOCK(lock);
 383         unsigned long flags;
 384
 385         spin_lock_irqsave(&lock, flags);
 386         if (*done) {
 387                 spin_unlock_irqrestore(&lock, flags);
 388                 return false;
 389         }
 390
 391         get_random_bytes(buf, nbytes);
 392         *done = true;
 393         spin_unlock_irqrestore(&lock, flags);
 394
 395         __net_random_once_disable_jump(once_key);
 396
 397         return true;
 398 }
 399 EXPORT_SYMBOL(__net_get_random_once);