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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ax25/] [ax25_iface.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *      AX.25 release 037
 *
 *      This code REQUIRES 2.1.15 or higher/ NET3.038
 *
 *      This module:
 *              This module 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.
 *
 *      History
 *      AX.25 036       Jonathan(G4KLX) Split from ax25_timer.c.
 */
 
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <net/ax25.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
 
static struct protocol_struct {
        struct protocol_struct *next;
        unsigned int pid;
        int (*func)(struct sk_buff *, ax25_cb *);
} *protocol_list;
 
static struct linkfail_struct {
        struct linkfail_struct *next;
        void (*func)(ax25_cb *, int);
} *linkfail_list;
 
static struct listen_struct {
        struct listen_struct *next;
        ax25_address  callsign;
        struct net_device *dev;
} *listen_list;
 
int ax25_protocol_register(unsigned int pid, int (*func)(struct sk_buff *, ax25_cb *))
{
        struct protocol_struct *protocol;
        unsigned long flags;
 
        if (pid == AX25_P_TEXT || pid == AX25_P_SEGMENT)
                return 0;
#ifdef CONFIG_INET
        if (pid == AX25_P_IP || pid == AX25_P_ARP)
                return 0;
#endif
        if ((protocol = kmalloc(sizeof(*protocol), GFP_ATOMIC)) == NULL)
                return 0;
 
        protocol->pid  = pid;
        protocol->func = func;
 
        save_flags(flags);
        cli();
 
        protocol->next = protocol_list;
        protocol_list  = protocol;
 
        restore_flags(flags);
 
        return 1;
}
 
void ax25_protocol_release(unsigned int pid)
{
        struct protocol_struct *s, *protocol = protocol_list;
        unsigned long flags;
 
        if (protocol == NULL)
                return;
 
        save_flags(flags);
        cli();
 
        if (protocol->pid == pid) {
                protocol_list = protocol->next;
                restore_flags(flags);
                kfree(protocol);
                return;
        }
 
        while (protocol != NULL && protocol->next != NULL) {
                if (protocol->next->pid == pid) {
                        s = protocol->next;
                        protocol->next = protocol->next->next;
                        restore_flags(flags);
                        kfree(s);
                        return;
                }
 
                protocol = protocol->next;
        }
 
        restore_flags(flags);
}
 
int ax25_linkfail_register(void (*func)(ax25_cb *, int))
{
        struct linkfail_struct *linkfail;
        unsigned long flags;
 
        if ((linkfail = kmalloc(sizeof(*linkfail), GFP_ATOMIC)) == NULL)
                return 0;
 
        linkfail->func = func;
 
        save_flags(flags);
        cli();
 
        linkfail->next = linkfail_list;
        linkfail_list  = linkfail;
 
        restore_flags(flags);
 
        return 1;
}
 
void ax25_linkfail_release(void (*func)(ax25_cb *, int))
{
        struct linkfail_struct *s, *linkfail = linkfail_list;
        unsigned long flags;
 
        if (linkfail == NULL)
                return;
 
        save_flags(flags);
        cli();
 
        if (linkfail->func == func) {
                linkfail_list = linkfail->next;
                restore_flags(flags);
                kfree(linkfail);
                return;
        }
 
        while (linkfail != NULL && linkfail->next != NULL) {
                if (linkfail->next->func == func) {
                        s = linkfail->next;
                        linkfail->next = linkfail->next->next;
                        restore_flags(flags);
                        kfree(s);
                        return;
                }
 
                linkfail = linkfail->next;
        }
 
        restore_flags(flags);
}
 
int ax25_listen_register(ax25_address *callsign, struct net_device *dev)
{
        struct listen_struct *listen;
        unsigned long flags;
 
        if (ax25_listen_mine(callsign, dev))
                return 0;
 
        if ((listen = kmalloc(sizeof(*listen), GFP_ATOMIC)) == NULL)
                return 0;
 
        listen->callsign = *callsign;
        listen->dev      = dev;
 
        save_flags(flags);
        cli();
 
        listen->next = listen_list;
        listen_list  = listen;
 
        restore_flags(flags);
 
        return 1;
}
 
void ax25_listen_release(ax25_address *callsign, struct net_device *dev)
{
        struct listen_struct *s, *listen = listen_list;
        unsigned long flags;
 
        if (listen == NULL)
                return;
 
        save_flags(flags);
        cli();
 
        if (ax25cmp(&listen->callsign, callsign) == 0 && listen->dev == dev) {
                listen_list = listen->next;
                restore_flags(flags);
                kfree(listen);
                return;
        }
 
        while (listen != NULL && listen->next != NULL) {
                if (ax25cmp(&listen->next->callsign, callsign) == 0 && listen->next->dev == dev) {
                        s = listen->next;
                        listen->next = listen->next->next;
                        restore_flags(flags);
                        kfree(s);
                        return;
                }
 
                listen = listen->next;
        }
 
        restore_flags(flags);
}
 
int (*ax25_protocol_function(unsigned int pid))(struct sk_buff *, ax25_cb *)
{
        struct protocol_struct *protocol;
 
        for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)
                if (protocol->pid == pid)
                        return protocol->func;
 
        return NULL;
}
 
int ax25_listen_mine(ax25_address *callsign, struct net_device *dev)
{
        struct listen_struct *listen;
 
        for (listen = listen_list; listen != NULL; listen = listen->next)
                if (ax25cmp(&listen->callsign, callsign) == 0 && (listen->dev == dev || listen->dev == NULL))
                        return 1;
 
        return 0;
}
 
void ax25_link_failed(ax25_cb *ax25, int reason)
{
        struct linkfail_struct *linkfail;
 
        for (linkfail = linkfail_list; linkfail != NULL; linkfail = linkfail->next)
                (linkfail->func)(ax25, reason);
}
 
int ax25_protocol_is_registered(unsigned int pid)
{
        struct protocol_struct *protocol;
 
        for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)
                if (protocol->pid == pid)
                        return 1;
 
        return 0;
}
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ax25/] [ax25_iface.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* AX.25 release 037`
3			`*`
4			`* This code REQUIRES 2.1.15 or higher/ NET3.038`
5			`*`
6			`* This module:`
7			`* This module is free software; you can redistribute it and/or`
8			`* modify it under the terms of the GNU General Public License`
9			`* as published by the Free Software Foundation; either version`
10			`* 2 of the License, or (at your option) any later version.`
11			`*`
12			`* History`
13			`* AX.25 036 Jonathan(G4KLX) Split from ax25_timer.c.`
14			`*/`
15
16			`#include <linux/config.h>`
17			`#include <linux/errno.h>`
18			`#include <linux/types.h>`
19			`#include <linux/socket.h>`
20			`#include <linux/in.h>`
21			`#include <linux/kernel.h>`
22			`#include <linux/sched.h>`
23			`#include <linux/timer.h>`
24			`#include <linux/string.h>`
25			`#include <linux/sockios.h>`
26			`#include <linux/net.h>`
27			`#include <net/ax25.h>`
28			`#include <linux/inet.h>`
29			`#include <linux/netdevice.h>`
30			`#include <linux/skbuff.h>`
31			`#include <net/sock.h>`
32			`#include <asm/uaccess.h>`
33			`#include <asm/system.h>`
34			`#include <linux/fcntl.h>`
35			`#include <linux/mm.h>`
36			`#include <linux/interrupt.h>`
37
38			`static struct protocol_struct {`
39			`struct protocol_struct *next;`
40			`unsigned int pid;`
41			`int (func)(struct sk_buff , ax25_cb *);`
42			`} *protocol_list;`
43
44			`static struct linkfail_struct {`
45			`struct linkfail_struct *next;`
46			`void (func)(ax25_cb , int);`
47			`} *linkfail_list;`
48
49			`static struct listen_struct {`
50			`struct listen_struct *next;`
51			`ax25_address callsign;`
52			`struct net_device *dev;`
53			`} *listen_list;`
54
55			`int ax25_protocol_register(unsigned int pid, int (func)(struct sk_buff , ax25_cb *))`
56			`{`
57			`struct protocol_struct *protocol;`
58			`unsigned long flags;`
59
60			`if (pid == AX25_P_TEXT \|\| pid == AX25_P_SEGMENT)`
61			`return 0;`
62			`#ifdef CONFIG_INET`
63			`if (pid == AX25_P_IP \|\| pid == AX25_P_ARP)`
64			`return 0;`
65			`#endif`
66			`if ((protocol = kmalloc(sizeof(*protocol), GFP_ATOMIC)) == NULL)`
67			`return 0;`
68
69			`protocol->pid = pid;`
70			`protocol->func = func;`
71
72			`save_flags(flags);`
73			`cli();`
74
75			`protocol->next = protocol_list;`
76			`protocol_list = protocol;`
77
78			`restore_flags(flags);`
79
80			`return 1;`
81			`}`
82
83			`void ax25_protocol_release(unsigned int pid)`
84			`{`
85			`struct protocol_struct s, protocol = protocol_list;`
86			`unsigned long flags;`
87
88			`if (protocol == NULL)`
89			`return;`
90
91			`save_flags(flags);`
92			`cli();`
93
94			`if (protocol->pid == pid) {`
95			`protocol_list = protocol->next;`
96			`restore_flags(flags);`
97			`kfree(protocol);`
98			`return;`
99			`}`
100
101			`while (protocol != NULL && protocol->next != NULL) {`
102			`if (protocol->next->pid == pid) {`
103			`s = protocol->next;`
104			`protocol->next = protocol->next->next;`
105			`restore_flags(flags);`
106			`kfree(s);`
107			`return;`
108			`}`
109
110			`protocol = protocol->next;`
111			`}`
112
113			`restore_flags(flags);`
114			`}`
115
116			`int ax25_linkfail_register(void (func)(ax25_cb , int))`
117			`{`
118			`struct linkfail_struct *linkfail;`
119			`unsigned long flags;`
120
121			`if ((linkfail = kmalloc(sizeof(*linkfail), GFP_ATOMIC)) == NULL)`
122			`return 0;`
123
124			`linkfail->func = func;`
125
126			`save_flags(flags);`
127			`cli();`
128
129			`linkfail->next = linkfail_list;`
130			`linkfail_list = linkfail;`
131
132			`restore_flags(flags);`
133
134			`return 1;`
135			`}`
136
137			`void ax25_linkfail_release(void (func)(ax25_cb , int))`
138			`{`
139			`struct linkfail_struct s, linkfail = linkfail_list;`
140			`unsigned long flags;`
141
142			`if (linkfail == NULL)`
143			`return;`
144
145			`save_flags(flags);`
146			`cli();`
147
148			`if (linkfail->func == func) {`
149			`linkfail_list = linkfail->next;`
150			`restore_flags(flags);`
151			`kfree(linkfail);`
152			`return;`
153			`}`
154
155			`while (linkfail != NULL && linkfail->next != NULL) {`
156			`if (linkfail->next->func == func) {`
157			`s = linkfail->next;`
158			`linkfail->next = linkfail->next->next;`
159			`restore_flags(flags);`
160			`kfree(s);`
161			`return;`
162			`}`
163
164			`linkfail = linkfail->next;`
165			`}`
166
167			`restore_flags(flags);`
168			`}`
169
170			`int ax25_listen_register(ax25_address callsign, struct net_device dev)`
171			`{`
172			`struct listen_struct *listen;`
173			`unsigned long flags;`
174
175			`if (ax25_listen_mine(callsign, dev))`
176			`return 0;`
177
178			`if ((listen = kmalloc(sizeof(*listen), GFP_ATOMIC)) == NULL)`
179			`return 0;`
180
181			`listen->callsign = *callsign;`
182			`listen->dev = dev;`
183
184			`save_flags(flags);`
185			`cli();`
186
187			`listen->next = listen_list;`
188			`listen_list = listen;`
189
190			`restore_flags(flags);`
191
192			`return 1;`
193			`}`
194
195			`void ax25_listen_release(ax25_address callsign, struct net_device dev)`
196			`{`
197			`struct listen_struct s, listen = listen_list;`
198			`unsigned long flags;`
199
200			`if (listen == NULL)`
201			`return;`
202
203			`save_flags(flags);`
204			`cli();`
205
206			`if (ax25cmp(&listen->callsign, callsign) == 0 && listen->dev == dev) {`
207			`listen_list = listen->next;`
208			`restore_flags(flags);`
209			`kfree(listen);`
210			`return;`
211			`}`
212
213			`while (listen != NULL && listen->next != NULL) {`
214			`if (ax25cmp(&listen->next->callsign, callsign) == 0 && listen->next->dev == dev) {`
215			`s = listen->next;`
216			`listen->next = listen->next->next;`
217			`restore_flags(flags);`
218			`kfree(s);`
219			`return;`
220			`}`
221
222			`listen = listen->next;`
223			`}`
224
225			`restore_flags(flags);`
226			`}`
227
228			`int (ax25_protocol_function(unsigned int pid))(struct sk_buff , ax25_cb *)`
229			`{`
230			`struct protocol_struct *protocol;`
231
232			`for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)`
233			`if (protocol->pid == pid)`
234			`return protocol->func;`
235
236			`return NULL;`
237			`}`
238
239			`int ax25_listen_mine(ax25_address callsign, struct net_device dev)`
240			`{`
241			`struct listen_struct *listen;`
242
243			`for (listen = listen_list; listen != NULL; listen = listen->next)`
244			`if (ax25cmp(&listen->callsign, callsign) == 0 && (listen->dev == dev \|\| listen->dev == NULL))`
245			`return 1;`
246
247			`return 0;`
248			`}`
249
250			`void ax25_link_failed(ax25_cb *ax25, int reason)`
251			`{`
252			`struct linkfail_struct *linkfail;`
253
254			`for (linkfail = linkfail_list; linkfail != NULL; linkfail = linkfail->next)`
255			`(linkfail->func)(ax25, reason);`
256			`}`
257
258			`int ax25_protocol_is_registered(unsigned int pid)`
259			`{`
260			`struct protocol_struct *protocol;`
261
262			`for (protocol = protocol_list; protocol != NULL; protocol = protocol->next)`
263			`if (protocol->pid == pid)`
264			`return 1;`
265
266			`return 0;`
267			`}`
268