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/ctype.h> 21 #include <linux/inet.h> 22 #include <linux/mm.h> 23 #include <linux/net.h> 24 #include <linux/string.h> 25 #include <linux/types.h> 26 #include <linux/percpu.h> 27 #include <linux/init.h> 28 #include <linux/ratelimit.h> 29 30 #include <net/sock.h> 31 #include <net/net_ratelimit.h> 32 33 #include <asm/byteorder.h> 34 #include <asm/uaccess.h> 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 l <<= 8; 61 if (*str != '\0') { 62 val = 0; 63 while (*str != '\0' && *str != '.' && *str != '\n') { 64 val *= 10; 65 val += *str - '0'; 66 str++; 67 } 68 l |= val; 69 if (*str != '\0') 70 str++; 71 } 72 } 73 return htonl(l); 74 } 75 EXPORT_SYMBOL(in_aton); 76 77 #define IN6PTON_XDIGIT 0x00010000 78 #define IN6PTON_DIGIT 0x00020000 79 #define IN6PTON_COLON_MASK 0x00700000 80 #define IN6PTON_COLON_1 0x00100000 /* single : requested */ 81 #define IN6PTON_COLON_2 0x00200000 /* second : requested */ 82 #define IN6PTON_COLON_1_2 0x00400000 /* :: requested */ 83 #define IN6PTON_DOT 0x00800000 /* . */ 84 #define IN6PTON_DELIM 0x10000000 85 #define IN6PTON_NULL 0x20000000 /* first/tail */ 86 #define IN6PTON_UNKNOWN 0x40000000 87 88 static inline int xdigit2bin(char c, int delim) 89 { 90 int val; 91 92 if (c == delim || c == '\0') 93 return IN6PTON_DELIM; 94 if (c == ':') 95 return IN6PTON_COLON_MASK; 96 if (c == '.') 97 return IN6PTON_DOT; 98 99 val = hex_to_bin(c); 100 if (val >= 0) 101 return val | IN6PTON_XDIGIT | (val < 10 ? IN6PTON_DIGIT : 0); 102 103 if (delim == -1) 104 return IN6PTON_DELIM; 105 return IN6PTON_UNKNOWN; 106 } 107 108 /** 109 * in4_pton - convert an IPv4 address from literal to binary representation 110 * @src: the start of the IPv4 address string 111 * @srclen: the length of the string, -1 means strlen(src) 112 * @dst: the binary (u8[4] array) representation of the IPv4 address 113 * @delim: the delimiter of the IPv4 address in @src, -1 means no delimiter 114 * @end: A pointer to the end of the parsed string will be placed here 115 * 116 * Return one on success, return zero when any error occurs 117 * and @end will point to the end of the parsed string. 118 * 119 */ 120 int in4_pton(const char *src, int srclen, 121 u8 *dst, 122 int delim, const char **end) 123 { 124 const char *s; 125 u8 *d; 126 u8 dbuf[4]; 127 int ret = 0; 128 int i; 129 int w = 0; 130 131 if (srclen < 0) 132 srclen = strlen(src); 133 s = src; 134 d = dbuf; 135 i = 0; 136 while(1) { 137 int c; 138 c = xdigit2bin(srclen > 0 ? *s : '\0', delim); 139 if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) { 140 goto out; 141 } 142 if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) { 143 if (w == 0) 144 goto out; 145 *d++ = w & 0xff; 146 w = 0; 147 i++; 148 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) { 149 if (i != 4) 150 goto out; 151 break; 152 } 153 goto cont; 154 } 155 w = (w * 10) + c; 156 if ((w & 0xffff) > 255) { 157 goto out; 158 } 159 cont: 160 if (i >= 4) 161 goto out; 162 s++; 163 srclen--; 164 } 165 ret = 1; 166 memcpy(dst, dbuf, sizeof(dbuf)); 167 out: 168 if (end) 169 *end = s; 170 return ret; 171 } 172 EXPORT_SYMBOL(in4_pton); 173 174 /** 175 * in6_pton - convert an IPv6 address from literal to binary representation 176 * @src: the start of the IPv6 address string 177 * @srclen: the length of the string, -1 means strlen(src) 178 * @dst: the binary (u8[16] array) representation of the IPv6 address 179 * @delim: the delimiter of the IPv6 address in @src, -1 means no delimiter 180 * @end: A pointer to the end of the parsed string will be placed here 181 * 182 * Return one on success, return zero when any error occurs 183 * and @end will point to the end of the parsed string. 184 * 185 */ 186 int in6_pton(const char *src, int srclen, 187 u8 *dst, 188 int delim, const char **end) 189 { 190 const char *s, *tok = NULL; 191 u8 *d, *dc = NULL; 192 u8 dbuf[16]; 193 int ret = 0; 194 int i; 195 int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL; 196 int w = 0; 197 198 memset(dbuf, 0, sizeof(dbuf)); 199 200 s = src; 201 d = dbuf; 202 if (srclen < 0) 203 srclen = strlen(src); 204 205 while (1) { 206 int c; 207 208 c = xdigit2bin(srclen > 0 ? *s : '\0', delim); 209 if (!(c & state)) 210 goto out; 211 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) { 212 /* process one 16-bit word */ 213 if (!(state & IN6PTON_NULL)) { 214 *d++ = (w >> 8) & 0xff; 215 *d++ = w & 0xff; 216 } 217 w = 0; 218 if (c & IN6PTON_DELIM) { 219 /* We've processed last word */ 220 break; 221 } 222 /* 223 * COLON_1 => XDIGIT 224 * COLON_2 => XDIGIT|DELIM 225 * COLON_1_2 => COLON_2 226 */ 227 switch (state & IN6PTON_COLON_MASK) { 228 case IN6PTON_COLON_2: 229 dc = d; 230 state = IN6PTON_XDIGIT | IN6PTON_DELIM; 231 if (dc - dbuf >= sizeof(dbuf)) 232 state |= IN6PTON_NULL; 233 break; 234 case IN6PTON_COLON_1|IN6PTON_COLON_1_2: 235 state = IN6PTON_XDIGIT | IN6PTON_COLON_2; 236 break; 237 case IN6PTON_COLON_1: 238 state = IN6PTON_XDIGIT; 239 break; 240 case IN6PTON_COLON_1_2: 241 state = IN6PTON_COLON_2; 242 break; 243 default: 244 state = 0; 245 } 246 tok = s + 1; 247 goto cont; 248 } 249 250 if (c & IN6PTON_DOT) { 251 ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s); 252 if (ret > 0) { 253 d += 4; 254 break; 255 } 256 goto out; 257 } 258 259 w = (w << 4) | (0xff & c); 260 state = IN6PTON_COLON_1 | IN6PTON_DELIM; 261 if (!(w & 0xf000)) { 262 state |= IN6PTON_XDIGIT; 263 } 264 if (!dc && d + 2 < dbuf + sizeof(dbuf)) { 265 state |= IN6PTON_COLON_1_2; 266 state &= ~IN6PTON_DELIM; 267 } 268 if (d + 2 >= dbuf + sizeof(dbuf)) { 269 state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2); 270 } 271 cont: 272 if ((dc && d + 4 < dbuf + sizeof(dbuf)) || 273 d + 4 == dbuf + sizeof(dbuf)) { 274 state |= IN6PTON_DOT; 275 } 276 if (d >= dbuf + sizeof(dbuf)) { 277 state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK); 278 } 279 s++; 280 srclen--; 281 } 282 283 i = 15; d--; 284 285 if (dc) { 286 while(d >= dc) 287 dst[i--] = *d--; 288 while(i >= dc - dbuf) 289 dst[i--] = 0; 290 while(i >= 0) 291 dst[i--] = *d--; 292 } else 293 memcpy(dst, dbuf, sizeof(dbuf)); 294 295 ret = 1; 296 out: 297 if (end) 298 *end = s; 299 return ret; 300 } 301 EXPORT_SYMBOL(in6_pton); 302 303 void inet_proto_csum_replace4(__sum16 *sum, struct sk_buff *skb, 304 __be32 from, __be32 to, int pseudohdr) 305 { 306 if (skb->ip_summed != CHECKSUM_PARTIAL) { 307 *sum = csum_fold(csum_add(csum_sub(~csum_unfold(*sum), from), 308 to)); 309 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr) 310 skb->csum = ~csum_add(csum_sub(~(skb->csum), from), to); 311 } else if (pseudohdr) 312 *sum = ~csum_fold(csum_add(csum_sub(csum_unfold(*sum), from), 313 to)); 314 } 315 EXPORT_SYMBOL(inet_proto_csum_replace4); 316 317 void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb, 318 const __be32 *from, const __be32 *to, 319 int pseudohdr) 320 { 321 __be32 diff[] = { 322 ~from[0], ~from[1], ~from[2], ~from[3], 323 to[0], to[1], to[2], to[3], 324 }; 325 if (skb->ip_summed != CHECKSUM_PARTIAL) { 326 *sum = csum_fold(csum_partial(diff, sizeof(diff), 327 ~csum_unfold(*sum))); 328 if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr) 329 skb->csum = ~csum_partial(diff, sizeof(diff), 330 ~skb->csum); 331 } else if (pseudohdr) 332 *sum = ~csum_fold(csum_partial(diff, sizeof(diff), 333 csum_unfold(*sum))); 334 } 335 EXPORT_SYMBOL(inet_proto_csum_replace16); 336 337 struct __net_random_once_work { 338 struct work_struct work; 339 struct static_key *key; 340 }; 341 342 static void __net_random_once_deferred(struct work_struct *w) 343 { 344 struct __net_random_once_work *work = 345 container_of(w, struct __net_random_once_work, work); 346 BUG_ON(!static_key_enabled(work->key)); 347 static_key_slow_dec(work->key); 348 kfree(work); 349 } 350 351 static void __net_random_once_disable_jump(struct static_key *key) 352 { 353 struct __net_random_once_work *w; 354 355 w = kmalloc(sizeof(*w), GFP_ATOMIC); 356 if (!w) 357 return; 358 359 INIT_WORK(&w->work, __net_random_once_deferred); 360 w->key = key; 361 schedule_work(&w->work); 362 } 363 364 bool __net_get_random_once(void *buf, int nbytes, bool *done, 365 struct static_key *once_key) 366 { 367 static DEFINE_SPINLOCK(lock); 368 unsigned long flags; 369 370 spin_lock_irqsave(&lock, flags); 371 if (*done) { 372 spin_unlock_irqrestore(&lock, flags); 373 return false; 374 } 375 376 get_random_bytes(buf, nbytes); 377 *done = true; 378 spin_unlock_irqrestore(&lock, flags); 379 380 __net_random_once_disable_jump(once_key); 381 382 return true; 383 } 384 EXPORT_SYMBOL(__net_get_random_once); 385