net: Fix for dst_negative_advice
[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/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);