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 35 int net_msg_warn __read_mostly = 1; 36 EXPORT_SYMBOL(net_msg_warn); 37 38 DEFINE_RATELIMIT_STATE(net_ratelimit_state, 5 * HZ, 10); 39 /* 40 * All net warning printk()s should be guarded by this function. 41 */ 42 int net_ratelimit(void) 43 { 44 return __ratelimit(&net_ratelimit_state); 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 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 } 77 EXPORT_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 90 static 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 110 int 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 } 149 cont: 150 if (i >= 4) 151 goto out; 152 s++; 153 srclen--; 154 } 155 ret = 1; 156 memcpy(dst, dbuf, sizeof(dbuf)); 157 out: 158 if (end) 159 *end = s; 160 return ret; 161 } 162 EXPORT_SYMBOL(in4_pton); 163 164 int 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 } 249 cont: 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; 274 out: 275 if (end) 276 *end = s; 277 return ret; 278 } 279 EXPORT_SYMBOL(in6_pton); 280 281 void 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 } 295 EXPORT_SYMBOL(inet_proto_csum_replace4); 296 297 int 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 } 319 EXPORT_SYMBOL(mac_pton); 320