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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [net/] [ipv4/] [protocol.c] - Blame information for rev 1772

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


/*
 * INET         An implementation of the TCP/IP protocol suite for the LINUX
 *              operating system.  INET is implemented using the  BSD Socket
 *              interface as the means of communication with the user level.
 *
 *              INET protocol dispatch tables.
 *
 * Version:     @(#)protocol.c  1.0.5   05/25/93
 *
 * Authors:     Ross Biro, <bir7@leland.Stanford.Edu>
 *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *
 * Fixes:
 *              Alan Cox        : Ahah! udp icmp errors don't work because
 *                                udp_err is never called!
 *              Alan Cox        : Added new fields for init and ready for
 *                                proper fragmentation (_NO_ 4K limits!)
 *              Richard Colella : Hang on hash collision
 *
 *              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 <asm/segment.h>
#include <asm/system.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/config.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/timer.h>
#include <net/ip.h>
#include <net/protocol.h>
#include <net/tcp.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <net/icmp.h>
#include <net/udp.h>
#include <net/ipip.h>
#include <linux/igmp.h>
 
 
#ifdef CONFIG_NET_IPIP
 
static struct inet_protocol ipip_protocol =
{
        ipip_rcv,             /* IPIP handler          */
        NULL,                 /* TUNNEL error control    */
        0,                    /* next                 */
        IPPROTO_IPIP,         /* protocol ID          */
        0,                    /* copy                 */
        NULL,                 /* data                 */
        "IPIP"                /* name                 */
};
 
 
#endif
 
static struct inet_protocol tcp_protocol =
{
        tcp_rcv,                /* TCP handler          */
        tcp_err,                /* TCP error control    */
#if defined(CONFIG_NET_IPIP)
        &ipip_protocol,
#else  
        NULL,                   /* next                 */
#endif  
        IPPROTO_TCP,            /* protocol ID          */
        0,                       /* copy                 */
        NULL,                   /* data                 */
        "TCP"                   /* name                 */
};
 
 
static struct inet_protocol udp_protocol =
{
        udp_rcv,                /* UDP handler          */
        udp_err,                /* UDP error control    */
        &tcp_protocol,          /* next                 */
        IPPROTO_UDP,            /* protocol ID          */
        0,                       /* copy                 */
        NULL,                   /* data                 */
        "UDP"                   /* name                 */
};
 
 
static struct inet_protocol icmp_protocol =
{
        icmp_rcv,               /* ICMP handler         */
        NULL,                   /* ICMP error control   */
        &udp_protocol,          /* next                 */
        IPPROTO_ICMP,           /* protocol ID          */
        0,                       /* copy                 */
        NULL,                   /* data                 */
        "ICMP"                  /* name                 */
};
 
#ifndef CONFIG_IP_MULTICAST
struct inet_protocol *inet_protocol_base = &icmp_protocol;
#else
static struct inet_protocol igmp_protocol =
{
        igmp_rcv,               /* IGMP handler         */
        NULL,                   /* IGMP error control   */
        &icmp_protocol,         /* next                 */
        IPPROTO_IGMP,           /* protocol ID          */
        0,                       /* copy                 */
        NULL,                   /* data                 */
        "IGMP"                  /* name                 */
};
 
struct inet_protocol *inet_protocol_base = &igmp_protocol;
#endif
 
struct inet_protocol *inet_protos[MAX_INET_PROTOS] =
{
        NULL
};
 
 
/*
 *      Find a protocol in the protocol tables given its
 *      IP type.
 */
 
struct inet_protocol *inet_get_protocol(unsigned char prot)
{
        unsigned char hash;
        struct inet_protocol *p;
 
        hash = prot & (MAX_INET_PROTOS - 1);
        for (p = inet_protos[hash] ; p != NULL; p=p->next)
        {
                if (p->protocol == prot)
                        return((struct inet_protocol *) p);
        }
        return(NULL);
}
 
/*
 *      Add a protocol handler to the hash tables
 */
 
void inet_add_protocol(struct inet_protocol *prot)
{
        unsigned char hash;
        struct inet_protocol *p2;
 
        hash = prot->protocol & (MAX_INET_PROTOS - 1);
        prot ->next = inet_protos[hash];
        inet_protos[hash] = prot;
        prot->copy = 0;
 
        /*
         *      Set the copy bit if we need to.
         */
 
        p2 = (struct inet_protocol *) prot->next;
        while(p2 != NULL)
        {
                if (p2->protocol == prot->protocol)
                {
                        prot->copy = 1;
                        break;
                }
                p2 = (struct inet_protocol *) p2->next;
        }
}
 
/*
 *      Remove a protocol from the hash tables.
 */
 
int inet_del_protocol(struct inet_protocol *prot)
{
        struct inet_protocol *p;
        struct inet_protocol *lp = NULL;
        unsigned char hash;
 
        hash = prot->protocol & (MAX_INET_PROTOS - 1);
        if (prot == inet_protos[hash])
        {
                inet_protos[hash] = (struct inet_protocol *) inet_protos[hash]->next;
                return(0);
        }
 
        p = (struct inet_protocol *) inet_protos[hash];
        while(p != NULL)
        {
                /*
                 * We have to worry if the protocol being deleted is
                 * the last one on the list, then we may need to reset
                 * someone's copied bit.
                 */
                if (p->next != NULL && p->next == prot)
                {
                        /*
                         * if we are the last one with this protocol and
                         * there is a previous one, reset its copy bit.
                         */
                        if (p->copy == 0 && lp != NULL)
                                lp->copy = 0;
                        p->next = prot->next;
                        return(0);
                }
                if (p->next != NULL && p->next->protocol == prot->protocol)
                        lp = p;
 
                p = (struct inet_protocol *) p->next;
        }
        return(-1);
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rc203soc/] [sw/] [uClinux/] [net/] [ipv4/] [protocol.c] - Blame information for rev 1772

Line No.	Rev	Author	Line
1	1629	jcastillo	`/*`
2			`* INET An implementation of the TCP/IP protocol suite for the LINUX`
3			`* operating system. INET is implemented using the BSD Socket`
4			`* interface as the means of communication with the user level.`
5			`*`
6			`* INET protocol dispatch tables.`
7			`*`
8			`* Version: @(#)protocol.c 1.0.5 05/25/93`
9			`*`
10			`* Authors: Ross Biro, <bir7@leland.Stanford.Edu>`
11			`* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>`
12			`*`
13			`* Fixes:`
14			`* Alan Cox : Ahah! udp icmp errors don't work because`
15			`* udp_err is never called!`
16			`* Alan Cox : Added new fields for init and ready for`
17			`* proper fragmentation (_NO_ 4K limits!)`
18			`* Richard Colella : Hang on hash collision`
19			`*`
20			`* This program is free software; you can redistribute it and/or`
21			`* modify it under the terms of the GNU General Public License`
22			`* as published by the Free Software Foundation; either version`
23			`* 2 of the License, or (at your option) any later version.`
24			`*/`
25
26			`#include <asm/segment.h>`
27			`#include <asm/system.h>`
28			`#include <linux/types.h>`
29			`#include <linux/kernel.h>`
30			`#include <linux/sched.h>`
31			`#include <linux/string.h>`
32			`#include <linux/config.h>`
33			`#include <linux/socket.h>`
34			`#include <linux/in.h>`
35			`#include <linux/inet.h>`
36			`#include <linux/netdevice.h>`
37			`#include <linux/timer.h>`
38			`#include <net/ip.h>`
39			`#include <net/protocol.h>`
40			`#include <net/tcp.h>`
41			`#include <linux/skbuff.h>`
42			`#include <net/sock.h>`
43			`#include <net/icmp.h>`
44			`#include <net/udp.h>`
45			`#include <net/ipip.h>`
46			`#include <linux/igmp.h>`
47
48
49			`#ifdef CONFIG_NET_IPIP`
50
51			`static struct inet_protocol ipip_protocol =`
52			`{`
53			`ipip_rcv, /* IPIP handler */`
54			`NULL, /* TUNNEL error control */`
55			`0, /* next */`
56			`IPPROTO_IPIP, /* protocol ID */`
57			`0, /* copy */`
58			`NULL, /* data */`
59			`"IPIP" /* name */`
60			`};`
61
62
63			`#endif`
64
65			`static struct inet_protocol tcp_protocol =`
66			`{`
67			`tcp_rcv, /* TCP handler */`
68			`tcp_err, /* TCP error control */`
69			`#if defined(CONFIG_NET_IPIP)`
70			`&ipip_protocol,`
71			`#else`
72			`NULL, /* next */`
73			`#endif`
74			`IPPROTO_TCP, /* protocol ID */`
75			`0, /* copy */`
76			`NULL, /* data */`
77			`"TCP" /* name */`
78			`};`
79
80
81			`static struct inet_protocol udp_protocol =`
82			`{`
83			`udp_rcv, /* UDP handler */`
84			`udp_err, /* UDP error control */`
85			`&tcp_protocol, /* next */`
86			`IPPROTO_UDP, /* protocol ID */`
87			`0, /* copy */`
88			`NULL, /* data */`
89			`"UDP" /* name */`
90			`};`
91
92
93			`static struct inet_protocol icmp_protocol =`
94			`{`
95			`icmp_rcv, /* ICMP handler */`
96			`NULL, /* ICMP error control */`
97			`&udp_protocol, /* next */`
98			`IPPROTO_ICMP, /* protocol ID */`
99			`0, /* copy */`
100			`NULL, /* data */`
101			`"ICMP" /* name */`
102			`};`
103
104			`#ifndef CONFIG_IP_MULTICAST`
105			`struct inet_protocol *inet_protocol_base = &icmp_protocol;`
106			`#else`
107			`static struct inet_protocol igmp_protocol =`
108			`{`
109			`igmp_rcv, /* IGMP handler */`
110			`NULL, /* IGMP error control */`
111			`&icmp_protocol, /* next */`
112			`IPPROTO_IGMP, /* protocol ID */`
113			`0, /* copy */`
114			`NULL, /* data */`
115			`"IGMP" /* name */`
116			`};`
117
118			`struct inet_protocol *inet_protocol_base = &igmp_protocol;`
119			`#endif`
120
121			`struct inet_protocol *inet_protos[MAX_INET_PROTOS] =`
122			`{`
123			`NULL`
124			`};`
125
126
127			`/*`
128			`* Find a protocol in the protocol tables given its`
129			`* IP type.`
130			`*/`
131
132			`struct inet_protocol *inet_get_protocol(unsigned char prot)`
133			`{`
134			`unsigned char hash;`
135			`struct inet_protocol *p;`
136
137			`hash = prot & (MAX_INET_PROTOS - 1);`
138			`for (p = inet_protos[hash] ; p != NULL; p=p->next)`
139			`{`
140			`if (p->protocol == prot)`
141			`return((struct inet_protocol *) p);`
142			`}`
143			`return(NULL);`
144			`}`
145
146			`/*`
147			`* Add a protocol handler to the hash tables`
148			`*/`
149
150			`void inet_add_protocol(struct inet_protocol *prot)`
151			`{`
152			`unsigned char hash;`
153			`struct inet_protocol *p2;`
154
155			`hash = prot->protocol & (MAX_INET_PROTOS - 1);`
156			`prot ->next = inet_protos[hash];`
157			`inet_protos[hash] = prot;`
158			`prot->copy = 0;`
159
160			`/*`
161			`* Set the copy bit if we need to.`
162			`*/`
163
164			`p2 = (struct inet_protocol *) prot->next;`
165			`while(p2 != NULL)`
166			`{`
167			`if (p2->protocol == prot->protocol)`
168			`{`
169			`prot->copy = 1;`
170			`break;`
171			`}`
172			`p2 = (struct inet_protocol *) p2->next;`
173			`}`
174			`}`
175
176			`/*`
177			`* Remove a protocol from the hash tables.`
178			`*/`
179
180			`int inet_del_protocol(struct inet_protocol *prot)`
181			`{`
182			`struct inet_protocol *p;`
183			`struct inet_protocol *lp = NULL;`
184			`unsigned char hash;`
185
186			`hash = prot->protocol & (MAX_INET_PROTOS - 1);`
187			`if (prot == inet_protos[hash])`
188			`{`
189			`inet_protos[hash] = (struct inet_protocol *) inet_protos[hash]->next;`
190			`return(0);`
191			`}`
192
193			`p = (struct inet_protocol *) inet_protos[hash];`
194			`while(p != NULL)`
195			`{`
196			`/*`
197			`* We have to worry if the protocol being deleted is`
198			`* the last one on the list, then we may need to reset`
199			`* someone's copied bit.`
200			`*/`
201			`if (p->next != NULL && p->next == prot)`
202			`{`
203			`/*`
204			`* if we are the last one with this protocol and`
205			`* there is a previous one, reset its copy bit.`
206			`*/`
207			`if (p->copy == 0 && lp != NULL)`
208			`lp->copy = 0;`
209			`p->next = prot->next;`
210			`return(0);`
211			`}`
212			`if (p->next != NULL && p->next->protocol == prot->protocol)`
213			`lp = p;`
214
215			`p = (struct inet_protocol *) p->next;`
216			`}`
217			`return(-1);`
218			`}`