URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [net/] [core/] [utils.c] - Blame information for rev 17

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *      Generic address resultion entity
 *
 *      Authors:
 *      net_random Alan Cox
 *      net_ratelimit Andi Kleen
 *      in{4,6}_pton YOSHIFUJI Hideaki, Copyright (C)2006 USAGI/WIDE Project
 *
 *      Created by Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */
 
#include <linux/module.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/inet.h>
#include <linux/mm.h>
#include <linux/net.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/random.h>
#include <linux/percpu.h>
#include <linux/init.h>
#include <net/sock.h>
 
#include <asm/byteorder.h>
#include <asm/system.h>
#include <asm/uaccess.h>
 
int net_msg_cost __read_mostly = 5*HZ;
int net_msg_burst __read_mostly = 10;
int net_msg_warn __read_mostly = 1;
EXPORT_SYMBOL(net_msg_warn);
 
/*
 * All net warning printk()s should be guarded by this function.
 */
int net_ratelimit(void)
{
        return __printk_ratelimit(net_msg_cost, net_msg_burst);
}
EXPORT_SYMBOL(net_ratelimit);
 
/*
 * Convert an ASCII string to binary IP.
 * This is outside of net/ipv4/ because various code that uses IP addresses
 * is otherwise not dependent on the TCP/IP stack.
 */
 
__be32 in_aton(const char *str)
{
        unsigned long l;
        unsigned int val;
        int i;
 
        l = 0;
        for (i = 0; i < 4; i++)
        {
                l <<= 8;
                if (*str != '\0')
                {
                        val = 0;
                        while (*str != '\0' && *str != '.' && *str != '\n')
                        {
                                val *= 10;
                                val += *str - '0';
                                str++;
                        }
                        l |= val;
                        if (*str != '\0')
                                str++;
                }
        }
        return(htonl(l));
}
 
EXPORT_SYMBOL(in_aton);
 
#define IN6PTON_XDIGIT          0x00010000
#define IN6PTON_DIGIT           0x00020000
#define IN6PTON_COLON_MASK      0x00700000
#define IN6PTON_COLON_1         0x00100000      /* single : requested */
#define IN6PTON_COLON_2         0x00200000      /* second : requested */
#define IN6PTON_COLON_1_2       0x00400000      /* :: requested */
#define IN6PTON_DOT             0x00800000      /* . */
#define IN6PTON_DELIM           0x10000000
#define IN6PTON_NULL            0x20000000      /* first/tail */
#define IN6PTON_UNKNOWN         0x40000000
 
static inline int digit2bin(char c, int delim)
{
        if (c == delim || c == '\0')
                return IN6PTON_DELIM;
        if (c == '.')
                return IN6PTON_DOT;
        if (c >= '0' && c <= '9')
                return (IN6PTON_DIGIT | (c - '0'));
        return IN6PTON_UNKNOWN;
}
 
static inline int xdigit2bin(char c, int delim)
{
        if (c == delim || c == '\0')
                return IN6PTON_DELIM;
        if (c == ':')
                return IN6PTON_COLON_MASK;
        if (c == '.')
                return IN6PTON_DOT;
        if (c >= '0' && c <= '9')
                return (IN6PTON_XDIGIT | IN6PTON_DIGIT| (c - '0'));
        if (c >= 'a' && c <= 'f')
                return (IN6PTON_XDIGIT | (c - 'a' + 10));
        if (c >= 'A' && c <= 'F')
                return (IN6PTON_XDIGIT | (c - 'A' + 10));
        if (delim == -1)
                return IN6PTON_DELIM;
        return IN6PTON_UNKNOWN;
}
 
int in4_pton(const char *src, int srclen,
             u8 *dst,
             int delim, const char **end)
{
        const char *s;
        u8 *d;
        u8 dbuf[4];
        int ret = 0;
        int i;
        int w = 0;
 
        if (srclen < 0)
                srclen = strlen(src);
        s = src;
        d = dbuf;
        i = 0;
        while(1) {
                int c;
                c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
                if (!(c & (IN6PTON_DIGIT | IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK))) {
                        goto out;
                }
                if (c & (IN6PTON_DOT | IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
                        if (w == 0)
                                goto out;
                        *d++ = w & 0xff;
                        w = 0;
                        i++;
                        if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
                                if (i != 4)
                                        goto out;
                                break;
                        }
                        goto cont;
                }
                w = (w * 10) + c;
                if ((w & 0xffff) > 255) {
                        goto out;
                }
cont:
                if (i >= 4)
                        goto out;
                s++;
                srclen--;
        }
        ret = 1;
        memcpy(dst, dbuf, sizeof(dbuf));
out:
        if (end)
                *end = s;
        return ret;
}
 
EXPORT_SYMBOL(in4_pton);
 
int in6_pton(const char *src, int srclen,
             u8 *dst,
             int delim, const char **end)
{
        const char *s, *tok = NULL;
        u8 *d, *dc = NULL;
        u8 dbuf[16];
        int ret = 0;
        int i;
        int state = IN6PTON_COLON_1_2 | IN6PTON_XDIGIT | IN6PTON_NULL;
        int w = 0;
 
        memset(dbuf, 0, sizeof(dbuf));
 
        s = src;
        d = dbuf;
        if (srclen < 0)
                srclen = strlen(src);
 
        while (1) {
                int c;
 
                c = xdigit2bin(srclen > 0 ? *s : '\0', delim);
                if (!(c & state))
                        goto out;
                if (c & (IN6PTON_DELIM | IN6PTON_COLON_MASK)) {
                        /* process one 16-bit word */
                        if (!(state & IN6PTON_NULL)) {
                                *d++ = (w >> 8) & 0xff;
                                *d++ = w & 0xff;
                        }
                        w = 0;
                        if (c & IN6PTON_DELIM) {
                                /* We've processed last word */
                                break;
                        }
                        /*
                         * COLON_1 => XDIGIT
                         * COLON_2 => XDIGIT|DELIM
                         * COLON_1_2 => COLON_2
                         */
                        switch (state & IN6PTON_COLON_MASK) {
                        case IN6PTON_COLON_2:
                                dc = d;
                                state = IN6PTON_XDIGIT | IN6PTON_DELIM;
                                if (dc - dbuf >= sizeof(dbuf))
                                        state |= IN6PTON_NULL;
                                break;
                        case IN6PTON_COLON_1|IN6PTON_COLON_1_2:
                                state = IN6PTON_XDIGIT | IN6PTON_COLON_2;
                                break;
                        case IN6PTON_COLON_1:
                                state = IN6PTON_XDIGIT;
                                break;
                        case IN6PTON_COLON_1_2:
                                state = IN6PTON_COLON_2;
                                break;
                        default:
                                state = 0;
                        }
                        tok = s + 1;
                        goto cont;
                }
 
                if (c & IN6PTON_DOT) {
                        ret = in4_pton(tok ? tok : s, srclen + (int)(s - tok), d, delim, &s);
                        if (ret > 0) {
                                d += 4;
                                break;
                        }
                        goto out;
                }
 
                w = (w << 4) | (0xff & c);
                state = IN6PTON_COLON_1 | IN6PTON_DELIM;
                if (!(w & 0xf000)) {
                        state |= IN6PTON_XDIGIT;
                }
                if (!dc && d + 2 < dbuf + sizeof(dbuf)) {
                        state |= IN6PTON_COLON_1_2;
                        state &= ~IN6PTON_DELIM;
                }
                if (d + 2 >= dbuf + sizeof(dbuf)) {
                        state &= ~(IN6PTON_COLON_1|IN6PTON_COLON_1_2);
                }
cont:
                if ((dc && d + 4 < dbuf + sizeof(dbuf)) ||
                    d + 4 == dbuf + sizeof(dbuf)) {
                        state |= IN6PTON_DOT;
                }
                if (d >= dbuf + sizeof(dbuf)) {
                        state &= ~(IN6PTON_XDIGIT|IN6PTON_COLON_MASK);
                }
                s++;
                srclen--;
        }
 
        i = 15; d--;
 
        if (dc) {
                while(d >= dc)
                        dst[i--] = *d--;
                while(i >= dc - dbuf)
                        dst[i--] = 0;
                while(i >= 0)
                        dst[i--] = *d--;
        } else
                memcpy(dst, dbuf, sizeof(dbuf));
 
        ret = 1;
out:
        if (end)
                *end = s;
        return ret;
}
 
EXPORT_SYMBOL(in6_pton);

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [net/] [core/] [utils.c] - Blame information for rev 17

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