2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 #include <linux/config.h>
10 #include <linux/errno.h>
11 #include <linux/types.h>
12 #include <linux/socket.h>
14 #include <linux/kernel.h>
15 #include <linux/sched.h>
16 #include <linux/spinlock.h>
17 #include <linux/timer.h>
18 #include <linux/string.h>
19 #include <linux/sockios.h>
20 #include <linux/net.h>
22 #include <linux/inet.h>
23 #include <linux/netdevice.h>
24 #include <linux/skbuff.h>
26 #include <asm/uaccess.h>
27 #include <asm/system.h>
28 #include <linux/fcntl.h>
30 #include <linux/interrupt.h>
32 static struct protocol_struct
{
33 struct protocol_struct
*next
;
35 int (*func
)(struct sk_buff
*, ax25_cb
*);
36 } *protocol_list
= NULL
;
37 static DEFINE_RWLOCK(protocol_list_lock
);
39 static struct linkfail_struct
{
40 struct linkfail_struct
*next
;
41 void (*func
)(ax25_cb
*, int);
42 } *linkfail_list
= NULL
;
43 static DEFINE_SPINLOCK(linkfail_lock
);
45 static struct listen_struct
{
46 struct listen_struct
*next
;
47 ax25_address callsign
;
48 struct net_device
*dev
;
49 } *listen_list
= NULL
;
50 static DEFINE_SPINLOCK(listen_lock
);
52 int ax25_protocol_register(unsigned int pid
,
53 int (*func
)(struct sk_buff
*, ax25_cb
*))
55 struct protocol_struct
*protocol
;
57 if (pid
== AX25_P_TEXT
|| pid
== AX25_P_SEGMENT
)
60 if (pid
== AX25_P_IP
|| pid
== AX25_P_ARP
)
63 if ((protocol
= kmalloc(sizeof(*protocol
), GFP_ATOMIC
)) == NULL
)
67 protocol
->func
= func
;
69 write_lock(&protocol_list_lock
);
70 protocol
->next
= protocol_list
;
71 protocol_list
= protocol
;
72 write_unlock(&protocol_list_lock
);
77 void ax25_protocol_release(unsigned int pid
)
79 struct protocol_struct
*s
, *protocol
;
81 write_lock(&protocol_list_lock
);
82 protocol
= protocol_list
;
83 if (protocol
== NULL
) {
84 write_unlock(&protocol_list_lock
);
88 if (protocol
->pid
== pid
) {
89 protocol_list
= protocol
->next
;
90 write_unlock(&protocol_list_lock
);
95 while (protocol
!= NULL
&& protocol
->next
!= NULL
) {
96 if (protocol
->next
->pid
== pid
) {
98 protocol
->next
= protocol
->next
->next
;
99 write_unlock(&protocol_list_lock
);
104 protocol
= protocol
->next
;
106 write_unlock(&protocol_list_lock
);
109 int ax25_linkfail_register(void (*func
)(ax25_cb
*, int))
111 struct linkfail_struct
*linkfail
;
113 if ((linkfail
= kmalloc(sizeof(*linkfail
), GFP_ATOMIC
)) == NULL
)
116 linkfail
->func
= func
;
118 spin_lock_bh(&linkfail_lock
);
119 linkfail
->next
= linkfail_list
;
120 linkfail_list
= linkfail
;
121 spin_unlock_bh(&linkfail_lock
);
126 void ax25_linkfail_release(void (*func
)(ax25_cb
*, int))
128 struct linkfail_struct
*s
, *linkfail
;
130 spin_lock_bh(&linkfail_lock
);
131 linkfail
= linkfail_list
;
132 if (linkfail
== NULL
) {
133 spin_unlock_bh(&linkfail_lock
);
137 if (linkfail
->func
== func
) {
138 linkfail_list
= linkfail
->next
;
139 spin_unlock_bh(&linkfail_lock
);
144 while (linkfail
!= NULL
&& linkfail
->next
!= NULL
) {
145 if (linkfail
->next
->func
== func
) {
147 linkfail
->next
= linkfail
->next
->next
;
148 spin_unlock_bh(&linkfail_lock
);
153 linkfail
= linkfail
->next
;
155 spin_unlock_bh(&linkfail_lock
);
158 int ax25_listen_register(ax25_address
*callsign
, struct net_device
*dev
)
160 struct listen_struct
*listen
;
162 if (ax25_listen_mine(callsign
, dev
))
165 if ((listen
= kmalloc(sizeof(*listen
), GFP_ATOMIC
)) == NULL
)
168 listen
->callsign
= *callsign
;
171 spin_lock_bh(&listen_lock
);
172 listen
->next
= listen_list
;
173 listen_list
= listen
;
174 spin_unlock_bh(&listen_lock
);
179 void ax25_listen_release(ax25_address
*callsign
, struct net_device
*dev
)
181 struct listen_struct
*s
, *listen
;
183 spin_lock_bh(&listen_lock
);
184 listen
= listen_list
;
185 if (listen
== NULL
) {
186 spin_unlock_bh(&listen_lock
);
190 if (ax25cmp(&listen
->callsign
, callsign
) == 0 && listen
->dev
== dev
) {
191 listen_list
= listen
->next
;
192 spin_unlock_bh(&listen_lock
);
197 while (listen
!= NULL
&& listen
->next
!= NULL
) {
198 if (ax25cmp(&listen
->next
->callsign
, callsign
) == 0 && listen
->next
->dev
== dev
) {
200 listen
->next
= listen
->next
->next
;
201 spin_unlock_bh(&listen_lock
);
206 listen
= listen
->next
;
208 spin_unlock_bh(&listen_lock
);
211 int (*ax25_protocol_function(unsigned int pid
))(struct sk_buff
*, ax25_cb
*)
213 int (*res
)(struct sk_buff
*, ax25_cb
*) = NULL
;
214 struct protocol_struct
*protocol
;
216 read_lock(&protocol_list_lock
);
217 for (protocol
= protocol_list
; protocol
!= NULL
; protocol
= protocol
->next
)
218 if (protocol
->pid
== pid
) {
219 res
= protocol
->func
;
222 read_unlock(&protocol_list_lock
);
227 int ax25_listen_mine(ax25_address
*callsign
, struct net_device
*dev
)
229 struct listen_struct
*listen
;
231 spin_lock_bh(&listen_lock
);
232 for (listen
= listen_list
; listen
!= NULL
; listen
= listen
->next
)
233 if (ax25cmp(&listen
->callsign
, callsign
) == 0 && (listen
->dev
== dev
|| listen
->dev
== NULL
)) {
234 spin_unlock_bh(&listen_lock
);
237 spin_unlock_bh(&listen_lock
);
242 void ax25_link_failed(ax25_cb
*ax25
, int reason
)
244 struct linkfail_struct
*linkfail
;
246 spin_lock_bh(&linkfail_lock
);
247 for (linkfail
= linkfail_list
; linkfail
!= NULL
; linkfail
= linkfail
->next
)
248 (linkfail
->func
)(ax25
, reason
);
249 spin_unlock_bh(&linkfail_lock
);
252 int ax25_protocol_is_registered(unsigned int pid
)
254 struct protocol_struct
*protocol
;
257 read_lock(&protocol_list_lock
);
258 for (protocol
= protocol_list
; protocol
!= NULL
; protocol
= protocol
->next
)
259 if (protocol
->pid
== pid
) {
263 read_unlock(&protocol_list_lock
);
This page took 0.035176 seconds and 5 git commands to generate.