1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * File: pep.c
4 *
5 * Phonet pipe protocol end point socket
6 *
7 * Copyright (C) 2008 Nokia Corporation.
8 *
9 * Author: Rémi Denis-Courmont
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/sched/signal.h>
14 #include <linux/slab.h>
15 #include <linux/socket.h>
16 #include <net/sock.h>
17 #include <net/tcp_states.h>
18 #include <asm/ioctls.h>
19
20 #include <linux/phonet.h>
21 #include <linux/module.h>
22 #include <net/phonet/phonet.h>
23 #include <net/phonet/pep.h>
24 #include <net/phonet/gprs.h>
25
26 /* sk_state values:
27 * TCP_CLOSE sock not in use yet
28 * TCP_CLOSE_WAIT disconnected pipe
29 * TCP_LISTEN listening pipe endpoint
30 * TCP_SYN_RECV connected pipe in disabled state
31 * TCP_ESTABLISHED connected pipe in enabled state
32 *
33 * pep_sock locking:
34 * - sk_state, hlist: sock lock needed
35 * - listener: read only
36 * - pipe_handle: read only
37 */
38
39 #define CREDITS_MAX 10
40 #define CREDITS_THR 7
41
42 #define pep_sb_size(s) (((s) + 5) & ~3) /* 2-bytes head, 32-bits aligned */
43
44 /* Get the next TLV sub-block. */
pep_get_sb(struct sk_buff * skb,u8 * ptype,u8 * plen,void * buf)45 static unsigned char *pep_get_sb(struct sk_buff *skb, u8 *ptype, u8 *plen,
46 void *buf)
47 {
48 void *data = NULL;
49 struct {
50 u8 sb_type;
51 u8 sb_len;
52 } *ph, h;
53 int buflen = *plen;
54
55 ph = skb_header_pointer(skb, 0, 2, &h);
56 if (ph == NULL || ph->sb_len < 2 || !pskb_may_pull(skb, ph->sb_len))
57 return NULL;
58 ph->sb_len -= 2;
59 *ptype = ph->sb_type;
60 *plen = ph->sb_len;
61
62 if (buflen > ph->sb_len)
63 buflen = ph->sb_len;
64 data = skb_header_pointer(skb, 2, buflen, buf);
65 __skb_pull(skb, 2 + ph->sb_len);
66 return data;
67 }
68
pep_alloc_skb(struct sock * sk,const void * payload,int len,gfp_t priority)69 static struct sk_buff *pep_alloc_skb(struct sock *sk, const void *payload,
70 int len, gfp_t priority)
71 {
72 struct sk_buff *skb = alloc_skb(MAX_PNPIPE_HEADER + len, priority);
73 if (!skb)
74 return NULL;
75 skb_set_owner_w(skb, sk);
76
77 skb_reserve(skb, MAX_PNPIPE_HEADER);
78 __skb_put(skb, len);
79 skb_copy_to_linear_data(skb, payload, len);
80 __skb_push(skb, sizeof(struct pnpipehdr));
81 skb_reset_transport_header(skb);
82 return skb;
83 }
84
pep_reply(struct sock * sk,struct sk_buff * oskb,u8 code,const void * data,int len,gfp_t priority)85 static int pep_reply(struct sock *sk, struct sk_buff *oskb, u8 code,
86 const void *data, int len, gfp_t priority)
87 {
88 const struct pnpipehdr *oph = pnp_hdr(oskb);
89 struct pnpipehdr *ph;
90 struct sk_buff *skb;
91 struct sockaddr_pn peer;
92
93 skb = pep_alloc_skb(sk, data, len, priority);
94 if (!skb)
95 return -ENOMEM;
96
97 ph = pnp_hdr(skb);
98 ph->utid = oph->utid;
99 ph->message_id = oph->message_id + 1; /* REQ -> RESP */
100 ph->pipe_handle = oph->pipe_handle;
101 ph->error_code = code;
102
103 pn_skb_get_src_sockaddr(oskb, &peer);
104 return pn_skb_send(sk, skb, &peer);
105 }
106
pep_indicate(struct sock * sk,u8 id,u8 code,const void * data,int len,gfp_t priority)107 static int pep_indicate(struct sock *sk, u8 id, u8 code,
108 const void *data, int len, gfp_t priority)
109 {
110 struct pep_sock *pn = pep_sk(sk);
111 struct pnpipehdr *ph;
112 struct sk_buff *skb;
113
114 skb = pep_alloc_skb(sk, data, len, priority);
115 if (!skb)
116 return -ENOMEM;
117
118 ph = pnp_hdr(skb);
119 ph->utid = 0;
120 ph->message_id = id;
121 ph->pipe_handle = pn->pipe_handle;
122 ph->error_code = code;
123 return pn_skb_send(sk, skb, NULL);
124 }
125
126 #define PAD 0x00
127
pipe_handler_request(struct sock * sk,u8 id,u8 code,const void * data,int len)128 static int pipe_handler_request(struct sock *sk, u8 id, u8 code,
129 const void *data, int len)
130 {
131 struct pep_sock *pn = pep_sk(sk);
132 struct pnpipehdr *ph;
133 struct sk_buff *skb;
134
135 skb = pep_alloc_skb(sk, data, len, GFP_KERNEL);
136 if (!skb)
137 return -ENOMEM;
138
139 ph = pnp_hdr(skb);
140 ph->utid = id; /* whatever */
141 ph->message_id = id;
142 ph->pipe_handle = pn->pipe_handle;
143 ph->error_code = code;
144 return pn_skb_send(sk, skb, NULL);
145 }
146
pipe_handler_send_created_ind(struct sock * sk)147 static int pipe_handler_send_created_ind(struct sock *sk)
148 {
149 struct pep_sock *pn = pep_sk(sk);
150 u8 data[4] = {
151 PN_PIPE_SB_NEGOTIATED_FC, pep_sb_size(2),
152 pn->tx_fc, pn->rx_fc,
153 };
154
155 return pep_indicate(sk, PNS_PIPE_CREATED_IND, 1 /* sub-blocks */,
156 data, 4, GFP_ATOMIC);
157 }
158
pep_accept_conn(struct sock * sk,struct sk_buff * skb)159 static int pep_accept_conn(struct sock *sk, struct sk_buff *skb)
160 {
161 static const u8 data[20] = {
162 PAD, PAD, PAD, 2 /* sub-blocks */,
163 PN_PIPE_SB_REQUIRED_FC_TX, pep_sb_size(5), 3, PAD,
164 PN_MULTI_CREDIT_FLOW_CONTROL,
165 PN_ONE_CREDIT_FLOW_CONTROL,
166 PN_LEGACY_FLOW_CONTROL,
167 PAD,
168 PN_PIPE_SB_PREFERRED_FC_RX, pep_sb_size(5), 3, PAD,
169 PN_MULTI_CREDIT_FLOW_CONTROL,
170 PN_ONE_CREDIT_FLOW_CONTROL,
171 PN_LEGACY_FLOW_CONTROL,
172 PAD,
173 };
174
175 might_sleep();
176 return pep_reply(sk, skb, PN_PIPE_NO_ERROR, data, sizeof(data),
177 GFP_KERNEL);
178 }
179
pep_reject_conn(struct sock * sk,struct sk_buff * skb,u8 code,gfp_t priority)180 static int pep_reject_conn(struct sock *sk, struct sk_buff *skb, u8 code,
181 gfp_t priority)
182 {
183 static const u8 data[4] = { PAD, PAD, PAD, 0 /* sub-blocks */ };
184 WARN_ON(code == PN_PIPE_NO_ERROR);
185 return pep_reply(sk, skb, code, data, sizeof(data), priority);
186 }
187
188 /* Control requests are not sent by the pipe service and have a specific
189 * message format. */
pep_ctrlreq_error(struct sock * sk,struct sk_buff * oskb,u8 code,gfp_t priority)190 static int pep_ctrlreq_error(struct sock *sk, struct sk_buff *oskb, u8 code,
191 gfp_t priority)
192 {
193 const struct pnpipehdr *oph = pnp_hdr(oskb);
194 struct sk_buff *skb;
195 struct pnpipehdr *ph;
196 struct sockaddr_pn dst;
197 u8 data[4] = {
198 oph->pep_type, /* PEP type */
199 code, /* error code, at an unusual offset */
200 PAD, PAD,
201 };
202
203 skb = pep_alloc_skb(sk, data, 4, priority);
204 if (!skb)
205 return -ENOMEM;
206
207 ph = pnp_hdr(skb);
208 ph->utid = oph->utid;
209 ph->message_id = PNS_PEP_CTRL_RESP;
210 ph->pipe_handle = oph->pipe_handle;
211 ph->data0 = oph->data[0]; /* CTRL id */
212
213 pn_skb_get_src_sockaddr(oskb, &dst);
214 return pn_skb_send(sk, skb, &dst);
215 }
216
pipe_snd_status(struct sock * sk,u8 type,u8 status,gfp_t priority)217 static int pipe_snd_status(struct sock *sk, u8 type, u8 status, gfp_t priority)
218 {
219 u8 data[4] = { type, PAD, PAD, status };
220
221 return pep_indicate(sk, PNS_PEP_STATUS_IND, PN_PEP_TYPE_COMMON,
222 data, 4, priority);
223 }
224
225 /* Send our RX flow control information to the sender.
226 * Socket must be locked. */
pipe_grant_credits(struct sock * sk,gfp_t priority)227 static void pipe_grant_credits(struct sock *sk, gfp_t priority)
228 {
229 struct pep_sock *pn = pep_sk(sk);
230
231 BUG_ON(sk->sk_state != TCP_ESTABLISHED);
232
233 switch (pn->rx_fc) {
234 case PN_LEGACY_FLOW_CONTROL: /* TODO */
235 break;
236 case PN_ONE_CREDIT_FLOW_CONTROL:
237 if (pipe_snd_status(sk, PN_PEP_IND_FLOW_CONTROL,
238 PEP_IND_READY, priority) == 0)
239 pn->rx_credits = 1;
240 break;
241 case PN_MULTI_CREDIT_FLOW_CONTROL:
242 if ((pn->rx_credits + CREDITS_THR) > CREDITS_MAX)
243 break;
244 if (pipe_snd_status(sk, PN_PEP_IND_ID_MCFC_GRANT_CREDITS,
245 CREDITS_MAX - pn->rx_credits,
246 priority) == 0)
247 pn->rx_credits = CREDITS_MAX;
248 break;
249 }
250 }
251
pipe_rcv_status(struct sock * sk,struct sk_buff * skb)252 static int pipe_rcv_status(struct sock *sk, struct sk_buff *skb)
253 {
254 struct pep_sock *pn = pep_sk(sk);
255 struct pnpipehdr *hdr;
256 int wake = 0;
257
258 if (!pskb_may_pull(skb, sizeof(*hdr) + 4))
259 return -EINVAL;
260
261 hdr = pnp_hdr(skb);
262 if (hdr->pep_type != PN_PEP_TYPE_COMMON) {
263 net_dbg_ratelimited("Phonet unknown PEP type: %u\n",
264 (unsigned int)hdr->pep_type);
265 return -EOPNOTSUPP;
266 }
267
268 switch (hdr->data[0]) {
269 case PN_PEP_IND_FLOW_CONTROL:
270 switch (pn->tx_fc) {
271 case PN_LEGACY_FLOW_CONTROL:
272 switch (hdr->data[3]) {
273 case PEP_IND_BUSY:
274 atomic_set(&pn->tx_credits, 0);
275 break;
276 case PEP_IND_READY:
277 atomic_set(&pn->tx_credits, wake = 1);
278 break;
279 }
280 break;
281 case PN_ONE_CREDIT_FLOW_CONTROL:
282 if (hdr->data[3] == PEP_IND_READY)
283 atomic_set(&pn->tx_credits, wake = 1);
284 break;
285 }
286 break;
287
288 case PN_PEP_IND_ID_MCFC_GRANT_CREDITS:
289 if (pn->tx_fc != PN_MULTI_CREDIT_FLOW_CONTROL)
290 break;
291 atomic_add(wake = hdr->data[3], &pn->tx_credits);
292 break;
293
294 default:
295 net_dbg_ratelimited("Phonet unknown PEP indication: %u\n",
296 (unsigned int)hdr->data[0]);
297 return -EOPNOTSUPP;
298 }
299 if (wake)
300 sk->sk_write_space(sk);
301 return 0;
302 }
303
pipe_rcv_created(struct sock * sk,struct sk_buff * skb)304 static int pipe_rcv_created(struct sock *sk, struct sk_buff *skb)
305 {
306 struct pep_sock *pn = pep_sk(sk);
307 struct pnpipehdr *hdr = pnp_hdr(skb);
308 u8 n_sb = hdr->data0;
309
310 pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
311 __skb_pull(skb, sizeof(*hdr));
312 while (n_sb > 0) {
313 u8 type, buf[2], len = sizeof(buf);
314 u8 *data = pep_get_sb(skb, &type, &len, buf);
315
316 if (data == NULL)
317 return -EINVAL;
318 switch (type) {
319 case PN_PIPE_SB_NEGOTIATED_FC:
320 if (len < 2 || (data[0] | data[1]) > 3)
321 break;
322 pn->tx_fc = data[0] & 3;
323 pn->rx_fc = data[1] & 3;
324 break;
325 }
326 n_sb--;
327 }
328 return 0;
329 }
330
331 /* Queue an skb to a connected sock.
332 * Socket lock must be held. */
pipe_do_rcv(struct sock * sk,struct sk_buff * skb)333 static int pipe_do_rcv(struct sock *sk, struct sk_buff *skb)
334 {
335 struct pep_sock *pn = pep_sk(sk);
336 struct pnpipehdr *hdr = pnp_hdr(skb);
337 struct sk_buff_head *queue;
338 int err = 0;
339
340 BUG_ON(sk->sk_state == TCP_CLOSE_WAIT);
341
342 switch (hdr->message_id) {
343 case PNS_PEP_CONNECT_REQ:
344 pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE, GFP_ATOMIC);
345 break;
346
347 case PNS_PEP_DISCONNECT_REQ:
348 pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
349 sk->sk_state = TCP_CLOSE_WAIT;
350 if (!sock_flag(sk, SOCK_DEAD))
351 sk->sk_state_change(sk);
352 break;
353
354 case PNS_PEP_ENABLE_REQ:
355 /* Wait for PNS_PIPE_(ENABLED|REDIRECTED)_IND */
356 pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
357 break;
358
359 case PNS_PEP_RESET_REQ:
360 switch (hdr->state_after_reset) {
361 case PN_PIPE_DISABLE:
362 pn->init_enable = 0;
363 break;
364 case PN_PIPE_ENABLE:
365 pn->init_enable = 1;
366 break;
367 default: /* not allowed to send an error here!? */
368 err = -EINVAL;
369 goto out;
370 }
371 fallthrough;
372 case PNS_PEP_DISABLE_REQ:
373 atomic_set(&pn->tx_credits, 0);
374 pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
375 break;
376
377 case PNS_PEP_CTRL_REQ:
378 if (skb_queue_len(&pn->ctrlreq_queue) >= PNPIPE_CTRLREQ_MAX) {
379 sk_drops_inc(sk);
380 break;
381 }
382 __skb_pull(skb, 4);
383 queue = &pn->ctrlreq_queue;
384 goto queue;
385
386 case PNS_PIPE_ALIGNED_DATA:
387 __skb_pull(skb, 1);
388 fallthrough;
389 case PNS_PIPE_DATA:
390 __skb_pull(skb, 3); /* Pipe data header */
391 if (!pn_flow_safe(pn->rx_fc)) {
392 err = sock_queue_rcv_skb(sk, skb);
393 if (!err)
394 return NET_RX_SUCCESS;
395 err = -ENOBUFS;
396 break;
397 }
398
399 if (pn->rx_credits == 0) {
400 sk_drops_inc(sk);
401 err = -ENOBUFS;
402 break;
403 }
404 pn->rx_credits--;
405 queue = &sk->sk_receive_queue;
406 goto queue;
407
408 case PNS_PEP_STATUS_IND:
409 pipe_rcv_status(sk, skb);
410 break;
411
412 case PNS_PIPE_REDIRECTED_IND:
413 err = pipe_rcv_created(sk, skb);
414 break;
415
416 case PNS_PIPE_CREATED_IND:
417 err = pipe_rcv_created(sk, skb);
418 if (err)
419 break;
420 fallthrough;
421 case PNS_PIPE_RESET_IND:
422 if (!pn->init_enable)
423 break;
424 fallthrough;
425 case PNS_PIPE_ENABLED_IND:
426 if (!pn_flow_safe(pn->tx_fc)) {
427 atomic_set(&pn->tx_credits, 1);
428 sk->sk_write_space(sk);
429 }
430 if (sk->sk_state == TCP_ESTABLISHED)
431 break; /* Nothing to do */
432 sk->sk_state = TCP_ESTABLISHED;
433 pipe_grant_credits(sk, GFP_ATOMIC);
434 break;
435
436 case PNS_PIPE_DISABLED_IND:
437 sk->sk_state = TCP_SYN_RECV;
438 pn->rx_credits = 0;
439 break;
440
441 default:
442 net_dbg_ratelimited("Phonet unknown PEP message: %u\n",
443 hdr->message_id);
444 err = -EINVAL;
445 }
446 out:
447 kfree_skb(skb);
448 return (err == -ENOBUFS) ? NET_RX_DROP : NET_RX_SUCCESS;
449
450 queue:
451 skb->dev = NULL;
452 skb_set_owner_r(skb, sk);
453 skb_queue_tail(queue, skb);
454 if (!sock_flag(sk, SOCK_DEAD))
455 sk->sk_data_ready(sk);
456 return NET_RX_SUCCESS;
457 }
458
459 /* Destroy connected sock. */
pipe_destruct(struct sock * sk)460 static void pipe_destruct(struct sock *sk)
461 {
462 struct pep_sock *pn = pep_sk(sk);
463
464 skb_queue_purge(&sk->sk_receive_queue);
465 skb_queue_purge(&pn->ctrlreq_queue);
466 }
467
pipe_negotiate_fc(const u8 * fcs,unsigned int n)468 static u8 pipe_negotiate_fc(const u8 *fcs, unsigned int n)
469 {
470 unsigned int i;
471 u8 final_fc = PN_NO_FLOW_CONTROL;
472
473 for (i = 0; i < n; i++) {
474 u8 fc = fcs[i];
475
476 if (fc > final_fc && fc < PN_MAX_FLOW_CONTROL)
477 final_fc = fc;
478 }
479 return final_fc;
480 }
481
pep_connresp_rcv(struct sock * sk,struct sk_buff * skb)482 static int pep_connresp_rcv(struct sock *sk, struct sk_buff *skb)
483 {
484 struct pep_sock *pn = pep_sk(sk);
485 struct pnpipehdr *hdr;
486 u8 n_sb;
487
488 if (!pskb_pull(skb, sizeof(*hdr) + 4))
489 return -EINVAL;
490
491 hdr = pnp_hdr(skb);
492 if (hdr->error_code != PN_PIPE_NO_ERROR)
493 return -ECONNREFUSED;
494
495 /* Parse sub-blocks */
496 n_sb = hdr->data[3];
497 while (n_sb > 0) {
498 u8 type, buf[6], len = sizeof(buf);
499 const u8 *data = pep_get_sb(skb, &type, &len, buf);
500
501 if (data == NULL)
502 return -EINVAL;
503
504 switch (type) {
505 case PN_PIPE_SB_REQUIRED_FC_TX:
506 if (len < 2 || len < data[0])
507 break;
508 pn->tx_fc = pipe_negotiate_fc(data + 2, len - 2);
509 break;
510
511 case PN_PIPE_SB_PREFERRED_FC_RX:
512 if (len < 2 || len < data[0])
513 break;
514 pn->rx_fc = pipe_negotiate_fc(data + 2, len - 2);
515 break;
516
517 }
518 n_sb--;
519 }
520
521 return pipe_handler_send_created_ind(sk);
522 }
523
pep_enableresp_rcv(struct sock * sk,struct sk_buff * skb)524 static int pep_enableresp_rcv(struct sock *sk, struct sk_buff *skb)
525 {
526 struct pnpipehdr *hdr = pnp_hdr(skb);
527
528 if (hdr->error_code != PN_PIPE_NO_ERROR)
529 return -ECONNREFUSED;
530
531 return pep_indicate(sk, PNS_PIPE_ENABLED_IND, 0 /* sub-blocks */,
532 NULL, 0, GFP_ATOMIC);
533
534 }
535
pipe_start_flow_control(struct sock * sk)536 static void pipe_start_flow_control(struct sock *sk)
537 {
538 struct pep_sock *pn = pep_sk(sk);
539
540 if (!pn_flow_safe(pn->tx_fc)) {
541 atomic_set(&pn->tx_credits, 1);
542 sk->sk_write_space(sk);
543 }
544 pipe_grant_credits(sk, GFP_ATOMIC);
545 }
546
547 /* Queue an skb to an actively connected sock.
548 * Socket lock must be held. */
pipe_handler_do_rcv(struct sock * sk,struct sk_buff * skb)549 static int pipe_handler_do_rcv(struct sock *sk, struct sk_buff *skb)
550 {
551 struct pep_sock *pn = pep_sk(sk);
552 struct pnpipehdr *hdr = pnp_hdr(skb);
553 int err = NET_RX_SUCCESS;
554
555 switch (hdr->message_id) {
556 case PNS_PIPE_ALIGNED_DATA:
557 __skb_pull(skb, 1);
558 fallthrough;
559 case PNS_PIPE_DATA:
560 __skb_pull(skb, 3); /* Pipe data header */
561 if (!pn_flow_safe(pn->rx_fc)) {
562 err = sock_queue_rcv_skb(sk, skb);
563 if (!err)
564 return NET_RX_SUCCESS;
565 err = NET_RX_DROP;
566 break;
567 }
568
569 if (pn->rx_credits == 0) {
570 sk_drops_inc(sk);
571 err = NET_RX_DROP;
572 break;
573 }
574 pn->rx_credits--;
575 skb->dev = NULL;
576 skb_set_owner_r(skb, sk);
577 skb_queue_tail(&sk->sk_receive_queue, skb);
578 if (!sock_flag(sk, SOCK_DEAD))
579 sk->sk_data_ready(sk);
580 return NET_RX_SUCCESS;
581
582 case PNS_PEP_CONNECT_RESP:
583 if (sk->sk_state != TCP_SYN_SENT)
584 break;
585 if (!sock_flag(sk, SOCK_DEAD))
586 sk->sk_state_change(sk);
587 if (pep_connresp_rcv(sk, skb)) {
588 sk->sk_state = TCP_CLOSE_WAIT;
589 break;
590 }
591 if (pn->init_enable == PN_PIPE_DISABLE)
592 sk->sk_state = TCP_SYN_RECV;
593 else {
594 sk->sk_state = TCP_ESTABLISHED;
595 pipe_start_flow_control(sk);
596 }
597 break;
598
599 case PNS_PEP_ENABLE_RESP:
600 if (sk->sk_state != TCP_SYN_SENT)
601 break;
602
603 if (pep_enableresp_rcv(sk, skb)) {
604 sk->sk_state = TCP_CLOSE_WAIT;
605 break;
606 }
607
608 sk->sk_state = TCP_ESTABLISHED;
609 pipe_start_flow_control(sk);
610 break;
611
612 case PNS_PEP_DISCONNECT_RESP:
613 /* sock should already be dead, nothing to do */
614 break;
615
616 case PNS_PEP_STATUS_IND:
617 pipe_rcv_status(sk, skb);
618 break;
619 }
620 kfree_skb(skb);
621 return err;
622 }
623
624 /* Listening sock must be locked */
pep_find_pipe(const struct hlist_head * hlist,const struct sockaddr_pn * dst,u8 pipe_handle)625 static struct sock *pep_find_pipe(const struct hlist_head *hlist,
626 const struct sockaddr_pn *dst,
627 u8 pipe_handle)
628 {
629 struct sock *sknode;
630 u16 dobj = pn_sockaddr_get_object(dst);
631
632 sk_for_each(sknode, hlist) {
633 struct pep_sock *pnnode = pep_sk(sknode);
634
635 /* Ports match, but addresses might not: */
636 if (pnnode->pn_sk.sobject != dobj)
637 continue;
638 if (pnnode->pipe_handle != pipe_handle)
639 continue;
640 if (sknode->sk_state == TCP_CLOSE_WAIT)
641 continue;
642
643 sock_hold(sknode);
644 return sknode;
645 }
646 return NULL;
647 }
648
649 /*
650 * Deliver an skb to a listening sock.
651 * Socket lock must be held.
652 * We then queue the skb to the right connected sock (if any).
653 */
pep_do_rcv(struct sock * sk,struct sk_buff * skb)654 static int pep_do_rcv(struct sock *sk, struct sk_buff *skb)
655 {
656 struct pep_sock *pn = pep_sk(sk);
657 struct sock *sknode;
658 struct pnpipehdr *hdr;
659 struct sockaddr_pn dst;
660 u8 pipe_handle;
661
662 if (!pskb_may_pull(skb, sizeof(*hdr)))
663 goto drop;
664
665 hdr = pnp_hdr(skb);
666 pipe_handle = hdr->pipe_handle;
667 if (pipe_handle == PN_PIPE_INVALID_HANDLE)
668 goto drop;
669
670 pn_skb_get_dst_sockaddr(skb, &dst);
671
672 /* Look for an existing pipe handle */
673 sknode = pep_find_pipe(&pn->hlist, &dst, pipe_handle);
674 if (sknode) {
675 int rc;
676
677 /* pep_do_rcv() runs from two contexts: from softirq via
678 * phonet_rcv() -> __sk_receive_skb() with BH disabled,
679 * and from process context via
680 * release_sock() -> __release_sock(), which drops
681 * the listener slock with spin_unlock_bh() before draining
682 * the backlog. The child pipe slock is taken below via
683 * bh_lock_sock_nested(), which does not itself disable BH, so
684 * disable BH here to keep both acquire contexts consistent.
685 */
686 local_bh_disable();
687 rc = sk_receive_skb(sknode, skb, 1);
688 local_bh_enable();
689 return rc;
690 }
691
692 switch (hdr->message_id) {
693 case PNS_PEP_CONNECT_REQ:
694 if (sk->sk_state != TCP_LISTEN || sk_acceptq_is_full(sk)) {
695 pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE,
696 GFP_ATOMIC);
697 break;
698 }
699 skb_queue_head(&sk->sk_receive_queue, skb);
700 sk_acceptq_added(sk);
701 if (!sock_flag(sk, SOCK_DEAD))
702 sk->sk_data_ready(sk);
703 return NET_RX_SUCCESS;
704
705 case PNS_PEP_DISCONNECT_REQ:
706 pep_reply(sk, skb, PN_PIPE_NO_ERROR, NULL, 0, GFP_ATOMIC);
707 break;
708
709 case PNS_PEP_CTRL_REQ:
710 pep_ctrlreq_error(sk, skb, PN_PIPE_INVALID_HANDLE, GFP_ATOMIC);
711 break;
712
713 case PNS_PEP_RESET_REQ:
714 case PNS_PEP_ENABLE_REQ:
715 case PNS_PEP_DISABLE_REQ:
716 /* invalid handle is not even allowed here! */
717 break;
718
719 default:
720 if ((1 << sk->sk_state)
721 & ~(TCPF_CLOSE|TCPF_LISTEN|TCPF_CLOSE_WAIT))
722 /* actively connected socket */
723 return pipe_handler_do_rcv(sk, skb);
724 }
725 drop:
726 kfree_skb(skb);
727 return NET_RX_SUCCESS;
728 }
729
pipe_do_remove(struct sock * sk)730 static int pipe_do_remove(struct sock *sk)
731 {
732 struct pep_sock *pn = pep_sk(sk);
733 struct pnpipehdr *ph;
734 struct sk_buff *skb;
735
736 skb = pep_alloc_skb(sk, NULL, 0, GFP_KERNEL);
737 if (!skb)
738 return -ENOMEM;
739
740 ph = pnp_hdr(skb);
741 ph->utid = 0;
742 ph->message_id = PNS_PIPE_REMOVE_REQ;
743 ph->pipe_handle = pn->pipe_handle;
744 ph->data0 = PAD;
745 return pn_skb_send(sk, skb, NULL);
746 }
747
748 /* associated socket ceases to exist */
pep_sock_close(struct sock * sk,long timeout)749 static void pep_sock_close(struct sock *sk, long timeout)
750 {
751 struct pep_sock *pn = pep_sk(sk);
752 int ifindex = 0;
753
754 sock_hold(sk); /* keep a reference after sk_common_release() */
755 sk_common_release(sk);
756
757 lock_sock(sk);
758 if ((1 << sk->sk_state) & (TCPF_SYN_RECV|TCPF_ESTABLISHED)) {
759 if (sk->sk_backlog_rcv == pipe_do_rcv)
760 /* Forcefully remove dangling Phonet pipe */
761 pipe_do_remove(sk);
762 else
763 pipe_handler_request(sk, PNS_PEP_DISCONNECT_REQ, PAD,
764 NULL, 0);
765 }
766 sk->sk_state = TCP_CLOSE;
767
768 ifindex = pn->ifindex;
769 pn->ifindex = 0;
770 release_sock(sk);
771
772 if (ifindex)
773 gprs_detach(sk);
774 sock_put(sk);
775 }
776
pep_sock_accept(struct sock * sk,struct proto_accept_arg * arg)777 static struct sock *pep_sock_accept(struct sock *sk,
778 struct proto_accept_arg *arg)
779 {
780 struct pep_sock *pn = pep_sk(sk), *newpn;
781 struct sock *newsk = NULL;
782 struct sk_buff *skb;
783 struct pnpipehdr *hdr;
784 struct sockaddr_pn dst, src;
785 int err;
786 u16 peer_type;
787 u8 pipe_handle, enabled, n_sb;
788 u8 aligned = 0;
789
790 skb = skb_recv_datagram(sk, (arg->flags & O_NONBLOCK) ? MSG_DONTWAIT : 0,
791 &arg->err);
792 if (!skb)
793 return NULL;
794
795 lock_sock(sk);
796 if (sk->sk_state != TCP_LISTEN) {
797 err = -EINVAL;
798 goto drop;
799 }
800 sk_acceptq_removed(sk);
801
802 err = -EPROTO;
803 if (!pskb_may_pull(skb, sizeof(*hdr) + 4))
804 goto drop;
805
806 hdr = pnp_hdr(skb);
807 pipe_handle = hdr->pipe_handle;
808 switch (hdr->state_after_connect) {
809 case PN_PIPE_DISABLE:
810 enabled = 0;
811 break;
812 case PN_PIPE_ENABLE:
813 enabled = 1;
814 break;
815 default:
816 pep_reject_conn(sk, skb, PN_PIPE_ERR_INVALID_PARAM,
817 GFP_KERNEL);
818 goto drop;
819 }
820 peer_type = hdr->other_pep_type << 8;
821
822 /* Parse sub-blocks (options) */
823 n_sb = hdr->data[3];
824 while (n_sb > 0) {
825 u8 type, buf[1], len = sizeof(buf);
826 const u8 *data = pep_get_sb(skb, &type, &len, buf);
827
828 if (data == NULL)
829 goto drop;
830 switch (type) {
831 case PN_PIPE_SB_CONNECT_REQ_PEP_SUB_TYPE:
832 if (len < 1)
833 goto drop;
834 peer_type = (peer_type & 0xff00) | data[0];
835 break;
836 case PN_PIPE_SB_ALIGNED_DATA:
837 aligned = data[0] != 0;
838 break;
839 }
840 n_sb--;
841 }
842
843 /* Check for duplicate pipe handle */
844 pn_skb_get_dst_sockaddr(skb, &dst);
845 newsk = pep_find_pipe(&pn->hlist, &dst, pipe_handle);
846 if (unlikely(newsk)) {
847 __sock_put(newsk);
848 newsk = NULL;
849 pep_reject_conn(sk, skb, PN_PIPE_ERR_PEP_IN_USE, GFP_KERNEL);
850 goto drop;
851 }
852
853 /* Create a new to-be-accepted sock */
854 newsk = sk_alloc(sock_net(sk), PF_PHONET, GFP_KERNEL, sk->sk_prot,
855 arg->kern);
856 if (!newsk) {
857 pep_reject_conn(sk, skb, PN_PIPE_ERR_OVERLOAD, GFP_KERNEL);
858 err = -ENOBUFS;
859 goto drop;
860 }
861
862 sock_init_data(NULL, newsk);
863 newsk->sk_state = TCP_SYN_RECV;
864 newsk->sk_backlog_rcv = pipe_do_rcv;
865 newsk->sk_protocol = sk->sk_protocol;
866 newsk->sk_destruct = pipe_destruct;
867
868 newpn = pep_sk(newsk);
869 pn_skb_get_src_sockaddr(skb, &src);
870 newpn->pn_sk.sobject = pn_sockaddr_get_object(&dst);
871 newpn->pn_sk.dobject = pn_sockaddr_get_object(&src);
872 newpn->pn_sk.resource = pn_sockaddr_get_resource(&dst);
873 sock_hold(sk);
874 newpn->listener = sk;
875 skb_queue_head_init(&newpn->ctrlreq_queue);
876 newpn->pipe_handle = pipe_handle;
877 atomic_set(&newpn->tx_credits, 0);
878 newpn->ifindex = 0;
879 newpn->peer_type = peer_type;
880 newpn->rx_credits = 0;
881 newpn->rx_fc = newpn->tx_fc = PN_LEGACY_FLOW_CONTROL;
882 newpn->init_enable = enabled;
883 newpn->aligned = aligned;
884
885 err = pep_accept_conn(newsk, skb);
886 if (err) {
887 __sock_put(sk);
888 sock_put(newsk);
889 newsk = NULL;
890 goto drop;
891 }
892 sk_add_node(newsk, &pn->hlist);
893 drop:
894 release_sock(sk);
895 kfree_skb(skb);
896 arg->err = err;
897 return newsk;
898 }
899
pep_sock_connect(struct sock * sk,struct sockaddr_unsized * addr,int len)900 static int pep_sock_connect(struct sock *sk, struct sockaddr_unsized *addr,
901 int len)
902 {
903 struct pep_sock *pn = pep_sk(sk);
904 int err;
905 u8 data[4] = { 0 /* sub-blocks */, PAD, PAD, PAD };
906
907 if (pn->pipe_handle == PN_PIPE_INVALID_HANDLE)
908 pn->pipe_handle = 1; /* anything but INVALID_HANDLE */
909
910 err = pipe_handler_request(sk, PNS_PEP_CONNECT_REQ,
911 pn->init_enable, data, 4);
912 if (err) {
913 pn->pipe_handle = PN_PIPE_INVALID_HANDLE;
914 return err;
915 }
916
917 sk->sk_state = TCP_SYN_SENT;
918
919 return 0;
920 }
921
pep_sock_enable(struct sock * sk,struct sockaddr * addr,int len)922 static int pep_sock_enable(struct sock *sk, struct sockaddr *addr, int len)
923 {
924 int err;
925
926 err = pipe_handler_request(sk, PNS_PEP_ENABLE_REQ, PAD,
927 NULL, 0);
928 if (err)
929 return err;
930
931 sk->sk_state = TCP_SYN_SENT;
932
933 return 0;
934 }
935
pep_first_packet_length(struct sock * sk)936 static unsigned int pep_first_packet_length(struct sock *sk)
937 {
938 struct pep_sock *pn = pep_sk(sk);
939 struct sk_buff_head *q;
940 struct sk_buff *skb;
941 unsigned int len = 0;
942 bool found = false;
943
944 if (sock_flag(sk, SOCK_URGINLINE)) {
945 q = &pn->ctrlreq_queue;
946 spin_lock_bh(&q->lock);
947 skb = skb_peek(q);
948 if (skb) {
949 len = skb->len;
950 found = true;
951 }
952 spin_unlock_bh(&q->lock);
953 }
954
955 if (likely(!found)) {
956 q = &sk->sk_receive_queue;
957 spin_lock_bh(&q->lock);
958 skb = skb_peek(q);
959 if (skb)
960 len = skb->len;
961 spin_unlock_bh(&q->lock);
962 }
963
964 return len;
965 }
966
pep_ioctl(struct sock * sk,int cmd,int * karg)967 static int pep_ioctl(struct sock *sk, int cmd, int *karg)
968 {
969 struct pep_sock *pn = pep_sk(sk);
970 int ret = -ENOIOCTLCMD;
971
972 switch (cmd) {
973 case SIOCINQ:
974 if (sk->sk_state == TCP_LISTEN) {
975 ret = -EINVAL;
976 break;
977 }
978
979 *karg = pep_first_packet_length(sk);
980 ret = 0;
981 break;
982
983 case SIOCPNENABLEPIPE:
984 lock_sock(sk);
985 if (sk->sk_state == TCP_SYN_SENT)
986 ret = -EBUSY;
987 else if (sk->sk_state == TCP_ESTABLISHED)
988 ret = -EISCONN;
989 else if (!pn->pn_sk.sobject)
990 ret = -EADDRNOTAVAIL;
991 else
992 ret = pep_sock_enable(sk, NULL, 0);
993 release_sock(sk);
994 break;
995 }
996
997 return ret;
998 }
999
pep_init(struct sock * sk)1000 static int pep_init(struct sock *sk)
1001 {
1002 struct pep_sock *pn = pep_sk(sk);
1003
1004 sk->sk_destruct = pipe_destruct;
1005 INIT_HLIST_HEAD(&pn->hlist);
1006 pn->listener = NULL;
1007 skb_queue_head_init(&pn->ctrlreq_queue);
1008 atomic_set(&pn->tx_credits, 0);
1009 pn->ifindex = 0;
1010 pn->peer_type = 0;
1011 pn->pipe_handle = PN_PIPE_INVALID_HANDLE;
1012 pn->rx_credits = 0;
1013 pn->rx_fc = pn->tx_fc = PN_LEGACY_FLOW_CONTROL;
1014 pn->init_enable = 1;
1015 pn->aligned = 0;
1016 return 0;
1017 }
1018
pep_setsockopt(struct sock * sk,int level,int optname,sockptr_t optval,unsigned int optlen)1019 static int pep_setsockopt(struct sock *sk, int level, int optname,
1020 sockptr_t optval, unsigned int optlen)
1021 {
1022 struct pep_sock *pn = pep_sk(sk);
1023 int val = 0, err = 0;
1024
1025 if (level != SOL_PNPIPE)
1026 return -ENOPROTOOPT;
1027 if (optlen >= sizeof(int)) {
1028 if (copy_from_sockptr(&val, optval, sizeof(int)))
1029 return -EFAULT;
1030 }
1031
1032 lock_sock(sk);
1033 switch (optname) {
1034 case PNPIPE_ENCAP:
1035 if (val && val != PNPIPE_ENCAP_IP) {
1036 err = -EINVAL;
1037 break;
1038 }
1039 if (!pn->ifindex == !val)
1040 break; /* Nothing to do! */
1041 if (!capable(CAP_NET_ADMIN)) {
1042 err = -EPERM;
1043 break;
1044 }
1045 if (val) {
1046 release_sock(sk);
1047 err = gprs_attach(sk);
1048 if (err > 0) {
1049 pn->ifindex = err;
1050 err = 0;
1051 }
1052 } else {
1053 pn->ifindex = 0;
1054 release_sock(sk);
1055 gprs_detach(sk);
1056 err = 0;
1057 }
1058 goto out_norel;
1059
1060 case PNPIPE_HANDLE:
1061 if ((sk->sk_state == TCP_CLOSE) &&
1062 (val >= 0) && (val < PN_PIPE_INVALID_HANDLE))
1063 pn->pipe_handle = val;
1064 else
1065 err = -EINVAL;
1066 break;
1067
1068 case PNPIPE_INITSTATE:
1069 pn->init_enable = !!val;
1070 break;
1071
1072 default:
1073 err = -ENOPROTOOPT;
1074 }
1075 release_sock(sk);
1076
1077 out_norel:
1078 return err;
1079 }
1080
pep_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)1081 static int pep_getsockopt(struct sock *sk, int level, int optname,
1082 char __user *optval, int __user *optlen)
1083 {
1084 struct pep_sock *pn = pep_sk(sk);
1085 int len, val;
1086
1087 if (level != SOL_PNPIPE)
1088 return -ENOPROTOOPT;
1089 if (get_user(len, optlen))
1090 return -EFAULT;
1091
1092 switch (optname) {
1093 case PNPIPE_ENCAP:
1094 val = pn->ifindex ? PNPIPE_ENCAP_IP : PNPIPE_ENCAP_NONE;
1095 break;
1096
1097 case PNPIPE_IFINDEX:
1098 val = pn->ifindex;
1099 break;
1100
1101 case PNPIPE_HANDLE:
1102 val = pn->pipe_handle;
1103 if (val == PN_PIPE_INVALID_HANDLE)
1104 return -EINVAL;
1105 break;
1106
1107 case PNPIPE_INITSTATE:
1108 val = pn->init_enable;
1109 break;
1110
1111 default:
1112 return -ENOPROTOOPT;
1113 }
1114
1115 len = min_t(unsigned int, sizeof(int), len);
1116 if (put_user(len, optlen))
1117 return -EFAULT;
1118 if (put_user(val, (int __user *) optval))
1119 return -EFAULT;
1120 return 0;
1121 }
1122
pipe_skb_send(struct sock * sk,struct sk_buff * skb)1123 static int pipe_skb_send(struct sock *sk, struct sk_buff *skb)
1124 {
1125 struct pep_sock *pn = pep_sk(sk);
1126 struct pnpipehdr *ph;
1127 int err;
1128
1129 if (pn_flow_safe(pn->tx_fc) &&
1130 !atomic_add_unless(&pn->tx_credits, -1, 0)) {
1131 kfree_skb(skb);
1132 return -ENOBUFS;
1133 }
1134
1135 skb_push(skb, 3 + pn->aligned);
1136 skb_reset_transport_header(skb);
1137 ph = pnp_hdr(skb);
1138 ph->utid = 0;
1139 if (pn->aligned) {
1140 ph->message_id = PNS_PIPE_ALIGNED_DATA;
1141 ph->data0 = 0; /* padding */
1142 } else
1143 ph->message_id = PNS_PIPE_DATA;
1144 ph->pipe_handle = pn->pipe_handle;
1145 err = pn_skb_send(sk, skb, NULL);
1146
1147 if (err && pn_flow_safe(pn->tx_fc))
1148 atomic_inc(&pn->tx_credits);
1149 return err;
1150
1151 }
1152
pep_sendmsg(struct sock * sk,struct msghdr * msg,size_t len)1153 static int pep_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
1154 {
1155 struct pep_sock *pn = pep_sk(sk);
1156 struct sk_buff *skb;
1157 long timeo;
1158 int flags = msg->msg_flags;
1159 int err, done;
1160
1161 if (len > USHRT_MAX)
1162 return -EMSGSIZE;
1163
1164 if ((msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|
1165 MSG_CMSG_COMPAT)) ||
1166 !(msg->msg_flags & MSG_EOR))
1167 return -EOPNOTSUPP;
1168
1169 skb = sock_alloc_send_skb(sk, MAX_PNPIPE_HEADER + len,
1170 flags & MSG_DONTWAIT, &err);
1171 if (!skb)
1172 return err;
1173
1174 skb_reserve(skb, MAX_PHONET_HEADER + 3 + pn->aligned);
1175 err = memcpy_from_msg(skb_put(skb, len), msg, len);
1176 if (err < 0)
1177 goto outfree;
1178
1179 lock_sock(sk);
1180 timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
1181 if ((1 << sk->sk_state) & (TCPF_LISTEN|TCPF_CLOSE)) {
1182 err = -ENOTCONN;
1183 goto out;
1184 }
1185 if (sk->sk_state != TCP_ESTABLISHED) {
1186 /* Wait until the pipe gets to enabled state */
1187 disabled:
1188 err = sk_stream_wait_connect(sk, &timeo);
1189 if (err)
1190 goto out;
1191
1192 if (sk->sk_state == TCP_CLOSE_WAIT) {
1193 err = -ECONNRESET;
1194 goto out;
1195 }
1196 }
1197 BUG_ON(sk->sk_state != TCP_ESTABLISHED);
1198
1199 /* Wait until flow control allows TX */
1200 done = atomic_read(&pn->tx_credits);
1201 while (!done) {
1202 DEFINE_WAIT_FUNC(wait, woken_wake_function);
1203
1204 if (!timeo) {
1205 err = -EAGAIN;
1206 goto out;
1207 }
1208 if (signal_pending(current)) {
1209 err = sock_intr_errno(timeo);
1210 goto out;
1211 }
1212
1213 add_wait_queue(sk_sleep(sk), &wait);
1214 done = sk_wait_event(sk, &timeo, atomic_read(&pn->tx_credits), &wait);
1215 remove_wait_queue(sk_sleep(sk), &wait);
1216
1217 if (sk->sk_state != TCP_ESTABLISHED)
1218 goto disabled;
1219 }
1220
1221 err = pipe_skb_send(sk, skb);
1222 if (err >= 0)
1223 err = len; /* success! */
1224 skb = NULL;
1225 out:
1226 release_sock(sk);
1227 outfree:
1228 kfree_skb(skb);
1229 return err;
1230 }
1231
pep_writeable(struct sock * sk)1232 int pep_writeable(struct sock *sk)
1233 {
1234 struct pep_sock *pn = pep_sk(sk);
1235
1236 return atomic_read(&pn->tx_credits);
1237 }
1238
pep_write(struct sock * sk,struct sk_buff * skb)1239 int pep_write(struct sock *sk, struct sk_buff *skb)
1240 {
1241 struct sk_buff *rskb, *fs;
1242 int flen = 0;
1243
1244 if (pep_sk(sk)->aligned)
1245 return pipe_skb_send(sk, skb);
1246
1247 rskb = alloc_skb(MAX_PNPIPE_HEADER, GFP_ATOMIC);
1248 if (!rskb) {
1249 kfree_skb(skb);
1250 return -ENOMEM;
1251 }
1252 skb_shinfo(rskb)->frag_list = skb;
1253 rskb->len += skb->len;
1254 rskb->data_len += rskb->len;
1255 rskb->truesize += rskb->len;
1256
1257 /* Avoid nested fragments */
1258 skb_walk_frags(skb, fs)
1259 flen += fs->len;
1260 skb->next = skb_shinfo(skb)->frag_list;
1261 skb_frag_list_init(skb);
1262 skb->len -= flen;
1263 skb->data_len -= flen;
1264 skb->truesize -= flen;
1265
1266 skb_reserve(rskb, MAX_PHONET_HEADER + 3);
1267 return pipe_skb_send(sk, rskb);
1268 }
1269
pep_read(struct sock * sk)1270 struct sk_buff *pep_read(struct sock *sk)
1271 {
1272 struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
1273
1274 if (sk->sk_state == TCP_ESTABLISHED)
1275 pipe_grant_credits(sk, GFP_ATOMIC);
1276 return skb;
1277 }
1278
pep_recvmsg(struct sock * sk,struct msghdr * msg,size_t len,int flags)1279 static int pep_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
1280 int flags)
1281 {
1282 struct sk_buff *skb;
1283 int err;
1284
1285 if (flags & ~(MSG_OOB|MSG_PEEK|MSG_TRUNC|MSG_DONTWAIT|MSG_WAITALL|
1286 MSG_NOSIGNAL|MSG_CMSG_COMPAT))
1287 return -EOPNOTSUPP;
1288
1289 if (unlikely(1 << sk->sk_state & (TCPF_LISTEN | TCPF_CLOSE)))
1290 return -ENOTCONN;
1291
1292 if ((flags & MSG_OOB) || sock_flag(sk, SOCK_URGINLINE)) {
1293 /* Dequeue and acknowledge control request */
1294 struct pep_sock *pn = pep_sk(sk);
1295
1296 if (flags & MSG_PEEK)
1297 return -EOPNOTSUPP;
1298 skb = skb_dequeue(&pn->ctrlreq_queue);
1299 if (skb) {
1300 pep_ctrlreq_error(sk, skb, PN_PIPE_NO_ERROR,
1301 GFP_KERNEL);
1302 msg->msg_flags |= MSG_OOB;
1303 goto copy;
1304 }
1305 if (flags & MSG_OOB)
1306 return -EINVAL;
1307 }
1308
1309 skb = skb_recv_datagram(sk, flags, &err);
1310 lock_sock(sk);
1311 if (skb == NULL) {
1312 if (err == -ENOTCONN && sk->sk_state == TCP_CLOSE_WAIT)
1313 err = -ECONNRESET;
1314 release_sock(sk);
1315 return err;
1316 }
1317
1318 if (sk->sk_state == TCP_ESTABLISHED)
1319 pipe_grant_credits(sk, GFP_KERNEL);
1320 release_sock(sk);
1321 copy:
1322 msg->msg_flags |= MSG_EOR;
1323 if (skb->len > len)
1324 msg->msg_flags |= MSG_TRUNC;
1325 else
1326 len = skb->len;
1327
1328 err = skb_copy_datagram_msg(skb, 0, msg, len);
1329 if (!err)
1330 err = (flags & MSG_TRUNC) ? skb->len : len;
1331
1332 skb_free_datagram(sk, skb);
1333 return err;
1334 }
1335
pep_sock_unhash(struct sock * sk)1336 static void pep_sock_unhash(struct sock *sk)
1337 {
1338 struct pep_sock *pn = pep_sk(sk);
1339 struct sock *skparent = NULL;
1340
1341 lock_sock(sk);
1342
1343 if (pn->listener != NULL) {
1344 skparent = pn->listener;
1345 pn->listener = NULL;
1346 release_sock(sk);
1347
1348 pn = pep_sk(skparent);
1349 lock_sock(skparent);
1350 sk_del_node_init(sk);
1351 sk = skparent;
1352 }
1353
1354 /* Unhash a listening sock only when it is closed
1355 * and all of its active connected pipes are closed. */
1356 if (hlist_empty(&pn->hlist))
1357 pn_sock_unhash(&pn->pn_sk.sk);
1358 release_sock(sk);
1359
1360 if (skparent)
1361 sock_put(skparent);
1362 }
1363
1364 static struct proto pep_proto = {
1365 .close = pep_sock_close,
1366 .accept = pep_sock_accept,
1367 .connect = pep_sock_connect,
1368 .ioctl = pep_ioctl,
1369 .init = pep_init,
1370 .setsockopt = pep_setsockopt,
1371 .getsockopt = pep_getsockopt,
1372 .sendmsg = pep_sendmsg,
1373 .recvmsg = pep_recvmsg,
1374 .backlog_rcv = pep_do_rcv,
1375 .hash = pn_sock_hash,
1376 .unhash = pep_sock_unhash,
1377 .get_port = pn_sock_get_port,
1378 .obj_size = sizeof(struct pep_sock),
1379 .owner = THIS_MODULE,
1380 .name = "PNPIPE",
1381 };
1382
1383 static const struct phonet_protocol pep_pn_proto = {
1384 .ops = &phonet_stream_ops,
1385 .prot = &pep_proto,
1386 .sock_type = SOCK_SEQPACKET,
1387 };
1388
pep_register(void)1389 static int __init pep_register(void)
1390 {
1391 return phonet_proto_register(PN_PROTO_PIPE, &pep_pn_proto);
1392 }
1393
pep_unregister(void)1394 static void __exit pep_unregister(void)
1395 {
1396 phonet_proto_unregister(PN_PROTO_PIPE, &pep_pn_proto);
1397 }
1398
1399 module_init(pep_register);
1400 module_exit(pep_unregister);
1401 MODULE_AUTHOR("Remi Denis-Courmont, Nokia");
1402 MODULE_DESCRIPTION("Phonet pipe protocol");
1403 MODULE_LICENSE("GPL");
1404 MODULE_ALIAS_NET_PF_PROTO(PF_PHONET, PN_PROTO_PIPE);
1405