src/common/sessiond-comm/inet.c

   1 /*
   2  * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License, version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _LGPL_SOURCE
  19 #include <assert.h>
  20 #include <limits.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <sys/types.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <common/compat/time.h>
  30 #include <poll.h>
  31
  32 #include <common/common.h>
  33 #include <common/time.h>
  34
  35 #include "inet.h"
  36
  37 #define RECONNECT_DELAY 200     /* ms */
  38
  39 /*
  40  * INET protocol operations.
  41  */
  42 static const struct lttcomm_proto_ops inet_ops = {
  43         .bind = lttcomm_bind_inet_sock,
  44         .close = lttcomm_close_inet_sock,
  45         .connect = lttcomm_connect_inet_sock,
  46         .accept = lttcomm_accept_inet_sock,
  47         .listen = lttcomm_listen_inet_sock,
  48         .recvmsg = lttcomm_recvmsg_inet_sock,
  49         .sendmsg = lttcomm_sendmsg_inet_sock,
  50 };
  51
  52 unsigned long lttcomm_inet_tcp_timeout;
  53
  54 /*
  55  * Creates an PF_INET socket.
  56  */
  57 LTTNG_HIDDEN
  58 int lttcomm_create_inet_sock(struct lttcomm_sock *sock, int type, int proto)
  59 {
  60         int val = 1, ret;
  61         unsigned long timeout;
  62
  63         /* Create server socket */
  64         if ((sock->fd = socket(PF_INET, type, proto)) < 0) {
  65                 PERROR("socket inet");
  66                 goto error;
  67         }
  68
  69         sock->ops = &inet_ops;
  70
  71         /*
  72          * Set socket option to reuse the address.
  73          */
  74         ret = setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
  75         if (ret < 0) {
  76                 PERROR("setsockopt inet");
  77                 goto error;
  78         }
  79         timeout = lttcomm_get_network_timeout();
  80         if (timeout) {
  81                 ret = lttcomm_setsockopt_rcv_timeout(sock->fd, timeout);
  82                 if (ret) {
  83                         goto error;
  84                 }
  85                 ret = lttcomm_setsockopt_snd_timeout(sock->fd, timeout);
  86                 if (ret) {
  87                         goto error;
  88                 }
  89         }
  90
  91         return 0;
  92
  93 error:
  94         return -1;
  95 }
  96
  97 /*
  98  * Bind socket and return.
  99  */
 100 LTTNG_HIDDEN
 101 int lttcomm_bind_inet_sock(struct lttcomm_sock *sock)
 102 {
 103         return bind(sock->fd,
 104                         (const struct sockaddr *) &sock->sockaddr.addr.sin,
 105                         sizeof(sock->sockaddr.addr.sin));
 106 }
 107
 108 static
 109 int connect_no_timeout(struct lttcomm_sock *sock)
 110 {
 111         return connect(sock->fd, (struct sockaddr *) &sock->sockaddr.addr.sin,
 112                         sizeof(sock->sockaddr.addr.sin));
 113 }
 114
 115 static
 116 int connect_with_timeout(struct lttcomm_sock *sock)
 117 {
 118         unsigned long timeout = lttcomm_get_network_timeout();
 119         int ret, flags, connect_ret;
 120         struct timespec orig_time, cur_time;
 121         unsigned long diff_ms;
 122
 123         ret = fcntl(sock->fd, F_GETFL, 0);
 124         if (ret == -1) {
 125                 PERROR("fcntl");
 126                 return -1;
 127         }
 128         flags = ret;
 129
 130         /* Set socket to nonblock */
 131         ret = fcntl(sock->fd, F_SETFL, flags | O_NONBLOCK);
 132         if (ret == -1) {
 133                 PERROR("fcntl");
 134                 return -1;
 135         }
 136
 137         ret = lttng_clock_gettime(CLOCK_MONOTONIC, &orig_time);
 138         if (ret == -1) {
 139                 PERROR("clock_gettime");
 140                 return -1;
 141         }
 142
 143         connect_ret = connect(sock->fd,
 144                 (struct sockaddr *) &sock->sockaddr.addr.sin,
 145                 sizeof(sock->sockaddr.addr.sin));
 146         if (connect_ret == -1 && errno != EAGAIN
 147                         && errno != EWOULDBLOCK
 148                         && errno != EINPROGRESS) {
 149                 goto error;
 150         } else if (!connect_ret) {
 151                 /* Connect succeeded */
 152                 goto success;
 153         }
 154
 155         DBG("Asynchronous connect for sock %d, performing polling with"
 156                         " timeout: %lums", sock->fd, timeout);
 157         /*
 158          * Perform poll loop following EINPROGRESS recommendation from
 159          * connect(2) man page.
 160          */
 161         do {
 162                 struct pollfd fds;
 163
 164                 fds.fd = sock->fd;
 165                 fds.events = POLLOUT;
 166                 fds.revents = 0;
 167                 ret = poll(&fds, 1, RECONNECT_DELAY);
 168                 if (ret < 0) {
 169                         goto error;
 170                 } else if (ret > 0) {
 171                         int optval;
 172                         socklen_t optval_len = sizeof(optval);
 173
 174                         if (!(fds.revents & POLLOUT)) {
 175                                 /* Either hup or error */
 176                                 errno = EPIPE;
 177                                 goto error;
 178                         }
 179                         /* got something */
 180                         ret = getsockopt(sock->fd, SOL_SOCKET,
 181                                 SO_ERROR, &optval, &optval_len);
 182                         if (ret) {
 183                                 PERROR("getsockopt");
 184                                 goto error;
 185                         }
 186                         if (!optval) {
 187                                 connect_ret = 0;
 188                                 goto success;
 189                         } else {
 190                                 /* Get actual connect() errno from opt_val */
 191                                 errno = optval;
 192                                 goto error;
 193                         }
 194                 }
 195                 /* ret == 0: timeout */
 196                 ret = lttng_clock_gettime(CLOCK_MONOTONIC, &cur_time);
 197                 if (ret == -1) {
 198                         PERROR("clock_gettime");
 199                         connect_ret = ret;
 200                         goto error;
 201                 }
 202                 if (timespec_to_ms(timespec_abs_diff(cur_time, orig_time), &diff_ms) < 0) {
 203                         ERR("timespec_to_ms input overflows milliseconds output");
 204                         connect_ret = -1;
 205                         goto error;
 206                 }
 207         } while (diff_ms < timeout);
 208
 209         /* Timeout */
 210         errno = ETIMEDOUT;
 211         connect_ret = -1;
 212
 213 success:
 214         /* Restore initial flags */
 215         ret = fcntl(sock->fd, F_SETFL, flags);
 216         if (ret == -1) {
 217                 PERROR("fcntl");
 218                 /* Continue anyway */
 219         }
 220 error:
 221         return connect_ret;
 222 }
 223
 224 /*
 225  * Connect PF_INET socket.
 226  */
 227 LTTNG_HIDDEN
 228 int lttcomm_connect_inet_sock(struct lttcomm_sock *sock)
 229 {
 230         int ret, closeret;
 231
 232         if (lttcomm_get_network_timeout()) {
 233                 ret = connect_with_timeout(sock);
 234         } else {
 235                 ret = connect_no_timeout(sock);
 236         }
 237         if (ret < 0) {
 238                 PERROR("connect");
 239                 goto error_connect;
 240         }
 241
 242         return ret;
 243
 244 error_connect:
 245         closeret = close(sock->fd);
 246         if (closeret) {
 247                 PERROR("close inet");
 248         }
 249
 250         return ret;
 251 }
 252
 253 /*
 254  * Do an accept(2) on the sock and return the new lttcomm socket. The socket
 255  * MUST be bind(2) before.
 256  */
 257 LTTNG_HIDDEN
 258 struct lttcomm_sock *lttcomm_accept_inet_sock(struct lttcomm_sock *sock)
 259 {
 260         int new_fd;
 261         socklen_t len;
 262         struct lttcomm_sock *new_sock;
 263         unsigned long timeout;
 264
 265         if (sock->proto == LTTCOMM_SOCK_UDP) {
 266                 /*
 267                  * accept(2) does not exist for UDP so simply return the passed socket.
 268                  */
 269                 new_sock = sock;
 270                 goto end;
 271         }
 272
 273         new_sock = lttcomm_alloc_sock(sock->proto);
 274         if (new_sock == NULL) {
 275                 goto error;
 276         }
 277
 278         len = sizeof(new_sock->sockaddr.addr.sin);
 279
 280         /* Blocking call */
 281         new_fd = accept(sock->fd, (struct sockaddr *) &new_sock->sockaddr.addr.sin,
 282                         &len);
 283         if (new_fd < 0) {
 284                 PERROR("accept inet");
 285                 goto error;
 286         }
 287         timeout = lttcomm_get_network_timeout();
 288         if (timeout) {
 289                 int ret;
 290
 291                 ret = lttcomm_setsockopt_rcv_timeout(new_fd, timeout);
 292                 if (ret) {
 293                         goto error_close;
 294                 }
 295                 ret = lttcomm_setsockopt_snd_timeout(new_fd, timeout);
 296                 if (ret) {
 297                         goto error_close;
 298                 }
 299         }
 300
 301         new_sock->fd = new_fd;
 302         new_sock->ops = &inet_ops;
 303
 304 end:
 305         return new_sock;
 306
 307 error_close:
 308         if (close(new_fd) < 0) {
 309                 PERROR("accept inet close fd");
 310         }
 311
 312 error:
 313         free(new_sock);
 314         return NULL;
 315 }
 316
 317 /*
 318  * Make the socket listen using LTTNG_SESSIOND_COMM_MAX_LISTEN.
 319  */
 320 LTTNG_HIDDEN
 321 int lttcomm_listen_inet_sock(struct lttcomm_sock *sock, int backlog)
 322 {
 323         int ret;
 324
 325         if (sock->proto == LTTCOMM_SOCK_UDP) {
 326                 /* listen(2) does not exist for UDP so simply return success. */
 327                 ret = 0;
 328                 goto end;
 329         }
 330
 331         /* Default listen backlog */
 332         if (backlog <= 0) {
 333                 backlog = LTTNG_SESSIOND_COMM_MAX_LISTEN;
 334         }
 335
 336         ret = listen(sock->fd, backlog);
 337         if (ret < 0) {
 338                 PERROR("listen inet");
 339         }
 340
 341 end:
 342         return ret;
 343 }
 344
 345 /*
 346  * Receive data of size len in put that data into the buf param. Using recvmsg
 347  * API.
 348  *
 349  * Return the size of received data.
 350  */
 351 LTTNG_HIDDEN
 352 ssize_t lttcomm_recvmsg_inet_sock(struct lttcomm_sock *sock, void *buf,
 353                 size_t len, int flags)
 354 {
 355         struct msghdr msg;
 356         struct iovec iov[1];
 357         ssize_t ret = -1;
 358         size_t len_last;
 359
 360         memset(&msg, 0, sizeof(msg));
 361
 362         iov[0].iov_base = buf;
 363         iov[0].iov_len = len;
 364         msg.msg_iov = iov;
 365         msg.msg_iovlen = 1;
 366
 367         msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
 368         msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
 369
 370         do {
 371                 len_last = iov[0].iov_len;
 372                 ret = recvmsg(sock->fd, &msg, flags);
 373                 if (ret > 0) {
 374                         if (flags & MSG_DONTWAIT) {
 375                                 goto end;
 376                         }
 377                         iov[0].iov_base += ret;
 378                         iov[0].iov_len -= ret;
 379                         assert(ret <= len_last);
 380                 }
 381         } while ((ret > 0 && ret < len_last) || (ret < 0 && errno == EINTR));
 382
 383         if (ret < 0) {
 384                 PERROR("recvmsg inet");
 385         } else if (ret > 0) {
 386                 ret = len;
 387         }
 388         /* Else ret = 0 meaning an orderly shutdown. */
 389 end:
 390         return ret;
 391 }
 392
 393 /*
 394  * Send buf data of size len. Using sendmsg API.
 395  *
 396  * Return the size of sent data.
 397  */
 398 LTTNG_HIDDEN
 399 ssize_t lttcomm_sendmsg_inet_sock(struct lttcomm_sock *sock, const void *buf,
 400                 size_t len, int flags)
 401 {
 402         struct msghdr msg;
 403         struct iovec iov[1];
 404         ssize_t ret = -1;
 405
 406         memset(&msg, 0, sizeof(msg));
 407
 408         iov[0].iov_base = (void *) buf;
 409         iov[0].iov_len = len;
 410         msg.msg_iov = iov;
 411         msg.msg_iovlen = 1;
 412
 413         switch (sock->proto) {
 414         case LTTCOMM_SOCK_UDP:
 415                 msg.msg_name = (struct sockaddr *) &sock->sockaddr.addr.sin;
 416                 msg.msg_namelen = sizeof(sock->sockaddr.addr.sin);
 417                 break;
 418         default:
 419                 break;
 420         }
 421
 422         do {
 423                 ret = sendmsg(sock->fd, &msg, flags);
 424         } while (ret < 0 && errno == EINTR);
 425         if (ret < 0) {
 426                 /*
 427                  * Only warn about EPIPE when quiet mode is deactivated.
 428                  * We consider EPIPE as expected.
 429                  */
 430                 if (errno != EPIPE || !lttng_opt_quiet) {
 431                         PERROR("sendmsg inet");
 432                 }
 433         }
 434
 435         return ret;
 436 }
 437
 438 /*
 439  * Shutdown cleanly and close.
 440  */
 441 LTTNG_HIDDEN
 442 int lttcomm_close_inet_sock(struct lttcomm_sock *sock)
 443 {
 444         int ret;
 445
 446         /* Don't try to close an invalid marked socket */
 447         if (sock->fd == -1) {
 448                 return 0;
 449         }
 450
 451         ret = close(sock->fd);
 452         if (ret) {
 453                 PERROR("close inet");
 454         }
 455
 456         /* Mark socket */
 457         sock->fd = -1;
 458
 459         return ret;
 460 }
 461
 462 /*
 463  * Return value read from /proc or else 0 if value is not found.
 464  */
 465 static unsigned long read_proc_value(const char *path)
 466 {
 467         int ret, fd;
 468         ssize_t size_ret;
 469         long r_val;
 470         unsigned long val = 0;
 471         char buf[64];
 472
 473         fd = open(path, O_RDONLY);
 474         if (fd < 0) {
 475                 goto error;
 476         }
 477
 478         size_ret = lttng_read(fd, buf, sizeof(buf));
 479         /*
 480          * Allow reading a file smaller than buf, but keep space for
 481          * final \0.
 482          */
 483         if (size_ret < 0 || size_ret >= sizeof(buf)) {
 484                 PERROR("read proc failed");
 485                 goto error_close;
 486         }
 487         buf[size_ret] = '\0';
 488
 489         errno = 0;
 490         r_val = strtol(buf, NULL, 10);
 491         if (errno != 0 || r_val < -1L) {
 492                 val = 0;
 493                 goto error_close;
 494         } else {
 495                 if (r_val > 0) {
 496                         val = r_val;
 497                 }
 498         }
 499
 500 error_close:
 501         ret = close(fd);
 502         if (ret) {
 503                 PERROR("close /proc value");
 504         }
 505 error:
 506         return val;
 507 }
 508
 509 LTTNG_HIDDEN
 510 void lttcomm_inet_init(void)
 511 {
 512         unsigned long syn_retries, fin_timeout, syn_timeout, env;
 513
 514         env = lttcomm_get_network_timeout();
 515         if (env) {
 516                 lttcomm_inet_tcp_timeout = env;
 517                 goto end;
 518         }
 519
 520         /* Assign default value and see if we can change it. */
 521         lttcomm_inet_tcp_timeout = DEFAULT_INET_TCP_TIMEOUT;
 522
 523         syn_retries = read_proc_value(LTTCOMM_INET_PROC_SYN_RETRIES_PATH);
 524         fin_timeout = read_proc_value(LTTCOMM_INET_PROC_FIN_TIMEOUT_PATH);
 525
 526         syn_timeout = syn_retries * LTTCOMM_INET_SYN_TIMEOUT_FACTOR;
 527
 528         /*
 529          * Get the maximum between the two possible timeout value and use that to
 530          * get the maximum with the default timeout.
 531          */
 532         lttcomm_inet_tcp_timeout = max_t(unsigned long,
 533                         max_t(unsigned long, syn_timeout, fin_timeout),
 534                         lttcomm_inet_tcp_timeout);
 535
 536 end:
 537         DBG("TCP inet operation timeout set to %lu sec", lttcomm_inet_tcp_timeout);
 538 }