1 /* 2 * af_llc.c - LLC User Interface SAPs 3 * Description: 4 * Functions in this module are implementation of socket based llc 5 * communications for the Linux operating system. Support of llc class 6 * one and class two is provided via SOCK_DGRAM and SOCK_STREAM 7 * respectively. 8 * 9 * An llc2 connection is (mac + sap), only one llc2 sap connection 10 * is allowed per mac. Though one sap may have multiple mac + sap 11 * connections. 12 * 13 * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org> 14 * 2002-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br> 15 * 16 * This program can be redistributed or modified under the terms of the 17 * GNU General Public License as published by the Free Software Foundation. 18 * This program is distributed without any warranty or implied warranty 19 * of merchantability or fitness for a particular purpose. 20 * 21 * See the GNU General Public License for more details. 22 */ 23 #include <linux/compiler.h> 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/rtnetlink.h> 27 #include <linux/init.h> 28 #include <net/llc.h> 29 #include <net/llc_sap.h> 30 #include <net/llc_pdu.h> 31 #include <net/llc_conn.h> 32 #include <net/tcp_states.h> 33 34 /* remember: uninitialized global data is zeroed because its in .bss */ 35 static u16 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 36 static u16 llc_ui_sap_link_no_max[256]; 37 static struct sockaddr_llc llc_ui_addrnull; 38 static const struct proto_ops llc_ui_ops; 39 40 static int llc_ui_wait_for_conn(struct sock *sk, long timeout); 41 static int llc_ui_wait_for_disc(struct sock *sk, long timeout); 42 static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout); 43 44 #if 0 45 #define dprintk(args...) printk(KERN_DEBUG args) 46 #else 47 #define dprintk(args...) 48 #endif 49 50 /** 51 * llc_ui_next_link_no - return the next unused link number for a sap 52 * @sap: Address of sap to get link number from. 53 * 54 * Return the next unused link number for a given sap. 55 */ 56 static inline u16 llc_ui_next_link_no(int sap) 57 { 58 return llc_ui_sap_link_no_max[sap]++; 59 } 60 61 /** 62 * llc_proto_type - return eth protocol for ARP header type 63 * @arphrd: ARP header type. 64 * 65 * Given an ARP header type return the corresponding ethernet protocol. 66 */ 67 static inline __be16 llc_proto_type(u16 arphrd) 68 { 69 return arphrd == ARPHRD_IEEE802_TR ? 70 htons(ETH_P_TR_802_2) : htons(ETH_P_802_2); 71 } 72 73 /** 74 * llc_ui_addr_null - determines if a address structure is null 75 * @addr: Address to test if null. 76 */ 77 static inline u8 llc_ui_addr_null(struct sockaddr_llc *addr) 78 { 79 return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr)); 80 } 81 82 /** 83 * llc_ui_header_len - return length of llc header based on operation 84 * @sk: Socket which contains a valid llc socket type. 85 * @addr: Complete sockaddr_llc structure received from the user. 86 * 87 * Provide the length of the llc header depending on what kind of 88 * operation the user would like to perform and the type of socket. 89 * Returns the correct llc header length. 90 */ 91 static inline u8 llc_ui_header_len(struct sock *sk, struct sockaddr_llc *addr) 92 { 93 u8 rc = LLC_PDU_LEN_U; 94 95 if (addr->sllc_test || addr->sllc_xid) 96 rc = LLC_PDU_LEN_U; 97 else if (sk->sk_type == SOCK_STREAM) 98 rc = LLC_PDU_LEN_I; 99 return rc; 100 } 101 102 /** 103 * llc_ui_send_data - send data via reliable llc2 connection 104 * @sk: Connection the socket is using. 105 * @skb: Data the user wishes to send. 106 * @noblock: can we block waiting for data? 107 * 108 * Send data via reliable llc2 connection. 109 * Returns 0 upon success, non-zero if action did not succeed. 110 */ 111 static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock) 112 { 113 struct llc_sock* llc = llc_sk(sk); 114 int rc = 0; 115 116 if (unlikely(llc_data_accept_state(llc->state) || 117 llc->remote_busy_flag || 118 llc->p_flag)) { 119 long timeout = sock_sndtimeo(sk, noblock); 120 121 rc = llc_ui_wait_for_busy_core(sk, timeout); 122 } 123 if (unlikely(!rc)) 124 rc = llc_build_and_send_pkt(sk, skb); 125 return rc; 126 } 127 128 static void llc_ui_sk_init(struct socket *sock, struct sock *sk) 129 { 130 sock_graft(sk, sock); 131 sk->sk_type = sock->type; 132 sock->ops = &llc_ui_ops; 133 } 134 135 static struct proto llc_proto = { 136 .name = "LLC", 137 .owner = THIS_MODULE, 138 .obj_size = sizeof(struct llc_sock), 139 }; 140 141 /** 142 * llc_ui_create - alloc and init a new llc_ui socket 143 * @net: network namespace (must be default network) 144 * @sock: Socket to initialize and attach allocated sk to. 145 * @protocol: Unused. 146 * @kern: on behalf of kernel or userspace 147 * 148 * Allocate and initialize a new llc_ui socket, validate the user wants a 149 * socket type we have available. 150 * Returns 0 upon success, negative upon failure. 151 */ 152 static int llc_ui_create(struct net *net, struct socket *sock, int protocol, 153 int kern) 154 { 155 struct sock *sk; 156 int rc = -ESOCKTNOSUPPORT; 157 158 if (!capable(CAP_NET_RAW)) 159 return -EPERM; 160 161 if (!net_eq(net, &init_net)) 162 return -EAFNOSUPPORT; 163 164 if (likely(sock->type == SOCK_DGRAM || sock->type == SOCK_STREAM)) { 165 rc = -ENOMEM; 166 sk = llc_sk_alloc(net, PF_LLC, GFP_KERNEL, &llc_proto); 167 if (sk) { 168 rc = 0; 169 llc_ui_sk_init(sock, sk); 170 } 171 } 172 return rc; 173 } 174 175 /** 176 * llc_ui_release - shutdown socket 177 * @sock: Socket to release. 178 * 179 * Shutdown and deallocate an existing socket. 180 */ 181 static int llc_ui_release(struct socket *sock) 182 { 183 struct sock *sk = sock->sk; 184 struct llc_sock *llc; 185 186 if (unlikely(sk == NULL)) 187 goto out; 188 sock_hold(sk); 189 lock_sock(sk); 190 llc = llc_sk(sk); 191 dprintk("%s: closing local(%02X) remote(%02X)\n", __func__, 192 llc->laddr.lsap, llc->daddr.lsap); 193 if (!llc_send_disc(sk)) 194 llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo); 195 if (!sock_flag(sk, SOCK_ZAPPED)) { 196 llc_sap_put(llc->sap); 197 llc_sap_remove_socket(llc->sap, sk); 198 } 199 release_sock(sk); 200 if (llc->dev) 201 dev_put(llc->dev); 202 sock_put(sk); 203 llc_sk_free(sk); 204 out: 205 return 0; 206 } 207 208 /** 209 * llc_ui_autoport - provide dynamically allocate SAP number 210 * 211 * Provide the caller with a dynamically allocated SAP number according 212 * to the rules that are set in this function. Returns: 0, upon failure, 213 * SAP number otherwise. 214 */ 215 static int llc_ui_autoport(void) 216 { 217 struct llc_sap *sap; 218 int i, tries = 0; 219 220 while (tries < LLC_SAP_DYN_TRIES) { 221 for (i = llc_ui_sap_last_autoport; 222 i < LLC_SAP_DYN_STOP; i += 2) { 223 sap = llc_sap_find(i); 224 if (!sap) { 225 llc_ui_sap_last_autoport = i + 2; 226 goto out; 227 } 228 llc_sap_put(sap); 229 } 230 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 231 tries++; 232 } 233 i = 0; 234 out: 235 return i; 236 } 237 238 /** 239 * llc_ui_autobind - automatically bind a socket to a sap 240 * @sock: socket to bind 241 * @addr: address to connect to 242 * 243 * Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't 244 * specifically used llc_ui_bind to bind to an specific address/sap 245 * 246 * Returns: 0 upon success, negative otherwise. 247 */ 248 static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr) 249 { 250 struct sock *sk = sock->sk; 251 struct llc_sock *llc = llc_sk(sk); 252 struct llc_sap *sap; 253 int rc = -EINVAL; 254 255 if (!sock_flag(sk, SOCK_ZAPPED)) 256 goto out; 257 rc = -ENODEV; 258 llc->dev = dev_getfirstbyhwtype(&init_net, addr->sllc_arphrd); 259 if (!llc->dev) 260 goto out; 261 rc = -EUSERS; 262 llc->laddr.lsap = llc_ui_autoport(); 263 if (!llc->laddr.lsap) 264 goto out; 265 rc = -EBUSY; /* some other network layer is using the sap */ 266 sap = llc_sap_open(llc->laddr.lsap, NULL); 267 if (!sap) 268 goto out; 269 memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN); 270 memcpy(&llc->addr, addr, sizeof(llc->addr)); 271 /* assign new connection to its SAP */ 272 llc_sap_add_socket(sap, sk); 273 sock_reset_flag(sk, SOCK_ZAPPED); 274 rc = 0; 275 out: 276 return rc; 277 } 278 279 /** 280 * llc_ui_bind - bind a socket to a specific address. 281 * @sock: Socket to bind an address to. 282 * @uaddr: Address the user wants the socket bound to. 283 * @addrlen: Length of the uaddr structure. 284 * 285 * Bind a socket to a specific address. For llc a user is able to bind to 286 * a specific sap only or mac + sap. 287 * If the user desires to bind to a specific mac + sap, it is possible to 288 * have multiple sap connections via multiple macs. 289 * Bind and autobind for that matter must enforce the correct sap usage 290 * otherwise all hell will break loose. 291 * Returns: 0 upon success, negative otherwise. 292 */ 293 static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen) 294 { 295 struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr; 296 struct sock *sk = sock->sk; 297 struct llc_sock *llc = llc_sk(sk); 298 struct llc_sap *sap; 299 int rc = -EINVAL; 300 301 dprintk("%s: binding %02X\n", __func__, addr->sllc_sap); 302 if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr))) 303 goto out; 304 rc = -EAFNOSUPPORT; 305 if (unlikely(addr->sllc_family != AF_LLC)) 306 goto out; 307 rc = -ENODEV; 308 rtnl_lock(); 309 llc->dev = dev_getbyhwaddr(&init_net, addr->sllc_arphrd, addr->sllc_mac); 310 rtnl_unlock(); 311 if (!llc->dev) 312 goto out; 313 if (!addr->sllc_sap) { 314 rc = -EUSERS; 315 addr->sllc_sap = llc_ui_autoport(); 316 if (!addr->sllc_sap) 317 goto out; 318 } 319 sap = llc_sap_find(addr->sllc_sap); 320 if (!sap) { 321 sap = llc_sap_open(addr->sllc_sap, NULL); 322 rc = -EBUSY; /* some other network layer is using the sap */ 323 if (!sap) 324 goto out; 325 llc_sap_hold(sap); 326 } else { 327 struct llc_addr laddr, daddr; 328 struct sock *ask; 329 330 memset(&laddr, 0, sizeof(laddr)); 331 memset(&daddr, 0, sizeof(daddr)); 332 /* 333 * FIXME: check if the address is multicast, 334 * only SOCK_DGRAM can do this. 335 */ 336 memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN); 337 laddr.lsap = addr->sllc_sap; 338 rc = -EADDRINUSE; /* mac + sap clash. */ 339 ask = llc_lookup_established(sap, &daddr, &laddr); 340 if (ask) { 341 sock_put(ask); 342 goto out_put; 343 } 344 } 345 llc->laddr.lsap = addr->sllc_sap; 346 memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN); 347 memcpy(&llc->addr, addr, sizeof(llc->addr)); 348 /* assign new connection to its SAP */ 349 llc_sap_add_socket(sap, sk); 350 sock_reset_flag(sk, SOCK_ZAPPED); 351 rc = 0; 352 out_put: 353 llc_sap_put(sap); 354 out: 355 return rc; 356 } 357 358 /** 359 * llc_ui_shutdown - shutdown a connect llc2 socket. 360 * @sock: Socket to shutdown. 361 * @how: What part of the socket to shutdown. 362 * 363 * Shutdown a connected llc2 socket. Currently this function only supports 364 * shutting down both sends and receives (2), we could probably make this 365 * function such that a user can shutdown only half the connection but not 366 * right now. 367 * Returns: 0 upon success, negative otherwise. 368 */ 369 static int llc_ui_shutdown(struct socket *sock, int how) 370 { 371 struct sock *sk = sock->sk; 372 int rc = -ENOTCONN; 373 374 lock_sock(sk); 375 if (unlikely(sk->sk_state != TCP_ESTABLISHED)) 376 goto out; 377 rc = -EINVAL; 378 if (how != 2) 379 goto out; 380 rc = llc_send_disc(sk); 381 if (!rc) 382 rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo); 383 /* Wake up anyone sleeping in poll */ 384 sk->sk_state_change(sk); 385 out: 386 release_sock(sk); 387 return rc; 388 } 389 390 /** 391 * llc_ui_connect - Connect to a remote llc2 mac + sap. 392 * @sock: Socket which will be connected to the remote destination. 393 * @uaddr: Remote and possibly the local address of the new connection. 394 * @addrlen: Size of uaddr structure. 395 * @flags: Operational flags specified by the user. 396 * 397 * Connect to a remote llc2 mac + sap. The caller must specify the 398 * destination mac and address to connect to. If the user hasn't previously 399 * called bind(2) with a smac the address of the first interface of the 400 * specified arp type will be used. 401 * This function will autobind if user did not previously call bind. 402 * Returns: 0 upon success, negative otherwise. 403 */ 404 static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr, 405 int addrlen, int flags) 406 { 407 struct sock *sk = sock->sk; 408 struct llc_sock *llc = llc_sk(sk); 409 struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr; 410 int rc = -EINVAL; 411 412 lock_sock(sk); 413 if (unlikely(addrlen != sizeof(*addr))) 414 goto out; 415 rc = -EAFNOSUPPORT; 416 if (unlikely(addr->sllc_family != AF_LLC)) 417 goto out; 418 if (unlikely(sk->sk_type != SOCK_STREAM)) 419 goto out; 420 rc = -EALREADY; 421 if (unlikely(sock->state == SS_CONNECTING)) 422 goto out; 423 /* bind connection to sap if user hasn't done it. */ 424 if (sock_flag(sk, SOCK_ZAPPED)) { 425 /* bind to sap with null dev, exclusive */ 426 rc = llc_ui_autobind(sock, addr); 427 if (rc) 428 goto out; 429 } 430 llc->daddr.lsap = addr->sllc_sap; 431 memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN); 432 sock->state = SS_CONNECTING; 433 sk->sk_state = TCP_SYN_SENT; 434 llc->link = llc_ui_next_link_no(llc->sap->laddr.lsap); 435 rc = llc_establish_connection(sk, llc->dev->dev_addr, 436 addr->sllc_mac, addr->sllc_sap); 437 if (rc) { 438 dprintk("%s: llc_ui_send_conn failed :-(\n", __func__); 439 sock->state = SS_UNCONNECTED; 440 sk->sk_state = TCP_CLOSE; 441 goto out; 442 } 443 444 if (sk->sk_state == TCP_SYN_SENT) { 445 const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); 446 447 if (!timeo || !llc_ui_wait_for_conn(sk, timeo)) 448 goto out; 449 450 rc = sock_intr_errno(timeo); 451 if (signal_pending(current)) 452 goto out; 453 } 454 455 if (sk->sk_state == TCP_CLOSE) 456 goto sock_error; 457 458 sock->state = SS_CONNECTED; 459 rc = 0; 460 out: 461 release_sock(sk); 462 return rc; 463 sock_error: 464 rc = sock_error(sk) ? : -ECONNABORTED; 465 sock->state = SS_UNCONNECTED; 466 goto out; 467 } 468 469 /** 470 * llc_ui_listen - allow a normal socket to accept incoming connections 471 * @sock: Socket to allow incoming connections on. 472 * @backlog: Number of connections to queue. 473 * 474 * Allow a normal socket to accept incoming connections. 475 * Returns 0 upon success, negative otherwise. 476 */ 477 static int llc_ui_listen(struct socket *sock, int backlog) 478 { 479 struct sock *sk = sock->sk; 480 int rc = -EINVAL; 481 482 lock_sock(sk); 483 if (unlikely(sock->state != SS_UNCONNECTED)) 484 goto out; 485 rc = -EOPNOTSUPP; 486 if (unlikely(sk->sk_type != SOCK_STREAM)) 487 goto out; 488 rc = -EAGAIN; 489 if (sock_flag(sk, SOCK_ZAPPED)) 490 goto out; 491 rc = 0; 492 if (!(unsigned)backlog) /* BSDism */ 493 backlog = 1; 494 sk->sk_max_ack_backlog = backlog; 495 if (sk->sk_state != TCP_LISTEN) { 496 sk->sk_ack_backlog = 0; 497 sk->sk_state = TCP_LISTEN; 498 } 499 sk->sk_socket->flags |= __SO_ACCEPTCON; 500 out: 501 release_sock(sk); 502 return rc; 503 } 504 505 static int llc_ui_wait_for_disc(struct sock *sk, long timeout) 506 { 507 DEFINE_WAIT(wait); 508 int rc = 0; 509 510 while (1) { 511 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 512 if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE)) 513 break; 514 rc = -ERESTARTSYS; 515 if (signal_pending(current)) 516 break; 517 rc = -EAGAIN; 518 if (!timeout) 519 break; 520 rc = 0; 521 } 522 finish_wait(sk->sk_sleep, &wait); 523 return rc; 524 } 525 526 static int llc_ui_wait_for_conn(struct sock *sk, long timeout) 527 { 528 DEFINE_WAIT(wait); 529 530 while (1) { 531 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 532 if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT)) 533 break; 534 if (signal_pending(current) || !timeout) 535 break; 536 } 537 finish_wait(sk->sk_sleep, &wait); 538 return timeout; 539 } 540 541 static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout) 542 { 543 DEFINE_WAIT(wait); 544 struct llc_sock *llc = llc_sk(sk); 545 int rc; 546 547 while (1) { 548 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 549 rc = 0; 550 if (sk_wait_event(sk, &timeout, 551 (sk->sk_shutdown & RCV_SHUTDOWN) || 552 (!llc_data_accept_state(llc->state) && 553 !llc->remote_busy_flag && 554 !llc->p_flag))) 555 break; 556 rc = -ERESTARTSYS; 557 if (signal_pending(current)) 558 break; 559 rc = -EAGAIN; 560 if (!timeout) 561 break; 562 } 563 finish_wait(sk->sk_sleep, &wait); 564 return rc; 565 } 566 567 static int llc_wait_data(struct sock *sk, long timeo) 568 { 569 int rc; 570 571 while (1) { 572 /* 573 * POSIX 1003.1g mandates this order. 574 */ 575 rc = sock_error(sk); 576 if (rc) 577 break; 578 rc = 0; 579 if (sk->sk_shutdown & RCV_SHUTDOWN) 580 break; 581 rc = -EAGAIN; 582 if (!timeo) 583 break; 584 rc = sock_intr_errno(timeo); 585 if (signal_pending(current)) 586 break; 587 rc = 0; 588 if (sk_wait_data(sk, &timeo)) 589 break; 590 } 591 return rc; 592 } 593 594 /** 595 * llc_ui_accept - accept a new incoming connection. 596 * @sock: Socket which connections arrive on. 597 * @newsock: Socket to move incoming connection to. 598 * @flags: User specified operational flags. 599 * 600 * Accept a new incoming connection. 601 * Returns 0 upon success, negative otherwise. 602 */ 603 static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags) 604 { 605 struct sock *sk = sock->sk, *newsk; 606 struct llc_sock *llc, *newllc; 607 struct sk_buff *skb; 608 int rc = -EOPNOTSUPP; 609 610 dprintk("%s: accepting on %02X\n", __func__, 611 llc_sk(sk)->laddr.lsap); 612 lock_sock(sk); 613 if (unlikely(sk->sk_type != SOCK_STREAM)) 614 goto out; 615 rc = -EINVAL; 616 if (unlikely(sock->state != SS_UNCONNECTED || 617 sk->sk_state != TCP_LISTEN)) 618 goto out; 619 /* wait for a connection to arrive. */ 620 if (skb_queue_empty(&sk->sk_receive_queue)) { 621 rc = llc_wait_data(sk, sk->sk_rcvtimeo); 622 if (rc) 623 goto out; 624 } 625 dprintk("%s: got a new connection on %02X\n", __func__, 626 llc_sk(sk)->laddr.lsap); 627 skb = skb_dequeue(&sk->sk_receive_queue); 628 rc = -EINVAL; 629 if (!skb->sk) 630 goto frees; 631 rc = 0; 632 newsk = skb->sk; 633 /* attach connection to a new socket. */ 634 llc_ui_sk_init(newsock, newsk); 635 sock_reset_flag(newsk, SOCK_ZAPPED); 636 newsk->sk_state = TCP_ESTABLISHED; 637 newsock->state = SS_CONNECTED; 638 llc = llc_sk(sk); 639 newllc = llc_sk(newsk); 640 memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr)); 641 newllc->link = llc_ui_next_link_no(newllc->laddr.lsap); 642 643 /* put original socket back into a clean listen state. */ 644 sk->sk_state = TCP_LISTEN; 645 sk->sk_ack_backlog--; 646 dprintk("%s: ok success on %02X, client on %02X\n", __func__, 647 llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap); 648 frees: 649 kfree_skb(skb); 650 out: 651 release_sock(sk); 652 return rc; 653 } 654 655 /** 656 * llc_ui_recvmsg - copy received data to the socket user. 657 * @sock: Socket to copy data from. 658 * @msg: Various user space related information. 659 * @len: Size of user buffer. 660 * @flags: User specified flags. 661 * 662 * Copy received data to the socket user. 663 * Returns non-negative upon success, negative otherwise. 664 */ 665 static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock, 666 struct msghdr *msg, size_t len, int flags) 667 { 668 struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name; 669 const int nonblock = flags & MSG_DONTWAIT; 670 struct sk_buff *skb = NULL; 671 struct sock *sk = sock->sk; 672 struct llc_sock *llc = llc_sk(sk); 673 size_t copied = 0; 674 u32 peek_seq = 0; 675 u32 *seq; 676 unsigned long used; 677 int target; /* Read at least this many bytes */ 678 long timeo; 679 680 lock_sock(sk); 681 copied = -ENOTCONN; 682 if (unlikely(sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN)) 683 goto out; 684 685 timeo = sock_rcvtimeo(sk, nonblock); 686 687 seq = &llc->copied_seq; 688 if (flags & MSG_PEEK) { 689 peek_seq = llc->copied_seq; 690 seq = &peek_seq; 691 } 692 693 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len); 694 copied = 0; 695 696 do { 697 u32 offset; 698 699 /* 700 * We need to check signals first, to get correct SIGURG 701 * handling. FIXME: Need to check this doesn't impact 1003.1g 702 * and move it down to the bottom of the loop 703 */ 704 if (signal_pending(current)) { 705 if (copied) 706 break; 707 copied = timeo ? sock_intr_errno(timeo) : -EAGAIN; 708 break; 709 } 710 711 /* Next get a buffer. */ 712 713 skb = skb_peek(&sk->sk_receive_queue); 714 if (skb) { 715 offset = *seq; 716 goto found_ok_skb; 717 } 718 /* Well, if we have backlog, try to process it now yet. */ 719 720 if (copied >= target && !sk->sk_backlog.tail) 721 break; 722 723 if (copied) { 724 if (sk->sk_err || 725 sk->sk_state == TCP_CLOSE || 726 (sk->sk_shutdown & RCV_SHUTDOWN) || 727 !timeo || 728 (flags & MSG_PEEK)) 729 break; 730 } else { 731 if (sock_flag(sk, SOCK_DONE)) 732 break; 733 734 if (sk->sk_err) { 735 copied = sock_error(sk); 736 break; 737 } 738 if (sk->sk_shutdown & RCV_SHUTDOWN) 739 break; 740 741 if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSE) { 742 if (!sock_flag(sk, SOCK_DONE)) { 743 /* 744 * This occurs when user tries to read 745 * from never connected socket. 746 */ 747 copied = -ENOTCONN; 748 break; 749 } 750 break; 751 } 752 if (!timeo) { 753 copied = -EAGAIN; 754 break; 755 } 756 } 757 758 if (copied >= target) { /* Do not sleep, just process backlog. */ 759 release_sock(sk); 760 lock_sock(sk); 761 } else 762 sk_wait_data(sk, &timeo); 763 764 if ((flags & MSG_PEEK) && peek_seq != llc->copied_seq) { 765 if (net_ratelimit()) 766 printk(KERN_DEBUG "LLC(%s:%d): Application " 767 "bug, race in MSG_PEEK.\n", 768 current->comm, task_pid_nr(current)); 769 peek_seq = llc->copied_seq; 770 } 771 continue; 772 found_ok_skb: 773 /* Ok so how much can we use? */ 774 used = skb->len - offset; 775 if (len < used) 776 used = len; 777 778 if (!(flags & MSG_TRUNC)) { 779 int rc = skb_copy_datagram_iovec(skb, offset, 780 msg->msg_iov, used); 781 if (rc) { 782 /* Exception. Bailout! */ 783 if (!copied) 784 copied = -EFAULT; 785 break; 786 } 787 } 788 789 *seq += used; 790 copied += used; 791 len -= used; 792 793 if (!(flags & MSG_PEEK)) { 794 sk_eat_skb(sk, skb, 0); 795 *seq = 0; 796 } 797 798 /* For non stream protcols we get one packet per recvmsg call */ 799 if (sk->sk_type != SOCK_STREAM) 800 goto copy_uaddr; 801 802 /* Partial read */ 803 if (used + offset < skb->len) 804 continue; 805 } while (len > 0); 806 807 out: 808 release_sock(sk); 809 return copied; 810 copy_uaddr: 811 if (uaddr != NULL && skb != NULL) { 812 memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr)); 813 msg->msg_namelen = sizeof(*uaddr); 814 } 815 goto out; 816 } 817 818 /** 819 * llc_ui_sendmsg - Transmit data provided by the socket user. 820 * @sock: Socket to transmit data from. 821 * @msg: Various user related information. 822 * @len: Length of data to transmit. 823 * 824 * Transmit data provided by the socket user. 825 * Returns non-negative upon success, negative otherwise. 826 */ 827 static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock, 828 struct msghdr *msg, size_t len) 829 { 830 struct sock *sk = sock->sk; 831 struct llc_sock *llc = llc_sk(sk); 832 struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name; 833 int flags = msg->msg_flags; 834 int noblock = flags & MSG_DONTWAIT; 835 struct sk_buff *skb; 836 size_t size = 0; 837 int rc = -EINVAL, copied = 0, hdrlen; 838 839 dprintk("%s: sending from %02X to %02X\n", __func__, 840 llc->laddr.lsap, llc->daddr.lsap); 841 lock_sock(sk); 842 if (addr) { 843 if (msg->msg_namelen < sizeof(*addr)) 844 goto release; 845 } else { 846 if (llc_ui_addr_null(&llc->addr)) 847 goto release; 848 addr = &llc->addr; 849 } 850 /* must bind connection to sap if user hasn't done it. */ 851 if (sock_flag(sk, SOCK_ZAPPED)) { 852 /* bind to sap with null dev, exclusive. */ 853 rc = llc_ui_autobind(sock, addr); 854 if (rc) 855 goto release; 856 } 857 hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr); 858 size = hdrlen + len; 859 if (size > llc->dev->mtu) 860 size = llc->dev->mtu; 861 copied = size - hdrlen; 862 release_sock(sk); 863 skb = sock_alloc_send_skb(sk, size, noblock, &rc); 864 lock_sock(sk); 865 if (!skb) 866 goto release; 867 skb->dev = llc->dev; 868 skb->protocol = llc_proto_type(addr->sllc_arphrd); 869 skb_reserve(skb, hdrlen); 870 rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied); 871 if (rc) 872 goto out; 873 if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) { 874 llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac, 875 addr->sllc_sap); 876 goto out; 877 } 878 if (addr->sllc_test) { 879 llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac, 880 addr->sllc_sap); 881 goto out; 882 } 883 if (addr->sllc_xid) { 884 llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac, 885 addr->sllc_sap); 886 goto out; 887 } 888 rc = -ENOPROTOOPT; 889 if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua)) 890 goto out; 891 rc = llc_ui_send_data(sk, skb, noblock); 892 out: 893 if (rc) { 894 kfree_skb(skb); 895 release: 896 dprintk("%s: failed sending from %02X to %02X: %d\n", 897 __func__, llc->laddr.lsap, llc->daddr.lsap, rc); 898 } 899 release_sock(sk); 900 return rc ? : copied; 901 } 902 903 /** 904 * llc_ui_getname - return the address info of a socket 905 * @sock: Socket to get address of. 906 * @uaddr: Address structure to return information. 907 * @uaddrlen: Length of address structure. 908 * @peer: Does user want local or remote address information. 909 * 910 * Return the address information of a socket. 911 */ 912 static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr, 913 int *uaddrlen, int peer) 914 { 915 struct sockaddr_llc sllc; 916 struct sock *sk = sock->sk; 917 struct llc_sock *llc = llc_sk(sk); 918 int rc = 0; 919 920 memset(&sllc, 0, sizeof(sllc)); 921 lock_sock(sk); 922 if (sock_flag(sk, SOCK_ZAPPED)) 923 goto out; 924 *uaddrlen = sizeof(sllc); 925 memset(uaddr, 0, *uaddrlen); 926 if (peer) { 927 rc = -ENOTCONN; 928 if (sk->sk_state != TCP_ESTABLISHED) 929 goto out; 930 if(llc->dev) 931 sllc.sllc_arphrd = llc->dev->type; 932 sllc.sllc_sap = llc->daddr.lsap; 933 memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN); 934 } else { 935 rc = -EINVAL; 936 if (!llc->sap) 937 goto out; 938 sllc.sllc_sap = llc->sap->laddr.lsap; 939 940 if (llc->dev) { 941 sllc.sllc_arphrd = llc->dev->type; 942 memcpy(&sllc.sllc_mac, llc->dev->dev_addr, 943 IFHWADDRLEN); 944 } 945 } 946 rc = 0; 947 sllc.sllc_family = AF_LLC; 948 memcpy(uaddr, &sllc, sizeof(sllc)); 949 out: 950 release_sock(sk); 951 return rc; 952 } 953 954 /** 955 * llc_ui_ioctl - io controls for PF_LLC 956 * @sock: Socket to get/set info 957 * @cmd: command 958 * @arg: optional argument for cmd 959 * 960 * get/set info on llc sockets 961 */ 962 static int llc_ui_ioctl(struct socket *sock, unsigned int cmd, 963 unsigned long arg) 964 { 965 return -ENOIOCTLCMD; 966 } 967 968 /** 969 * llc_ui_setsockopt - set various connection specific parameters. 970 * @sock: Socket to set options on. 971 * @level: Socket level user is requesting operations on. 972 * @optname: Operation name. 973 * @optval User provided operation data. 974 * @optlen: Length of optval. 975 * 976 * Set various connection specific parameters. 977 */ 978 static int llc_ui_setsockopt(struct socket *sock, int level, int optname, 979 char __user *optval, unsigned int optlen) 980 { 981 struct sock *sk = sock->sk; 982 struct llc_sock *llc = llc_sk(sk); 983 int rc = -EINVAL, opt; 984 985 lock_sock(sk); 986 if (unlikely(level != SOL_LLC || optlen != sizeof(int))) 987 goto out; 988 rc = get_user(opt, (int __user *)optval); 989 if (rc) 990 goto out; 991 rc = -EINVAL; 992 switch (optname) { 993 case LLC_OPT_RETRY: 994 if (opt > LLC_OPT_MAX_RETRY) 995 goto out; 996 llc->n2 = opt; 997 break; 998 case LLC_OPT_SIZE: 999 if (opt > LLC_OPT_MAX_SIZE) 1000 goto out; 1001 llc->n1 = opt; 1002 break; 1003 case LLC_OPT_ACK_TMR_EXP: 1004 if (opt > LLC_OPT_MAX_ACK_TMR_EXP) 1005 goto out; 1006 llc->ack_timer.expire = opt * HZ; 1007 break; 1008 case LLC_OPT_P_TMR_EXP: 1009 if (opt > LLC_OPT_MAX_P_TMR_EXP) 1010 goto out; 1011 llc->pf_cycle_timer.expire = opt * HZ; 1012 break; 1013 case LLC_OPT_REJ_TMR_EXP: 1014 if (opt > LLC_OPT_MAX_REJ_TMR_EXP) 1015 goto out; 1016 llc->rej_sent_timer.expire = opt * HZ; 1017 break; 1018 case LLC_OPT_BUSY_TMR_EXP: 1019 if (opt > LLC_OPT_MAX_BUSY_TMR_EXP) 1020 goto out; 1021 llc->busy_state_timer.expire = opt * HZ; 1022 break; 1023 case LLC_OPT_TX_WIN: 1024 if (opt > LLC_OPT_MAX_WIN) 1025 goto out; 1026 llc->k = opt; 1027 break; 1028 case LLC_OPT_RX_WIN: 1029 if (opt > LLC_OPT_MAX_WIN) 1030 goto out; 1031 llc->rw = opt; 1032 break; 1033 default: 1034 rc = -ENOPROTOOPT; 1035 goto out; 1036 } 1037 rc = 0; 1038 out: 1039 release_sock(sk); 1040 return rc; 1041 } 1042 1043 /** 1044 * llc_ui_getsockopt - get connection specific socket info 1045 * @sock: Socket to get information from. 1046 * @level: Socket level user is requesting operations on. 1047 * @optname: Operation name. 1048 * @optval: Variable to return operation data in. 1049 * @optlen: Length of optval. 1050 * 1051 * Get connection specific socket information. 1052 */ 1053 static int llc_ui_getsockopt(struct socket *sock, int level, int optname, 1054 char __user *optval, int __user *optlen) 1055 { 1056 struct sock *sk = sock->sk; 1057 struct llc_sock *llc = llc_sk(sk); 1058 int val = 0, len = 0, rc = -EINVAL; 1059 1060 lock_sock(sk); 1061 if (unlikely(level != SOL_LLC)) 1062 goto out; 1063 rc = get_user(len, optlen); 1064 if (rc) 1065 goto out; 1066 rc = -EINVAL; 1067 if (len != sizeof(int)) 1068 goto out; 1069 switch (optname) { 1070 case LLC_OPT_RETRY: 1071 val = llc->n2; break; 1072 case LLC_OPT_SIZE: 1073 val = llc->n1; break; 1074 case LLC_OPT_ACK_TMR_EXP: 1075 val = llc->ack_timer.expire / HZ; break; 1076 case LLC_OPT_P_TMR_EXP: 1077 val = llc->pf_cycle_timer.expire / HZ; break; 1078 case LLC_OPT_REJ_TMR_EXP: 1079 val = llc->rej_sent_timer.expire / HZ; break; 1080 case LLC_OPT_BUSY_TMR_EXP: 1081 val = llc->busy_state_timer.expire / HZ; break; 1082 case LLC_OPT_TX_WIN: 1083 val = llc->k; break; 1084 case LLC_OPT_RX_WIN: 1085 val = llc->rw; break; 1086 default: 1087 rc = -ENOPROTOOPT; 1088 goto out; 1089 } 1090 rc = 0; 1091 if (put_user(len, optlen) || copy_to_user(optval, &val, len)) 1092 rc = -EFAULT; 1093 out: 1094 release_sock(sk); 1095 return rc; 1096 } 1097 1098 static const struct net_proto_family llc_ui_family_ops = { 1099 .family = PF_LLC, 1100 .create = llc_ui_create, 1101 .owner = THIS_MODULE, 1102 }; 1103 1104 static const struct proto_ops llc_ui_ops = { 1105 .family = PF_LLC, 1106 .owner = THIS_MODULE, 1107 .release = llc_ui_release, 1108 .bind = llc_ui_bind, 1109 .connect = llc_ui_connect, 1110 .socketpair = sock_no_socketpair, 1111 .accept = llc_ui_accept, 1112 .getname = llc_ui_getname, 1113 .poll = datagram_poll, 1114 .ioctl = llc_ui_ioctl, 1115 .listen = llc_ui_listen, 1116 .shutdown = llc_ui_shutdown, 1117 .setsockopt = llc_ui_setsockopt, 1118 .getsockopt = llc_ui_getsockopt, 1119 .sendmsg = llc_ui_sendmsg, 1120 .recvmsg = llc_ui_recvmsg, 1121 .mmap = sock_no_mmap, 1122 .sendpage = sock_no_sendpage, 1123 }; 1124 1125 static const char llc_proc_err_msg[] __initconst = 1126 KERN_CRIT "LLC: Unable to register the proc_fs entries\n"; 1127 static const char llc_sysctl_err_msg[] __initconst = 1128 KERN_CRIT "LLC: Unable to register the sysctl entries\n"; 1129 static const char llc_sock_err_msg[] __initconst = 1130 KERN_CRIT "LLC: Unable to register the network family\n"; 1131 1132 static int __init llc2_init(void) 1133 { 1134 int rc = proto_register(&llc_proto, 0); 1135 1136 if (rc != 0) 1137 goto out; 1138 1139 llc_build_offset_table(); 1140 llc_station_init(); 1141 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 1142 rc = llc_proc_init(); 1143 if (rc != 0) { 1144 printk(llc_proc_err_msg); 1145 goto out_unregister_llc_proto; 1146 } 1147 rc = llc_sysctl_init(); 1148 if (rc) { 1149 printk(llc_sysctl_err_msg); 1150 goto out_proc; 1151 } 1152 rc = sock_register(&llc_ui_family_ops); 1153 if (rc) { 1154 printk(llc_sock_err_msg); 1155 goto out_sysctl; 1156 } 1157 llc_add_pack(LLC_DEST_SAP, llc_sap_handler); 1158 llc_add_pack(LLC_DEST_CONN, llc_conn_handler); 1159 out: 1160 return rc; 1161 out_sysctl: 1162 llc_sysctl_exit(); 1163 out_proc: 1164 llc_proc_exit(); 1165 out_unregister_llc_proto: 1166 proto_unregister(&llc_proto); 1167 goto out; 1168 } 1169 1170 static void __exit llc2_exit(void) 1171 { 1172 llc_station_exit(); 1173 llc_remove_pack(LLC_DEST_SAP); 1174 llc_remove_pack(LLC_DEST_CONN); 1175 sock_unregister(PF_LLC); 1176 llc_proc_exit(); 1177 llc_sysctl_exit(); 1178 proto_unregister(&llc_proto); 1179 } 1180 1181 module_init(llc2_init); 1182 module_exit(llc2_exit); 1183 1184 MODULE_LICENSE("GPL"); 1185 MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003"); 1186 MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support"); 1187 MODULE_ALIAS_NETPROTO(PF_LLC); 1188