LXR linux/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
  36DEFINE_RATELIMIT_STATE(net_ratelimit_state, 5 * HZ, 10);
  37/*
  38 * All net warning printk()s should be guarded by this function.
  39 */
  40int net_ratelimit(void)
  41{
  42        return __ratelimit(&net_ratelimit_state);
  43}
  44EXPORT_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}
  75EXPORT_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
  88static 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 */
 120int 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                }
 159cont:
 160                if (i >= 4)
 161                        goto out;
 162                s++;
 163                srclen--;
 164        }
 165        ret = 1;
 166        memcpy(dst, dbuf, sizeof(dbuf));
 167out:
 168        if (end)
 169                *end = s;
 170        return ret;
 171}
 172EXPORT_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 */
 186int 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                }
 271cont:
 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;
 296out:
 297        if (end)
 298                *end = s;
 299        return ret;
 300}
 301EXPORT_SYMBOL(in6_pton);
 302
 303void 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                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}
 317EXPORT_SYMBOL(inet_proto_csum_replace4);
 318
 319void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb,
 320                               const __be32 *from, const __be32 *to,
 321                               int 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}
 337EXPORT_SYMBOL(inet_proto_csum_replace16);
 338
 339struct __net_random_once_work {
 340        struct work_struct work;
 341        struct static_key *key;
 342};
 343
 344static void __net_random_once_deferred(struct work_struct *w)
 345{
 346        struct __net_random_once_work *work =
 347                container_of(w, struct __net_random_once_work, work);
 348        BUG_ON(!static_key_enabled(work->key));
 349        static_key_slow_dec(work->key);
 350        kfree(work);
 351}
 352
 353static void __net_random_once_disable_jump(struct static_key *key)
 354{
 355        struct __net_random_once_work *w;
 356
 357        w = kmalloc(sizeof(*w), GFP_ATOMIC);
 358        if (!w)
 359                return;
 360
 361        INIT_WORK(&w->work, __net_random_once_deferred);
 362        w->key = key;
 363        schedule_work(&w->work);
 364}
 365
 366bool __net_get_random_once(void *buf, int nbytes, bool *done,
 367                           struct static_key *once_key)
 368{
 369        static DEFINE_SPINLOCK(lock);
 370        unsigned long flags;
 371
 372        spin_lock_irqsave(&lock, flags);
 373        if (*done) {
 374                spin_unlock_irqrestore(&lock, flags);
 375                return false;
 376        }
 377
 378        get_random_bytes(buf, nbytes);
 379        *done = true;
 380        spin_unlock_irqrestore(&lock, flags);
 381
 382        __net_random_once_disable_jump(once_key);
 383
 384        return true;
 385}
 386EXPORT_SYMBOL(__net_get_random_once);
 387