1
2
3
4
5
6
7#define pr_fmt(fmt) KBUILD_MODNAME ":%s(): " fmt, __func__
8
9#include <linux/fs.h>
10#include <linux/init.h>
11#include <linux/module.h>
12#include <linux/sched.h>
13#include <linux/spinlock.h>
14#include <linux/mutex.h>
15#include <linux/list.h>
16#include <linux/wait.h>
17#include <linux/poll.h>
18#include <linux/tcp.h>
19#include <linux/uaccess.h>
20#include <linux/debugfs.h>
21#include <linux/caif/caif_socket.h>
22#include <linux/pkt_sched.h>
23#include <net/sock.h>
24#include <net/tcp_states.h>
25#include <net/caif/caif_layer.h>
26#include <net/caif/caif_dev.h>
27#include <net/caif/cfpkt.h>
28
29MODULE_LICENSE("GPL");
30MODULE_ALIAS_NETPROTO(AF_CAIF);
31
32
33
34
35
36
37enum caif_states {
38 CAIF_CONNECTED = TCP_ESTABLISHED,
39 CAIF_CONNECTING = TCP_SYN_SENT,
40 CAIF_DISCONNECTED = TCP_CLOSE
41};
42
43#define TX_FLOW_ON_BIT 1
44#define RX_FLOW_ON_BIT 2
45
46struct caifsock {
47 struct sock sk;
48 struct cflayer layer;
49 u32 flow_state;
50 struct caif_connect_request conn_req;
51 struct mutex readlock;
52 struct dentry *debugfs_socket_dir;
53 int headroom, tailroom, maxframe;
54};
55
56static int rx_flow_is_on(struct caifsock *cf_sk)
57{
58 return test_bit(RX_FLOW_ON_BIT,
59 (void *) &cf_sk->flow_state);
60}
61
62static int tx_flow_is_on(struct caifsock *cf_sk)
63{
64 return test_bit(TX_FLOW_ON_BIT,
65 (void *) &cf_sk->flow_state);
66}
67
68static void set_rx_flow_off(struct caifsock *cf_sk)
69{
70 clear_bit(RX_FLOW_ON_BIT,
71 (void *) &cf_sk->flow_state);
72}
73
74static void set_rx_flow_on(struct caifsock *cf_sk)
75{
76 set_bit(RX_FLOW_ON_BIT,
77 (void *) &cf_sk->flow_state);
78}
79
80static void set_tx_flow_off(struct caifsock *cf_sk)
81{
82 clear_bit(TX_FLOW_ON_BIT,
83 (void *) &cf_sk->flow_state);
84}
85
86static void set_tx_flow_on(struct caifsock *cf_sk)
87{
88 set_bit(TX_FLOW_ON_BIT,
89 (void *) &cf_sk->flow_state);
90}
91
92static void caif_read_lock(struct sock *sk)
93{
94 struct caifsock *cf_sk;
95 cf_sk = container_of(sk, struct caifsock, sk);
96 mutex_lock(&cf_sk->readlock);
97}
98
99static void caif_read_unlock(struct sock *sk)
100{
101 struct caifsock *cf_sk;
102 cf_sk = container_of(sk, struct caifsock, sk);
103 mutex_unlock(&cf_sk->readlock);
104}
105
106static int sk_rcvbuf_lowwater(struct caifsock *cf_sk)
107{
108
109 return cf_sk->sk.sk_rcvbuf / 4;
110}
111
112static void caif_flow_ctrl(struct sock *sk, int mode)
113{
114 struct caifsock *cf_sk;
115 cf_sk = container_of(sk, struct caifsock, sk);
116 if (cf_sk->layer.dn && cf_sk->layer.dn->modemcmd)
117 cf_sk->layer.dn->modemcmd(cf_sk->layer.dn, mode);
118}
119
120
121
122
123
124static int caif_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
125{
126 int err;
127 int skb_len;
128 unsigned long flags;
129 struct sk_buff_head *list = &sk->sk_receive_queue;
130 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
131
132 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
133 (unsigned int)sk->sk_rcvbuf && rx_flow_is_on(cf_sk)) {
134 net_dbg_ratelimited("sending flow OFF (queue len = %d %d)\n",
135 atomic_read(&cf_sk->sk.sk_rmem_alloc),
136 sk_rcvbuf_lowwater(cf_sk));
137 set_rx_flow_off(cf_sk);
138 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
139 }
140
141 err = sk_filter(sk, skb);
142 if (err)
143 return err;
144 if (!sk_rmem_schedule(sk, skb, skb->truesize) && rx_flow_is_on(cf_sk)) {
145 set_rx_flow_off(cf_sk);
146 net_dbg_ratelimited("sending flow OFF due to rmem_schedule\n");
147 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_OFF_REQ);
148 }
149 skb->dev = NULL;
150 skb_set_owner_r(skb, sk);
151
152
153
154
155
156 skb_len = skb->len;
157 spin_lock_irqsave(&list->lock, flags);
158 if (!sock_flag(sk, SOCK_DEAD))
159 __skb_queue_tail(list, skb);
160 spin_unlock_irqrestore(&list->lock, flags);
161
162 if (!sock_flag(sk, SOCK_DEAD))
163 sk->sk_data_ready(sk, skb_len);
164 else
165 kfree_skb(skb);
166 return 0;
167}
168
169
170static int caif_sktrecv_cb(struct cflayer *layr, struct cfpkt *pkt)
171{
172 struct caifsock *cf_sk;
173 struct sk_buff *skb;
174
175 cf_sk = container_of(layr, struct caifsock, layer);
176 skb = cfpkt_tonative(pkt);
177
178 if (unlikely(cf_sk->sk.sk_state != CAIF_CONNECTED)) {
179 kfree_skb(skb);
180 return 0;
181 }
182 caif_queue_rcv_skb(&cf_sk->sk, skb);
183 return 0;
184}
185
186static void cfsk_hold(struct cflayer *layr)
187{
188 struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
189 sock_hold(&cf_sk->sk);
190}
191
192static void cfsk_put(struct cflayer *layr)
193{
194 struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
195 sock_put(&cf_sk->sk);
196}
197
198
199static void caif_ctrl_cb(struct cflayer *layr,
200 enum caif_ctrlcmd flow,
201 int phyid)
202{
203 struct caifsock *cf_sk = container_of(layr, struct caifsock, layer);
204 switch (flow) {
205 case CAIF_CTRLCMD_FLOW_ON_IND:
206
207 set_tx_flow_on(cf_sk);
208 cf_sk->sk.sk_state_change(&cf_sk->sk);
209 break;
210
211 case CAIF_CTRLCMD_FLOW_OFF_IND:
212
213 set_tx_flow_off(cf_sk);
214 cf_sk->sk.sk_state_change(&cf_sk->sk);
215 break;
216
217 case CAIF_CTRLCMD_INIT_RSP:
218
219 caif_client_register_refcnt(&cf_sk->layer,
220 cfsk_hold, cfsk_put);
221 cf_sk->sk.sk_state = CAIF_CONNECTED;
222 set_tx_flow_on(cf_sk);
223 cf_sk->sk.sk_shutdown = 0;
224 cf_sk->sk.sk_state_change(&cf_sk->sk);
225 break;
226
227 case CAIF_CTRLCMD_DEINIT_RSP:
228
229 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
230 cf_sk->sk.sk_state_change(&cf_sk->sk);
231 break;
232
233 case CAIF_CTRLCMD_INIT_FAIL_RSP:
234
235 cf_sk->sk.sk_err = ECONNREFUSED;
236 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
237 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
238
239
240
241
242 set_tx_flow_on(cf_sk);
243 cf_sk->sk.sk_state_change(&cf_sk->sk);
244 break;
245
246 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND:
247
248 cf_sk->sk.sk_shutdown = SHUTDOWN_MASK;
249 cf_sk->sk.sk_err = ECONNRESET;
250 set_rx_flow_on(cf_sk);
251 cf_sk->sk.sk_error_report(&cf_sk->sk);
252 break;
253
254 default:
255 pr_debug("Unexpected flow command %d\n", flow);
256 }
257}
258
259static void caif_check_flow_release(struct sock *sk)
260{
261 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
262
263 if (rx_flow_is_on(cf_sk))
264 return;
265
266 if (atomic_read(&sk->sk_rmem_alloc) <= sk_rcvbuf_lowwater(cf_sk)) {
267 set_rx_flow_on(cf_sk);
268 caif_flow_ctrl(sk, CAIF_MODEMCMD_FLOW_ON_REQ);
269 }
270}
271
272
273
274
275
276static int caif_seqpkt_recvmsg(struct kiocb *iocb, struct socket *sock,
277 struct msghdr *m, size_t len, int flags)
278
279{
280 struct sock *sk = sock->sk;
281 struct sk_buff *skb;
282 int ret;
283 int copylen;
284
285 ret = -EOPNOTSUPP;
286 if (m->msg_flags&MSG_OOB)
287 goto read_error;
288
289 m->msg_namelen = 0;
290
291 skb = skb_recv_datagram(sk, flags, 0 , &ret);
292 if (!skb)
293 goto read_error;
294 copylen = skb->len;
295 if (len < copylen) {
296 m->msg_flags |= MSG_TRUNC;
297 copylen = len;
298 }
299
300 ret = skb_copy_datagram_iovec(skb, 0, m->msg_iov, copylen);
301 if (ret)
302 goto out_free;
303
304 ret = (flags & MSG_TRUNC) ? skb->len : copylen;
305out_free:
306 skb_free_datagram(sk, skb);
307 caif_check_flow_release(sk);
308 return ret;
309
310read_error:
311 return ret;
312}
313
314
315
316static long caif_stream_data_wait(struct sock *sk, long timeo)
317{
318 DEFINE_WAIT(wait);
319 lock_sock(sk);
320
321 for (;;) {
322 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
323
324 if (!skb_queue_empty(&sk->sk_receive_queue) ||
325 sk->sk_err ||
326 sk->sk_state != CAIF_CONNECTED ||
327 sock_flag(sk, SOCK_DEAD) ||
328 (sk->sk_shutdown & RCV_SHUTDOWN) ||
329 signal_pending(current) ||
330 !timeo)
331 break;
332
333 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
334 release_sock(sk);
335 timeo = schedule_timeout(timeo);
336 lock_sock(sk);
337 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
338 }
339
340 finish_wait(sk_sleep(sk), &wait);
341 release_sock(sk);
342 return timeo;
343}
344
345
346
347
348
349
350static int caif_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
351 struct msghdr *msg, size_t size,
352 int flags)
353{
354 struct sock *sk = sock->sk;
355 int copied = 0;
356 int target;
357 int err = 0;
358 long timeo;
359
360 err = -EOPNOTSUPP;
361 if (flags&MSG_OOB)
362 goto out;
363
364 msg->msg_namelen = 0;
365
366
367
368
369
370 err = -EAGAIN;
371 if (sk->sk_state == CAIF_CONNECTING)
372 goto out;
373
374 caif_read_lock(sk);
375 target = sock_rcvlowat(sk, flags&MSG_WAITALL, size);
376 timeo = sock_rcvtimeo(sk, flags&MSG_DONTWAIT);
377
378 do {
379 int chunk;
380 struct sk_buff *skb;
381
382 lock_sock(sk);
383 skb = skb_dequeue(&sk->sk_receive_queue);
384 caif_check_flow_release(sk);
385
386 if (skb == NULL) {
387 if (copied >= target)
388 goto unlock;
389
390
391
392 err = sock_error(sk);
393 if (err)
394 goto unlock;
395 err = -ECONNRESET;
396 if (sk->sk_shutdown & RCV_SHUTDOWN)
397 goto unlock;
398
399 err = -EPIPE;
400 if (sk->sk_state != CAIF_CONNECTED)
401 goto unlock;
402 if (sock_flag(sk, SOCK_DEAD))
403 goto unlock;
404
405 release_sock(sk);
406
407 err = -EAGAIN;
408 if (!timeo)
409 break;
410
411 caif_read_unlock(sk);
412
413 timeo = caif_stream_data_wait(sk, timeo);
414
415 if (signal_pending(current)) {
416 err = sock_intr_errno(timeo);
417 goto out;
418 }
419 caif_read_lock(sk);
420 continue;
421unlock:
422 release_sock(sk);
423 break;
424 }
425 release_sock(sk);
426 chunk = min_t(unsigned int, skb->len, size);
427 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
428 skb_queue_head(&sk->sk_receive_queue, skb);
429 if (copied == 0)
430 copied = -EFAULT;
431 break;
432 }
433 copied += chunk;
434 size -= chunk;
435
436
437 if (!(flags & MSG_PEEK)) {
438 skb_pull(skb, chunk);
439
440
441 if (skb->len) {
442 skb_queue_head(&sk->sk_receive_queue, skb);
443 break;
444 }
445 kfree_skb(skb);
446
447 } else {
448
449
450
451
452 skb_queue_head(&sk->sk_receive_queue, skb);
453 break;
454 }
455 } while (size);
456 caif_read_unlock(sk);
457
458out:
459 return copied ? : err;
460}
461
462
463
464
465
466static long caif_wait_for_flow_on(struct caifsock *cf_sk,
467 int wait_writeable, long timeo, int *err)
468{
469 struct sock *sk = &cf_sk->sk;
470 DEFINE_WAIT(wait);
471 for (;;) {
472 *err = 0;
473 if (tx_flow_is_on(cf_sk) &&
474 (!wait_writeable || sock_writeable(&cf_sk->sk)))
475 break;
476 *err = -ETIMEDOUT;
477 if (!timeo)
478 break;
479 *err = -ERESTARTSYS;
480 if (signal_pending(current))
481 break;
482 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
483 *err = -ECONNRESET;
484 if (sk->sk_shutdown & SHUTDOWN_MASK)
485 break;
486 *err = -sk->sk_err;
487 if (sk->sk_err)
488 break;
489 *err = -EPIPE;
490 if (cf_sk->sk.sk_state != CAIF_CONNECTED)
491 break;
492 timeo = schedule_timeout(timeo);
493 }
494 finish_wait(sk_sleep(sk), &wait);
495 return timeo;
496}
497
498
499
500
501
502static int transmit_skb(struct sk_buff *skb, struct caifsock *cf_sk,
503 int noblock, long timeo)
504{
505 struct cfpkt *pkt;
506
507 pkt = cfpkt_fromnative(CAIF_DIR_OUT, skb);
508 memset(skb->cb, 0, sizeof(struct caif_payload_info));
509 cfpkt_set_prio(pkt, cf_sk->sk.sk_priority);
510
511 if (cf_sk->layer.dn == NULL) {
512 kfree_skb(skb);
513 return -EINVAL;
514 }
515
516 return cf_sk->layer.dn->transmit(cf_sk->layer.dn, pkt);
517}
518
519
520static int caif_seqpkt_sendmsg(struct kiocb *kiocb, struct socket *sock,
521 struct msghdr *msg, size_t len)
522{
523 struct sock *sk = sock->sk;
524 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
525 int buffer_size;
526 int ret = 0;
527 struct sk_buff *skb = NULL;
528 int noblock;
529 long timeo;
530 caif_assert(cf_sk);
531 ret = sock_error(sk);
532 if (ret)
533 goto err;
534
535 ret = -EOPNOTSUPP;
536 if (msg->msg_flags&MSG_OOB)
537 goto err;
538
539 ret = -EOPNOTSUPP;
540 if (msg->msg_namelen)
541 goto err;
542
543 ret = -EINVAL;
544 if (unlikely(msg->msg_iov->iov_base == NULL))
545 goto err;
546 noblock = msg->msg_flags & MSG_DONTWAIT;
547
548 timeo = sock_sndtimeo(sk, noblock);
549 timeo = caif_wait_for_flow_on(container_of(sk, struct caifsock, sk),
550 1, timeo, &ret);
551
552 if (ret)
553 goto err;
554 ret = -EPIPE;
555 if (cf_sk->sk.sk_state != CAIF_CONNECTED ||
556 sock_flag(sk, SOCK_DEAD) ||
557 (sk->sk_shutdown & RCV_SHUTDOWN))
558 goto err;
559
560
561 ret = -EMSGSIZE;
562 if (len > cf_sk->maxframe && cf_sk->sk.sk_protocol != CAIFPROTO_RFM)
563 goto err;
564
565 buffer_size = len + cf_sk->headroom + cf_sk->tailroom;
566
567 ret = -ENOMEM;
568 skb = sock_alloc_send_skb(sk, buffer_size, noblock, &ret);
569
570 if (!skb || skb_tailroom(skb) < buffer_size)
571 goto err;
572
573 skb_reserve(skb, cf_sk->headroom);
574
575 ret = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
576
577 if (ret)
578 goto err;
579 ret = transmit_skb(skb, cf_sk, noblock, timeo);
580 if (ret < 0)
581
582 return ret;
583
584 return len;
585err:
586 kfree_skb(skb);
587 return ret;
588}
589
590
591
592
593
594
595static int caif_stream_sendmsg(struct kiocb *kiocb, struct socket *sock,
596 struct msghdr *msg, size_t len)
597{
598 struct sock *sk = sock->sk;
599 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
600 int err, size;
601 struct sk_buff *skb;
602 int sent = 0;
603 long timeo;
604
605 err = -EOPNOTSUPP;
606 if (unlikely(msg->msg_flags&MSG_OOB))
607 goto out_err;
608
609 if (unlikely(msg->msg_namelen))
610 goto out_err;
611
612 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
613 timeo = caif_wait_for_flow_on(cf_sk, 1, timeo, &err);
614
615 if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
616 goto pipe_err;
617
618 while (sent < len) {
619
620 size = len-sent;
621
622 if (size > cf_sk->maxframe)
623 size = cf_sk->maxframe;
624
625
626 if (size > ((sk->sk_sndbuf >> 1) - 64))
627 size = (sk->sk_sndbuf >> 1) - 64;
628
629 if (size > SKB_MAX_ALLOC)
630 size = SKB_MAX_ALLOC;
631
632 skb = sock_alloc_send_skb(sk,
633 size + cf_sk->headroom +
634 cf_sk->tailroom,
635 msg->msg_flags&MSG_DONTWAIT,
636 &err);
637 if (skb == NULL)
638 goto out_err;
639
640 skb_reserve(skb, cf_sk->headroom);
641
642
643
644
645
646
647
648 size = min_t(int, size, skb_tailroom(skb));
649
650 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
651 if (err) {
652 kfree_skb(skb);
653 goto out_err;
654 }
655 err = transmit_skb(skb, cf_sk,
656 msg->msg_flags&MSG_DONTWAIT, timeo);
657 if (err < 0)
658
659 goto pipe_err;
660
661 sent += size;
662 }
663
664 return sent;
665
666pipe_err:
667 if (sent == 0 && !(msg->msg_flags&MSG_NOSIGNAL))
668 send_sig(SIGPIPE, current, 0);
669 err = -EPIPE;
670out_err:
671 return sent ? : err;
672}
673
674static int setsockopt(struct socket *sock,
675 int lvl, int opt, char __user *ov, unsigned int ol)
676{
677 struct sock *sk = sock->sk;
678 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
679 int linksel;
680
681 if (cf_sk->sk.sk_socket->state != SS_UNCONNECTED)
682 return -ENOPROTOOPT;
683
684 switch (opt) {
685 case CAIFSO_LINK_SELECT:
686 if (ol < sizeof(int))
687 return -EINVAL;
688 if (lvl != SOL_CAIF)
689 goto bad_sol;
690 if (copy_from_user(&linksel, ov, sizeof(int)))
691 return -EINVAL;
692 lock_sock(&(cf_sk->sk));
693 cf_sk->conn_req.link_selector = linksel;
694 release_sock(&cf_sk->sk);
695 return 0;
696
697 case CAIFSO_REQ_PARAM:
698 if (lvl != SOL_CAIF)
699 goto bad_sol;
700 if (cf_sk->sk.sk_protocol != CAIFPROTO_UTIL)
701 return -ENOPROTOOPT;
702 lock_sock(&(cf_sk->sk));
703 if (ol > sizeof(cf_sk->conn_req.param.data) ||
704 copy_from_user(&cf_sk->conn_req.param.data, ov, ol)) {
705 release_sock(&cf_sk->sk);
706 return -EINVAL;
707 }
708 cf_sk->conn_req.param.size = ol;
709 release_sock(&cf_sk->sk);
710 return 0;
711
712 default:
713 return -ENOPROTOOPT;
714 }
715
716 return 0;
717bad_sol:
718 return -ENOPROTOOPT;
719
720}
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746static int caif_connect(struct socket *sock, struct sockaddr *uaddr,
747 int addr_len, int flags)
748{
749 struct sock *sk = sock->sk;
750 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
751 long timeo;
752 int err;
753 int ifindex, headroom, tailroom;
754 unsigned int mtu;
755 struct net_device *dev;
756
757 lock_sock(sk);
758
759 err = -EAFNOSUPPORT;
760 if (uaddr->sa_family != AF_CAIF)
761 goto out;
762
763 switch (sock->state) {
764 case SS_UNCONNECTED:
765
766 caif_assert(sk->sk_state == CAIF_DISCONNECTED);
767 break;
768 case SS_CONNECTING:
769 switch (sk->sk_state) {
770 case CAIF_CONNECTED:
771 sock->state = SS_CONNECTED;
772 err = -EISCONN;
773 goto out;
774 case CAIF_DISCONNECTED:
775
776 break;
777 case CAIF_CONNECTING:
778 err = -EALREADY;
779 if (flags & O_NONBLOCK)
780 goto out;
781 goto wait_connect;
782 }
783 break;
784 case SS_CONNECTED:
785 caif_assert(sk->sk_state == CAIF_CONNECTED ||
786 sk->sk_state == CAIF_DISCONNECTED);
787 if (sk->sk_shutdown & SHUTDOWN_MASK) {
788
789 caif_disconnect_client(sock_net(sk), &cf_sk->layer);
790 caif_free_client(&cf_sk->layer);
791 break;
792 }
793
794 err = -EISCONN;
795 goto out;
796 case SS_DISCONNECTING:
797 case SS_FREE:
798 caif_assert(1);
799 break;
800 }
801 sk->sk_state = CAIF_DISCONNECTED;
802 sock->state = SS_UNCONNECTED;
803 sk_stream_kill_queues(&cf_sk->sk);
804
805 err = -EINVAL;
806 if (addr_len != sizeof(struct sockaddr_caif))
807 goto out;
808
809 memcpy(&cf_sk->conn_req.sockaddr, uaddr,
810 sizeof(struct sockaddr_caif));
811
812
813 sock->state = SS_CONNECTING;
814 sk->sk_state = CAIF_CONNECTING;
815
816
817
818 if (cf_sk->sk.sk_priority > CAIF_PRIO_MAX)
819 cf_sk->conn_req.priority = CAIF_PRIO_MAX;
820 else if (cf_sk->sk.sk_priority < CAIF_PRIO_MIN)
821 cf_sk->conn_req.priority = CAIF_PRIO_MIN;
822 else
823 cf_sk->conn_req.priority = cf_sk->sk.sk_priority;
824
825
826 cf_sk->conn_req.ifindex = cf_sk->sk.sk_bound_dev_if;
827
828 cf_sk->layer.receive = caif_sktrecv_cb;
829
830 err = caif_connect_client(sock_net(sk), &cf_sk->conn_req,
831 &cf_sk->layer, &ifindex, &headroom, &tailroom);
832
833 if (err < 0) {
834 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
835 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
836 goto out;
837 }
838
839 err = -ENODEV;
840 rcu_read_lock();
841 dev = dev_get_by_index_rcu(sock_net(sk), ifindex);
842 if (!dev) {
843 rcu_read_unlock();
844 goto out;
845 }
846 cf_sk->headroom = LL_RESERVED_SPACE_EXTRA(dev, headroom);
847 mtu = dev->mtu;
848 rcu_read_unlock();
849
850 cf_sk->tailroom = tailroom;
851 cf_sk->maxframe = mtu - (headroom + tailroom);
852 if (cf_sk->maxframe < 1) {
853 pr_warn("CAIF Interface MTU too small (%d)\n", dev->mtu);
854 err = -ENODEV;
855 goto out;
856 }
857
858 err = -EINPROGRESS;
859wait_connect:
860
861 if (sk->sk_state != CAIF_CONNECTED && (flags & O_NONBLOCK))
862 goto out;
863
864 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
865
866 release_sock(sk);
867 err = -ERESTARTSYS;
868 timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
869 sk->sk_state != CAIF_CONNECTING,
870 timeo);
871 lock_sock(sk);
872 if (timeo < 0)
873 goto out;
874
875 err = -ETIMEDOUT;
876 if (timeo == 0 && sk->sk_state != CAIF_CONNECTED)
877 goto out;
878 if (sk->sk_state != CAIF_CONNECTED) {
879 sock->state = SS_UNCONNECTED;
880 err = sock_error(sk);
881 if (!err)
882 err = -ECONNREFUSED;
883 goto out;
884 }
885 sock->state = SS_CONNECTED;
886 err = 0;
887out:
888 release_sock(sk);
889 return err;
890}
891
892
893
894
895
896static int caif_release(struct socket *sock)
897{
898 struct sock *sk = sock->sk;
899 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
900
901 if (!sk)
902 return 0;
903
904 set_tx_flow_off(cf_sk);
905
906
907
908
909
910
911 spin_lock_bh(&sk->sk_receive_queue.lock);
912 sock_set_flag(sk, SOCK_DEAD);
913 spin_unlock_bh(&sk->sk_receive_queue.lock);
914 sock->sk = NULL;
915
916 WARN_ON(IS_ERR(cf_sk->debugfs_socket_dir));
917 if (cf_sk->debugfs_socket_dir != NULL)
918 debugfs_remove_recursive(cf_sk->debugfs_socket_dir);
919
920 lock_sock(&(cf_sk->sk));
921 sk->sk_state = CAIF_DISCONNECTED;
922 sk->sk_shutdown = SHUTDOWN_MASK;
923
924 caif_disconnect_client(sock_net(sk), &cf_sk->layer);
925 cf_sk->sk.sk_socket->state = SS_DISCONNECTING;
926 wake_up_interruptible_poll(sk_sleep(sk), POLLERR|POLLHUP);
927
928 sock_orphan(sk);
929 sk_stream_kill_queues(&cf_sk->sk);
930 release_sock(sk);
931 sock_put(sk);
932 return 0;
933}
934
935
936static unsigned int caif_poll(struct file *file,
937 struct socket *sock, poll_table *wait)
938{
939 struct sock *sk = sock->sk;
940 unsigned int mask;
941 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
942
943 sock_poll_wait(file, sk_sleep(sk), wait);
944 mask = 0;
945
946
947 if (sk->sk_err)
948 mask |= POLLERR;
949 if (sk->sk_shutdown == SHUTDOWN_MASK)
950 mask |= POLLHUP;
951 if (sk->sk_shutdown & RCV_SHUTDOWN)
952 mask |= POLLRDHUP;
953
954
955 if (!skb_queue_empty(&sk->sk_receive_queue) ||
956 (sk->sk_shutdown & RCV_SHUTDOWN))
957 mask |= POLLIN | POLLRDNORM;
958
959
960
961
962
963 if (sock_writeable(sk) && tx_flow_is_on(cf_sk))
964 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
965
966 return mask;
967}
968
969static const struct proto_ops caif_seqpacket_ops = {
970 .family = PF_CAIF,
971 .owner = THIS_MODULE,
972 .release = caif_release,
973 .bind = sock_no_bind,
974 .connect = caif_connect,
975 .socketpair = sock_no_socketpair,
976 .accept = sock_no_accept,
977 .getname = sock_no_getname,
978 .poll = caif_poll,
979 .ioctl = sock_no_ioctl,
980 .listen = sock_no_listen,
981 .shutdown = sock_no_shutdown,
982 .setsockopt = setsockopt,
983 .getsockopt = sock_no_getsockopt,
984 .sendmsg = caif_seqpkt_sendmsg,
985 .recvmsg = caif_seqpkt_recvmsg,
986 .mmap = sock_no_mmap,
987 .sendpage = sock_no_sendpage,
988};
989
990static const struct proto_ops caif_stream_ops = {
991 .family = PF_CAIF,
992 .owner = THIS_MODULE,
993 .release = caif_release,
994 .bind = sock_no_bind,
995 .connect = caif_connect,
996 .socketpair = sock_no_socketpair,
997 .accept = sock_no_accept,
998 .getname = sock_no_getname,
999 .poll = caif_poll,
1000 .ioctl = sock_no_ioctl,
1001 .listen = sock_no_listen,
1002 .shutdown = sock_no_shutdown,
1003 .setsockopt = setsockopt,
1004 .getsockopt = sock_no_getsockopt,
1005 .sendmsg = caif_stream_sendmsg,
1006 .recvmsg = caif_stream_recvmsg,
1007 .mmap = sock_no_mmap,
1008 .sendpage = sock_no_sendpage,
1009};
1010
1011
1012static void caif_sock_destructor(struct sock *sk)
1013{
1014 struct caifsock *cf_sk = container_of(sk, struct caifsock, sk);
1015 caif_assert(!atomic_read(&sk->sk_wmem_alloc));
1016 caif_assert(sk_unhashed(sk));
1017 caif_assert(!sk->sk_socket);
1018 if (!sock_flag(sk, SOCK_DEAD)) {
1019 pr_debug("Attempt to release alive CAIF socket: %p\n", sk);
1020 return;
1021 }
1022 sk_stream_kill_queues(&cf_sk->sk);
1023 caif_free_client(&cf_sk->layer);
1024}
1025
1026static int caif_create(struct net *net, struct socket *sock, int protocol,
1027 int kern)
1028{
1029 struct sock *sk = NULL;
1030 struct caifsock *cf_sk = NULL;
1031 static struct proto prot = {.name = "PF_CAIF",
1032 .owner = THIS_MODULE,
1033 .obj_size = sizeof(struct caifsock),
1034 };
1035
1036 if (!capable(CAP_SYS_ADMIN) && !capable(CAP_NET_ADMIN))
1037 return -EPERM;
1038
1039
1040
1041
1042
1043
1044 if (sock->type == SOCK_SEQPACKET)
1045 sock->ops = &caif_seqpacket_ops;
1046 else if (sock->type == SOCK_STREAM)
1047 sock->ops = &caif_stream_ops;
1048 else
1049 return -ESOCKTNOSUPPORT;
1050
1051 if (protocol < 0 || protocol >= CAIFPROTO_MAX)
1052 return -EPROTONOSUPPORT;
1053
1054
1055
1056
1057
1058 sk = sk_alloc(net, PF_CAIF, GFP_KERNEL, &prot);
1059 if (!sk)
1060 return -ENOMEM;
1061
1062 cf_sk = container_of(sk, struct caifsock, sk);
1063
1064
1065 sk->sk_protocol = (unsigned char) protocol;
1066
1067
1068 switch (protocol) {
1069 case CAIFPROTO_AT:
1070 sk->sk_priority = TC_PRIO_CONTROL;
1071 break;
1072 case CAIFPROTO_RFM:
1073 sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
1074 break;
1075 default:
1076 sk->sk_priority = TC_PRIO_BESTEFFORT;
1077 }
1078
1079
1080
1081
1082
1083 lock_sock(&(cf_sk->sk));
1084
1085
1086 sock_init_data(sock, sk);
1087 sk->sk_destruct = caif_sock_destructor;
1088
1089 mutex_init(&cf_sk->readlock);
1090 cf_sk->layer.ctrlcmd = caif_ctrl_cb;
1091 cf_sk->sk.sk_socket->state = SS_UNCONNECTED;
1092 cf_sk->sk.sk_state = CAIF_DISCONNECTED;
1093
1094 set_tx_flow_off(cf_sk);
1095 set_rx_flow_on(cf_sk);
1096
1097
1098 cf_sk->conn_req.link_selector = CAIF_LINK_LOW_LATENCY;
1099 cf_sk->conn_req.protocol = protocol;
1100 release_sock(&cf_sk->sk);
1101 return 0;
1102}
1103
1104
1105static struct net_proto_family caif_family_ops = {
1106 .family = PF_CAIF,
1107 .create = caif_create,
1108 .owner = THIS_MODULE,
1109};
1110
1111static int __init caif_sktinit_module(void)
1112{
1113 int err = sock_register(&caif_family_ops);
1114 if (!err)
1115 return err;
1116 return 0;
1117}
1118
1119static void __exit caif_sktexit_module(void)
1120{
1121 sock_unregister(PF_CAIF);
1122}
1123module_init(caif_sktinit_module);
1124module_exit(caif_sktexit_module);
1125