1/* 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 */ 32 33/****************************************************************************** 34 (c) 1995-1998 E.M. Serrat emserrat@geocities.com 35 36 This program is free software; you can redistribute it and/or modify 37 it under the terms of the GNU General Public License as published by 38 the Free Software Foundation; either version 2 of the License, or 39 any later version. 40 41 This program is distributed in the hope that it will be useful, 42 but WITHOUT ANY WARRANTY; without even the implied warranty of 43 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 44 GNU General Public License for more details. 45*******************************************************************************/ 46 47#include <linux/config.h> 48#include <linux/errno.h> 49#include <linux/types.h> 50#include <linux/socket.h> 51#include <linux/in.h> 52#include <linux/kernel.h> 53#include <linux/sched.h> 54#include <linux/timer.h> 55#include <linux/string.h> 56#include <linux/sockios.h> 57#include <linux/net.h> 58#include <linux/netdevice.h> 59#include <linux/inet.h> 60#include <linux/route.h> 61#include <net/sock.h> 62#include <asm/segment.h> 63#include <asm/system.h> 64#include <linux/fcntl.h> 65#include <linux/mm.h> 66#include <linux/termios.h> 67#include <linux/interrupt.h> 68#include <linux/proc_fs.h> 69#include <linux/stat.h> 70#include <linux/init.h> 71#include <linux/poll.h> 72#include <linux/netfilter_decnet.h> 73#include <net/neighbour.h> 74#include <net/dst.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); 86 printk(KERN_INFO "DECnet: Martian packet (%s) dev=%s src=0x%04hx dst=0x%04hx srcport=0x%04hx dstport=0x%04hx\n", msg, devname, cb->src, cb->dst, cb->src_port, cb->dst_port); 87 } 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 (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 (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 && !sk->dead) 121 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{ 129 unsigned short *ptr = (unsigned short *)skb->data; 130 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) { 141 if (oth) 142 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) { 154 if (oth) 155 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 (skb->len < 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->ack_backlog >= sk->max_ack_backlog) { 326 kfree_skb(skb); 327 return; 328 } 329 330 sk->ack_backlog++; 331 skb_queue_tail(&sk->receive_queue, skb); 332 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++; 347 cb->segsize = dn_ntohs(*(__u16 *)ptr); 348 349 if ((scp->state == DN_CI) || (scp->state == DN_CD)) { 350 scp->persist = 0; 351 scp->addrrem = cb->src_port; 352 sk->state = TCP_ESTABLISHED; 353 scp->state = DN_RUN; 354 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) { 362 unsigned char dlen = *skb->data; 363 if ((dlen <= 16) && (dlen <= skb->len)) { 364 scp->conndata_in.opt_optl = dlen; 365 memcpy(scp->conndata_in.opt_data, skb->data + 1, dlen); 366 } 367 } 368 dn_nsp_send_link(sk, DN_NOCHANGE, 0); 369 if (!sk->dead) 370 sk->state_change(sk); 371 } 372 373out: 374 kfree_skb(skb); 375} 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 398 reason = dn_ntohs(*(__u16 *)skb->data); 399 skb_pull(skb, 2); 400 401 scp->discdata_in.opt_status = reason; 402 scp->discdata_in.opt_optl = 0; 403 memset(scp->discdata_in.opt_data, 0, 16); 404 405 if (skb->len > 0) { 406 unsigned char dlen = *skb->data; 407 if ((dlen <= 16) && (dlen <= skb->len)) { 408 scp->discdata_in.opt_optl = dlen; 409 memcpy(scp->discdata_in.opt_data, skb->data + 1, dlen); 410 } 411 } 412 413 scp->addrrem = cb->src_port; 414 sk->state = TCP_CLOSE; 415 416 switch(scp->state) { 417 case DN_CI: 418 case DN_CD: 419 scp->state = DN_RJ; 420 break; 421 case DN_RUN: 422 sk->shutdown |= SHUTDOWN_MASK; 423 scp->state = DN_DN; 424 break; 425 case DN_DI: 426 scp->state = DN_DIC; 427 break; 428 } 429 430 if (!sk->dead) { 431 if (sk->socket->state != SS_UNCONNECTED) 432 sk->socket->state = SS_DISCONNECTING; 433 sk->state_change(sk); 434 } 435 436 dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC, GFP_ATOMIC); 437 scp->persist_fxn = dn_destroy_timer; 438 scp->persist = dn_nsp_persist(sk); 439 440out: 441 kfree_skb(skb); 442} 443 444/* 445 * disc_conf messages are also called no_resources or no_link 446 * messages depending upon the "reason" field. 447 */ 448static void dn_nsp_disc_conf(struct sock *sk, struct sk_buff *skb) 449{ 450 struct dn_scp *scp = DN_SK(sk); 451 unsigned short reason; 452 453 if (skb->len != 2) 454 goto out; 455 456 reason = dn_ntohs(*(__u16 *)skb->data); 457 458 sk->state = TCP_CLOSE; 459 460 switch(scp->state) { 461 case DN_CI: 462 scp->state = DN_NR; 463 break; 464 case DN_DR: 465 if (reason == NSP_REASON_DC) 466 scp->state = DN_DRC; 467 if (reason == NSP_REASON_NL) 468 scp->state = DN_CN; 469 break; 470 case DN_DI: 471 scp->state = DN_DIC; 472 break; 473 case DN_RUN: 474 sk->shutdown |= SHUTDOWN_MASK; 475 case DN_CC: 476 scp->state = DN_CN; 477 } 478 479 if (!sk->dead) { 480 if (sk->socket->state != SS_UNCONNECTED) 481 sk->socket->state = SS_DISCONNECTING; 482 sk->state_change(sk); 483 } 484 485 scp->persist_fxn = dn_destroy_timer; 486 scp->persist = dn_nsp_persist(sk); 487 488out: 489 kfree_skb(skb); 490} 491 492static void dn_nsp_linkservice(struct sock *sk, struct sk_buff *skb) 493{ 494 struct dn_scp *scp = DN_SK(sk); 495 unsigned short segnum; 496 unsigned char lsflags; 497 char fcval; 498 int wake_up = 0; 499 char *ptr = skb->data; 500 unsigned char fctype = scp->services_rem & NSP_FC_MASK; 501 502 if (skb->len != 4) 503 goto out; 504 505 segnum = dn_ntohs(*(__u16 *)ptr); 506 ptr += 2; 507 lsflags = *(unsigned char *)ptr++; 508 fcval = *ptr; 509 510 /* 511 * Here we ignore erronous packets which should really 512 * should cause a connection abort. It is not critical 513 * for now though. 514 */ 515 if (lsflags & 0xf8) 516 goto out; 517 518 if (seq_next(scp->numoth_rcv, segnum)) { 519 seq_add(&scp->numoth_rcv, 1); 520 switch(lsflags & 0x04) { /* FCVAL INT */ 521 case 0x00: /* Normal Request */ 522 switch(lsflags & 0x03) { /* FCVAL MOD */ 523 case 0x00: /* Request count */ 524 if (fcval < 0) { 525 unsigned char p_fcval = -fcval; 526 if ((scp->flowrem_dat > p_fcval) && 527 (fctype == NSP_FC_SCMC)) { 528 scp->flowrem_dat -= p_fcval; 529 } 530 } else if (fcval > 0) { 531 scp->flowrem_dat += fcval; 532 wake_up = 1; 533 } 534 break; 535 case 0x01: /* Stop outgoing data */ 536 scp->flowrem_sw = DN_DONTSEND; 537 break; 538 case 0x02: /* Ok to start again */ 539 scp->flowrem_sw = DN_SEND; 540 dn_nsp_output(sk); 541 wake_up = 1; 542 } 543 break; 544 case 0x04: /* Interrupt Request */ 545 if (fcval > 0) { 546 scp->flowrem_oth += fcval; 547 wake_up = 1; 548 } 549 break; 550 } 551 if (wake_up && !sk->dead) 552 sk->state_change(sk); 553 } 554 555 dn_nsp_send_oth_ack(sk); 556 557out: 558 kfree_skb(skb); 559} 560 561/* 562 * Copy of sock_queue_rcv_skb (from sock.h) without 563 * bh_lock_sock() (its already held when this is called) which 564 * also allows data and other data to be queued to a socket. 565 */ 566static __inline__ int dn_queue_skb(struct sock *sk, struct sk_buff *skb, int sig, struct sk_buff_head *queue) 567{ 568#ifdef CONFIG_FILTER 569 struct sk_filter *filter; 570#endif 571 572 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces 573 number of warnings when compiling with -W --ANK 574 */ 575 if (atomic_read(&sk->rmem_alloc) + skb->truesize >= (unsigned)sk->rcvbuf 576) 577 return -ENOMEM; 578 579#ifdef CONFIG_FILTER 580 if (sk->filter) { 581 int err = 0; 582 if ((filter = sk->filter) != NULL && sk_filter(skb, sk->filter)) 583 err = -EPERM; /* Toss packet */ 584 if (err) 585 return err; 586 } 587#endif /* CONFIG_FILTER */ 588 589 skb_set_owner_r(skb, sk); 590 skb_queue_tail(queue, skb); 591 592 /* This code only runs from BH or BH protected context. 593 * Therefore the plain read_lock is ok here. -DaveM 594 */ 595 read_lock(&sk->callback_lock); 596 if (!sk->dead) { 597 struct socket *sock = sk->socket; 598 wake_up_interruptible(sk->sleep); 599 if (sock && sock->fasync_list && 600 !test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 601 __kill_fasync(sock->fasync_list, sig, 602 (sig == SIGURG) ? POLL_PRI : POLL_IN); 603 } 604 read_unlock(&sk->callback_lock); 605 606 return 0; 607} 608 609static void dn_nsp_otherdata(struct sock *sk, struct sk_buff *skb) 610{ 611 struct dn_scp *scp = DN_SK(sk); 612 unsigned short segnum; 613 struct dn_skb_cb *cb = DN_SKB_CB(skb); 614 int queued = 0; 615 616 if (skb->len < 2) 617 goto out; 618 619 cb->segnum = segnum = dn_ntohs(*(__u16 *)skb->data); 620 skb_pull(skb, 2); 621 622 if (seq_next(scp->numoth_rcv, segnum)) { 623 624 if (dn_queue_skb(sk, skb, SIGURG, &scp->other_receive_queue) == 0) { 625 seq_add(&scp->numoth_rcv, 1); 626 scp->other_report = 0; 627 queued = 1; 628 } 629 } 630 631 dn_nsp_send_oth_ack(sk); 632out: 633 if (!queued) 634 kfree_skb(skb); 635} 636 637static void dn_nsp_data(struct sock *sk, struct sk_buff *skb) 638{ 639 int queued = 0; 640 unsigned short segnum; 641 struct dn_skb_cb *cb = DN_SKB_CB(skb); 642 struct dn_scp *scp = DN_SK(sk); 643 644 if (skb->len < 2) 645 goto out; 646 647 cb->segnum = segnum = dn_ntohs(*(__u16 *)skb->data); 648 skb_pull(skb, 2); 649 650 if (seq_next(scp->numdat_rcv, segnum)) { 651 if (dn_queue_skb(sk, skb, SIGIO, &sk->receive_queue) == 0) { 652 seq_add(&scp->numdat_rcv, 1); 653 queued = 1; 654 } 655 656 if ((scp->flowloc_sw == DN_SEND) && dn_congested(sk)) { 657 scp->flowloc_sw = DN_DONTSEND; 658 dn_nsp_send_link(sk, DN_DONTSEND, 0); 659 } 660 } 661 662 dn_nsp_send_data_ack(sk); 663out: 664 if (!queued) 665 kfree_skb(skb); 666} 667 668/* 669 * If one of our conninit messages is returned, this function 670 * deals with it. It puts the socket into the NO_COMMUNICATION 671 * state. 672 */ 673static void dn_returned_conn_init(struct sock *sk, struct sk_buff *skb) 674{ 675 struct dn_scp *scp = DN_SK(sk); 676 677 if (scp->state == DN_CI) { 678 scp->state = DN_NC; 679 sk->state = TCP_CLOSE; 680 if (!sk->dead) 681 sk->state_change(sk); 682 } 683 684 kfree_skb(skb); 685} 686 687static int dn_nsp_no_socket(struct sk_buff *skb, unsigned short reason) 688{ 689 struct dn_skb_cb *cb = DN_SKB_CB(skb); 690 int ret = NET_RX_DROP; 691 692 /* Must not reply to returned packets */ 693 if (cb->rt_flags & DN_RT_F_RTS) 694 goto out; 695 696 if ((reason != NSP_REASON_OK) && ((cb->nsp_flags & 0x0c) == 0x08)) { 697 switch(cb->nsp_flags & 0x70) { 698 case 0x10: 699 case 0x60: /* (Retransmitted) Connect Init */ 700 dn_nsp_return_disc(skb, NSP_DISCINIT, reason); 701 ret = NET_RX_SUCCESS; 702 break; 703 case 0x20: /* Connect Confirm */ 704 dn_nsp_return_disc(skb, NSP_DISCCONF, reason); 705 ret = NET_RX_SUCCESS; 706 break; 707 } 708 } 709 710out: 711 kfree_skb(skb); 712 return ret; 713} 714 715static int dn_nsp_rx_packet(struct sk_buff *skb) 716{ 717 struct dn_skb_cb *cb = DN_SKB_CB(skb); 718 struct sock *sk = NULL; 719 unsigned char *ptr = (unsigned char *)skb->data; 720 unsigned short reason = NSP_REASON_NL; 721 722 skb->h.raw = skb->data; 723 cb->nsp_flags = *ptr++; 724 725 if (decnet_debug_level & 2) 726 printk(KERN_DEBUG "dn_nsp_rx: Message type 0x%02x\n", (int)cb->nsp_flags); 727 728 if (skb->len < 2) 729 goto free_out; 730 731 if (cb->nsp_flags & 0x83) 732 goto free_out; 733 734 /* 735 * Returned packets... 736 * Swap src & dst and look up in the normal way. 737 */ 738 if (cb->rt_flags & DN_RT_F_RTS) { 739 unsigned short tmp = cb->dst_port; 740 cb->dst_port = cb->src_port; 741 cb->src_port = tmp; 742 tmp = cb->dst; 743 cb->dst = cb->src; 744 cb->src = tmp; 745 sk = dn_find_by_skb(skb); 746 goto got_it; 747 } 748 749 /* 750 * Filter out conninits and useless packet types 751 */ 752 if ((cb->nsp_flags & 0x0c) == 0x08) { 753 switch(cb->nsp_flags & 0x70) { 754 case 0x00: /* NOP */ 755 case 0x70: /* Reserved */ 756 case 0x50: /* Reserved, Phase II node init */ 757 goto free_out; 758 case 0x10: 759 case 0x60: 760 sk = dn_find_listener(skb, &reason); 761 goto got_it; 762 } 763 } 764 765 if (skb->len < 3) 766 goto free_out; 767 768 /* 769 * Grab the destination address. 770 */ 771 cb->dst_port = *(unsigned short *)ptr; 772 cb->src_port = 0; 773 ptr += 2; 774 775 /* 776 * If not a connack, grab the source address too. 777 */ 778 if (skb->len >= 5) { 779 cb->src_port = *(unsigned short *)ptr; 780 ptr += 2; 781 skb_pull(skb, 5); 782 } 783 784 /* 785 * Find the socket to which this skb is destined. 786 */ 787 sk = dn_find_by_skb(skb); 788got_it: 789 if (sk != NULL) { 790 struct dn_scp *scp = DN_SK(sk); 791 int ret; 792 793 /* Reset backoff */ 794 scp->nsp_rxtshift = 0; 795 796 bh_lock_sock(sk); 797 ret = NET_RX_SUCCESS; 798 if (decnet_debug_level & 8) 799 printk(KERN_DEBUG "NSP: 0x%02x 0x%02x 0x%04x 0x%04x %d\n", 800 (int)cb->rt_flags, (int)cb->nsp_flags, 801 (int)cb->src_port, (int)cb->dst_port, 802 (int)sk->lock.users); 803 if (sk->lock.users == 0) 804 ret = dn_nsp_backlog_rcv(sk, skb); 805 else 806 sk_add_backlog(sk, skb); 807 bh_unlock_sock(sk); 808 sock_put(sk); 809 810 return ret; 811 } 812 813 return dn_nsp_no_socket(skb, reason); 814 815free_out: 816 kfree_skb(skb); 817 return NET_RX_DROP; 818} 819 820int dn_nsp_rx(struct sk_buff *skb) 821{ 822 return NF_HOOK(PF_DECnet, NF_DN_LOCAL_IN, skb, skb->dev, NULL, dn_nsp_rx_packet); 823} 824 825/* 826 * This is the main receive routine for sockets. It is called 827 * from the above when the socket is not busy, and also from 828 * sock_release() when there is a backlog queued up. 829 */ 830int dn_nsp_backlog_rcv(struct sock *sk, struct sk_buff *skb) 831{ 832 struct dn_scp *scp = DN_SK(sk); 833 struct dn_skb_cb *cb = DN_SKB_CB(skb); 834 835 if (cb->rt_flags & DN_RT_F_RTS) { 836 dn_returned_conn_init(sk, skb); 837 return NET_RX_SUCCESS; 838 } 839 840 /* 841 * Control packet. 842 */ 843 if ((cb->nsp_flags & 0x0c) == 0x08) { 844 switch(cb->nsp_flags & 0x70) { 845 case 0x10: 846 case 0x60: 847 dn_nsp_conn_init(sk, skb); 848 break; 849 case 0x20: 850 dn_nsp_conn_conf(sk, skb); 851 break; 852 case 0x30: 853 dn_nsp_disc_init(sk, skb); 854 break; 855 case 0x40: 856 dn_nsp_disc_conf(sk, skb); 857 break; 858 } 859 860 } else if (cb->nsp_flags == 0x24) { 861 /* 862 * Special for connacks, 'cos they don't have 863 * ack data or ack otherdata info. 864 */ 865 dn_nsp_conn_ack(sk, skb); 866 } else { 867 int other = 1; 868 869 /* both data and ack frames can kick a CC socket into RUN */ 870 if ((scp->state == DN_CC) && !sk->dead) { 871 scp->state = DN_RUN; 872 sk->state = TCP_ESTABLISHED; 873 sk->state_change(sk); 874 } 875 876 if ((cb->nsp_flags & 0x1c) == 0) 877 other = 0; 878 if (cb->nsp_flags == 0x04) 879 other = 0; 880 881 /* 882 * Read out ack data here, this applies equally 883 * to data, other data, link serivce and both 884 * ack data and ack otherdata. 885 */ 886 dn_process_ack(sk, skb, other); 887 888 /* 889 * If we've some sort of data here then call a 890 * suitable routine for dealing with it, otherwise 891 * the packet is an ack and can be discarded. 892 */ 893 if ((cb->nsp_flags & 0x0c) == 0) { 894 895 if (scp->state != DN_RUN) 896 goto free_out; 897 898 switch(cb->nsp_flags) { 899 case 0x10: /* LS */ 900 dn_nsp_linkservice(sk, skb); 901 break; 902 case 0x30: /* OD */ 903 dn_nsp_otherdata(sk, skb); 904 break; 905 default: 906 dn_nsp_data(sk, skb); 907 } 908 909 } else { /* Ack, chuck it out here */ 910free_out: 911 kfree_skb(skb); 912 } 913 } 914 915 return NET_RX_SUCCESS; 916} 917 918