4 * Phonet pipe protocol end point socket
6 * Copyright (C) 2008 Nokia Corporation.
8 * Author: RĂ©mi Denis-Courmont <remi.denis-courmont@nokia.com>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * version 2 as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
25 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/socket.h>
29 #include <net/tcp_states.h>
30 #include <asm/ioctls.h>
32 #include <linux/phonet.h>
33 #include <net/phonet/phonet.h>
34 #include <net/phonet/pep.h>
35 #include <net/phonet/gprs.h>
38 * TCP_CLOSE sock not in use yet
39 * TCP_CLOSE_WAIT disconnected pipe
40 * TCP_LISTEN listening pipe endpoint
41 * TCP_SYN_RECV connected pipe in disabled state
42 * TCP_ESTABLISHED connected pipe in enabled state
45 * - sk_state, ackq, hlist: sock lock needed
46 * - listener: read only
47 * - pipe_handle: read only
50 #define CREDITS_MAX 10
53 static const struct sockaddr_pn pipe_srv
= {
54 .spn_family
= AF_PHONET
,
55 .spn_resource
= 0xD9, /* pipe service */
58 #define pep_sb_size(s) (((s) + 5) & ~3) /* 2-bytes head, 32-bits aligned */
60 /* Get the next TLV sub-block. */
61 static unsigned char *pep_get_sb(struct sk_buff
*skb
, u8
*ptype
, u8
*plen
,
71 ph
= skb_header_pointer(skb
, 0, 2, &h
);
72 if (ph
== NULL
|| ph
->sb_len
< 2 || !pskb_may_pull(skb
, ph
->sb_len
))
78 if (buflen
> ph
->sb_len
)
80 data
= skb_header_pointer(skb
, 2, buflen
, buf
);
81 __skb_pull(skb
, 2 + ph
->sb_len
);
85 static int pep_reply(struct sock
*sk
, struct sk_buff
*oskb
,
86 u8 code
, const void *data
, int len
, gfp_t priority
)
88 const struct pnpipehdr
*oph
= pnp_hdr(oskb
);
92 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ len
, priority
);
95 skb_set_owner_w(skb
, sk
);
97 skb_reserve(skb
, MAX_PNPIPE_HEADER
);
99 skb_copy_to_linear_data(skb
, data
, len
);
100 __skb_push(skb
, sizeof(*ph
));
101 skb_reset_transport_header(skb
);
103 ph
->utid
= oph
->utid
;
104 ph
->message_id
= oph
->message_id
+ 1; /* REQ -> RESP */
105 ph
->pipe_handle
= oph
->pipe_handle
;
106 ph
->error_code
= code
;
108 return pn_skb_send(sk
, skb
, &pipe_srv
);
112 static int pep_accept_conn(struct sock
*sk
, struct sk_buff
*skb
)
114 static const u8 data
[20] = {
115 PAD
, PAD
, PAD
, 2 /* sub-blocks */,
116 PN_PIPE_SB_REQUIRED_FC_TX
, pep_sb_size(5), 3, PAD
,
117 PN_MULTI_CREDIT_FLOW_CONTROL
,
118 PN_ONE_CREDIT_FLOW_CONTROL
,
119 PN_LEGACY_FLOW_CONTROL
,
121 PN_PIPE_SB_PREFERRED_FC_RX
, pep_sb_size(5), 3, PAD
,
122 PN_MULTI_CREDIT_FLOW_CONTROL
,
123 PN_ONE_CREDIT_FLOW_CONTROL
,
124 PN_LEGACY_FLOW_CONTROL
,
129 return pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, data
, sizeof(data
),
133 static int pep_reject_conn(struct sock
*sk
, struct sk_buff
*skb
, u8 code
)
135 static const u8 data
[4] = { PAD
, PAD
, PAD
, 0 /* sub-blocks */ };
136 WARN_ON(code
== PN_PIPE_NO_ERROR
);
137 return pep_reply(sk
, skb
, code
, data
, sizeof(data
), GFP_ATOMIC
);
140 /* Control requests are not sent by the pipe service and have a specific
142 static int pep_ctrlreq_error(struct sock
*sk
, struct sk_buff
*oskb
, u8 code
,
145 const struct pnpipehdr
*oph
= pnp_hdr(oskb
);
147 struct pnpipehdr
*ph
;
148 struct sockaddr_pn dst
;
150 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ 4, priority
);
153 skb_set_owner_w(skb
, sk
);
155 skb_reserve(skb
, MAX_PHONET_HEADER
);
156 ph
= (struct pnpipehdr
*)skb_put(skb
, sizeof(*ph
) + 4);
158 ph
->utid
= oph
->utid
;
159 ph
->message_id
= PNS_PEP_CTRL_RESP
;
160 ph
->pipe_handle
= oph
->pipe_handle
;
161 ph
->data
[0] = oph
->data
[1]; /* CTRL id */
162 ph
->data
[1] = oph
->data
[0]; /* PEP type */
163 ph
->data
[2] = code
; /* error code, at an usual offset */
167 pn_skb_get_src_sockaddr(oskb
, &dst
);
168 return pn_skb_send(sk
, skb
, &dst
);
171 static int pipe_snd_status(struct sock
*sk
, u8 type
, u8 status
, gfp_t priority
)
173 struct pep_sock
*pn
= pep_sk(sk
);
174 struct pnpipehdr
*ph
;
177 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ 4, priority
);
180 skb_set_owner_w(skb
, sk
);
182 skb_reserve(skb
, MAX_PNPIPE_HEADER
+ 4);
183 __skb_push(skb
, sizeof(*ph
) + 4);
184 skb_reset_transport_header(skb
);
187 ph
->message_id
= PNS_PEP_STATUS_IND
;
188 ph
->pipe_handle
= pn
->pipe_handle
;
189 ph
->pep_type
= PN_PEP_TYPE_COMMON
;
193 ph
->data
[4] = status
;
195 return pn_skb_send(sk
, skb
, &pipe_srv
);
198 /* Send our RX flow control information to the sender.
199 * Socket must be locked. */
200 static void pipe_grant_credits(struct sock
*sk
)
202 struct pep_sock
*pn
= pep_sk(sk
);
204 BUG_ON(sk
->sk_state
!= TCP_ESTABLISHED
);
207 case PN_LEGACY_FLOW_CONTROL
: /* TODO */
209 case PN_ONE_CREDIT_FLOW_CONTROL
:
210 pipe_snd_status(sk
, PN_PEP_IND_FLOW_CONTROL
,
211 PEP_IND_READY
, GFP_ATOMIC
);
214 case PN_MULTI_CREDIT_FLOW_CONTROL
:
215 if ((pn
->rx_credits
+ CREDITS_THR
) > CREDITS_MAX
)
217 if (pipe_snd_status(sk
, PN_PEP_IND_ID_MCFC_GRANT_CREDITS
,
218 CREDITS_MAX
- pn
->rx_credits
,
220 pn
->rx_credits
= CREDITS_MAX
;
225 static int pipe_rcv_status(struct sock
*sk
, struct sk_buff
*skb
)
227 struct pep_sock
*pn
= pep_sk(sk
);
228 struct pnpipehdr
*hdr
;
231 if (!pskb_may_pull(skb
, sizeof(*hdr
) + 4))
235 if (hdr
->data
[0] != PN_PEP_TYPE_COMMON
) {
236 LIMIT_NETDEBUG(KERN_DEBUG
"Phonet unknown PEP type: %u\n",
237 (unsigned)hdr
->data
[0]);
241 switch (hdr
->data
[1]) {
242 case PN_PEP_IND_FLOW_CONTROL
:
244 case PN_LEGACY_FLOW_CONTROL
:
245 switch (hdr
->data
[4]) {
247 atomic_set(&pn
->tx_credits
, 0);
250 atomic_set(&pn
->tx_credits
, wake
= 1);
254 case PN_ONE_CREDIT_FLOW_CONTROL
:
255 if (hdr
->data
[4] == PEP_IND_READY
)
256 atomic_set(&pn
->tx_credits
, wake
= 1);
261 case PN_PEP_IND_ID_MCFC_GRANT_CREDITS
:
262 if (pn
->tx_fc
!= PN_MULTI_CREDIT_FLOW_CONTROL
)
264 atomic_add(wake
= hdr
->data
[4], &pn
->tx_credits
);
268 LIMIT_NETDEBUG(KERN_DEBUG
"Phonet unknown PEP indication: %u\n",
269 (unsigned)hdr
->data
[1]);
273 sk
->sk_write_space(sk
);
277 static int pipe_rcv_created(struct sock
*sk
, struct sk_buff
*skb
)
279 struct pep_sock
*pn
= pep_sk(sk
);
280 struct pnpipehdr
*hdr
= pnp_hdr(skb
);
281 u8 n_sb
= hdr
->data
[0];
283 pn
->rx_fc
= pn
->tx_fc
= PN_LEGACY_FLOW_CONTROL
;
284 __skb_pull(skb
, sizeof(*hdr
));
286 u8 type
, buf
[2], len
= sizeof(buf
);
287 u8
*data
= pep_get_sb(skb
, &type
, &len
, buf
);
292 case PN_PIPE_SB_NEGOTIATED_FC
:
293 if (len
< 2 || (data
[0] | data
[1]) > 3)
295 pn
->tx_fc
= data
[0] & 3;
296 pn
->rx_fc
= data
[1] & 3;
304 /* Queue an skb to a connected sock.
305 * Socket lock must be held. */
306 static int pipe_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
308 struct pep_sock
*pn
= pep_sk(sk
);
309 struct pnpipehdr
*hdr
= pnp_hdr(skb
);
310 struct sk_buff_head
*queue
;
313 BUG_ON(sk
->sk_state
== TCP_CLOSE_WAIT
);
315 switch (hdr
->message_id
) {
316 case PNS_PEP_CONNECT_REQ
:
317 pep_reject_conn(sk
, skb
, PN_PIPE_ERR_PEP_IN_USE
);
320 case PNS_PEP_DISCONNECT_REQ
:
321 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
322 sk
->sk_state
= TCP_CLOSE_WAIT
;
323 if (!sock_flag(sk
, SOCK_DEAD
))
324 sk
->sk_state_change(sk
);
327 case PNS_PEP_ENABLE_REQ
:
328 /* Wait for PNS_PIPE_(ENABLED|REDIRECTED)_IND */
329 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
332 case PNS_PEP_RESET_REQ
:
333 switch (hdr
->state_after_reset
) {
334 case PN_PIPE_DISABLE
:
340 default: /* not allowed to send an error here!? */
345 case PNS_PEP_DISABLE_REQ
:
346 atomic_set(&pn
->tx_credits
, 0);
347 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
350 case PNS_PEP_CTRL_REQ
:
351 if (skb_queue_len(&pn
->ctrlreq_queue
) >= PNPIPE_CTRLREQ_MAX
) {
352 atomic_inc(&sk
->sk_drops
);
356 queue
= &pn
->ctrlreq_queue
;
359 case PNS_PIPE_ALIGNED_DATA
:
363 __skb_pull(skb
, 3); /* Pipe data header */
364 if (!pn_flow_safe(pn
->rx_fc
)) {
365 err
= sock_queue_rcv_skb(sk
, skb
);
371 if (pn
->rx_credits
== 0) {
372 atomic_inc(&sk
->sk_drops
);
377 queue
= &sk
->sk_receive_queue
;
380 case PNS_PEP_STATUS_IND
:
381 pipe_rcv_status(sk
, skb
);
384 case PNS_PIPE_REDIRECTED_IND
:
385 err
= pipe_rcv_created(sk
, skb
);
388 case PNS_PIPE_CREATED_IND
:
389 err
= pipe_rcv_created(sk
, skb
);
393 case PNS_PIPE_RESET_IND
:
394 if (!pn
->init_enable
)
397 case PNS_PIPE_ENABLED_IND
:
398 if (!pn_flow_safe(pn
->tx_fc
)) {
399 atomic_set(&pn
->tx_credits
, 1);
400 sk
->sk_write_space(sk
);
402 if (sk
->sk_state
== TCP_ESTABLISHED
)
403 break; /* Nothing to do */
404 sk
->sk_state
= TCP_ESTABLISHED
;
405 pipe_grant_credits(sk
);
408 case PNS_PIPE_DISABLED_IND
:
409 sk
->sk_state
= TCP_SYN_RECV
;
414 LIMIT_NETDEBUG(KERN_DEBUG
"Phonet unknown PEP message: %u\n",
424 skb_set_owner_r(skb
, sk
);
426 skb_queue_tail(queue
, skb
);
427 if (!sock_flag(sk
, SOCK_DEAD
))
428 sk
->sk_data_ready(sk
, err
);
432 /* Destroy connected sock. */
433 static void pipe_destruct(struct sock
*sk
)
435 struct pep_sock
*pn
= pep_sk(sk
);
437 skb_queue_purge(&sk
->sk_receive_queue
);
438 skb_queue_purge(&pn
->ctrlreq_queue
);
441 static int pep_connreq_rcv(struct sock
*sk
, struct sk_buff
*skb
)
444 struct pep_sock
*newpn
, *pn
= pep_sk(sk
);
445 struct pnpipehdr
*hdr
;
446 struct sockaddr_pn dst
;
448 u8 pipe_handle
, enabled
, n_sb
;
451 if (!pskb_pull(skb
, sizeof(*hdr
) + 4))
455 pipe_handle
= hdr
->pipe_handle
;
456 switch (hdr
->state_after_connect
) {
457 case PN_PIPE_DISABLE
:
464 pep_reject_conn(sk
, skb
, PN_PIPE_ERR_INVALID_PARAM
);
467 peer_type
= hdr
->other_pep_type
<< 8;
469 if (unlikely(sk
->sk_state
!= TCP_LISTEN
) || sk_acceptq_is_full(sk
)) {
470 pep_reject_conn(sk
, skb
, PN_PIPE_ERR_PEP_IN_USE
);
474 /* Parse sub-blocks (options) */
477 u8 type
, buf
[1], len
= sizeof(buf
);
478 const u8
*data
= pep_get_sb(skb
, &type
, &len
, buf
);
483 case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE
:
486 peer_type
= (peer_type
& 0xff00) | data
[0];
488 case PN_PIPE_SB_ALIGNED_DATA
:
489 aligned
= data
[0] != 0;
495 skb
= skb_clone(skb
, GFP_ATOMIC
);
499 /* Create a new to-be-accepted sock */
500 newsk
= sk_alloc(sock_net(sk
), PF_PHONET
, GFP_ATOMIC
, sk
->sk_prot
);
505 sock_init_data(NULL
, newsk
);
506 newsk
->sk_state
= TCP_SYN_RECV
;
507 newsk
->sk_backlog_rcv
= pipe_do_rcv
;
508 newsk
->sk_protocol
= sk
->sk_protocol
;
509 newsk
->sk_destruct
= pipe_destruct
;
511 newpn
= pep_sk(newsk
);
512 pn_skb_get_dst_sockaddr(skb
, &dst
);
513 newpn
->pn_sk
.sobject
= pn_sockaddr_get_object(&dst
);
514 newpn
->pn_sk
.resource
= pn
->pn_sk
.resource
;
515 skb_queue_head_init(&newpn
->ctrlreq_queue
);
516 newpn
->pipe_handle
= pipe_handle
;
517 atomic_set(&newpn
->tx_credits
, 0);
518 newpn
->peer_type
= peer_type
;
519 newpn
->rx_credits
= 0;
520 newpn
->rx_fc
= newpn
->tx_fc
= PN_LEGACY_FLOW_CONTROL
;
521 newpn
->init_enable
= enabled
;
522 newpn
->aligned
= aligned
;
524 BUG_ON(!skb_queue_empty(&newsk
->sk_receive_queue
));
525 skb_queue_head(&newsk
->sk_receive_queue
, skb
);
526 if (!sock_flag(sk
, SOCK_DEAD
))
527 sk
->sk_data_ready(sk
, 0);
529 sk_acceptq_added(sk
);
530 sk_add_node(newsk
, &pn
->ackq
);
534 /* Listening sock must be locked */
535 static struct sock
*pep_find_pipe(const struct hlist_head
*hlist
,
536 const struct sockaddr_pn
*dst
,
539 struct hlist_node
*node
;
541 u16 dobj
= pn_sockaddr_get_object(dst
);
543 sk_for_each(sknode
, node
, hlist
) {
544 struct pep_sock
*pnnode
= pep_sk(sknode
);
546 /* Ports match, but addresses might not: */
547 if (pnnode
->pn_sk
.sobject
!= dobj
)
549 if (pnnode
->pipe_handle
!= pipe_handle
)
551 if (sknode
->sk_state
== TCP_CLOSE_WAIT
)
561 * Deliver an skb to a listening sock.
562 * Socket lock must be held.
563 * We then queue the skb to the right connected sock (if any).
565 static int pep_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
567 struct pep_sock
*pn
= pep_sk(sk
);
569 struct pnpipehdr
*hdr
;
570 struct sockaddr_pn dst
;
571 int err
= NET_RX_SUCCESS
;
574 if (!pskb_may_pull(skb
, sizeof(*hdr
)))
578 pipe_handle
= hdr
->pipe_handle
;
579 if (pipe_handle
== PN_PIPE_INVALID_HANDLE
)
582 pn_skb_get_dst_sockaddr(skb
, &dst
);
584 /* Look for an existing pipe handle */
585 sknode
= pep_find_pipe(&pn
->hlist
, &dst
, pipe_handle
);
587 return sk_receive_skb(sknode
, skb
, 1);
589 /* Look for a pipe handle pending accept */
590 sknode
= pep_find_pipe(&pn
->ackq
, &dst
, pipe_handle
);
594 printk(KERN_WARNING
"Phonet unconnected PEP ignored");
599 switch (hdr
->message_id
) {
600 case PNS_PEP_CONNECT_REQ
:
601 err
= pep_connreq_rcv(sk
, skb
);
604 case PNS_PEP_DISCONNECT_REQ
:
605 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
608 case PNS_PEP_CTRL_REQ
:
609 pep_ctrlreq_error(sk
, skb
, PN_PIPE_INVALID_HANDLE
, GFP_ATOMIC
);
612 case PNS_PEP_RESET_REQ
:
613 case PNS_PEP_ENABLE_REQ
:
614 case PNS_PEP_DISABLE_REQ
:
615 /* invalid handle is not even allowed here! */
624 /* associated socket ceases to exist */
625 static void pep_sock_close(struct sock
*sk
, long timeout
)
627 struct pep_sock
*pn
= pep_sk(sk
);
630 sock_hold(sk
); /* keep a reference after sk_common_release() */
631 sk_common_release(sk
);
634 if (sk
->sk_state
== TCP_LISTEN
) {
635 /* Destroy the listen queue */
637 struct hlist_node
*p
, *n
;
639 sk_for_each_safe(sknode
, p
, n
, &pn
->ackq
)
640 sk_del_node_init(sknode
);
641 sk
->sk_state
= TCP_CLOSE
;
643 ifindex
= pn
->ifindex
;
652 static int pep_wait_connreq(struct sock
*sk
, int noblock
)
654 struct task_struct
*tsk
= current
;
655 struct pep_sock
*pn
= pep_sk(sk
);
656 long timeo
= sock_rcvtimeo(sk
, noblock
);
661 if (sk
->sk_state
!= TCP_LISTEN
)
663 if (!hlist_empty(&pn
->ackq
))
667 if (signal_pending(tsk
))
668 return sock_intr_errno(timeo
);
670 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
,
673 timeo
= schedule_timeout(timeo
);
675 finish_wait(sk_sleep(sk
), &wait
);
681 static struct sock
*pep_sock_accept(struct sock
*sk
, int flags
, int *errp
)
683 struct pep_sock
*pn
= pep_sk(sk
);
684 struct sock
*newsk
= NULL
;
685 struct sk_buff
*oskb
;
689 err
= pep_wait_connreq(sk
, flags
& O_NONBLOCK
);
693 newsk
= __sk_head(&pn
->ackq
);
695 oskb
= skb_dequeue(&newsk
->sk_receive_queue
);
696 err
= pep_accept_conn(newsk
, oskb
);
698 skb_queue_head(&newsk
->sk_receive_queue
, oskb
);
705 pep_sk(newsk
)->listener
= sk
;
708 sk_del_node_init(newsk
);
709 sk_acceptq_removed(sk
);
710 sk_add_node(newsk
, &pn
->hlist
);
719 static int pep_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
721 struct pep_sock
*pn
= pep_sk(sk
);
726 if (sk
->sk_state
== TCP_LISTEN
)
730 if (sock_flag(sk
, SOCK_URGINLINE
) &&
731 !skb_queue_empty(&pn
->ctrlreq_queue
))
732 answ
= skb_peek(&pn
->ctrlreq_queue
)->len
;
733 else if (!skb_queue_empty(&sk
->sk_receive_queue
))
734 answ
= skb_peek(&sk
->sk_receive_queue
)->len
;
738 return put_user(answ
, (int __user
*)arg
);
744 static int pep_init(struct sock
*sk
)
746 struct pep_sock
*pn
= pep_sk(sk
);
748 INIT_HLIST_HEAD(&pn
->ackq
);
749 INIT_HLIST_HEAD(&pn
->hlist
);
750 skb_queue_head_init(&pn
->ctrlreq_queue
);
751 pn
->pipe_handle
= PN_PIPE_INVALID_HANDLE
;
755 static int pep_setsockopt(struct sock
*sk
, int level
, int optname
,
756 char __user
*optval
, unsigned int optlen
)
758 struct pep_sock
*pn
= pep_sk(sk
);
759 int val
= 0, err
= 0;
761 if (level
!= SOL_PNPIPE
)
763 if (optlen
>= sizeof(int)) {
764 if (get_user(val
, (int __user
*) optval
))
771 if (val
&& val
!= PNPIPE_ENCAP_IP
) {
775 if (!pn
->ifindex
== !val
)
776 break; /* Nothing to do! */
777 if (!capable(CAP_NET_ADMIN
)) {
783 err
= gprs_attach(sk
);
804 static int pep_getsockopt(struct sock
*sk
, int level
, int optname
,
805 char __user
*optval
, int __user
*optlen
)
807 struct pep_sock
*pn
= pep_sk(sk
);
810 if (level
!= SOL_PNPIPE
)
812 if (get_user(len
, optlen
))
817 val
= pn
->ifindex
? PNPIPE_ENCAP_IP
: PNPIPE_ENCAP_NONE
;
826 len
= min_t(unsigned int, sizeof(int), len
);
827 if (put_user(len
, optlen
))
829 if (put_user(val
, (int __user
*) optval
))
834 static int pipe_skb_send(struct sock
*sk
, struct sk_buff
*skb
)
836 struct pep_sock
*pn
= pep_sk(sk
);
837 struct pnpipehdr
*ph
;
839 if (pn_flow_safe(pn
->tx_fc
) &&
840 !atomic_add_unless(&pn
->tx_credits
, -1, 0)) {
845 skb_push(skb
, 3 + pn
->aligned
);
846 skb_reset_transport_header(skb
);
850 ph
->message_id
= PNS_PIPE_ALIGNED_DATA
;
851 ph
->data
[0] = 0; /* padding */
853 ph
->message_id
= PNS_PIPE_DATA
;
854 ph
->pipe_handle
= pn
->pipe_handle
;
856 return pn_skb_send(sk
, skb
, &pipe_srv
);
859 static int pep_sendmsg(struct kiocb
*iocb
, struct sock
*sk
,
860 struct msghdr
*msg
, size_t len
)
862 struct pep_sock
*pn
= pep_sk(sk
);
865 int flags
= msg
->msg_flags
;
868 if ((msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_EOR
|MSG_NOSIGNAL
|
870 !(msg
->msg_flags
& MSG_EOR
))
873 skb
= sock_alloc_send_skb(sk
, MAX_PNPIPE_HEADER
+ len
,
874 flags
& MSG_DONTWAIT
, &err
);
878 skb_reserve(skb
, MAX_PHONET_HEADER
+ 3);
879 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
884 timeo
= sock_sndtimeo(sk
, flags
& MSG_DONTWAIT
);
885 if ((1 << sk
->sk_state
) & (TCPF_LISTEN
|TCPF_CLOSE
)) {
889 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
890 /* Wait until the pipe gets to enabled state */
892 err
= sk_stream_wait_connect(sk
, &timeo
);
896 if (sk
->sk_state
== TCP_CLOSE_WAIT
) {
901 BUG_ON(sk
->sk_state
!= TCP_ESTABLISHED
);
903 /* Wait until flow control allows TX */
904 done
= atomic_read(&pn
->tx_credits
);
912 if (signal_pending(current
)) {
913 err
= sock_intr_errno(timeo
);
917 prepare_to_wait(sk_sleep(sk
), &wait
,
919 done
= sk_wait_event(sk
, &timeo
, atomic_read(&pn
->tx_credits
));
920 finish_wait(sk_sleep(sk
), &wait
);
922 if (sk
->sk_state
!= TCP_ESTABLISHED
)
926 err
= pipe_skb_send(sk
, skb
);
928 err
= len
; /* success! */
937 int pep_writeable(struct sock
*sk
)
939 struct pep_sock
*pn
= pep_sk(sk
);
941 return atomic_read(&pn
->tx_credits
);
944 int pep_write(struct sock
*sk
, struct sk_buff
*skb
)
946 struct sk_buff
*rskb
, *fs
;
949 if (pep_sk(sk
)->aligned
)
950 return pipe_skb_send(sk
, skb
);
952 rskb
= alloc_skb(MAX_PNPIPE_HEADER
, GFP_ATOMIC
);
957 skb_shinfo(rskb
)->frag_list
= skb
;
958 rskb
->len
+= skb
->len
;
959 rskb
->data_len
+= rskb
->len
;
960 rskb
->truesize
+= rskb
->len
;
962 /* Avoid nested fragments */
963 skb_walk_frags(skb
, fs
)
965 skb
->next
= skb_shinfo(skb
)->frag_list
;
966 skb_frag_list_init(skb
);
968 skb
->data_len
-= flen
;
969 skb
->truesize
-= flen
;
971 skb_reserve(rskb
, MAX_PHONET_HEADER
+ 3);
972 return pipe_skb_send(sk
, rskb
);
975 struct sk_buff
*pep_read(struct sock
*sk
)
977 struct sk_buff
*skb
= skb_dequeue(&sk
->sk_receive_queue
);
979 if (sk
->sk_state
== TCP_ESTABLISHED
)
980 pipe_grant_credits(sk
);
984 static int pep_recvmsg(struct kiocb
*iocb
, struct sock
*sk
,
985 struct msghdr
*msg
, size_t len
, int noblock
,
986 int flags
, int *addr_len
)
991 if (flags
& ~(MSG_OOB
|MSG_PEEK
|MSG_TRUNC
|MSG_DONTWAIT
|MSG_WAITALL
|
992 MSG_NOSIGNAL
|MSG_CMSG_COMPAT
))
995 if (unlikely(1 << sk
->sk_state
& (TCPF_LISTEN
| TCPF_CLOSE
)))
998 if ((flags
& MSG_OOB
) || sock_flag(sk
, SOCK_URGINLINE
)) {
999 /* Dequeue and acknowledge control request */
1000 struct pep_sock
*pn
= pep_sk(sk
);
1002 if (flags
& MSG_PEEK
)
1004 skb
= skb_dequeue(&pn
->ctrlreq_queue
);
1006 pep_ctrlreq_error(sk
, skb
, PN_PIPE_NO_ERROR
,
1008 msg
->msg_flags
|= MSG_OOB
;
1011 if (flags
& MSG_OOB
)
1015 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
1018 if (err
== -ENOTCONN
&& sk
->sk_state
== TCP_CLOSE_WAIT
)
1024 if (sk
->sk_state
== TCP_ESTABLISHED
)
1025 pipe_grant_credits(sk
);
1028 msg
->msg_flags
|= MSG_EOR
;
1030 msg
->msg_flags
|= MSG_TRUNC
;
1034 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, len
);
1036 err
= (flags
& MSG_TRUNC
) ? skb
->len
: len
;
1038 skb_free_datagram(sk
, skb
);
1042 static void pep_sock_unhash(struct sock
*sk
)
1044 struct pep_sock
*pn
= pep_sk(sk
);
1045 struct sock
*skparent
= NULL
;
1048 if ((1 << sk
->sk_state
) & ~(TCPF_CLOSE
|TCPF_LISTEN
)) {
1049 skparent
= pn
->listener
;
1052 pn
= pep_sk(skparent
);
1053 lock_sock(skparent
);
1054 sk_del_node_init(sk
);
1057 /* Unhash a listening sock only when it is closed
1058 * and all of its active connected pipes are closed. */
1059 if (hlist_empty(&pn
->hlist
))
1060 pn_sock_unhash(&pn
->pn_sk
.sk
);
1067 static struct proto pep_proto
= {
1068 .close
= pep_sock_close
,
1069 .accept
= pep_sock_accept
,
1072 .setsockopt
= pep_setsockopt
,
1073 .getsockopt
= pep_getsockopt
,
1074 .sendmsg
= pep_sendmsg
,
1075 .recvmsg
= pep_recvmsg
,
1076 .backlog_rcv
= pep_do_rcv
,
1077 .hash
= pn_sock_hash
,
1078 .unhash
= pep_sock_unhash
,
1079 .get_port
= pn_sock_get_port
,
1080 .obj_size
= sizeof(struct pep_sock
),
1081 .owner
= THIS_MODULE
,
1085 static struct phonet_protocol pep_pn_proto
= {
1086 .ops
= &phonet_stream_ops
,
1088 .sock_type
= SOCK_SEQPACKET
,
1091 static int __init
pep_register(void)
1093 return phonet_proto_register(PN_PROTO_PIPE
, &pep_pn_proto
);
1096 static void __exit
pep_unregister(void)
1098 phonet_proto_unregister(PN_PROTO_PIPE
, &pep_pn_proto
);
1101 module_init(pep_register
);
1102 module_exit(pep_unregister
);
1103 MODULE_AUTHOR("Remi Denis-Courmont, Nokia");
1104 MODULE_DESCRIPTION("Phonet pipe protocol");
1105 MODULE_LICENSE("GPL");
1106 MODULE_ALIAS_NET_PF_PROTO(PF_PHONET
, PN_PROTO_PIPE
);