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