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