Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | * Steve Whitehouse: Prepare for nonlinear skbs |
| 32 | */ |
| 33 | |
| 34 | /****************************************************************************** |
| 35 | (c) 1995-1998 E.M. Serrat emserrat@geocities.com |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 36 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | #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 Melo | c752f07 | 2005-08-09 20:08:28 -0700 | [diff] [blame] | 61 | #include <net/tcp_states.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | #include <asm/system.h> |
| 63 | #include <linux/fcntl.h> |
| 64 | #include <linux/mm.h> |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 65 | #include <linux/termios.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | #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 | |
| 79 | extern int decnet_log_martians; |
| 80 | |
| 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); |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 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, dn_ntohs(cb->src), dn_ntohs(cb->dst), dn_ntohs(cb->src_port), dn_ntohs(cb->dst_port)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
| 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; |
| 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 | */ |
| 127 | static int dn_process_ack(struct sock *sk, struct sk_buff *skb, int oth) |
| 128 | { |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 129 | __le16 *ptr = (__le16 *)skb->data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) { |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 141 | if (oth) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) { |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 154 | if (oth) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
| 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++; |
| 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 | */ |
| 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 | }; |
| 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 | */ |
| 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; |
| 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); |
| 316 | err_out: |
| 317 | dn_log_martian(skb, ci_err_table[err].text); |
| 318 | *reason = ci_err_table[err].reason; |
| 319 | return NULL; |
| 320 | } |
| 321 | |
| 322 | |
| 323 | static 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 | |
| 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; |
| 340 | |
| 341 | if (skb->len < 4) |
| 342 | goto out; |
| 343 | |
| 344 | ptr = skb->data; |
| 345 | cb->services = *ptr++; |
| 346 | cb->info = *ptr++; |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 347 | cb->segsize = dn_ntohs(*(__le16 *)ptr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | |
| 349 | if ((scp->state == DN_CI) || (scp->state == DN_CD)) { |
| 350 | scp->persist = 0; |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 351 | scp->addrrem = cb->src_port; |
| 352 | sk->sk_state = TCP_ESTABLISHED; |
| 353 | scp->state = DN_RUN; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) { |
Steven Whitehouse | 375d9d7 | 2006-11-07 15:09:17 -0800 | [diff] [blame] | 362 | u16 dlen = *skb->data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | if ((dlen <= 16) && (dlen <= skb->len)) { |
Steven Whitehouse | 375d9d7 | 2006-11-07 15:09:17 -0800 | [diff] [blame] | 364 | scp->conndata_in.opt_optl = dn_htons(dlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 365 | memcpy(scp->conndata_in.opt_data, skb->data + 1, dlen); |
| 366 | } |
| 367 | } |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 368 | dn_nsp_send_link(sk, DN_NOCHANGE, 0); |
| 369 | if (!sock_flag(sk, SOCK_DEAD)) |
| 370 | sk->sk_state_change(sk); |
| 371 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | |
| 373 | out: |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 374 | kfree_skb(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | } |
| 376 | |
| 377 | static 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 | |
| 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; |
| 394 | |
| 395 | if (skb->len < 2) |
| 396 | goto out; |
| 397 | |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 398 | reason = dn_ntohs(*(__le16 *)skb->data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | skb_pull(skb, 2); |
| 400 | |
Steven Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 401 | scp->discdata_in.opt_status = dn_htons(reason); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | scp->discdata_in.opt_optl = 0; |
| 403 | memset(scp->discdata_in.opt_data, 0, 16); |
| 404 | |
| 405 | if (skb->len > 0) { |
Steven Whitehouse | 375d9d7 | 2006-11-07 15:09:17 -0800 | [diff] [blame] | 406 | u16 dlen = *skb->data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 407 | if ((dlen <= 16) && (dlen <= skb->len)) { |
Steven Whitehouse | 375d9d7 | 2006-11-07 15:09:17 -0800 | [diff] [blame] | 408 | scp->discdata_in.opt_optl = dn_htons(dlen); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 437 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | * 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 | |
| 449 | out: |
| 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 | */ |
| 457 | static 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 465 | reason = dn_ntohs(*(__le16 *)skb->data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 466 | |
| 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 | |
| 497 | out: |
| 498 | kfree_skb(skb); |
| 499 | } |
| 500 | |
| 501 | static 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 514 | segnum = dn_ntohs(*(__le16 *)ptr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 515 | ptr += 2; |
| 516 | lsflags = *(unsigned char *)ptr++; |
| 517 | fcval = *ptr; |
| 518 | |
| 519 | /* |
| 520 | * Here we ignore erronous packets which should really |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 521 | * should cause a connection abort. It is not critical |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | * 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 532 | case 0x00: /* Request count */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 533 | 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 543 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 544 | 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 559 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 560 | if (wake_up && !sock_flag(sk, SOCK_DEAD)) |
| 561 | sk->sk_state_change(sk); |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 562 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 563 | |
| 564 | dn_nsp_send_oth_ack(sk); |
| 565 | |
| 566 | out: |
| 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 | */ |
| 575 | static __inline__ int dn_queue_skb(struct sock *sk, struct sk_buff *skb, int sig, struct sk_buff_head *queue) |
| 576 | { |
| 577 | int err; |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 578 | |
| 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 583 | (unsigned)sk->sk_rcvbuf) { |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 584 | err = -ENOMEM; |
| 585 | goto out; |
| 586 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | |
Dmitry Mishin | fda9ef5 | 2006-08-31 15:28:39 -0700 | [diff] [blame] | 588 | err = sk_filter(sk, skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 589 | if (err) |
| 590 | goto out; |
| 591 | |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 592 | skb_set_owner_r(skb, sk); |
| 593 | skb_queue_tail(queue, skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | |
| 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 599 | if (!sock_flag(sk, SOCK_DEAD)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 600 | 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 604 | __kill_fasync(sock->fasync_list, sig, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 605 | (sig == SIGURG) ? POLL_PRI : POLL_IN); |
| 606 | } |
| 607 | read_unlock(&sk->sk_callback_lock); |
| 608 | out: |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 609 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | } |
| 611 | |
| 612 | static 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 622 | cb->segnum = segnum = dn_ntohs(*(__le16 *)skb->data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 623 | 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); |
| 635 | out: |
| 636 | if (!queued) |
| 637 | kfree_skb(skb); |
| 638 | } |
| 639 | |
| 640 | static 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 650 | cb->segnum = segnum = dn_ntohs(*(__le16 *)skb->data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 651 | skb_pull(skb, 2); |
| 652 | |
| 653 | if (seq_next(scp->numdat_rcv, segnum)) { |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 654 | if (dn_queue_skb(sk, skb, SIGIO, &sk->sk_receive_queue) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 655 | seq_add(&scp->numdat_rcv, 1); |
YOSHIFUJI Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 656 | queued = 1; |
| 657 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 658 | |
| 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 663 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 664 | |
| 665 | dn_nsp_send_data_ack(sk); |
| 666 | out: |
| 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 | */ |
| 676 | static 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 | |
| 690 | static 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 | |
| 713 | out: |
| 714 | kfree_skb(skb); |
| 715 | return ret; |
| 716 | } |
| 717 | |
| 718 | static 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 734 | if (cb->nsp_flags & 0x83) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 735 | 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 761 | cb->dst_port = *(__le16 *)ptr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 762 | 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 769 | cb->src_port = *(__le16 *)ptr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 770 | 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 Whitehouse | c4ea94a | 2006-03-20 22:42:39 -0800 | [diff] [blame] | 779 | __le16 tmp = cb->dst_port; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 780 | 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); |
| 791 | got_it: |
| 792 | if (sk != NULL) { |
| 793 | struct dn_scp *scp = DN_SK(sk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 794 | |
| 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 Xu | 364c6ba | 2006-06-09 16:10:40 -0700 | [diff] [blame] | 802 | if (unlikely(skb_linearize(skb))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 803 | goto free_out; |
| 804 | } |
| 805 | |
Arnaldo Carvalho de Melo | 58a5a7b | 2006-11-16 14:06:06 -0200 | [diff] [blame] | 806 | return sk_receive_skb(sk, skb, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 807 | } |
| 808 | |
| 809 | return dn_nsp_no_socket(skb, reason); |
| 810 | |
| 811 | free_out: |
| 812 | kfree_skb(skb); |
| 813 | return NET_RX_DROP; |
| 814 | } |
| 815 | |
| 816 | int 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 | */ |
| 826 | int 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 Hideaki | 429eb0f | 2007-02-09 23:24:40 +0900 | [diff] [blame] | 854 | case 0x40: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 855 | 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 */ |
| 909 | free_out: |
| 910 | kfree_skb(skb); |
| 911 | } |
| 912 | } |
| 913 | |
| 914 | return NET_RX_SUCCESS; |
| 915 | } |
| 916 | |