src/common/sessiond-comm/sessiond-comm.c

   1 /*
   2  * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
   3  * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 #define _LGPL_SOURCE
  10 #include <limits.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <sys/stat.h>
  15 #include <sys/types.h>
  16 #include <unistd.h>
  17 #include <inttypes.h>
  18
  19 #include <common/common.h>
  20 #include <common/compat/errno.h>
  21
  22 #include "sessiond-comm.h"
  23
  24 /* For Unix socket */
  25 #include <common/unix.h>
  26 /* For Inet socket */
  27 #include "inet.h"
  28 /* For Inet6 socket */
  29 #include "inet6.h"
  30
  31 #define NETWORK_TIMEOUT_ENV     "LTTNG_NETWORK_SOCKET_TIMEOUT"
  32
  33 static struct lttcomm_net_family net_families[] = {
  34         { LTTCOMM_INET, lttcomm_create_inet_sock },
  35         { LTTCOMM_INET6, lttcomm_create_inet6_sock },
  36 };
  37
  38 /*
  39  * Human readable error message.
  40  */
  41 static const char *lttcomm_readable_code[] = {
  42         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) ] = "consumerd command socket ready",
  43         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SUCCESS_RECV_FD) ] = "consumerd success on receiving fds",
  44         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_RECV_FD) ] = "consumerd error on receiving fds",
  45         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_RECV_CMD) ] = "consumerd error on receiving command",
  46         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_ERROR) ] = "consumerd error in polling thread",
  47         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_NVAL) ] = "consumerd polling on closed fd",
  48         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_POLL_HUP) ] = "consumerd all fd hung up",
  49         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_EXIT_SUCCESS) ] = "consumerd exiting normally",
  50         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_EXIT_FAILURE) ] = "consumerd exiting on error",
  51         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_OUTFD_ERROR) ] = "consumerd error opening the tracefile",
  52         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_EBADF) ] = "consumerd splice EBADF",
  53         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_EINVAL) ] = "consumerd splice EINVAL",
  54         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_ENOMEM) ] = "consumerd splice ENOMEM",
  55         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_SPLICE_ESPIPE) ] = "consumerd splice ESPIPE",
  56         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ENOMEM) ] = "Consumer is out of memory",
  57         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_ERROR_METADATA) ] = "Error with metadata",
  58         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_FATAL) ] = "Fatal error",
  59         [ LTTCOMM_ERR_INDEX(LTTCOMM_CONSUMERD_RELAYD_FAIL) ] = "Error on remote relayd",
  60
  61         /* Last element */
  62         [ LTTCOMM_ERR_INDEX(LTTCOMM_NR) ] = "Unknown error code"
  63 };
  64
  65 static unsigned long network_timeout;
  66
  67 /*
  68  * Return ptr to string representing a human readable error code from the
  69  * lttcomm_return_code enum.
  70  *
  71  * These code MUST be negative in other to treat that as an error value.
  72  */
  73 LTTNG_HIDDEN
  74 const char *lttcomm_get_readable_code(enum lttcomm_return_code code)
  75 {
  76         code = -code;
  77
  78         if (code < LTTCOMM_CONSUMERD_COMMAND_SOCK_READY || code > LTTCOMM_NR) {
  79                 code = LTTCOMM_NR;
  80         }
  81
  82         return lttcomm_readable_code[LTTCOMM_ERR_INDEX(code)];
  83 }
  84
  85 /*
  86  * Create socket from an already allocated lttcomm socket structure and init
  87  * sockaddr in the lttcomm sock.
  88  */
  89 LTTNG_HIDDEN
  90 int lttcomm_create_sock(struct lttcomm_sock *sock)
  91 {
  92         int ret, _sock_type, _sock_proto, domain;
  93
  94         LTTNG_ASSERT(sock);
  95
  96         domain = sock->sockaddr.type;
  97         if (domain != LTTCOMM_INET && domain != LTTCOMM_INET6) {
  98                 ERR("Create socket of unknown domain %d", domain);
  99                 ret = -1;
 100                 goto error;
 101         }
 102
 103         switch (sock->proto) {
 104         case LTTCOMM_SOCK_UDP:
 105                 _sock_type = SOCK_DGRAM;
 106                 _sock_proto = IPPROTO_UDP;
 107                 break;
 108         case LTTCOMM_SOCK_TCP:
 109                 _sock_type = SOCK_STREAM;
 110                 _sock_proto = IPPROTO_TCP;
 111                 break;
 112         default:
 113                 ret = -1;
 114                 goto error;
 115         }
 116
 117         ret = net_families[domain].create(sock, _sock_type, _sock_proto);
 118         if (ret < 0) {
 119                 goto error;
 120         }
 121
 122 error:
 123         return ret;
 124 }
 125
 126 /*
 127  * Return allocated lttcomm socket structure.
 128  */
 129 LTTNG_HIDDEN
 130 struct lttcomm_sock *lttcomm_alloc_sock(enum lttcomm_sock_proto proto)
 131 {
 132         struct lttcomm_sock *sock;
 133
 134         sock = zmalloc(sizeof(struct lttcomm_sock));
 135         if (sock == NULL) {
 136                 PERROR("zmalloc create sock");
 137                 goto end;
 138         }
 139
 140         sock->proto = proto;
 141         sock->fd = -1;
 142
 143 end:
 144         return sock;
 145 }
 146
 147 /*
 148  * Return an allocated lttcomm socket structure and copy src content into
 149  * the newly created socket.
 150  *
 151  * This is mostly useful when lttcomm_sock are passed between process where the
 152  * fd and ops have to be changed within the correct address space.
 153  */
 154 LTTNG_HIDDEN
 155 struct lttcomm_sock *lttcomm_alloc_copy_sock(struct lttcomm_sock *src)
 156 {
 157         struct lttcomm_sock *sock;
 158
 159         /* Safety net */
 160         LTTNG_ASSERT(src);
 161
 162         sock = lttcomm_alloc_sock(src->proto);
 163         if (sock == NULL) {
 164                 goto alloc_error;
 165         }
 166
 167         lttcomm_copy_sock(sock, src);
 168
 169 alloc_error:
 170         return sock;
 171 }
 172
 173 /*
 174  * Create and copy socket from an allocated lttcomm socket structure.
 175  *
 176  * This is mostly useful when lttcomm_sock are passed between process where the
 177  * fd and ops have to be changed within the correct address space.
 178  */
 179 LTTNG_HIDDEN
 180 void lttcomm_copy_sock(struct lttcomm_sock *dst, struct lttcomm_sock *src)
 181 {
 182         /* Safety net */
 183         LTTNG_ASSERT(dst);
 184         LTTNG_ASSERT(src);
 185
 186         dst->proto = src->proto;
 187         dst->fd = src->fd;
 188         dst->ops = src->ops;
 189         /* Copy sockaddr information from original socket */
 190         memcpy(&dst->sockaddr, &src->sockaddr, sizeof(dst->sockaddr));
 191 }
 192
 193 /*
 194  * Init IPv4 sockaddr structure.
 195  */
 196 LTTNG_HIDDEN
 197 int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr *sockaddr,
 198                 const char *ip, unsigned int port)
 199 {
 200         int ret;
 201
 202         LTTNG_ASSERT(sockaddr);
 203         LTTNG_ASSERT(ip);
 204         LTTNG_ASSERT(port > 0 && port <= 65535);
 205
 206         memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
 207
 208         sockaddr->type = LTTCOMM_INET;
 209         sockaddr->addr.sin.sin_family = AF_INET;
 210         sockaddr->addr.sin.sin_port = htons(port);
 211         ret = inet_pton(sockaddr->addr.sin.sin_family, ip,
 212                         &sockaddr->addr.sin.sin_addr);
 213         if (ret < 1) {
 214                 ret = -1;
 215                 ERR("%s with port %d: unrecognized IPv4 address", ip, port);
 216                 goto error;
 217         }
 218         memset(sockaddr->addr.sin.sin_zero, 0, sizeof(sockaddr->addr.sin.sin_zero));
 219
 220 error:
 221         return ret;
 222 }
 223
 224 /*
 225  * Init IPv6 sockaddr structure.
 226  */
 227 LTTNG_HIDDEN
 228 int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
 229                 const char *ip, unsigned int port)
 230 {
 231         int ret;
 232
 233         LTTNG_ASSERT(sockaddr);
 234         LTTNG_ASSERT(ip);
 235         LTTNG_ASSERT(port > 0 && port <= 65535);
 236
 237         memset(sockaddr, 0, sizeof(struct lttcomm_sockaddr));
 238
 239         sockaddr->type = LTTCOMM_INET6;
 240         sockaddr->addr.sin6.sin6_family = AF_INET6;
 241         sockaddr->addr.sin6.sin6_port = htons(port);
 242         ret = inet_pton(sockaddr->addr.sin6.sin6_family, ip,
 243                         &sockaddr->addr.sin6.sin6_addr);
 244         if (ret < 1) {
 245                 ret = -1;
 246                 goto error;
 247         }
 248
 249 error:
 250         return ret;
 251 }
 252
 253 /*
 254  * Return allocated lttcomm socket structure from lttng URI.
 255  */
 256 LTTNG_HIDDEN
 257 struct lttcomm_sock *lttcomm_alloc_sock_from_uri(struct lttng_uri *uri)
 258 {
 259         int ret;
 260         int _sock_proto;
 261         struct lttcomm_sock *sock = NULL;
 262
 263         /* Safety net */
 264         LTTNG_ASSERT(uri);
 265
 266         /* Check URI protocol */
 267         if (uri->proto == LTTNG_TCP) {
 268                 _sock_proto = LTTCOMM_SOCK_TCP;
 269         } else {
 270                 ERR("Relayd invalid URI proto: %d", uri->proto);
 271                 goto alloc_error;
 272         }
 273
 274         sock = lttcomm_alloc_sock(_sock_proto);
 275         if (sock == NULL) {
 276                 goto alloc_error;
 277         }
 278
 279         /* Check destination type */
 280         if (uri->dtype == LTTNG_DST_IPV4) {
 281                 ret = lttcomm_init_inet_sockaddr(&sock->sockaddr, uri->dst.ipv4,
 282                                 uri->port);
 283                 if (ret < 0) {
 284                         goto error;
 285                 }
 286         } else if (uri->dtype == LTTNG_DST_IPV6) {
 287                 ret = lttcomm_init_inet6_sockaddr(&sock->sockaddr, uri->dst.ipv6,
 288                                 uri->port);
 289                 if (ret < 0) {
 290                         goto error;
 291                 }
 292         } else {
 293                 /* Command URI is invalid */
 294                 ERR("Relayd invalid URI dst type: %d", uri->dtype);
 295                 goto error;
 296         }
 297
 298         return sock;
 299
 300 error:
 301         lttcomm_destroy_sock(sock);
 302 alloc_error:
 303         return NULL;
 304 }
 305
 306 /*
 307  * Destroy and free lttcomm socket.
 308  */
 309 LTTNG_HIDDEN
 310 void lttcomm_destroy_sock(struct lttcomm_sock *sock)
 311 {
 312         free(sock);
 313 }
 314
 315 /*
 316  * Allocate and return a relayd socket object using a given URI to initialize
 317  * it and the major/minor version of the supported protocol.
 318  *
 319  * On error, NULL is returned.
 320  */
 321 LTTNG_HIDDEN
 322 struct lttcomm_relayd_sock *lttcomm_alloc_relayd_sock(struct lttng_uri *uri,
 323                 uint32_t major, uint32_t minor)
 324 {
 325         int ret;
 326         struct lttcomm_sock *tmp_sock = NULL;
 327         struct lttcomm_relayd_sock *rsock = NULL;
 328
 329         LTTNG_ASSERT(uri);
 330
 331         rsock = zmalloc(sizeof(*rsock));
 332         if (!rsock) {
 333                 PERROR("zmalloc relayd sock");
 334                 goto error;
 335         }
 336
 337         /* Allocate socket object from URI */
 338         tmp_sock = lttcomm_alloc_sock_from_uri(uri);
 339         if (tmp_sock == NULL) {
 340                 goto error_free;
 341         }
 342
 343         /*
 344          * Create socket object which basically sets the ops according to the
 345          * socket protocol.
 346          */
 347         lttcomm_copy_sock(&rsock->sock, tmp_sock);
 348         /* Temporary socket pointer not needed anymore. */
 349         lttcomm_destroy_sock(tmp_sock);
 350         ret = lttcomm_create_sock(&rsock->sock);
 351         if (ret < 0) {
 352                 goto error_free;
 353         }
 354
 355         rsock->major = major;
 356         rsock->minor = minor;
 357
 358         return rsock;
 359
 360 error_free:
 361         free(rsock);
 362 error:
 363         return NULL;
 364 }
 365
 366 /*
 367  * Set socket receiving timeout.
 368  */
 369 LTTNG_HIDDEN
 370 int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec)
 371 {
 372         int ret;
 373         struct timeval tv;
 374
 375         tv.tv_sec = msec / 1000;
 376         tv.tv_usec = (msec % 1000) * 1000;
 377
 378         ret = setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 379         if (ret < 0) {
 380                 PERROR("setsockopt SO_RCVTIMEO");
 381         }
 382
 383         return ret;
 384 }
 385
 386 /*
 387  * Set socket sending timeout.
 388  */
 389 LTTNG_HIDDEN
 390 int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec)
 391 {
 392         int ret;
 393         struct timeval tv;
 394
 395         tv.tv_sec = msec / 1000;
 396         tv.tv_usec = (msec % 1000) * 1000;
 397
 398         ret = setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
 399         if (ret < 0) {
 400                 PERROR("setsockopt SO_SNDTIMEO");
 401         }
 402
 403         return ret;
 404 }
 405
 406 LTTNG_HIDDEN
 407 int lttcomm_sock_get_port(const struct lttcomm_sock *sock, uint16_t *port)
 408 {
 409         LTTNG_ASSERT(sock);
 410         LTTNG_ASSERT(port);
 411         LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET ||
 412                         sock->sockaddr.type == LTTCOMM_INET6);
 413         LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP ||
 414                         sock->proto == LTTCOMM_SOCK_UDP);
 415
 416         switch (sock->sockaddr.type) {
 417         case LTTCOMM_INET:
 418                 *port = ntohs(sock->sockaddr.addr.sin.sin_port);
 419                 break;
 420         case LTTCOMM_INET6:
 421                 *port = ntohs(sock->sockaddr.addr.sin6.sin6_port);
 422                 break;
 423         default:
 424                 abort();
 425         }
 426
 427         return 0;
 428 }
 429
 430 LTTNG_HIDDEN
 431 int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port)
 432 {
 433         LTTNG_ASSERT(sock);
 434         LTTNG_ASSERT(sock->sockaddr.type == LTTCOMM_INET ||
 435                         sock->sockaddr.type == LTTCOMM_INET6);
 436         LTTNG_ASSERT(sock->proto == LTTCOMM_SOCK_TCP ||
 437                         sock->proto == LTTCOMM_SOCK_UDP);
 438
 439         switch (sock->sockaddr.type) {
 440         case LTTCOMM_INET:
 441                 sock->sockaddr.addr.sin.sin_port = htons(port);
 442                 break;
 443         case LTTCOMM_INET6:
 444                 sock->sockaddr.addr.sin6.sin6_port = htons(port);
 445                 break;
 446         default:
 447                 abort();
 448         }
 449
 450         return 0;
 451 }
 452
 453 LTTNG_HIDDEN
 454 void lttcomm_init(void)
 455 {
 456         const char *env;
 457
 458         env = getenv(NETWORK_TIMEOUT_ENV);
 459         if (env) {
 460                 long timeout;
 461
 462                 errno = 0;
 463                 timeout = strtol(env, NULL, 0);
 464                 if (errno != 0 || timeout < -1L) {
 465                         PERROR("Network timeout");
 466                 } else {
 467                         if (timeout > 0) {
 468                                 network_timeout = timeout;
 469                         }
 470                 }
 471         }
 472 }
 473
 474 LTTNG_HIDDEN
 475 unsigned long lttcomm_get_network_timeout(void)
 476 {
 477         return network_timeout;
 478 }