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