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