2 * af_llc.c - LLC User Interface SAPs
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
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
13 * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org>
14 * 2002-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
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.
21 * See the GNU General Public License for more details.
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>
30 #include <net/llc_sap.h>
31 #include <net/llc_pdu.h>
32 #include <net/llc_conn.h>
33 #include <net/tcp_states.h>
35 /* remember: uninitialized global data is zeroed because its in .bss */
36 static u16 llc_ui_sap_last_autoport
= LLC_SAP_DYN_START
;
37 static u16 llc_ui_sap_link_no_max
[256];
38 static struct sockaddr_llc llc_ui_addrnull
;
39 static const struct proto_ops llc_ui_ops
;
41 static int llc_ui_wait_for_conn(struct sock
*sk
, long timeout
);
42 static int llc_ui_wait_for_disc(struct sock
*sk
, long timeout
);
43 static int llc_ui_wait_for_busy_core(struct sock
*sk
, long timeout
);
45 #define dprintk(args...)
47 /* Maybe we'll add some more in the future. */
48 #define LLC_CMSG_PKTINFO 1
52 * llc_ui_next_link_no - return the next unused link number for a sap
53 * @sap: Address of sap to get link number from.
55 * Return the next unused link number for a given sap.
57 static inline u16
llc_ui_next_link_no(int sap
)
59 return llc_ui_sap_link_no_max
[sap
]++;
63 * llc_proto_type - return eth protocol for ARP header type
64 * @arphrd: ARP header type.
66 * Given an ARP header type return the corresponding ethernet protocol.
68 static inline __be16
llc_proto_type(u16 arphrd
)
70 return arphrd
== ARPHRD_IEEE802_TR
?
71 htons(ETH_P_TR_802_2
) : htons(ETH_P_802_2
);
75 * llc_ui_addr_null - determines if a address structure is null
76 * @addr: Address to test if null.
78 static inline u8
llc_ui_addr_null(struct sockaddr_llc
*addr
)
80 return !memcmp(addr
, &llc_ui_addrnull
, sizeof(*addr
));
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.
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.
92 static inline u8
llc_ui_header_len(struct sock
*sk
, struct sockaddr_llc
*addr
)
94 u8 rc
= LLC_PDU_LEN_U
;
96 if (addr
->sllc_test
|| addr
->sllc_xid
)
98 else if (sk
->sk_type
== SOCK_STREAM
)
104 * llc_ui_send_data - send data via reliable llc2 connection
105 * @sk: Connection the socket is using.
106 * @skb: Data the user wishes to send.
107 * @noblock: can we block waiting for data?
109 * Send data via reliable llc2 connection.
110 * Returns 0 upon success, non-zero if action did not succeed.
112 static int llc_ui_send_data(struct sock
* sk
, struct sk_buff
*skb
, int noblock
)
114 struct llc_sock
* llc
= llc_sk(sk
);
117 if (unlikely(llc_data_accept_state(llc
->state
) ||
118 llc
->remote_busy_flag
||
120 long timeout
= sock_sndtimeo(sk
, noblock
);
122 rc
= llc_ui_wait_for_busy_core(sk
, timeout
);
125 rc
= llc_build_and_send_pkt(sk
, skb
);
129 static void llc_ui_sk_init(struct socket
*sock
, struct sock
*sk
)
131 sock_graft(sk
, sock
);
132 sk
->sk_type
= sock
->type
;
133 sock
->ops
= &llc_ui_ops
;
136 static struct proto llc_proto
= {
138 .owner
= THIS_MODULE
,
139 .obj_size
= sizeof(struct llc_sock
),
140 .slab_flags
= SLAB_DESTROY_BY_RCU
,
144 * llc_ui_create - alloc and init a new llc_ui socket
145 * @net: network namespace (must be default network)
146 * @sock: Socket to initialize and attach allocated sk to.
148 * @kern: on behalf of kernel or userspace
150 * Allocate and initialize a new llc_ui socket, validate the user wants a
151 * socket type we have available.
152 * Returns 0 upon success, negative upon failure.
154 static int llc_ui_create(struct net
*net
, struct socket
*sock
, int protocol
,
158 int rc
= -ESOCKTNOSUPPORT
;
160 if (!capable(CAP_NET_RAW
))
163 if (!net_eq(net
, &init_net
))
164 return -EAFNOSUPPORT
;
166 if (likely(sock
->type
== SOCK_DGRAM
|| sock
->type
== SOCK_STREAM
)) {
168 sk
= llc_sk_alloc(net
, PF_LLC
, GFP_KERNEL
, &llc_proto
);
171 llc_ui_sk_init(sock
, sk
);
178 * llc_ui_release - shutdown socket
179 * @sock: Socket to release.
181 * Shutdown and deallocate an existing socket.
183 static int llc_ui_release(struct socket
*sock
)
185 struct sock
*sk
= sock
->sk
;
186 struct llc_sock
*llc
;
188 if (unlikely(sk
== NULL
))
193 dprintk("%s: closing local(%02X) remote(%02X)\n", __func__
,
194 llc
->laddr
.lsap
, llc
->daddr
.lsap
);
195 if (!llc_send_disc(sk
))
196 llc_ui_wait_for_disc(sk
, sk
->sk_rcvtimeo
);
197 if (!sock_flag(sk
, SOCK_ZAPPED
))
198 llc_sap_remove_socket(llc
->sap
, sk
);
209 * llc_ui_autoport - provide dynamically allocate SAP number
211 * Provide the caller with a dynamically allocated SAP number according
212 * to the rules that are set in this function. Returns: 0, upon failure,
213 * SAP number otherwise.
215 static int llc_ui_autoport(void)
220 while (tries
< LLC_SAP_DYN_TRIES
) {
221 for (i
= llc_ui_sap_last_autoport
;
222 i
< LLC_SAP_DYN_STOP
; i
+= 2) {
223 sap
= llc_sap_find(i
);
225 llc_ui_sap_last_autoport
= i
+ 2;
230 llc_ui_sap_last_autoport
= LLC_SAP_DYN_START
;
239 * llc_ui_autobind - automatically bind a socket to a sap
240 * @sock: socket to bind
241 * @addr: address to connect to
243 * Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't
244 * specifically used llc_ui_bind to bind to an specific address/sap
246 * Returns: 0 upon success, negative otherwise.
248 static int llc_ui_autobind(struct socket
*sock
, struct sockaddr_llc
*addr
)
250 struct sock
*sk
= sock
->sk
;
251 struct llc_sock
*llc
= llc_sk(sk
);
255 if (!sock_flag(sk
, SOCK_ZAPPED
))
258 if (sk
->sk_bound_dev_if
) {
259 llc
->dev
= dev_get_by_index(&init_net
, sk
->sk_bound_dev_if
);
260 if (llc
->dev
&& addr
->sllc_arphrd
!= llc
->dev
->type
) {
265 llc
->dev
= dev_getfirstbyhwtype(&init_net
, addr
->sllc_arphrd
);
269 llc
->laddr
.lsap
= llc_ui_autoport();
270 if (!llc
->laddr
.lsap
)
272 rc
= -EBUSY
; /* some other network layer is using the sap */
273 sap
= llc_sap_open(llc
->laddr
.lsap
, NULL
);
276 memcpy(llc
->laddr
.mac
, llc
->dev
->dev_addr
, IFHWADDRLEN
);
277 memcpy(&llc
->addr
, addr
, sizeof(llc
->addr
));
278 /* assign new connection to its SAP */
279 llc_sap_add_socket(sap
, sk
);
280 sock_reset_flag(sk
, SOCK_ZAPPED
);
287 * llc_ui_bind - bind a socket to a specific address.
288 * @sock: Socket to bind an address to.
289 * @uaddr: Address the user wants the socket bound to.
290 * @addrlen: Length of the uaddr structure.
292 * Bind a socket to a specific address. For llc a user is able to bind to
293 * a specific sap only or mac + sap.
294 * If the user desires to bind to a specific mac + sap, it is possible to
295 * have multiple sap connections via multiple macs.
296 * Bind and autobind for that matter must enforce the correct sap usage
297 * otherwise all hell will break loose.
298 * Returns: 0 upon success, negative otherwise.
300 static int llc_ui_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addrlen
)
302 struct sockaddr_llc
*addr
= (struct sockaddr_llc
*)uaddr
;
303 struct sock
*sk
= sock
->sk
;
304 struct llc_sock
*llc
= llc_sk(sk
);
308 dprintk("%s: binding %02X\n", __func__
, addr
->sllc_sap
);
309 if (unlikely(!sock_flag(sk
, SOCK_ZAPPED
) || addrlen
!= sizeof(*addr
)))
312 if (unlikely(addr
->sllc_family
!= AF_LLC
))
317 if (sk
->sk_bound_dev_if
) {
318 llc
->dev
= dev_get_by_index_rcu(&init_net
, sk
->sk_bound_dev_if
);
320 if (!addr
->sllc_arphrd
)
321 addr
->sllc_arphrd
= llc
->dev
->type
;
322 if (llc_mac_null(addr
->sllc_mac
))
323 memcpy(addr
->sllc_mac
, llc
->dev
->dev_addr
,
325 if (addr
->sllc_arphrd
!= llc
->dev
->type
||
326 !llc_mac_match(addr
->sllc_mac
,
327 llc
->dev
->dev_addr
)) {
333 llc
->dev
= dev_getbyhwaddr(&init_net
, addr
->sllc_arphrd
,
339 if (!addr
->sllc_sap
) {
341 addr
->sllc_sap
= llc_ui_autoport();
345 sap
= llc_sap_find(addr
->sllc_sap
);
347 sap
= llc_sap_open(addr
->sllc_sap
, NULL
);
348 rc
= -EBUSY
; /* some other network layer is using the sap */
352 struct llc_addr laddr
, daddr
;
355 memset(&laddr
, 0, sizeof(laddr
));
356 memset(&daddr
, 0, sizeof(daddr
));
357 memcpy(laddr
.mac
, addr
->sllc_mac
, IFHWADDRLEN
);
358 laddr
.lsap
= addr
->sllc_sap
;
359 rc
= -EADDRINUSE
; /* mac + sap clash. */
360 ask
= llc_lookup_established(sap
, &daddr
, &laddr
);
366 llc
->laddr
.lsap
= addr
->sllc_sap
;
367 memcpy(llc
->laddr
.mac
, addr
->sllc_mac
, IFHWADDRLEN
);
368 memcpy(&llc
->addr
, addr
, sizeof(llc
->addr
));
369 /* assign new connection to its SAP */
370 llc_sap_add_socket(sap
, sk
);
371 sock_reset_flag(sk
, SOCK_ZAPPED
);
380 * llc_ui_shutdown - shutdown a connect llc2 socket.
381 * @sock: Socket to shutdown.
382 * @how: What part of the socket to shutdown.
384 * Shutdown a connected llc2 socket. Currently this function only supports
385 * shutting down both sends and receives (2), we could probably make this
386 * function such that a user can shutdown only half the connection but not
388 * Returns: 0 upon success, negative otherwise.
390 static int llc_ui_shutdown(struct socket
*sock
, int how
)
392 struct sock
*sk
= sock
->sk
;
396 if (unlikely(sk
->sk_state
!= TCP_ESTABLISHED
))
401 rc
= llc_send_disc(sk
);
403 rc
= llc_ui_wait_for_disc(sk
, sk
->sk_rcvtimeo
);
404 /* Wake up anyone sleeping in poll */
405 sk
->sk_state_change(sk
);
412 * llc_ui_connect - Connect to a remote llc2 mac + sap.
413 * @sock: Socket which will be connected to the remote destination.
414 * @uaddr: Remote and possibly the local address of the new connection.
415 * @addrlen: Size of uaddr structure.
416 * @flags: Operational flags specified by the user.
418 * Connect to a remote llc2 mac + sap. The caller must specify the
419 * destination mac and address to connect to. If the user hasn't previously
420 * called bind(2) with a smac the address of the first interface of the
421 * specified arp type will be used.
422 * This function will autobind if user did not previously call bind.
423 * Returns: 0 upon success, negative otherwise.
425 static int llc_ui_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
426 int addrlen
, int flags
)
428 struct sock
*sk
= sock
->sk
;
429 struct llc_sock
*llc
= llc_sk(sk
);
430 struct sockaddr_llc
*addr
= (struct sockaddr_llc
*)uaddr
;
434 if (unlikely(addrlen
!= sizeof(*addr
)))
437 if (unlikely(addr
->sllc_family
!= AF_LLC
))
439 if (unlikely(sk
->sk_type
!= SOCK_STREAM
))
442 if (unlikely(sock
->state
== SS_CONNECTING
))
444 /* bind connection to sap if user hasn't done it. */
445 if (sock_flag(sk
, SOCK_ZAPPED
)) {
446 /* bind to sap with null dev, exclusive */
447 rc
= llc_ui_autobind(sock
, addr
);
451 llc
->daddr
.lsap
= addr
->sllc_sap
;
452 memcpy(llc
->daddr
.mac
, addr
->sllc_mac
, IFHWADDRLEN
);
453 sock
->state
= SS_CONNECTING
;
454 sk
->sk_state
= TCP_SYN_SENT
;
455 llc
->link
= llc_ui_next_link_no(llc
->sap
->laddr
.lsap
);
456 rc
= llc_establish_connection(sk
, llc
->dev
->dev_addr
,
457 addr
->sllc_mac
, addr
->sllc_sap
);
459 dprintk("%s: llc_ui_send_conn failed :-(\n", __func__
);
460 sock
->state
= SS_UNCONNECTED
;
461 sk
->sk_state
= TCP_CLOSE
;
465 if (sk
->sk_state
== TCP_SYN_SENT
) {
466 const long timeo
= sock_sndtimeo(sk
, flags
& O_NONBLOCK
);
468 if (!timeo
|| !llc_ui_wait_for_conn(sk
, timeo
))
471 rc
= sock_intr_errno(timeo
);
472 if (signal_pending(current
))
476 if (sk
->sk_state
== TCP_CLOSE
)
479 sock
->state
= SS_CONNECTED
;
485 rc
= sock_error(sk
) ? : -ECONNABORTED
;
486 sock
->state
= SS_UNCONNECTED
;
491 * llc_ui_listen - allow a normal socket to accept incoming connections
492 * @sock: Socket to allow incoming connections on.
493 * @backlog: Number of connections to queue.
495 * Allow a normal socket to accept incoming connections.
496 * Returns 0 upon success, negative otherwise.
498 static int llc_ui_listen(struct socket
*sock
, int backlog
)
500 struct sock
*sk
= sock
->sk
;
504 if (unlikely(sock
->state
!= SS_UNCONNECTED
))
507 if (unlikely(sk
->sk_type
!= SOCK_STREAM
))
510 if (sock_flag(sk
, SOCK_ZAPPED
))
513 if (!(unsigned)backlog
) /* BSDism */
515 sk
->sk_max_ack_backlog
= backlog
;
516 if (sk
->sk_state
!= TCP_LISTEN
) {
517 sk
->sk_ack_backlog
= 0;
518 sk
->sk_state
= TCP_LISTEN
;
520 sk
->sk_socket
->flags
|= __SO_ACCEPTCON
;
526 static int llc_ui_wait_for_disc(struct sock
*sk
, long timeout
)
532 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
533 if (sk_wait_event(sk
, &timeout
, sk
->sk_state
== TCP_CLOSE
))
536 if (signal_pending(current
))
543 finish_wait(sk_sleep(sk
), &wait
);
547 static int llc_ui_wait_for_conn(struct sock
*sk
, long timeout
)
552 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
553 if (sk_wait_event(sk
, &timeout
, sk
->sk_state
!= TCP_SYN_SENT
))
555 if (signal_pending(current
) || !timeout
)
558 finish_wait(sk_sleep(sk
), &wait
);
562 static int llc_ui_wait_for_busy_core(struct sock
*sk
, long timeout
)
565 struct llc_sock
*llc
= llc_sk(sk
);
569 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
571 if (sk_wait_event(sk
, &timeout
,
572 (sk
->sk_shutdown
& RCV_SHUTDOWN
) ||
573 (!llc_data_accept_state(llc
->state
) &&
574 !llc
->remote_busy_flag
&&
578 if (signal_pending(current
))
584 finish_wait(sk_sleep(sk
), &wait
);
588 static int llc_wait_data(struct sock
*sk
, long timeo
)
594 * POSIX 1003.1g mandates this order.
600 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
605 rc
= sock_intr_errno(timeo
);
606 if (signal_pending(current
))
609 if (sk_wait_data(sk
, &timeo
))
615 static void llc_cmsg_rcv(struct msghdr
*msg
, struct sk_buff
*skb
)
617 struct llc_sock
*llc
= llc_sk(skb
->sk
);
619 if (llc
->cmsg_flags
& LLC_CMSG_PKTINFO
) {
620 struct llc_pktinfo info
;
622 info
.lpi_ifindex
= llc_sk(skb
->sk
)->dev
->ifindex
;
623 llc_pdu_decode_dsap(skb
, &info
.lpi_sap
);
624 llc_pdu_decode_da(skb
, info
.lpi_mac
);
625 put_cmsg(msg
, SOL_LLC
, LLC_OPT_PKTINFO
, sizeof(info
), &info
);
630 * llc_ui_accept - accept a new incoming connection.
631 * @sock: Socket which connections arrive on.
632 * @newsock: Socket to move incoming connection to.
633 * @flags: User specified operational flags.
635 * Accept a new incoming connection.
636 * Returns 0 upon success, negative otherwise.
638 static int llc_ui_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
640 struct sock
*sk
= sock
->sk
, *newsk
;
641 struct llc_sock
*llc
, *newllc
;
643 int rc
= -EOPNOTSUPP
;
645 dprintk("%s: accepting on %02X\n", __func__
,
646 llc_sk(sk
)->laddr
.lsap
);
648 if (unlikely(sk
->sk_type
!= SOCK_STREAM
))
651 if (unlikely(sock
->state
!= SS_UNCONNECTED
||
652 sk
->sk_state
!= TCP_LISTEN
))
654 /* wait for a connection to arrive. */
655 if (skb_queue_empty(&sk
->sk_receive_queue
)) {
656 rc
= llc_wait_data(sk
, sk
->sk_rcvtimeo
);
660 dprintk("%s: got a new connection on %02X\n", __func__
,
661 llc_sk(sk
)->laddr
.lsap
);
662 skb
= skb_dequeue(&sk
->sk_receive_queue
);
668 /* attach connection to a new socket. */
669 llc_ui_sk_init(newsock
, newsk
);
670 sock_reset_flag(newsk
, SOCK_ZAPPED
);
671 newsk
->sk_state
= TCP_ESTABLISHED
;
672 newsock
->state
= SS_CONNECTED
;
674 newllc
= llc_sk(newsk
);
675 memcpy(&newllc
->addr
, &llc
->addr
, sizeof(newllc
->addr
));
676 newllc
->link
= llc_ui_next_link_no(newllc
->laddr
.lsap
);
678 /* put original socket back into a clean listen state. */
679 sk
->sk_state
= TCP_LISTEN
;
680 sk
->sk_ack_backlog
--;
681 dprintk("%s: ok success on %02X, client on %02X\n", __func__
,
682 llc_sk(sk
)->addr
.sllc_sap
, newllc
->daddr
.lsap
);
691 * llc_ui_recvmsg - copy received data to the socket user.
692 * @sock: Socket to copy data from.
693 * @msg: Various user space related information.
694 * @len: Size of user buffer.
695 * @flags: User specified flags.
697 * Copy received data to the socket user.
698 * Returns non-negative upon success, negative otherwise.
700 static int llc_ui_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
701 struct msghdr
*msg
, size_t len
, int flags
)
703 struct sockaddr_llc
*uaddr
= (struct sockaddr_llc
*)msg
->msg_name
;
704 const int nonblock
= flags
& MSG_DONTWAIT
;
705 struct sk_buff
*skb
= NULL
;
706 struct sock
*sk
= sock
->sk
;
707 struct llc_sock
*llc
= llc_sk(sk
);
712 int target
; /* Read at least this many bytes */
717 if (unlikely(sk
->sk_type
== SOCK_STREAM
&& sk
->sk_state
== TCP_LISTEN
))
720 timeo
= sock_rcvtimeo(sk
, nonblock
);
722 seq
= &llc
->copied_seq
;
723 if (flags
& MSG_PEEK
) {
724 peek_seq
= llc
->copied_seq
;
728 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, len
);
734 if (signal_pending(current
)) {
737 copied
= timeo
? sock_intr_errno(timeo
) : -EAGAIN
;
741 /* Next get a buffer. */
743 skb
= skb_peek(&sk
->sk_receive_queue
);
748 /* Well, if we have backlog, try to process it now yet. */
750 if (copied
>= target
&& !sk
->sk_backlog
.tail
)
755 sk
->sk_state
== TCP_CLOSE
||
756 (sk
->sk_shutdown
& RCV_SHUTDOWN
) ||
761 if (sock_flag(sk
, SOCK_DONE
))
765 copied
= sock_error(sk
);
768 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
771 if (sk
->sk_type
== SOCK_STREAM
&& sk
->sk_state
== TCP_CLOSE
) {
772 if (!sock_flag(sk
, SOCK_DONE
)) {
774 * This occurs when user tries to read
775 * from never connected socket.
788 if (copied
>= target
) { /* Do not sleep, just process backlog. */
792 sk_wait_data(sk
, &timeo
);
794 if ((flags
& MSG_PEEK
) && peek_seq
!= llc
->copied_seq
) {
796 printk(KERN_DEBUG
"LLC(%s:%d): Application "
797 "bug, race in MSG_PEEK.\n",
798 current
->comm
, task_pid_nr(current
));
799 peek_seq
= llc
->copied_seq
;
803 /* Ok so how much can we use? */
804 used
= skb
->len
- offset
;
808 if (!(flags
& MSG_TRUNC
)) {
809 int rc
= skb_copy_datagram_iovec(skb
, offset
,
812 /* Exception. Bailout! */
823 if (!(flags
& MSG_PEEK
)) {
824 sk_eat_skb(sk
, skb
, 0);
828 /* For non stream protcols we get one packet per recvmsg call */
829 if (sk
->sk_type
!= SOCK_STREAM
)
833 if (used
+ offset
< skb
->len
)
841 if (uaddr
!= NULL
&& skb
!= NULL
) {
842 memcpy(uaddr
, llc_ui_skb_cb(skb
), sizeof(*uaddr
));
843 msg
->msg_namelen
= sizeof(*uaddr
);
845 if (llc_sk(sk
)->cmsg_flags
)
846 llc_cmsg_rcv(msg
, skb
);
851 * llc_ui_sendmsg - Transmit data provided by the socket user.
852 * @sock: Socket to transmit data from.
853 * @msg: Various user related information.
854 * @len: Length of data to transmit.
856 * Transmit data provided by the socket user.
857 * Returns non-negative upon success, negative otherwise.
859 static int llc_ui_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
860 struct msghdr
*msg
, size_t len
)
862 struct sock
*sk
= sock
->sk
;
863 struct llc_sock
*llc
= llc_sk(sk
);
864 struct sockaddr_llc
*addr
= (struct sockaddr_llc
*)msg
->msg_name
;
865 int flags
= msg
->msg_flags
;
866 int noblock
= flags
& MSG_DONTWAIT
;
869 int rc
= -EINVAL
, copied
= 0, hdrlen
;
871 dprintk("%s: sending from %02X to %02X\n", __func__
,
872 llc
->laddr
.lsap
, llc
->daddr
.lsap
);
875 if (msg
->msg_namelen
< sizeof(*addr
))
878 if (llc_ui_addr_null(&llc
->addr
))
882 /* must bind connection to sap if user hasn't done it. */
883 if (sock_flag(sk
, SOCK_ZAPPED
)) {
884 /* bind to sap with null dev, exclusive. */
885 rc
= llc_ui_autobind(sock
, addr
);
889 hdrlen
= llc
->dev
->hard_header_len
+ llc_ui_header_len(sk
, addr
);
891 if (size
> llc
->dev
->mtu
)
892 size
= llc
->dev
->mtu
;
893 copied
= size
- hdrlen
;
895 skb
= sock_alloc_send_skb(sk
, size
, noblock
, &rc
);
900 skb
->protocol
= llc_proto_type(addr
->sllc_arphrd
);
901 skb_reserve(skb
, hdrlen
);
902 rc
= memcpy_fromiovec(skb_put(skb
, copied
), msg
->msg_iov
, copied
);
905 if (sk
->sk_type
== SOCK_DGRAM
|| addr
->sllc_ua
) {
906 llc_build_and_send_ui_pkt(llc
->sap
, skb
, addr
->sllc_mac
,
910 if (addr
->sllc_test
) {
911 llc_build_and_send_test_pkt(llc
->sap
, skb
, addr
->sllc_mac
,
915 if (addr
->sllc_xid
) {
916 llc_build_and_send_xid_pkt(llc
->sap
, skb
, addr
->sllc_mac
,
921 if (!(sk
->sk_type
== SOCK_STREAM
&& !addr
->sllc_ua
))
923 rc
= llc_ui_send_data(sk
, skb
, noblock
);
928 dprintk("%s: failed sending from %02X to %02X: %d\n",
929 __func__
, llc
->laddr
.lsap
, llc
->daddr
.lsap
, rc
);
932 return rc
? : copied
;
936 * llc_ui_getname - return the address info of a socket
937 * @sock: Socket to get address of.
938 * @uaddr: Address structure to return information.
939 * @uaddrlen: Length of address structure.
940 * @peer: Does user want local or remote address information.
942 * Return the address information of a socket.
944 static int llc_ui_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
945 int *uaddrlen
, int peer
)
947 struct sockaddr_llc sllc
;
948 struct sock
*sk
= sock
->sk
;
949 struct llc_sock
*llc
= llc_sk(sk
);
952 memset(&sllc
, 0, sizeof(sllc
));
954 if (sock_flag(sk
, SOCK_ZAPPED
))
956 *uaddrlen
= sizeof(sllc
);
957 memset(uaddr
, 0, *uaddrlen
);
960 if (sk
->sk_state
!= TCP_ESTABLISHED
)
963 sllc
.sllc_arphrd
= llc
->dev
->type
;
964 sllc
.sllc_sap
= llc
->daddr
.lsap
;
965 memcpy(&sllc
.sllc_mac
, &llc
->daddr
.mac
, IFHWADDRLEN
);
970 sllc
.sllc_sap
= llc
->sap
->laddr
.lsap
;
973 sllc
.sllc_arphrd
= llc
->dev
->type
;
974 memcpy(&sllc
.sllc_mac
, llc
->dev
->dev_addr
,
979 sllc
.sllc_family
= AF_LLC
;
980 memcpy(uaddr
, &sllc
, sizeof(sllc
));
987 * llc_ui_ioctl - io controls for PF_LLC
988 * @sock: Socket to get/set info
990 * @arg: optional argument for cmd
992 * get/set info on llc sockets
994 static int llc_ui_ioctl(struct socket
*sock
, unsigned int cmd
,
1001 * llc_ui_setsockopt - set various connection specific parameters.
1002 * @sock: Socket to set options on.
1003 * @level: Socket level user is requesting operations on.
1004 * @optname: Operation name.
1005 * @optval User provided operation data.
1006 * @optlen: Length of optval.
1008 * Set various connection specific parameters.
1010 static int llc_ui_setsockopt(struct socket
*sock
, int level
, int optname
,
1011 char __user
*optval
, unsigned int optlen
)
1013 struct sock
*sk
= sock
->sk
;
1014 struct llc_sock
*llc
= llc_sk(sk
);
1019 if (unlikely(level
!= SOL_LLC
|| optlen
!= sizeof(int)))
1021 rc
= get_user(opt
, (int __user
*)optval
);
1027 if (opt
> LLC_OPT_MAX_RETRY
)
1032 if (opt
> LLC_OPT_MAX_SIZE
)
1036 case LLC_OPT_ACK_TMR_EXP
:
1037 if (opt
> LLC_OPT_MAX_ACK_TMR_EXP
)
1039 llc
->ack_timer
.expire
= opt
* HZ
;
1041 case LLC_OPT_P_TMR_EXP
:
1042 if (opt
> LLC_OPT_MAX_P_TMR_EXP
)
1044 llc
->pf_cycle_timer
.expire
= opt
* HZ
;
1046 case LLC_OPT_REJ_TMR_EXP
:
1047 if (opt
> LLC_OPT_MAX_REJ_TMR_EXP
)
1049 llc
->rej_sent_timer
.expire
= opt
* HZ
;
1051 case LLC_OPT_BUSY_TMR_EXP
:
1052 if (opt
> LLC_OPT_MAX_BUSY_TMR_EXP
)
1054 llc
->busy_state_timer
.expire
= opt
* HZ
;
1056 case LLC_OPT_TX_WIN
:
1057 if (opt
> LLC_OPT_MAX_WIN
)
1061 case LLC_OPT_RX_WIN
:
1062 if (opt
> LLC_OPT_MAX_WIN
)
1066 case LLC_OPT_PKTINFO
:
1068 llc
->cmsg_flags
|= LLC_CMSG_PKTINFO
;
1070 llc
->cmsg_flags
&= ~LLC_CMSG_PKTINFO
;
1083 * llc_ui_getsockopt - get connection specific socket info
1084 * @sock: Socket to get information from.
1085 * @level: Socket level user is requesting operations on.
1086 * @optname: Operation name.
1087 * @optval: Variable to return operation data in.
1088 * @optlen: Length of optval.
1090 * Get connection specific socket information.
1092 static int llc_ui_getsockopt(struct socket
*sock
, int level
, int optname
,
1093 char __user
*optval
, int __user
*optlen
)
1095 struct sock
*sk
= sock
->sk
;
1096 struct llc_sock
*llc
= llc_sk(sk
);
1097 int val
= 0, len
= 0, rc
= -EINVAL
;
1100 if (unlikely(level
!= SOL_LLC
))
1102 rc
= get_user(len
, optlen
);
1106 if (len
!= sizeof(int))
1110 val
= llc
->n2
; break;
1112 val
= llc
->n1
; break;
1113 case LLC_OPT_ACK_TMR_EXP
:
1114 val
= llc
->ack_timer
.expire
/ HZ
; break;
1115 case LLC_OPT_P_TMR_EXP
:
1116 val
= llc
->pf_cycle_timer
.expire
/ HZ
; break;
1117 case LLC_OPT_REJ_TMR_EXP
:
1118 val
= llc
->rej_sent_timer
.expire
/ HZ
; break;
1119 case LLC_OPT_BUSY_TMR_EXP
:
1120 val
= llc
->busy_state_timer
.expire
/ HZ
; break;
1121 case LLC_OPT_TX_WIN
:
1122 val
= llc
->k
; break;
1123 case LLC_OPT_RX_WIN
:
1124 val
= llc
->rw
; break;
1125 case LLC_OPT_PKTINFO
:
1126 val
= (llc
->cmsg_flags
& LLC_CMSG_PKTINFO
) != 0;
1133 if (put_user(len
, optlen
) || copy_to_user(optval
, &val
, len
))
1140 static const struct net_proto_family llc_ui_family_ops
= {
1142 .create
= llc_ui_create
,
1143 .owner
= THIS_MODULE
,
1146 static const struct proto_ops llc_ui_ops
= {
1148 .owner
= THIS_MODULE
,
1149 .release
= llc_ui_release
,
1150 .bind
= llc_ui_bind
,
1151 .connect
= llc_ui_connect
,
1152 .socketpair
= sock_no_socketpair
,
1153 .accept
= llc_ui_accept
,
1154 .getname
= llc_ui_getname
,
1155 .poll
= datagram_poll
,
1156 .ioctl
= llc_ui_ioctl
,
1157 .listen
= llc_ui_listen
,
1158 .shutdown
= llc_ui_shutdown
,
1159 .setsockopt
= llc_ui_setsockopt
,
1160 .getsockopt
= llc_ui_getsockopt
,
1161 .sendmsg
= llc_ui_sendmsg
,
1162 .recvmsg
= llc_ui_recvmsg
,
1163 .mmap
= sock_no_mmap
,
1164 .sendpage
= sock_no_sendpage
,
1167 static const char llc_proc_err_msg
[] __initconst
=
1168 KERN_CRIT
"LLC: Unable to register the proc_fs entries\n";
1169 static const char llc_sysctl_err_msg
[] __initconst
=
1170 KERN_CRIT
"LLC: Unable to register the sysctl entries\n";
1171 static const char llc_sock_err_msg
[] __initconst
=
1172 KERN_CRIT
"LLC: Unable to register the network family\n";
1174 static int __init
llc2_init(void)
1176 int rc
= proto_register(&llc_proto
, 0);
1181 llc_build_offset_table();
1183 llc_ui_sap_last_autoport
= LLC_SAP_DYN_START
;
1184 rc
= llc_proc_init();
1186 printk(llc_proc_err_msg
);
1187 goto out_unregister_llc_proto
;
1189 rc
= llc_sysctl_init();
1191 printk(llc_sysctl_err_msg
);
1194 rc
= sock_register(&llc_ui_family_ops
);
1196 printk(llc_sock_err_msg
);
1199 llc_add_pack(LLC_DEST_SAP
, llc_sap_handler
);
1200 llc_add_pack(LLC_DEST_CONN
, llc_conn_handler
);
1207 out_unregister_llc_proto
:
1208 proto_unregister(&llc_proto
);
1212 static void __exit
llc2_exit(void)
1215 llc_remove_pack(LLC_DEST_SAP
);
1216 llc_remove_pack(LLC_DEST_CONN
);
1217 sock_unregister(PF_LLC
);
1220 proto_unregister(&llc_proto
);
1223 module_init(llc2_init
);
1224 module_exit(llc2_exit
);
1226 MODULE_LICENSE("GPL");
1227 MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
1228 MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
1229 MODULE_ALIAS_NETPROTO(PF_LLC
);