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