af_llc.c revision b35bd11019ed1084a36632f1c1d936244d9cfb5b
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/config.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 struct proto_ops llc_ui_ops; 39 40static int llc_ui_wait_for_conn(struct sock *sk, int timeout); 41static int llc_ui_wait_for_disc(struct sock *sk, int timeout); 42static int llc_ui_wait_for_data(struct sock *sk, int timeout); 43static int llc_ui_wait_for_busy_core(struct sock *sk, int timeout); 44 45#if 0 46#define dprintk(args...) printk(KERN_DEBUG args) 47#else 48#define dprintk(args...) 49#endif 50 51/** 52 * llc_ui_next_link_no - return the next unused link number for a sap 53 * @sap: Address of sap to get link number from. 54 * 55 * Return the next unused link number for a given sap. 56 */ 57static __inline__ u16 llc_ui_next_link_no(int sap) 58{ 59 return llc_ui_sap_link_no_max[sap]++; 60} 61 62/** 63 * llc_proto_type - return eth protocol for ARP header type 64 * @arphrd: ARP header type. 65 * 66 * Given an ARP header type return the corresponding ethernet protocol. 67 */ 68static __inline__ u16 llc_proto_type(u16 arphrd) 69{ 70 return arphrd == ARPHRD_IEEE802_TR ? 71 htons(ETH_P_TR_802_2) : htons(ETH_P_802_2); 72} 73 74/** 75 * llc_ui_addr_null - determines if a address structure is null 76 * @addr: Address to test if null. 77 */ 78static __inline__ u8 llc_ui_addr_null(struct sockaddr_llc *addr) 79{ 80 return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr)); 81} 82 83/** 84 * llc_ui_header_len - return length of llc header based on operation 85 * @sk: Socket which contains a valid llc socket type. 86 * @addr: Complete sockaddr_llc structure received from the user. 87 * 88 * Provide the length of the llc header depending on what kind of 89 * operation the user would like to perform and the type of socket. 90 * Returns the correct llc header length. 91 */ 92static __inline__ u8 llc_ui_header_len(struct sock *sk, 93 struct sockaddr_llc *addr) 94{ 95 u8 rc = LLC_PDU_LEN_U; 96 97 if (addr->sllc_test || addr->sllc_xid) 98 rc = LLC_PDU_LEN_U; 99 else if (sk->sk_type == SOCK_STREAM) 100 rc = LLC_PDU_LEN_I; 101 return rc; 102} 103 104/** 105 * llc_ui_send_data - send data via reliable llc2 connection 106 * @sk: Connection the socket is using. 107 * @skb: Data the user wishes to send. 108 * @addr: Source and destination fields provided by the user. 109 * @noblock: can we block waiting for data? 110 * 111 * Send data via reliable llc2 connection. 112 * Returns 0 upon success, non-zero if action did not succeed. 113 */ 114static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock) 115{ 116 struct llc_sock* llc = llc_sk(sk); 117 int rc = 0; 118 119 if (llc_data_accept_state(llc->state) || llc->p_flag) { 120 int timeout = sock_sndtimeo(sk, noblock); 121 122 rc = llc_ui_wait_for_busy_core(sk, timeout); 123 } 124 if (!rc) 125 rc = llc_build_and_send_pkt(sk, skb); 126 return rc; 127} 128 129static void llc_ui_sk_init(struct socket *sock, struct sock *sk) 130{ 131 sk->sk_type = sock->type; 132 sk->sk_sleep = &sock->wait; 133 sk->sk_socket = sock; 134 sock->sk = sk; 135 sock->ops = &llc_ui_ops; 136} 137 138static struct proto llc_proto = { 139 .name = "DDP", 140 .owner = THIS_MODULE, 141 .obj_size = sizeof(struct llc_sock), 142}; 143 144/** 145 * llc_ui_create - alloc and init a new llc_ui socket 146 * @sock: Socket to initialize and attach allocated sk to. 147 * @protocol: Unused. 148 * 149 * Allocate and initialize a new llc_ui socket, validate the user wants a 150 * socket type we have available. 151 * Returns 0 upon success, negative upon failure. 152 */ 153static int llc_ui_create(struct socket *sock, int protocol) 154{ 155 struct sock *sk; 156 int rc = -ESOCKTNOSUPPORT; 157 158 if (likely(sock->type == SOCK_DGRAM || sock->type == SOCK_STREAM)) { 159 rc = -ENOMEM; 160 sk = llc_sk_alloc(PF_LLC, GFP_KERNEL, &llc_proto); 161 if (sk) { 162 rc = 0; 163 llc_ui_sk_init(sock, sk); 164 } 165 } 166 return rc; 167} 168 169/** 170 * llc_ui_release - shutdown socket 171 * @sock: Socket to release. 172 * 173 * Shutdown and deallocate an existing socket. 174 */ 175static int llc_ui_release(struct socket *sock) 176{ 177 struct sock *sk = sock->sk; 178 struct llc_sock *llc; 179 180 if (unlikely(sk == NULL)) 181 goto out; 182 sock_hold(sk); 183 lock_sock(sk); 184 llc = llc_sk(sk); 185 dprintk("%s: closing local(%02X) remote(%02X)\n", __FUNCTION__, 186 llc->laddr.lsap, llc->daddr.lsap); 187 if (!llc_send_disc(sk)) 188 llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo); 189 if (!sock_flag(sk, SOCK_ZAPPED)) 190 llc_sap_remove_socket(llc->sap, sk); 191 release_sock(sk); 192 if (llc->sap && hlist_empty(&llc->sap->sk_list.list)) { 193 llc_release_sockets(llc->sap); 194 llc_sap_close(llc->sap); 195 } 196 if (llc->dev) 197 dev_put(llc->dev); 198 sock_put(sk); 199 llc_sk_free(sk); 200out: 201 return 0; 202} 203 204/** 205 * llc_ui_autoport - provide dynamically allocate SAP number 206 * 207 * Provide the caller with a dynamically allocated SAP number according 208 * to the rules that are set in this function. Returns: 0, upon failure, 209 * SAP number otherwise. 210 */ 211static int llc_ui_autoport(void) 212{ 213 struct llc_sap *sap; 214 int i, tries = 0; 215 216 while (tries < LLC_SAP_DYN_TRIES) { 217 for (i = llc_ui_sap_last_autoport; 218 i < LLC_SAP_DYN_STOP; i += 2) { 219 sap = llc_sap_find(i); 220 if (!sap) { 221 llc_ui_sap_last_autoport = i + 2; 222 goto out; 223 } 224 } 225 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 226 tries++; 227 } 228 i = 0; 229out: 230 return i; 231} 232 233/** 234 * llc_ui_autobind - automatically bind a socket to a sap 235 * @sock: socket to bind 236 * @addr: address to connect to 237 * 238 * Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't 239 * specifically used llc_ui_bind to bind to an specific address/sap 240 * 241 * Returns: 0 upon success, negative otherwise. 242 */ 243static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr) 244{ 245 struct sock *sk = sock->sk; 246 struct llc_sock *llc = llc_sk(sk); 247 struct llc_sap *sap; 248 int rc = -EINVAL; 249 250 if (!sock_flag(sk, SOCK_ZAPPED)) 251 goto out; 252 rc = -ENODEV; 253 llc->dev = dev_getfirstbyhwtype(addr->sllc_arphrd); 254 if (!llc->dev) 255 goto out; 256 rc = -EUSERS; 257 llc->laddr.lsap = llc_ui_autoport(); 258 if (!llc->laddr.lsap) 259 goto out; 260 rc = -EBUSY; /* some other network layer is using the sap */ 261 sap = llc_sap_open(llc->laddr.lsap, NULL); 262 if (!sap) 263 goto out; 264 memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN); 265 memcpy(&llc->addr, addr, sizeof(llc->addr)); 266 /* assign new connection to its SAP */ 267 llc_sap_add_socket(sap, sk); 268 sock_reset_flag(sk, SOCK_ZAPPED); 269 rc = 0; 270out: 271 return rc; 272} 273 274/** 275 * llc_ui_bind - bind a socket to a specific address. 276 * @sock: Socket to bind an address to. 277 * @uaddr: Address the user wants the socket bound to. 278 * @addrlen: Length of the uaddr structure. 279 * 280 * Bind a socket to a specific address. For llc a user is able to bind to 281 * a specific sap only or mac + sap. 282 * If the user desires to bind to a specific mac + sap, it is possible to 283 * have multiple sap connections via multiple macs. 284 * Bind and autobind for that matter must enforce the correct sap usage 285 * otherwise all hell will break loose. 286 * Returns: 0 upon success, negative otherwise. 287 */ 288static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen) 289{ 290 struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr; 291 struct sock *sk = sock->sk; 292 struct llc_sock *llc = llc_sk(sk); 293 struct llc_sap *sap; 294 int rc = -EINVAL; 295 296 dprintk("%s: binding %02X\n", __FUNCTION__, addr->sllc_sap); 297 if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr))) 298 goto out; 299 rc = -EAFNOSUPPORT; 300 if (unlikely(addr->sllc_family != AF_LLC)) 301 goto out; 302 if (!addr->sllc_sap) { 303 rc = -EUSERS; 304 addr->sllc_sap = llc_ui_autoport(); 305 if (!addr->sllc_sap) 306 goto out; 307 } 308 sap = llc_sap_find(addr->sllc_sap); 309 if (!sap) { 310 sap = llc_sap_open(addr->sllc_sap, NULL); 311 rc = -EBUSY; /* some other network layer is using the sap */ 312 if (!sap) 313 goto out; 314 } else { 315 struct llc_addr laddr, daddr; 316 struct sock *ask; 317 318 memset(&laddr, 0, sizeof(laddr)); 319 memset(&daddr, 0, sizeof(daddr)); 320 /* 321 * FIXME: check if the the address is multicast, 322 * only SOCK_DGRAM can do this. 323 */ 324 memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN); 325 laddr.lsap = addr->sllc_sap; 326 rc = -EADDRINUSE; /* mac + sap clash. */ 327 ask = llc_lookup_established(sap, &daddr, &laddr); 328 if (ask) { 329 sock_put(ask); 330 goto out; 331 } 332 } 333 llc->laddr.lsap = addr->sllc_sap; 334 memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN); 335 memcpy(&llc->addr, addr, sizeof(llc->addr)); 336 /* assign new connection to its SAP */ 337 llc_sap_add_socket(sap, sk); 338 sock_reset_flag(sk, SOCK_ZAPPED); 339 rc = 0; 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 llc->daddr.lsap = addr->sllc_sap; 416 memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN); 417 } 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 int 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, int timeout) 492{ 493 DEFINE_WAIT(wait); 494 int rc = 0; 495 496 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 497 while (sk->sk_state != TCP_CLOSE) { 498 release_sock(sk); 499 timeout = schedule_timeout(timeout); 500 lock_sock(sk); 501 rc = -ERESTARTSYS; 502 if (signal_pending(current)) 503 break; 504 rc = -EAGAIN; 505 if (!timeout) 506 break; 507 rc = 0; 508 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 509 } 510 finish_wait(sk->sk_sleep, &wait); 511 return rc; 512} 513 514static int llc_ui_wait_for_conn(struct sock *sk, int timeout) 515{ 516 DEFINE_WAIT(wait); 517 518 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 519 520 while (sk->sk_state == TCP_SYN_SENT) { 521 release_sock(sk); 522 timeout = schedule_timeout(timeout); 523 lock_sock(sk); 524 if (signal_pending(current) || !timeout) 525 break; 526 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 527 } 528 finish_wait(sk->sk_sleep, &wait); 529 return timeout; 530} 531 532static int llc_ui_wait_for_data(struct sock *sk, int timeout) 533{ 534 DEFINE_WAIT(wait); 535 int rc = 0; 536 537 for (;;) { 538 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 539 if (sk->sk_shutdown & RCV_SHUTDOWN) 540 break; 541 if (!skb_queue_empty(&sk->sk_receive_queue)) 542 break; 543 release_sock(sk); 544 timeout = schedule_timeout(timeout); 545 lock_sock(sk); 546 rc = -ERESTARTSYS; 547 if (signal_pending(current)) 548 break; 549 rc = -EAGAIN; 550 if (!timeout) 551 break; 552 rc = 0; 553 } 554 finish_wait(sk->sk_sleep, &wait); 555 return rc; 556} 557 558static int llc_ui_wait_for_busy_core(struct sock *sk, int timeout) 559{ 560 DEFINE_WAIT(wait); 561 struct llc_sock *llc = llc_sk(sk); 562 int rc; 563 564 for (;;) { 565 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 566 rc = -ENOTCONN; 567 if (sk->sk_shutdown & RCV_SHUTDOWN) 568 break; 569 rc = 0; 570 if (!llc_data_accept_state(llc->state) && !llc->p_flag) 571 break; 572 release_sock(sk); 573 timeout = schedule_timeout(timeout); 574 lock_sock(sk); 575 rc = -ERESTARTSYS; 576 if (signal_pending(current)) 577 break; 578 rc = -EAGAIN; 579 if (!timeout) 580 break; 581 } 582 finish_wait(sk->sk_sleep, &wait); 583 return rc; 584} 585 586/** 587 * llc_ui_accept - accept a new incoming connection. 588 * @sock: Socket which connections arrive on. 589 * @newsock: Socket to move incoming connection to. 590 * @flags: User specified operational flags. 591 * 592 * Accept a new incoming connection. 593 * Returns 0 upon success, negative otherwise. 594 */ 595static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags) 596{ 597 struct sock *sk = sock->sk, *newsk; 598 struct llc_sock *llc, *newllc; 599 struct sk_buff *skb; 600 int rc = -EOPNOTSUPP; 601 602 dprintk("%s: accepting on %02X\n", __FUNCTION__, 603 llc_sk(sk)->laddr.lsap); 604 lock_sock(sk); 605 if (unlikely(sk->sk_type != SOCK_STREAM)) 606 goto out; 607 rc = -EINVAL; 608 if (unlikely(sock->state != SS_UNCONNECTED || 609 sk->sk_state != TCP_LISTEN)) 610 goto out; 611 /* wait for a connection to arrive. */ 612 if (skb_queue_empty(&sk->sk_receive_queue)) { 613 rc = llc_ui_wait_for_data(sk, sk->sk_rcvtimeo); 614 if (rc) 615 goto out; 616 } 617 dprintk("%s: got a new connection on %02X\n", __FUNCTION__, 618 llc_sk(sk)->laddr.lsap); 619 skb = skb_dequeue(&sk->sk_receive_queue); 620 rc = -EINVAL; 621 if (!skb->sk) 622 goto frees; 623 rc = 0; 624 newsk = skb->sk; 625 /* attach connection to a new socket. */ 626 llc_ui_sk_init(newsock, newsk); 627 sock_reset_flag(newsk, SOCK_ZAPPED); 628 newsk->sk_state = TCP_ESTABLISHED; 629 newsock->state = SS_CONNECTED; 630 llc = llc_sk(sk); 631 newllc = llc_sk(newsk); 632 memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr)); 633 newllc->link = llc_ui_next_link_no(newllc->laddr.lsap); 634 635 /* put original socket back into a clean listen state. */ 636 sk->sk_state = TCP_LISTEN; 637 sk->sk_ack_backlog--; 638 skb->sk = NULL; 639 dprintk("%s: ok success on %02X, client on %02X\n", __FUNCTION__, 640 llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap); 641frees: 642 kfree_skb(skb); 643out: 644 release_sock(sk); 645 return rc; 646} 647 648/** 649 * llc_ui_recvmsg - copy received data to the socket user. 650 * @sock: Socket to copy data from. 651 * @msg: Various user space related information. 652 * @size: Size of user buffer. 653 * @flags: User specified flags. 654 * 655 * Copy received data to the socket user. 656 * Returns non-negative upon success, negative otherwise. 657 */ 658static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock, 659 struct msghdr *msg, size_t size, int flags) 660{ 661 struct sock *sk = sock->sk; 662 struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name; 663 struct sk_buff *skb; 664 size_t copied = 0; 665 int rc = -ENOMEM; 666 int noblock = flags & MSG_DONTWAIT; 667 668 dprintk("%s: receiving in %02X from %02X\n", __FUNCTION__, 669 llc_sk(sk)->laddr.lsap, llc_sk(sk)->daddr.lsap); 670 lock_sock(sk); 671 if (skb_queue_empty(&sk->sk_receive_queue)) { 672 rc = llc_ui_wait_for_data(sk, sock_rcvtimeo(sk, noblock)); 673 if (rc) 674 goto out; 675 } 676 skb = skb_dequeue(&sk->sk_receive_queue); 677 if (!skb) /* shutdown */ 678 goto out; 679 copied = skb->len; 680 if (copied > size) 681 copied = size; 682 rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 683 if (rc) 684 goto dgram_free; 685 if (skb->len > copied) { 686 skb_pull(skb, copied); 687 skb_queue_head(&sk->sk_receive_queue, skb); 688 } 689 if (uaddr) 690 memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr)); 691 msg->msg_namelen = sizeof(*uaddr); 692 if (!skb->next) { 693dgram_free: 694 kfree_skb(skb); 695 } 696out: 697 release_sock(sk); 698 return rc ? : copied; 699} 700 701/** 702 * llc_ui_sendmsg - Transmit data provided by the socket user. 703 * @sock: Socket to transmit data from. 704 * @msg: Various user related information. 705 * @len: Length of data to transmit. 706 * 707 * Transmit data provided by the socket user. 708 * Returns non-negative upon success, negative otherwise. 709 */ 710static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock, 711 struct msghdr *msg, size_t len) 712{ 713 struct sock *sk = sock->sk; 714 struct llc_sock *llc = llc_sk(sk); 715 struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name; 716 int flags = msg->msg_flags; 717 int noblock = flags & MSG_DONTWAIT; 718 struct sk_buff *skb; 719 size_t size = 0; 720 int rc = -EINVAL, copied = 0, hdrlen; 721 722 dprintk("%s: sending from %02X to %02X\n", __FUNCTION__, 723 llc->laddr.lsap, llc->daddr.lsap); 724 lock_sock(sk); 725 if (addr) { 726 if (msg->msg_namelen < sizeof(*addr)) 727 goto release; 728 } else { 729 if (llc_ui_addr_null(&llc->addr)) 730 goto release; 731 addr = &llc->addr; 732 } 733 /* must bind connection to sap if user hasn't done it. */ 734 if (sock_flag(sk, SOCK_ZAPPED)) { 735 /* bind to sap with null dev, exclusive. */ 736 rc = llc_ui_autobind(sock, addr); 737 if (rc) 738 goto release; 739 } 740 hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr); 741 size = hdrlen + len; 742 if (size > llc->dev->mtu) 743 size = llc->dev->mtu; 744 copied = size - hdrlen; 745 release_sock(sk); 746 skb = sock_alloc_send_skb(sk, size, noblock, &rc); 747 lock_sock(sk); 748 if (!skb) 749 goto release; 750 skb->sk = sk; 751 skb->dev = llc->dev; 752 skb->protocol = llc_proto_type(addr->sllc_arphrd); 753 skb_reserve(skb, hdrlen); 754 rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied); 755 if (rc) 756 goto out; 757 if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) { 758 llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac, 759 addr->sllc_sap); 760 goto out; 761 } 762 if (addr->sllc_test) { 763 llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac, 764 addr->sllc_sap); 765 goto out; 766 } 767 if (addr->sllc_xid) { 768 llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac, 769 addr->sllc_sap); 770 goto out; 771 } 772 rc = -ENOPROTOOPT; 773 if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua)) 774 goto out; 775 rc = llc_ui_send_data(sk, skb, noblock); 776 if (rc) 777 dprintk("%s: llc_ui_send_data failed: %d\n", __FUNCTION__, rc); 778out: 779 if (rc) 780 kfree_skb(skb); 781release: 782 if (rc) 783 dprintk("%s: failed sending from %02X to %02X: %d\n", 784 __FUNCTION__, llc->laddr.lsap, llc->daddr.lsap, rc); 785 release_sock(sk); 786 return rc ? : copied; 787} 788 789/** 790 * llc_ui_getname - return the address info of a socket 791 * @sock: Socket to get address of. 792 * @uaddr: Address structure to return information. 793 * @uaddrlen: Length of address structure. 794 * @peer: Does user want local or remote address information. 795 * 796 * Return the address information of a socket. 797 */ 798static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr, 799 int *uaddrlen, int peer) 800{ 801 struct sockaddr_llc sllc; 802 struct sock *sk = sock->sk; 803 struct llc_sock *llc = llc_sk(sk); 804 int rc = 0; 805 806 lock_sock(sk); 807 if (sock_flag(sk, SOCK_ZAPPED)) 808 goto out; 809 *uaddrlen = sizeof(sllc); 810 memset(uaddr, 0, *uaddrlen); 811 if (peer) { 812 rc = -ENOTCONN; 813 if (sk->sk_state != TCP_ESTABLISHED) 814 goto out; 815 if(llc->dev) 816 sllc.sllc_arphrd = llc->dev->type; 817 sllc.sllc_sap = llc->daddr.lsap; 818 memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN); 819 } else { 820 rc = -EINVAL; 821 if (!llc->sap) 822 goto out; 823 sllc.sllc_sap = llc->sap->laddr.lsap; 824 825 if (llc->dev) { 826 sllc.sllc_arphrd = llc->dev->type; 827 memcpy(&sllc.sllc_mac, &llc->dev->dev_addr, 828 IFHWADDRLEN); 829 } 830 } 831 rc = 0; 832 sllc.sllc_family = AF_LLC; 833 memcpy(uaddr, &sllc, sizeof(sllc)); 834out: 835 release_sock(sk); 836 return rc; 837} 838 839/** 840 * llc_ui_ioctl - io controls for PF_LLC 841 * @sock: Socket to get/set info 842 * @cmd: command 843 * @arg: optional argument for cmd 844 * 845 * get/set info on llc sockets 846 */ 847static int llc_ui_ioctl(struct socket *sock, unsigned int cmd, 848 unsigned long arg) 849{ 850 return dev_ioctl(cmd, (void __user *)arg); 851} 852 853/** 854 * llc_ui_setsockopt - set various connection specific parameters. 855 * @sock: Socket to set options on. 856 * @level: Socket level user is requesting operations on. 857 * @optname: Operation name. 858 * @optval User provided operation data. 859 * @optlen: Length of optval. 860 * 861 * Set various connection specific parameters. 862 */ 863static int llc_ui_setsockopt(struct socket *sock, int level, int optname, 864 char __user *optval, int optlen) 865{ 866 struct sock *sk = sock->sk; 867 struct llc_sock *llc = llc_sk(sk); 868 int rc = -EINVAL, opt; 869 870 lock_sock(sk); 871 if (unlikely(level != SOL_LLC || optlen != sizeof(int))) 872 goto out; 873 rc = get_user(opt, (int __user *)optval); 874 if (rc) 875 goto out; 876 rc = -EINVAL; 877 switch (optname) { 878 case LLC_OPT_RETRY: 879 if (opt > LLC_OPT_MAX_RETRY) 880 goto out; 881 llc->n2 = opt; 882 break; 883 case LLC_OPT_SIZE: 884 if (opt > LLC_OPT_MAX_SIZE) 885 goto out; 886 llc->n1 = opt; 887 break; 888 case LLC_OPT_ACK_TMR_EXP: 889 if (opt > LLC_OPT_MAX_ACK_TMR_EXP) 890 goto out; 891 llc->ack_timer.expire = opt; 892 break; 893 case LLC_OPT_P_TMR_EXP: 894 if (opt > LLC_OPT_MAX_P_TMR_EXP) 895 goto out; 896 llc->pf_cycle_timer.expire = opt; 897 break; 898 case LLC_OPT_REJ_TMR_EXP: 899 if (opt > LLC_OPT_MAX_REJ_TMR_EXP) 900 goto out; 901 llc->rej_sent_timer.expire = opt; 902 break; 903 case LLC_OPT_BUSY_TMR_EXP: 904 if (opt > LLC_OPT_MAX_BUSY_TMR_EXP) 905 goto out; 906 llc->busy_state_timer.expire = opt; 907 break; 908 case LLC_OPT_TX_WIN: 909 if (opt > LLC_OPT_MAX_WIN) 910 goto out; 911 llc->k = opt; 912 break; 913 case LLC_OPT_RX_WIN: 914 if (opt > LLC_OPT_MAX_WIN) 915 goto out; 916 llc->rw = opt; 917 break; 918 default: 919 rc = -ENOPROTOOPT; 920 goto out; 921 } 922 rc = 0; 923out: 924 release_sock(sk); 925 return rc; 926} 927 928/** 929 * llc_ui_getsockopt - get connection specific socket info 930 * @sock: Socket to get information from. 931 * @level: Socket level user is requesting operations on. 932 * @optname: Operation name. 933 * @optval: Variable to return operation data in. 934 * @optlen: Length of optval. 935 * 936 * Get connection specific socket information. 937 */ 938static int llc_ui_getsockopt(struct socket *sock, int level, int optname, 939 char __user *optval, int __user *optlen) 940{ 941 struct sock *sk = sock->sk; 942 struct llc_sock *llc = llc_sk(sk); 943 int val = 0, len = 0, rc = -EINVAL; 944 945 lock_sock(sk); 946 if (unlikely(level != SOL_LLC)) 947 goto out; 948 rc = get_user(len, optlen); 949 if (rc) 950 goto out; 951 rc = -EINVAL; 952 if (len != sizeof(int)) 953 goto out; 954 switch (optname) { 955 case LLC_OPT_RETRY: 956 val = llc->n2; break; 957 case LLC_OPT_SIZE: 958 val = llc->n1; break; 959 case LLC_OPT_ACK_TMR_EXP: 960 val = llc->ack_timer.expire; break; 961 case LLC_OPT_P_TMR_EXP: 962 val = llc->pf_cycle_timer.expire; break; 963 case LLC_OPT_REJ_TMR_EXP: 964 val = llc->rej_sent_timer.expire; break; 965 case LLC_OPT_BUSY_TMR_EXP: 966 val = llc->busy_state_timer.expire; break; 967 case LLC_OPT_TX_WIN: 968 val = llc->k; break; 969 case LLC_OPT_RX_WIN: 970 val = llc->rw; break; 971 default: 972 rc = -ENOPROTOOPT; 973 goto out; 974 } 975 rc = 0; 976 if (put_user(len, optlen) || copy_to_user(optval, &val, len)) 977 rc = -EFAULT; 978out: 979 release_sock(sk); 980 return rc; 981} 982 983static struct net_proto_family llc_ui_family_ops = { 984 .family = PF_LLC, 985 .create = llc_ui_create, 986 .owner = THIS_MODULE, 987}; 988 989static struct proto_ops llc_ui_ops = { 990 .family = PF_LLC, 991 .owner = THIS_MODULE, 992 .release = llc_ui_release, 993 .bind = llc_ui_bind, 994 .connect = llc_ui_connect, 995 .socketpair = sock_no_socketpair, 996 .accept = llc_ui_accept, 997 .getname = llc_ui_getname, 998 .poll = datagram_poll, 999 .ioctl = llc_ui_ioctl, 1000 .listen = llc_ui_listen, 1001 .shutdown = llc_ui_shutdown, 1002 .setsockopt = llc_ui_setsockopt, 1003 .getsockopt = llc_ui_getsockopt, 1004 .sendmsg = llc_ui_sendmsg, 1005 .recvmsg = llc_ui_recvmsg, 1006 .mmap = sock_no_mmap, 1007 .sendpage = sock_no_sendpage, 1008}; 1009 1010extern void llc_sap_handler(struct llc_sap *sap, struct sk_buff *skb); 1011extern void llc_conn_handler(struct llc_sap *sap, struct sk_buff *skb); 1012 1013static int __init llc2_init(void) 1014{ 1015 int rc = proto_register(&llc_proto, 0); 1016 1017 if (rc != 0) 1018 goto out; 1019 1020 llc_build_offset_table(); 1021 llc_station_init(); 1022 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 1023 rc = llc_proc_init(); 1024 if (rc != 0) 1025 goto out_unregister_llc_proto; 1026 sock_register(&llc_ui_family_ops); 1027 llc_add_pack(LLC_DEST_SAP, llc_sap_handler); 1028 llc_add_pack(LLC_DEST_CONN, llc_conn_handler); 1029out: 1030 return rc; 1031out_unregister_llc_proto: 1032 proto_unregister(&llc_proto); 1033 goto out; 1034} 1035 1036static void __exit llc2_exit(void) 1037{ 1038 llc_station_exit(); 1039 llc_remove_pack(LLC_DEST_SAP); 1040 llc_remove_pack(LLC_DEST_CONN); 1041 sock_unregister(PF_LLC); 1042 llc_proc_exit(); 1043 proto_unregister(&llc_proto); 1044} 1045 1046module_init(llc2_init); 1047module_exit(llc2_exit); 1048 1049MODULE_LICENSE("GPL"); 1050MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003"); 1051MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support"); 1052MODULE_ALIAS_NETPROTO(PF_LLC); 1053