[LLC]: Fix the accept path
[linux-3.10.git] / net / llc / af_llc.c
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/config.h>
24 #include <linux/compiler.h>
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/rtnetlink.h>
28 #include <linux/init.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 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 /**
52  *      llc_ui_next_link_no - return the next unused link number for a sap
53  *      @sap: Address of sap to get link number from.
54  *
55  *      Return the next unused link number for a given sap.
56  */
57 static __inline__ u16 llc_ui_next_link_no(int sap)
58 {
59         return llc_ui_sap_link_no_max[sap]++;
60 }
61
62 /**
63  *      llc_proto_type - return eth protocol for ARP header type
64  *      @arphrd: ARP header type.
65  *
66  *      Given an ARP header type return the corresponding ethernet protocol.
67  */
68 static __inline__ u16 llc_proto_type(u16 arphrd)
69 {
70         return arphrd == ARPHRD_IEEE802_TR ?
71                          htons(ETH_P_TR_802_2) : htons(ETH_P_802_2);
72 }
73
74 /**
75  *      llc_ui_addr_null - determines if a address structure is null
76  *      @addr: Address to test if null.
77  */
78 static __inline__ u8 llc_ui_addr_null(struct sockaddr_llc *addr)
79 {
80         return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr));
81 }
82
83 /**
84  *      llc_ui_header_len - return length of llc header based on operation
85  *      @sk: Socket which contains a valid llc socket type.
86  *      @addr: Complete sockaddr_llc structure received from the user.
87  *
88  *      Provide the length of the llc header depending on what kind of
89  *      operation the user would like to perform and the type of socket.
90  *      Returns the correct llc header length.
91  */
92 static __inline__ u8 llc_ui_header_len(struct sock *sk,
93                                        struct sockaddr_llc *addr)
94 {
95         u8 rc = LLC_PDU_LEN_U;
96
97         if (addr->sllc_test || addr->sllc_xid)
98                 rc = LLC_PDU_LEN_U;
99         else if (sk->sk_type == SOCK_STREAM)
100                 rc = LLC_PDU_LEN_I;
101         return rc;
102 }
103
104 /**
105  *      llc_ui_send_data - send data via reliable llc2 connection
106  *      @sk: Connection the socket is using.
107  *      @skb: Data the user wishes to send.
108  *      @addr: Source and destination fields provided by the user.
109  *      @noblock: can we block waiting for data?
110  *
111  *      Send data via reliable llc2 connection.
112  *      Returns 0 upon success, non-zero if action did not succeed.
113  */
114 static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock)
115 {
116         struct llc_sock* llc = llc_sk(sk);
117         int rc = 0;
118
119         if (unlikely(llc_data_accept_state(llc->state) || 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     = "DDP",
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_remove_socket(llc->sap, sk);
191         release_sock(sk);
192         if (llc->dev)
193                 dev_put(llc->dev);
194         sock_put(sk);
195         llc_sk_free(sk);
196 out:
197         return 0;
198 }
199
200 /**
201  *      llc_ui_autoport - provide dynamically allocate SAP number
202  *
203  *      Provide the caller with a dynamically allocated SAP number according
204  *      to the rules that are set in this function. Returns: 0, upon failure,
205  *      SAP number otherwise.
206  */
207 static int llc_ui_autoport(void)
208 {
209         struct llc_sap *sap;
210         int i, tries = 0;
211
212         while (tries < LLC_SAP_DYN_TRIES) {
213                 for (i = llc_ui_sap_last_autoport;
214                      i < LLC_SAP_DYN_STOP; i += 2) {
215                         sap = llc_sap_find(i);
216                         if (!sap) {
217                                 llc_ui_sap_last_autoport = i + 2;
218                                 goto out;
219                         }
220                         llc_sap_put(sap);
221                 }
222                 llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
223                 tries++;
224         }
225         i = 0;
226 out:
227         return i;
228 }
229
230 /**
231  *      llc_ui_autobind - automatically bind a socket to a sap
232  *      @sock: socket to bind
233  *      @addr: address to connect to
234  *
235  *      Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't
236  *      specifically used llc_ui_bind to bind to an specific address/sap
237  *
238  *      Returns: 0 upon success, negative otherwise.
239  */
240 static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr)
241 {
242         struct sock *sk = sock->sk;
243         struct llc_sock *llc = llc_sk(sk);
244         struct llc_sap *sap;
245         int rc = -EINVAL;
246
247         if (!sock_flag(sk, SOCK_ZAPPED))
248                 goto out;
249         rc = -ENODEV;
250         llc->dev = dev_getfirstbyhwtype(addr->sllc_arphrd);
251         if (!llc->dev)
252                 goto out;
253         rc = -EUSERS;
254         llc->laddr.lsap = llc_ui_autoport();
255         if (!llc->laddr.lsap)
256                 goto out;
257         rc = -EBUSY; /* some other network layer is using the sap */
258         sap = llc_sap_open(llc->laddr.lsap, NULL);
259         if (!sap)
260                 goto out;
261         memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN);
262         memcpy(&llc->addr, addr, sizeof(llc->addr));
263         /* assign new connection to its SAP */
264         llc_sap_add_socket(sap, sk);
265         sock_reset_flag(sk, SOCK_ZAPPED);
266         rc = 0;
267 out:
268         return rc;
269 }
270
271 /**
272  *      llc_ui_bind - bind a socket to a specific address.
273  *      @sock: Socket to bind an address to.
274  *      @uaddr: Address the user wants the socket bound to.
275  *      @addrlen: Length of the uaddr structure.
276  *
277  *      Bind a socket to a specific address. For llc a user is able to bind to
278  *      a specific sap only or mac + sap.
279  *      If the user desires to bind to a specific mac + sap, it is possible to
280  *      have multiple sap connections via multiple macs.
281  *      Bind and autobind for that matter must enforce the correct sap usage
282  *      otherwise all hell will break loose.
283  *      Returns: 0 upon success, negative otherwise.
284  */
285 static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen)
286 {
287         struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
288         struct sock *sk = sock->sk;
289         struct llc_sock *llc = llc_sk(sk);
290         struct llc_sap *sap;
291         int rc = -EINVAL;
292
293         dprintk("%s: binding %02X\n", __FUNCTION__, addr->sllc_sap);
294         if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr)))
295                 goto out;
296         rc = -EAFNOSUPPORT;
297         if (unlikely(addr->sllc_family != AF_LLC))
298                 goto out;
299         rc = -ENODEV;
300         rtnl_lock();
301         llc->dev = dev_getbyhwaddr(addr->sllc_arphrd, addr->sllc_mac);
302         rtnl_unlock();
303         if (!llc->dev)
304                 goto out;
305         if (!addr->sllc_sap) {
306                 rc = -EUSERS;
307                 addr->sllc_sap = llc_ui_autoport();
308                 if (!addr->sllc_sap)
309                         goto out;
310         }
311         sap = llc_sap_find(addr->sllc_sap);
312         if (!sap) {
313                 sap = llc_sap_open(addr->sllc_sap, NULL);
314                 rc = -EBUSY; /* some other network layer is using the sap */
315                 if (!sap)
316                         goto out;
317                 llc_sap_hold(sap);
318         } else {
319                 struct llc_addr laddr, daddr;
320                 struct sock *ask;
321
322                 memset(&laddr, 0, sizeof(laddr));
323                 memset(&daddr, 0, sizeof(daddr));
324                 /*
325                  * FIXME: check if the the address is multicast,
326                  *        only SOCK_DGRAM can do this.
327                  */
328                 memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN);
329                 laddr.lsap = addr->sllc_sap;
330                 rc = -EADDRINUSE; /* mac + sap clash. */
331                 ask = llc_lookup_established(sap, &daddr, &laddr);
332                 if (ask) {
333                         sock_put(ask);
334                         goto out_put;
335                 }
336         }
337         llc->laddr.lsap = addr->sllc_sap;
338         memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN);
339         memcpy(&llc->addr, addr, sizeof(llc->addr));
340         /* assign new connection to its SAP */
341         llc_sap_add_socket(sap, sk);
342         sock_reset_flag(sk, SOCK_ZAPPED);
343         rc = 0;
344 out_put:
345         llc_sap_put(sap);
346 out:
347         return rc;
348 }
349
350 /**
351  *      llc_ui_shutdown - shutdown a connect llc2 socket.
352  *      @sock: Socket to shutdown.
353  *      @how: What part of the socket to shutdown.
354  *
355  *      Shutdown a connected llc2 socket. Currently this function only supports
356  *      shutting down both sends and receives (2), we could probably make this
357  *      function such that a user can shutdown only half the connection but not
358  *      right now.
359  *      Returns: 0 upon success, negative otherwise.
360  */
361 static int llc_ui_shutdown(struct socket *sock, int how)
362 {
363         struct sock *sk = sock->sk;
364         int rc = -ENOTCONN;
365
366         lock_sock(sk);
367         if (unlikely(sk->sk_state != TCP_ESTABLISHED))
368                 goto out;
369         rc = -EINVAL;
370         if (how != 2)
371                 goto out;
372         rc = llc_send_disc(sk);
373         if (!rc)
374                 rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
375         /* Wake up anyone sleeping in poll */
376         sk->sk_state_change(sk);
377 out:
378         release_sock(sk);
379         return rc;
380 }
381
382 /**
383  *      llc_ui_connect - Connect to a remote llc2 mac + sap.
384  *      @sock: Socket which will be connected to the remote destination.
385  *      @uaddr: Remote and possibly the local address of the new connection.
386  *      @addrlen: Size of uaddr structure.
387  *      @flags: Operational flags specified by the user.
388  *
389  *      Connect to a remote llc2 mac + sap. The caller must specify the
390  *      destination mac and address to connect to. If the user hasn't previously
391  *      called bind(2) with a smac the address of the first interface of the
392  *      specified arp type will be used.
393  *      This function will autobind if user did not previously call bind.
394  *      Returns: 0 upon success, negative otherwise.
395  */
396 static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr,
397                           int addrlen, int flags)
398 {
399         struct sock *sk = sock->sk;
400         struct llc_sock *llc = llc_sk(sk);
401         struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
402         int rc = -EINVAL;
403
404         lock_sock(sk);
405         if (unlikely(addrlen != sizeof(*addr)))
406                 goto out;
407         rc = -EAFNOSUPPORT;
408         if (unlikely(addr->sllc_family != AF_LLC))
409                 goto out;
410         if (unlikely(sk->sk_type != SOCK_STREAM))
411                 goto out;
412         rc = -EALREADY;
413         if (unlikely(sock->state == SS_CONNECTING))
414                 goto out;
415         /* bind connection to sap if user hasn't done it. */
416         if (sock_flag(sk, SOCK_ZAPPED)) {
417                 /* bind to sap with null dev, exclusive */
418                 rc = llc_ui_autobind(sock, addr);
419                 if (rc)
420                         goto out;
421         }
422         llc->daddr.lsap = addr->sllc_sap;
423         memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN);
424         sock->state = SS_CONNECTING;
425         sk->sk_state   = TCP_SYN_SENT;
426         llc->link   = llc_ui_next_link_no(llc->sap->laddr.lsap);
427         rc = llc_establish_connection(sk, llc->dev->dev_addr,
428                                       addr->sllc_mac, addr->sllc_sap);
429         if (rc) {
430                 dprintk("%s: llc_ui_send_conn failed :-(\n", __FUNCTION__);
431                 sock->state  = SS_UNCONNECTED;
432                 sk->sk_state = TCP_CLOSE;
433                 goto out;
434         }
435
436         if (sk->sk_state == TCP_SYN_SENT) {
437                 const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
438
439                 if (!timeo || !llc_ui_wait_for_conn(sk, timeo))
440                         goto out;
441
442                 rc = sock_intr_errno(timeo);
443                 if (signal_pending(current))
444                         goto out;
445         }
446
447         if (sk->sk_state == TCP_CLOSE)
448                 goto sock_error;
449
450         sock->state = SS_CONNECTED;
451         rc = 0;
452 out:
453         release_sock(sk);
454         return rc;
455 sock_error:
456         rc = sock_error(sk) ? : -ECONNABORTED;
457         sock->state = SS_UNCONNECTED;
458         goto out;
459 }
460
461 /**
462  *      llc_ui_listen - allow a normal socket to accept incoming connections
463  *      @sock: Socket to allow incoming connections on.
464  *      @backlog: Number of connections to queue.
465  *
466  *      Allow a normal socket to accept incoming connections.
467  *      Returns 0 upon success, negative otherwise.
468  */
469 static int llc_ui_listen(struct socket *sock, int backlog)
470 {
471         struct sock *sk = sock->sk;
472         int rc = -EINVAL;
473
474         lock_sock(sk);
475         if (unlikely(sock->state != SS_UNCONNECTED))
476                 goto out;
477         rc = -EOPNOTSUPP;
478         if (unlikely(sk->sk_type != SOCK_STREAM))
479                 goto out;
480         rc = -EAGAIN;
481         if (sock_flag(sk, SOCK_ZAPPED))
482                 goto out;
483         rc = 0;
484         if (!(unsigned)backlog) /* BSDism */
485                 backlog = 1;
486         sk->sk_max_ack_backlog = backlog;
487         if (sk->sk_state != TCP_LISTEN) {
488                 sk->sk_ack_backlog = 0;
489                 sk->sk_state       = TCP_LISTEN;
490         }
491         sk->sk_socket->flags |= __SO_ACCEPTCON;
492 out:
493         release_sock(sk);
494         return rc;
495 }
496
497 static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
498 {
499         DEFINE_WAIT(wait);
500         int rc = 0;
501
502         while (1) {
503                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
504                 if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE))
505                         break;
506                 rc = -ERESTARTSYS;
507                 if (signal_pending(current))
508                         break;
509                 rc = -EAGAIN;
510                 if (!timeout)
511                         break;
512                 rc = 0;
513         }
514         finish_wait(sk->sk_sleep, &wait);
515         return rc;
516 }
517
518 static int llc_ui_wait_for_conn(struct sock *sk, long timeout)
519 {
520         DEFINE_WAIT(wait);
521
522         while (1) {
523                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
524                 if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT))
525                         break;
526                 if (signal_pending(current) || !timeout)
527                         break;
528         }
529         finish_wait(sk->sk_sleep, &wait);
530         return timeout;
531 }
532
533 static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
534 {
535         DEFINE_WAIT(wait);
536         struct llc_sock *llc = llc_sk(sk);
537         int rc;
538
539         while (1) {
540                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
541                 rc = 0;
542                 if (sk_wait_event(sk, &timeout,
543                                   (sk->sk_shutdown & RCV_SHUTDOWN) ||
544                                   (!llc_data_accept_state(llc->state) &&
545                                    !llc->p_flag)))
546                         break;
547                 rc = -ERESTARTSYS;
548                 if (signal_pending(current))
549                         break;
550                 rc = -EAGAIN;
551                 if (!timeout)
552                         break;
553         }
554         finish_wait(sk->sk_sleep, &wait);
555         return rc;
556 }
557
558 static int llc_wait_data(struct sock *sk, long timeo)
559 {
560         int rc;
561
562         while (1) {
563                 /*
564                  * POSIX 1003.1g mandates this order.
565                  */
566                 if (sk->sk_err) {
567                         rc = sock_error(sk);
568                         break;
569                 }
570                 rc = 0;
571                 if (sk->sk_shutdown & RCV_SHUTDOWN)
572                         break;
573                 rc = -EAGAIN;
574                 if (!timeo)
575                         break;
576                 rc = sock_intr_errno(timeo);
577                 if (signal_pending(current))
578                         break;
579                 rc = 0;
580                 if (sk_wait_data(sk, &timeo))
581                         break;
582         }
583         return rc;
584 }
585
586 /**
587  *      llc_ui_accept - accept a new incoming connection.
588  *      @sock: Socket which connections arrive on.
589  *      @newsock: Socket to move incoming connection to.
590  *      @flags: User specified operational flags.
591  *
592  *      Accept a new incoming connection.
593  *      Returns 0 upon success, negative otherwise.
594  */
595 static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags)
596 {
597         struct sock *sk = sock->sk, *newsk;
598         struct llc_sock *llc, *newllc;
599         struct sk_buff *skb;
600         int rc = -EOPNOTSUPP;
601
602         dprintk("%s: accepting on %02X\n", __FUNCTION__,
603                 llc_sk(sk)->laddr.lsap);
604         lock_sock(sk);
605         if (unlikely(sk->sk_type != SOCK_STREAM))
606                 goto out;
607         rc = -EINVAL;
608         if (unlikely(sock->state != SS_UNCONNECTED ||
609                      sk->sk_state != TCP_LISTEN))
610                 goto out;
611         /* wait for a connection to arrive. */
612         if (skb_queue_empty(&sk->sk_receive_queue)) {
613                 rc = llc_wait_data(sk, sk->sk_rcvtimeo);
614                 if (rc)
615                         goto out;
616         }
617         dprintk("%s: got a new connection on %02X\n", __FUNCTION__,
618                 llc_sk(sk)->laddr.lsap);
619         skb = skb_dequeue(&sk->sk_receive_queue);
620         rc = -EINVAL;
621         if (!skb->sk)
622                 goto frees;
623         rc = 0;
624         newsk = skb->sk;
625         /* attach connection to a new socket. */
626         llc_ui_sk_init(newsock, newsk);
627         sock_reset_flag(newsk, SOCK_ZAPPED);
628         newsk->sk_state         = TCP_ESTABLISHED;
629         newsock->state          = SS_CONNECTED;
630         llc                     = llc_sk(sk);
631         newllc                  = llc_sk(newsk);
632         memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr));
633         newllc->link = llc_ui_next_link_no(newllc->laddr.lsap);
634
635         /* put original socket back into a clean listen state. */
636         sk->sk_state = TCP_LISTEN;
637         sk->sk_ack_backlog--;
638         dprintk("%s: ok success on %02X, client on %02X\n", __FUNCTION__,
639                 llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap);
640 frees:
641         kfree_skb(skb);
642 out:
643         release_sock(sk);
644         return rc;
645 }
646
647 /**
648  *      llc_ui_recvmsg - copy received data to the socket user.
649  *      @sock: Socket to copy data from.
650  *      @msg: Various user space related information.
651  *      @size: Size of user buffer.
652  *      @flags: User specified flags.
653  *
654  *      Copy received data to the socket user.
655  *      Returns non-negative upon success, negative otherwise.
656  */
657 static int llc_ui_recvmsg(struct kiocb *iocb, struct socket *sock,
658                           struct msghdr *msg, size_t size, int flags)
659 {
660         struct sock *sk = sock->sk;
661         struct sockaddr_llc *uaddr = (struct sockaddr_llc *)msg->msg_name;
662         struct sk_buff *skb;
663         size_t copied = 0;
664         int rc = -ENOMEM;
665         int noblock = flags & MSG_DONTWAIT;
666
667         dprintk("%s: receiving in %02X from %02X\n", __FUNCTION__,
668                 llc_sk(sk)->laddr.lsap, llc_sk(sk)->daddr.lsap);
669         lock_sock(sk);
670         if (skb_queue_empty(&sk->sk_receive_queue)) {
671                 rc = llc_wait_data(sk, sock_rcvtimeo(sk, noblock));
672                 if (rc)
673                         goto out;
674         }
675         skb = skb_dequeue(&sk->sk_receive_queue);
676         if (!skb) /* shutdown */
677                 goto out;
678         copied = skb->len;
679         if (copied > size)
680                 copied = size;
681         rc = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
682         if (rc)
683                 goto dgram_free;
684         if (skb->len > copied) {
685                 skb_pull(skb, copied);
686                 skb_queue_head(&sk->sk_receive_queue, skb);
687         }
688         if (uaddr)
689                 memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr));
690         msg->msg_namelen = sizeof(*uaddr);
691         if (!skb->next) {
692 dgram_free:
693                 kfree_skb(skb);
694         }
695 out:
696         release_sock(sk);
697         return rc ? : copied;
698 }
699
700 /**
701  *      llc_ui_sendmsg - Transmit data provided by the socket user.
702  *      @sock: Socket to transmit data from.
703  *      @msg: Various user related information.
704  *      @len: Length of data to transmit.
705  *
706  *      Transmit data provided by the socket user.
707  *      Returns non-negative upon success, negative otherwise.
708  */
709 static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock,
710                           struct msghdr *msg, size_t len)
711 {
712         struct sock *sk = sock->sk;
713         struct llc_sock *llc = llc_sk(sk);
714         struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name;
715         int flags = msg->msg_flags;
716         int noblock = flags & MSG_DONTWAIT;
717         struct sk_buff *skb;
718         size_t size = 0;
719         int rc = -EINVAL, copied = 0, hdrlen;
720
721         dprintk("%s: sending from %02X to %02X\n", __FUNCTION__,
722                 llc->laddr.lsap, llc->daddr.lsap);
723         lock_sock(sk);
724         if (addr) {
725                 if (msg->msg_namelen < sizeof(*addr))
726                         goto release;
727         } else {
728                 if (llc_ui_addr_null(&llc->addr))
729                         goto release;
730                 addr = &llc->addr;
731         }
732         /* must bind connection to sap if user hasn't done it. */
733         if (sock_flag(sk, SOCK_ZAPPED)) {
734                 /* bind to sap with null dev, exclusive. */
735                 rc = llc_ui_autobind(sock, addr);
736                 if (rc)
737                         goto release;
738         }
739         hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr);
740         size = hdrlen + len;
741         if (size > llc->dev->mtu)
742                 size = llc->dev->mtu;
743         copied = size - hdrlen;
744         release_sock(sk);
745         skb = sock_alloc_send_skb(sk, size, noblock, &rc);
746         lock_sock(sk);
747         if (!skb)
748                 goto release;
749         skb->dev      = llc->dev;
750         skb->protocol = llc_proto_type(addr->sllc_arphrd);
751         skb_reserve(skb, hdrlen); 
752         rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied);
753         if (rc)
754                 goto out;
755         if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) {
756                 llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac,
757                                           addr->sllc_sap);
758                 goto out;
759         }
760         if (addr->sllc_test) {
761                 llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac,
762                                             addr->sllc_sap);
763                 goto out;
764         }
765         if (addr->sllc_xid) {
766                 llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac,
767                                            addr->sllc_sap);
768                 goto out;
769         }
770         rc = -ENOPROTOOPT;
771         if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua))
772                 goto out;
773         rc = llc_ui_send_data(sk, skb, noblock);
774 out:
775         if (rc) {
776                 kfree_skb(skb);
777 release:
778                 dprintk("%s: failed sending from %02X to %02X: %d\n",
779                         __FUNCTION__, llc->laddr.lsap, llc->daddr.lsap, rc);
780         }
781         release_sock(sk);
782         return rc ? : copied;
783 }
784
785 /**
786  *      llc_ui_getname - return the address info of a socket
787  *      @sock: Socket to get address of.
788  *      @uaddr: Address structure to return information.
789  *      @uaddrlen: Length of address structure.
790  *      @peer: Does user want local or remote address information.
791  *
792  *      Return the address information of a socket.
793  */
794 static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
795                           int *uaddrlen, int peer)
796 {
797         struct sockaddr_llc sllc;
798         struct sock *sk = sock->sk;
799         struct llc_sock *llc = llc_sk(sk);
800         int rc = 0;
801
802         lock_sock(sk);
803         if (sock_flag(sk, SOCK_ZAPPED))
804                 goto out;
805         *uaddrlen = sizeof(sllc);
806         memset(uaddr, 0, *uaddrlen);
807         if (peer) {
808                 rc = -ENOTCONN;
809                 if (sk->sk_state != TCP_ESTABLISHED)
810                         goto out;
811                 if(llc->dev)
812                         sllc.sllc_arphrd = llc->dev->type;
813                 sllc.sllc_sap = llc->daddr.lsap;
814                 memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN);
815         } else {
816                 rc = -EINVAL;
817                 if (!llc->sap)
818                         goto out;
819                 sllc.sllc_sap = llc->sap->laddr.lsap;
820
821                 if (llc->dev) {
822                         sllc.sllc_arphrd = llc->dev->type;
823                         memcpy(&sllc.sllc_mac, &llc->dev->dev_addr,
824                                IFHWADDRLEN);
825                 }
826         }
827         rc = 0;
828         sllc.sllc_family = AF_LLC;
829         memcpy(uaddr, &sllc, sizeof(sllc));
830 out:
831         release_sock(sk);
832         return rc;
833 }
834
835 /**
836  *      llc_ui_ioctl - io controls for PF_LLC
837  *      @sock: Socket to get/set info
838  *      @cmd: command
839  *      @arg: optional argument for cmd
840  *
841  *      get/set info on llc sockets
842  */
843 static int llc_ui_ioctl(struct socket *sock, unsigned int cmd,
844                         unsigned long arg)
845 {
846         return dev_ioctl(cmd, (void __user *)arg);
847 }
848
849 /**
850  *      llc_ui_setsockopt - set various connection specific parameters.
851  *      @sock: Socket to set options on.
852  *      @level: Socket level user is requesting operations on.
853  *      @optname: Operation name.
854  *      @optval User provided operation data.
855  *      @optlen: Length of optval.
856  *
857  *      Set various connection specific parameters.
858  */
859 static int llc_ui_setsockopt(struct socket *sock, int level, int optname,
860                              char __user *optval, int optlen)
861 {
862         struct sock *sk = sock->sk;
863         struct llc_sock *llc = llc_sk(sk);
864         int rc = -EINVAL, opt;
865
866         lock_sock(sk);
867         if (unlikely(level != SOL_LLC || optlen != sizeof(int)))
868                 goto out;
869         rc = get_user(opt, (int __user *)optval);
870         if (rc)
871                 goto out;
872         rc = -EINVAL;
873         switch (optname) {
874         case LLC_OPT_RETRY:
875                 if (opt > LLC_OPT_MAX_RETRY)
876                         goto out;
877                 llc->n2 = opt;
878                 break;
879         case LLC_OPT_SIZE:
880                 if (opt > LLC_OPT_MAX_SIZE)
881                         goto out;
882                 llc->n1 = opt;
883                 break;
884         case LLC_OPT_ACK_TMR_EXP:
885                 if (opt > LLC_OPT_MAX_ACK_TMR_EXP)
886                         goto out;
887                 llc->ack_timer.expire = opt * HZ;
888                 break;
889         case LLC_OPT_P_TMR_EXP:
890                 if (opt > LLC_OPT_MAX_P_TMR_EXP)
891                         goto out;
892                 llc->pf_cycle_timer.expire = opt * HZ;
893                 break;
894         case LLC_OPT_REJ_TMR_EXP:
895                 if (opt > LLC_OPT_MAX_REJ_TMR_EXP)
896                         goto out;
897                 llc->rej_sent_timer.expire = opt * HZ;
898                 break;
899         case LLC_OPT_BUSY_TMR_EXP:
900                 if (opt > LLC_OPT_MAX_BUSY_TMR_EXP)
901                         goto out;
902                 llc->busy_state_timer.expire = opt * HZ;
903                 break;
904         case LLC_OPT_TX_WIN:
905                 if (opt > LLC_OPT_MAX_WIN)
906                         goto out;
907                 llc->k = opt;
908                 break;
909         case LLC_OPT_RX_WIN:
910                 if (opt > LLC_OPT_MAX_WIN)
911                         goto out;
912                 llc->rw = opt;
913                 break;
914         default:
915                 rc = -ENOPROTOOPT;
916                 goto out;
917         }
918         rc = 0;
919 out:
920         release_sock(sk);
921         return rc;
922 }
923
924 /**
925  *      llc_ui_getsockopt - get connection specific socket info
926  *      @sock: Socket to get information from.
927  *      @level: Socket level user is requesting operations on.
928  *      @optname: Operation name.
929  *      @optval: Variable to return operation data in.
930  *      @optlen: Length of optval.
931  *
932  *      Get connection specific socket information.
933  */
934 static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
935                              char __user *optval, int __user *optlen)
936 {
937         struct sock *sk = sock->sk;
938         struct llc_sock *llc = llc_sk(sk);
939         int val = 0, len = 0, rc = -EINVAL;
940
941         lock_sock(sk);
942         if (unlikely(level != SOL_LLC))
943                 goto out;
944         rc = get_user(len, optlen);
945         if (rc)
946                 goto out;
947         rc = -EINVAL;
948         if (len != sizeof(int))
949                 goto out;
950         switch (optname) {
951         case LLC_OPT_RETRY:
952                 val = llc->n2;                                  break;
953         case LLC_OPT_SIZE:
954                 val = llc->n1;                                  break;
955         case LLC_OPT_ACK_TMR_EXP:
956                 val = llc->ack_timer.expire / HZ;               break;
957         case LLC_OPT_P_TMR_EXP:
958                 val = llc->pf_cycle_timer.expire / HZ;          break;
959         case LLC_OPT_REJ_TMR_EXP:
960                 val = llc->rej_sent_timer.expire / HZ;          break;
961         case LLC_OPT_BUSY_TMR_EXP:
962                 val = llc->busy_state_timer.expire / HZ;        break;
963         case LLC_OPT_TX_WIN:
964                 val = llc->k;                           break;
965         case LLC_OPT_RX_WIN:
966                 val = llc->rw;                          break;
967         default:
968                 rc = -ENOPROTOOPT;
969                 goto out;
970         }
971         rc = 0;
972         if (put_user(len, optlen) || copy_to_user(optval, &val, len))
973                 rc = -EFAULT;
974 out:
975         release_sock(sk);
976         return rc;
977 }
978
979 static struct net_proto_family llc_ui_family_ops = {
980         .family = PF_LLC,
981         .create = llc_ui_create,
982         .owner  = THIS_MODULE,
983 };
984
985 static struct proto_ops llc_ui_ops = {
986         .family      = PF_LLC,
987         .owner       = THIS_MODULE,
988         .release     = llc_ui_release,
989         .bind        = llc_ui_bind,
990         .connect     = llc_ui_connect,
991         .socketpair  = sock_no_socketpair,
992         .accept      = llc_ui_accept,
993         .getname     = llc_ui_getname,
994         .poll        = datagram_poll,
995         .ioctl       = llc_ui_ioctl,
996         .listen      = llc_ui_listen,
997         .shutdown    = llc_ui_shutdown,
998         .setsockopt  = llc_ui_setsockopt,
999         .getsockopt  = llc_ui_getsockopt,
1000         .sendmsg     = llc_ui_sendmsg,
1001         .recvmsg     = llc_ui_recvmsg,
1002         .mmap        = sock_no_mmap,
1003         .sendpage    = sock_no_sendpage,
1004 };
1005
1006 static char llc_proc_err_msg[] __initdata =
1007         KERN_CRIT "LLC: Unable to register the proc_fs entries\n";
1008 static char llc_sysctl_err_msg[] __initdata =
1009         KERN_CRIT "LLC: Unable to register the sysctl entries\n";
1010 static char llc_sock_err_msg[] __initdata =
1011         KERN_CRIT "LLC: Unable to register the network family\n";
1012
1013 static int __init llc2_init(void)
1014 {
1015         int rc = proto_register(&llc_proto, 0);
1016
1017         if (rc != 0)
1018                 goto out;
1019
1020         llc_build_offset_table();
1021         llc_station_init();
1022         llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
1023         rc = llc_proc_init();
1024         if (rc != 0) {
1025                 printk(llc_proc_err_msg);
1026                 goto out_unregister_llc_proto;
1027         }
1028         rc = llc_sysctl_init();
1029         if (rc) {
1030                 printk(llc_sysctl_err_msg);
1031                 goto out_proc;
1032         }
1033         rc = sock_register(&llc_ui_family_ops);
1034         if (rc) {
1035                 printk(llc_sock_err_msg);
1036                 goto out_sysctl;
1037         }
1038         llc_add_pack(LLC_DEST_SAP, llc_sap_handler);
1039         llc_add_pack(LLC_DEST_CONN, llc_conn_handler);
1040 out:
1041         return rc;
1042 out_sysctl:
1043         llc_sysctl_exit();
1044 out_proc:
1045         llc_proc_exit();
1046 out_unregister_llc_proto:
1047         proto_unregister(&llc_proto);
1048         goto out;
1049 }
1050
1051 static void __exit llc2_exit(void)
1052 {
1053         llc_station_exit();
1054         llc_remove_pack(LLC_DEST_SAP);
1055         llc_remove_pack(LLC_DEST_CONN);
1056         sock_unregister(PF_LLC);
1057         llc_proc_exit();
1058         llc_sysctl_exit();
1059         proto_unregister(&llc_proto);
1060 }
1061
1062 module_init(llc2_init);
1063 module_exit(llc2_exit);
1064
1065 MODULE_LICENSE("GPL");
1066 MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
1067 MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
1068 MODULE_ALIAS_NETPROTO(PF_LLC);