1 /* 2 * net/tipc/socket.c: TIPC socket API 3 * 4 * Copyright (c) 2001-2007, 2012-2015, Ericsson AB 5 * Copyright (c) 2004-2008, 2010-2013, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the names of the copyright holders nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * Alternatively, this software may be distributed under the terms of the 21 * GNU General Public License ("GPL") version 2 as published by the Free 22 * Software Foundation. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #include <linux/rhashtable.h> 38 #include "core.h" 39 #include "name_table.h" 40 #include "node.h" 41 #include "link.h" 42 #include "name_distr.h" 43 #include "socket.h" 44 #include "bcast.h" 45 46 #define SS_LISTENING -1 /* socket is listening */ 47 #define SS_READY -2 /* socket is connectionless */ 48 49 #define CONN_TIMEOUT_DEFAULT 8000 /* default connect timeout = 8s */ 50 #define CONN_PROBING_INTERVAL msecs_to_jiffies(3600000) /* [ms] => 1 h */ 51 #define TIPC_FWD_MSG 1 52 #define TIPC_CONN_OK 0 53 #define TIPC_CONN_PROBING 1 54 #define TIPC_MAX_PORT 0xffffffff 55 #define TIPC_MIN_PORT 1 56 57 /** 58 * struct tipc_sock - TIPC socket structure 59 * @sk: socket - interacts with 'port' and with user via the socket API 60 * @connected: non-zero if port is currently connected to a peer port 61 * @conn_type: TIPC type used when connection was established 62 * @conn_instance: TIPC instance used when connection was established 63 * @published: non-zero if port has one or more associated names 64 * @max_pkt: maximum packet size "hint" used when building messages sent by port 65 * @portid: unique port identity in TIPC socket hash table 66 * @phdr: preformatted message header used when sending messages 67 * @port_list: adjacent ports in TIPC's global list of ports 68 * @publications: list of publications for port 69 * @pub_count: total # of publications port has made during its lifetime 70 * @probing_state: 71 * @probing_intv: 72 * @conn_timeout: the time we can wait for an unresponded setup request 73 * @dupl_rcvcnt: number of bytes counted twice, in both backlog and rcv queue 74 * @link_cong: non-zero if owner must sleep because of link congestion 75 * @sent_unacked: # messages sent by socket, and not yet acked by peer 76 * @rcv_unacked: # messages read by user, but not yet acked back to peer 77 * @remote: 'connected' peer for dgram/rdm 78 * @node: hash table node 79 * @rcu: rcu struct for tipc_sock 80 */ 81 struct tipc_sock { 82 struct sock sk; 83 int connected; 84 u32 conn_type; 85 u32 conn_instance; 86 int published; 87 u32 max_pkt; 88 u32 portid; 89 struct tipc_msg phdr; 90 struct list_head sock_list; 91 struct list_head publications; 92 u32 pub_count; 93 u32 probing_state; 94 unsigned long probing_intv; 95 uint conn_timeout; 96 atomic_t dupl_rcvcnt; 97 bool link_cong; 98 uint sent_unacked; 99 uint rcv_unacked; 100 struct sockaddr_tipc remote; 101 struct rhash_head node; 102 struct rcu_head rcu; 103 }; 104 105 static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb); 106 static void tipc_data_ready(struct sock *sk); 107 static void tipc_write_space(struct sock *sk); 108 static int tipc_release(struct socket *sock); 109 static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags); 110 static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p); 111 static void tipc_sk_timeout(unsigned long data); 112 static int tipc_sk_publish(struct tipc_sock *tsk, uint scope, 113 struct tipc_name_seq const *seq); 114 static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope, 115 struct tipc_name_seq const *seq); 116 static struct tipc_sock *tipc_sk_lookup(struct net *net, u32 portid); 117 static int tipc_sk_insert(struct tipc_sock *tsk); 118 static void tipc_sk_remove(struct tipc_sock *tsk); 119 static int __tipc_send_stream(struct socket *sock, struct msghdr *m, 120 size_t dsz); 121 static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz); 122 123 static const struct proto_ops packet_ops; 124 static const struct proto_ops stream_ops; 125 static const struct proto_ops msg_ops; 126 static struct proto tipc_proto; 127 128 static const struct nla_policy tipc_nl_sock_policy[TIPC_NLA_SOCK_MAX + 1] = { 129 [TIPC_NLA_SOCK_UNSPEC] = { .type = NLA_UNSPEC }, 130 [TIPC_NLA_SOCK_ADDR] = { .type = NLA_U32 }, 131 [TIPC_NLA_SOCK_REF] = { .type = NLA_U32 }, 132 [TIPC_NLA_SOCK_CON] = { .type = NLA_NESTED }, 133 [TIPC_NLA_SOCK_HAS_PUBL] = { .type = NLA_FLAG } 134 }; 135 136 static const struct rhashtable_params tsk_rht_params; 137 138 /* 139 * Revised TIPC socket locking policy: 140 * 141 * Most socket operations take the standard socket lock when they start 142 * and hold it until they finish (or until they need to sleep). Acquiring 143 * this lock grants the owner exclusive access to the fields of the socket 144 * data structures, with the exception of the backlog queue. A few socket 145 * operations can be done without taking the socket lock because they only 146 * read socket information that never changes during the life of the socket. 147 * 148 * Socket operations may acquire the lock for the associated TIPC port if they 149 * need to perform an operation on the port. If any routine needs to acquire 150 * both the socket lock and the port lock it must take the socket lock first 151 * to avoid the risk of deadlock. 152 * 153 * The dispatcher handling incoming messages cannot grab the socket lock in 154 * the standard fashion, since invoked it runs at the BH level and cannot block. 155 * Instead, it checks to see if the socket lock is currently owned by someone, 156 * and either handles the message itself or adds it to the socket's backlog 157 * queue; in the latter case the queued message is processed once the process 158 * owning the socket lock releases it. 159 * 160 * NOTE: Releasing the socket lock while an operation is sleeping overcomes 161 * the problem of a blocked socket operation preventing any other operations 162 * from occurring. However, applications must be careful if they have 163 * multiple threads trying to send (or receive) on the same socket, as these 164 * operations might interfere with each other. For example, doing a connect 165 * and a receive at the same time might allow the receive to consume the 166 * ACK message meant for the connect. While additional work could be done 167 * to try and overcome this, it doesn't seem to be worthwhile at the present. 168 * 169 * NOTE: Releasing the socket lock while an operation is sleeping also ensures 170 * that another operation that must be performed in a non-blocking manner is 171 * not delayed for very long because the lock has already been taken. 172 * 173 * NOTE: This code assumes that certain fields of a port/socket pair are 174 * constant over its lifetime; such fields can be examined without taking 175 * the socket lock and/or port lock, and do not need to be re-read even 176 * after resuming processing after waiting. These fields include: 177 * - socket type 178 * - pointer to socket sk structure (aka tipc_sock structure) 179 * - pointer to port structure 180 * - port reference 181 */ 182 183 static u32 tsk_own_node(struct tipc_sock *tsk) 184 { 185 return msg_prevnode(&tsk->phdr); 186 } 187 188 static u32 tsk_peer_node(struct tipc_sock *tsk) 189 { 190 return msg_destnode(&tsk->phdr); 191 } 192 193 static u32 tsk_peer_port(struct tipc_sock *tsk) 194 { 195 return msg_destport(&tsk->phdr); 196 } 197 198 static bool tsk_unreliable(struct tipc_sock *tsk) 199 { 200 return msg_src_droppable(&tsk->phdr) != 0; 201 } 202 203 static void tsk_set_unreliable(struct tipc_sock *tsk, bool unreliable) 204 { 205 msg_set_src_droppable(&tsk->phdr, unreliable ? 1 : 0); 206 } 207 208 static bool tsk_unreturnable(struct tipc_sock *tsk) 209 { 210 return msg_dest_droppable(&tsk->phdr) != 0; 211 } 212 213 static void tsk_set_unreturnable(struct tipc_sock *tsk, bool unreturnable) 214 { 215 msg_set_dest_droppable(&tsk->phdr, unreturnable ? 1 : 0); 216 } 217 218 static int tsk_importance(struct tipc_sock *tsk) 219 { 220 return msg_importance(&tsk->phdr); 221 } 222 223 static int tsk_set_importance(struct tipc_sock *tsk, int imp) 224 { 225 if (imp > TIPC_CRITICAL_IMPORTANCE) 226 return -EINVAL; 227 msg_set_importance(&tsk->phdr, (u32)imp); 228 return 0; 229 } 230 231 static struct tipc_sock *tipc_sk(const struct sock *sk) 232 { 233 return container_of(sk, struct tipc_sock, sk); 234 } 235 236 static int tsk_conn_cong(struct tipc_sock *tsk) 237 { 238 return tsk->sent_unacked >= TIPC_FLOWCTRL_WIN; 239 } 240 241 /** 242 * tsk_advance_rx_queue - discard first buffer in socket receive queue 243 * 244 * Caller must hold socket lock 245 */ 246 static void tsk_advance_rx_queue(struct sock *sk) 247 { 248 kfree_skb(__skb_dequeue(&sk->sk_receive_queue)); 249 } 250 251 /** 252 * tsk_rej_rx_queue - reject all buffers in socket receive queue 253 * 254 * Caller must hold socket lock 255 */ 256 static void tsk_rej_rx_queue(struct sock *sk) 257 { 258 struct sk_buff *skb; 259 u32 dnode; 260 u32 own_node = tsk_own_node(tipc_sk(sk)); 261 262 while ((skb = __skb_dequeue(&sk->sk_receive_queue))) { 263 if (tipc_msg_reverse(own_node, skb, &dnode, TIPC_ERR_NO_PORT)) 264 tipc_link_xmit_skb(sock_net(sk), skb, dnode, 0); 265 } 266 } 267 268 /* tsk_peer_msg - verify if message was sent by connected port's peer 269 * 270 * Handles cases where the node's network address has changed from 271 * the default of <0.0.0> to its configured setting. 272 */ 273 static bool tsk_peer_msg(struct tipc_sock *tsk, struct tipc_msg *msg) 274 { 275 struct tipc_net *tn = net_generic(sock_net(&tsk->sk), tipc_net_id); 276 u32 peer_port = tsk_peer_port(tsk); 277 u32 orig_node; 278 u32 peer_node; 279 280 if (unlikely(!tsk->connected)) 281 return false; 282 283 if (unlikely(msg_origport(msg) != peer_port)) 284 return false; 285 286 orig_node = msg_orignode(msg); 287 peer_node = tsk_peer_node(tsk); 288 289 if (likely(orig_node == peer_node)) 290 return true; 291 292 if (!orig_node && (peer_node == tn->own_addr)) 293 return true; 294 295 if (!peer_node && (orig_node == tn->own_addr)) 296 return true; 297 298 return false; 299 } 300 301 /** 302 * tipc_sk_create - create a TIPC socket 303 * @net: network namespace (must be default network) 304 * @sock: pre-allocated socket structure 305 * @protocol: protocol indicator (must be 0) 306 * @kern: caused by kernel or by userspace? 307 * 308 * This routine creates additional data structures used by the TIPC socket, 309 * initializes them, and links them together. 310 * 311 * Returns 0 on success, errno otherwise 312 */ 313 static int tipc_sk_create(struct net *net, struct socket *sock, 314 int protocol, int kern) 315 { 316 struct tipc_net *tn; 317 const struct proto_ops *ops; 318 socket_state state; 319 struct sock *sk; 320 struct tipc_sock *tsk; 321 struct tipc_msg *msg; 322 323 /* Validate arguments */ 324 if (unlikely(protocol != 0)) 325 return -EPROTONOSUPPORT; 326 327 switch (sock->type) { 328 case SOCK_STREAM: 329 ops = &stream_ops; 330 state = SS_UNCONNECTED; 331 break; 332 case SOCK_SEQPACKET: 333 ops = &packet_ops; 334 state = SS_UNCONNECTED; 335 break; 336 case SOCK_DGRAM: 337 case SOCK_RDM: 338 ops = &msg_ops; 339 state = SS_READY; 340 break; 341 default: 342 return -EPROTOTYPE; 343 } 344 345 /* Allocate socket's protocol area */ 346 sk = sk_alloc(net, AF_TIPC, GFP_KERNEL, &tipc_proto, kern); 347 if (sk == NULL) 348 return -ENOMEM; 349 350 tsk = tipc_sk(sk); 351 tsk->max_pkt = MAX_PKT_DEFAULT; 352 INIT_LIST_HEAD(&tsk->publications); 353 msg = &tsk->phdr; 354 tn = net_generic(sock_net(sk), tipc_net_id); 355 tipc_msg_init(tn->own_addr, msg, TIPC_LOW_IMPORTANCE, TIPC_NAMED_MSG, 356 NAMED_H_SIZE, 0); 357 358 /* Finish initializing socket data structures */ 359 sock->ops = ops; 360 sock->state = state; 361 sock_init_data(sock, sk); 362 if (tipc_sk_insert(tsk)) { 363 pr_warn("Socket create failed; port numbrer exhausted\n"); 364 return -EINVAL; 365 } 366 msg_set_origport(msg, tsk->portid); 367 setup_timer(&sk->sk_timer, tipc_sk_timeout, (unsigned long)tsk); 368 sk->sk_backlog_rcv = tipc_backlog_rcv; 369 sk->sk_rcvbuf = sysctl_tipc_rmem[1]; 370 sk->sk_data_ready = tipc_data_ready; 371 sk->sk_write_space = tipc_write_space; 372 tsk->conn_timeout = CONN_TIMEOUT_DEFAULT; 373 tsk->sent_unacked = 0; 374 atomic_set(&tsk->dupl_rcvcnt, 0); 375 376 if (sock->state == SS_READY) { 377 tsk_set_unreturnable(tsk, true); 378 if (sock->type == SOCK_DGRAM) 379 tsk_set_unreliable(tsk, true); 380 } 381 return 0; 382 } 383 384 static void tipc_sk_callback(struct rcu_head *head) 385 { 386 struct tipc_sock *tsk = container_of(head, struct tipc_sock, rcu); 387 388 sock_put(&tsk->sk); 389 } 390 391 /** 392 * tipc_release - destroy a TIPC socket 393 * @sock: socket to destroy 394 * 395 * This routine cleans up any messages that are still queued on the socket. 396 * For DGRAM and RDM socket types, all queued messages are rejected. 397 * For SEQPACKET and STREAM socket types, the first message is rejected 398 * and any others are discarded. (If the first message on a STREAM socket 399 * is partially-read, it is discarded and the next one is rejected instead.) 400 * 401 * NOTE: Rejected messages are not necessarily returned to the sender! They 402 * are returned or discarded according to the "destination droppable" setting 403 * specified for the message by the sender. 404 * 405 * Returns 0 on success, errno otherwise 406 */ 407 static int tipc_release(struct socket *sock) 408 { 409 struct sock *sk = sock->sk; 410 struct net *net; 411 struct tipc_sock *tsk; 412 struct sk_buff *skb; 413 u32 dnode; 414 415 /* 416 * Exit if socket isn't fully initialized (occurs when a failed accept() 417 * releases a pre-allocated child socket that was never used) 418 */ 419 if (sk == NULL) 420 return 0; 421 422 net = sock_net(sk); 423 tsk = tipc_sk(sk); 424 lock_sock(sk); 425 426 /* 427 * Reject all unreceived messages, except on an active connection 428 * (which disconnects locally & sends a 'FIN+' to peer) 429 */ 430 dnode = tsk_peer_node(tsk); 431 while (sock->state != SS_DISCONNECTING) { 432 skb = __skb_dequeue(&sk->sk_receive_queue); 433 if (skb == NULL) 434 break; 435 if (TIPC_SKB_CB(skb)->handle != NULL) 436 kfree_skb(skb); 437 else { 438 if ((sock->state == SS_CONNECTING) || 439 (sock->state == SS_CONNECTED)) { 440 sock->state = SS_DISCONNECTING; 441 tsk->connected = 0; 442 tipc_node_remove_conn(net, dnode, tsk->portid); 443 } 444 if (tipc_msg_reverse(tsk_own_node(tsk), skb, &dnode, 445 TIPC_ERR_NO_PORT)) 446 tipc_link_xmit_skb(net, skb, dnode, 0); 447 } 448 } 449 450 tipc_sk_withdraw(tsk, 0, NULL); 451 sk_stop_timer(sk, &sk->sk_timer); 452 tipc_sk_remove(tsk); 453 if (tsk->connected) { 454 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, 455 TIPC_CONN_MSG, SHORT_H_SIZE, 0, dnode, 456 tsk_own_node(tsk), tsk_peer_port(tsk), 457 tsk->portid, TIPC_ERR_NO_PORT); 458 if (skb) 459 tipc_link_xmit_skb(net, skb, dnode, tsk->portid); 460 tipc_node_remove_conn(net, dnode, tsk->portid); 461 } 462 463 /* Discard any remaining (connection-based) messages in receive queue */ 464 __skb_queue_purge(&sk->sk_receive_queue); 465 466 /* Reject any messages that accumulated in backlog queue */ 467 sock->state = SS_DISCONNECTING; 468 release_sock(sk); 469 470 call_rcu(&tsk->rcu, tipc_sk_callback); 471 sock->sk = NULL; 472 473 return 0; 474 } 475 476 /** 477 * tipc_bind - associate or disassocate TIPC name(s) with a socket 478 * @sock: socket structure 479 * @uaddr: socket address describing name(s) and desired operation 480 * @uaddr_len: size of socket address data structure 481 * 482 * Name and name sequence binding is indicated using a positive scope value; 483 * a negative scope value unbinds the specified name. Specifying no name 484 * (i.e. a socket address length of 0) unbinds all names from the socket. 485 * 486 * Returns 0 on success, errno otherwise 487 * 488 * NOTE: This routine doesn't need to take the socket lock since it doesn't 489 * access any non-constant socket information. 490 */ 491 static int tipc_bind(struct socket *sock, struct sockaddr *uaddr, 492 int uaddr_len) 493 { 494 struct sock *sk = sock->sk; 495 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr; 496 struct tipc_sock *tsk = tipc_sk(sk); 497 int res = -EINVAL; 498 499 lock_sock(sk); 500 if (unlikely(!uaddr_len)) { 501 res = tipc_sk_withdraw(tsk, 0, NULL); 502 goto exit; 503 } 504 505 if (uaddr_len < sizeof(struct sockaddr_tipc)) { 506 res = -EINVAL; 507 goto exit; 508 } 509 if (addr->family != AF_TIPC) { 510 res = -EAFNOSUPPORT; 511 goto exit; 512 } 513 514 if (addr->addrtype == TIPC_ADDR_NAME) 515 addr->addr.nameseq.upper = addr->addr.nameseq.lower; 516 else if (addr->addrtype != TIPC_ADDR_NAMESEQ) { 517 res = -EAFNOSUPPORT; 518 goto exit; 519 } 520 521 if ((addr->addr.nameseq.type < TIPC_RESERVED_TYPES) && 522 (addr->addr.nameseq.type != TIPC_TOP_SRV) && 523 (addr->addr.nameseq.type != TIPC_CFG_SRV)) { 524 res = -EACCES; 525 goto exit; 526 } 527 528 res = (addr->scope > 0) ? 529 tipc_sk_publish(tsk, addr->scope, &addr->addr.nameseq) : 530 tipc_sk_withdraw(tsk, -addr->scope, &addr->addr.nameseq); 531 exit: 532 release_sock(sk); 533 return res; 534 } 535 536 /** 537 * tipc_getname - get port ID of socket or peer socket 538 * @sock: socket structure 539 * @uaddr: area for returned socket address 540 * @uaddr_len: area for returned length of socket address 541 * @peer: 0 = own ID, 1 = current peer ID, 2 = current/former peer ID 542 * 543 * Returns 0 on success, errno otherwise 544 * 545 * NOTE: This routine doesn't need to take the socket lock since it only 546 * accesses socket information that is unchanging (or which changes in 547 * a completely predictable manner). 548 */ 549 static int tipc_getname(struct socket *sock, struct sockaddr *uaddr, 550 int *uaddr_len, int peer) 551 { 552 struct sockaddr_tipc *addr = (struct sockaddr_tipc *)uaddr; 553 struct tipc_sock *tsk = tipc_sk(sock->sk); 554 struct tipc_net *tn = net_generic(sock_net(sock->sk), tipc_net_id); 555 556 memset(addr, 0, sizeof(*addr)); 557 if (peer) { 558 if ((sock->state != SS_CONNECTED) && 559 ((peer != 2) || (sock->state != SS_DISCONNECTING))) 560 return -ENOTCONN; 561 addr->addr.id.ref = tsk_peer_port(tsk); 562 addr->addr.id.node = tsk_peer_node(tsk); 563 } else { 564 addr->addr.id.ref = tsk->portid; 565 addr->addr.id.node = tn->own_addr; 566 } 567 568 *uaddr_len = sizeof(*addr); 569 addr->addrtype = TIPC_ADDR_ID; 570 addr->family = AF_TIPC; 571 addr->scope = 0; 572 addr->addr.name.domain = 0; 573 574 return 0; 575 } 576 577 /** 578 * tipc_poll - read and possibly block on pollmask 579 * @file: file structure associated with the socket 580 * @sock: socket for which to calculate the poll bits 581 * @wait: ??? 582 * 583 * Returns pollmask value 584 * 585 * COMMENTARY: 586 * It appears that the usual socket locking mechanisms are not useful here 587 * since the pollmask info is potentially out-of-date the moment this routine 588 * exits. TCP and other protocols seem to rely on higher level poll routines 589 * to handle any preventable race conditions, so TIPC will do the same ... 590 * 591 * TIPC sets the returned events as follows: 592 * 593 * socket state flags set 594 * ------------ --------- 595 * unconnected no read flags 596 * POLLOUT if port is not congested 597 * 598 * connecting POLLIN/POLLRDNORM if ACK/NACK in rx queue 599 * no write flags 600 * 601 * connected POLLIN/POLLRDNORM if data in rx queue 602 * POLLOUT if port is not congested 603 * 604 * disconnecting POLLIN/POLLRDNORM/POLLHUP 605 * no write flags 606 * 607 * listening POLLIN if SYN in rx queue 608 * no write flags 609 * 610 * ready POLLIN/POLLRDNORM if data in rx queue 611 * [connectionless] POLLOUT (since port cannot be congested) 612 * 613 * IMPORTANT: The fact that a read or write operation is indicated does NOT 614 * imply that the operation will succeed, merely that it should be performed 615 * and will not block. 616 */ 617 static unsigned int tipc_poll(struct file *file, struct socket *sock, 618 poll_table *wait) 619 { 620 struct sock *sk = sock->sk; 621 struct tipc_sock *tsk = tipc_sk(sk); 622 u32 mask = 0; 623 624 sock_poll_wait(file, sk_sleep(sk), wait); 625 626 switch ((int)sock->state) { 627 case SS_UNCONNECTED: 628 if (!tsk->link_cong) 629 mask |= POLLOUT; 630 break; 631 case SS_READY: 632 case SS_CONNECTED: 633 if (!tsk->link_cong && !tsk_conn_cong(tsk)) 634 mask |= POLLOUT; 635 /* fall thru' */ 636 case SS_CONNECTING: 637 case SS_LISTENING: 638 if (!skb_queue_empty(&sk->sk_receive_queue)) 639 mask |= (POLLIN | POLLRDNORM); 640 break; 641 case SS_DISCONNECTING: 642 mask = (POLLIN | POLLRDNORM | POLLHUP); 643 break; 644 } 645 646 return mask; 647 } 648 649 /** 650 * tipc_sendmcast - send multicast message 651 * @sock: socket structure 652 * @seq: destination address 653 * @msg: message to send 654 * @dsz: total length of message data 655 * @timeo: timeout to wait for wakeup 656 * 657 * Called from function tipc_sendmsg(), which has done all sanity checks 658 * Returns the number of bytes sent on success, or errno 659 */ 660 static int tipc_sendmcast(struct socket *sock, struct tipc_name_seq *seq, 661 struct msghdr *msg, size_t dsz, long timeo) 662 { 663 struct sock *sk = sock->sk; 664 struct tipc_sock *tsk = tipc_sk(sk); 665 struct net *net = sock_net(sk); 666 struct tipc_msg *mhdr = &tsk->phdr; 667 struct sk_buff_head *pktchain = &sk->sk_write_queue; 668 struct iov_iter save = msg->msg_iter; 669 uint mtu; 670 int rc; 671 672 msg_set_type(mhdr, TIPC_MCAST_MSG); 673 msg_set_lookup_scope(mhdr, TIPC_CLUSTER_SCOPE); 674 msg_set_destport(mhdr, 0); 675 msg_set_destnode(mhdr, 0); 676 msg_set_nametype(mhdr, seq->type); 677 msg_set_namelower(mhdr, seq->lower); 678 msg_set_nameupper(mhdr, seq->upper); 679 msg_set_hdr_sz(mhdr, MCAST_H_SIZE); 680 681 new_mtu: 682 mtu = tipc_bclink_get_mtu(); 683 rc = tipc_msg_build(mhdr, msg, 0, dsz, mtu, pktchain); 684 if (unlikely(rc < 0)) 685 return rc; 686 687 do { 688 rc = tipc_bclink_xmit(net, pktchain); 689 if (likely(rc >= 0)) { 690 rc = dsz; 691 break; 692 } 693 if (rc == -EMSGSIZE) { 694 msg->msg_iter = save; 695 goto new_mtu; 696 } 697 if (rc != -ELINKCONG) 698 break; 699 tipc_sk(sk)->link_cong = 1; 700 rc = tipc_wait_for_sndmsg(sock, &timeo); 701 if (rc) 702 __skb_queue_purge(pktchain); 703 } while (!rc); 704 return rc; 705 } 706 707 /** 708 * tipc_sk_mcast_rcv - Deliver multicast messages to all destination sockets 709 * @arrvq: queue with arriving messages, to be cloned after destination lookup 710 * @inputq: queue with cloned messages, delivered to socket after dest lookup 711 * 712 * Multi-threaded: parallel calls with reference to same queues may occur 713 */ 714 void tipc_sk_mcast_rcv(struct net *net, struct sk_buff_head *arrvq, 715 struct sk_buff_head *inputq) 716 { 717 struct tipc_msg *msg; 718 struct tipc_plist dports; 719 u32 portid; 720 u32 scope = TIPC_CLUSTER_SCOPE; 721 struct sk_buff_head tmpq; 722 uint hsz; 723 struct sk_buff *skb, *_skb; 724 725 __skb_queue_head_init(&tmpq); 726 tipc_plist_init(&dports); 727 728 skb = tipc_skb_peek(arrvq, &inputq->lock); 729 for (; skb; skb = tipc_skb_peek(arrvq, &inputq->lock)) { 730 msg = buf_msg(skb); 731 hsz = skb_headroom(skb) + msg_hdr_sz(msg); 732 733 if (in_own_node(net, msg_orignode(msg))) 734 scope = TIPC_NODE_SCOPE; 735 736 /* Create destination port list and message clones: */ 737 tipc_nametbl_mc_translate(net, 738 msg_nametype(msg), msg_namelower(msg), 739 msg_nameupper(msg), scope, &dports); 740 portid = tipc_plist_pop(&dports); 741 for (; portid; portid = tipc_plist_pop(&dports)) { 742 _skb = __pskb_copy(skb, hsz, GFP_ATOMIC); 743 if (_skb) { 744 msg_set_destport(buf_msg(_skb), portid); 745 __skb_queue_tail(&tmpq, _skb); 746 continue; 747 } 748 pr_warn("Failed to clone mcast rcv buffer\n"); 749 } 750 /* Append to inputq if not already done by other thread */ 751 spin_lock_bh(&inputq->lock); 752 if (skb_peek(arrvq) == skb) { 753 skb_queue_splice_tail_init(&tmpq, inputq); 754 kfree_skb(__skb_dequeue(arrvq)); 755 } 756 spin_unlock_bh(&inputq->lock); 757 __skb_queue_purge(&tmpq); 758 kfree_skb(skb); 759 } 760 tipc_sk_rcv(net, inputq); 761 } 762 763 /** 764 * tipc_sk_proto_rcv - receive a connection mng protocol message 765 * @tsk: receiving socket 766 * @skb: pointer to message buffer. Set to NULL if buffer is consumed. 767 */ 768 static void tipc_sk_proto_rcv(struct tipc_sock *tsk, struct sk_buff **skb) 769 { 770 struct tipc_msg *msg = buf_msg(*skb); 771 int conn_cong; 772 u32 dnode; 773 u32 own_node = tsk_own_node(tsk); 774 /* Ignore if connection cannot be validated: */ 775 if (!tsk_peer_msg(tsk, msg)) 776 goto exit; 777 778 tsk->probing_state = TIPC_CONN_OK; 779 780 if (msg_type(msg) == CONN_ACK) { 781 conn_cong = tsk_conn_cong(tsk); 782 tsk->sent_unacked -= msg_msgcnt(msg); 783 if (conn_cong) 784 tsk->sk.sk_write_space(&tsk->sk); 785 } else if (msg_type(msg) == CONN_PROBE) { 786 if (tipc_msg_reverse(own_node, *skb, &dnode, TIPC_OK)) { 787 msg_set_type(msg, CONN_PROBE_REPLY); 788 return; 789 } 790 } 791 /* Do nothing if msg_type() == CONN_PROBE_REPLY */ 792 exit: 793 kfree_skb(*skb); 794 *skb = NULL; 795 } 796 797 static int tipc_wait_for_sndmsg(struct socket *sock, long *timeo_p) 798 { 799 struct sock *sk = sock->sk; 800 struct tipc_sock *tsk = tipc_sk(sk); 801 DEFINE_WAIT(wait); 802 int done; 803 804 do { 805 int err = sock_error(sk); 806 if (err) 807 return err; 808 if (sock->state == SS_DISCONNECTING) 809 return -EPIPE; 810 if (!*timeo_p) 811 return -EAGAIN; 812 if (signal_pending(current)) 813 return sock_intr_errno(*timeo_p); 814 815 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 816 done = sk_wait_event(sk, timeo_p, !tsk->link_cong); 817 finish_wait(sk_sleep(sk), &wait); 818 } while (!done); 819 return 0; 820 } 821 822 /** 823 * tipc_sendmsg - send message in connectionless manner 824 * @sock: socket structure 825 * @m: message to send 826 * @dsz: amount of user data to be sent 827 * 828 * Message must have an destination specified explicitly. 829 * Used for SOCK_RDM and SOCK_DGRAM messages, 830 * and for 'SYN' messages on SOCK_SEQPACKET and SOCK_STREAM connections. 831 * (Note: 'SYN+' is prohibited on SOCK_STREAM.) 832 * 833 * Returns the number of bytes sent on success, or errno otherwise 834 */ 835 static int tipc_sendmsg(struct socket *sock, 836 struct msghdr *m, size_t dsz) 837 { 838 struct sock *sk = sock->sk; 839 int ret; 840 841 lock_sock(sk); 842 ret = __tipc_sendmsg(sock, m, dsz); 843 release_sock(sk); 844 845 return ret; 846 } 847 848 static int __tipc_sendmsg(struct socket *sock, struct msghdr *m, size_t dsz) 849 { 850 DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name); 851 struct sock *sk = sock->sk; 852 struct tipc_sock *tsk = tipc_sk(sk); 853 struct net *net = sock_net(sk); 854 struct tipc_msg *mhdr = &tsk->phdr; 855 u32 dnode, dport; 856 struct sk_buff_head *pktchain = &sk->sk_write_queue; 857 struct sk_buff *skb; 858 struct tipc_name_seq *seq; 859 struct iov_iter save; 860 u32 mtu; 861 long timeo; 862 int rc; 863 864 if (dsz > TIPC_MAX_USER_MSG_SIZE) 865 return -EMSGSIZE; 866 if (unlikely(!dest)) { 867 if (tsk->connected && sock->state == SS_READY) 868 dest = &tsk->remote; 869 else 870 return -EDESTADDRREQ; 871 } else if (unlikely(m->msg_namelen < sizeof(*dest)) || 872 dest->family != AF_TIPC) { 873 return -EINVAL; 874 } 875 if (unlikely(sock->state != SS_READY)) { 876 if (sock->state == SS_LISTENING) 877 return -EPIPE; 878 if (sock->state != SS_UNCONNECTED) 879 return -EISCONN; 880 if (tsk->published) 881 return -EOPNOTSUPP; 882 if (dest->addrtype == TIPC_ADDR_NAME) { 883 tsk->conn_type = dest->addr.name.name.type; 884 tsk->conn_instance = dest->addr.name.name.instance; 885 } 886 } 887 seq = &dest->addr.nameseq; 888 timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT); 889 890 if (dest->addrtype == TIPC_ADDR_MCAST) { 891 return tipc_sendmcast(sock, seq, m, dsz, timeo); 892 } else if (dest->addrtype == TIPC_ADDR_NAME) { 893 u32 type = dest->addr.name.name.type; 894 u32 inst = dest->addr.name.name.instance; 895 u32 domain = dest->addr.name.domain; 896 897 dnode = domain; 898 msg_set_type(mhdr, TIPC_NAMED_MSG); 899 msg_set_hdr_sz(mhdr, NAMED_H_SIZE); 900 msg_set_nametype(mhdr, type); 901 msg_set_nameinst(mhdr, inst); 902 msg_set_lookup_scope(mhdr, tipc_addr_scope(domain)); 903 dport = tipc_nametbl_translate(net, type, inst, &dnode); 904 msg_set_destnode(mhdr, dnode); 905 msg_set_destport(mhdr, dport); 906 if (unlikely(!dport && !dnode)) 907 return -EHOSTUNREACH; 908 } else if (dest->addrtype == TIPC_ADDR_ID) { 909 dnode = dest->addr.id.node; 910 msg_set_type(mhdr, TIPC_DIRECT_MSG); 911 msg_set_lookup_scope(mhdr, 0); 912 msg_set_destnode(mhdr, dnode); 913 msg_set_destport(mhdr, dest->addr.id.ref); 914 msg_set_hdr_sz(mhdr, BASIC_H_SIZE); 915 } 916 917 save = m->msg_iter; 918 new_mtu: 919 mtu = tipc_node_get_mtu(net, dnode, tsk->portid); 920 rc = tipc_msg_build(mhdr, m, 0, dsz, mtu, pktchain); 921 if (rc < 0) 922 return rc; 923 924 do { 925 skb = skb_peek(pktchain); 926 TIPC_SKB_CB(skb)->wakeup_pending = tsk->link_cong; 927 rc = tipc_link_xmit(net, pktchain, dnode, tsk->portid); 928 if (likely(rc >= 0)) { 929 if (sock->state != SS_READY) 930 sock->state = SS_CONNECTING; 931 rc = dsz; 932 break; 933 } 934 if (rc == -EMSGSIZE) { 935 m->msg_iter = save; 936 goto new_mtu; 937 } 938 if (rc != -ELINKCONG) 939 break; 940 tsk->link_cong = 1; 941 rc = tipc_wait_for_sndmsg(sock, &timeo); 942 if (rc) 943 __skb_queue_purge(pktchain); 944 } while (!rc); 945 946 return rc; 947 } 948 949 static int tipc_wait_for_sndpkt(struct socket *sock, long *timeo_p) 950 { 951 struct sock *sk = sock->sk; 952 struct tipc_sock *tsk = tipc_sk(sk); 953 DEFINE_WAIT(wait); 954 int done; 955 956 do { 957 int err = sock_error(sk); 958 if (err) 959 return err; 960 if (sock->state == SS_DISCONNECTING) 961 return -EPIPE; 962 else if (sock->state != SS_CONNECTED) 963 return -ENOTCONN; 964 if (!*timeo_p) 965 return -EAGAIN; 966 if (signal_pending(current)) 967 return sock_intr_errno(*timeo_p); 968 969 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 970 done = sk_wait_event(sk, timeo_p, 971 (!tsk->link_cong && 972 !tsk_conn_cong(tsk)) || 973 !tsk->connected); 974 finish_wait(sk_sleep(sk), &wait); 975 } while (!done); 976 return 0; 977 } 978 979 /** 980 * tipc_send_stream - send stream-oriented data 981 * @sock: socket structure 982 * @m: data to send 983 * @dsz: total length of data to be transmitted 984 * 985 * Used for SOCK_STREAM data. 986 * 987 * Returns the number of bytes sent on success (or partial success), 988 * or errno if no data sent 989 */ 990 static int tipc_send_stream(struct socket *sock, struct msghdr *m, size_t dsz) 991 { 992 struct sock *sk = sock->sk; 993 int ret; 994 995 lock_sock(sk); 996 ret = __tipc_send_stream(sock, m, dsz); 997 release_sock(sk); 998 999 return ret; 1000 } 1001 1002 static int __tipc_send_stream(struct socket *sock, struct msghdr *m, size_t dsz) 1003 { 1004 struct sock *sk = sock->sk; 1005 struct net *net = sock_net(sk); 1006 struct tipc_sock *tsk = tipc_sk(sk); 1007 struct tipc_msg *mhdr = &tsk->phdr; 1008 struct sk_buff_head *pktchain = &sk->sk_write_queue; 1009 DECLARE_SOCKADDR(struct sockaddr_tipc *, dest, m->msg_name); 1010 u32 portid = tsk->portid; 1011 int rc = -EINVAL; 1012 long timeo; 1013 u32 dnode; 1014 uint mtu, send, sent = 0; 1015 struct iov_iter save; 1016 1017 /* Handle implied connection establishment */ 1018 if (unlikely(dest)) { 1019 rc = __tipc_sendmsg(sock, m, dsz); 1020 if (dsz && (dsz == rc)) 1021 tsk->sent_unacked = 1; 1022 return rc; 1023 } 1024 if (dsz > (uint)INT_MAX) 1025 return -EMSGSIZE; 1026 1027 if (unlikely(sock->state != SS_CONNECTED)) { 1028 if (sock->state == SS_DISCONNECTING) 1029 return -EPIPE; 1030 else 1031 return -ENOTCONN; 1032 } 1033 1034 timeo = sock_sndtimeo(sk, m->msg_flags & MSG_DONTWAIT); 1035 dnode = tsk_peer_node(tsk); 1036 1037 next: 1038 save = m->msg_iter; 1039 mtu = tsk->max_pkt; 1040 send = min_t(uint, dsz - sent, TIPC_MAX_USER_MSG_SIZE); 1041 rc = tipc_msg_build(mhdr, m, sent, send, mtu, pktchain); 1042 if (unlikely(rc < 0)) 1043 return rc; 1044 do { 1045 if (likely(!tsk_conn_cong(tsk))) { 1046 rc = tipc_link_xmit(net, pktchain, dnode, portid); 1047 if (likely(!rc)) { 1048 tsk->sent_unacked++; 1049 sent += send; 1050 if (sent == dsz) 1051 break; 1052 goto next; 1053 } 1054 if (rc == -EMSGSIZE) { 1055 tsk->max_pkt = tipc_node_get_mtu(net, dnode, 1056 portid); 1057 m->msg_iter = save; 1058 goto next; 1059 } 1060 if (rc != -ELINKCONG) 1061 break; 1062 tsk->link_cong = 1; 1063 } 1064 rc = tipc_wait_for_sndpkt(sock, &timeo); 1065 if (rc) 1066 __skb_queue_purge(pktchain); 1067 } while (!rc); 1068 1069 return sent ? sent : rc; 1070 } 1071 1072 /** 1073 * tipc_send_packet - send a connection-oriented message 1074 * @sock: socket structure 1075 * @m: message to send 1076 * @dsz: length of data to be transmitted 1077 * 1078 * Used for SOCK_SEQPACKET messages. 1079 * 1080 * Returns the number of bytes sent on success, or errno otherwise 1081 */ 1082 static int tipc_send_packet(struct socket *sock, struct msghdr *m, size_t dsz) 1083 { 1084 if (dsz > TIPC_MAX_USER_MSG_SIZE) 1085 return -EMSGSIZE; 1086 1087 return tipc_send_stream(sock, m, dsz); 1088 } 1089 1090 /* tipc_sk_finish_conn - complete the setup of a connection 1091 */ 1092 static void tipc_sk_finish_conn(struct tipc_sock *tsk, u32 peer_port, 1093 u32 peer_node) 1094 { 1095 struct sock *sk = &tsk->sk; 1096 struct net *net = sock_net(sk); 1097 struct tipc_msg *msg = &tsk->phdr; 1098 1099 msg_set_destnode(msg, peer_node); 1100 msg_set_destport(msg, peer_port); 1101 msg_set_type(msg, TIPC_CONN_MSG); 1102 msg_set_lookup_scope(msg, 0); 1103 msg_set_hdr_sz(msg, SHORT_H_SIZE); 1104 1105 tsk->probing_intv = CONN_PROBING_INTERVAL; 1106 tsk->probing_state = TIPC_CONN_OK; 1107 tsk->connected = 1; 1108 sk_reset_timer(sk, &sk->sk_timer, jiffies + tsk->probing_intv); 1109 tipc_node_add_conn(net, peer_node, tsk->portid, peer_port); 1110 tsk->max_pkt = tipc_node_get_mtu(net, peer_node, tsk->portid); 1111 } 1112 1113 /** 1114 * set_orig_addr - capture sender's address for received message 1115 * @m: descriptor for message info 1116 * @msg: received message header 1117 * 1118 * Note: Address is not captured if not requested by receiver. 1119 */ 1120 static void set_orig_addr(struct msghdr *m, struct tipc_msg *msg) 1121 { 1122 DECLARE_SOCKADDR(struct sockaddr_tipc *, addr, m->msg_name); 1123 1124 if (addr) { 1125 addr->family = AF_TIPC; 1126 addr->addrtype = TIPC_ADDR_ID; 1127 memset(&addr->addr, 0, sizeof(addr->addr)); 1128 addr->addr.id.ref = msg_origport(msg); 1129 addr->addr.id.node = msg_orignode(msg); 1130 addr->addr.name.domain = 0; /* could leave uninitialized */ 1131 addr->scope = 0; /* could leave uninitialized */ 1132 m->msg_namelen = sizeof(struct sockaddr_tipc); 1133 } 1134 } 1135 1136 /** 1137 * tipc_sk_anc_data_recv - optionally capture ancillary data for received message 1138 * @m: descriptor for message info 1139 * @msg: received message header 1140 * @tsk: TIPC port associated with message 1141 * 1142 * Note: Ancillary data is not captured if not requested by receiver. 1143 * 1144 * Returns 0 if successful, otherwise errno 1145 */ 1146 static int tipc_sk_anc_data_recv(struct msghdr *m, struct tipc_msg *msg, 1147 struct tipc_sock *tsk) 1148 { 1149 u32 anc_data[3]; 1150 u32 err; 1151 u32 dest_type; 1152 int has_name; 1153 int res; 1154 1155 if (likely(m->msg_controllen == 0)) 1156 return 0; 1157 1158 /* Optionally capture errored message object(s) */ 1159 err = msg ? msg_errcode(msg) : 0; 1160 if (unlikely(err)) { 1161 anc_data[0] = err; 1162 anc_data[1] = msg_data_sz(msg); 1163 res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data); 1164 if (res) 1165 return res; 1166 if (anc_data[1]) { 1167 res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1], 1168 msg_data(msg)); 1169 if (res) 1170 return res; 1171 } 1172 } 1173 1174 /* Optionally capture message destination object */ 1175 dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG; 1176 switch (dest_type) { 1177 case TIPC_NAMED_MSG: 1178 has_name = 1; 1179 anc_data[0] = msg_nametype(msg); 1180 anc_data[1] = msg_namelower(msg); 1181 anc_data[2] = msg_namelower(msg); 1182 break; 1183 case TIPC_MCAST_MSG: 1184 has_name = 1; 1185 anc_data[0] = msg_nametype(msg); 1186 anc_data[1] = msg_namelower(msg); 1187 anc_data[2] = msg_nameupper(msg); 1188 break; 1189 case TIPC_CONN_MSG: 1190 has_name = (tsk->conn_type != 0); 1191 anc_data[0] = tsk->conn_type; 1192 anc_data[1] = tsk->conn_instance; 1193 anc_data[2] = tsk->conn_instance; 1194 break; 1195 default: 1196 has_name = 0; 1197 } 1198 if (has_name) { 1199 res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data); 1200 if (res) 1201 return res; 1202 } 1203 1204 return 0; 1205 } 1206 1207 static void tipc_sk_send_ack(struct tipc_sock *tsk, uint ack) 1208 { 1209 struct net *net = sock_net(&tsk->sk); 1210 struct sk_buff *skb = NULL; 1211 struct tipc_msg *msg; 1212 u32 peer_port = tsk_peer_port(tsk); 1213 u32 dnode = tsk_peer_node(tsk); 1214 1215 if (!tsk->connected) 1216 return; 1217 skb = tipc_msg_create(CONN_MANAGER, CONN_ACK, INT_H_SIZE, 0, 1218 dnode, tsk_own_node(tsk), peer_port, 1219 tsk->portid, TIPC_OK); 1220 if (!skb) 1221 return; 1222 msg = buf_msg(skb); 1223 msg_set_msgcnt(msg, ack); 1224 tipc_link_xmit_skb(net, skb, dnode, msg_link_selector(msg)); 1225 } 1226 1227 static int tipc_wait_for_rcvmsg(struct socket *sock, long *timeop) 1228 { 1229 struct sock *sk = sock->sk; 1230 DEFINE_WAIT(wait); 1231 long timeo = *timeop; 1232 int err; 1233 1234 for (;;) { 1235 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1236 if (timeo && skb_queue_empty(&sk->sk_receive_queue)) { 1237 if (sock->state == SS_DISCONNECTING) { 1238 err = -ENOTCONN; 1239 break; 1240 } 1241 release_sock(sk); 1242 timeo = schedule_timeout(timeo); 1243 lock_sock(sk); 1244 } 1245 err = 0; 1246 if (!skb_queue_empty(&sk->sk_receive_queue)) 1247 break; 1248 err = -EAGAIN; 1249 if (!timeo) 1250 break; 1251 err = sock_intr_errno(timeo); 1252 if (signal_pending(current)) 1253 break; 1254 } 1255 finish_wait(sk_sleep(sk), &wait); 1256 *timeop = timeo; 1257 return err; 1258 } 1259 1260 /** 1261 * tipc_recvmsg - receive packet-oriented message 1262 * @m: descriptor for message info 1263 * @buf_len: total size of user buffer area 1264 * @flags: receive flags 1265 * 1266 * Used for SOCK_DGRAM, SOCK_RDM, and SOCK_SEQPACKET messages. 1267 * If the complete message doesn't fit in user area, truncate it. 1268 * 1269 * Returns size of returned message data, errno otherwise 1270 */ 1271 static int tipc_recvmsg(struct socket *sock, struct msghdr *m, size_t buf_len, 1272 int flags) 1273 { 1274 struct sock *sk = sock->sk; 1275 struct tipc_sock *tsk = tipc_sk(sk); 1276 struct sk_buff *buf; 1277 struct tipc_msg *msg; 1278 long timeo; 1279 unsigned int sz; 1280 u32 err; 1281 int res; 1282 1283 /* Catch invalid receive requests */ 1284 if (unlikely(!buf_len)) 1285 return -EINVAL; 1286 1287 lock_sock(sk); 1288 1289 if (unlikely(sock->state == SS_UNCONNECTED)) { 1290 res = -ENOTCONN; 1291 goto exit; 1292 } 1293 1294 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1295 restart: 1296 1297 /* Look for a message in receive queue; wait if necessary */ 1298 res = tipc_wait_for_rcvmsg(sock, &timeo); 1299 if (res) 1300 goto exit; 1301 1302 /* Look at first message in receive queue */ 1303 buf = skb_peek(&sk->sk_receive_queue); 1304 msg = buf_msg(buf); 1305 sz = msg_data_sz(msg); 1306 err = msg_errcode(msg); 1307 1308 /* Discard an empty non-errored message & try again */ 1309 if ((!sz) && (!err)) { 1310 tsk_advance_rx_queue(sk); 1311 goto restart; 1312 } 1313 1314 /* Capture sender's address (optional) */ 1315 set_orig_addr(m, msg); 1316 1317 /* Capture ancillary data (optional) */ 1318 res = tipc_sk_anc_data_recv(m, msg, tsk); 1319 if (res) 1320 goto exit; 1321 1322 /* Capture message data (if valid) & compute return value (always) */ 1323 if (!err) { 1324 if (unlikely(buf_len < sz)) { 1325 sz = buf_len; 1326 m->msg_flags |= MSG_TRUNC; 1327 } 1328 res = skb_copy_datagram_msg(buf, msg_hdr_sz(msg), m, sz); 1329 if (res) 1330 goto exit; 1331 res = sz; 1332 } else { 1333 if ((sock->state == SS_READY) || 1334 ((err == TIPC_CONN_SHUTDOWN) || m->msg_control)) 1335 res = 0; 1336 else 1337 res = -ECONNRESET; 1338 } 1339 1340 /* Consume received message (optional) */ 1341 if (likely(!(flags & MSG_PEEK))) { 1342 if ((sock->state != SS_READY) && 1343 (++tsk->rcv_unacked >= TIPC_CONNACK_INTV)) { 1344 tipc_sk_send_ack(tsk, tsk->rcv_unacked); 1345 tsk->rcv_unacked = 0; 1346 } 1347 tsk_advance_rx_queue(sk); 1348 } 1349 exit: 1350 release_sock(sk); 1351 return res; 1352 } 1353 1354 /** 1355 * tipc_recv_stream - receive stream-oriented data 1356 * @m: descriptor for message info 1357 * @buf_len: total size of user buffer area 1358 * @flags: receive flags 1359 * 1360 * Used for SOCK_STREAM messages only. If not enough data is available 1361 * will optionally wait for more; never truncates data. 1362 * 1363 * Returns size of returned message data, errno otherwise 1364 */ 1365 static int tipc_recv_stream(struct socket *sock, struct msghdr *m, 1366 size_t buf_len, int flags) 1367 { 1368 struct sock *sk = sock->sk; 1369 struct tipc_sock *tsk = tipc_sk(sk); 1370 struct sk_buff *buf; 1371 struct tipc_msg *msg; 1372 long timeo; 1373 unsigned int sz; 1374 int sz_to_copy, target, needed; 1375 int sz_copied = 0; 1376 u32 err; 1377 int res = 0; 1378 1379 /* Catch invalid receive attempts */ 1380 if (unlikely(!buf_len)) 1381 return -EINVAL; 1382 1383 lock_sock(sk); 1384 1385 if (unlikely(sock->state == SS_UNCONNECTED)) { 1386 res = -ENOTCONN; 1387 goto exit; 1388 } 1389 1390 target = sock_rcvlowat(sk, flags & MSG_WAITALL, buf_len); 1391 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1392 1393 restart: 1394 /* Look for a message in receive queue; wait if necessary */ 1395 res = tipc_wait_for_rcvmsg(sock, &timeo); 1396 if (res) 1397 goto exit; 1398 1399 /* Look at first message in receive queue */ 1400 buf = skb_peek(&sk->sk_receive_queue); 1401 msg = buf_msg(buf); 1402 sz = msg_data_sz(msg); 1403 err = msg_errcode(msg); 1404 1405 /* Discard an empty non-errored message & try again */ 1406 if ((!sz) && (!err)) { 1407 tsk_advance_rx_queue(sk); 1408 goto restart; 1409 } 1410 1411 /* Optionally capture sender's address & ancillary data of first msg */ 1412 if (sz_copied == 0) { 1413 set_orig_addr(m, msg); 1414 res = tipc_sk_anc_data_recv(m, msg, tsk); 1415 if (res) 1416 goto exit; 1417 } 1418 1419 /* Capture message data (if valid) & compute return value (always) */ 1420 if (!err) { 1421 u32 offset = (u32)(unsigned long)(TIPC_SKB_CB(buf)->handle); 1422 1423 sz -= offset; 1424 needed = (buf_len - sz_copied); 1425 sz_to_copy = (sz <= needed) ? sz : needed; 1426 1427 res = skb_copy_datagram_msg(buf, msg_hdr_sz(msg) + offset, 1428 m, sz_to_copy); 1429 if (res) 1430 goto exit; 1431 1432 sz_copied += sz_to_copy; 1433 1434 if (sz_to_copy < sz) { 1435 if (!(flags & MSG_PEEK)) 1436 TIPC_SKB_CB(buf)->handle = 1437 (void *)(unsigned long)(offset + sz_to_copy); 1438 goto exit; 1439 } 1440 } else { 1441 if (sz_copied != 0) 1442 goto exit; /* can't add error msg to valid data */ 1443 1444 if ((err == TIPC_CONN_SHUTDOWN) || m->msg_control) 1445 res = 0; 1446 else 1447 res = -ECONNRESET; 1448 } 1449 1450 /* Consume received message (optional) */ 1451 if (likely(!(flags & MSG_PEEK))) { 1452 if (unlikely(++tsk->rcv_unacked >= TIPC_CONNACK_INTV)) { 1453 tipc_sk_send_ack(tsk, tsk->rcv_unacked); 1454 tsk->rcv_unacked = 0; 1455 } 1456 tsk_advance_rx_queue(sk); 1457 } 1458 1459 /* Loop around if more data is required */ 1460 if ((sz_copied < buf_len) && /* didn't get all requested data */ 1461 (!skb_queue_empty(&sk->sk_receive_queue) || 1462 (sz_copied < target)) && /* and more is ready or required */ 1463 (!(flags & MSG_PEEK)) && /* and aren't just peeking at data */ 1464 (!err)) /* and haven't reached a FIN */ 1465 goto restart; 1466 1467 exit: 1468 release_sock(sk); 1469 return sz_copied ? sz_copied : res; 1470 } 1471 1472 /** 1473 * tipc_write_space - wake up thread if port congestion is released 1474 * @sk: socket 1475 */ 1476 static void tipc_write_space(struct sock *sk) 1477 { 1478 struct socket_wq *wq; 1479 1480 rcu_read_lock(); 1481 wq = rcu_dereference(sk->sk_wq); 1482 if (wq_has_sleeper(wq)) 1483 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT | 1484 POLLWRNORM | POLLWRBAND); 1485 rcu_read_unlock(); 1486 } 1487 1488 /** 1489 * tipc_data_ready - wake up threads to indicate messages have been received 1490 * @sk: socket 1491 * @len: the length of messages 1492 */ 1493 static void tipc_data_ready(struct sock *sk) 1494 { 1495 struct socket_wq *wq; 1496 1497 rcu_read_lock(); 1498 wq = rcu_dereference(sk->sk_wq); 1499 if (wq_has_sleeper(wq)) 1500 wake_up_interruptible_sync_poll(&wq->wait, POLLIN | 1501 POLLRDNORM | POLLRDBAND); 1502 rcu_read_unlock(); 1503 } 1504 1505 /** 1506 * filter_connect - Handle all incoming messages for a connection-based socket 1507 * @tsk: TIPC socket 1508 * @skb: pointer to message buffer. Set to NULL if buffer is consumed 1509 * 1510 * Returns 0 (TIPC_OK) if everything ok, -TIPC_ERR_NO_PORT otherwise 1511 */ 1512 static int filter_connect(struct tipc_sock *tsk, struct sk_buff **skb) 1513 { 1514 struct sock *sk = &tsk->sk; 1515 struct net *net = sock_net(sk); 1516 struct socket *sock = sk->sk_socket; 1517 struct tipc_msg *msg = buf_msg(*skb); 1518 int retval = -TIPC_ERR_NO_PORT; 1519 1520 if (msg_mcast(msg)) 1521 return retval; 1522 1523 switch ((int)sock->state) { 1524 case SS_CONNECTED: 1525 /* Accept only connection-based messages sent by peer */ 1526 if (tsk_peer_msg(tsk, msg)) { 1527 if (unlikely(msg_errcode(msg))) { 1528 sock->state = SS_DISCONNECTING; 1529 tsk->connected = 0; 1530 /* let timer expire on it's own */ 1531 tipc_node_remove_conn(net, tsk_peer_node(tsk), 1532 tsk->portid); 1533 } 1534 retval = TIPC_OK; 1535 } 1536 break; 1537 case SS_CONNECTING: 1538 /* Accept only ACK or NACK message */ 1539 1540 if (unlikely(!msg_connected(msg))) 1541 break; 1542 1543 if (unlikely(msg_errcode(msg))) { 1544 sock->state = SS_DISCONNECTING; 1545 sk->sk_err = ECONNREFUSED; 1546 retval = TIPC_OK; 1547 break; 1548 } 1549 1550 if (unlikely(msg_importance(msg) > TIPC_CRITICAL_IMPORTANCE)) { 1551 sock->state = SS_DISCONNECTING; 1552 sk->sk_err = EINVAL; 1553 retval = TIPC_OK; 1554 break; 1555 } 1556 1557 tipc_sk_finish_conn(tsk, msg_origport(msg), msg_orignode(msg)); 1558 msg_set_importance(&tsk->phdr, msg_importance(msg)); 1559 sock->state = SS_CONNECTED; 1560 1561 /* If an incoming message is an 'ACK-', it should be 1562 * discarded here because it doesn't contain useful 1563 * data. In addition, we should try to wake up 1564 * connect() routine if sleeping. 1565 */ 1566 if (msg_data_sz(msg) == 0) { 1567 kfree_skb(*skb); 1568 *skb = NULL; 1569 if (waitqueue_active(sk_sleep(sk))) 1570 wake_up_interruptible(sk_sleep(sk)); 1571 } 1572 retval = TIPC_OK; 1573 break; 1574 case SS_LISTENING: 1575 case SS_UNCONNECTED: 1576 /* Accept only SYN message */ 1577 if (!msg_connected(msg) && !(msg_errcode(msg))) 1578 retval = TIPC_OK; 1579 break; 1580 case SS_DISCONNECTING: 1581 break; 1582 default: 1583 pr_err("Unknown socket state %u\n", sock->state); 1584 } 1585 return retval; 1586 } 1587 1588 /** 1589 * rcvbuf_limit - get proper overload limit of socket receive queue 1590 * @sk: socket 1591 * @buf: message 1592 * 1593 * For all connection oriented messages, irrespective of importance, 1594 * the default overload value (i.e. 67MB) is set as limit. 1595 * 1596 * For all connectionless messages, by default new queue limits are 1597 * as belows: 1598 * 1599 * TIPC_LOW_IMPORTANCE (4 MB) 1600 * TIPC_MEDIUM_IMPORTANCE (8 MB) 1601 * TIPC_HIGH_IMPORTANCE (16 MB) 1602 * TIPC_CRITICAL_IMPORTANCE (32 MB) 1603 * 1604 * Returns overload limit according to corresponding message importance 1605 */ 1606 static unsigned int rcvbuf_limit(struct sock *sk, struct sk_buff *buf) 1607 { 1608 struct tipc_msg *msg = buf_msg(buf); 1609 1610 if (msg_connected(msg)) 1611 return sysctl_tipc_rmem[2]; 1612 1613 return sk->sk_rcvbuf >> TIPC_CRITICAL_IMPORTANCE << 1614 msg_importance(msg); 1615 } 1616 1617 /** 1618 * filter_rcv - validate incoming message 1619 * @sk: socket 1620 * @skb: pointer to message. Set to NULL if buffer is consumed. 1621 * 1622 * Enqueues message on receive queue if acceptable; optionally handles 1623 * disconnect indication for a connected socket. 1624 * 1625 * Called with socket lock already taken 1626 * 1627 * Returns 0 (TIPC_OK) if message was ok, -TIPC error code if rejected 1628 */ 1629 static int filter_rcv(struct sock *sk, struct sk_buff **skb) 1630 { 1631 struct socket *sock = sk->sk_socket; 1632 struct tipc_sock *tsk = tipc_sk(sk); 1633 struct tipc_msg *msg = buf_msg(*skb); 1634 unsigned int limit = rcvbuf_limit(sk, *skb); 1635 int rc = TIPC_OK; 1636 1637 if (unlikely(msg_user(msg) == CONN_MANAGER)) { 1638 tipc_sk_proto_rcv(tsk, skb); 1639 return TIPC_OK; 1640 } 1641 1642 if (unlikely(msg_user(msg) == SOCK_WAKEUP)) { 1643 kfree_skb(*skb); 1644 tsk->link_cong = 0; 1645 sk->sk_write_space(sk); 1646 *skb = NULL; 1647 return TIPC_OK; 1648 } 1649 1650 /* Reject message if it is wrong sort of message for socket */ 1651 if (msg_type(msg) > TIPC_DIRECT_MSG) 1652 return -TIPC_ERR_NO_PORT; 1653 1654 if (sock->state == SS_READY) { 1655 if (msg_connected(msg)) 1656 return -TIPC_ERR_NO_PORT; 1657 } else { 1658 rc = filter_connect(tsk, skb); 1659 if (rc != TIPC_OK || !*skb) 1660 return rc; 1661 } 1662 1663 /* Reject message if there isn't room to queue it */ 1664 if (sk_rmem_alloc_get(sk) + (*skb)->truesize >= limit) 1665 return -TIPC_ERR_OVERLOAD; 1666 1667 /* Enqueue message */ 1668 TIPC_SKB_CB(*skb)->handle = NULL; 1669 __skb_queue_tail(&sk->sk_receive_queue, *skb); 1670 skb_set_owner_r(*skb, sk); 1671 1672 sk->sk_data_ready(sk); 1673 *skb = NULL; 1674 return TIPC_OK; 1675 } 1676 1677 /** 1678 * tipc_backlog_rcv - handle incoming message from backlog queue 1679 * @sk: socket 1680 * @skb: message 1681 * 1682 * Caller must hold socket lock 1683 * 1684 * Returns 0 1685 */ 1686 static int tipc_backlog_rcv(struct sock *sk, struct sk_buff *skb) 1687 { 1688 int err; 1689 atomic_t *dcnt; 1690 u32 dnode; 1691 struct tipc_sock *tsk = tipc_sk(sk); 1692 struct net *net = sock_net(sk); 1693 uint truesize = skb->truesize; 1694 1695 err = filter_rcv(sk, &skb); 1696 if (likely(!skb)) { 1697 dcnt = &tsk->dupl_rcvcnt; 1698 if (atomic_read(dcnt) < TIPC_CONN_OVERLOAD_LIMIT) 1699 atomic_add(truesize, dcnt); 1700 return 0; 1701 } 1702 if (!err || tipc_msg_reverse(tsk_own_node(tsk), skb, &dnode, -err)) 1703 tipc_link_xmit_skb(net, skb, dnode, tsk->portid); 1704 return 0; 1705 } 1706 1707 /** 1708 * tipc_sk_enqueue - extract all buffers with destination 'dport' from 1709 * inputq and try adding them to socket or backlog queue 1710 * @inputq: list of incoming buffers with potentially different destinations 1711 * @sk: socket where the buffers should be enqueued 1712 * @dport: port number for the socket 1713 * @_skb: returned buffer to be forwarded or rejected, if applicable 1714 * 1715 * Caller must hold socket lock 1716 * 1717 * Returns TIPC_OK if all buffers enqueued, otherwise -TIPC_ERR_OVERLOAD 1718 * or -TIPC_ERR_NO_PORT 1719 */ 1720 static int tipc_sk_enqueue(struct sk_buff_head *inputq, struct sock *sk, 1721 u32 dport, struct sk_buff **_skb) 1722 { 1723 unsigned int lim; 1724 atomic_t *dcnt; 1725 int err; 1726 struct sk_buff *skb; 1727 unsigned long time_limit = jiffies + 2; 1728 1729 while (skb_queue_len(inputq)) { 1730 if (unlikely(time_after_eq(jiffies, time_limit))) 1731 return TIPC_OK; 1732 skb = tipc_skb_dequeue(inputq, dport); 1733 if (unlikely(!skb)) 1734 return TIPC_OK; 1735 if (!sock_owned_by_user(sk)) { 1736 err = filter_rcv(sk, &skb); 1737 if (likely(!skb)) 1738 continue; 1739 *_skb = skb; 1740 return err; 1741 } 1742 dcnt = &tipc_sk(sk)->dupl_rcvcnt; 1743 if (sk->sk_backlog.len) 1744 atomic_set(dcnt, 0); 1745 lim = rcvbuf_limit(sk, skb) + atomic_read(dcnt); 1746 if (likely(!sk_add_backlog(sk, skb, lim))) 1747 continue; 1748 *_skb = skb; 1749 return -TIPC_ERR_OVERLOAD; 1750 } 1751 return TIPC_OK; 1752 } 1753 1754 /** 1755 * tipc_sk_rcv - handle a chain of incoming buffers 1756 * @inputq: buffer list containing the buffers 1757 * Consumes all buffers in list until inputq is empty 1758 * Note: may be called in multiple threads referring to the same queue 1759 * Returns 0 if last buffer was accepted, otherwise -EHOSTUNREACH 1760 * Only node local calls check the return value, sending single-buffer queues 1761 */ 1762 int tipc_sk_rcv(struct net *net, struct sk_buff_head *inputq) 1763 { 1764 u32 dnode, dport = 0; 1765 int err; 1766 struct sk_buff *skb; 1767 struct tipc_sock *tsk; 1768 struct tipc_net *tn; 1769 struct sock *sk; 1770 1771 while (skb_queue_len(inputq)) { 1772 err = -TIPC_ERR_NO_PORT; 1773 skb = NULL; 1774 dport = tipc_skb_peek_port(inputq, dport); 1775 tsk = tipc_sk_lookup(net, dport); 1776 if (likely(tsk)) { 1777 sk = &tsk->sk; 1778 if (likely(spin_trylock_bh(&sk->sk_lock.slock))) { 1779 err = tipc_sk_enqueue(inputq, sk, dport, &skb); 1780 spin_unlock_bh(&sk->sk_lock.slock); 1781 dport = 0; 1782 } 1783 sock_put(sk); 1784 } else { 1785 skb = tipc_skb_dequeue(inputq, dport); 1786 } 1787 if (likely(!skb)) 1788 continue; 1789 if (tipc_msg_lookup_dest(net, skb, &dnode, &err)) 1790 goto xmit; 1791 if (!err) { 1792 dnode = msg_destnode(buf_msg(skb)); 1793 goto xmit; 1794 } 1795 tn = net_generic(net, tipc_net_id); 1796 if (!tipc_msg_reverse(tn->own_addr, skb, &dnode, -err)) 1797 continue; 1798 xmit: 1799 tipc_link_xmit_skb(net, skb, dnode, dport); 1800 } 1801 return err ? -EHOSTUNREACH : 0; 1802 } 1803 1804 static int tipc_wait_for_connect(struct socket *sock, long *timeo_p) 1805 { 1806 struct sock *sk = sock->sk; 1807 DEFINE_WAIT(wait); 1808 int done; 1809 1810 do { 1811 int err = sock_error(sk); 1812 if (err) 1813 return err; 1814 if (!*timeo_p) 1815 return -ETIMEDOUT; 1816 if (signal_pending(current)) 1817 return sock_intr_errno(*timeo_p); 1818 1819 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE); 1820 done = sk_wait_event(sk, timeo_p, sock->state != SS_CONNECTING); 1821 finish_wait(sk_sleep(sk), &wait); 1822 } while (!done); 1823 return 0; 1824 } 1825 1826 /** 1827 * tipc_connect - establish a connection to another TIPC port 1828 * @sock: socket structure 1829 * @dest: socket address for destination port 1830 * @destlen: size of socket address data structure 1831 * @flags: file-related flags associated with socket 1832 * 1833 * Returns 0 on success, errno otherwise 1834 */ 1835 static int tipc_connect(struct socket *sock, struct sockaddr *dest, 1836 int destlen, int flags) 1837 { 1838 struct sock *sk = sock->sk; 1839 struct tipc_sock *tsk = tipc_sk(sk); 1840 struct sockaddr_tipc *dst = (struct sockaddr_tipc *)dest; 1841 struct msghdr m = {NULL,}; 1842 long timeout = (flags & O_NONBLOCK) ? 0 : tsk->conn_timeout; 1843 socket_state previous; 1844 int res = 0; 1845 1846 lock_sock(sk); 1847 1848 /* DGRAM/RDM connect(), just save the destaddr */ 1849 if (sock->state == SS_READY) { 1850 if (dst->family == AF_UNSPEC) { 1851 memset(&tsk->remote, 0, sizeof(struct sockaddr_tipc)); 1852 tsk->connected = 0; 1853 } else if (destlen != sizeof(struct sockaddr_tipc)) { 1854 res = -EINVAL; 1855 } else { 1856 memcpy(&tsk->remote, dest, destlen); 1857 tsk->connected = 1; 1858 } 1859 goto exit; 1860 } 1861 1862 /* 1863 * Reject connection attempt using multicast address 1864 * 1865 * Note: send_msg() validates the rest of the address fields, 1866 * so there's no need to do it here 1867 */ 1868 if (dst->addrtype == TIPC_ADDR_MCAST) { 1869 res = -EINVAL; 1870 goto exit; 1871 } 1872 1873 previous = sock->state; 1874 switch (sock->state) { 1875 case SS_UNCONNECTED: 1876 /* Send a 'SYN-' to destination */ 1877 m.msg_name = dest; 1878 m.msg_namelen = destlen; 1879 1880 /* If connect is in non-blocking case, set MSG_DONTWAIT to 1881 * indicate send_msg() is never blocked. 1882 */ 1883 if (!timeout) 1884 m.msg_flags = MSG_DONTWAIT; 1885 1886 res = __tipc_sendmsg(sock, &m, 0); 1887 if ((res < 0) && (res != -EWOULDBLOCK)) 1888 goto exit; 1889 1890 /* Just entered SS_CONNECTING state; the only 1891 * difference is that return value in non-blocking 1892 * case is EINPROGRESS, rather than EALREADY. 1893 */ 1894 res = -EINPROGRESS; 1895 case SS_CONNECTING: 1896 if (previous == SS_CONNECTING) 1897 res = -EALREADY; 1898 if (!timeout) 1899 goto exit; 1900 timeout = msecs_to_jiffies(timeout); 1901 /* Wait until an 'ACK' or 'RST' arrives, or a timeout occurs */ 1902 res = tipc_wait_for_connect(sock, &timeout); 1903 break; 1904 case SS_CONNECTED: 1905 res = -EISCONN; 1906 break; 1907 default: 1908 res = -EINVAL; 1909 break; 1910 } 1911 exit: 1912 release_sock(sk); 1913 return res; 1914 } 1915 1916 /** 1917 * tipc_listen - allow socket to listen for incoming connections 1918 * @sock: socket structure 1919 * @len: (unused) 1920 * 1921 * Returns 0 on success, errno otherwise 1922 */ 1923 static int tipc_listen(struct socket *sock, int len) 1924 { 1925 struct sock *sk = sock->sk; 1926 int res; 1927 1928 lock_sock(sk); 1929 1930 if (sock->state != SS_UNCONNECTED) 1931 res = -EINVAL; 1932 else { 1933 sock->state = SS_LISTENING; 1934 res = 0; 1935 } 1936 1937 release_sock(sk); 1938 return res; 1939 } 1940 1941 static int tipc_wait_for_accept(struct socket *sock, long timeo) 1942 { 1943 struct sock *sk = sock->sk; 1944 DEFINE_WAIT(wait); 1945 int err; 1946 1947 /* True wake-one mechanism for incoming connections: only 1948 * one process gets woken up, not the 'whole herd'. 1949 * Since we do not 'race & poll' for established sockets 1950 * anymore, the common case will execute the loop only once. 1951 */ 1952 for (;;) { 1953 prepare_to_wait_exclusive(sk_sleep(sk), &wait, 1954 TASK_INTERRUPTIBLE); 1955 if (timeo && skb_queue_empty(&sk->sk_receive_queue)) { 1956 release_sock(sk); 1957 timeo = schedule_timeout(timeo); 1958 lock_sock(sk); 1959 } 1960 err = 0; 1961 if (!skb_queue_empty(&sk->sk_receive_queue)) 1962 break; 1963 err = -EINVAL; 1964 if (sock->state != SS_LISTENING) 1965 break; 1966 err = -EAGAIN; 1967 if (!timeo) 1968 break; 1969 err = sock_intr_errno(timeo); 1970 if (signal_pending(current)) 1971 break; 1972 } 1973 finish_wait(sk_sleep(sk), &wait); 1974 return err; 1975 } 1976 1977 /** 1978 * tipc_accept - wait for connection request 1979 * @sock: listening socket 1980 * @newsock: new socket that is to be connected 1981 * @flags: file-related flags associated with socket 1982 * 1983 * Returns 0 on success, errno otherwise 1984 */ 1985 static int tipc_accept(struct socket *sock, struct socket *new_sock, int flags) 1986 { 1987 struct sock *new_sk, *sk = sock->sk; 1988 struct sk_buff *buf; 1989 struct tipc_sock *new_tsock; 1990 struct tipc_msg *msg; 1991 long timeo; 1992 int res; 1993 1994 lock_sock(sk); 1995 1996 if (sock->state != SS_LISTENING) { 1997 res = -EINVAL; 1998 goto exit; 1999 } 2000 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 2001 res = tipc_wait_for_accept(sock, timeo); 2002 if (res) 2003 goto exit; 2004 2005 buf = skb_peek(&sk->sk_receive_queue); 2006 2007 res = tipc_sk_create(sock_net(sock->sk), new_sock, 0, 1); 2008 if (res) 2009 goto exit; 2010 security_sk_clone(sock->sk, new_sock->sk); 2011 2012 new_sk = new_sock->sk; 2013 new_tsock = tipc_sk(new_sk); 2014 msg = buf_msg(buf); 2015 2016 /* we lock on new_sk; but lockdep sees the lock on sk */ 2017 lock_sock_nested(new_sk, SINGLE_DEPTH_NESTING); 2018 2019 /* 2020 * Reject any stray messages received by new socket 2021 * before the socket lock was taken (very, very unlikely) 2022 */ 2023 tsk_rej_rx_queue(new_sk); 2024 2025 /* Connect new socket to it's peer */ 2026 tipc_sk_finish_conn(new_tsock, msg_origport(msg), msg_orignode(msg)); 2027 new_sock->state = SS_CONNECTED; 2028 2029 tsk_set_importance(new_tsock, msg_importance(msg)); 2030 if (msg_named(msg)) { 2031 new_tsock->conn_type = msg_nametype(msg); 2032 new_tsock->conn_instance = msg_nameinst(msg); 2033 } 2034 2035 /* 2036 * Respond to 'SYN-' by discarding it & returning 'ACK'-. 2037 * Respond to 'SYN+' by queuing it on new socket. 2038 */ 2039 if (!msg_data_sz(msg)) { 2040 struct msghdr m = {NULL,}; 2041 2042 tsk_advance_rx_queue(sk); 2043 __tipc_send_stream(new_sock, &m, 0); 2044 } else { 2045 __skb_dequeue(&sk->sk_receive_queue); 2046 __skb_queue_head(&new_sk->sk_receive_queue, buf); 2047 skb_set_owner_r(buf, new_sk); 2048 } 2049 release_sock(new_sk); 2050 exit: 2051 release_sock(sk); 2052 return res; 2053 } 2054 2055 /** 2056 * tipc_shutdown - shutdown socket connection 2057 * @sock: socket structure 2058 * @how: direction to close (must be SHUT_RDWR) 2059 * 2060 * Terminates connection (if necessary), then purges socket's receive queue. 2061 * 2062 * Returns 0 on success, errno otherwise 2063 */ 2064 static int tipc_shutdown(struct socket *sock, int how) 2065 { 2066 struct sock *sk = sock->sk; 2067 struct net *net = sock_net(sk); 2068 struct tipc_sock *tsk = tipc_sk(sk); 2069 struct sk_buff *skb; 2070 u32 dnode; 2071 int res; 2072 2073 if (how != SHUT_RDWR) 2074 return -EINVAL; 2075 2076 lock_sock(sk); 2077 2078 switch (sock->state) { 2079 case SS_CONNECTING: 2080 case SS_CONNECTED: 2081 2082 restart: 2083 /* Disconnect and send a 'FIN+' or 'FIN-' message to peer */ 2084 skb = __skb_dequeue(&sk->sk_receive_queue); 2085 if (skb) { 2086 if (TIPC_SKB_CB(skb)->handle != NULL) { 2087 kfree_skb(skb); 2088 goto restart; 2089 } 2090 if (tipc_msg_reverse(tsk_own_node(tsk), skb, &dnode, 2091 TIPC_CONN_SHUTDOWN)) 2092 tipc_link_xmit_skb(net, skb, dnode, 2093 tsk->portid); 2094 } else { 2095 dnode = tsk_peer_node(tsk); 2096 2097 skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, 2098 TIPC_CONN_MSG, SHORT_H_SIZE, 2099 0, dnode, tsk_own_node(tsk), 2100 tsk_peer_port(tsk), 2101 tsk->portid, TIPC_CONN_SHUTDOWN); 2102 tipc_link_xmit_skb(net, skb, dnode, tsk->portid); 2103 } 2104 tsk->connected = 0; 2105 sock->state = SS_DISCONNECTING; 2106 tipc_node_remove_conn(net, dnode, tsk->portid); 2107 /* fall through */ 2108 2109 case SS_DISCONNECTING: 2110 2111 /* Discard any unreceived messages */ 2112 __skb_queue_purge(&sk->sk_receive_queue); 2113 2114 /* Wake up anyone sleeping in poll */ 2115 sk->sk_state_change(sk); 2116 res = 0; 2117 break; 2118 2119 default: 2120 res = -ENOTCONN; 2121 } 2122 2123 release_sock(sk); 2124 return res; 2125 } 2126 2127 static void tipc_sk_timeout(unsigned long data) 2128 { 2129 struct tipc_sock *tsk = (struct tipc_sock *)data; 2130 struct sock *sk = &tsk->sk; 2131 struct sk_buff *skb = NULL; 2132 u32 peer_port, peer_node; 2133 u32 own_node = tsk_own_node(tsk); 2134 2135 bh_lock_sock(sk); 2136 if (!tsk->connected) { 2137 bh_unlock_sock(sk); 2138 goto exit; 2139 } 2140 peer_port = tsk_peer_port(tsk); 2141 peer_node = tsk_peer_node(tsk); 2142 2143 if (tsk->probing_state == TIPC_CONN_PROBING) { 2144 if (!sock_owned_by_user(sk)) { 2145 sk->sk_socket->state = SS_DISCONNECTING; 2146 tsk->connected = 0; 2147 tipc_node_remove_conn(sock_net(sk), tsk_peer_node(tsk), 2148 tsk_peer_port(tsk)); 2149 sk->sk_state_change(sk); 2150 } else { 2151 /* Try again later */ 2152 sk_reset_timer(sk, &sk->sk_timer, (HZ / 20)); 2153 } 2154 2155 } else { 2156 skb = tipc_msg_create(CONN_MANAGER, CONN_PROBE, 2157 INT_H_SIZE, 0, peer_node, own_node, 2158 peer_port, tsk->portid, TIPC_OK); 2159 tsk->probing_state = TIPC_CONN_PROBING; 2160 sk_reset_timer(sk, &sk->sk_timer, jiffies + tsk->probing_intv); 2161 } 2162 bh_unlock_sock(sk); 2163 if (skb) 2164 tipc_link_xmit_skb(sock_net(sk), skb, peer_node, tsk->portid); 2165 exit: 2166 sock_put(sk); 2167 } 2168 2169 static int tipc_sk_publish(struct tipc_sock *tsk, uint scope, 2170 struct tipc_name_seq const *seq) 2171 { 2172 struct net *net = sock_net(&tsk->sk); 2173 struct publication *publ; 2174 u32 key; 2175 2176 if (tsk->connected) 2177 return -EINVAL; 2178 key = tsk->portid + tsk->pub_count + 1; 2179 if (key == tsk->portid) 2180 return -EADDRINUSE; 2181 2182 publ = tipc_nametbl_publish(net, seq->type, seq->lower, seq->upper, 2183 scope, tsk->portid, key); 2184 if (unlikely(!publ)) 2185 return -EINVAL; 2186 2187 list_add(&publ->pport_list, &tsk->publications); 2188 tsk->pub_count++; 2189 tsk->published = 1; 2190 return 0; 2191 } 2192 2193 static int tipc_sk_withdraw(struct tipc_sock *tsk, uint scope, 2194 struct tipc_name_seq const *seq) 2195 { 2196 struct net *net = sock_net(&tsk->sk); 2197 struct publication *publ; 2198 struct publication *safe; 2199 int rc = -EINVAL; 2200 2201 list_for_each_entry_safe(publ, safe, &tsk->publications, pport_list) { 2202 if (seq) { 2203 if (publ->scope != scope) 2204 continue; 2205 if (publ->type != seq->type) 2206 continue; 2207 if (publ->lower != seq->lower) 2208 continue; 2209 if (publ->upper != seq->upper) 2210 break; 2211 tipc_nametbl_withdraw(net, publ->type, publ->lower, 2212 publ->ref, publ->key); 2213 rc = 0; 2214 break; 2215 } 2216 tipc_nametbl_withdraw(net, publ->type, publ->lower, 2217 publ->ref, publ->key); 2218 rc = 0; 2219 } 2220 if (list_empty(&tsk->publications)) 2221 tsk->published = 0; 2222 return rc; 2223 } 2224 2225 /* tipc_sk_reinit: set non-zero address in all existing sockets 2226 * when we go from standalone to network mode. 2227 */ 2228 void tipc_sk_reinit(struct net *net) 2229 { 2230 struct tipc_net *tn = net_generic(net, tipc_net_id); 2231 const struct bucket_table *tbl; 2232 struct rhash_head *pos; 2233 struct tipc_sock *tsk; 2234 struct tipc_msg *msg; 2235 int i; 2236 2237 rcu_read_lock(); 2238 tbl = rht_dereference_rcu((&tn->sk_rht)->tbl, &tn->sk_rht); 2239 for (i = 0; i < tbl->size; i++) { 2240 rht_for_each_entry_rcu(tsk, pos, tbl, i, node) { 2241 spin_lock_bh(&tsk->sk.sk_lock.slock); 2242 msg = &tsk->phdr; 2243 msg_set_prevnode(msg, tn->own_addr); 2244 msg_set_orignode(msg, tn->own_addr); 2245 spin_unlock_bh(&tsk->sk.sk_lock.slock); 2246 } 2247 } 2248 rcu_read_unlock(); 2249 } 2250 2251 static struct tipc_sock *tipc_sk_lookup(struct net *net, u32 portid) 2252 { 2253 struct tipc_net *tn = net_generic(net, tipc_net_id); 2254 struct tipc_sock *tsk; 2255 2256 rcu_read_lock(); 2257 tsk = rhashtable_lookup_fast(&tn->sk_rht, &portid, tsk_rht_params); 2258 if (tsk) 2259 sock_hold(&tsk->sk); 2260 rcu_read_unlock(); 2261 2262 return tsk; 2263 } 2264 2265 static int tipc_sk_insert(struct tipc_sock *tsk) 2266 { 2267 struct sock *sk = &tsk->sk; 2268 struct net *net = sock_net(sk); 2269 struct tipc_net *tn = net_generic(net, tipc_net_id); 2270 u32 remaining = (TIPC_MAX_PORT - TIPC_MIN_PORT) + 1; 2271 u32 portid = prandom_u32() % remaining + TIPC_MIN_PORT; 2272 2273 while (remaining--) { 2274 portid++; 2275 if ((portid < TIPC_MIN_PORT) || (portid > TIPC_MAX_PORT)) 2276 portid = TIPC_MIN_PORT; 2277 tsk->portid = portid; 2278 sock_hold(&tsk->sk); 2279 if (!rhashtable_lookup_insert_fast(&tn->sk_rht, &tsk->node, 2280 tsk_rht_params)) 2281 return 0; 2282 sock_put(&tsk->sk); 2283 } 2284 2285 return -1; 2286 } 2287 2288 static void tipc_sk_remove(struct tipc_sock *tsk) 2289 { 2290 struct sock *sk = &tsk->sk; 2291 struct tipc_net *tn = net_generic(sock_net(sk), tipc_net_id); 2292 2293 if (!rhashtable_remove_fast(&tn->sk_rht, &tsk->node, tsk_rht_params)) { 2294 WARN_ON(atomic_read(&sk->sk_refcnt) == 1); 2295 __sock_put(sk); 2296 } 2297 } 2298 2299 static const struct rhashtable_params tsk_rht_params = { 2300 .nelem_hint = 192, 2301 .head_offset = offsetof(struct tipc_sock, node), 2302 .key_offset = offsetof(struct tipc_sock, portid), 2303 .key_len = sizeof(u32), /* portid */ 2304 .max_size = 1048576, 2305 .min_size = 256, 2306 .automatic_shrinking = true, 2307 }; 2308 2309 int tipc_sk_rht_init(struct net *net) 2310 { 2311 struct tipc_net *tn = net_generic(net, tipc_net_id); 2312 2313 return rhashtable_init(&tn->sk_rht, &tsk_rht_params); 2314 } 2315 2316 void tipc_sk_rht_destroy(struct net *net) 2317 { 2318 struct tipc_net *tn = net_generic(net, tipc_net_id); 2319 2320 /* Wait for socket readers to complete */ 2321 synchronize_net(); 2322 2323 rhashtable_destroy(&tn->sk_rht); 2324 } 2325 2326 /** 2327 * tipc_setsockopt - set socket option 2328 * @sock: socket structure 2329 * @lvl: option level 2330 * @opt: option identifier 2331 * @ov: pointer to new option value 2332 * @ol: length of option value 2333 * 2334 * For stream sockets only, accepts and ignores all IPPROTO_TCP options 2335 * (to ease compatibility). 2336 * 2337 * Returns 0 on success, errno otherwise 2338 */ 2339 static int tipc_setsockopt(struct socket *sock, int lvl, int opt, 2340 char __user *ov, unsigned int ol) 2341 { 2342 struct sock *sk = sock->sk; 2343 struct tipc_sock *tsk = tipc_sk(sk); 2344 u32 value; 2345 int res; 2346 2347 if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM)) 2348 return 0; 2349 if (lvl != SOL_TIPC) 2350 return -ENOPROTOOPT; 2351 if (ol < sizeof(value)) 2352 return -EINVAL; 2353 res = get_user(value, (u32 __user *)ov); 2354 if (res) 2355 return res; 2356 2357 lock_sock(sk); 2358 2359 switch (opt) { 2360 case TIPC_IMPORTANCE: 2361 res = tsk_set_importance(tsk, value); 2362 break; 2363 case TIPC_SRC_DROPPABLE: 2364 if (sock->type != SOCK_STREAM) 2365 tsk_set_unreliable(tsk, value); 2366 else 2367 res = -ENOPROTOOPT; 2368 break; 2369 case TIPC_DEST_DROPPABLE: 2370 tsk_set_unreturnable(tsk, value); 2371 break; 2372 case TIPC_CONN_TIMEOUT: 2373 tipc_sk(sk)->conn_timeout = value; 2374 /* no need to set "res", since already 0 at this point */ 2375 break; 2376 default: 2377 res = -EINVAL; 2378 } 2379 2380 release_sock(sk); 2381 2382 return res; 2383 } 2384 2385 /** 2386 * tipc_getsockopt - get socket option 2387 * @sock: socket structure 2388 * @lvl: option level 2389 * @opt: option identifier 2390 * @ov: receptacle for option value 2391 * @ol: receptacle for length of option value 2392 * 2393 * For stream sockets only, returns 0 length result for all IPPROTO_TCP options 2394 * (to ease compatibility). 2395 * 2396 * Returns 0 on success, errno otherwise 2397 */ 2398 static int tipc_getsockopt(struct socket *sock, int lvl, int opt, 2399 char __user *ov, int __user *ol) 2400 { 2401 struct sock *sk = sock->sk; 2402 struct tipc_sock *tsk = tipc_sk(sk); 2403 int len; 2404 u32 value; 2405 int res; 2406 2407 if ((lvl == IPPROTO_TCP) && (sock->type == SOCK_STREAM)) 2408 return put_user(0, ol); 2409 if (lvl != SOL_TIPC) 2410 return -ENOPROTOOPT; 2411 res = get_user(len, ol); 2412 if (res) 2413 return res; 2414 2415 lock_sock(sk); 2416 2417 switch (opt) { 2418 case TIPC_IMPORTANCE: 2419 value = tsk_importance(tsk); 2420 break; 2421 case TIPC_SRC_DROPPABLE: 2422 value = tsk_unreliable(tsk); 2423 break; 2424 case TIPC_DEST_DROPPABLE: 2425 value = tsk_unreturnable(tsk); 2426 break; 2427 case TIPC_CONN_TIMEOUT: 2428 value = tsk->conn_timeout; 2429 /* no need to set "res", since already 0 at this point */ 2430 break; 2431 case TIPC_NODE_RECVQ_DEPTH: 2432 value = 0; /* was tipc_queue_size, now obsolete */ 2433 break; 2434 case TIPC_SOCK_RECVQ_DEPTH: 2435 value = skb_queue_len(&sk->sk_receive_queue); 2436 break; 2437 default: 2438 res = -EINVAL; 2439 } 2440 2441 release_sock(sk); 2442 2443 if (res) 2444 return res; /* "get" failed */ 2445 2446 if (len < sizeof(value)) 2447 return -EINVAL; 2448 2449 if (copy_to_user(ov, &value, sizeof(value))) 2450 return -EFAULT; 2451 2452 return put_user(sizeof(value), ol); 2453 } 2454 2455 static int tipc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 2456 { 2457 struct sock *sk = sock->sk; 2458 struct tipc_sioc_ln_req lnr; 2459 void __user *argp = (void __user *)arg; 2460 2461 switch (cmd) { 2462 case SIOCGETLINKNAME: 2463 if (copy_from_user(&lnr, argp, sizeof(lnr))) 2464 return -EFAULT; 2465 if (!tipc_node_get_linkname(sock_net(sk), 2466 lnr.bearer_id & 0xffff, lnr.peer, 2467 lnr.linkname, TIPC_MAX_LINK_NAME)) { 2468 if (copy_to_user(argp, &lnr, sizeof(lnr))) 2469 return -EFAULT; 2470 return 0; 2471 } 2472 return -EADDRNOTAVAIL; 2473 default: 2474 return -ENOIOCTLCMD; 2475 } 2476 } 2477 2478 /* Protocol switches for the various types of TIPC sockets */ 2479 2480 static const struct proto_ops msg_ops = { 2481 .owner = THIS_MODULE, 2482 .family = AF_TIPC, 2483 .release = tipc_release, 2484 .bind = tipc_bind, 2485 .connect = tipc_connect, 2486 .socketpair = sock_no_socketpair, 2487 .accept = sock_no_accept, 2488 .getname = tipc_getname, 2489 .poll = tipc_poll, 2490 .ioctl = tipc_ioctl, 2491 .listen = sock_no_listen, 2492 .shutdown = tipc_shutdown, 2493 .setsockopt = tipc_setsockopt, 2494 .getsockopt = tipc_getsockopt, 2495 .sendmsg = tipc_sendmsg, 2496 .recvmsg = tipc_recvmsg, 2497 .mmap = sock_no_mmap, 2498 .sendpage = sock_no_sendpage 2499 }; 2500 2501 static const struct proto_ops packet_ops = { 2502 .owner = THIS_MODULE, 2503 .family = AF_TIPC, 2504 .release = tipc_release, 2505 .bind = tipc_bind, 2506 .connect = tipc_connect, 2507 .socketpair = sock_no_socketpair, 2508 .accept = tipc_accept, 2509 .getname = tipc_getname, 2510 .poll = tipc_poll, 2511 .ioctl = tipc_ioctl, 2512 .listen = tipc_listen, 2513 .shutdown = tipc_shutdown, 2514 .setsockopt = tipc_setsockopt, 2515 .getsockopt = tipc_getsockopt, 2516 .sendmsg = tipc_send_packet, 2517 .recvmsg = tipc_recvmsg, 2518 .mmap = sock_no_mmap, 2519 .sendpage = sock_no_sendpage 2520 }; 2521 2522 static const struct proto_ops stream_ops = { 2523 .owner = THIS_MODULE, 2524 .family = AF_TIPC, 2525 .release = tipc_release, 2526 .bind = tipc_bind, 2527 .connect = tipc_connect, 2528 .socketpair = sock_no_socketpair, 2529 .accept = tipc_accept, 2530 .getname = tipc_getname, 2531 .poll = tipc_poll, 2532 .ioctl = tipc_ioctl, 2533 .listen = tipc_listen, 2534 .shutdown = tipc_shutdown, 2535 .setsockopt = tipc_setsockopt, 2536 .getsockopt = tipc_getsockopt, 2537 .sendmsg = tipc_send_stream, 2538 .recvmsg = tipc_recv_stream, 2539 .mmap = sock_no_mmap, 2540 .sendpage = sock_no_sendpage 2541 }; 2542 2543 static const struct net_proto_family tipc_family_ops = { 2544 .owner = THIS_MODULE, 2545 .family = AF_TIPC, 2546 .create = tipc_sk_create 2547 }; 2548 2549 static struct proto tipc_proto = { 2550 .name = "TIPC", 2551 .owner = THIS_MODULE, 2552 .obj_size = sizeof(struct tipc_sock), 2553 .sysctl_rmem = sysctl_tipc_rmem 2554 }; 2555 2556 /** 2557 * tipc_socket_init - initialize TIPC socket interface 2558 * 2559 * Returns 0 on success, errno otherwise 2560 */ 2561 int tipc_socket_init(void) 2562 { 2563 int res; 2564 2565 res = proto_register(&tipc_proto, 1); 2566 if (res) { 2567 pr_err("Failed to register TIPC protocol type\n"); 2568 goto out; 2569 } 2570 2571 res = sock_register(&tipc_family_ops); 2572 if (res) { 2573 pr_err("Failed to register TIPC socket type\n"); 2574 proto_unregister(&tipc_proto); 2575 goto out; 2576 } 2577 out: 2578 return res; 2579 } 2580 2581 /** 2582 * tipc_socket_stop - stop TIPC socket interface 2583 */ 2584 void tipc_socket_stop(void) 2585 { 2586 sock_unregister(tipc_family_ops.family); 2587 proto_unregister(&tipc_proto); 2588 } 2589 2590 /* Caller should hold socket lock for the passed tipc socket. */ 2591 static int __tipc_nl_add_sk_con(struct sk_buff *skb, struct tipc_sock *tsk) 2592 { 2593 u32 peer_node; 2594 u32 peer_port; 2595 struct nlattr *nest; 2596 2597 peer_node = tsk_peer_node(tsk); 2598 peer_port = tsk_peer_port(tsk); 2599 2600 nest = nla_nest_start(skb, TIPC_NLA_SOCK_CON); 2601 2602 if (nla_put_u32(skb, TIPC_NLA_CON_NODE, peer_node)) 2603 goto msg_full; 2604 if (nla_put_u32(skb, TIPC_NLA_CON_SOCK, peer_port)) 2605 goto msg_full; 2606 2607 if (tsk->conn_type != 0) { 2608 if (nla_put_flag(skb, TIPC_NLA_CON_FLAG)) 2609 goto msg_full; 2610 if (nla_put_u32(skb, TIPC_NLA_CON_TYPE, tsk->conn_type)) 2611 goto msg_full; 2612 if (nla_put_u32(skb, TIPC_NLA_CON_INST, tsk->conn_instance)) 2613 goto msg_full; 2614 } 2615 nla_nest_end(skb, nest); 2616 2617 return 0; 2618 2619 msg_full: 2620 nla_nest_cancel(skb, nest); 2621 2622 return -EMSGSIZE; 2623 } 2624 2625 /* Caller should hold socket lock for the passed tipc socket. */ 2626 static int __tipc_nl_add_sk(struct sk_buff *skb, struct netlink_callback *cb, 2627 struct tipc_sock *tsk) 2628 { 2629 int err; 2630 void *hdr; 2631 struct nlattr *attrs; 2632 struct net *net = sock_net(skb->sk); 2633 struct tipc_net *tn = net_generic(net, tipc_net_id); 2634 2635 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 2636 &tipc_genl_family, NLM_F_MULTI, TIPC_NL_SOCK_GET); 2637 if (!hdr) 2638 goto msg_cancel; 2639 2640 attrs = nla_nest_start(skb, TIPC_NLA_SOCK); 2641 if (!attrs) 2642 goto genlmsg_cancel; 2643 if (nla_put_u32(skb, TIPC_NLA_SOCK_REF, tsk->portid)) 2644 goto attr_msg_cancel; 2645 if (nla_put_u32(skb, TIPC_NLA_SOCK_ADDR, tn->own_addr)) 2646 goto attr_msg_cancel; 2647 2648 if (tsk->connected) { 2649 err = __tipc_nl_add_sk_con(skb, tsk); 2650 if (err) 2651 goto attr_msg_cancel; 2652 } else if (!list_empty(&tsk->publications)) { 2653 if (nla_put_flag(skb, TIPC_NLA_SOCK_HAS_PUBL)) 2654 goto attr_msg_cancel; 2655 } 2656 nla_nest_end(skb, attrs); 2657 genlmsg_end(skb, hdr); 2658 2659 return 0; 2660 2661 attr_msg_cancel: 2662 nla_nest_cancel(skb, attrs); 2663 genlmsg_cancel: 2664 genlmsg_cancel(skb, hdr); 2665 msg_cancel: 2666 return -EMSGSIZE; 2667 } 2668 2669 int tipc_nl_sk_dump(struct sk_buff *skb, struct netlink_callback *cb) 2670 { 2671 int err; 2672 struct tipc_sock *tsk; 2673 const struct bucket_table *tbl; 2674 struct rhash_head *pos; 2675 struct net *net = sock_net(skb->sk); 2676 struct tipc_net *tn = net_generic(net, tipc_net_id); 2677 u32 tbl_id = cb->args[0]; 2678 u32 prev_portid = cb->args[1]; 2679 2680 rcu_read_lock(); 2681 tbl = rht_dereference_rcu((&tn->sk_rht)->tbl, &tn->sk_rht); 2682 for (; tbl_id < tbl->size; tbl_id++) { 2683 rht_for_each_entry_rcu(tsk, pos, tbl, tbl_id, node) { 2684 spin_lock_bh(&tsk->sk.sk_lock.slock); 2685 if (prev_portid && prev_portid != tsk->portid) { 2686 spin_unlock_bh(&tsk->sk.sk_lock.slock); 2687 continue; 2688 } 2689 2690 err = __tipc_nl_add_sk(skb, cb, tsk); 2691 if (err) { 2692 prev_portid = tsk->portid; 2693 spin_unlock_bh(&tsk->sk.sk_lock.slock); 2694 goto out; 2695 } 2696 prev_portid = 0; 2697 spin_unlock_bh(&tsk->sk.sk_lock.slock); 2698 } 2699 } 2700 out: 2701 rcu_read_unlock(); 2702 cb->args[0] = tbl_id; 2703 cb->args[1] = prev_portid; 2704 2705 return skb->len; 2706 } 2707 2708 /* Caller should hold socket lock for the passed tipc socket. */ 2709 static int __tipc_nl_add_sk_publ(struct sk_buff *skb, 2710 struct netlink_callback *cb, 2711 struct publication *publ) 2712 { 2713 void *hdr; 2714 struct nlattr *attrs; 2715 2716 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 2717 &tipc_genl_family, NLM_F_MULTI, TIPC_NL_PUBL_GET); 2718 if (!hdr) 2719 goto msg_cancel; 2720 2721 attrs = nla_nest_start(skb, TIPC_NLA_PUBL); 2722 if (!attrs) 2723 goto genlmsg_cancel; 2724 2725 if (nla_put_u32(skb, TIPC_NLA_PUBL_KEY, publ->key)) 2726 goto attr_msg_cancel; 2727 if (nla_put_u32(skb, TIPC_NLA_PUBL_TYPE, publ->type)) 2728 goto attr_msg_cancel; 2729 if (nla_put_u32(skb, TIPC_NLA_PUBL_LOWER, publ->lower)) 2730 goto attr_msg_cancel; 2731 if (nla_put_u32(skb, TIPC_NLA_PUBL_UPPER, publ->upper)) 2732 goto attr_msg_cancel; 2733 2734 nla_nest_end(skb, attrs); 2735 genlmsg_end(skb, hdr); 2736 2737 return 0; 2738 2739 attr_msg_cancel: 2740 nla_nest_cancel(skb, attrs); 2741 genlmsg_cancel: 2742 genlmsg_cancel(skb, hdr); 2743 msg_cancel: 2744 return -EMSGSIZE; 2745 } 2746 2747 /* Caller should hold socket lock for the passed tipc socket. */ 2748 static int __tipc_nl_list_sk_publ(struct sk_buff *skb, 2749 struct netlink_callback *cb, 2750 struct tipc_sock *tsk, u32 *last_publ) 2751 { 2752 int err; 2753 struct publication *p; 2754 2755 if (*last_publ) { 2756 list_for_each_entry(p, &tsk->publications, pport_list) { 2757 if (p->key == *last_publ) 2758 break; 2759 } 2760 if (p->key != *last_publ) { 2761 /* We never set seq or call nl_dump_check_consistent() 2762 * this means that setting prev_seq here will cause the 2763 * consistence check to fail in the netlink callback 2764 * handler. Resulting in the last NLMSG_DONE message 2765 * having the NLM_F_DUMP_INTR flag set. 2766 */ 2767 cb->prev_seq = 1; 2768 *last_publ = 0; 2769 return -EPIPE; 2770 } 2771 } else { 2772 p = list_first_entry(&tsk->publications, struct publication, 2773 pport_list); 2774 } 2775 2776 list_for_each_entry_from(p, &tsk->publications, pport_list) { 2777 err = __tipc_nl_add_sk_publ(skb, cb, p); 2778 if (err) { 2779 *last_publ = p->key; 2780 return err; 2781 } 2782 } 2783 *last_publ = 0; 2784 2785 return 0; 2786 } 2787 2788 int tipc_nl_publ_dump(struct sk_buff *skb, struct netlink_callback *cb) 2789 { 2790 int err; 2791 u32 tsk_portid = cb->args[0]; 2792 u32 last_publ = cb->args[1]; 2793 u32 done = cb->args[2]; 2794 struct net *net = sock_net(skb->sk); 2795 struct tipc_sock *tsk; 2796 2797 if (!tsk_portid) { 2798 struct nlattr **attrs; 2799 struct nlattr *sock[TIPC_NLA_SOCK_MAX + 1]; 2800 2801 err = tipc_nlmsg_parse(cb->nlh, &attrs); 2802 if (err) 2803 return err; 2804 2805 err = nla_parse_nested(sock, TIPC_NLA_SOCK_MAX, 2806 attrs[TIPC_NLA_SOCK], 2807 tipc_nl_sock_policy); 2808 if (err) 2809 return err; 2810 2811 if (!sock[TIPC_NLA_SOCK_REF]) 2812 return -EINVAL; 2813 2814 tsk_portid = nla_get_u32(sock[TIPC_NLA_SOCK_REF]); 2815 } 2816 2817 if (done) 2818 return 0; 2819 2820 tsk = tipc_sk_lookup(net, tsk_portid); 2821 if (!tsk) 2822 return -EINVAL; 2823 2824 lock_sock(&tsk->sk); 2825 err = __tipc_nl_list_sk_publ(skb, cb, tsk, &last_publ); 2826 if (!err) 2827 done = 1; 2828 release_sock(&tsk->sk); 2829 sock_put(&tsk->sk); 2830 2831 cb->args[0] = tsk_portid; 2832 cb->args[1] = last_publ; 2833 cb->args[2] = done; 2834 2835 return skb->len; 2836 } 2837