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
);
91 #ifdef CONFIG_PHONET_PIPECTRLR
92 const struct phonethdr
*hdr
= pn_hdr(oskb
);
93 struct sockaddr_pn spn
= {
94 .spn_family
= AF_PHONET
,
96 .spn_dev
= hdr
->pn_sdev
,
97 .spn_obj
= hdr
->pn_sobj
,
101 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ len
, priority
);
104 skb_set_owner_w(skb
, sk
);
106 skb_reserve(skb
, MAX_PNPIPE_HEADER
);
108 skb_copy_to_linear_data(skb
, data
, len
);
109 __skb_push(skb
, sizeof(*ph
));
110 skb_reset_transport_header(skb
);
112 ph
->utid
= oph
->utid
;
113 ph
->message_id
= oph
->message_id
+ 1; /* REQ -> RESP */
114 ph
->pipe_handle
= oph
->pipe_handle
;
115 ph
->error_code
= code
;
117 #ifdef CONFIG_PHONET_PIPECTRLR
118 return pn_skb_send(sk
, skb
, &spn
);
120 return pn_skb_send(sk
, skb
, &pipe_srv
);
126 #ifdef CONFIG_PHONET_PIPECTRLR
127 static u8
pipe_negotiate_fc(u8
*host_fc
, u8
*remote_fc
, int len
)
130 u8 base_fc
, final_fc
;
132 for (i
= 0; i
< len
; i
++) {
133 base_fc
= host_fc
[i
];
134 for (j
= 0; j
< len
; j
++) {
135 if (remote_fc
[j
] == base_fc
) {
148 static int pipe_get_flow_info(struct sock
*sk
, struct sk_buff
*skb
,
149 u8
*pref_rx_fc
, u8
*req_tx_fc
)
151 struct pnpipehdr
*hdr
;
154 if (!pskb_may_pull(skb
, sizeof(*hdr
) + 4))
160 __skb_pull(skb
, sizeof(*hdr
) + 4);
162 u8 type
, buf
[3], len
= sizeof(buf
);
163 u8
*data
= pep_get_sb(skb
, &type
, &len
, buf
);
169 case PN_PIPE_SB_REQUIRED_FC_TX
:
170 if (len
< 3 || (data
[2] | data
[3] | data
[4]) > 3)
172 req_tx_fc
[0] = data
[2];
173 req_tx_fc
[1] = data
[3];
174 req_tx_fc
[2] = data
[4];
177 case PN_PIPE_SB_PREFERRED_FC_RX
:
178 if (len
< 3 || (data
[2] | data
[3] | data
[4]) > 3)
180 pref_rx_fc
[0] = data
[2];
181 pref_rx_fc
[1] = data
[3];
182 pref_rx_fc
[2] = data
[4];
191 static int pipe_handler_send_req(struct sock
*sk
, u16 dobj
, u8 utid
,
192 u8 msg_id
, u8 p_handle
, gfp_t priority
)
195 struct pnpipehdr
*ph
;
197 struct sockaddr_pn spn
= {
198 .spn_family
= AF_PHONET
,
199 .spn_resource
= 0xD9,
200 .spn_dev
= pn_dev(dobj
),
201 .spn_obj
= pn_obj(dobj
),
204 static const u8 data
[4] = {
209 case PNS_PEP_CONNECT_REQ
:
213 case PNS_PEP_DISCONNECT_REQ
:
214 case PNS_PEP_ENABLE_REQ
:
215 case PNS_PEP_DISABLE_REQ
:
223 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ len
, priority
);
226 skb_set_owner_w(skb
, sk
);
228 skb_reserve(skb
, MAX_PNPIPE_HEADER
);
231 skb_copy_to_linear_data(skb
, data
, len
);
233 __skb_push(skb
, sizeof(*ph
));
234 skb_reset_transport_header(skb
);
237 ph
->message_id
= msg_id
;
238 ph
->pipe_handle
= p_handle
;
239 ph
->error_code
= PN_PIPE_NO_ERROR
;
241 return pn_skb_send(sk
, skb
, &spn
);
244 static int pipe_handler_send_created_ind(struct sock
*sk
, u16 dobj
,
245 u8 utid
, u8 p_handle
, u8 msg_id
, u8 tx_fc
, u8 rx_fc
)
248 struct pnpipehdr
*ph
;
250 struct sockaddr_pn spn
= {
251 .spn_family
= AF_PHONET
,
252 .spn_resource
= 0xD9,
253 .spn_dev
= pn_dev(dobj
),
254 .spn_obj
= pn_obj(dobj
),
257 static u8 data
[4] = {
264 * actually, below is number of sub-blocks and not error code.
265 * Pipe_created_ind message format does not have any
266 * error code field. However, the Phonet stack will always send
267 * an error code as part of pnpipehdr. So, use that err_code to
268 * specify the number of sub-blocks.
272 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ sizeof(data
), GFP_ATOMIC
);
275 skb_set_owner_w(skb
, sk
);
277 skb_reserve(skb
, MAX_PNPIPE_HEADER
);
278 __skb_put(skb
, sizeof(data
));
279 skb_copy_to_linear_data(skb
, data
, sizeof(data
));
280 __skb_push(skb
, sizeof(*ph
));
281 skb_reset_transport_header(skb
);
284 ph
->message_id
= msg_id
;
285 ph
->pipe_handle
= p_handle
;
286 ph
->error_code
= err_code
;
288 return pn_skb_send(sk
, skb
, &spn
);
291 static int pipe_handler_send_ind(struct sock
*sk
, u16 dobj
, u8 utid
,
292 u8 p_handle
, u8 msg_id
)
295 struct pnpipehdr
*ph
;
297 struct sockaddr_pn spn
= {
298 .spn_family
= AF_PHONET
,
299 .spn_resource
= 0xD9,
300 .spn_dev
= pn_dev(dobj
),
301 .spn_obj
= pn_obj(dobj
),
305 * actually, below is a filler.
306 * Pipe_enabled/disabled_ind message format does not have any
307 * error code field. However, the Phonet stack will always send
308 * an error code as part of pnpipehdr. So, use that err_code to
309 * specify the filler value.
313 skb
= alloc_skb(MAX_PNPIPE_HEADER
, GFP_ATOMIC
);
316 skb_set_owner_w(skb
, sk
);
318 skb_reserve(skb
, MAX_PNPIPE_HEADER
);
319 __skb_push(skb
, sizeof(*ph
));
320 skb_reset_transport_header(skb
);
323 ph
->message_id
= msg_id
;
324 ph
->pipe_handle
= p_handle
;
325 ph
->error_code
= err_code
;
327 return pn_skb_send(sk
, skb
, &spn
);
330 static int pipe_handler_enable_pipe(struct sock
*sk
, int cmd
)
333 struct pep_sock
*pn
= pep_sk(sk
);
337 ret
= pipe_handler_send_req(sk
, pn
->pn_sk
.sobject
,
338 PNS_PIPE_ENABLE_UTID
, PNS_PEP_ENABLE_REQ
,
339 pn
->pipe_handle
, GFP_ATOMIC
);
343 ret
= pipe_handler_send_req(sk
, pn
->pn_sk
.sobject
,
344 PNS_PIPE_DISABLE_UTID
, PNS_PEP_DISABLE_REQ
,
345 pn
->pipe_handle
, GFP_ATOMIC
);
355 static int pipe_handler_create_pipe(struct sock
*sk
, int pipe_handle
, int cmd
)
358 struct pep_sock
*pn
= pep_sk(sk
);
362 ret
= pipe_handler_send_req(sk
, pn
->pn_sk
.sobject
,
363 PNS_PEP_CONNECT_UTID
, PNS_PEP_CONNECT_REQ
,
364 pipe_handle
, GFP_ATOMIC
);
368 ret
= pipe_handler_send_req(sk
, pn
->remote_pep
,
369 PNS_PEP_DISCONNECT_UTID
,
370 PNS_PEP_DISCONNECT_REQ
,
371 pn
->pipe_handle
, GFP_ATOMIC
);
382 static int pep_accept_conn(struct sock
*sk
, struct sk_buff
*skb
)
384 static const u8 data
[20] = {
385 PAD
, PAD
, PAD
, 2 /* sub-blocks */,
386 PN_PIPE_SB_REQUIRED_FC_TX
, pep_sb_size(5), 3, PAD
,
387 PN_MULTI_CREDIT_FLOW_CONTROL
,
388 PN_ONE_CREDIT_FLOW_CONTROL
,
389 PN_LEGACY_FLOW_CONTROL
,
391 PN_PIPE_SB_PREFERRED_FC_RX
, pep_sb_size(5), 3, PAD
,
392 PN_MULTI_CREDIT_FLOW_CONTROL
,
393 PN_ONE_CREDIT_FLOW_CONTROL
,
394 PN_LEGACY_FLOW_CONTROL
,
399 return pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, data
, sizeof(data
),
403 static int pep_reject_conn(struct sock
*sk
, struct sk_buff
*skb
, u8 code
)
405 static const u8 data
[4] = { PAD
, PAD
, PAD
, 0 /* sub-blocks */ };
406 WARN_ON(code
== PN_PIPE_NO_ERROR
);
407 return pep_reply(sk
, skb
, code
, data
, sizeof(data
), GFP_ATOMIC
);
410 /* Control requests are not sent by the pipe service and have a specific
412 static int pep_ctrlreq_error(struct sock
*sk
, struct sk_buff
*oskb
, u8 code
,
415 const struct pnpipehdr
*oph
= pnp_hdr(oskb
);
417 struct pnpipehdr
*ph
;
418 struct sockaddr_pn dst
;
420 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ 4, priority
);
423 skb_set_owner_w(skb
, sk
);
425 skb_reserve(skb
, MAX_PHONET_HEADER
);
426 ph
= (struct pnpipehdr
*)skb_put(skb
, sizeof(*ph
) + 4);
428 ph
->utid
= oph
->utid
;
429 ph
->message_id
= PNS_PEP_CTRL_RESP
;
430 ph
->pipe_handle
= oph
->pipe_handle
;
431 ph
->data
[0] = oph
->data
[1]; /* CTRL id */
432 ph
->data
[1] = oph
->data
[0]; /* PEP type */
433 ph
->data
[2] = code
; /* error code, at an usual offset */
437 pn_skb_get_src_sockaddr(oskb
, &dst
);
438 return pn_skb_send(sk
, skb
, &dst
);
441 static int pipe_snd_status(struct sock
*sk
, u8 type
, u8 status
, gfp_t priority
)
443 struct pep_sock
*pn
= pep_sk(sk
);
444 struct pnpipehdr
*ph
;
446 #ifdef CONFIG_PHONET_PIPECTRLR
447 struct sockaddr_pn spn
= {
448 .spn_family
= AF_PHONET
,
449 .spn_resource
= 0xD9,
450 .spn_dev
= pn_dev(pn
->remote_pep
),
451 .spn_obj
= pn_obj(pn
->remote_pep
),
455 skb
= alloc_skb(MAX_PNPIPE_HEADER
+ 4, priority
);
458 skb_set_owner_w(skb
, sk
);
460 skb_reserve(skb
, MAX_PNPIPE_HEADER
+ 4);
461 __skb_push(skb
, sizeof(*ph
) + 4);
462 skb_reset_transport_header(skb
);
465 ph
->message_id
= PNS_PEP_STATUS_IND
;
466 ph
->pipe_handle
= pn
->pipe_handle
;
467 ph
->pep_type
= PN_PEP_TYPE_COMMON
;
471 ph
->data
[4] = status
;
473 #ifdef CONFIG_PHONET_PIPECTRLR
474 return pn_skb_send(sk
, skb
, &spn
);
476 return pn_skb_send(sk
, skb
, &pipe_srv
);
480 /* Send our RX flow control information to the sender.
481 * Socket must be locked. */
482 static void pipe_grant_credits(struct sock
*sk
)
484 struct pep_sock
*pn
= pep_sk(sk
);
486 BUG_ON(sk
->sk_state
!= TCP_ESTABLISHED
);
489 case PN_LEGACY_FLOW_CONTROL
: /* TODO */
491 case PN_ONE_CREDIT_FLOW_CONTROL
:
492 pipe_snd_status(sk
, PN_PEP_IND_FLOW_CONTROL
,
493 PEP_IND_READY
, GFP_ATOMIC
);
496 case PN_MULTI_CREDIT_FLOW_CONTROL
:
497 if ((pn
->rx_credits
+ CREDITS_THR
) > CREDITS_MAX
)
499 if (pipe_snd_status(sk
, PN_PEP_IND_ID_MCFC_GRANT_CREDITS
,
500 CREDITS_MAX
- pn
->rx_credits
,
502 pn
->rx_credits
= CREDITS_MAX
;
507 static int pipe_rcv_status(struct sock
*sk
, struct sk_buff
*skb
)
509 struct pep_sock
*pn
= pep_sk(sk
);
510 struct pnpipehdr
*hdr
;
513 if (!pskb_may_pull(skb
, sizeof(*hdr
) + 4))
517 if (hdr
->data
[0] != PN_PEP_TYPE_COMMON
) {
518 LIMIT_NETDEBUG(KERN_DEBUG
"Phonet unknown PEP type: %u\n",
519 (unsigned)hdr
->data
[0]);
523 switch (hdr
->data
[1]) {
524 case PN_PEP_IND_FLOW_CONTROL
:
526 case PN_LEGACY_FLOW_CONTROL
:
527 switch (hdr
->data
[4]) {
529 atomic_set(&pn
->tx_credits
, 0);
532 atomic_set(&pn
->tx_credits
, wake
= 1);
536 case PN_ONE_CREDIT_FLOW_CONTROL
:
537 if (hdr
->data
[4] == PEP_IND_READY
)
538 atomic_set(&pn
->tx_credits
, wake
= 1);
543 case PN_PEP_IND_ID_MCFC_GRANT_CREDITS
:
544 if (pn
->tx_fc
!= PN_MULTI_CREDIT_FLOW_CONTROL
)
546 atomic_add(wake
= hdr
->data
[4], &pn
->tx_credits
);
550 LIMIT_NETDEBUG(KERN_DEBUG
"Phonet unknown PEP indication: %u\n",
551 (unsigned)hdr
->data
[1]);
555 sk
->sk_write_space(sk
);
559 static int pipe_rcv_created(struct sock
*sk
, struct sk_buff
*skb
)
561 struct pep_sock
*pn
= pep_sk(sk
);
562 struct pnpipehdr
*hdr
= pnp_hdr(skb
);
563 u8 n_sb
= hdr
->data
[0];
565 pn
->rx_fc
= pn
->tx_fc
= PN_LEGACY_FLOW_CONTROL
;
566 __skb_pull(skb
, sizeof(*hdr
));
568 u8 type
, buf
[2], len
= sizeof(buf
);
569 u8
*data
= pep_get_sb(skb
, &type
, &len
, buf
);
574 case PN_PIPE_SB_NEGOTIATED_FC
:
575 if (len
< 2 || (data
[0] | data
[1]) > 3)
577 pn
->tx_fc
= data
[0] & 3;
578 pn
->rx_fc
= data
[1] & 3;
586 /* Queue an skb to a connected sock.
587 * Socket lock must be held. */
588 static int pipe_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
590 struct pep_sock
*pn
= pep_sk(sk
);
591 struct pnpipehdr
*hdr
= pnp_hdr(skb
);
592 struct sk_buff_head
*queue
;
594 #ifdef CONFIG_PHONET_PIPECTRLR
595 struct phonethdr
*ph
= pn_hdr(skb
);
596 static u8 host_pref_rx_fc
[3], host_req_tx_fc
[3];
597 u8 remote_pref_rx_fc
[3], remote_req_tx_fc
[3];
598 u8 negotiated_rx_fc
, negotiated_tx_fc
;
601 BUG_ON(sk
->sk_state
== TCP_CLOSE_WAIT
);
603 switch (hdr
->message_id
) {
604 case PNS_PEP_CONNECT_REQ
:
605 pep_reject_conn(sk
, skb
, PN_PIPE_ERR_PEP_IN_USE
);
608 #ifdef CONFIG_PHONET_PIPECTRLR
609 case PNS_PEP_CONNECT_RESP
:
610 if ((ph
->pn_sdev
== pn_dev(pn
->remote_pep
)) &&
611 (ph
->pn_sobj
== pn_obj(pn
->remote_pep
))) {
612 pipe_get_flow_info(sk
, skb
, remote_pref_rx_fc
,
615 negotiated_tx_fc
= pipe_negotiate_fc(remote_req_tx_fc
,
617 sizeof(host_pref_rx_fc
));
618 negotiated_rx_fc
= pipe_negotiate_fc(host_req_tx_fc
,
620 sizeof(host_pref_rx_fc
));
622 pn
->pipe_state
= PIPE_DISABLED
;
623 pipe_handler_send_created_ind(sk
, pn
->remote_pep
,
624 PNS_PIPE_CREATED_IND_UTID
,
625 pn
->pipe_handle
, PNS_PIPE_CREATED_IND
,
626 negotiated_tx_fc
, negotiated_rx_fc
);
627 pipe_handler_send_created_ind(sk
, pn
->pn_sk
.sobject
,
628 PNS_PIPE_CREATED_IND_UTID
,
629 pn
->pipe_handle
, PNS_PIPE_CREATED_IND
,
630 negotiated_tx_fc
, negotiated_rx_fc
);
632 pipe_handler_send_req(sk
, pn
->remote_pep
,
633 PNS_PEP_CONNECT_UTID
,
634 PNS_PEP_CONNECT_REQ
, pn
->pipe_handle
,
636 pipe_get_flow_info(sk
, skb
, host_pref_rx_fc
,
642 case PNS_PEP_DISCONNECT_REQ
:
643 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
644 sk
->sk_state
= TCP_CLOSE_WAIT
;
645 if (!sock_flag(sk
, SOCK_DEAD
))
646 sk
->sk_state_change(sk
);
649 #ifdef CONFIG_PHONET_PIPECTRLR
650 case PNS_PEP_DISCONNECT_RESP
:
651 pn
->pipe_state
= PIPE_IDLE
;
652 pipe_handler_send_req(sk
, pn
->pn_sk
.sobject
,
653 PNS_PEP_DISCONNECT_UTID
,
654 PNS_PEP_DISCONNECT_REQ
, pn
->pipe_handle
,
659 case PNS_PEP_ENABLE_REQ
:
660 /* Wait for PNS_PIPE_(ENABLED|REDIRECTED)_IND */
661 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
664 #ifdef CONFIG_PHONET_PIPECTRLR
665 case PNS_PEP_ENABLE_RESP
:
666 if ((ph
->pn_sdev
== pn_dev(pn
->remote_pep
)) &&
667 (ph
->pn_sobj
== pn_obj(pn
->remote_pep
))) {
668 pn
->pipe_state
= PIPE_ENABLED
;
669 pipe_handler_send_ind(sk
, pn
->remote_pep
,
670 PNS_PIPE_ENABLED_IND_UTID
,
671 pn
->pipe_handle
, PNS_PIPE_ENABLED_IND
);
672 pipe_handler_send_ind(sk
, pn
->pn_sk
.sobject
,
673 PNS_PIPE_ENABLED_IND_UTID
,
674 pn
->pipe_handle
, PNS_PIPE_ENABLED_IND
);
676 pipe_handler_send_req(sk
, pn
->remote_pep
,
677 PNS_PIPE_ENABLE_UTID
,
678 PNS_PEP_ENABLE_REQ
, pn
->pipe_handle
,
684 case PNS_PEP_RESET_REQ
:
685 switch (hdr
->state_after_reset
) {
686 case PN_PIPE_DISABLE
:
692 default: /* not allowed to send an error here!? */
697 case PNS_PEP_DISABLE_REQ
:
698 atomic_set(&pn
->tx_credits
, 0);
699 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
702 #ifdef CONFIG_PHONET_PIPECTRLR
703 case PNS_PEP_DISABLE_RESP
:
704 if ((ph
->pn_sdev
== pn_dev(pn
->remote_pep
)) &&
705 (ph
->pn_sobj
== pn_obj(pn
->remote_pep
))) {
706 pn
->pipe_state
= PIPE_DISABLED
;
707 pipe_handler_send_ind(sk
, pn
->remote_pep
,
708 PNS_PIPE_DISABLED_IND_UTID
,
710 PNS_PIPE_DISABLED_IND
);
711 pipe_handler_send_ind(sk
, pn
->pn_sk
.sobject
,
712 PNS_PIPE_DISABLED_IND_UTID
,
714 PNS_PIPE_DISABLED_IND
);
716 pipe_handler_send_req(sk
, pn
->remote_pep
,
717 PNS_PIPE_DISABLE_UTID
,
718 PNS_PEP_DISABLE_REQ
, pn
->pipe_handle
,
723 case PNS_PEP_CTRL_REQ
:
724 if (skb_queue_len(&pn
->ctrlreq_queue
) >= PNPIPE_CTRLREQ_MAX
) {
725 atomic_inc(&sk
->sk_drops
);
729 queue
= &pn
->ctrlreq_queue
;
732 case PNS_PIPE_ALIGNED_DATA
:
736 __skb_pull(skb
, 3); /* Pipe data header */
737 if (!pn_flow_safe(pn
->rx_fc
)) {
738 err
= sock_queue_rcv_skb(sk
, skb
);
744 if (pn
->rx_credits
== 0) {
745 atomic_inc(&sk
->sk_drops
);
750 queue
= &sk
->sk_receive_queue
;
753 case PNS_PEP_STATUS_IND
:
754 pipe_rcv_status(sk
, skb
);
757 case PNS_PIPE_REDIRECTED_IND
:
758 err
= pipe_rcv_created(sk
, skb
);
761 case PNS_PIPE_CREATED_IND
:
762 err
= pipe_rcv_created(sk
, skb
);
766 case PNS_PIPE_RESET_IND
:
767 if (!pn
->init_enable
)
770 case PNS_PIPE_ENABLED_IND
:
771 if (!pn_flow_safe(pn
->tx_fc
)) {
772 atomic_set(&pn
->tx_credits
, 1);
773 sk
->sk_write_space(sk
);
775 if (sk
->sk_state
== TCP_ESTABLISHED
)
776 break; /* Nothing to do */
777 sk
->sk_state
= TCP_ESTABLISHED
;
778 pipe_grant_credits(sk
);
781 case PNS_PIPE_DISABLED_IND
:
782 sk
->sk_state
= TCP_SYN_RECV
;
787 LIMIT_NETDEBUG(KERN_DEBUG
"Phonet unknown PEP message: %u\n",
797 skb_set_owner_r(skb
, sk
);
799 skb_queue_tail(queue
, skb
);
800 if (!sock_flag(sk
, SOCK_DEAD
))
801 sk
->sk_data_ready(sk
, err
);
805 /* Destroy connected sock. */
806 static void pipe_destruct(struct sock
*sk
)
808 struct pep_sock
*pn
= pep_sk(sk
);
810 skb_queue_purge(&sk
->sk_receive_queue
);
811 skb_queue_purge(&pn
->ctrlreq_queue
);
814 static int pep_connreq_rcv(struct sock
*sk
, struct sk_buff
*skb
)
817 struct pep_sock
*newpn
, *pn
= pep_sk(sk
);
818 struct pnpipehdr
*hdr
;
819 struct sockaddr_pn dst
;
821 u8 pipe_handle
, enabled
, n_sb
;
824 if (!pskb_pull(skb
, sizeof(*hdr
) + 4))
828 pipe_handle
= hdr
->pipe_handle
;
829 switch (hdr
->state_after_connect
) {
830 case PN_PIPE_DISABLE
:
837 pep_reject_conn(sk
, skb
, PN_PIPE_ERR_INVALID_PARAM
);
840 peer_type
= hdr
->other_pep_type
<< 8;
842 if (unlikely(sk
->sk_state
!= TCP_LISTEN
) || sk_acceptq_is_full(sk
)) {
843 pep_reject_conn(sk
, skb
, PN_PIPE_ERR_PEP_IN_USE
);
847 /* Parse sub-blocks (options) */
850 u8 type
, buf
[1], len
= sizeof(buf
);
851 const u8
*data
= pep_get_sb(skb
, &type
, &len
, buf
);
856 case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE
:
859 peer_type
= (peer_type
& 0xff00) | data
[0];
861 case PN_PIPE_SB_ALIGNED_DATA
:
862 aligned
= data
[0] != 0;
868 skb
= skb_clone(skb
, GFP_ATOMIC
);
872 /* Create a new to-be-accepted sock */
873 newsk
= sk_alloc(sock_net(sk
), PF_PHONET
, GFP_ATOMIC
, sk
->sk_prot
);
878 sock_init_data(NULL
, newsk
);
879 newsk
->sk_state
= TCP_SYN_RECV
;
880 newsk
->sk_backlog_rcv
= pipe_do_rcv
;
881 newsk
->sk_protocol
= sk
->sk_protocol
;
882 newsk
->sk_destruct
= pipe_destruct
;
884 newpn
= pep_sk(newsk
);
885 pn_skb_get_dst_sockaddr(skb
, &dst
);
886 newpn
->pn_sk
.sobject
= pn_sockaddr_get_object(&dst
);
887 newpn
->pn_sk
.resource
= pn
->pn_sk
.resource
;
888 skb_queue_head_init(&newpn
->ctrlreq_queue
);
889 newpn
->pipe_handle
= pipe_handle
;
890 atomic_set(&newpn
->tx_credits
, 0);
891 newpn
->peer_type
= peer_type
;
892 newpn
->rx_credits
= 0;
893 newpn
->rx_fc
= newpn
->tx_fc
= PN_LEGACY_FLOW_CONTROL
;
894 newpn
->init_enable
= enabled
;
895 newpn
->aligned
= aligned
;
896 #ifdef CONFIG_PHONET_PIPECTRLR
897 newpn
->remote_pep
= pn
->remote_pep
;
900 BUG_ON(!skb_queue_empty(&newsk
->sk_receive_queue
));
901 skb_queue_head(&newsk
->sk_receive_queue
, skb
);
902 if (!sock_flag(sk
, SOCK_DEAD
))
903 sk
->sk_data_ready(sk
, 0);
905 sk_acceptq_added(sk
);
906 sk_add_node(newsk
, &pn
->ackq
);
910 /* Listening sock must be locked */
911 static struct sock
*pep_find_pipe(const struct hlist_head
*hlist
,
912 const struct sockaddr_pn
*dst
,
915 struct hlist_node
*node
;
917 u16 dobj
= pn_sockaddr_get_object(dst
);
919 sk_for_each(sknode
, node
, hlist
) {
920 struct pep_sock
*pnnode
= pep_sk(sknode
);
922 /* Ports match, but addresses might not: */
923 if (pnnode
->pn_sk
.sobject
!= dobj
)
925 if (pnnode
->pipe_handle
!= pipe_handle
)
927 if (sknode
->sk_state
== TCP_CLOSE_WAIT
)
937 * Deliver an skb to a listening sock.
938 * Socket lock must be held.
939 * We then queue the skb to the right connected sock (if any).
941 static int pep_do_rcv(struct sock
*sk
, struct sk_buff
*skb
)
943 struct pep_sock
*pn
= pep_sk(sk
);
945 struct pnpipehdr
*hdr
;
946 struct sockaddr_pn dst
;
947 int err
= NET_RX_SUCCESS
;
950 if (!pskb_may_pull(skb
, sizeof(*hdr
)))
954 pipe_handle
= hdr
->pipe_handle
;
955 if (pipe_handle
== PN_PIPE_INVALID_HANDLE
)
958 pn_skb_get_dst_sockaddr(skb
, &dst
);
960 /* Look for an existing pipe handle */
961 sknode
= pep_find_pipe(&pn
->hlist
, &dst
, pipe_handle
);
963 return sk_receive_skb(sknode
, skb
, 1);
965 /* Look for a pipe handle pending accept */
966 sknode
= pep_find_pipe(&pn
->ackq
, &dst
, pipe_handle
);
970 printk(KERN_WARNING
"Phonet unconnected PEP ignored");
975 switch (hdr
->message_id
) {
976 case PNS_PEP_CONNECT_REQ
:
977 err
= pep_connreq_rcv(sk
, skb
);
980 case PNS_PEP_DISCONNECT_REQ
:
981 pep_reply(sk
, skb
, PN_PIPE_NO_ERROR
, NULL
, 0, GFP_ATOMIC
);
984 case PNS_PEP_CTRL_REQ
:
985 pep_ctrlreq_error(sk
, skb
, PN_PIPE_INVALID_HANDLE
, GFP_ATOMIC
);
988 case PNS_PEP_RESET_REQ
:
989 case PNS_PEP_ENABLE_REQ
:
990 case PNS_PEP_DISABLE_REQ
:
991 /* invalid handle is not even allowed here! */
1000 static int pipe_do_remove(struct sock
*sk
)
1002 struct pep_sock
*pn
= pep_sk(sk
);
1003 struct pnpipehdr
*ph
;
1004 struct sk_buff
*skb
;
1006 skb
= alloc_skb(MAX_PNPIPE_HEADER
, GFP_KERNEL
);
1010 skb_reserve(skb
, MAX_PNPIPE_HEADER
);
1011 __skb_push(skb
, sizeof(*ph
));
1012 skb_reset_transport_header(skb
);
1015 ph
->message_id
= PNS_PIPE_REMOVE_REQ
;
1016 ph
->pipe_handle
= pn
->pipe_handle
;
1019 return pn_skb_send(sk
, skb
, &pipe_srv
);
1022 /* associated socket ceases to exist */
1023 static void pep_sock_close(struct sock
*sk
, long timeout
)
1025 struct pep_sock
*pn
= pep_sk(sk
);
1028 sock_hold(sk
); /* keep a reference after sk_common_release() */
1029 sk_common_release(sk
);
1032 if (sk
->sk_state
== TCP_LISTEN
) {
1033 /* Destroy the listen queue */
1034 struct sock
*sknode
;
1035 struct hlist_node
*p
, *n
;
1037 sk_for_each_safe(sknode
, p
, n
, &pn
->ackq
)
1038 sk_del_node_init(sknode
);
1039 sk
->sk_state
= TCP_CLOSE
;
1040 } else if ((1 << sk
->sk_state
) & (TCPF_SYN_RECV
|TCPF_ESTABLISHED
))
1041 /* Forcefully remove dangling Phonet pipe */
1044 ifindex
= pn
->ifindex
;
1053 static int pep_wait_connreq(struct sock
*sk
, int noblock
)
1055 struct task_struct
*tsk
= current
;
1056 struct pep_sock
*pn
= pep_sk(sk
);
1057 long timeo
= sock_rcvtimeo(sk
, noblock
);
1062 if (sk
->sk_state
!= TCP_LISTEN
)
1064 if (!hlist_empty(&pn
->ackq
))
1067 return -EWOULDBLOCK
;
1068 if (signal_pending(tsk
))
1069 return sock_intr_errno(timeo
);
1071 prepare_to_wait_exclusive(sk_sleep(sk
), &wait
,
1072 TASK_INTERRUPTIBLE
);
1074 timeo
= schedule_timeout(timeo
);
1076 finish_wait(sk_sleep(sk
), &wait
);
1082 static struct sock
*pep_sock_accept(struct sock
*sk
, int flags
, int *errp
)
1084 struct pep_sock
*pn
= pep_sk(sk
);
1085 struct sock
*newsk
= NULL
;
1086 struct sk_buff
*oskb
;
1090 err
= pep_wait_connreq(sk
, flags
& O_NONBLOCK
);
1094 newsk
= __sk_head(&pn
->ackq
);
1096 oskb
= skb_dequeue(&newsk
->sk_receive_queue
);
1097 err
= pep_accept_conn(newsk
, oskb
);
1099 skb_queue_head(&newsk
->sk_receive_queue
, oskb
);
1106 pep_sk(newsk
)->listener
= sk
;
1109 sk_del_node_init(newsk
);
1110 sk_acceptq_removed(sk
);
1111 sk_add_node(newsk
, &pn
->hlist
);
1120 static int pep_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
1122 struct pep_sock
*pn
= pep_sk(sk
);
1127 if (sk
->sk_state
== TCP_LISTEN
)
1131 if (sock_flag(sk
, SOCK_URGINLINE
) &&
1132 !skb_queue_empty(&pn
->ctrlreq_queue
))
1133 answ
= skb_peek(&pn
->ctrlreq_queue
)->len
;
1134 else if (!skb_queue_empty(&sk
->sk_receive_queue
))
1135 answ
= skb_peek(&sk
->sk_receive_queue
)->len
;
1139 return put_user(answ
, (int __user
*)arg
);
1142 return -ENOIOCTLCMD
;
1145 static int pep_init(struct sock
*sk
)
1147 struct pep_sock
*pn
= pep_sk(sk
);
1149 INIT_HLIST_HEAD(&pn
->ackq
);
1150 INIT_HLIST_HEAD(&pn
->hlist
);
1151 skb_queue_head_init(&pn
->ctrlreq_queue
);
1152 pn
->pipe_handle
= PN_PIPE_INVALID_HANDLE
;
1156 static int pep_setsockopt(struct sock
*sk
, int level
, int optname
,
1157 char __user
*optval
, unsigned int optlen
)
1159 struct pep_sock
*pn
= pep_sk(sk
);
1160 int val
= 0, err
= 0;
1161 #ifdef CONFIG_PHONET_PIPECTRLR
1166 if (level
!= SOL_PNPIPE
)
1167 return -ENOPROTOOPT
;
1168 if (optlen
>= sizeof(int)) {
1169 if (get_user(val
, (int __user
*) optval
))
1175 #ifdef CONFIG_PHONET_PIPECTRLR
1178 if (pn
->pipe_state
> PIPE_IDLE
) {
1182 remote_pep
= val
& 0xFFFF;
1183 pipe_handle
= (val
>> 16) & 0xFF;
1184 pn
->remote_pep
= remote_pep
;
1185 err
= pipe_handler_create_pipe(sk
, pipe_handle
,
1191 if (pn
->pipe_state
!= PIPE_DISABLED
) {
1195 err
= pipe_handler_enable_pipe(sk
, PNPIPE_ENABLE
);
1198 case PNPIPE_DISABLE
:
1199 if (pn
->pipe_state
!= PIPE_ENABLED
) {
1204 err
= pipe_handler_enable_pipe(sk
, PNPIPE_DISABLE
);
1207 case PNPIPE_DESTROY
:
1208 if (pn
->pipe_state
< PIPE_DISABLED
) {
1213 err
= pipe_handler_create_pipe(sk
, 0x0, PNPIPE_DESTROY
);
1218 if (val
&& val
!= PNPIPE_ENCAP_IP
) {
1222 if (!pn
->ifindex
== !val
)
1223 break; /* Nothing to do! */
1224 if (!capable(CAP_NET_ADMIN
)) {
1230 err
= gprs_attach(sk
);
1251 static int pep_getsockopt(struct sock
*sk
, int level
, int optname
,
1252 char __user
*optval
, int __user
*optlen
)
1254 struct pep_sock
*pn
= pep_sk(sk
);
1257 if (level
!= SOL_PNPIPE
)
1258 return -ENOPROTOOPT
;
1259 if (get_user(len
, optlen
))
1264 val
= pn
->ifindex
? PNPIPE_ENCAP_IP
: PNPIPE_ENCAP_NONE
;
1267 #ifdef CONFIG_PHONET_PIPECTRLR
1269 val
= pn
->pipe_state
;
1273 case PNPIPE_IFINDEX
:
1277 return -ENOPROTOOPT
;
1280 len
= min_t(unsigned int, sizeof(int), len
);
1281 if (put_user(len
, optlen
))
1283 if (put_user(val
, (int __user
*) optval
))
1288 static int pipe_skb_send(struct sock
*sk
, struct sk_buff
*skb
)
1290 struct pep_sock
*pn
= pep_sk(sk
);
1291 struct pnpipehdr
*ph
;
1293 #ifdef CONFIG_PHONET_PIPECTRLR
1294 struct sockaddr_pn spn
= {
1295 .spn_family
= AF_PHONET
,
1296 .spn_resource
= 0xD9,
1297 .spn_dev
= pn_dev(pn
->remote_pep
),
1298 .spn_obj
= pn_obj(pn
->remote_pep
),
1302 if (pn_flow_safe(pn
->tx_fc
) &&
1303 !atomic_add_unless(&pn
->tx_credits
, -1, 0)) {
1308 skb_push(skb
, 3 + pn
->aligned
);
1309 skb_reset_transport_header(skb
);
1313 ph
->message_id
= PNS_PIPE_ALIGNED_DATA
;
1314 ph
->data
[0] = 0; /* padding */
1316 ph
->message_id
= PNS_PIPE_DATA
;
1317 ph
->pipe_handle
= pn
->pipe_handle
;
1318 #ifdef CONFIG_PHONET_PIPECTRLR
1319 err
= pn_skb_send(sk
, skb
, &spn
);
1321 err
= pn_skb_send(sk
, skb
, &pipe_srv
);
1324 if (err
&& pn_flow_safe(pn
->tx_fc
))
1325 atomic_inc(&pn
->tx_credits
);
1330 static int pep_sendmsg(struct kiocb
*iocb
, struct sock
*sk
,
1331 struct msghdr
*msg
, size_t len
)
1333 struct pep_sock
*pn
= pep_sk(sk
);
1334 struct sk_buff
*skb
;
1336 int flags
= msg
->msg_flags
;
1339 if ((msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_EOR
|MSG_NOSIGNAL
|
1340 MSG_CMSG_COMPAT
)) ||
1341 !(msg
->msg_flags
& MSG_EOR
))
1344 skb
= sock_alloc_send_skb(sk
, MAX_PNPIPE_HEADER
+ len
,
1345 flags
& MSG_DONTWAIT
, &err
);
1349 skb_reserve(skb
, MAX_PHONET_HEADER
+ 3);
1350 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
1355 timeo
= sock_sndtimeo(sk
, flags
& MSG_DONTWAIT
);
1356 if ((1 << sk
->sk_state
) & (TCPF_LISTEN
|TCPF_CLOSE
)) {
1360 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1361 /* Wait until the pipe gets to enabled state */
1363 err
= sk_stream_wait_connect(sk
, &timeo
);
1367 if (sk
->sk_state
== TCP_CLOSE_WAIT
) {
1372 BUG_ON(sk
->sk_state
!= TCP_ESTABLISHED
);
1374 /* Wait until flow control allows TX */
1375 done
= atomic_read(&pn
->tx_credits
);
1383 if (signal_pending(current
)) {
1384 err
= sock_intr_errno(timeo
);
1388 prepare_to_wait(sk_sleep(sk
), &wait
,
1389 TASK_INTERRUPTIBLE
);
1390 done
= sk_wait_event(sk
, &timeo
, atomic_read(&pn
->tx_credits
));
1391 finish_wait(sk_sleep(sk
), &wait
);
1393 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1397 err
= pipe_skb_send(sk
, skb
);
1399 err
= len
; /* success! */
1408 int pep_writeable(struct sock
*sk
)
1410 struct pep_sock
*pn
= pep_sk(sk
);
1412 return atomic_read(&pn
->tx_credits
);
1415 int pep_write(struct sock
*sk
, struct sk_buff
*skb
)
1417 struct sk_buff
*rskb
, *fs
;
1420 if (pep_sk(sk
)->aligned
)
1421 return pipe_skb_send(sk
, skb
);
1423 rskb
= alloc_skb(MAX_PNPIPE_HEADER
, GFP_ATOMIC
);
1428 skb_shinfo(rskb
)->frag_list
= skb
;
1429 rskb
->len
+= skb
->len
;
1430 rskb
->data_len
+= rskb
->len
;
1431 rskb
->truesize
+= rskb
->len
;
1433 /* Avoid nested fragments */
1434 skb_walk_frags(skb
, fs
)
1436 skb
->next
= skb_shinfo(skb
)->frag_list
;
1437 skb_frag_list_init(skb
);
1439 skb
->data_len
-= flen
;
1440 skb
->truesize
-= flen
;
1442 skb_reserve(rskb
, MAX_PHONET_HEADER
+ 3);
1443 return pipe_skb_send(sk
, rskb
);
1446 struct sk_buff
*pep_read(struct sock
*sk
)
1448 struct sk_buff
*skb
= skb_dequeue(&sk
->sk_receive_queue
);
1450 if (sk
->sk_state
== TCP_ESTABLISHED
)
1451 pipe_grant_credits(sk
);
1455 static int pep_recvmsg(struct kiocb
*iocb
, struct sock
*sk
,
1456 struct msghdr
*msg
, size_t len
, int noblock
,
1457 int flags
, int *addr_len
)
1459 struct sk_buff
*skb
;
1462 if (flags
& ~(MSG_OOB
|MSG_PEEK
|MSG_TRUNC
|MSG_DONTWAIT
|MSG_WAITALL
|
1463 MSG_NOSIGNAL
|MSG_CMSG_COMPAT
))
1466 if (unlikely(1 << sk
->sk_state
& (TCPF_LISTEN
| TCPF_CLOSE
)))
1469 if ((flags
& MSG_OOB
) || sock_flag(sk
, SOCK_URGINLINE
)) {
1470 /* Dequeue and acknowledge control request */
1471 struct pep_sock
*pn
= pep_sk(sk
);
1473 if (flags
& MSG_PEEK
)
1475 skb
= skb_dequeue(&pn
->ctrlreq_queue
);
1477 pep_ctrlreq_error(sk
, skb
, PN_PIPE_NO_ERROR
,
1479 msg
->msg_flags
|= MSG_OOB
;
1482 if (flags
& MSG_OOB
)
1486 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
1489 if (err
== -ENOTCONN
&& sk
->sk_state
== TCP_CLOSE_WAIT
)
1495 if (sk
->sk_state
== TCP_ESTABLISHED
)
1496 pipe_grant_credits(sk
);
1499 msg
->msg_flags
|= MSG_EOR
;
1501 msg
->msg_flags
|= MSG_TRUNC
;
1505 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, len
);
1507 err
= (flags
& MSG_TRUNC
) ? skb
->len
: len
;
1509 skb_free_datagram(sk
, skb
);
1513 static void pep_sock_unhash(struct sock
*sk
)
1515 struct pep_sock
*pn
= pep_sk(sk
);
1516 struct sock
*skparent
= NULL
;
1519 if ((1 << sk
->sk_state
) & ~(TCPF_CLOSE
|TCPF_LISTEN
)) {
1520 skparent
= pn
->listener
;
1523 pn
= pep_sk(skparent
);
1524 lock_sock(skparent
);
1525 sk_del_node_init(sk
);
1528 /* Unhash a listening sock only when it is closed
1529 * and all of its active connected pipes are closed. */
1530 if (hlist_empty(&pn
->hlist
))
1531 pn_sock_unhash(&pn
->pn_sk
.sk
);
1538 static struct proto pep_proto
= {
1539 .close
= pep_sock_close
,
1540 .accept
= pep_sock_accept
,
1543 .setsockopt
= pep_setsockopt
,
1544 .getsockopt
= pep_getsockopt
,
1545 .sendmsg
= pep_sendmsg
,
1546 .recvmsg
= pep_recvmsg
,
1547 .backlog_rcv
= pep_do_rcv
,
1548 .hash
= pn_sock_hash
,
1549 .unhash
= pep_sock_unhash
,
1550 .get_port
= pn_sock_get_port
,
1551 .obj_size
= sizeof(struct pep_sock
),
1552 .owner
= THIS_MODULE
,
1556 static struct phonet_protocol pep_pn_proto
= {
1557 .ops
= &phonet_stream_ops
,
1559 .sock_type
= SOCK_SEQPACKET
,
1562 static int __init
pep_register(void)
1564 return phonet_proto_register(PN_PROTO_PIPE
, &pep_pn_proto
);
1567 static void __exit
pep_unregister(void)
1569 phonet_proto_unregister(PN_PROTO_PIPE
, &pep_pn_proto
);
1572 module_init(pep_register
);
1573 module_exit(pep_unregister
);
1574 MODULE_AUTHOR("Remi Denis-Courmont, Nokia");
1575 MODULE_DESCRIPTION("Phonet pipe protocol");
1576 MODULE_LICENSE("GPL");
1577 MODULE_ALIAS_NET_PF_PROTO(PF_PHONET
, PN_PROTO_PIPE
);