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