linux/net/core/utils.c
<<
>>
Prefs
   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/inet.h>
  21#include <linux/mm.h>
  22#include <linux/net.h>
  23#include <linux/string.h>
  24#include <linux/types.h>
  25#include <linux/percpu.h>
  26#include <linux/init.h>
  27#include <linux/ratelimit.h>
  28
  29#include <net/sock.h>
  30#include <net/net_ratelimit.h>
  31
  32#include <asm/byteorder.h>
  33#include <asm/uaccess.h>
  34
  35int net_msg_warn __read_mostly = 1;
  36EXPORT_SYMBOL(net_msg_warn);
  37
  38DEFINE_RATELIMIT_STATE(net_ratelimit_state, 5 * HZ, 10);
  39/*
  40 * All net warning printk()s should be guarded by this function.
  41 */
  42int net_ratelimit(void)
  43{
  44        return __ratelimit(&net_ratelimit_state);
  45}
  46EXPORT_SYMBOL(net_ratelimit);
  47
  48/*
  49 * Convert an ASCII string to binary IP.
  50 * This is outside of net/ipv4/ because various code that uses IP addresses
  51 * is otherwise not dependent on the TCP/IP stack.
  52 */
  53
  54__be32 in_aton(const char *str)
  55{
  56        unsigned long l;
  57        unsigned int val;
  58        int i;
  59
  60        l = 0;
  61        for (i = 0; i < 4; i++) {
  62                l <<= 8;
  63                if (*str != '\0') {
  64                        val = 0;
  65                        while (*str != '\0' && *str != '.' && *str != '\n') {
  66                                val *= 10;
  67                                val += *str - '0';
  68                                str++;
  69                        }
  70                        l |= val;
  71                        if (*str != '\0')
  72                                str++;
  73                }
  74        }
  75        return htonl(l);
  76}
  77EXPORT_SYMBOL(in_aton);
  78
  79#define IN6PTON_XDIGIT          0x00010000
  80#define IN6PTON_DIGIT           0x00020000
  81#define IN6PTON_COLON_MASK      0x00700000
  82#define IN6PTON_COLON_1         0x00100000      /* single : requested */
  83#define IN6PTON_COLON_2         0x00200000      /* second : requested */
  84#define IN6PTON_COLON_1_2       0x00400000      /* :: requested */
  85#define IN6PTON_DOT             0x00800000      /* . */
  86#define IN6PTON_DELIM           0x10000000
  87#define IN6PTON_NULL            0x20000000      /* first/tail */
  88#define IN6PTON_UNKNOWN         0x40000000
  89
  90static inline int xdigit2bin(char c, int delim)
  91{
  92        int val;
  93
  94        if (c == delim || c == '\0')
  95                return IN6PTON_DELIM;
  96        if (c == ':')
  97                return IN6PTON_COLON_MASK;
  98        if (c == '.')
  99                return IN6PTON_DOT;
 100
 101        val = hex_to_bin(c);
 102        if (val >= 0)
 103                return val | IN6PTON_XDIGIT | (val < 10 ? IN6PTON_DIGIT : 0);
 104
 105        if (delim == -1)
 106                return IN6PTON_DELIM;
 107        return IN6PTON_UNKNOWN;
 108}
 109
 110int in4_pton(const char *src, int srclen,
 111             u8 *dst,
 112             int delim, const char **end)
 113{
 114        const char *s;
 115        u8 *d;
 116        u8 dbuf[4];
 117        int ret = 0;
 118        int i;
 119        int w = 0;
 120
 121        if (srclen < 0)
 122                srclen = strlen(src);
 123        s = src;
 124        d = dbuf;
 125        i = 0;
 126        while(1) {
 127                int c;
 128                c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
 129                if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) {
 130                        goto out;
 131                }
 132                if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
 133                        if (w == 0)
 134                                goto out;
 135                        *d++ = w & 0xff;
 136                        w = 0;
 137                        i++;
 138                        if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
 139                                if (i != 4)
 140                                        goto out;
 141                                break;
 142                        }
 143                        goto cont;
 144                }
 145                w = (w * 10) + c;
 146                if ((w & 0xffff) > 255) {
 147                        goto out;
 148                }
 149cont:
 150                if (i >= 4)
 151                        goto out;
 152                s++;
 153                srclen--;
 154        }
 155        ret = 1;
 156        memcpy(dst, dbuf, sizeof(dbuf));
 157out:
 158        if (end)
 159                *end = s;
 160        return ret;
 161}
 162EXPORT_SYMBOL(in4_pton);
 163
 164int in6_pton(const char *src, int srclen,
 165             u8 *dst,
 166             int delim, const char **end)
 167{
 168        const char *s, *tok = NULL;
 169        u8 *d, *dc = NULL;
 170        u8 dbuf[16];
 171        int ret = 0;
 172        int i;
 173        int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
 174        int w = 0;
 175
 176        memset(dbuf, 0, sizeof(dbuf));
 177
 178        s = src;
 179        d = dbuf;
 180        if (srclen < 0)
 181                srclen = strlen(src);
 182
 183        while (1) {
 184                int c;
 185
 186                c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
 187                if (!(c & state))
 188                        goto out;
 189                if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
 190                        /* process one 16-bit word */
 191                        if (!(state & IN6PTON_NULL)) {
 192                                *d++ = (w >> 8) & 0xff;
 193                                *d++ = w & 0xff;
 194                        }
 195                        w = 0;
 196                        if (c & IN6PTON_DELIM) {
 197                                /* We've processed last word */
 198                                break;
 199                        }
 200                        /*
 201                         * COLON_1 => XDIGIT
 202                         * COLON_2 => XDIGIT|DELIM
 203                         * COLON_1_2 => COLON_2
 204                         */
 205                        switch (state & IN6PTON_COLON_MASK) {
 206                        case IN6PTON_COLON_2:
 207                                dc = d;
 208                                state = IN6PTON_XDIGIT | IN6PTON_DELIM;
 209                                if (dc - dbuf >= sizeof(dbuf))
 210                                        state |= IN6PTON_NULL;
 211                                break;
 212                        case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
 213                                state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
 214                                break;
 215                        case IN6PTON_COLON_1:
 216                                state = IN6PTON_XDIGIT;
 217                                break;
 218                        case IN6PTON_COLON_1_2:
 219                                state = IN6PTON_COLON_2;
 220                                break;
 221                        default:
 222                                state = 0;
 223                        }
 224                        tok = s + 1;
 225                        goto cont;
 226                }
 227
 228                if (c & IN6PTON_DOT) {
 229                        ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
 230                        if (ret > 0) {
 231                                d += 4;
 232                                break;
 233                        }
 234                        goto out;
 235                }
 236
 237                w = (w << 4) | (0xff & c);
 238                state = IN6PTON_COLON_1 | IN6PTON_DELIM;
 239                if (!(w & 0xf000)) {
 240                        state |= IN6PTON_XDIGIT;
 241                }
 242                if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
 243                        state |= IN6PTON_COLON_1_2;
 244                        state &= ~IN6PTON_DELIM;
 245                }
 246                if (d + 2 >= dbuf + sizeof(dbuf)) {
 247                        state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
 248                }
 249cont:
 250                if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
 251                    d + 4 == dbuf + sizeof(dbuf)) {
 252                        state |= IN6PTON_DOT;
 253                }
 254                if (d >= dbuf + sizeof(dbuf)) {
 255                        state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
 256                }
 257                s++;
 258                srclen--;
 259        }
 260
 261        i = 15; d--;
 262
 263        if (dc) {
 264                while(d >= dc)
 265                        dst[i--] = *d--;
 266                while(i >= dc - dbuf)
 267                        dst[i--] = 0;
 268                while(i >= 0)
 269                        dst[i--] = *d--;
 270        } else
 271                memcpy(dst, dbuf, sizeof(dbuf));
 272
 273        ret = 1;
 274out:
 275        if (end)
 276                *end = s;
 277        return ret;
 278}
 279EXPORT_SYMBOL(in6_pton);
 280
 281void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb,
 282                              __be32 from, __be32 to, int pseudohdr)
 283{
 284        __be32 diff[] = { ~from, to };
 285        if (skb->ip_summed != CHECKSUM_PARTIAL) {
 286                *sum = csum_fold(csum_partial(diff, sizeof(diff),
 287                                ~csum_unfold(*sum)));
 288                if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr)
 289                        skb->csum = ~csum_partial(diff, sizeof(diff),
 290                                                ~skb->csum);
 291        } else if (pseudohdr)
 292                *sum = ~csum_fold(csum_partial(diff, sizeof(diff),
 293                                csum_unfold(*sum)));
 294}
 295EXPORT_SYMBOL(inet_proto_csum_replace4);
 296
 297int mac_pton(const char *s, u8 *mac)
 298{
 299        int i;
 300
 301        /* XX:XX:XX:XX:XX:XX */
 302        if (strlen(s) < 3 * ETH_ALEN - 1)
 303                return 0;
 304
 305        /* Don't dirty result unless string is valid MAC. */
 306        for (i = 0; i < ETH_ALEN; i++) {
 307                if (!strchr("0123456789abcdefABCDEF", s[i * 3]))
 308                        return 0;
 309                if (!strchr("0123456789abcdefABCDEF", s[i * 3 + 1]))
 310                        return 0;
 311                if (i != ETH_ALEN - 1 && s[i * 3 + 2] != ':')
 312                        return 0;
 313        }
 314        for (i = 0; i < ETH_ALEN; i++) {
 315                mac[i] = (hex_to_bin(s[i * 3]) << 4) | hex_to_bin(s[i * 3 + 1]);
 316        }
 317        return 1;
 318}
 319EXPORT_SYMBOL(mac_pton);
 320
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.