blob: 9d20904f6f52ebe60b5cdbe2c0b0de42a92a7a5e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * DECnet An implementation of the DECnet protocol suite for the LINUX
3 * operating system. DECnet is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * DECnet Network Services Protocol (Input)
7 *
8 * Author: Eduardo Marcelo Serrat <emserrat@geocities.com>
9 *
10 * Changes:
11 *
12 * Steve Whitehouse: Split into dn_nsp_in.c and dn_nsp_out.c from
13 * original dn_nsp.c.
14 * Steve Whitehouse: Updated to work with my new routing architecture.
15 * Steve Whitehouse: Add changes from Eduardo Serrat's patches.
16 * Steve Whitehouse: Put all ack handling code in a common routine.
17 * Steve Whitehouse: Put other common bits into dn_nsp_rx()
18 * Steve Whitehouse: More checks on skb->len to catch bogus packets
19 * Fixed various race conditions and possible nasties.
20 * Steve Whitehouse: Now handles returned conninit frames.
21 * David S. Miller: New socket locking
22 * Steve Whitehouse: Fixed lockup when socket filtering was enabled.
23 * Paul Koning: Fix to push CC sockets into RUN when acks are
24 * received.
25 * Steve Whitehouse:
26 * Patrick Caulfield: Checking conninits for correctness & sending of error
27 * responses.
28 * Steve Whitehouse: Added backlog congestion level return codes.
29 * Patrick Caulfield:
30 * Steve Whitehouse: Added flow control support (outbound)
31 * Steve Whitehouse: Prepare for nonlinear skbs
32 */
33
34/******************************************************************************
35 (c) 1995-1998 E.M. Serrat emserrat@geocities.com
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +090036
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 This program is free software; you can redistribute it and/or modify
38 it under the terms of the GNU General Public License as published by
39 the Free Software Foundation; either version 2 of the License, or
40 any later version.
41
42 This program is distributed in the hope that it will be useful,
43 but WITHOUT ANY WARRANTY; without even the implied warranty of
44 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 GNU General Public License for more details.
46*******************************************************************************/
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/errno.h>
49#include <linux/types.h>
50#include <linux/socket.h>
51#include <linux/in.h>
52#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/timer.h>
54#include <linux/string.h>
55#include <linux/sockios.h>
56#include <linux/net.h>
57#include <linux/netdevice.h>
58#include <linux/inet.h>
59#include <linux/route.h>
60#include <net/sock.h>
Arnaldo Carvalho de Meloc752f072005-08-09 20:08:28 -070061#include <net/tcp_states.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#include <asm/system.h>
63#include <linux/fcntl.h>
64#include <linux/mm.h>
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +090065#include <linux/termios.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#include <linux/interrupt.h>
67#include <linux/proc_fs.h>
68#include <linux/stat.h>
69#include <linux/init.h>
70#include <linux/poll.h>
71#include <linux/netfilter_decnet.h>
72#include <net/neighbour.h>
73#include <net/dst.h>
74#include <net/dn.h>
75#include <net/dn_nsp.h>
76#include <net/dn_dev.h>
77#include <net/dn_route.h>
78
79extern int decnet_log_martians;
80
81static void dn_log_martian(struct sk_buff *skb, const char *msg)
82{
83 if (decnet_log_martians && net_ratelimit()) {
84 char *devname = skb->dev ? skb->dev->name : "???";
85 struct dn_skb_cb *cb = DN_SKB_CB(skb);
Steven Whitehousec4ea94a2006-03-20 22:42:39 -080086 printk(KERN_INFO "DECnet: Martian packet (%s) dev=%s src=0x%04hx dst=0x%04hx srcport=0x%04hx dstport=0x%04hx\n", msg, devname, dn_ntohs(cb->src), dn_ntohs(cb->dst), dn_ntohs(cb->src_port), dn_ntohs(cb->dst_port));
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 }
88}
89
90/*
91 * For this function we've flipped the cross-subchannel bit
92 * if the message is an otherdata or linkservice message. Thus
93 * we can use it to work out what to update.
94 */
95static void dn_ack(struct sock *sk, struct sk_buff *skb, unsigned short ack)
96{
97 struct dn_scp *scp = DN_SK(sk);
98 unsigned short type = ((ack >> 12) & 0x0003);
99 int wakeup = 0;
100
101 switch(type) {
102 case 0: /* ACK - Data */
103 if (dn_after(ack, scp->ackrcv_dat)) {
104 scp->ackrcv_dat = ack & 0x0fff;
105 wakeup |= dn_nsp_check_xmit_queue(sk, skb, &scp->data_xmit_queue, ack);
106 }
107 break;
108 case 1: /* NAK - Data */
109 break;
110 case 2: /* ACK - OtherData */
111 if (dn_after(ack, scp->ackrcv_oth)) {
112 scp->ackrcv_oth = ack & 0x0fff;
113 wakeup |= dn_nsp_check_xmit_queue(sk, skb, &scp->other_xmit_queue, ack);
114 }
115 break;
116 case 3: /* NAK - OtherData */
117 break;
118 }
119
120 if (wakeup && !sock_flag(sk, SOCK_DEAD))
121 sk->sk_state_change(sk);
122}
123
124/*
125 * This function is a universal ack processor.
126 */
127static int dn_process_ack(struct sock *sk, struct sk_buff *skb, int oth)
128{
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800129 __le16 *ptr = (__le16 *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 int len = 0;
131 unsigned short ack;
132
133 if (skb->len < 2)
134 return len;
135
136 if ((ack = dn_ntohs(*ptr)) & 0x8000) {
137 skb_pull(skb, 2);
138 ptr++;
139 len += 2;
140 if ((ack & 0x4000) == 0) {
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900141 if (oth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 ack ^= 0x2000;
143 dn_ack(sk, skb, ack);
144 }
145 }
146
147 if (skb->len < 2)
148 return len;
149
150 if ((ack = dn_ntohs(*ptr)) & 0x8000) {
151 skb_pull(skb, 2);
152 len += 2;
153 if ((ack & 0x4000) == 0) {
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900154 if (oth)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 ack ^= 0x2000;
156 dn_ack(sk, skb, ack);
157 }
158 }
159
160 return len;
161}
162
163
164/**
165 * dn_check_idf - Check an image data field format is correct.
166 * @pptr: Pointer to pointer to image data
167 * @len: Pointer to length of image data
168 * @max: The maximum allowed length of the data in the image data field
169 * @follow_on: Check that this many bytes exist beyond the end of the image data
170 *
171 * Returns: 0 if ok, -1 on error
172 */
173static inline int dn_check_idf(unsigned char **pptr, int *len, unsigned char max, unsigned char follow_on)
174{
175 unsigned char *ptr = *pptr;
176 unsigned char flen = *ptr++;
177
178 (*len)--;
179 if (flen > max)
180 return -1;
181 if ((flen + follow_on) > *len)
182 return -1;
183
184 *len -= flen;
185 *pptr = ptr + flen;
186 return 0;
187}
188
189/*
190 * Table of reason codes to pass back to node which sent us a badly
191 * formed message, plus text messages for the log. A zero entry in
192 * the reason field means "don't reply" otherwise a disc init is sent with
193 * the specified reason code.
194 */
195static struct {
196 unsigned short reason;
197 const char *text;
198} ci_err_table[] = {
199 { 0, "CI: Truncated message" },
200 { NSP_REASON_ID, "CI: Destination username error" },
201 { NSP_REASON_ID, "CI: Destination username type" },
202 { NSP_REASON_US, "CI: Source username error" },
203 { 0, "CI: Truncated at menuver" },
204 { 0, "CI: Truncated before access or user data" },
205 { NSP_REASON_IO, "CI: Access data format error" },
206 { NSP_REASON_IO, "CI: User data format error" }
207};
208
209/*
210 * This function uses a slightly different lookup method
211 * to find its sockets, since it searches on object name/number
212 * rather than port numbers. Various tests are done to ensure that
213 * the incoming data is in the correct format before it is queued to
214 * a socket.
215 */
216static struct sock *dn_find_listener(struct sk_buff *skb, unsigned short *reason)
217{
218 struct dn_skb_cb *cb = DN_SKB_CB(skb);
219 struct nsp_conn_init_msg *msg = (struct nsp_conn_init_msg *)skb->data;
220 struct sockaddr_dn dstaddr;
221 struct sockaddr_dn srcaddr;
222 unsigned char type = 0;
223 int dstlen;
224 int srclen;
225 unsigned char *ptr;
226 int len;
227 int err = 0;
228 unsigned char menuver;
229
230 memset(&dstaddr, 0, sizeof(struct sockaddr_dn));
231 memset(&srcaddr, 0, sizeof(struct sockaddr_dn));
232
233 /*
234 * 1. Decode & remove message header
235 */
236 cb->src_port = msg->srcaddr;
237 cb->dst_port = msg->dstaddr;
238 cb->services = msg->services;
239 cb->info = msg->info;
240 cb->segsize = dn_ntohs(msg->segsize);
241
242 if (!pskb_may_pull(skb, sizeof(*msg)))
243 goto err_out;
244
245 skb_pull(skb, sizeof(*msg));
246
247 len = skb->len;
248 ptr = skb->data;
249
250 /*
251 * 2. Check destination end username format
252 */
253 dstlen = dn_username2sockaddr(ptr, len, &dstaddr, &type);
254 err++;
255 if (dstlen < 0)
256 goto err_out;
257
258 err++;
259 if (type > 1)
260 goto err_out;
261
262 len -= dstlen;
263 ptr += dstlen;
264
265 /*
266 * 3. Check source end username format
267 */
268 srclen = dn_username2sockaddr(ptr, len, &srcaddr, &type);
269 err++;
270 if (srclen < 0)
271 goto err_out;
272
273 len -= srclen;
274 ptr += srclen;
275 err++;
276 if (len < 1)
277 goto err_out;
278
279 menuver = *ptr;
280 ptr++;
281 len--;
282
283 /*
284 * 4. Check that optional data actually exists if menuver says it does
285 */
286 err++;
287 if ((menuver & (DN_MENUVER_ACC | DN_MENUVER_USR)) && (len < 1))
288 goto err_out;
289
290 /*
291 * 5. Check optional access data format
292 */
293 err++;
294 if (menuver & DN_MENUVER_ACC) {
295 if (dn_check_idf(&ptr, &len, 39, 1))
296 goto err_out;
297 if (dn_check_idf(&ptr, &len, 39, 1))
298 goto err_out;
299 if (dn_check_idf(&ptr, &len, 39, (menuver & DN_MENUVER_USR) ? 1 : 0))
300 goto err_out;
301 }
302
303 /*
304 * 6. Check optional user data format
305 */
306 err++;
307 if (menuver & DN_MENUVER_USR) {
308 if (dn_check_idf(&ptr, &len, 16, 0))
309 goto err_out;
310 }
311
312 /*
313 * 7. Look up socket based on destination end username
314 */
315 return dn_sklist_find_listener(&dstaddr);
316err_out:
317 dn_log_martian(skb, ci_err_table[err].text);
318 *reason = ci_err_table[err].reason;
319 return NULL;
320}
321
322
323static void dn_nsp_conn_init(struct sock *sk, struct sk_buff *skb)
324{
325 if (sk_acceptq_is_full(sk)) {
326 kfree_skb(skb);
327 return;
328 }
329
330 sk->sk_ack_backlog++;
331 skb_queue_tail(&sk->sk_receive_queue, skb);
332 sk->sk_state_change(sk);
333}
334
335static void dn_nsp_conn_conf(struct sock *sk, struct sk_buff *skb)
336{
337 struct dn_skb_cb *cb = DN_SKB_CB(skb);
338 struct dn_scp *scp = DN_SK(sk);
339 unsigned char *ptr;
340
341 if (skb->len < 4)
342 goto out;
343
344 ptr = skb->data;
345 cb->services = *ptr++;
346 cb->info = *ptr++;
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800347 cb->segsize = dn_ntohs(*(__le16 *)ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
349 if ((scp->state == DN_CI) || (scp->state == DN_CD)) {
350 scp->persist = 0;
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900351 scp->addrrem = cb->src_port;
352 sk->sk_state = TCP_ESTABLISHED;
353 scp->state = DN_RUN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 scp->services_rem = cb->services;
355 scp->info_rem = cb->info;
356 scp->segsize_rem = cb->segsize;
357
358 if ((scp->services_rem & NSP_FC_MASK) == NSP_FC_NONE)
359 scp->max_window = decnet_no_fc_max_cwnd;
360
361 if (skb->len > 0) {
Steven Whitehouse375d9d72006-11-07 15:09:17 -0800362 u16 dlen = *skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 if ((dlen <= 16) && (dlen <= skb->len)) {
Steven Whitehouse375d9d72006-11-07 15:09:17 -0800364 scp->conndata_in.opt_optl = dn_htons(dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 memcpy(scp->conndata_in.opt_data, skb->data + 1, dlen);
366 }
367 }
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900368 dn_nsp_send_link(sk, DN_NOCHANGE, 0);
369 if (!sock_flag(sk, SOCK_DEAD))
370 sk->sk_state_change(sk);
371 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373out:
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900374 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375}
376
377static void dn_nsp_conn_ack(struct sock *sk, struct sk_buff *skb)
378{
379 struct dn_scp *scp = DN_SK(sk);
380
381 if (scp->state == DN_CI) {
382 scp->state = DN_CD;
383 scp->persist = 0;
384 }
385
386 kfree_skb(skb);
387}
388
389static void dn_nsp_disc_init(struct sock *sk, struct sk_buff *skb)
390{
391 struct dn_scp *scp = DN_SK(sk);
392 struct dn_skb_cb *cb = DN_SKB_CB(skb);
393 unsigned short reason;
394
395 if (skb->len < 2)
396 goto out;
397
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800398 reason = dn_ntohs(*(__le16 *)skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 skb_pull(skb, 2);
400
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800401 scp->discdata_in.opt_status = dn_htons(reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 scp->discdata_in.opt_optl = 0;
403 memset(scp->discdata_in.opt_data, 0, 16);
404
405 if (skb->len > 0) {
Steven Whitehouse375d9d72006-11-07 15:09:17 -0800406 u16 dlen = *skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 if ((dlen <= 16) && (dlen <= skb->len)) {
Steven Whitehouse375d9d72006-11-07 15:09:17 -0800408 scp->discdata_in.opt_optl = dn_htons(dlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 memcpy(scp->discdata_in.opt_data, skb->data + 1, dlen);
410 }
411 }
412
413 scp->addrrem = cb->src_port;
414 sk->sk_state = TCP_CLOSE;
415
416 switch(scp->state) {
417 case DN_CI:
418 case DN_CD:
419 scp->state = DN_RJ;
420 sk->sk_err = ECONNREFUSED;
421 break;
422 case DN_RUN:
423 sk->sk_shutdown |= SHUTDOWN_MASK;
424 scp->state = DN_DN;
425 break;
426 case DN_DI:
427 scp->state = DN_DIC;
428 break;
429 }
430
431 if (!sock_flag(sk, SOCK_DEAD)) {
432 if (sk->sk_socket->state != SS_UNCONNECTED)
433 sk->sk_socket->state = SS_DISCONNECTING;
434 sk->sk_state_change(sk);
435 }
436
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900437 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 * It appears that its possible for remote machines to send disc
439 * init messages with no port identifier if we are in the CI and
440 * possibly also the CD state. Obviously we shouldn't reply with
441 * a message if we don't know what the end point is.
442 */
443 if (scp->addrrem) {
444 dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, GFP_ATOMIC);
445 }
446 scp->persist_fxn = dn_destroy_timer;
447 scp->persist = dn_nsp_persist(sk);
448
449out:
450 kfree_skb(skb);
451}
452
453/*
454 * disc_conf messages are also called no_resources or no_link
455 * messages depending upon the "reason" field.
456 */
457static void dn_nsp_disc_conf(struct sock *sk, struct sk_buff *skb)
458{
459 struct dn_scp *scp = DN_SK(sk);
460 unsigned short reason;
461
462 if (skb->len != 2)
463 goto out;
464
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800465 reason = dn_ntohs(*(__le16 *)skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
467 sk->sk_state = TCP_CLOSE;
468
469 switch(scp->state) {
470 case DN_CI:
471 scp->state = DN_NR;
472 break;
473 case DN_DR:
474 if (reason == NSP_REASON_DC)
475 scp->state = DN_DRC;
476 if (reason == NSP_REASON_NL)
477 scp->state = DN_CN;
478 break;
479 case DN_DI:
480 scp->state = DN_DIC;
481 break;
482 case DN_RUN:
483 sk->sk_shutdown |= SHUTDOWN_MASK;
484 case DN_CC:
485 scp->state = DN_CN;
486 }
487
488 if (!sock_flag(sk, SOCK_DEAD)) {
489 if (sk->sk_socket->state != SS_UNCONNECTED)
490 sk->sk_socket->state = SS_DISCONNECTING;
491 sk->sk_state_change(sk);
492 }
493
494 scp->persist_fxn = dn_destroy_timer;
495 scp->persist = dn_nsp_persist(sk);
496
497out:
498 kfree_skb(skb);
499}
500
501static void dn_nsp_linkservice(struct sock *sk, struct sk_buff *skb)
502{
503 struct dn_scp *scp = DN_SK(sk);
504 unsigned short segnum;
505 unsigned char lsflags;
506 signed char fcval;
507 int wake_up = 0;
508 char *ptr = skb->data;
509 unsigned char fctype = scp->services_rem & NSP_FC_MASK;
510
511 if (skb->len != 4)
512 goto out;
513
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800514 segnum = dn_ntohs(*(__le16 *)ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 ptr += 2;
516 lsflags = *(unsigned char *)ptr++;
517 fcval = *ptr;
518
519 /*
520 * Here we ignore erronous packets which should really
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900521 * should cause a connection abort. It is not critical
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 * for now though.
523 */
524 if (lsflags & 0xf8)
525 goto out;
526
527 if (seq_next(scp->numoth_rcv, segnum)) {
528 seq_add(&scp->numoth_rcv, 1);
529 switch(lsflags & 0x04) { /* FCVAL INT */
530 case 0x00: /* Normal Request */
531 switch(lsflags & 0x03) { /* FCVAL MOD */
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900532 case 0x00: /* Request count */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 if (fcval < 0) {
534 unsigned char p_fcval = -fcval;
535 if ((scp->flowrem_dat > p_fcval) &&
536 (fctype == NSP_FC_SCMC)) {
537 scp->flowrem_dat -= p_fcval;
538 }
539 } else if (fcval > 0) {
540 scp->flowrem_dat += fcval;
541 wake_up = 1;
542 }
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900543 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 case 0x01: /* Stop outgoing data */
545 scp->flowrem_sw = DN_DONTSEND;
546 break;
547 case 0x02: /* Ok to start again */
548 scp->flowrem_sw = DN_SEND;
549 dn_nsp_output(sk);
550 wake_up = 1;
551 }
552 break;
553 case 0x04: /* Interrupt Request */
554 if (fcval > 0) {
555 scp->flowrem_oth += fcval;
556 wake_up = 1;
557 }
558 break;
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900559 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if (wake_up && !sock_flag(sk, SOCK_DEAD))
561 sk->sk_state_change(sk);
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
564 dn_nsp_send_oth_ack(sk);
565
566out:
567 kfree_skb(skb);
568}
569
570/*
571 * Copy of sock_queue_rcv_skb (from sock.h) without
572 * bh_lock_sock() (its already held when this is called) which
573 * also allows data and other data to be queued to a socket.
574 */
575static __inline__ int dn_queue_skb(struct sock *sk, struct sk_buff *skb, int sig, struct sk_buff_head *queue)
576{
577 int err;
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900578
579 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
580 number of warnings when compiling with -W --ANK
581 */
582 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 (unsigned)sk->sk_rcvbuf) {
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900584 err = -ENOMEM;
585 goto out;
586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700588 err = sk_filter(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 if (err)
590 goto out;
591
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900592 skb_set_owner_r(skb, sk);
593 skb_queue_tail(queue, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
595 /* This code only runs from BH or BH protected context.
596 * Therefore the plain read_lock is ok here. -DaveM
597 */
598 read_lock(&sk->sk_callback_lock);
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900599 if (!sock_flag(sk, SOCK_DEAD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 struct socket *sock = sk->sk_socket;
601 wake_up_interruptible(sk->sk_sleep);
602 if (sock && sock->fasync_list &&
603 !test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900604 __kill_fasync(sock->fasync_list, sig,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 (sig == SIGURG) ? POLL_PRI : POLL_IN);
606 }
607 read_unlock(&sk->sk_callback_lock);
608out:
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900609 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610}
611
612static void dn_nsp_otherdata(struct sock *sk, struct sk_buff *skb)
613{
614 struct dn_scp *scp = DN_SK(sk);
615 unsigned short segnum;
616 struct dn_skb_cb *cb = DN_SKB_CB(skb);
617 int queued = 0;
618
619 if (skb->len < 2)
620 goto out;
621
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800622 cb->segnum = segnum = dn_ntohs(*(__le16 *)skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 skb_pull(skb, 2);
624
625 if (seq_next(scp->numoth_rcv, segnum)) {
626
627 if (dn_queue_skb(sk, skb, SIGURG, &scp->other_receive_queue) == 0) {
628 seq_add(&scp->numoth_rcv, 1);
629 scp->other_report = 0;
630 queued = 1;
631 }
632 }
633
634 dn_nsp_send_oth_ack(sk);
635out:
636 if (!queued)
637 kfree_skb(skb);
638}
639
640static void dn_nsp_data(struct sock *sk, struct sk_buff *skb)
641{
642 int queued = 0;
643 unsigned short segnum;
644 struct dn_skb_cb *cb = DN_SKB_CB(skb);
645 struct dn_scp *scp = DN_SK(sk);
646
647 if (skb->len < 2)
648 goto out;
649
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800650 cb->segnum = segnum = dn_ntohs(*(__le16 *)skb->data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 skb_pull(skb, 2);
652
653 if (seq_next(scp->numdat_rcv, segnum)) {
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900654 if (dn_queue_skb(sk, skb, SIGIO, &sk->sk_receive_queue) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 seq_add(&scp->numdat_rcv, 1);
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900656 queued = 1;
657 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
659 if ((scp->flowloc_sw == DN_SEND) && dn_congested(sk)) {
660 scp->flowloc_sw = DN_DONTSEND;
661 dn_nsp_send_link(sk, DN_DONTSEND, 0);
662 }
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900663 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
665 dn_nsp_send_data_ack(sk);
666out:
667 if (!queued)
668 kfree_skb(skb);
669}
670
671/*
672 * If one of our conninit messages is returned, this function
673 * deals with it. It puts the socket into the NO_COMMUNICATION
674 * state.
675 */
676static void dn_returned_conn_init(struct sock *sk, struct sk_buff *skb)
677{
678 struct dn_scp *scp = DN_SK(sk);
679
680 if (scp->state == DN_CI) {
681 scp->state = DN_NC;
682 sk->sk_state = TCP_CLOSE;
683 if (!sock_flag(sk, SOCK_DEAD))
684 sk->sk_state_change(sk);
685 }
686
687 kfree_skb(skb);
688}
689
690static int dn_nsp_no_socket(struct sk_buff *skb, unsigned short reason)
691{
692 struct dn_skb_cb *cb = DN_SKB_CB(skb);
693 int ret = NET_RX_DROP;
694
695 /* Must not reply to returned packets */
696 if (cb->rt_flags & DN_RT_F_RTS)
697 goto out;
698
699 if ((reason != NSP_REASON_OK) && ((cb->nsp_flags & 0x0c) == 0x08)) {
700 switch(cb->nsp_flags & 0x70) {
701 case 0x10:
702 case 0x60: /* (Retransmitted) Connect Init */
703 dn_nsp_return_disc(skb, NSP_DISCINIT, reason);
704 ret = NET_RX_SUCCESS;
705 break;
706 case 0x20: /* Connect Confirm */
707 dn_nsp_return_disc(skb, NSP_DISCCONF, reason);
708 ret = NET_RX_SUCCESS;
709 break;
710 }
711 }
712
713out:
714 kfree_skb(skb);
715 return ret;
716}
717
718static int dn_nsp_rx_packet(struct sk_buff *skb)
719{
720 struct dn_skb_cb *cb = DN_SKB_CB(skb);
721 struct sock *sk = NULL;
722 unsigned char *ptr = (unsigned char *)skb->data;
723 unsigned short reason = NSP_REASON_NL;
724
725 if (!pskb_may_pull(skb, 2))
726 goto free_out;
727
728 skb->h.raw = skb->data;
729 cb->nsp_flags = *ptr++;
730
731 if (decnet_debug_level & 2)
732 printk(KERN_DEBUG "dn_nsp_rx: Message type 0x%02x\n", (int)cb->nsp_flags);
733
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900734 if (cb->nsp_flags & 0x83)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 goto free_out;
736
737 /*
738 * Filter out conninits and useless packet types
739 */
740 if ((cb->nsp_flags & 0x0c) == 0x08) {
741 switch(cb->nsp_flags & 0x70) {
742 case 0x00: /* NOP */
743 case 0x70: /* Reserved */
744 case 0x50: /* Reserved, Phase II node init */
745 goto free_out;
746 case 0x10:
747 case 0x60:
748 if (unlikely(cb->rt_flags & DN_RT_F_RTS))
749 goto free_out;
750 sk = dn_find_listener(skb, &reason);
751 goto got_it;
752 }
753 }
754
755 if (!pskb_may_pull(skb, 3))
756 goto free_out;
757
758 /*
759 * Grab the destination address.
760 */
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800761 cb->dst_port = *(__le16 *)ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 cb->src_port = 0;
763 ptr += 2;
764
765 /*
766 * If not a connack, grab the source address too.
767 */
768 if (pskb_may_pull(skb, 5)) {
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800769 cb->src_port = *(__le16 *)ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 ptr += 2;
771 skb_pull(skb, 5);
772 }
773
774 /*
775 * Returned packets...
776 * Swap src & dst and look up in the normal way.
777 */
778 if (unlikely(cb->rt_flags & DN_RT_F_RTS)) {
Steven Whitehousec4ea94a2006-03-20 22:42:39 -0800779 __le16 tmp = cb->dst_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 cb->dst_port = cb->src_port;
781 cb->src_port = tmp;
782 tmp = cb->dst;
783 cb->dst = cb->src;
784 cb->src = tmp;
785 }
786
787 /*
788 * Find the socket to which this skb is destined.
789 */
790 sk = dn_find_by_skb(skb);
791got_it:
792 if (sk != NULL) {
793 struct dn_scp *scp = DN_SK(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 /* Reset backoff */
796 scp->nsp_rxtshift = 0;
797
798 /*
799 * We linearize everything except data segments here.
800 */
801 if (cb->nsp_flags & ~0x60) {
Herbert Xu364c6ba2006-06-09 16:10:40 -0700802 if (unlikely(skb_linearize(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 goto free_out;
804 }
805
Arnaldo Carvalho de Melo58a5a7b2006-11-16 14:06:06 -0200806 return sk_receive_skb(sk, skb, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 }
808
809 return dn_nsp_no_socket(skb, reason);
810
811free_out:
812 kfree_skb(skb);
813 return NET_RX_DROP;
814}
815
816int dn_nsp_rx(struct sk_buff *skb)
817{
818 return NF_HOOK(PF_DECnet, NF_DN_LOCAL_IN, skb, skb->dev, NULL, dn_nsp_rx_packet);
819}
820
821/*
822 * This is the main receive routine for sockets. It is called
823 * from the above when the socket is not busy, and also from
824 * sock_release() when there is a backlog queued up.
825 */
826int dn_nsp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
827{
828 struct dn_scp *scp = DN_SK(sk);
829 struct dn_skb_cb *cb = DN_SKB_CB(skb);
830
831 if (cb->rt_flags & DN_RT_F_RTS) {
832 if (cb->nsp_flags == 0x18 || cb->nsp_flags == 0x68)
833 dn_returned_conn_init(sk, skb);
834 else
835 kfree_skb(skb);
836 return NET_RX_SUCCESS;
837 }
838
839 /*
840 * Control packet.
841 */
842 if ((cb->nsp_flags & 0x0c) == 0x08) {
843 switch(cb->nsp_flags & 0x70) {
844 case 0x10:
845 case 0x60:
846 dn_nsp_conn_init(sk, skb);
847 break;
848 case 0x20:
849 dn_nsp_conn_conf(sk, skb);
850 break;
851 case 0x30:
852 dn_nsp_disc_init(sk, skb);
853 break;
YOSHIFUJI Hideaki429eb0f2007-02-09 23:24:40 +0900854 case 0x40:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 dn_nsp_disc_conf(sk, skb);
856 break;
857 }
858
859 } else if (cb->nsp_flags == 0x24) {
860 /*
861 * Special for connacks, 'cos they don't have
862 * ack data or ack otherdata info.
863 */
864 dn_nsp_conn_ack(sk, skb);
865 } else {
866 int other = 1;
867
868 /* both data and ack frames can kick a CC socket into RUN */
869 if ((scp->state == DN_CC) && !sock_flag(sk, SOCK_DEAD)) {
870 scp->state = DN_RUN;
871 sk->sk_state = TCP_ESTABLISHED;
872 sk->sk_state_change(sk);
873 }
874
875 if ((cb->nsp_flags & 0x1c) == 0)
876 other = 0;
877 if (cb->nsp_flags == 0x04)
878 other = 0;
879
880 /*
881 * Read out ack data here, this applies equally
882 * to data, other data, link serivce and both
883 * ack data and ack otherdata.
884 */
885 dn_process_ack(sk, skb, other);
886
887 /*
888 * If we've some sort of data here then call a
889 * suitable routine for dealing with it, otherwise
890 * the packet is an ack and can be discarded.
891 */
892 if ((cb->nsp_flags & 0x0c) == 0) {
893
894 if (scp->state != DN_RUN)
895 goto free_out;
896
897 switch(cb->nsp_flags) {
898 case 0x10: /* LS */
899 dn_nsp_linkservice(sk, skb);
900 break;
901 case 0x30: /* OD */
902 dn_nsp_otherdata(sk, skb);
903 break;
904 default:
905 dn_nsp_data(sk, skb);
906 }
907
908 } else { /* Ack, chuck it out here */
909free_out:
910 kfree_skb(skb);
911 }
912 }
913
914 return NET_RX_SUCCESS;
915}
916