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, int pseudohdr)
 305 {
 306         if (skb->ip_summed != CHECKSUM_PARTIAL) {
 307                 *sum = csum_fold(csum_add(csum_sub(~csum_unfold(*sum), from),
 308                                  to));
 309                 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
 310                         skb->csum = ~csum_add(csum_sub(~(skb->csum), from), to);
 311         } else if (pseudohdr)
 312                 *sum = ~csum_fold(csum_add(csum_sub(csum_unfold(*sum), from),
 313                                   to));
 314 }
 315 EXPORT_SYMBOL(inet_proto_csum_replace4);
 316
 317 void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb,
 318                                const __be32 *from, const __be32 *to,
 319                                int pseudohdr)
 320 {
 321         __be32 diff[] = {
 322                 ~from[0], ~from[1], ~from[2], ~from[3],
 323                 to[0], to[1], to[2], to[3],
 324         };
 325         if (skb->ip_summed != CHECKSUM_PARTIAL) {
 326                 *sum = csum_fold(csum_partial(diff, sizeof(diff),
 327                                  ~csum_unfold(*sum)));
 328                 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
 329                         skb->csum = ~csum_partial(diff, sizeof(diff),
 330                                                   ~skb->csum);
 331         } else if (pseudohdr)
 332                 *sum = ~csum_fold(csum_partial(diff, sizeof(diff),
 333                                   csum_unfold(*sum)));
 334 }
 335 EXPORT_SYMBOL(inet_proto_csum_replace16);
 336
 337 struct __net_random_once_work {
 338         struct work_struct work;
 339         struct static_key *key;
 340 };
 341
 342 static void __net_random_once_deferred(struct work_struct *w)
 343 {
 344         struct __net_random_once_work *work =
 345                 container_of(w, struct __net_random_once_work, work);
 346         BUG_ON(!static_key_enabled(work->key));
 347         static_key_slow_dec(work->key);
 348         kfree(work);
 349 }
 350
 351 static void __net_random_once_disable_jump(struct static_key *key)
 352 {
 353         struct __net_random_once_work *w;
 354
 355         w = kmalloc(sizeof(*w), GFP_ATOMIC);
 356         if (!w)
 357                 return;
 358
 359         INIT_WORK(&w->work, __net_random_once_deferred);
 360         w->key = key;
 361         schedule_work(&w->work);
 362 }
 363
 364 bool __net_get_random_once(void *buf, int nbytes, bool *done,
 365                            struct static_key *once_key)
 366 {
 367         static DEFINE_SPINLOCK(lock);
 368         unsigned long flags;
 369
 370         spin_lock_irqsave(&lock, flags);
 371         if (*done) {
 372                 spin_unlock_irqrestore(&lock, flags);
 373                 return false;
 374         }
 375
 376         get_random_bytes(buf, nbytes);
 377         *done = true;
 378         spin_unlock_irqrestore(&lock, flags);
 379
 380         __net_random_once_disable_jump(once_key);
 381
 382         return true;
 383 }
 384 EXPORT_SYMBOL(__net_get_random_once);