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/errno.h>
10 #include <linux/types.h>
11 #include <linux/socket.h>
13 #include <linux/kernel.h>
14 #include <linux/module.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 ax25_protocol
*protocol_list
;
33 static DEFINE_RWLOCK(protocol_list_lock
);
35 static HLIST_HEAD(ax25_linkfail_list
);
36 static DEFINE_SPINLOCK(linkfail_lock
);
38 static struct listen_struct
{
39 struct listen_struct
*next
;
40 ax25_address callsign
;
41 struct net_device
*dev
;
42 } *listen_list
= NULL
;
43 static DEFINE_SPINLOCK(listen_lock
);
46 * Do not register the internal protocols AX25_P_TEXT, AX25_P_SEGMENT,
47 * AX25_P_IP or AX25_P_ARP ...
49 void ax25_register_pid(struct ax25_protocol
*ap
)
51 write_lock_bh(&protocol_list_lock
);
52 ap
->next
= protocol_list
;
54 write_unlock_bh(&protocol_list_lock
);
57 EXPORT_SYMBOL_GPL(ax25_register_pid
);
59 void ax25_protocol_release(unsigned int pid
)
61 struct ax25_protocol
*s
, *protocol
;
63 write_lock_bh(&protocol_list_lock
);
64 protocol
= protocol_list
;
65 if (protocol
== NULL
) {
66 write_unlock_bh(&protocol_list_lock
);
70 if (protocol
->pid
== pid
) {
71 protocol_list
= protocol
->next
;
72 write_unlock_bh(&protocol_list_lock
);
77 while (protocol
!= NULL
&& protocol
->next
!= NULL
) {
78 if (protocol
->next
->pid
== pid
) {
80 protocol
->next
= protocol
->next
->next
;
81 write_unlock_bh(&protocol_list_lock
);
86 protocol
= protocol
->next
;
88 write_unlock_bh(&protocol_list_lock
);
91 EXPORT_SYMBOL(ax25_protocol_release
);
93 void ax25_linkfail_register(struct ax25_linkfail
*lf
)
95 spin_lock_bh(&linkfail_lock
);
96 hlist_add_head(&lf
->lf_node
, &ax25_linkfail_list
);
97 spin_unlock_bh(&linkfail_lock
);
100 EXPORT_SYMBOL(ax25_linkfail_register
);
102 void ax25_linkfail_release(struct ax25_linkfail
*lf
)
104 spin_lock_bh(&linkfail_lock
);
105 hlist_del_init(&lf
->lf_node
);
106 spin_unlock_bh(&linkfail_lock
);
109 EXPORT_SYMBOL(ax25_linkfail_release
);
111 int ax25_listen_register(ax25_address
*callsign
, struct net_device
*dev
)
113 struct listen_struct
*listen
;
115 if (ax25_listen_mine(callsign
, dev
))
118 if ((listen
= kmalloc(sizeof(*listen
), GFP_ATOMIC
)) == NULL
)
121 listen
->callsign
= *callsign
;
124 spin_lock_bh(&listen_lock
);
125 listen
->next
= listen_list
;
126 listen_list
= listen
;
127 spin_unlock_bh(&listen_lock
);
132 EXPORT_SYMBOL(ax25_listen_register
);
134 void ax25_listen_release(ax25_address
*callsign
, struct net_device
*dev
)
136 struct listen_struct
*s
, *listen
;
138 spin_lock_bh(&listen_lock
);
139 listen
= listen_list
;
140 if (listen
== NULL
) {
141 spin_unlock_bh(&listen_lock
);
145 if (ax25cmp(&listen
->callsign
, callsign
) == 0 && listen
->dev
== dev
) {
146 listen_list
= listen
->next
;
147 spin_unlock_bh(&listen_lock
);
152 while (listen
!= NULL
&& listen
->next
!= NULL
) {
153 if (ax25cmp(&listen
->next
->callsign
, callsign
) == 0 && listen
->next
->dev
== dev
) {
155 listen
->next
= listen
->next
->next
;
156 spin_unlock_bh(&listen_lock
);
161 listen
= listen
->next
;
163 spin_unlock_bh(&listen_lock
);
166 EXPORT_SYMBOL(ax25_listen_release
);
168 int (*ax25_protocol_function(unsigned int pid
))(struct sk_buff
*, ax25_cb
*)
170 int (*res
)(struct sk_buff
*, ax25_cb
*) = NULL
;
171 struct ax25_protocol
*protocol
;
173 read_lock(&protocol_list_lock
);
174 for (protocol
= protocol_list
; protocol
!= NULL
; protocol
= protocol
->next
)
175 if (protocol
->pid
== pid
) {
176 res
= protocol
->func
;
179 read_unlock(&protocol_list_lock
);
184 int ax25_listen_mine(ax25_address
*callsign
, struct net_device
*dev
)
186 struct listen_struct
*listen
;
188 spin_lock_bh(&listen_lock
);
189 for (listen
= listen_list
; listen
!= NULL
; listen
= listen
->next
)
190 if (ax25cmp(&listen
->callsign
, callsign
) == 0 &&
191 (listen
->dev
== dev
|| listen
->dev
== NULL
)) {
192 spin_unlock_bh(&listen_lock
);
195 spin_unlock_bh(&listen_lock
);
200 void ax25_link_failed(ax25_cb
*ax25
, int reason
)
202 struct ax25_linkfail
*lf
;
203 struct hlist_node
*node
;
205 spin_lock_bh(&linkfail_lock
);
206 hlist_for_each_entry(lf
, node
, &ax25_linkfail_list
, lf_node
)
207 lf
->func(ax25
, reason
);
208 spin_unlock_bh(&linkfail_lock
);
211 int ax25_protocol_is_registered(unsigned int pid
)
213 struct ax25_protocol
*protocol
;
216 read_lock_bh(&protocol_list_lock
);
217 for (protocol
= protocol_list
; protocol
!= NULL
; protocol
= protocol
->next
)
218 if (protocol
->pid
== pid
) {
222 read_unlock_bh(&protocol_list_lock
);