af_llc.c revision cf309e3fb863b7a245b91f816193957f6daf786f
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/compiler.h> 25#include <linux/kernel.h> 26#include <linux/module.h> 27#include <linux/rtnetlink.h> 28#include <linux/init.h> 29#include <net/llc.h> 30#include <net/llc_sap.h> 31#include <net/llc_pdu.h> 32#include <net/llc_conn.h> 33#include <net/tcp_states.h> 34 35/* remember: uninitialized global data is zeroed because its in .bss */ 36static u16 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 37static u16 llc_ui_sap_link_no_max[256]; 38static struct sockaddr_llc llc_ui_addrnull; 39static struct proto_ops llc_ui_ops; 40 41static int llc_ui_wait_for_conn(struct sock *sk, long timeout); 42static int llc_ui_wait_for_disc(struct sock *sk, long timeout); 43static int llc_ui_wait_for_busy_core(struct sock *sk, long 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 (unlikely(llc_data_accept_state(llc->state) || llc->p_flag)) { 120 long timeout = sock_sndtimeo(sk, noblock); 121 122 rc = llc_ui_wait_for_busy_core(sk, timeout); 123 } 124 if (unlikely(!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->dev) 193 dev_put(llc->dev); 194 sock_put(sk); 195 llc_sk_free(sk); 196out: 197 return 0; 198} 199 200/** 201 * llc_ui_autoport - provide dynamically allocate SAP number 202 * 203 * Provide the caller with a dynamically allocated SAP number according 204 * to the rules that are set in this function. Returns: 0, upon failure, 205 * SAP number otherwise. 206 */ 207static int llc_ui_autoport(void) 208{ 209 struct llc_sap *sap; 210 int i, tries = 0; 211 212 while (tries < LLC_SAP_DYN_TRIES) { 213 for (i = llc_ui_sap_last_autoport; 214 i < LLC_SAP_DYN_STOP; i += 2) { 215 sap = llc_sap_find(i); 216 if (!sap) { 217 llc_ui_sap_last_autoport = i + 2; 218 goto out; 219 } 220 llc_sap_put(sap); 221 } 222 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 223 tries++; 224 } 225 i = 0; 226out: 227 return i; 228} 229 230/** 231 * llc_ui_autobind - automatically bind a socket to a sap 232 * @sock: socket to bind 233 * @addr: address to connect to 234 * 235 * Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't 236 * specifically used llc_ui_bind to bind to an specific address/sap 237 * 238 * Returns: 0 upon success, negative otherwise. 239 */ 240static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr) 241{ 242 struct sock *sk = sock->sk; 243 struct llc_sock *llc = llc_sk(sk); 244 struct llc_sap *sap; 245 int rc = -EINVAL; 246 247 if (!sock_flag(sk, SOCK_ZAPPED)) 248 goto out; 249 rc = -ENODEV; 250 llc->dev = dev_getfirstbyhwtype(addr->sllc_arphrd); 251 if (!llc->dev) 252 goto out; 253 rc = -EUSERS; 254 llc->laddr.lsap = llc_ui_autoport(); 255 if (!llc->laddr.lsap) 256 goto out; 257 rc = -EBUSY; /* some other network layer is using the sap */ 258 sap = llc_sap_open(llc->laddr.lsap, NULL); 259 if (!sap) 260 goto out; 261 memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN); 262 memcpy(&llc->addr, addr, sizeof(llc->addr)); 263 /* assign new connection to its SAP */ 264 llc_sap_add_socket(sap, sk); 265 sock_reset_flag(sk, SOCK_ZAPPED); 266 rc = 0; 267out: 268 return rc; 269} 270 271/** 272 * llc_ui_bind - bind a socket to a specific address. 273 * @sock: Socket to bind an address to. 274 * @uaddr: Address the user wants the socket bound to. 275 * @addrlen: Length of the uaddr structure. 276 * 277 * Bind a socket to a specific address. For llc a user is able to bind to 278 * a specific sap only or mac + sap. 279 * If the user desires to bind to a specific mac + sap, it is possible to 280 * have multiple sap connections via multiple macs. 281 * Bind and autobind for that matter must enforce the correct sap usage 282 * otherwise all hell will break loose. 283 * Returns: 0 upon success, negative otherwise. 284 */ 285static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen) 286{ 287 struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr; 288 struct sock *sk = sock->sk; 289 struct llc_sock *llc = llc_sk(sk); 290 struct llc_sap *sap; 291 int rc = -EINVAL; 292 293 dprintk("%s: binding %02X\n", __FUNCTION__, addr->sllc_sap); 294 if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr))) 295 goto out; 296 rc = -EAFNOSUPPORT; 297 if (unlikely(addr->sllc_family != AF_LLC)) 298 goto out; 299 rc = -ENODEV; 300 rtnl_lock(); 301 llc->dev = dev_getbyhwaddr(addr->sllc_arphrd, addr->sllc_mac); 302 rtnl_unlock(); 303 if (!llc->dev) 304 goto out; 305 if (!addr->sllc_sap) { 306 rc = -EUSERS; 307 addr->sllc_sap = llc_ui_autoport(); 308 if (!addr->sllc_sap) 309 goto out; 310 } 311 sap = llc_sap_find(addr->sllc_sap); 312 if (!sap) { 313 sap = llc_sap_open(addr->sllc_sap, NULL); 314 rc = -EBUSY; /* some other network layer is using the sap */ 315 if (!sap) 316 goto out; 317 llc_sap_hold(sap); 318 } else { 319 struct llc_addr laddr, daddr; 320 struct sock *ask; 321 322 memset(&laddr, 0, sizeof(laddr)); 323 memset(&daddr, 0, sizeof(daddr)); 324 /* 325 * FIXME: check if the the address is multicast, 326 * only SOCK_DGRAM can do this. 327 */ 328 memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN); 329 laddr.lsap = addr->sllc_sap; 330 rc = -EADDRINUSE; /* mac + sap clash. */ 331 ask = llc_lookup_established(sap, &daddr, &laddr); 332 if (ask) { 333 sock_put(ask); 334 goto out_put; 335 } 336 } 337 llc->laddr.lsap = addr->sllc_sap; 338 memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN); 339 memcpy(&llc->addr, addr, sizeof(llc->addr)); 340 /* assign new connection to its SAP */ 341 llc_sap_add_socket(sap, sk); 342 sock_reset_flag(sk, SOCK_ZAPPED); 343 rc = 0; 344out_put: 345 llc_sap_put(sap); 346out: 347 return rc; 348} 349 350/** 351 * llc_ui_shutdown - shutdown a connect llc2 socket. 352 * @sock: Socket to shutdown. 353 * @how: What part of the socket to shutdown. 354 * 355 * Shutdown a connected llc2 socket. Currently this function only supports 356 * shutting down both sends and receives (2), we could probably make this 357 * function such that a user can shutdown only half the connection but not 358 * right now. 359 * Returns: 0 upon success, negative otherwise. 360 */ 361static int llc_ui_shutdown(struct socket *sock, int how) 362{ 363 struct sock *sk = sock->sk; 364 int rc = -ENOTCONN; 365 366 lock_sock(sk); 367 if (unlikely(sk->sk_state != TCP_ESTABLISHED)) 368 goto out; 369 rc = -EINVAL; 370 if (how != 2) 371 goto out; 372 rc = llc_send_disc(sk); 373 if (!rc) 374 rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo); 375 /* Wake up anyone sleeping in poll */ 376 sk->sk_state_change(sk); 377out: 378 release_sock(sk); 379 return rc; 380} 381 382/** 383 * llc_ui_connect - Connect to a remote llc2 mac + sap. 384 * @sock: Socket which will be connected to the remote destination. 385 * @uaddr: Remote and possibly the local address of the new connection. 386 * @addrlen: Size of uaddr structure. 387 * @flags: Operational flags specified by the user. 388 * 389 * Connect to a remote llc2 mac + sap. The caller must specify the 390 * destination mac and address to connect to. If the user hasn't previously 391 * called bind(2) with a smac the address of the first interface of the 392 * specified arp type will be used. 393 * This function will autobind if user did not previously call bind. 394 * Returns: 0 upon success, negative otherwise. 395 */ 396static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr, 397 int addrlen, int flags) 398{ 399 struct sock *sk = sock->sk; 400 struct llc_sock *llc = llc_sk(sk); 401 struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr; 402 int rc = -EINVAL; 403 404 lock_sock(sk); 405 if (unlikely(addrlen != sizeof(*addr))) 406 goto out; 407 rc = -EAFNOSUPPORT; 408 if (unlikely(addr->sllc_family != AF_LLC)) 409 goto out; 410 if (unlikely(sk->sk_type != SOCK_STREAM)) 411 goto out; 412 rc = -EALREADY; 413 if (unlikely(sock->state == SS_CONNECTING)) 414 goto out; 415 /* bind connection to sap if user hasn't done it. */ 416 if (sock_flag(sk, SOCK_ZAPPED)) { 417 /* bind to sap with null dev, exclusive */ 418 rc = llc_ui_autobind(sock, addr); 419 if (rc) 420 goto out; 421 llc->daddr.lsap = addr->sllc_sap; 422 memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN); 423 } 424 sock->state = SS_CONNECTING; 425 sk->sk_state = TCP_SYN_SENT; 426 llc->link = llc_ui_next_link_no(llc->sap->laddr.lsap); 427 rc = llc_establish_connection(sk, llc->dev->dev_addr, 428 addr->sllc_mac, addr->sllc_sap); 429 if (rc) { 430 dprintk("%s: llc_ui_send_conn failed :-(\n", __FUNCTION__); 431 sock->state = SS_UNCONNECTED; 432 sk->sk_state = TCP_CLOSE; 433 goto out; 434 } 435 436 if (sk->sk_state == TCP_SYN_SENT) { 437 const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK); 438 439 if (!timeo || !llc_ui_wait_for_conn(sk, timeo)) 440 goto out; 441 442 rc = sock_intr_errno(timeo); 443 if (signal_pending(current)) 444 goto out; 445 } 446 447 if (sk->sk_state == TCP_CLOSE) 448 goto sock_error; 449 450 sock->state = SS_CONNECTED; 451 rc = 0; 452out: 453 release_sock(sk); 454 return rc; 455sock_error: 456 rc = sock_error(sk) ? : -ECONNABORTED; 457 sock->state = SS_UNCONNECTED; 458 goto out; 459} 460 461/** 462 * llc_ui_listen - allow a normal socket to accept incoming connections 463 * @sock: Socket to allow incoming connections on. 464 * @backlog: Number of connections to queue. 465 * 466 * Allow a normal socket to accept incoming connections. 467 * Returns 0 upon success, negative otherwise. 468 */ 469static int llc_ui_listen(struct socket *sock, int backlog) 470{ 471 struct sock *sk = sock->sk; 472 int rc = -EINVAL; 473 474 lock_sock(sk); 475 if (unlikely(sock->state != SS_UNCONNECTED)) 476 goto out; 477 rc = -EOPNOTSUPP; 478 if (unlikely(sk->sk_type != SOCK_STREAM)) 479 goto out; 480 rc = -EAGAIN; 481 if (sock_flag(sk, SOCK_ZAPPED)) 482 goto out; 483 rc = 0; 484 if (!(unsigned)backlog) /* BSDism */ 485 backlog = 1; 486 sk->sk_max_ack_backlog = backlog; 487 if (sk->sk_state != TCP_LISTEN) { 488 sk->sk_ack_backlog = 0; 489 sk->sk_state = TCP_LISTEN; 490 } 491 sk->sk_socket->flags |= __SO_ACCEPTCON; 492out: 493 release_sock(sk); 494 return rc; 495} 496 497static int llc_ui_wait_for_disc(struct sock *sk, long timeout) 498{ 499 DEFINE_WAIT(wait); 500 int rc = 0; 501 502 while (1) { 503 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 504 if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE)) 505 break; 506 rc = -ERESTARTSYS; 507 if (signal_pending(current)) 508 break; 509 rc = -EAGAIN; 510 if (!timeout) 511 break; 512 rc = 0; 513 } 514 finish_wait(sk->sk_sleep, &wait); 515 return rc; 516} 517 518static int llc_ui_wait_for_conn(struct sock *sk, long timeout) 519{ 520 DEFINE_WAIT(wait); 521 522 while (1) { 523 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 524 if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT)) 525 break; 526 if (signal_pending(current) || !timeout) 527 break; 528 } 529 finish_wait(sk->sk_sleep, &wait); 530 return timeout; 531} 532 533static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout) 534{ 535 DEFINE_WAIT(wait); 536 struct llc_sock *llc = llc_sk(sk); 537 int rc; 538 539 while (1) { 540 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 541 rc = 0; 542 if (sk_wait_event(sk, &timeout, 543 (sk->sk_shutdown & RCV_SHUTDOWN) || 544 (!llc_data_accept_state(llc->state) && 545 !llc->p_flag))) 546 break; 547 rc = -ERESTARTSYS; 548 if (signal_pending(current)) 549 break; 550 rc = -EAGAIN; 551 if (!timeout) 552 break; 553 } 554 finish_wait(sk->sk_sleep, &wait); 555 return rc; 556} 557 558int llc_wait_data(struct sock *sk, long timeo) 559{ 560 int rc; 561 562 while (1) { 563 /* 564 * POSIX 1003.1g mandates this order. 565 */ 566 if (sk->sk_err) { 567 rc = sock_error(sk); 568 break; 569 } 570 rc = 0; 571 if (sk->sk_shutdown & RCV_SHUTDOWN) 572 break; 573 rc = -EAGAIN; 574 if (!timeo) 575 break; 576 rc = sock_intr_errno(timeo); 577 if (signal_pending(current)) 578 break; 579 rc = 0; 580 if (sk_wait_data(sk, &timeo)) 581 break; 582 } 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_wait_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 dprintk("%s: ok success on %02X, client on %02X\n", __FUNCTION__, 639 llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap); 640frees: 641 kfree_skb(skb); 642out: 643 release_sock(sk); 644 return rc; 645} 646 647/** 648 * llc_ui_recvmsg - copy received data to the socket user. 649 * @sock: Socket to copy data from. 650 * @msg: Various user space related information. 651 * @size: Size of user buffer. 652 * @flags: User specified flags. 653 * 654 * Copy received data to the socket user. 655 * Returns non-negative upon success, negative otherwise. 656 */ 657static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock, 658 struct msghdr *msg, size_t size, int flags) 659{ 660 struct sock *sk = sock->sk; 661 struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name; 662 struct sk_buff *skb; 663 size_t copied = 0; 664 int rc = -ENOMEM; 665 int noblock = flags & MSG_DONTWAIT; 666 667 dprintk("%s: receiving in %02X from %02X\n", __FUNCTION__, 668 llc_sk(sk)->laddr.lsap, llc_sk(sk)->daddr.lsap); 669 lock_sock(sk); 670 if (skb_queue_empty(&sk->sk_receive_queue)) { 671 rc = llc_wait_data(sk, sock_rcvtimeo(sk, noblock)); 672 if (rc) 673 goto out; 674 } 675 skb = skb_dequeue(&sk->sk_receive_queue); 676 if (!skb) /* shutdown */ 677 goto out; 678 copied = skb->len; 679 if (copied > size) 680 copied = size; 681 rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 682 if (rc) 683 goto dgram_free; 684 if (skb->len > copied) { 685 skb_pull(skb, copied); 686 skb_queue_head(&sk->sk_receive_queue, skb); 687 } 688 if (uaddr) 689 memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr)); 690 msg->msg_namelen = sizeof(*uaddr); 691 if (!skb->next) { 692dgram_free: 693 kfree_skb(skb); 694 } 695out: 696 release_sock(sk); 697 return rc ? : copied; 698} 699 700/** 701 * llc_ui_sendmsg - Transmit data provided by the socket user. 702 * @sock: Socket to transmit data from. 703 * @msg: Various user related information. 704 * @len: Length of data to transmit. 705 * 706 * Transmit data provided by the socket user. 707 * Returns non-negative upon success, negative otherwise. 708 */ 709static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock, 710 struct msghdr *msg, size_t len) 711{ 712 struct sock *sk = sock->sk; 713 struct llc_sock *llc = llc_sk(sk); 714 struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name; 715 int flags = msg->msg_flags; 716 int noblock = flags & MSG_DONTWAIT; 717 struct sk_buff *skb; 718 size_t size = 0; 719 int rc = -EINVAL, copied = 0, hdrlen; 720 721 dprintk("%s: sending from %02X to %02X\n", __FUNCTION__, 722 llc->laddr.lsap, llc->daddr.lsap); 723 lock_sock(sk); 724 if (addr) { 725 if (msg->msg_namelen < sizeof(*addr)) 726 goto release; 727 } else { 728 if (llc_ui_addr_null(&llc->addr)) 729 goto release; 730 addr = &llc->addr; 731 } 732 /* must bind connection to sap if user hasn't done it. */ 733 if (sock_flag(sk, SOCK_ZAPPED)) { 734 /* bind to sap with null dev, exclusive. */ 735 rc = llc_ui_autobind(sock, addr); 736 if (rc) 737 goto release; 738 } 739 hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr); 740 size = hdrlen + len; 741 if (size > llc->dev->mtu) 742 size = llc->dev->mtu; 743 copied = size - hdrlen; 744 release_sock(sk); 745 skb = sock_alloc_send_skb(sk, size, noblock, &rc); 746 lock_sock(sk); 747 if (!skb) 748 goto release; 749 skb->dev = llc->dev; 750 skb->protocol = llc_proto_type(addr->sllc_arphrd); 751 skb_reserve(skb, hdrlen); 752 rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied); 753 if (rc) 754 goto out; 755 if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) { 756 llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac, 757 addr->sllc_sap); 758 goto out; 759 } 760 if (addr->sllc_test) { 761 llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac, 762 addr->sllc_sap); 763 goto out; 764 } 765 if (addr->sllc_xid) { 766 llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac, 767 addr->sllc_sap); 768 goto out; 769 } 770 rc = -ENOPROTOOPT; 771 if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua)) 772 goto out; 773 rc = llc_ui_send_data(sk, skb, noblock); 774out: 775 if (rc) { 776 kfree_skb(skb); 777release: 778 dprintk("%s: failed sending from %02X to %02X: %d\n", 779 __FUNCTION__, llc->laddr.lsap, llc->daddr.lsap, rc); 780 } 781 release_sock(sk); 782 return rc ? : copied; 783} 784 785/** 786 * llc_ui_getname - return the address info of a socket 787 * @sock: Socket to get address of. 788 * @uaddr: Address structure to return information. 789 * @uaddrlen: Length of address structure. 790 * @peer: Does user want local or remote address information. 791 * 792 * Return the address information of a socket. 793 */ 794static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr, 795 int *uaddrlen, int peer) 796{ 797 struct sockaddr_llc sllc; 798 struct sock *sk = sock->sk; 799 struct llc_sock *llc = llc_sk(sk); 800 int rc = 0; 801 802 lock_sock(sk); 803 if (sock_flag(sk, SOCK_ZAPPED)) 804 goto out; 805 *uaddrlen = sizeof(sllc); 806 memset(uaddr, 0, *uaddrlen); 807 if (peer) { 808 rc = -ENOTCONN; 809 if (sk->sk_state != TCP_ESTABLISHED) 810 goto out; 811 if(llc->dev) 812 sllc.sllc_arphrd = llc->dev->type; 813 sllc.sllc_sap = llc->daddr.lsap; 814 memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN); 815 } else { 816 rc = -EINVAL; 817 if (!llc->sap) 818 goto out; 819 sllc.sllc_sap = llc->sap->laddr.lsap; 820 821 if (llc->dev) { 822 sllc.sllc_arphrd = llc->dev->type; 823 memcpy(&sllc.sllc_mac, &llc->dev->dev_addr, 824 IFHWADDRLEN); 825 } 826 } 827 rc = 0; 828 sllc.sllc_family = AF_LLC; 829 memcpy(uaddr, &sllc, sizeof(sllc)); 830out: 831 release_sock(sk); 832 return rc; 833} 834 835/** 836 * llc_ui_ioctl - io controls for PF_LLC 837 * @sock: Socket to get/set info 838 * @cmd: command 839 * @arg: optional argument for cmd 840 * 841 * get/set info on llc sockets 842 */ 843static int llc_ui_ioctl(struct socket *sock, unsigned int cmd, 844 unsigned long arg) 845{ 846 return dev_ioctl(cmd, (void __user *)arg); 847} 848 849/** 850 * llc_ui_setsockopt - set various connection specific parameters. 851 * @sock: Socket to set options on. 852 * @level: Socket level user is requesting operations on. 853 * @optname: Operation name. 854 * @optval User provided operation data. 855 * @optlen: Length of optval. 856 * 857 * Set various connection specific parameters. 858 */ 859static int llc_ui_setsockopt(struct socket *sock, int level, int optname, 860 char __user *optval, int optlen) 861{ 862 struct sock *sk = sock->sk; 863 struct llc_sock *llc = llc_sk(sk); 864 int rc = -EINVAL, opt; 865 866 lock_sock(sk); 867 if (unlikely(level != SOL_LLC || optlen != sizeof(int))) 868 goto out; 869 rc = get_user(opt, (int __user *)optval); 870 if (rc) 871 goto out; 872 rc = -EINVAL; 873 switch (optname) { 874 case LLC_OPT_RETRY: 875 if (opt > LLC_OPT_MAX_RETRY) 876 goto out; 877 llc->n2 = opt; 878 break; 879 case LLC_OPT_SIZE: 880 if (opt > LLC_OPT_MAX_SIZE) 881 goto out; 882 llc->n1 = opt; 883 break; 884 case LLC_OPT_ACK_TMR_EXP: 885 if (opt > LLC_OPT_MAX_ACK_TMR_EXP) 886 goto out; 887 llc->ack_timer.expire = opt * HZ; 888 break; 889 case LLC_OPT_P_TMR_EXP: 890 if (opt > LLC_OPT_MAX_P_TMR_EXP) 891 goto out; 892 llc->pf_cycle_timer.expire = opt * HZ; 893 break; 894 case LLC_OPT_REJ_TMR_EXP: 895 if (opt > LLC_OPT_MAX_REJ_TMR_EXP) 896 goto out; 897 llc->rej_sent_timer.expire = opt * HZ; 898 break; 899 case LLC_OPT_BUSY_TMR_EXP: 900 if (opt > LLC_OPT_MAX_BUSY_TMR_EXP) 901 goto out; 902 llc->busy_state_timer.expire = opt * HZ; 903 break; 904 case LLC_OPT_TX_WIN: 905 if (opt > LLC_OPT_MAX_WIN) 906 goto out; 907 llc->k = opt; 908 break; 909 case LLC_OPT_RX_WIN: 910 if (opt > LLC_OPT_MAX_WIN) 911 goto out; 912 llc->rw = opt; 913 break; 914 default: 915 rc = -ENOPROTOOPT; 916 goto out; 917 } 918 rc = 0; 919out: 920 release_sock(sk); 921 return rc; 922} 923 924/** 925 * llc_ui_getsockopt - get connection specific socket info 926 * @sock: Socket to get information from. 927 * @level: Socket level user is requesting operations on. 928 * @optname: Operation name. 929 * @optval: Variable to return operation data in. 930 * @optlen: Length of optval. 931 * 932 * Get connection specific socket information. 933 */ 934static int llc_ui_getsockopt(struct socket *sock, int level, int optname, 935 char __user *optval, int __user *optlen) 936{ 937 struct sock *sk = sock->sk; 938 struct llc_sock *llc = llc_sk(sk); 939 int val = 0, len = 0, rc = -EINVAL; 940 941 lock_sock(sk); 942 if (unlikely(level != SOL_LLC)) 943 goto out; 944 rc = get_user(len, optlen); 945 if (rc) 946 goto out; 947 rc = -EINVAL; 948 if (len != sizeof(int)) 949 goto out; 950 switch (optname) { 951 case LLC_OPT_RETRY: 952 val = llc->n2; break; 953 case LLC_OPT_SIZE: 954 val = llc->n1; break; 955 case LLC_OPT_ACK_TMR_EXP: 956 val = llc->ack_timer.expire / HZ; break; 957 case LLC_OPT_P_TMR_EXP: 958 val = llc->pf_cycle_timer.expire / HZ; break; 959 case LLC_OPT_REJ_TMR_EXP: 960 val = llc->rej_sent_timer.expire / HZ; break; 961 case LLC_OPT_BUSY_TMR_EXP: 962 val = llc->busy_state_timer.expire / HZ; break; 963 case LLC_OPT_TX_WIN: 964 val = llc->k; break; 965 case LLC_OPT_RX_WIN: 966 val = llc->rw; break; 967 default: 968 rc = -ENOPROTOOPT; 969 goto out; 970 } 971 rc = 0; 972 if (put_user(len, optlen) || copy_to_user(optval, &val, len)) 973 rc = -EFAULT; 974out: 975 release_sock(sk); 976 return rc; 977} 978 979static struct net_proto_family llc_ui_family_ops = { 980 .family = PF_LLC, 981 .create = llc_ui_create, 982 .owner = THIS_MODULE, 983}; 984 985static struct proto_ops llc_ui_ops = { 986 .family = PF_LLC, 987 .owner = THIS_MODULE, 988 .release = llc_ui_release, 989 .bind = llc_ui_bind, 990 .connect = llc_ui_connect, 991 .socketpair = sock_no_socketpair, 992 .accept = llc_ui_accept, 993 .getname = llc_ui_getname, 994 .poll = datagram_poll, 995 .ioctl = llc_ui_ioctl, 996 .listen = llc_ui_listen, 997 .shutdown = llc_ui_shutdown, 998 .setsockopt = llc_ui_setsockopt, 999 .getsockopt = llc_ui_getsockopt, 1000 .sendmsg = llc_ui_sendmsg, 1001 .recvmsg = llc_ui_recvmsg, 1002 .mmap = sock_no_mmap, 1003 .sendpage = sock_no_sendpage, 1004}; 1005 1006extern void llc_sap_handler(struct llc_sap *sap, struct sk_buff *skb); 1007extern void llc_conn_handler(struct llc_sap *sap, struct sk_buff *skb); 1008 1009static char llc_proc_err_msg[] __initdata = 1010 KERN_CRIT "LLC: Unable to register the proc_fs entries\n"; 1011static char llc_sysctl_err_msg[] __initdata = 1012 KERN_CRIT "LLC: Unable to register the sysctl entries\n"; 1013static char llc_sock_err_msg[] __initdata = 1014 KERN_CRIT "LLC: Unable to register the network family\n"; 1015 1016static int __init llc2_init(void) 1017{ 1018 int rc = proto_register(&llc_proto, 0); 1019 1020 if (rc != 0) 1021 goto out; 1022 1023 llc_build_offset_table(); 1024 llc_station_init(); 1025 llc_ui_sap_last_autoport = LLC_SAP_DYN_START; 1026 rc = llc_proc_init(); 1027 if (rc != 0) { 1028 printk(llc_proc_err_msg); 1029 goto out_unregister_llc_proto; 1030 } 1031 rc = llc_sysctl_init(); 1032 if (rc) { 1033 printk(llc_sysctl_err_msg); 1034 goto out_proc; 1035 } 1036 rc = sock_register(&llc_ui_family_ops); 1037 if (rc) { 1038 printk(llc_sock_err_msg); 1039 goto out_sysctl; 1040 } 1041 llc_add_pack(LLC_DEST_SAP, llc_sap_handler); 1042 llc_add_pack(LLC_DEST_CONN, llc_conn_handler); 1043out: 1044 return rc; 1045out_sysctl: 1046 llc_sysctl_exit(); 1047out_proc: 1048 llc_proc_exit(); 1049out_unregister_llc_proto: 1050 proto_unregister(&llc_proto); 1051 goto out; 1052} 1053 1054static void __exit llc2_exit(void) 1055{ 1056 llc_station_exit(); 1057 llc_remove_pack(LLC_DEST_SAP); 1058 llc_remove_pack(LLC_DEST_CONN); 1059 sock_unregister(PF_LLC); 1060 llc_proc_exit(); 1061 llc_sysctl_exit(); 1062 proto_unregister(&llc_proto); 1063} 1064 1065module_init(llc2_init); 1066module_exit(llc2_exit); 1067 1068MODULE_LICENSE("GPL"); 1069MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003"); 1070MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support"); 1071MODULE_ALIAS_NETPROTO(PF_LLC); 1072