[PATCH] sysctl: remove unused "context" param
[linux-2.6] / net / core / utils.c
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/random.h>
26 #include <linux/percpu.h>
27 #include <linux/init.h>
28
29 #include <asm/byteorder.h>
30 #include <asm/system.h>
31 #include <asm/uaccess.h>
32
33 int net_msg_cost = 5*HZ;
34 int net_msg_burst = 10;
35
36 /* 
37  * All net warning printk()s should be guarded by this function.
38  */ 
39 int net_ratelimit(void)
40 {
41         return __printk_ratelimit(net_msg_cost, net_msg_burst);
42 }
43 EXPORT_SYMBOL(net_ratelimit);
44
45 /*
46  * Convert an ASCII string to binary IP.
47  * This is outside of net/ipv4/ because various code that uses IP addresses
48  * is otherwise not dependent on the TCP/IP stack.
49  */
50
51 __be32 in_aton(const char *str)
52 {
53         unsigned long l;
54         unsigned int val;
55         int i;
56
57         l = 0;
58         for (i = 0; i < 4; i++)
59         {
60                 l <<= 8;
61                 if (*str != '\0')
62                 {
63                         val = 0;
64                         while (*str != '\0' && *str != '.' && *str != '\n')
65                         {
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
78 EXPORT_SYMBOL(in_aton);
79
80 #define IN6PTON_XDIGIT          0x00010000
81 #define IN6PTON_DIGIT           0x00020000
82 #define IN6PTON_COLON_MASK      0x00700000
83 #define IN6PTON_COLON_1         0x00100000      /* single : requested */
84 #define IN6PTON_COLON_2         0x00200000      /* second : requested */
85 #define IN6PTON_COLON_1_2       0x00400000      /* :: requested */
86 #define IN6PTON_DOT             0x00800000      /* . */
87 #define IN6PTON_DELIM           0x10000000
88 #define IN6PTON_NULL            0x20000000      /* first/tail */
89 #define IN6PTON_UNKNOWN         0x40000000
90
91 static inline int digit2bin(char c, int delim)
92 {
93         if (c == delim || c == '\0')
94                 return IN6PTON_DELIM;
95         if (c == '.')
96                 return IN6PTON_DOT;
97         if (c >= '0' && c <= '9')
98                 return (IN6PTON_DIGIT | (c - '0'));
99         return IN6PTON_UNKNOWN;
100 }
101
102 static inline int xdigit2bin(char c, int delim)
103 {
104         if (c == delim || c == '\0')
105                 return IN6PTON_DELIM;
106         if (c == ':')
107                 return IN6PTON_COLON_MASK;
108         if (c == '.')
109                 return IN6PTON_DOT;
110         if (c >= '0' && c <= '9')
111                 return (IN6PTON_XDIGIT | IN6PTON_DIGIT| (c - '0'));
112         if (c >= 'a' && c <= 'f')
113                 return (IN6PTON_XDIGIT | (c - 'a' + 10));
114         if (c >= 'A' && c <= 'F')
115                 return (IN6PTON_XDIGIT | (c - 'A' + 10));
116         if (delim == -1)
117                 return IN6PTON_DELIM;
118         return IN6PTON_UNKNOWN;
119 }
120
121 int in4_pton(const char *src, int srclen,
122              u8 *dst,
123              int delim, const char **end)
124 {
125         const char *s;
126         u8 *d;
127         u8 dbuf[4];
128         int ret = 0;
129         int i;
130         int w = 0;
131
132         if (srclen < 0)
133                 srclen = strlen(src);
134         s = src;
135         d = dbuf;
136         i = 0;
137         while(1) {
138                 int c;
139                 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
140                 if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM))) {
141                         goto out;
142                 }
143                 if (c & (IN6PTON_DOT | IN6PTON_DELIM)) {
144                         if (w == 0)
145                                 goto out;
146                         *d++ = w & 0xff;
147                         w = 0;
148                         i++;
149                         if (c & IN6PTON_DELIM) {
150                                 if (i != 4)
151                                         goto out;
152                                 break;
153                         }
154                         goto cont;
155                 }
156                 w = (w * 10) + c;
157                 if ((w & 0xffff) > 255) {
158                         goto out;
159                 }
160 cont:
161                 if (i >= 4)
162                         goto out;
163                 s++;
164                 srclen--;
165         }
166         ret = 1;
167         memcpy(dst, dbuf, sizeof(dbuf));
168 out:
169         if (end)
170                 *end = s;
171         return ret;
172 }
173
174 EXPORT_SYMBOL(in4_pton);
175
176 int in6_pton(const char *src, int srclen,
177              u8 *dst,
178              int delim, const char **end)
179 {
180         const char *s, *tok = NULL;
181         u8 *d, *dc = NULL;
182         u8 dbuf[16];
183         int ret = 0;
184         int i;
185         int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
186         int w = 0;
187
188         memset(dbuf, 0, sizeof(dbuf));
189
190         s = src;
191         d = dbuf;
192         if (srclen < 0)
193                 srclen = strlen(src);
194
195         while (1) {
196                 int c;
197
198                 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
199                 if (!(c & state))
200                         goto out;
201                 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
202                         /* process one 16-bit word */
203                         if (!(state & IN6PTON_NULL)) {
204                                 *d++ = (w >> 8) & 0xff;
205                                 *d++ = w & 0xff;
206                         }
207                         w = 0;
208                         if (c & IN6PTON_DELIM) {
209                                 /* We've processed last word */
210                                 break;
211                         }
212                         /*
213                          * COLON_1 => XDIGIT
214                          * COLON_2 => XDIGIT|DELIM
215                          * COLON_1_2 => COLON_2
216                          */
217                         switch (state & IN6PTON_COLON_MASK) {
218                         case IN6PTON_COLON_2:
219                                 dc = d;
220                                 state = IN6PTON_XDIGIT | IN6PTON_DELIM;
221                                 if (dc - dbuf >= sizeof(dbuf))
222                                         state |= IN6PTON_NULL;
223                                 break;
224                         case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
225                                 state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
226                                 break;
227                         case IN6PTON_COLON_1:
228                                 state = IN6PTON_XDIGIT;
229                                 break;
230                         case IN6PTON_COLON_1_2:
231                                 state = IN6PTON_COLON_2;
232                                 break;
233                         default:
234                                 state = 0;
235                         }
236                         tok = s + 1;
237                         goto cont;
238                 }
239
240                 if (c & IN6PTON_DOT) {
241                         ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
242                         if (ret > 0) {
243                                 d += 4;
244                                 break;
245                         }
246                         goto out;
247                 }
248
249                 w = (w << 4) | (0xff & c);
250                 state = IN6PTON_COLON_1 | IN6PTON_DELIM;
251                 if (!(w & 0xf000)) {
252                         state |= IN6PTON_XDIGIT;
253                 }
254                 if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
255                         state |= IN6PTON_COLON_1_2;
256                         state &= ~IN6PTON_DELIM;
257                 }
258                 if (d + 2 >= dbuf + sizeof(dbuf)) {
259                         state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
260                 }
261 cont:
262                 if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
263                     d + 4 == dbuf + sizeof(dbuf)) {
264                         state |= IN6PTON_DOT;
265                 }
266                 if (d >= dbuf + sizeof(dbuf)) {
267                         state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
268                 }
269                 s++;
270                 srclen--;
271         }
272
273         i = 15; d--;
274
275         if (dc) {
276                 while(d >= dc)
277                         dst[i--] = *d--;
278                 while(i >= dc - dbuf)
279                         dst[i--] = 0;
280                 while(i >= 0)
281                         dst[i--] = *d--;
282         } else
283                 memcpy(dst, dbuf, sizeof(dbuf));
284
285         ret = 1;
286 out:
287         if (end)
288                 *end = s;
289         return ret;
290 }
291
292 EXPORT_SYMBOL(in6_pton);