[AX25/NETROM]: Cleanup direct calls into IP stack
[linux-2.6.git] / net / netrom / nr_subr.c
1 /*
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.
6  *
7  * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
8  */
9 #include <linux/errno.h>
10 #include <linux/types.h>
11 #include <linux/socket.h>
12 #include <linux/in.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/timer.h>
16 #include <linux/string.h>
17 #include <linux/sockios.h>
18 #include <linux/net.h>
19 #include <net/ax25.h>
20 #include <linux/inet.h>
21 #include <linux/netdevice.h>
22 #include <linux/skbuff.h>
23 #include <net/sock.h>
24 #include <net/tcp_states.h>
25 #include <asm/uaccess.h>
26 #include <asm/system.h>
27 #include <linux/fcntl.h>
28 #include <linux/mm.h>
29 #include <linux/interrupt.h>
30 #include <net/netrom.h>
31
32 /*
33  *      This routine purges all of the queues of frames.
34  */
35 void nr_clear_queues(struct sock *sk)
36 {
37         struct nr_sock *nr = nr_sk(sk);
38
39         skb_queue_purge(&sk->sk_write_queue);
40         skb_queue_purge(&nr->ack_queue);
41         skb_queue_purge(&nr->reseq_queue);
42         skb_queue_purge(&nr->frag_queue);
43 }
44
45 /*
46  * This routine purges the input queue of those frames that have been
47  * acknowledged. This replaces the boxes labelled "V(a) <- N(r)" on the
48  * SDL diagram.
49  */
50 void nr_frames_acked(struct sock *sk, unsigned short nr)
51 {
52         struct nr_sock *nrom = nr_sk(sk);
53         struct sk_buff *skb;
54
55         /*
56          * Remove all the ack-ed frames from the ack queue.
57          */
58         if (nrom->va != nr) {
59                 while (skb_peek(&nrom->ack_queue) != NULL && nrom->va != nr) {
60                         skb = skb_dequeue(&nrom->ack_queue);
61                         kfree_skb(skb);
62                         nrom->va = (nrom->va + 1) % NR_MODULUS;
63                 }
64         }
65 }
66
67 /*
68  * Requeue all the un-ack-ed frames on the output queue to be picked
69  * up by nr_kick called from the timer. This arrangement handles the
70  * possibility of an empty output queue.
71  */
72 void nr_requeue_frames(struct sock *sk)
73 {
74         struct sk_buff *skb, *skb_prev = NULL;
75
76         while ((skb = skb_dequeue(&nr_sk(sk)->ack_queue)) != NULL) {
77                 if (skb_prev == NULL)
78                         skb_queue_head(&sk->sk_write_queue, skb);
79                 else
80                         skb_append(skb_prev, skb, &sk->sk_write_queue);
81                 skb_prev = skb;
82         }
83 }
84
85 /*
86  *      Validate that the value of nr is between va and vs. Return true or
87  *      false for testing.
88  */
89 int nr_validate_nr(struct sock *sk, unsigned short nr)
90 {
91         struct nr_sock *nrom = nr_sk(sk);
92         unsigned short vc = nrom->va;
93
94         while (vc != nrom->vs) {
95                 if (nr == vc) return 1;
96                 vc = (vc + 1) % NR_MODULUS;
97         }
98
99         return nr == nrom->vs;
100 }
101
102 /*
103  *      Check that ns is within the receive window.
104  */
105 int nr_in_rx_window(struct sock *sk, unsigned short ns)
106 {
107         struct nr_sock *nr = nr_sk(sk);
108         unsigned short vc = nr->vr;
109         unsigned short vt = (nr->vl + nr->window) % NR_MODULUS;
110
111         while (vc != vt) {
112                 if (ns == vc) return 1;
113                 vc = (vc + 1) % NR_MODULUS;
114         }
115
116         return 0;
117 }
118
119 /*
120  *  This routine is called when the HDLC layer internally generates a
121  *  control frame.
122  */
123 void nr_write_internal(struct sock *sk, int frametype)
124 {
125         struct nr_sock *nr = nr_sk(sk);
126         struct sk_buff *skb;
127         unsigned char  *dptr;
128         int len, timeout;
129
130         len = NR_NETWORK_LEN + NR_TRANSPORT_LEN;
131
132         switch (frametype & 0x0F) {
133         case NR_CONNREQ:
134                 len += 17;
135                 break;
136         case NR_CONNACK:
137                 len += (nr->bpqext) ? 2 : 1;
138                 break;
139         case NR_DISCREQ:
140         case NR_DISCACK:
141         case NR_INFOACK:
142                 break;
143         default:
144                 printk(KERN_ERR "NET/ROM: nr_write_internal - invalid frame type %d\n", frametype);
145                 return;
146         }
147
148         if ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL)
149                 return;
150
151         /*
152          *      Space for AX.25 and NET/ROM network header
153          */
154         skb_reserve(skb, NR_NETWORK_LEN);
155
156         dptr = skb_put(skb, skb_tailroom(skb));
157
158         switch (frametype & 0x0F) {
159         case NR_CONNREQ:
160                 timeout  = nr->t1 / HZ;
161                 *dptr++  = nr->my_index;
162                 *dptr++  = nr->my_id;
163                 *dptr++  = 0;
164                 *dptr++  = 0;
165                 *dptr++  = frametype;
166                 *dptr++  = nr->window;
167                 memcpy(dptr, &nr->user_addr, AX25_ADDR_LEN);
168                 dptr[6] &= ~AX25_CBIT;
169                 dptr[6] &= ~AX25_EBIT;
170                 dptr[6] |= AX25_SSSID_SPARE;
171                 dptr    += AX25_ADDR_LEN;
172                 memcpy(dptr, &nr->source_addr, AX25_ADDR_LEN);
173                 dptr[6] &= ~AX25_CBIT;
174                 dptr[6] &= ~AX25_EBIT;
175                 dptr[6] |= AX25_SSSID_SPARE;
176                 dptr    += AX25_ADDR_LEN;
177                 *dptr++  = timeout % 256;
178                 *dptr++  = timeout / 256;
179                 break;
180
181         case NR_CONNACK:
182                 *dptr++ = nr->your_index;
183                 *dptr++ = nr->your_id;
184                 *dptr++ = nr->my_index;
185                 *dptr++ = nr->my_id;
186                 *dptr++ = frametype;
187                 *dptr++ = nr->window;
188                 if (nr->bpqext) *dptr++ = sysctl_netrom_network_ttl_initialiser;
189                 break;
190
191         case NR_DISCREQ:
192         case NR_DISCACK:
193                 *dptr++ = nr->your_index;
194                 *dptr++ = nr->your_id;
195                 *dptr++ = 0;
196                 *dptr++ = 0;
197                 *dptr++ = frametype;
198                 break;
199
200         case NR_INFOACK:
201                 *dptr++ = nr->your_index;
202                 *dptr++ = nr->your_id;
203                 *dptr++ = 0;
204                 *dptr++ = nr->vr;
205                 *dptr++ = frametype;
206                 break;
207         }
208
209         nr_transmit_buffer(sk, skb);
210 }
211
212 /*
213  * This routine is called when a Connect Acknowledge with the Choke Flag
214  * set is needed to refuse a connection.
215  */
216 void nr_transmit_refusal(struct sk_buff *skb, int mine)
217 {
218         struct sk_buff *skbn;
219         unsigned char *dptr;
220         int len;
221
222         len = NR_NETWORK_LEN + NR_TRANSPORT_LEN + 1;
223
224         if ((skbn = alloc_skb(len, GFP_ATOMIC)) == NULL)
225                 return;
226
227         skb_reserve(skbn, 0);
228
229         dptr = skb_put(skbn, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
230
231         memcpy(dptr, skb->data + 7, AX25_ADDR_LEN);
232         dptr[6] &= ~AX25_CBIT;
233         dptr[6] &= ~AX25_EBIT;
234         dptr[6] |= AX25_SSSID_SPARE;
235         dptr += AX25_ADDR_LEN;
236
237         memcpy(dptr, skb->data + 0, AX25_ADDR_LEN);
238         dptr[6] &= ~AX25_CBIT;
239         dptr[6] |= AX25_EBIT;
240         dptr[6] |= AX25_SSSID_SPARE;
241         dptr += AX25_ADDR_LEN;
242
243         *dptr++ = sysctl_netrom_network_ttl_initialiser;
244
245         if (mine) {
246                 *dptr++ = 0;
247                 *dptr++ = 0;
248                 *dptr++ = skb->data[15];
249                 *dptr++ = skb->data[16];
250         } else {
251                 *dptr++ = skb->data[15];
252                 *dptr++ = skb->data[16];
253                 *dptr++ = 0;
254                 *dptr++ = 0;
255         }
256
257         *dptr++ = NR_CONNACK | NR_CHOKE_FLAG;
258         *dptr++ = 0;
259
260         if (!nr_route_frame(skbn, NULL))
261                 kfree_skb(skbn);
262 }
263
264 void nr_disconnect(struct sock *sk, int reason)
265 {
266         nr_stop_t1timer(sk);
267         nr_stop_t2timer(sk);
268         nr_stop_t4timer(sk);
269         nr_stop_idletimer(sk);
270
271         nr_clear_queues(sk);
272
273         nr_sk(sk)->state = NR_STATE_0;
274
275         sk->sk_state     = TCP_CLOSE;
276         sk->sk_err       = reason;
277         sk->sk_shutdown |= SEND_SHUTDOWN;
278
279         if (!sock_flag(sk, SOCK_DEAD)) {
280                 sk->sk_state_change(sk);
281                 sock_set_flag(sk, SOCK_DEAD);
282         }
283 }