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/random.h> 26 #include <linux/percpu.h> 27 #include <linux/init.h> 28 #include <net/sock.h> 29 30 #include <asm/byteorder.h> 31 #include <asm/system.h> 32 #include <asm/uaccess.h> 33 34 int net_msg_cost __read_mostly = 5*HZ; 35 int net_msg_burst __read_mostly = 10; 36 int net_msg_warn __read_mostly = 1; 37 EXPORT_SYMBOL(net_msg_warn); 38 39 /* 40 * All net warning printk()s should be guarded by this function. 41 */ 42 int net_ratelimit(void) 43 { 44 return __printk_ratelimit(net_msg_cost, net_msg_burst); 45 } 46 EXPORT_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 { 63 l <<= 8; 64 if (*str != '\0') 65 { 66 val = 0; 67 while (*str != '\0' && *str != '.' && *str != '\n') 68 { 69 val *= 10; 70 val += *str - '0'; 71 str++; 72 } 73 l |= val; 74 if (*str != '\0') 75 str++; 76 } 77 } 78 return(htonl(l)); 79 } 80 81 EXPORT_SYMBOL(in_aton); 82 83 #define IN6PTON_XDIGIT 0x00010000 84 #define IN6PTON_DIGIT 0x00020000 85 #define IN6PTON_COLON_MASK 0x00700000 86 #define IN6PTON_COLON_1 0x00100000 /* single : requested */ 87 #define IN6PTON_COLON_2 0x00200000 /* second : requested */ 88 #define IN6PTON_COLON_1_2 0x00400000 /* :: requested */ 89 #define IN6PTON_DOT 0x00800000 /* . */ 90 #define IN6PTON_DELIM 0x10000000 91 #define IN6PTON_NULL 0x20000000 /* first/tail */ 92 #define IN6PTON_UNKNOWN 0x40000000 93 94 static inline int digit2bin(char c, int delim) 95 { 96 if (c == delim || c == '\0') 97 return IN6PTON_DELIM; 98 if (c == '.') 99 return IN6PTON_DOT; 100 if (c >= '0' && c <= '9') 101 return (IN6PTON_DIGIT | (c - '0')); 102 return IN6PTON_UNKNOWN; 103 } 104 105 static inline int xdigit2bin(char c, int delim) 106 { 107 if (c == delim || c == '\0') 108 return IN6PTON_DELIM; 109 if (c == ':') 110 return IN6PTON_COLON_MASK; 111 if (c == '.') 112 return IN6PTON_DOT; 113 if (c >= '0' && c <= '9') 114 return (IN6PTON_XDIGIT | IN6PTON_DIGIT| (c - '0')); 115 if (c >= 'a' && c <= 'f') 116 return (IN6PTON_XDIGIT | (c - 'a' + 10)); 117 if (c >= 'A' && c <= 'F') 118 return (IN6PTON_XDIGIT | (c - 'A' + 10)); 119 if (delim == -1) 120 return IN6PTON_DELIM; 121 return IN6PTON_UNKNOWN; 122 } 123 124 int in4_pton(const char *src, int srclen, 125 u8 *dst, 126 int delim, const char **end) 127 { 128 const char *s; 129 u8 *d; 130 u8 dbuf[4]; 131 int ret = 0; 132 int i; 133 int w = 0; 134 135 if (srclen < 0) 136 srclen = strlen(src); 137 s = src; 138 d = dbuf; 139 i = 0; 140 while(1) { 141 int c; 142 c = xdigit2bin(srclen > 0 ? *s : '\0', delim); 143 if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) { 144 goto out; 145 } 146 if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) { 147 if (w == 0) 148 goto out; 149 *d++ = w & 0xff; 150 w = 0; 151 i++; 152 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) { 153 if (i != 4) 154 goto out; 155 break; 156 } 157 goto cont; 158 } 159 w = (w * 10) + c; 160 if ((w & 0xffff) > 255) { 161 goto out; 162 } 163 cont: 164 if (i >= 4) 165 goto out; 166 s++; 167 srclen--; 168 } 169 ret = 1; 170 memcpy(dst, dbuf, sizeof(dbuf)); 171 out: 172 if (end) 173 *end = s; 174 return ret; 175 } 176 177 EXPORT_SYMBOL(in4_pton); 178 179 int in6_pton(const char *src, int srclen, 180 u8 *dst, 181 int delim, const char **end) 182 { 183 const char *s, *tok = NULL; 184 u8 *d, *dc = NULL; 185 u8 dbuf[16]; 186 int ret = 0; 187 int i; 188 int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL; 189 int w = 0; 190 191 memset(dbuf, 0, sizeof(dbuf)); 192 193 s = src; 194 d = dbuf; 195 if (srclen < 0) 196 srclen = strlen(src); 197 198 while (1) { 199 int c; 200 201 c = xdigit2bin(srclen > 0 ? *s : '\0', delim); 202 if (!(c & state)) 203 goto out; 204 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) { 205 /* process one 16-bit word */ 206 if (!(state & IN6PTON_NULL)) { 207 *d++ = (w >> 8) & 0xff; 208 *d++ = w & 0xff; 209 } 210 w = 0; 211 if (c & IN6PTON_DELIM) { 212 /* We've processed last word */ 213 break; 214 } 215 /* 216 * COLON_1 => XDIGIT 217 * COLON_2 => XDIGIT|DELIM 218 * COLON_1_2 => COLON_2 219 */ 220 switch (state & IN6PTON_COLON_MASK) { 221 case IN6PTON_COLON_2: 222 dc = d; 223 state = IN6PTON_XDIGIT | IN6PTON_DELIM; 224 if (dc - dbuf >= sizeof(dbuf)) 225 state |= IN6PTON_NULL; 226 break; 227 case IN6PTON_COLON_1|IN6PTON_COLON_1_2: 228 state = IN6PTON_XDIGIT | IN6PTON_COLON_2; 229 break; 230 case IN6PTON_COLON_1: 231 state = IN6PTON_XDIGIT; 232 break; 233 case IN6PTON_COLON_1_2: 234 state = IN6PTON_COLON_2; 235 break; 236 default: 237 state = 0; 238 } 239 tok = s + 1; 240 goto cont; 241 } 242 243 if (c & IN6PTON_DOT) { 244 ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s); 245 if (ret > 0) { 246 d += 4; 247 break; 248 } 249 goto out; 250 } 251 252 w = (w << 4) | (0xff & c); 253 state = IN6PTON_COLON_1 | IN6PTON_DELIM; 254 if (!(w & 0xf000)) { 255 state |= IN6PTON_XDIGIT; 256 } 257 if (!dc && d + 2 < dbuf + sizeof(dbuf)) { 258 state |= IN6PTON_COLON_1_2; 259 state &= ~IN6PTON_DELIM; 260 } 261 if (d + 2 >= dbuf + sizeof(dbuf)) { 262 state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2); 263 } 264 cont: 265 if ((dc && d + 4 < dbuf + sizeof(dbuf)) || 266 d + 4 == dbuf + sizeof(dbuf)) { 267 state |= IN6PTON_DOT; 268 } 269 if (d >= dbuf + sizeof(dbuf)) { 270 state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK); 271 } 272 s++; 273 srclen--; 274 } 275 276 i = 15; d--; 277 278 if (dc) { 279 while(d >= dc) 280 dst[i--] = *d--; 281 while(i >= dc - dbuf) 282 dst[i--] = 0; 283 while(i >= 0) 284 dst[i--] = *d--; 285 } else 286 memcpy(dst, dbuf, sizeof(dbuf)); 287 288 ret = 1; 289 out: 290 if (end) 291 *end = s; 292 return ret; 293 } 294 295 EXPORT_SYMBOL(in6_pton); 296