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) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
10 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
12 #include <linux/errno.h>
13 #include <linux/types.h>
14 #include <linux/socket.h>
16 #include <linux/kernel.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>
25 #include <linux/netfilter.h>
27 #include <net/tcp_states.h>
28 #include <asm/uaccess.h>
29 #include <asm/system.h>
30 #include <linux/fcntl.h>
32 #include <linux/interrupt.h>
35 * Given a fragment, queue it on the fragment queue and if the fragment
36 * is complete, send it back to ax25_rx_iframe.
38 static int ax25_rx_fragment(ax25_cb
*ax25
, struct sk_buff
*skb
)
40 struct sk_buff
*skbn
, *skbo
;
42 if (ax25
->fragno
!= 0) {
43 if (!(*skb
->data
& AX25_SEG_FIRST
)) {
44 if ((ax25
->fragno
- 1) == (*skb
->data
& AX25_SEG_REM
)) {
45 /* Enqueue fragment */
46 ax25
->fragno
= *skb
->data
& AX25_SEG_REM
;
47 skb_pull(skb
, 1); /* skip fragno */
48 ax25
->fraglen
+= skb
->len
;
49 skb_queue_tail(&ax25
->frag_queue
, skb
);
51 /* Last fragment received ? */
52 if (ax25
->fragno
== 0) {
53 skbn
= alloc_skb(AX25_MAX_HEADER_LEN
+
57 skb_queue_purge(&ax25
->frag_queue
);
61 skb_reserve(skbn
, AX25_MAX_HEADER_LEN
);
63 skbn
->dev
= ax25
->ax25_dev
->dev
;
64 skb_reset_network_header(skbn
);
65 skb_reset_transport_header(skbn
);
67 /* Copy data from the fragments */
68 while ((skbo
= skb_dequeue(&ax25
->frag_queue
)) != NULL
) {
69 skb_copy_from_linear_data(skbo
,
70 skb_put(skbn
, skbo
->len
),
77 if (ax25_rx_iframe(ax25
, skbn
) == 0)
85 /* First fragment received */
86 if (*skb
->data
& AX25_SEG_FIRST
) {
87 skb_queue_purge(&ax25
->frag_queue
);
88 ax25
->fragno
= *skb
->data
& AX25_SEG_REM
;
89 skb_pull(skb
, 1); /* skip fragno */
90 ax25
->fraglen
= skb
->len
;
91 skb_queue_tail(&ax25
->frag_queue
, skb
);
100 * This is where all valid I frames are sent to, to be dispatched to
101 * whichever protocol requires them.
103 int ax25_rx_iframe(ax25_cb
*ax25
, struct sk_buff
*skb
)
105 int (*func
)(struct sk_buff
*, ax25_cb
*);
109 if (skb
== NULL
) return 0;
111 ax25_start_idletimer(ax25
);
115 if (pid
== AX25_P_IP
) {
116 /* working around a TCP bug to keep additional listeners
117 * happy. TCP re-uses the buffer and destroys the original
120 struct sk_buff
*skbn
= skb_copy(skb
, GFP_ATOMIC
);
126 skb_pull(skb
, 1); /* Remove PID */
127 skb
->mac_header
= skb
->network_header
;
128 skb_reset_network_header(skb
);
129 skb
->dev
= ax25
->ax25_dev
->dev
;
130 skb
->pkt_type
= PACKET_HOST
;
131 skb
->protocol
= htons(ETH_P_IP
);
135 if (pid
== AX25_P_SEGMENT
) {
136 skb_pull(skb
, 1); /* Remove PID */
137 return ax25_rx_fragment(ax25
, skb
);
140 if ((func
= ax25_protocol_function(pid
)) != NULL
) {
141 skb_pull(skb
, 1); /* Remove PID */
142 return (*func
)(skb
, ax25
);
145 if (ax25
->sk
!= NULL
&& ax25
->ax25_dev
->values
[AX25_VALUES_CONMODE
] == 2) {
146 if ((!ax25
->pidincl
&& ax25
->sk
->sk_protocol
== pid
) ||
148 if (sock_queue_rcv_skb(ax25
->sk
, skb
) == 0)
151 ax25
->condition
|= AX25_COND_OWN_RX_BUSY
;
159 * Higher level upcall for a LAPB frame
161 static int ax25_process_rx_frame(ax25_cb
*ax25
, struct sk_buff
*skb
, int type
, int dama
)
165 if (ax25
->state
== AX25_STATE_0
)
168 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
169 case AX25_PROTO_STD_SIMPLEX
:
170 case AX25_PROTO_STD_DUPLEX
:
171 queued
= ax25_std_frame_in(ax25
, skb
, type
);
174 #ifdef CONFIG_AX25_DAMA_SLAVE
175 case AX25_PROTO_DAMA_SLAVE
:
176 if (dama
|| ax25
->ax25_dev
->dama
.slave
)
177 queued
= ax25_ds_frame_in(ax25
, skb
, type
);
179 queued
= ax25_std_frame_in(ax25
, skb
, type
);
187 static int ax25_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
188 ax25_address
*dev_addr
, struct packet_type
*ptype
)
190 ax25_address src
, dest
, *next_digi
= NULL
;
191 int type
= 0, mine
= 0, dama
;
192 struct sock
*make
, *sk
;
193 ax25_digi dp
, reverse_dp
;
198 * Process the AX.25/LAPB frame.
201 skb_reset_transport_header(skb
);
203 if ((ax25_dev
= ax25_dev_ax25dev(dev
)) == NULL
)
207 * Parse the address header.
210 if (ax25_addr_parse(skb
->data
, skb
->len
, &src
, &dest
, &dp
, &type
, &dama
) == NULL
)
216 if (dp
.lastrepeat
+ 1 < dp
.ndigi
) /* Not yet digipeated completely */
217 next_digi
= &dp
.calls
[dp
.lastrepeat
+ 1];
220 * Pull of the AX.25 headers leaving the CTRL/PID bytes
222 skb_pull(skb
, ax25_addr_size(&dp
));
224 /* For our port addresses ? */
225 if (ax25cmp(&dest
, dev_addr
) == 0 && dp
.lastrepeat
+ 1 == dp
.ndigi
)
228 /* Also match on any registered callsign from L3/4 */
229 if (!mine
&& ax25_listen_mine(&dest
, dev
) && dp
.lastrepeat
+ 1 == dp
.ndigi
)
232 /* UI frame - bypass LAPB processing */
233 if ((*skb
->data
& ~0x10) == AX25_UI
&& dp
.lastrepeat
+ 1 == dp
.ndigi
) {
234 skb_set_transport_header(skb
, 2); /* skip control and pid */
236 ax25_send_to_raw(&dest
, skb
, skb
->data
[1]);
238 if (!mine
&& ax25cmp(&dest
, (ax25_address
*)dev
->broadcast
) != 0)
241 /* Now we are pointing at the pid byte */
242 switch (skb
->data
[1]) {
244 skb_pull(skb
,2); /* drop PID/CTRL */
245 skb_reset_transport_header(skb
);
246 skb_reset_network_header(skb
);
248 skb
->pkt_type
= PACKET_HOST
;
249 skb
->protocol
= htons(ETH_P_IP
);
255 skb_reset_transport_header(skb
);
256 skb_reset_network_header(skb
);
258 skb
->pkt_type
= PACKET_HOST
;
259 skb
->protocol
= htons(ETH_P_ARP
);
263 /* Now find a suitable dgram socket */
264 sk
= ax25_get_socket(&dest
, &src
, SOCK_DGRAM
);
267 if (atomic_read(&sk
->sk_rmem_alloc
) >=
272 * Remove the control and PID.
275 if (sock_queue_rcv_skb(sk
, skb
) != 0)
286 kfree_skb(skb
); /* Will scan SOCK_AX25 RAW sockets */
294 * Is connected mode supported on this device ?
295 * If not, should we DM the incoming frame (except DMs) or
296 * silently ignore them. For now we stay quiet.
298 if (ax25_dev
->values
[AX25_VALUES_CONMODE
] == 0)
303 /* AX.25 state 1-4 */
305 ax25_digi_invert(&dp
, &reverse_dp
);
307 if ((ax25
= ax25_find_cb(&dest
, &src
, &reverse_dp
, dev
)) != NULL
) {
309 * Process the frame. If it is queued up internally it
310 * returns one otherwise we free it immediately. This
311 * routine itself wakes the user context layers so we do
314 if (ax25_process_rx_frame(ax25
, skb
, type
, dama
) == 0)
321 /* AX.25 state 0 (disconnected) */
323 /* a) received not a SABM(E) */
325 if ((*skb
->data
& ~AX25_PF
) != AX25_SABM
&&
326 (*skb
->data
& ~AX25_PF
) != AX25_SABME
) {
328 * Never reply to a DM. Also ignore any connects for
329 * addresses that are not our interfaces and not a socket.
331 if ((*skb
->data
& ~AX25_PF
) != AX25_DM
&& mine
)
332 ax25_return_dm(dev
, &src
, &dest
, &dp
);
337 /* b) received SABM(E) */
339 if (dp
.lastrepeat
+ 1 == dp
.ndigi
)
340 sk
= ax25_find_listener(&dest
, 0, dev
, SOCK_SEQPACKET
);
342 sk
= ax25_find_listener(next_digi
, 1, dev
, SOCK_SEQPACKET
);
346 if (sk_acceptq_is_full(sk
) ||
347 (make
= ax25_make_new(sk
, ax25_dev
)) == NULL
) {
349 ax25_return_dm(dev
, &src
, &dest
, &dp
);
357 ax25
= ax25_sk(make
);
358 skb_set_owner_r(skb
, make
);
359 skb_queue_head(&sk
->sk_receive_queue
, skb
);
361 make
->sk_state
= TCP_ESTABLISHED
;
363 sk
->sk_ack_backlog
++;
369 if ((ax25
= ax25_create_cb()) == NULL
) {
370 ax25_return_dm(dev
, &src
, &dest
, &dp
);
374 ax25_fillin_cb(ax25
, ax25_dev
);
377 ax25
->source_addr
= dest
;
378 ax25
->dest_addr
= src
;
381 * Sort out any digipeated paths.
383 if (dp
.ndigi
&& !ax25
->digipeat
&&
384 (ax25
->digipeat
= kmalloc(sizeof(ax25_digi
), GFP_ATOMIC
)) == NULL
) {
386 ax25_destroy_socket(ax25
);
393 kfree(ax25
->digipeat
);
394 ax25
->digipeat
= NULL
;
396 /* Reverse the source SABM's path */
397 memcpy(ax25
->digipeat
, &reverse_dp
, sizeof(ax25_digi
));
400 if ((*skb
->data
& ~AX25_PF
) == AX25_SABME
) {
401 ax25
->modulus
= AX25_EMODULUS
;
402 ax25
->window
= ax25_dev
->values
[AX25_VALUES_EWINDOW
];
404 ax25
->modulus
= AX25_MODULUS
;
405 ax25
->window
= ax25_dev
->values
[AX25_VALUES_WINDOW
];
408 ax25_send_control(ax25
, AX25_UA
, AX25_POLLON
, AX25_RESPONSE
);
410 #ifdef CONFIG_AX25_DAMA_SLAVE
411 if (dama
&& ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
] == AX25_PROTO_DAMA_SLAVE
)
415 ax25
->state
= AX25_STATE_3
;
419 ax25_start_heartbeat(ax25
);
420 ax25_start_t3timer(ax25
);
421 ax25_start_idletimer(ax25
);
424 if (!sock_flag(sk
, SOCK_DEAD
))
425 sk
->sk_data_ready(sk
, skb
->len
);
435 * Receive an AX.25 frame via a SLIP interface.
437 int ax25_kiss_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
438 struct packet_type
*ptype
, struct net_device
*orig_dev
)
440 skb
->sk
= NULL
; /* Initially we don't know who it's for */
441 skb
->destructor
= NULL
; /* Who initializes this, dammit?! */
443 if (!net_eq(dev_net(dev
), &init_net
)) {
448 if ((*skb
->data
& 0x0F) != 0) {
449 kfree_skb(skb
); /* Not a KISS data frame */
453 skb_pull(skb
, AX25_KISS_HEADER_LEN
); /* Remove the KISS byte */
455 return ax25_rcv(skb
, dev
, (ax25_address
*)dev
->dev_addr
, ptype
);