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