开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
dn_nsp_in.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

dn_nsp_in.c：源码内容
  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.  */
  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.
  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. *******************************************************************************/
  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>
  79. extern int decnet_log_martians;
  81. static 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%04hxn", msg, devname, cb->src, cb->dst, cb->src_port, cb->dst_port);
  87. }
  88. }
  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.  */
  95. static 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;
  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. }
  120. if (wakeup && !sk->dead)
  121. sk->state_change(sk);
  122. }
  124. /*
  125.  * This function is a universal ack processor.
  126.  */
  127. static 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;
  133. if (skb->len < 2)
  134. return len;
  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. }
  147. if (skb->len < 2)
  148. return len;
  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. }
  160. return len;
  161. }
  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.  */
  173. static 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++;
  178. (*len)--;
  179. if (flen > max)
  180. return -1;
  181. if ((flen + follow_on) > *len)
  182. return -1;
  184. *len -= flen;
  185. *pptr = ptr + flen;
  186. return 0;
  187. }
  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.  */
  195. static 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. };
  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.  */
  216. static 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;
  230. memset(&dstaddr, 0, sizeof(struct sockaddr_dn));
  231. memset(&srcaddr, 0, sizeof(struct sockaddr_dn));
  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);
  242. if (skb->len < sizeof(*msg))
  243. goto err_out;
  245. skb_pull(skb, sizeof(*msg));
  247. len = skb->len;
  248. ptr = skb->data;
  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;
  258. err++;
  259. if (type > 1)
  260. goto err_out;
  262. len -= dstlen;
  263. ptr += dstlen;
  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;
  273. len -= srclen;
  274. ptr += srclen;
  275. err++;
  276. if (len < 1)
  277. goto err_out;
  279. menuver = *ptr;
  280. ptr++;
  281. len--;
  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;
  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. }
  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. }
  312. /*
  313.  * 7. Look up socket based on destination end username
  314.  */
  315. return dn_sklist_find_listener(&dstaddr);
  316. err_out:
  317. dn_log_martian(skb, ci_err_table[err].text);
  318. *reason = ci_err_table[err].reason;
  319. return NULL;
  320. }
  323. static 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. }
  330. sk->ack_backlog++;
  331. skb_queue_tail(&sk->receive_queue, skb);
  332. sk->state_change(sk);
  333. }
  335. static 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;
  341. if (skb->len < 4)
  342. goto out;
  344. ptr = skb->data;
  345. cb->services = *ptr++;
  346. cb->info = *ptr++;
  347. cb->segsize = dn_ntohs(*(__u16 *)ptr);
  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;
  358. if ((scp->services_rem & NSP_FC_MASK) == NSP_FC_NONE)
  359. scp->max_window = decnet_no_fc_max_cwnd;
  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.         }
  373. out:
  374.         kfree_skb(skb);
  375. }
  377. static void dn_nsp_conn_ack(struct sock *sk, struct sk_buff *skb)
  378. {
  379. struct dn_scp *scp = DN_SK(sk);
  381. if (scp->state == DN_CI) {
  382. scp->state = DN_CD;
  383. scp->persist = 0;
  384. }
  386. kfree_skb(skb);
  387. }
  389. static 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;
  395. if (skb->len < 2)
  396. goto out;
  398. reason = dn_ntohs(*(__u16 *)skb->data);
  399. skb_pull(skb, 2);
  401. scp->discdata_in.opt_status = reason;
  402. scp->discdata_in.opt_optl   = 0;
  403. memset(scp->discdata_in.opt_data, 0, 16);
  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. }
  413. scp->addrrem = cb->src_port;
  414. sk->state    = TCP_CLOSE;
  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. }
  430. if (!sk->dead) {
  431. if (sk->socket->state != SS_UNCONNECTED)
  432. sk->socket->state = SS_DISCONNECTING;
  433. sk->state_change(sk);
  434. }
  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);
  440. out:
  441. kfree_skb(skb);
  442. }
  444. /*
  445.  * disc_conf messages are also called no_resources or no_link
  446.  * messages depending upon the "reason" field.
  447.  */
  448. static 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;
  453. if (skb->len != 2)
  454. goto out;
  456. reason = dn_ntohs(*(__u16 *)skb->data);
  458. sk->state = TCP_CLOSE;
  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. }
  479. if (!sk->dead) {
  480. if (sk->socket->state != SS_UNCONNECTED)
  481. sk->socket->state = SS_DISCONNECTING;
  482. sk->state_change(sk);
  483. }
  485. scp->persist_fxn = dn_destroy_timer;
  486. scp->persist = dn_nsp_persist(sk);
  488. out:
  489. kfree_skb(skb);
  490. }
  492. static 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;
  502. if (skb->len != 4)
  503. goto out;
  505. segnum = dn_ntohs(*(__u16 *)ptr);
  506. ptr += 2;
  507. lsflags = *(unsigned char *)ptr++;
  508. fcval = *ptr;
  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;
  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.         }
  555. dn_nsp_send_oth_ack(sk);
  557. out:
  558. kfree_skb(skb);
  559. }
  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.  */
  566. static __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
  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;
  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 */
  589.         skb_set_owner_r(skb, sk);
  590.         skb_queue_tail(queue, skb);
  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);
  606.         return 0;
  607. }
  609. static 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;
  616. if (skb->len < 2)
  617. goto out;
  619. cb->segnum = segnum = dn_ntohs(*(__u16 *)skb->data);
  620. skb_pull(skb, 2);
  622. if (seq_next(scp->numoth_rcv, segnum)) {
  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. }
  631. dn_nsp_send_oth_ack(sk);
  632. out:
  633. if (!queued)
  634. kfree_skb(skb);
  635. }
  637. static 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);
  644. if (skb->len < 2)
  645. goto out;
  647. cb->segnum = segnum = dn_ntohs(*(__u16 *)skb->data);
  648. skb_pull(skb, 2);
  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.                 }
  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.         }
  662. dn_nsp_send_data_ack(sk);
  663. out:
  664. if (!queued)
  665. kfree_skb(skb);
  666. }
  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.  */
  673. static void dn_returned_conn_init(struct sock *sk, struct sk_buff *skb)
  674. {
  675. struct dn_scp *scp = DN_SK(sk);
  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. }
  684. kfree_skb(skb);
  685. }
  687. static 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;
  692. /* Must not reply to returned packets */
  693. if (cb->rt_flags & DN_RT_F_RTS)
  694. goto out;
  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. }
  710. out:
  711. kfree_skb(skb);
  712. return ret;
  713. }
  715. static 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;
  722. skb->h.raw    = skb->data;
  723. cb->nsp_flags = *ptr++;
  725. if (decnet_debug_level & 2)
  726. printk(KERN_DEBUG "dn_nsp_rx: Message type 0x%02xn", (int)cb->nsp_flags);
  728. if (skb->len < 2) 
  729. goto free_out;
  731. if (cb->nsp_flags & 0x83) 
  732. goto free_out;
  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. }
  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. }
  765. if (skb->len < 3)
  766. goto free_out;
  768. /*
  769.  * Grab the destination address.
  770.  */
  771. cb->dst_port = *(unsigned short *)ptr;
  772. cb->src_port = 0;
  773. ptr += 2;
  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. }
  784. /*
  785.  * Find the socket to which this skb is destined.
  786.  */
  787. sk = dn_find_by_skb(skb);
  788. got_it:
  789. if (sk != NULL) {
  790. struct dn_scp *scp = DN_SK(sk);
  791. int ret;
  793. /* Reset backoff */
  794. scp->nsp_rxtshift = 0;
  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 %dn",
  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);
  810. return ret;
  811. }
  813. return dn_nsp_no_socket(skb, reason);
  815. free_out:
  816. kfree_skb(skb);
  817. return NET_RX_DROP;
  818. }
  820. int 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. }
  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.  */
  830. int 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);
  835. if (cb->rt_flags & DN_RT_F_RTS) {
  836. dn_returned_conn_init(sk, skb);
  837. return NET_RX_SUCCESS;
  838. }
  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. }
  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;
  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. }
  876. if ((cb->nsp_flags & 0x1c) == 0)
  877. other = 0;
  878. if (cb->nsp_flags == 0x04)
  879. other = 0;
  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);
  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) {
  895. if (scp->state != DN_RUN)
  896. goto free_out;
  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. }
  909. } else { /* Ack, chuck it out here */
  910. free_out:
  911. kfree_skb(skb);
  912. }
  913. }
  915. return NET_RX_SUCCESS;
  916. }