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. */ 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 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 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 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 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 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 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 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. */ 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 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. */ 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 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 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. */ 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. */ 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 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 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 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 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. */ 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 */ 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 */ 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 1389 static int __init pep_register(void) 1390 { 1391 return phonet_proto_register(PN_PROTO_PIPE, &pep_pn_proto); 1392 } 1393 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