Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
af_llc.c
Go to the documentation of this file.
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 <[email protected]>
14  * 2002-2003 by Arnaldo Carvalho de Melo <[email protected]>
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 
61 static inline u16 llc_ui_next_link_no(int sap)
62 {
63  return llc_ui_sap_link_no_max[sap]++;
64 }
65 
72 static inline __be16 llc_proto_type(u16 arphrd)
73 {
74  return htons(ETH_P_802_2);
75 }
76 
81 static inline u8 llc_ui_addr_null(struct sockaddr_llc *addr)
82 {
83  return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr));
84 }
85 
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 
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 
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 (!capable(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);
172  if (sk) {
173  rc = 0;
174  llc_ui_sk_init(sock, sk);
175  }
176  }
177  return rc;
178 }
179 
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  llc_sap_remove_socket(llc->sap, sk);
202  release_sock(sk);
203  if (llc->dev)
204  dev_put(llc->dev);
205  sock_put(sk);
206  llc_sk_free(sk);
207 out:
208  return 0;
209 }
210 
218 static int llc_ui_autoport(void)
219 {
220  struct llc_sap *sap;
221  int i, tries = 0;
222 
223  while (tries < LLC_SAP_DYN_TRIES) {
224  for (i = llc_ui_sap_last_autoport;
225  i < LLC_SAP_DYN_STOP; i += 2) {
226  sap = llc_sap_find(i);
227  if (!sap) {
228  llc_ui_sap_last_autoport = i + 2;
229  goto out;
230  }
231  llc_sap_put(sap);
232  }
233  llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
234  tries++;
235  }
236  i = 0;
237 out:
238  return i;
239 }
240 
251 static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr)
252 {
253  struct sock *sk = sock->sk;
254  struct llc_sock *llc = llc_sk(sk);
255  struct llc_sap *sap;
256  int rc = -EINVAL;
257 
258  if (!sock_flag(sk, SOCK_ZAPPED))
259  goto out;
260  rc = -ENODEV;
261  if (sk->sk_bound_dev_if) {
262  llc->dev = dev_get_by_index(&init_net, sk->sk_bound_dev_if);
263  if (llc->dev && addr->sllc_arphrd != llc->dev->type) {
264  dev_put(llc->dev);
265  llc->dev = NULL;
266  }
267  } else
268  llc->dev = dev_getfirstbyhwtype(&init_net, addr->sllc_arphrd);
269  if (!llc->dev)
270  goto out;
271  rc = -EUSERS;
272  llc->laddr.lsap = llc_ui_autoport();
273  if (!llc->laddr.lsap)
274  goto out;
275  rc = -EBUSY; /* some other network layer is using the sap */
276  sap = llc_sap_open(llc->laddr.lsap, NULL);
277  if (!sap)
278  goto out;
279  memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN);
280  memcpy(&llc->addr, addr, sizeof(llc->addr));
281  /* assign new connection to its SAP */
282  llc_sap_add_socket(sap, sk);
283  sock_reset_flag(sk, SOCK_ZAPPED);
284  rc = 0;
285 out:
286  return rc;
287 }
288 
303 static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen)
304 {
305  struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
306  struct sock *sk = sock->sk;
307  struct llc_sock *llc = llc_sk(sk);
308  struct llc_sap *sap;
309  int rc = -EINVAL;
310 
311  dprintk("%s: binding %02X\n", __func__, addr->sllc_sap);
312  if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr)))
313  goto out;
314  rc = -EAFNOSUPPORT;
315  if (unlikely(addr->sllc_family != AF_LLC))
316  goto out;
317  rc = -ENODEV;
318  rcu_read_lock();
319  if (sk->sk_bound_dev_if) {
320  llc->dev = dev_get_by_index_rcu(&init_net, sk->sk_bound_dev_if);
321  if (llc->dev) {
322  if (!addr->sllc_arphrd)
323  addr->sllc_arphrd = llc->dev->type;
324  if (llc_mac_null(addr->sllc_mac))
325  memcpy(addr->sllc_mac, llc->dev->dev_addr,
326  IFHWADDRLEN);
327  if (addr->sllc_arphrd != llc->dev->type ||
328  !llc_mac_match(addr->sllc_mac,
329  llc->dev->dev_addr)) {
330  rc = -EINVAL;
331  llc->dev = NULL;
332  }
333  }
334  } else
335  llc->dev = dev_getbyhwaddr_rcu(&init_net, addr->sllc_arphrd,
336  addr->sllc_mac);
337  if (llc->dev)
338  dev_hold(llc->dev);
339  rcu_read_unlock();
340  if (!llc->dev)
341  goto out;
342  if (!addr->sllc_sap) {
343  rc = -EUSERS;
344  addr->sllc_sap = llc_ui_autoport();
345  if (!addr->sllc_sap)
346  goto out;
347  }
348  sap = llc_sap_find(addr->sllc_sap);
349  if (!sap) {
350  sap = llc_sap_open(addr->sllc_sap, NULL);
351  rc = -EBUSY; /* some other network layer is using the sap */
352  if (!sap)
353  goto out;
354  } else {
355  struct llc_addr laddr, daddr;
356  struct sock *ask;
357 
358  memset(&laddr, 0, sizeof(laddr));
359  memset(&daddr, 0, sizeof(daddr));
360  /*
361  * FIXME: check if the address is multicast,
362  * only SOCK_DGRAM can do this.
363  */
364  memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN);
365  laddr.lsap = addr->sllc_sap;
366  rc = -EADDRINUSE; /* mac + sap clash. */
367  ask = llc_lookup_established(sap, &daddr, &laddr);
368  if (ask) {
369  sock_put(ask);
370  goto out_put;
371  }
372  }
373  llc->laddr.lsap = addr->sllc_sap;
374  memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN);
375  memcpy(&llc->addr, addr, sizeof(llc->addr));
376  /* assign new connection to its SAP */
377  llc_sap_add_socket(sap, sk);
378  sock_reset_flag(sk, SOCK_ZAPPED);
379  rc = 0;
380 out_put:
381  llc_sap_put(sap);
382 out:
383  return rc;
384 }
385 
397 static int llc_ui_shutdown(struct socket *sock, int how)
398 {
399  struct sock *sk = sock->sk;
400  int rc = -ENOTCONN;
401 
402  lock_sock(sk);
403  if (unlikely(sk->sk_state != TCP_ESTABLISHED))
404  goto out;
405  rc = -EINVAL;
406  if (how != 2)
407  goto out;
408  rc = llc_send_disc(sk);
409  if (!rc)
410  rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
411  /* Wake up anyone sleeping in poll */
412  sk->sk_state_change(sk);
413 out:
414  release_sock(sk);
415  return rc;
416 }
417 
432 static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr,
433  int addrlen, int flags)
434 {
435  struct sock *sk = sock->sk;
436  struct llc_sock *llc = llc_sk(sk);
437  struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
438  int rc = -EINVAL;
439 
440  lock_sock(sk);
441  if (unlikely(addrlen != sizeof(*addr)))
442  goto out;
443  rc = -EAFNOSUPPORT;
444  if (unlikely(addr->sllc_family != AF_LLC))
445  goto out;
446  if (unlikely(sk->sk_type != SOCK_STREAM))
447  goto out;
448  rc = -EALREADY;
449  if (unlikely(sock->state == SS_CONNECTING))
450  goto out;
451  /* bind connection to sap if user hasn't done it. */
452  if (sock_flag(sk, SOCK_ZAPPED)) {
453  /* bind to sap with null dev, exclusive */
454  rc = llc_ui_autobind(sock, addr);
455  if (rc)
456  goto out;
457  }
458  llc->daddr.lsap = addr->sllc_sap;
459  memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN);
460  sock->state = SS_CONNECTING;
461  sk->sk_state = TCP_SYN_SENT;
462  llc->link = llc_ui_next_link_no(llc->sap->laddr.lsap);
463  rc = llc_establish_connection(sk, llc->dev->dev_addr,
464  addr->sllc_mac, addr->sllc_sap);
465  if (rc) {
466  dprintk("%s: llc_ui_send_conn failed :-(\n", __func__);
467  sock->state = SS_UNCONNECTED;
468  sk->sk_state = TCP_CLOSE;
469  goto out;
470  }
471 
472  if (sk->sk_state == TCP_SYN_SENT) {
473  const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
474 
475  if (!timeo || !llc_ui_wait_for_conn(sk, timeo))
476  goto out;
477 
478  rc = sock_intr_errno(timeo);
479  if (signal_pending(current))
480  goto out;
481  }
482 
483  if (sk->sk_state == TCP_CLOSE)
484  goto sock_error;
485 
486  sock->state = SS_CONNECTED;
487  rc = 0;
488 out:
489  release_sock(sk);
490  return rc;
491 sock_error:
492  rc = sock_error(sk) ? : -ECONNABORTED;
493  sock->state = SS_UNCONNECTED;
494  goto out;
495 }
496 
505 static int llc_ui_listen(struct socket *sock, int backlog)
506 {
507  struct sock *sk = sock->sk;
508  int rc = -EINVAL;
509 
510  lock_sock(sk);
511  if (unlikely(sock->state != SS_UNCONNECTED))
512  goto out;
513  rc = -EOPNOTSUPP;
514  if (unlikely(sk->sk_type != SOCK_STREAM))
515  goto out;
516  rc = -EAGAIN;
517  if (sock_flag(sk, SOCK_ZAPPED))
518  goto out;
519  rc = 0;
520  if (!(unsigned int)backlog) /* BSDism */
521  backlog = 1;
522  sk->sk_max_ack_backlog = backlog;
523  if (sk->sk_state != TCP_LISTEN) {
524  sk->sk_ack_backlog = 0;
525  sk->sk_state = TCP_LISTEN;
526  }
527  sk->sk_socket->flags |= __SO_ACCEPTCON;
528 out:
529  release_sock(sk);
530  return rc;
531 }
532 
533 static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
534 {
535  DEFINE_WAIT(wait);
536  int rc = 0;
537 
538  while (1) {
539  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
540  if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE))
541  break;
542  rc = -ERESTARTSYS;
543  if (signal_pending(current))
544  break;
545  rc = -EAGAIN;
546  if (!timeout)
547  break;
548  rc = 0;
549  }
550  finish_wait(sk_sleep(sk), &wait);
551  return rc;
552 }
553 
554 static int llc_ui_wait_for_conn(struct sock *sk, long timeout)
555 {
556  DEFINE_WAIT(wait);
557 
558  while (1) {
559  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
560  if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT))
561  break;
562  if (signal_pending(current) || !timeout)
563  break;
564  }
565  finish_wait(sk_sleep(sk), &wait);
566  return timeout;
567 }
568 
569 static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
570 {
571  DEFINE_WAIT(wait);
572  struct llc_sock *llc = llc_sk(sk);
573  int rc;
574 
575  while (1) {
576  prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
577  rc = 0;
578  if (sk_wait_event(sk, &timeout,
579  (sk->sk_shutdown & RCV_SHUTDOWN) ||
580  (!llc_data_accept_state(llc->state) &&
581  !llc->remote_busy_flag &&
582  !llc->p_flag)))
583  break;
584  rc = -ERESTARTSYS;
585  if (signal_pending(current))
586  break;
587  rc = -EAGAIN;
588  if (!timeout)
589  break;
590  }
591  finish_wait(sk_sleep(sk), &wait);
592  return rc;
593 }
594 
595 static int llc_wait_data(struct sock *sk, long timeo)
596 {
597  int rc;
598 
599  while (1) {
600  /*
601  * POSIX 1003.1g mandates this order.
602  */
603  rc = sock_error(sk);
604  if (rc)
605  break;
606  rc = 0;
607  if (sk->sk_shutdown & RCV_SHUTDOWN)
608  break;
609  rc = -EAGAIN;
610  if (!timeo)
611  break;
612  rc = sock_intr_errno(timeo);
613  if (signal_pending(current))
614  break;
615  rc = 0;
616  if (sk_wait_data(sk, &timeo))
617  break;
618  }
619  return rc;
620 }
621 
622 static void llc_cmsg_rcv(struct msghdr *msg, struct sk_buff *skb)
623 {
624  struct llc_sock *llc = llc_sk(skb->sk);
625 
626  if (llc->cmsg_flags & LLC_CMSG_PKTINFO) {
627  struct llc_pktinfo info;
628 
629  info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex;
630  llc_pdu_decode_dsap(skb, &info.lpi_sap);
631  llc_pdu_decode_da(skb, info.lpi_mac);
632  put_cmsg(msg, SOL_LLC, LLC_OPT_PKTINFO, sizeof(info), &info);
633  }
634 }
635 
645 static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags)
646 {
647  struct sock *sk = sock->sk, *newsk;
648  struct llc_sock *llc, *newllc;
649  struct sk_buff *skb;
650  int rc = -EOPNOTSUPP;
651 
652  dprintk("%s: accepting on %02X\n", __func__,
653  llc_sk(sk)->laddr.lsap);
654  lock_sock(sk);
655  if (unlikely(sk->sk_type != SOCK_STREAM))
656  goto out;
657  rc = -EINVAL;
658  if (unlikely(sock->state != SS_UNCONNECTED ||
659  sk->sk_state != TCP_LISTEN))
660  goto out;
661  /* wait for a connection to arrive. */
662  if (skb_queue_empty(&sk->sk_receive_queue)) {
663  rc = llc_wait_data(sk, sk->sk_rcvtimeo);
664  if (rc)
665  goto out;
666  }
667  dprintk("%s: got a new connection on %02X\n", __func__,
668  llc_sk(sk)->laddr.lsap);
669  skb = skb_dequeue(&sk->sk_receive_queue);
670  rc = -EINVAL;
671  if (!skb->sk)
672  goto frees;
673  rc = 0;
674  newsk = skb->sk;
675  /* attach connection to a new socket. */
676  llc_ui_sk_init(newsock, newsk);
677  sock_reset_flag(newsk, SOCK_ZAPPED);
678  newsk->sk_state = TCP_ESTABLISHED;
679  newsock->state = SS_CONNECTED;
680  llc = llc_sk(sk);
681  newllc = llc_sk(newsk);
682  memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr));
683  newllc->link = llc_ui_next_link_no(newllc->laddr.lsap);
684 
685  /* put original socket back into a clean listen state. */
686  sk->sk_state = TCP_LISTEN;
687  sk->sk_ack_backlog--;
688  dprintk("%s: ok success on %02X, client on %02X\n", __func__,
689  llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap);
690 frees:
691  kfree_skb(skb);
692 out:
693  release_sock(sk);
694  return rc;
695 }
696 
707 static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock,
708  struct msghdr *msg, size_t len, int flags)
709 {
710  struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name;
711  const int nonblock = flags & MSG_DONTWAIT;
712  struct sk_buff *skb = NULL;
713  struct sock *sk = sock->sk;
714  struct llc_sock *llc = llc_sk(sk);
715  unsigned long cpu_flags;
716  size_t copied = 0;
717  u32 peek_seq = 0;
718  u32 *seq;
719  unsigned long used;
720  int target; /* Read at least this many bytes */
721  long timeo;
722 
723  lock_sock(sk);
724  copied = -ENOTCONN;
725  if (unlikely(sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN))
726  goto out;
727 
728  timeo = sock_rcvtimeo(sk, nonblock);
729 
730  seq = &llc->copied_seq;
731  if (flags & MSG_PEEK) {
732  peek_seq = llc->copied_seq;
733  seq = &peek_seq;
734  }
735 
736  target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
737  copied = 0;
738 
739  do {
740  u32 offset;
741 
742  /*
743  * We need to check signals first, to get correct SIGURG
744  * handling. FIXME: Need to check this doesn't impact 1003.1g
745  * and move it down to the bottom of the loop
746  */
747  if (signal_pending(current)) {
748  if (copied)
749  break;
750  copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
751  break;
752  }
753 
754  /* Next get a buffer. */
755 
756  skb = skb_peek(&sk->sk_receive_queue);
757  if (skb) {
758  offset = *seq;
759  goto found_ok_skb;
760  }
761  /* Well, if we have backlog, try to process it now yet. */
762 
763  if (copied >= target && !sk->sk_backlog.tail)
764  break;
765 
766  if (copied) {
767  if (sk->sk_err ||
768  sk->sk_state == TCP_CLOSE ||
769  (sk->sk_shutdown & RCV_SHUTDOWN) ||
770  !timeo ||
771  (flags & MSG_PEEK))
772  break;
773  } else {
774  if (sock_flag(sk, SOCK_DONE))
775  break;
776 
777  if (sk->sk_err) {
778  copied = sock_error(sk);
779  break;
780  }
781  if (sk->sk_shutdown & RCV_SHUTDOWN)
782  break;
783 
784  if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSE) {
785  if (!sock_flag(sk, SOCK_DONE)) {
786  /*
787  * This occurs when user tries to read
788  * from never connected socket.
789  */
790  copied = -ENOTCONN;
791  break;
792  }
793  break;
794  }
795  if (!timeo) {
796  copied = -EAGAIN;
797  break;
798  }
799  }
800 
801  if (copied >= target) { /* Do not sleep, just process backlog. */
802  release_sock(sk);
803  lock_sock(sk);
804  } else
805  sk_wait_data(sk, &timeo);
806 
807  if ((flags & MSG_PEEK) && peek_seq != llc->copied_seq) {
808  net_dbg_ratelimited("LLC(%s:%d): Application bug, race in MSG_PEEK\n",
809  current->comm,
810  task_pid_nr(current));
811  peek_seq = llc->copied_seq;
812  }
813  continue;
814  found_ok_skb:
815  /* Ok so how much can we use? */
816  used = skb->len - offset;
817  if (len < used)
818  used = len;
819 
820  if (!(flags & MSG_TRUNC)) {
821  int rc = skb_copy_datagram_iovec(skb, offset,
822  msg->msg_iov, used);
823  if (rc) {
824  /* Exception. Bailout! */
825  if (!copied)
826  copied = -EFAULT;
827  break;
828  }
829  }
830 
831  *seq += used;
832  copied += used;
833  len -= used;
834 
835  /* For non stream protcols we get one packet per recvmsg call */
836  if (sk->sk_type != SOCK_STREAM)
837  goto copy_uaddr;
838 
839  if (!(flags & MSG_PEEK)) {
840  spin_lock_irqsave(&sk->sk_receive_queue.lock, cpu_flags);
841  sk_eat_skb(sk, skb, false);
842  spin_unlock_irqrestore(&sk->sk_receive_queue.lock, cpu_flags);
843  *seq = 0;
844  }
845 
846  /* Partial read */
847  if (used + offset < skb->len)
848  continue;
849  } while (len > 0);
850 
851 out:
852  release_sock(sk);
853  return copied;
854 copy_uaddr:
855  if (uaddr != NULL && skb != NULL) {
856  memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr));
857  msg->msg_namelen = sizeof(*uaddr);
858  }
859  if (llc_sk(sk)->cmsg_flags)
860  llc_cmsg_rcv(msg, skb);
861 
862  if (!(flags & MSG_PEEK)) {
863  spin_lock_irqsave(&sk->sk_receive_queue.lock, cpu_flags);
864  sk_eat_skb(sk, skb, false);
865  spin_unlock_irqrestore(&sk->sk_receive_queue.lock, cpu_flags);
866  *seq = 0;
867  }
868 
869  goto out;
870 }
871 
881 static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock,
882  struct msghdr *msg, size_t len)
883 {
884  struct sock *sk = sock->sk;
885  struct llc_sock *llc = llc_sk(sk);
886  struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name;
887  int flags = msg->msg_flags;
888  int noblock = flags & MSG_DONTWAIT;
889  struct sk_buff *skb;
890  size_t size = 0;
891  int rc = -EINVAL, copied = 0, hdrlen;
892 
893  dprintk("%s: sending from %02X to %02X\n", __func__,
894  llc->laddr.lsap, llc->daddr.lsap);
895  lock_sock(sk);
896  if (addr) {
897  if (msg->msg_namelen < sizeof(*addr))
898  goto release;
899  } else {
900  if (llc_ui_addr_null(&llc->addr))
901  goto release;
902  addr = &llc->addr;
903  }
904  /* must bind connection to sap if user hasn't done it. */
905  if (sock_flag(sk, SOCK_ZAPPED)) {
906  /* bind to sap with null dev, exclusive. */
907  rc = llc_ui_autobind(sock, addr);
908  if (rc)
909  goto release;
910  }
911  hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr);
912  size = hdrlen + len;
913  if (size > llc->dev->mtu)
914  size = llc->dev->mtu;
915  copied = size - hdrlen;
916  release_sock(sk);
917  skb = sock_alloc_send_skb(sk, size, noblock, &rc);
918  lock_sock(sk);
919  if (!skb)
920  goto release;
921  skb->dev = llc->dev;
922  skb->protocol = llc_proto_type(addr->sllc_arphrd);
923  skb_reserve(skb, hdrlen);
924  rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied);
925  if (rc)
926  goto out;
927  if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) {
928  llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac,
929  addr->sllc_sap);
930  goto out;
931  }
932  if (addr->sllc_test) {
933  llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac,
934  addr->sllc_sap);
935  goto out;
936  }
937  if (addr->sllc_xid) {
938  llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac,
939  addr->sllc_sap);
940  goto out;
941  }
942  rc = -ENOPROTOOPT;
943  if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua))
944  goto out;
945  rc = llc_ui_send_data(sk, skb, noblock);
946 out:
947  if (rc) {
948  kfree_skb(skb);
949 release:
950  dprintk("%s: failed sending from %02X to %02X: %d\n",
951  __func__, llc->laddr.lsap, llc->daddr.lsap, rc);
952  }
953  release_sock(sk);
954  return rc ? : copied;
955 }
956 
966 static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
967  int *uaddrlen, int peer)
968 {
969  struct sockaddr_llc sllc;
970  struct sock *sk = sock->sk;
971  struct llc_sock *llc = llc_sk(sk);
972  int rc = -EBADF;
973 
974  memset(&sllc, 0, sizeof(sllc));
975  lock_sock(sk);
976  if (sock_flag(sk, SOCK_ZAPPED))
977  goto out;
978  *uaddrlen = sizeof(sllc);
979  if (peer) {
980  rc = -ENOTCONN;
981  if (sk->sk_state != TCP_ESTABLISHED)
982  goto out;
983  if(llc->dev)
984  sllc.sllc_arphrd = llc->dev->type;
985  sllc.sllc_sap = llc->daddr.lsap;
986  memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN);
987  } else {
988  rc = -EINVAL;
989  if (!llc->sap)
990  goto out;
991  sllc.sllc_sap = llc->sap->laddr.lsap;
992 
993  if (llc->dev) {
994  sllc.sllc_arphrd = llc->dev->type;
995  memcpy(&sllc.sllc_mac, llc->dev->dev_addr,
996  IFHWADDRLEN);
997  }
998  }
999  rc = 0;
1000  sllc.sllc_family = AF_LLC;
1001  memcpy(uaddr, &sllc, sizeof(sllc));
1002 out:
1003  release_sock(sk);
1004  return rc;
1005 }
1006 
1015 static int llc_ui_ioctl(struct socket *sock, unsigned int cmd,
1016  unsigned long arg)
1017 {
1018  return -ENOIOCTLCMD;
1019 }
1020 
1031 static int llc_ui_setsockopt(struct socket *sock, int level, int optname,
1032  char __user *optval, unsigned int optlen)
1033 {
1034  struct sock *sk = sock->sk;
1035  struct llc_sock *llc = llc_sk(sk);
1036  unsigned int opt;
1037  int rc = -EINVAL;
1038 
1039  lock_sock(sk);
1040  if (unlikely(level != SOL_LLC || optlen != sizeof(int)))
1041  goto out;
1042  rc = get_user(opt, (int __user *)optval);
1043  if (rc)
1044  goto out;
1045  rc = -EINVAL;
1046  switch (optname) {
1047  case LLC_OPT_RETRY:
1048  if (opt > LLC_OPT_MAX_RETRY)
1049  goto out;
1050  llc->n2 = opt;
1051  break;
1052  case LLC_OPT_SIZE:
1053  if (opt > LLC_OPT_MAX_SIZE)
1054  goto out;
1055  llc->n1 = opt;
1056  break;
1057  case LLC_OPT_ACK_TMR_EXP:
1058  if (opt > LLC_OPT_MAX_ACK_TMR_EXP)
1059  goto out;
1060  llc->ack_timer.expire = opt * HZ;
1061  break;
1062  case LLC_OPT_P_TMR_EXP:
1063  if (opt > LLC_OPT_MAX_P_TMR_EXP)
1064  goto out;
1065  llc->pf_cycle_timer.expire = opt * HZ;
1066  break;
1067  case LLC_OPT_REJ_TMR_EXP:
1068  if (opt > LLC_OPT_MAX_REJ_TMR_EXP)
1069  goto out;
1070  llc->rej_sent_timer.expire = opt * HZ;
1071  break;
1072  case LLC_OPT_BUSY_TMR_EXP:
1073  if (opt > LLC_OPT_MAX_BUSY_TMR_EXP)
1074  goto out;
1075  llc->busy_state_timer.expire = opt * HZ;
1076  break;
1077  case LLC_OPT_TX_WIN:
1078  if (opt > LLC_OPT_MAX_WIN)
1079  goto out;
1080  llc->k = opt;
1081  break;
1082  case LLC_OPT_RX_WIN:
1083  if (opt > LLC_OPT_MAX_WIN)
1084  goto out;
1085  llc->rw = opt;
1086  break;
1087  case LLC_OPT_PKTINFO:
1088  if (opt)
1089  llc->cmsg_flags |= LLC_CMSG_PKTINFO;
1090  else
1091  llc->cmsg_flags &= ~LLC_CMSG_PKTINFO;
1092  break;
1093  default:
1094  rc = -ENOPROTOOPT;
1095  goto out;
1096  }
1097  rc = 0;
1098 out:
1099  release_sock(sk);
1100  return rc;
1101 }
1102 
1113 static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
1114  char __user *optval, int __user *optlen)
1115 {
1116  struct sock *sk = sock->sk;
1117  struct llc_sock *llc = llc_sk(sk);
1118  int val = 0, len = 0, rc = -EINVAL;
1119 
1120  lock_sock(sk);
1121  if (unlikely(level != SOL_LLC))
1122  goto out;
1123  rc = get_user(len, optlen);
1124  if (rc)
1125  goto out;
1126  rc = -EINVAL;
1127  if (len != sizeof(int))
1128  goto out;
1129  switch (optname) {
1130  case LLC_OPT_RETRY:
1131  val = llc->n2; break;
1132  case LLC_OPT_SIZE:
1133  val = llc->n1; break;
1134  case LLC_OPT_ACK_TMR_EXP:
1135  val = llc->ack_timer.expire / HZ; break;
1136  case LLC_OPT_P_TMR_EXP:
1137  val = llc->pf_cycle_timer.expire / HZ; break;
1138  case LLC_OPT_REJ_TMR_EXP:
1139  val = llc->rej_sent_timer.expire / HZ; break;
1140  case LLC_OPT_BUSY_TMR_EXP:
1141  val = llc->busy_state_timer.expire / HZ; break;
1142  case LLC_OPT_TX_WIN:
1143  val = llc->k; break;
1144  case LLC_OPT_RX_WIN:
1145  val = llc->rw; break;
1146  case LLC_OPT_PKTINFO:
1147  val = (llc->cmsg_flags & LLC_CMSG_PKTINFO) != 0;
1148  break;
1149  default:
1150  rc = -ENOPROTOOPT;
1151  goto out;
1152  }
1153  rc = 0;
1154  if (put_user(len, optlen) || copy_to_user(optval, &val, len))
1155  rc = -EFAULT;
1156 out:
1157  release_sock(sk);
1158  return rc;
1159 }
1160 
1161 static const struct net_proto_family llc_ui_family_ops = {
1162  .family = PF_LLC,
1163  .create = llc_ui_create,
1164  .owner = THIS_MODULE,
1165 };
1166 
1167 static const struct proto_ops llc_ui_ops = {
1168  .family = PF_LLC,
1169  .owner = THIS_MODULE,
1170  .release = llc_ui_release,
1171  .bind = llc_ui_bind,
1172  .connect = llc_ui_connect,
1173  .socketpair = sock_no_socketpair,
1174  .accept = llc_ui_accept,
1175  .getname = llc_ui_getname,
1176  .poll = datagram_poll,
1177  .ioctl = llc_ui_ioctl,
1178  .listen = llc_ui_listen,
1179  .shutdown = llc_ui_shutdown,
1180  .setsockopt = llc_ui_setsockopt,
1181  .getsockopt = llc_ui_getsockopt,
1182  .sendmsg = llc_ui_sendmsg,
1183  .recvmsg = llc_ui_recvmsg,
1184  .mmap = sock_no_mmap,
1185  .sendpage = sock_no_sendpage,
1186 };
1187 
1188 static const char llc_proc_err_msg[] __initconst =
1189  KERN_CRIT "LLC: Unable to register the proc_fs entries\n";
1190 static const char llc_sysctl_err_msg[] __initconst =
1191  KERN_CRIT "LLC: Unable to register the sysctl entries\n";
1192 static const char llc_sock_err_msg[] __initconst =
1193  KERN_CRIT "LLC: Unable to register the network family\n";
1194 
1195 static int __init llc2_init(void)
1196 {
1197  int rc = proto_register(&llc_proto, 0);
1198 
1199  if (rc != 0)
1200  goto out;
1201 
1202  llc_build_offset_table();
1203  llc_station_init();
1204  llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
1205  rc = llc_proc_init();
1206  if (rc != 0) {
1207  printk(llc_proc_err_msg);
1208  goto out_station;
1209  }
1210  rc = llc_sysctl_init();
1211  if (rc) {
1212  printk(llc_sysctl_err_msg);
1213  goto out_proc;
1214  }
1215  rc = sock_register(&llc_ui_family_ops);
1216  if (rc) {
1217  printk(llc_sock_err_msg);
1218  goto out_sysctl;
1219  }
1220  llc_add_pack(LLC_DEST_SAP, llc_sap_handler);
1221  llc_add_pack(LLC_DEST_CONN, llc_conn_handler);
1222 out:
1223  return rc;
1224 out_sysctl:
1225  llc_sysctl_exit();
1226 out_proc:
1227  llc_proc_exit();
1228 out_station:
1229  llc_station_exit();
1230  proto_unregister(&llc_proto);
1231  goto out;
1232 }
1233 
1234 static void __exit llc2_exit(void)
1235 {
1236  llc_station_exit();
1237  llc_remove_pack(LLC_DEST_SAP);
1238  llc_remove_pack(LLC_DEST_CONN);
1239  sock_unregister(PF_LLC);
1240  llc_proc_exit();
1241  llc_sysctl_exit();
1242  proto_unregister(&llc_proto);
1243 }
1244 
1245 module_init(llc2_init);
1246 module_exit(llc2_exit);
1247 
1248 MODULE_LICENSE("GPL");
1249 MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
1250 MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
1251 MODULE_ALIAS_NETPROTO(PF_LLC);
Generated on Thu Jan 10 2013 14:59:52 for Linux Kernel by   doxygen 1.8.2