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