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