[DCCP] ACKVEC: Optimization - Do not traverse records if none will be found
[linux-2.6.git] / 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, char 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, char 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         return IN6PTON_UNKNOWN;
117 }
118
119 int in4_pton(const char *src, int srclen,
120              u8 *dst,
121              char delim, const char **end)
122 {
123         const char *s;
124         u8 *d;
125         u8 dbuf[4];
126         int ret = 0;
127         int i;
128         int w = 0;
129
130         if (srclen < 0)
131                 srclen = strlen(src);
132         s = src;
133         d = dbuf;
134         i = 0;
135         while(1) {
136                 int c;
137                 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
138                 if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM))) {
139                         goto out;
140                 }
141                 if (c & (IN6PTON_DOT | IN6PTON_DELIM)) {
142                         if (w == 0)
143                                 goto out;
144                         *d++ = w & 0xff;
145                         w = 0;
146                         i++;
147                         if (c & IN6PTON_DELIM) {
148                                 if (i != 4)
149                                         goto out;
150                                 break;
151                         }
152                         goto cont;
153                 }
154                 w = (w * 10) + c;
155                 if ((w & 0xffff) > 255) {
156                         goto out;
157                 }
158 cont:
159                 if (i >= 4)
160                         goto out;
161                 s++;
162                 srclen--;
163         }
164         ret = 1;
165         memcpy(dst, dbuf, sizeof(dbuf));
166 out:
167         if (end)
168                 *end = s;
169         return ret;
170 }
171
172 EXPORT_SYMBOL(in4_pton);
173
174 int in6_pton(const char *src, int srclen,
175              u8 *dst,
176              char delim, const char **end)
177 {
178         const char *s, *tok = NULL;
179         u8 *d, *dc = NULL;
180         u8 dbuf[16];
181         int ret = 0;
182         int i;
183         int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
184         int w = 0;
185
186         memset(dbuf, 0, sizeof(dbuf));
187
188         s = src;
189         d = dbuf;
190         if (srclen < 0)
191                 srclen = strlen(src);
192
193         while (1) {
194                 int c;
195
196                 c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
197                 if (!(c & state))
198                         goto out;
199                 if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
200                         /* process one 16-bit word */
201                         if (!(state & IN6PTON_NULL)) {
202                                 *d++ = (w >> 8) & 0xff;
203                                 *d++ = w & 0xff;
204                         }
205                         w = 0;
206                         if (c & IN6PTON_DELIM) {
207                                 /* We've processed last word */
208                                 break;
209                         }
210                         /*
211                          * COLON_1 => XDIGIT
212                          * COLON_2 => XDIGIT|DELIM
213                          * COLON_1_2 => COLON_2
214                          */
215                         switch (state & IN6PTON_COLON_MASK) {
216                         case IN6PTON_COLON_2:
217                                 dc = d;
218                                 state = IN6PTON_XDIGIT | IN6PTON_DELIM;
219                                 if (dc - dbuf >= sizeof(dbuf))
220                                         state |= IN6PTON_NULL;
221                                 break;
222                         case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
223                                 state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
224                                 break;
225                         case IN6PTON_COLON_1:
226                                 state = IN6PTON_XDIGIT;
227                                 break;
228                         case IN6PTON_COLON_1_2:
229                                 state = IN6PTON_COLON_2;
230                                 break;
231                         default:
232                                 state = 0;
233                         }
234                         tok = s + 1;
235                         goto cont;
236                 }
237
238                 if (c & IN6PTON_DOT) {
239                         ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
240                         if (ret > 0) {
241                                 d += 4;
242                                 break;
243                         }
244                         goto out;
245                 }
246
247                 w = (w << 4) | (0xff & c);
248                 state = IN6PTON_COLON_1 | IN6PTON_DELIM;
249                 if (!(w & 0xf000)) {
250                         state |= IN6PTON_XDIGIT;
251                 }
252                 if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
253                         state |= IN6PTON_COLON_1_2;
254                         state &= ~IN6PTON_DELIM;
255                 }
256                 if (d + 2 >= dbuf + sizeof(dbuf)) {
257                         state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
258                 }
259 cont:
260                 if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
261                     d + 4 == dbuf + sizeof(dbuf)) {
262                         state |= IN6PTON_DOT;
263                 }
264                 if (d >= dbuf + sizeof(dbuf)) {
265                         state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
266                 }
267                 s++;
268                 srclen--;
269         }
270
271         i = 15; d--;
272
273         if (dc) {
274                 while(d >= dc)
275                         dst[i--] = *d--;
276                 while(i >= dc - dbuf)
277                         dst[i--] = 0;
278                 while(i >= 0)
279                         dst[i--] = *d--;
280         } else
281                 memcpy(dst, dbuf, sizeof(dbuf));
282
283         ret = 1;
284 out:
285         if (end)
286                 *end = s;
287         return ret;
288 }
289
290 EXPORT_SYMBOL(in6_pton);