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