blob: 94c5d761c830e3a156501b9e0320ec16929d5564 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Generic address resultion entity
3 *
4 * Authors:
5 * net_random Alan Cox
Steven Rostedt75b31c32006-09-27 22:55:39 -07006 * net_ratelimit Andi Kleen
YOSHIFUJI Hideaki1aaec672006-06-25 23:54:55 +09007 * in{4,6}_pton YOSHIFUJI Hideaki, Copyright (C)2006 USAGI/WIDE Project
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
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>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030020#include <linux/inet.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/mm.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030022#include <linux/net.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#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
Matt Mackall5e43db72005-07-27 15:24:42 -070029#include <asm/byteorder.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <asm/system.h>
31#include <asm/uaccess.h>
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/*
34 This is a maximally equidistributed combined Tausworthe generator
35 based on code from GNU Scientific Library 1.5 (30 Jun 2004)
36
37 x_n = (s1_n ^ s2_n ^ s3_n)
38
39 s1_{n+1} = (((s1_n & 4294967294) <<12) ^ (((s1_n <<13) ^ s1_n) >>19))
40 s2_{n+1} = (((s2_n & 4294967288) << 4) ^ (((s2_n << 2) ^ s2_n) >>25))
41 s3_{n+1} = (((s3_n & 4294967280) <<17) ^ (((s3_n << 3) ^ s3_n) >>11))
42
43 The period of this generator is about 2^88.
44
45 From: P. L'Ecuyer, "Maximally Equidistributed Combined Tausworthe
46 Generators", Mathematics of Computation, 65, 213 (1996), 203--213.
47
48 This is available on the net from L'Ecuyer's home page,
49
50 http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme.ps
51 ftp://ftp.iro.umontreal.ca/pub/simulation/lecuyer/papers/tausme.ps
52
53 There is an erratum in the paper "Tables of Maximally
54 Equidistributed Combined LFSR Generators", Mathematics of
55 Computation, 68, 225 (1999), 261--269:
56 http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme2.ps
57
58 ... the k_j most significant bits of z_j must be non-
59 zero, for each j. (Note: this restriction also applies to the
60 computer code given in [4], but was mistakenly not mentioned in
61 that paper.)
62
63 This affects the seeding procedure by imposing the requirement
64 s1 > 1, s2 > 7, s3 > 15.
65
66*/
67struct nrnd_state {
68 u32 s1, s2, s3;
69};
70
71static DEFINE_PER_CPU(struct nrnd_state, net_rand_state);
72
73static u32 __net_random(struct nrnd_state *state)
74{
75#define TAUSWORTHE(s,a,b,c,d) ((s&c)<<d) ^ (((s <<a) ^ s)>>b)
76
77 state->s1 = TAUSWORTHE(state->s1, 13, 19, 4294967294UL, 12);
78 state->s2 = TAUSWORTHE(state->s2, 2, 25, 4294967288UL, 4);
79 state->s3 = TAUSWORTHE(state->s3, 3, 11, 4294967280UL, 17);
80
81 return (state->s1 ^ state->s2 ^ state->s3);
82}
83
84static void __net_srandom(struct nrnd_state *state, unsigned long s)
85{
86 if (s == 0)
87 s = 1; /* default seed is 1 */
88
89#define LCG(n) (69069 * n)
90 state->s1 = LCG(s);
91 state->s2 = LCG(state->s1);
92 state->s3 = LCG(state->s2);
93
94 /* "warm it up" */
95 __net_random(state);
96 __net_random(state);
97 __net_random(state);
98 __net_random(state);
99 __net_random(state);
100 __net_random(state);
101}
102
103
104unsigned long net_random(void)
105{
106 unsigned long r;
107 struct nrnd_state *state = &get_cpu_var(net_rand_state);
108 r = __net_random(state);
109 put_cpu_var(state);
110 return r;
111}
112
113
114void net_srandom(unsigned long entropy)
115{
116 struct nrnd_state *state = &get_cpu_var(net_rand_state);
117 __net_srandom(state, state->s1^entropy);
118 put_cpu_var(state);
119}
120
121void __init net_random_init(void)
122{
123 int i;
124
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700125 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 struct nrnd_state *state = &per_cpu(net_rand_state,i);
127 __net_srandom(state, i+jiffies);
128 }
129}
130
131static int net_random_reseed(void)
132{
133 int i;
Suresh Siddha85575112006-08-15 00:03:01 -0700134 unsigned long seed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700136 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 struct nrnd_state *state = &per_cpu(net_rand_state,i);
Suresh Siddha85575112006-08-15 00:03:01 -0700138
139 get_random_bytes(&seed, sizeof(seed));
140 __net_srandom(state, seed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 }
142 return 0;
143}
144late_initcall(net_random_reseed);
145
146int net_msg_cost = 5*HZ;
147int net_msg_burst = 10;
148
149/*
150 * All net warning printk()s should be guarded by this function.
151 */
152int net_ratelimit(void)
153{
154 return __printk_ratelimit(net_msg_cost, net_msg_burst);
155}
156
157EXPORT_SYMBOL(net_random);
158EXPORT_SYMBOL(net_ratelimit);
159EXPORT_SYMBOL(net_srandom);
Matt Mackall5e43db72005-07-27 15:24:42 -0700160
161/*
162 * Convert an ASCII string to binary IP.
163 * This is outside of net/ipv4/ because various code that uses IP addresses
164 * is otherwise not dependent on the TCP/IP stack.
165 */
166
Alexey Dobriyana2167dc2006-01-06 13:24:54 -0800167__be32 in_aton(const char *str)
Matt Mackall5e43db72005-07-27 15:24:42 -0700168{
169 unsigned long l;
170 unsigned int val;
171 int i;
172
173 l = 0;
174 for (i = 0; i < 4; i++)
175 {
176 l <<= 8;
177 if (*str != '\0')
178 {
179 val = 0;
Mitch Williams1e2e5652005-11-09 10:34:01 -0800180 while (*str != '\0' && *str != '.' && *str != '\n')
Matt Mackall5e43db72005-07-27 15:24:42 -0700181 {
182 val *= 10;
183 val += *str - '0';
184 str++;
185 }
186 l |= val;
187 if (*str != '\0')
188 str++;
189 }
190 }
191 return(htonl(l));
192}
193
194EXPORT_SYMBOL(in_aton);
YOSHIFUJI Hideaki1aaec672006-06-25 23:54:55 +0900195
196#define IN6PTON_XDIGIT 0x00010000
197#define IN6PTON_DIGIT 0x00020000
198#define IN6PTON_COLON_MASK 0x00700000
199#define IN6PTON_COLON_1 0x00100000 /* single : requested */
200#define IN6PTON_COLON_2 0x00200000 /* second : requested */
201#define IN6PTON_COLON_1_2 0x00400000 /* :: requested */
202#define IN6PTON_DOT 0x00800000 /* . */
203#define IN6PTON_DELIM 0x10000000
204#define IN6PTON_NULL 0x20000000 /* first/tail */
205#define IN6PTON_UNKNOWN 0x40000000
206
207static inline int digit2bin(char c, char delim)
208{
209 if (c == delim || c == '\0')
210 return IN6PTON_DELIM;
211 if (c == '.')
212 return IN6PTON_DOT;
213 if (c >= '0' && c <= '9')
214 return (IN6PTON_DIGIT | (c - '0'));
215 return IN6PTON_UNKNOWN;
216}
217
218static inline int xdigit2bin(char c, char delim)
219{
220 if (c == delim || c == '\0')
221 return IN6PTON_DELIM;
222 if (c == ':')
223 return IN6PTON_COLON_MASK;
224 if (c == '.')
225 return IN6PTON_DOT;
226 if (c >= '0' && c <= '9')
227 return (IN6PTON_XDIGIT | IN6PTON_DIGIT| (c - '0'));
228 if (c >= 'a' && c <= 'f')
229 return (IN6PTON_XDIGIT | (c - 'a' + 10));
230 if (c >= 'A' && c <= 'F')
231 return (IN6PTON_XDIGIT | (c - 'A' + 10));
232 return IN6PTON_UNKNOWN;
233}
234
235int in4_pton(const char *src, int srclen,
236 u8 *dst,
237 char delim, const char **end)
238{
239 const char *s;
240 u8 *d;
241 u8 dbuf[4];
242 int ret = 0;
243 int i;
244 int w = 0;
245
246 if (srclen < 0)
247 srclen = strlen(src);
248 s = src;
249 d = dbuf;
250 i = 0;
251 while(1) {
252 int c;
253 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
254 if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM))) {
255 goto out;
256 }
257 if (c & (IN6PTON_DOT | IN6PTON_DELIM)) {
258 if (w == 0)
259 goto out;
260 *d++ = w & 0xff;
261 w = 0;
262 i++;
263 if (c & IN6PTON_DELIM) {
264 if (i != 4)
265 goto out;
266 break;
267 }
268 goto cont;
269 }
270 w = (w * 10) + c;
271 if ((w & 0xffff) > 255) {
272 goto out;
273 }
274cont:
275 if (i >= 4)
276 goto out;
277 s++;
278 srclen--;
279 }
280 ret = 1;
281 memcpy(dst, dbuf, sizeof(dbuf));
282out:
283 if (end)
284 *end = s;
285 return ret;
286}
287
288EXPORT_SYMBOL(in4_pton);
289
290int in6_pton(const char *src, int srclen,
291 u8 *dst,
292 char delim, const char **end)
293{
294 const char *s, *tok = NULL;
295 u8 *d, *dc = NULL;
296 u8 dbuf[16];
297 int ret = 0;
298 int i;
299 int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
300 int w = 0;
301
302 memset(dbuf, 0, sizeof(dbuf));
303
304 s = src;
305 d = dbuf;
306 if (srclen < 0)
307 srclen = strlen(src);
308
YOSHIFUJI Hideaki1aaec672006-06-25 23:54:55 +0900309 while (1) {
310 int c;
311
312 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
313 if (!(c & state))
314 goto out;
315 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
316 /* process one 16-bit word */
317 if (!(state & IN6PTON_NULL)) {
318 *d++ = (w >> 8) & 0xff;
319 *d++ = w & 0xff;
320 }
321 w = 0;
322 if (c & IN6PTON_DELIM) {
323 /* We've processed last word */
324 break;
325 }
326 /*
327 * COLON_1 => XDIGIT
328 * COLON_2 => XDIGIT|DELIM
329 * COLON_1_2 => COLON_2
330 */
331 switch (state & IN6PTON_COLON_MASK) {
332 case IN6PTON_COLON_2:
333 dc = d;
334 state = IN6PTON_XDIGIT | IN6PTON_DELIM;
335 if (dc - dbuf >= sizeof(dbuf))
336 state |= IN6PTON_NULL;
337 break;
338 case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
339 state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
340 break;
341 case IN6PTON_COLON_1:
342 state = IN6PTON_XDIGIT;
343 break;
344 case IN6PTON_COLON_1_2:
345 state = IN6PTON_COLON_2;
346 break;
347 default:
348 state = 0;
349 }
350 tok = s + 1;
351 goto cont;
352 }
353
354 if (c & IN6PTON_DOT) {
355 ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
356 if (ret > 0) {
357 d += 4;
358 break;
359 }
360 goto out;
361 }
362
363 w = (w << 4) | (0xff & c);
364 state = IN6PTON_COLON_1 | IN6PTON_DELIM;
365 if (!(w & 0xf000)) {
366 state |= IN6PTON_XDIGIT;
367 }
368 if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
369 state |= IN6PTON_COLON_1_2;
370 state &= ~IN6PTON_DELIM;
371 }
372 if (d + 2 >= dbuf + sizeof(dbuf)) {
373 state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
374 }
375cont:
376 if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
377 d + 4 == dbuf + sizeof(dbuf)) {
378 state |= IN6PTON_DOT;
379 }
380 if (d >= dbuf + sizeof(dbuf)) {
381 state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
382 }
383 s++;
384 srclen--;
385 }
386
387 i = 15; d--;
388
389 if (dc) {
390 while(d >= dc)
391 dst[i--] = *d--;
392 while(i >= dc - dbuf)
393 dst[i--] = 0;
394 while(i >= 0)
395 dst[i--] = *d--;
396 } else
397 memcpy(dst, dbuf, sizeof(dbuf));
398
399 ret = 1;
400out:
401 if (end)
402 *end = s;
403 return ret;
404}
405
406EXPORT_SYMBOL(in6_pton);