2 * Generic address resultion entity
6 * net_ratelimit Andi Kleen
7 * in{4,6}_pton YOSHIFUJI Hideaki, Copyright (C)2006 USAGI/WIDE Project
9 * Created by Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
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.
17 #include <linux/module.h>
18 #include <linux/jiffies.h>
19 #include <linux/kernel.h>
20 #include <linux/inet.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 <linux/ratelimit.h>
30 #include <net/net_ratelimit.h>
32 #include <asm/byteorder.h>
33 #include <asm/uaccess.h>
35 int net_msg_warn __read_mostly
= 1;
36 EXPORT_SYMBOL(net_msg_warn
);
38 DEFINE_RATELIMIT_STATE(net_ratelimit_state
, 5 * HZ
, 10);
40 * All net warning printk()s should be guarded by this function.
42 int net_ratelimit(void)
44 return __ratelimit(&net_ratelimit_state
);
46 EXPORT_SYMBOL(net_ratelimit
);
49 * Convert an ASCII string to binary IP.
50 * This is outside of net/ipv4/ because various code that uses IP addresses
51 * is otherwise not dependent on the TCP/IP stack.
54 __be32
in_aton(const char *str
)
61 for (i
= 0; i
< 4; i
++) {
65 while (*str
!= '\0' && *str
!= '.' && *str
!= '\n') {
77 EXPORT_SYMBOL(in_aton
);
79 #define IN6PTON_XDIGIT 0x00010000
80 #define IN6PTON_DIGIT 0x00020000
81 #define IN6PTON_COLON_MASK 0x00700000
82 #define IN6PTON_COLON_1 0x00100000 /* single : requested */
83 #define IN6PTON_COLON_2 0x00200000 /* second : requested */
84 #define IN6PTON_COLON_1_2 0x00400000 /* :: requested */
85 #define IN6PTON_DOT 0x00800000 /* . */
86 #define IN6PTON_DELIM 0x10000000
87 #define IN6PTON_NULL 0x20000000 /* first/tail */
88 #define IN6PTON_UNKNOWN 0x40000000
90 static inline int xdigit2bin(char c
, int delim
)
94 if (c
== delim
|| c
== '\0')
97 return IN6PTON_COLON_MASK
;
103 return val
| IN6PTON_XDIGIT
| (val
< 10 ? IN6PTON_DIGIT
: 0);
106 return IN6PTON_DELIM
;
107 return IN6PTON_UNKNOWN
;
111 * in4_pton - convert an IPv4 address from literal to binary representation
112 * @src: the start of the IPv4 address string
113 * @srclen: the length of the string, -1 means strlen(src)
114 * @dst: the binary (u8[4] array) representation of the IPv4 address
115 * @delim: the delimiter of the IPv4 address in @src, -1 means no delimiter
116 * @end: A pointer to the end of the parsed string will be placed here
118 * Return one on success, return zero when any error occurs
119 * and @end will point to the end of the parsed string.
122 int in4_pton(const char *src
, int srclen
,
124 int delim
, const char **end
)
134 srclen
= strlen(src
);
140 c
= xdigit2bin(srclen
> 0 ? *s
: '\0', delim
);
141 if (!(c
& (IN6PTON_DIGIT
| IN6PTON_DOT
| IN6PTON_DELIM
| IN6PTON_COLON_MASK
))) {
144 if (c
& (IN6PTON_DOT
| IN6PTON_DELIM
| IN6PTON_COLON_MASK
)) {
150 if (c
& (IN6PTON_DELIM
| IN6PTON_COLON_MASK
)) {
158 if ((w
& 0xffff) > 255) {
168 memcpy(dst
, dbuf
, sizeof(dbuf
));
174 EXPORT_SYMBOL(in4_pton
);
177 * in6_pton - convert an IPv6 address from literal to binary representation
178 * @src: the start of the IPv6 address string
179 * @srclen: the length of the string, -1 means strlen(src)
180 * @dst: the binary (u8[16] array) representation of the IPv6 address
181 * @delim: the delimiter of the IPv6 address in @src, -1 means no delimiter
182 * @end: A pointer to the end of the parsed string will be placed here
184 * Return one on success, return zero when any error occurs
185 * and @end will point to the end of the parsed string.
188 int in6_pton(const char *src
, int srclen
,
190 int delim
, const char **end
)
192 const char *s
, *tok
= NULL
;
197 int state
= IN6PTON_COLON_1_2
| IN6PTON_XDIGIT
| IN6PTON_NULL
;
200 memset(dbuf
, 0, sizeof(dbuf
));
205 srclen
= strlen(src
);
210 c
= xdigit2bin(srclen
> 0 ? *s
: '\0', delim
);
213 if (c
& (IN6PTON_DELIM
| IN6PTON_COLON_MASK
)) {
214 /* process one 16-bit word */
215 if (!(state
& IN6PTON_NULL
)) {
216 *d
++ = (w
>> 8) & 0xff;
220 if (c
& IN6PTON_DELIM
) {
221 /* We've processed last word */
226 * COLON_2 => XDIGIT|DELIM
227 * COLON_1_2 => COLON_2
229 switch (state
& IN6PTON_COLON_MASK
) {
230 case IN6PTON_COLON_2
:
232 state
= IN6PTON_XDIGIT
| IN6PTON_DELIM
;
233 if (dc
- dbuf
>= sizeof(dbuf
))
234 state
|= IN6PTON_NULL
;
236 case IN6PTON_COLON_1
|IN6PTON_COLON_1_2
:
237 state
= IN6PTON_XDIGIT
| IN6PTON_COLON_2
;
239 case IN6PTON_COLON_1
:
240 state
= IN6PTON_XDIGIT
;
242 case IN6PTON_COLON_1_2
:
243 state
= IN6PTON_COLON_2
;
252 if (c
& IN6PTON_DOT
) {
253 ret
= in4_pton(tok
? tok
: s
, srclen
+ (int)(s
- tok
), d
, delim
, &s
);
261 w
= (w
<< 4) | (0xff & c
);
262 state
= IN6PTON_COLON_1
| IN6PTON_DELIM
;
264 state
|= IN6PTON_XDIGIT
;
266 if (!dc
&& d
+ 2 < dbuf
+ sizeof(dbuf
)) {
267 state
|= IN6PTON_COLON_1_2
;
268 state
&= ~IN6PTON_DELIM
;
270 if (d
+ 2 >= dbuf
+ sizeof(dbuf
)) {
271 state
&= ~(IN6PTON_COLON_1
|IN6PTON_COLON_1_2
);
274 if ((dc
&& d
+ 4 < dbuf
+ sizeof(dbuf
)) ||
275 d
+ 4 == dbuf
+ sizeof(dbuf
)) {
276 state
|= IN6PTON_DOT
;
278 if (d
>= dbuf
+ sizeof(dbuf
)) {
279 state
&= ~(IN6PTON_XDIGIT
|IN6PTON_COLON_MASK
);
290 while(i
>= dc
- dbuf
)
295 memcpy(dst
, dbuf
, sizeof(dbuf
));
303 EXPORT_SYMBOL(in6_pton
);
305 void inet_proto_csum_replace4(__sum16
*sum
, struct sk_buff
*skb
,
306 __be32 from
, __be32 to
, int pseudohdr
)
308 __be32 diff
[] = { ~from
, to
};
309 if (skb
->ip_summed
!= CHECKSUM_PARTIAL
) {
310 *sum
= csum_fold(csum_partial(diff
, sizeof(diff
),
311 ~csum_unfold(*sum
)));
312 if (skb
->ip_summed
== CHECKSUM_COMPLETE
&& pseudohdr
)
313 skb
->csum
= ~csum_partial(diff
, sizeof(diff
),
315 } else if (pseudohdr
)
316 *sum
= ~csum_fold(csum_partial(diff
, sizeof(diff
),
319 EXPORT_SYMBOL(inet_proto_csum_replace4
);
321 void inet_proto_csum_replace16(__sum16
*sum
, struct sk_buff
*skb
,
322 const __be32
*from
, const __be32
*to
,
326 ~from
[0], ~from
[1], ~from
[2], ~from
[3],
327 to
[0], to
[1], to
[2], to
[3],
329 if (skb
->ip_summed
!= CHECKSUM_PARTIAL
) {
330 *sum
= csum_fold(csum_partial(diff
, sizeof(diff
),
331 ~csum_unfold(*sum
)));
332 if (skb
->ip_summed
== CHECKSUM_COMPLETE
&& pseudohdr
)
333 skb
->csum
= ~csum_partial(diff
, sizeof(diff
),
335 } else if (pseudohdr
)
336 *sum
= ~csum_fold(csum_partial(diff
, sizeof(diff
),
339 EXPORT_SYMBOL(inet_proto_csum_replace16
);
341 int mac_pton(const char *s
, u8
*mac
)
345 /* XX:XX:XX:XX:XX:XX */
346 if (strlen(s
) < 3 * ETH_ALEN
- 1)
349 /* Don't dirty result unless string is valid MAC. */
350 for (i
= 0; i
< ETH_ALEN
; i
++) {
351 if (!strchr("0123456789abcdefABCDEF", s
[i
* 3]))
353 if (!strchr("0123456789abcdefABCDEF", s
[i
* 3 + 1]))
355 if (i
!= ETH_ALEN
- 1 && s
[i
* 3 + 2] != ':')
358 for (i
= 0; i
< ETH_ALEN
; i
++) {
359 mac
[i
] = (hex_to_bin(s
[i
* 3]) << 4) | hex_to_bin(s
[i
* 3 + 1]);
363 EXPORT_SYMBOL(mac_pton
);