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