src/lib/lttng-ctl/load.cpp

   1 /*
   2  * Copyright (C) 2014 David Goulet <dgoulet@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <string.h>
  10 #include <limits.h>
  11
  12 #include <lttng/lttng-error.h>
  13 #include <lttng/load.h>
  14 #include <lttng/load-internal.hpp>
  15 #include <common/sessiond-comm/sessiond-comm.hpp>
  16 #include <common/config/session-config.hpp>
  17 #include <common/uri.hpp>
  18 #include <common/macros.hpp>
  19 #include <common/compat/string.hpp>
  20
  21 #include "lttng-ctl-helper.hpp"
  22
  23 struct lttng_load_session_attr *lttng_load_session_attr_create(void)
  24 {
  25         return zmalloc<lttng_load_session_attr>();
  26 }
  27
  28 static
  29 void reset_load_session_attr_urls(struct lttng_load_session_attr *attr)
  30 {
  31         free(attr->raw_override_url);
  32         free(attr->raw_override_path_url);
  33         free(attr->raw_override_ctrl_url);
  34         free(attr->raw_override_data_url);
  35         if (attr->override_attr) {
  36                 free(attr->override_attr->path_url);
  37                 free(attr->override_attr->ctrl_url);
  38                 free(attr->override_attr->data_url);
  39                 free(attr->override_attr->session_name);
  40         }
  41 }
  42
  43 void lttng_load_session_attr_destroy(struct lttng_load_session_attr *attr)
  44 {
  45         if (attr) {
  46                 reset_load_session_attr_urls(attr);
  47                 free(attr->override_attr);
  48                 free(attr);
  49         }
  50 }
  51
  52 static int validate_attr(const struct lttng_load_session_attr *attr)
  53 {
  54         int ret = 0;
  55
  56         if (!attr) {
  57                 ret = -LTTNG_ERR_INVALID;
  58                 goto end;
  59         }
  60
  61         if (!attr->override_attr) {
  62                 goto end;
  63         }
  64
  65         /*
  66          * Refuse override name if the objective is to load multiple session
  67          * since this operation is ambiguous while loading multiple session.
  68          */
  69         if (attr->override_attr->session_name
  70                         && attr->session_name[0] == '\0') {
  71                 ret = -LTTNG_ERR_INVALID;
  72                 goto end;
  73         }
  74 end:
  75         return ret;
  76 }
  77
  78 const char *lttng_load_session_attr_get_session_name(
  79         struct lttng_load_session_attr *attr)
  80 {
  81         const char *ret = NULL;
  82
  83         if (attr && attr->session_name[0]) {
  84                 ret = attr->session_name;
  85         }
  86
  87         return ret;
  88 }
  89
  90 const char *lttng_load_session_attr_get_input_url(
  91         struct lttng_load_session_attr *attr)
  92 {
  93         const char *ret = NULL;
  94
  95         if (attr && attr->input_url[0]) {
  96                 ret = attr->input_url;
  97         }
  98
  99         return ret;
 100 }
 101
 102 int lttng_load_session_attr_get_overwrite(
 103         struct lttng_load_session_attr *attr)
 104 {
 105         return attr ? attr->overwrite : -LTTNG_ERR_INVALID;
 106 }
 107
 108 const char *lttng_load_session_attr_get_override_ctrl_url(
 109         struct lttng_load_session_attr *attr)
 110 {
 111         const char *ret = NULL;
 112
 113         if (!attr || !attr->override_attr) {
 114                 goto end;
 115         }
 116
 117         ret = attr->raw_override_ctrl_url;
 118 end:
 119         return ret;
 120 }
 121
 122 const char *lttng_load_session_attr_get_override_data_url(
 123         struct lttng_load_session_attr *attr)
 124 {
 125         const char *ret = NULL;
 126
 127         if (!attr || !attr->override_attr) {
 128                 goto end;
 129         }
 130
 131         ret = attr->raw_override_data_url;
 132 end:
 133         return ret;
 134 }
 135
 136 const char *lttng_load_session_attr_get_override_url(
 137                 struct lttng_load_session_attr *attr)
 138 {
 139         const char *ret = NULL;
 140
 141         if (!attr || !attr->override_attr) {
 142                 goto end;
 143         }
 144
 145         if ((attr->override_attr->path_url ||
 146                 (attr->override_attr->ctrl_url &&
 147                  attr->override_attr->data_url))) {
 148                 ret = attr->raw_override_url;
 149         }
 150 end:
 151         return ret;
 152 }
 153
 154 const char *lttng_load_session_attr_get_override_session_name(
 155                 struct lttng_load_session_attr *attr)
 156 {
 157         const char *ret = NULL;
 158
 159         if (!attr || !attr->override_attr) {
 160                 goto end;
 161         }
 162
 163         ret = attr->override_attr->session_name;
 164 end:
 165         return ret;
 166 }
 167
 168 int lttng_load_session_attr_set_session_name(
 169         struct lttng_load_session_attr *attr, const char *session_name)
 170 {
 171         int ret = 0;
 172
 173         if (!attr) {
 174                 ret = -LTTNG_ERR_INVALID;
 175                 goto error;
 176         }
 177
 178         if (session_name) {
 179                 size_t len;
 180
 181                 len = strlen(session_name);
 182                 if (len >= LTTNG_NAME_MAX) {
 183                         ret = -LTTNG_ERR_INVALID;
 184                         goto error;
 185                 }
 186
 187                 ret = lttng_strncpy(attr->session_name, session_name,
 188                                 sizeof(attr->session_name));
 189                 if (ret) {
 190                         ret = -LTTNG_ERR_INVALID;
 191                         goto error;
 192                 }
 193         } else {
 194                 attr->session_name[0] = '\0';
 195         }
 196 error:
 197         return ret;
 198 }
 199
 200 int lttng_load_session_attr_set_input_url(
 201         struct lttng_load_session_attr *attr, const char *url)
 202 {
 203         int ret = 0;
 204         size_t len;
 205         ssize_t size;
 206         struct lttng_uri *uris = NULL;
 207
 208         if (!attr) {
 209                 ret = -LTTNG_ERR_INVALID;
 210                 goto error;
 211         }
 212
 213         if (!url) {
 214                 attr->input_url[0] = '\0';
 215                 ret = 0;
 216                 goto end;
 217         }
 218
 219         len = strlen(url);
 220         if (len >= PATH_MAX) {
 221                 ret = -LTTNG_ERR_INVALID;
 222                 goto error;
 223         }
 224
 225         size = uri_parse_str_urls(url, NULL, &uris);
 226         if (size <= 0 || uris[0].dtype != LTTNG_DST_PATH) {
 227                 ret = -LTTNG_ERR_INVALID;
 228                 goto error;
 229         }
 230
 231         /* Copy string plus the NULL terminated byte. */
 232         ret = lttng_strncpy(attr->input_url, uris[0].dst.path,
 233                         sizeof(attr->input_url));
 234         if (ret) {
 235                 ret = -LTTNG_ERR_INVALID;
 236                 goto error;
 237         }
 238
 239 end:
 240 error:
 241         free(uris);
 242         return ret;
 243 }
 244
 245 int lttng_load_session_attr_set_overwrite(
 246         struct lttng_load_session_attr *attr, int overwrite)
 247 {
 248         int ret = 0;
 249
 250         if (!attr) {
 251                 ret = -LTTNG_ERR_INVALID;
 252                 goto end;
 253         }
 254
 255         attr->overwrite = !!overwrite;
 256 end:
 257         return ret;
 258 }
 259
 260 int lttng_load_session_attr_set_override_ctrl_url(
 261         struct lttng_load_session_attr *attr, const char *url)
 262 {
 263         int ret = 0;
 264         ssize_t ret_size;
 265         struct lttng_uri *uri = NULL;
 266         char *url_str = NULL;
 267         char *raw_str = NULL;
 268
 269         if (!attr) {
 270                 ret = -LTTNG_ERR_INVALID;
 271                 goto end;
 272         }
 273
 274         if (!attr->override_attr) {
 275                 attr->override_attr = zmalloc<config_load_session_override_attr>();
 276                 if (!attr->override_attr) {
 277                         ret = -LTTNG_ERR_NOMEM;
 278                         goto end;
 279                 }
 280         }
 281
 282         if (attr->override_attr->path_url) {
 283                 /*
 284                  * Setting a ctrl override after a path override makes no sense.
 285                  */
 286                 ret = -LTTNG_ERR_INVALID;
 287                 goto end;
 288         }
 289
 290         /*
 291          * FIXME: uri_parse should be able to take as parameter the protocol
 292          * type to validate "url". For now only check the parsing goes through;
 293          * it will fail later on.
 294          */
 295         ret_size = uri_parse(url, &uri);
 296         if (ret_size < 0) {
 297                 ret = -LTTNG_ERR_INVALID;
 298                 goto end;
 299         }
 300
 301         if (uri[0].port == 0) {
 302                 uri[0].port = DEFAULT_NETWORK_CONTROL_PORT;
 303         }
 304
 305         url_str = calloc<char>(PATH_MAX);
 306         if (!url_str) {
 307                 /* FIXME: return valid error */
 308                 ret = -LTTNG_ERR_NOMEM;
 309                 goto end;
 310         }
 311
 312         ret = uri_to_str_url(&uri[0], url_str, PATH_MAX);
 313         if (ret < 0) {
 314                 ret = -LTTNG_ERR_INVALID;
 315                 goto end;
 316         }
 317         ret = 0;
 318
 319         raw_str = lttng_strndup(url, PATH_MAX);
 320         if (!raw_str) {
 321                 ret = -LTTNG_ERR_NOMEM;
 322                 goto end;
 323         }
 324
 325         /* Squash old value if any */
 326         free(attr->override_attr->ctrl_url);
 327         free(attr->raw_override_ctrl_url);
 328
 329         /* Populate the object */
 330         attr->override_attr->ctrl_url = url_str;
 331         attr->raw_override_ctrl_url = raw_str;
 332
 333         /* Ownership passed to attr. */
 334         url_str = NULL;
 335         raw_str = NULL;
 336
 337 end:
 338         free(raw_str);
 339         free(url_str);
 340         free(uri);
 341         return ret;
 342 }
 343
 344 int lttng_load_session_attr_set_override_data_url(
 345         struct lttng_load_session_attr *attr, const char *url)
 346 {
 347         int ret = 0;
 348         ssize_t ret_size;
 349         struct lttng_uri *uri = NULL;
 350         char *url_str = NULL;
 351         char *raw_str = NULL;
 352
 353         if (!attr) {
 354                 ret = -LTTNG_ERR_INVALID;
 355                 goto end;
 356         }
 357
 358         if (!attr->override_attr) {
 359                 attr->override_attr = zmalloc<config_load_session_override_attr>();
 360                 if (!attr->override_attr) {
 361                         ret = -LTTNG_ERR_NOMEM;
 362                         goto end;
 363                 }
 364         }
 365
 366         if (attr->override_attr->path_url) {
 367                 /*
 368                  * Setting a data override after a path override makes no sense.
 369                  */
 370                 ret = -LTTNG_ERR_INVALID;
 371                 goto end;
 372         }
 373
 374         /*
 375          * FIXME: uri_parse should be able to take as parameter the protocol
 376          * type to validate "url". For now only check the parsing goes through;
 377          * it will fail later on.
 378          */
 379         ret_size = uri_parse(url, &uri);
 380         if (ret_size < 0) {
 381                 ret = -LTTNG_ERR_INVALID;
 382                 goto end;
 383         }
 384
 385         if (uri[0].port == 0) {
 386                 uri[0].port = DEFAULT_NETWORK_DATA_PORT;
 387         }
 388
 389         url_str = calloc<char>(PATH_MAX);
 390         if (!url_str) {
 391                 ret = -LTTNG_ERR_NOMEM;
 392                 goto end;
 393         }
 394
 395         ret = uri_to_str_url(&uri[0], url_str, PATH_MAX);
 396         if (ret < 0) {
 397                 ret = -LTTNG_ERR_INVALID;
 398                 goto end;
 399         }
 400         ret = 0;
 401
 402         raw_str = lttng_strndup(url, PATH_MAX);
 403         if (!raw_str) {
 404                 ret = -LTTNG_ERR_NOMEM;
 405                 goto end;
 406         }
 407
 408         /* Squash old value if any */
 409         free(attr->override_attr->data_url);
 410         free(attr->raw_override_data_url);
 411
 412         /* Populate the object */
 413         attr->override_attr->data_url = url_str;
 414         attr->raw_override_data_url = raw_str;
 415
 416         /* Ownership passed to attr. */
 417         url_str = NULL;
 418         raw_str = NULL;
 419 end:
 420         free(raw_str);
 421         free(url_str);
 422         free(uri);
 423         return ret;
 424 }
 425
 426 int lttng_load_session_attr_set_override_url(
 427                 struct lttng_load_session_attr *attr, const char *url)
 428 {
 429         int ret = 0;
 430         ssize_t ret_size;
 431         struct lttng_uri *uri = NULL;
 432         char *raw_url_str = NULL;
 433         char *raw_path_str = NULL;
 434         char *path_str = NULL;
 435         char *raw_ctrl_str = NULL;
 436         char *ctrl_str = NULL;
 437         char *raw_data_str = NULL;
 438         char *data_str = NULL;
 439         char buffer[PATH_MAX];
 440
 441         if (!attr || !url || strlen(url) >= PATH_MAX) {
 442                 ret = -LTTNG_ERR_INVALID;
 443                 goto end;
 444         }
 445
 446         if (!attr->override_attr) {
 447                 attr->override_attr = zmalloc<config_load_session_override_attr>();
 448                 if (!attr->override_attr) {
 449                         ret = -LTTNG_ERR_NOMEM;
 450                         goto end;
 451                 }
 452         }
 453
 454         /*
 455          * FIXME: uri_parse should be able to take as parameter the protocol
 456          * type to validate "url". For now only check the parsing goes through;
 457          * it will fail later on.
 458          */
 459         ret_size = uri_parse_str_urls(url, NULL, &uri);
 460         if (ret_size < 0 || ret_size > 2) {
 461                 /* Unexpected URL format. */
 462                 ret = -LTTNG_ERR_INVALID;
 463                 goto end;
 464         }
 465
 466         raw_url_str = lttng_strndup(url, PATH_MAX);
 467         if (!raw_url_str) {
 468                 ret = -LTTNG_ERR_NOMEM;
 469                 goto end;
 470         }
 471
 472         /* Get path | ctrl && data string URL. */
 473         ret = uri_to_str_url(&uri[0], buffer, sizeof(buffer));
 474         if (ret < 0 || ret >= PATH_MAX) {
 475                 ret = -LTTNG_ERR_INVALID;
 476                 goto end;
 477         }
 478         ret = 0;
 479
 480         switch (uri[0].dtype) {
 481         case LTTNG_DST_PATH:
 482                 raw_path_str = lttng_strndup(buffer, PATH_MAX);
 483                 if (!raw_path_str) {
 484                         ret = -LTTNG_ERR_NOMEM;
 485                         goto end;
 486                 }
 487
 488                 path_str = lttng_strndup(raw_path_str, PATH_MAX);
 489                 if (!path_str) {
 490                         ret = -LTTNG_ERR_NOMEM;
 491                         goto end;
 492                 }
 493                 break;
 494         case LTTNG_DST_IPV4:
 495         case LTTNG_DST_IPV6:
 496                 if (ret_size != 2) {
 497                         ret = -LTTNG_ERR_INVALID;
 498                         goto end;
 499                 }
 500
 501                 raw_ctrl_str = lttng_strndup(buffer, PATH_MAX);
 502                 if (!raw_ctrl_str) {
 503                         ret = -LTTNG_ERR_NOMEM;
 504                         goto end;
 505                 }
 506
 507                 ctrl_str = lttng_strndup(raw_ctrl_str, PATH_MAX);
 508                 if (!ctrl_str) {
 509                         ret = -LTTNG_ERR_NOMEM;
 510                         goto end;
 511                 }
 512
 513                 /* Get the data uri. */
 514                 ret = uri_to_str_url(&uri[1], buffer, sizeof(buffer));
 515                 if (ret < 0) {
 516                         ret = -LTTNG_ERR_INVALID;
 517                         goto end;
 518                 }
 519                 ret = 0;
 520
 521                 raw_data_str = lttng_strndup(buffer, PATH_MAX);
 522                 if (!raw_data_str) {
 523                         ret = -LTTNG_ERR_NOMEM;
 524                         goto end;
 525                 }
 526
 527                 data_str = lttng_strndup(raw_data_str, PATH_MAX);
 528                 if (!data_str) {
 529                         ret = -LTTNG_ERR_NOMEM;
 530                         goto end;
 531                 }
 532
 533                 break;
 534         default:
 535                 ret = -LTTNG_ERR_INVALID;
 536                 goto end;
 537         }
 538
 539         reset_load_session_attr_urls(attr);
 540
 541         attr->override_attr->path_url = path_str;
 542         attr->override_attr->ctrl_url = ctrl_str;
 543         attr->override_attr->data_url = data_str;
 544
 545         attr->raw_override_url = raw_url_str;
 546         attr->raw_override_path_url = raw_path_str;
 547         attr->raw_override_ctrl_url = raw_ctrl_str;
 548         attr->raw_override_data_url = raw_data_str;
 549
 550         /* Pass data ownership to attr. */
 551         raw_url_str = NULL;
 552         raw_path_str = NULL;
 553         path_str = NULL;
 554         raw_ctrl_str = NULL;
 555         ctrl_str = NULL;
 556         raw_data_str = NULL;
 557         data_str = NULL;
 558
 559 end:
 560         free(raw_path_str);
 561         free(path_str);
 562         free(raw_ctrl_str);
 563         free(ctrl_str);
 564         free(raw_data_str);
 565         free(data_str);
 566         free(raw_url_str);
 567         free(uri);
 568         return ret;
 569 }
 570
 571 int lttng_load_session_attr_set_override_session_name(
 572         struct lttng_load_session_attr *attr, const char *session_name)
 573 {
 574         int ret = 0;
 575         size_t len;
 576
 577         if (!attr ||!session_name) {
 578                 ret = -LTTNG_ERR_INVALID;
 579                 goto end;
 580         }
 581
 582         if (!attr->override_attr) {
 583                 attr->override_attr = zmalloc<config_load_session_override_attr>();
 584                 if (!attr->override_attr) {
 585                         ret = -LTTNG_ERR_NOMEM;
 586                         goto end;
 587                 }
 588         }
 589
 590         len = strlen(session_name);
 591         if (len >= LTTNG_NAME_MAX) {
 592                 ret = -LTTNG_ERR_INVALID;
 593                 goto end;
 594         }
 595
 596         attr->override_attr->session_name = lttng_strndup(session_name,
 597                 len);
 598         if (!attr->override_attr->session_name) {
 599                 ret = -LTTNG_ERR_NOMEM;
 600                 goto end;
 601         }
 602 end:
 603         return ret;
 604 }
 605
 606 int lttng_load_session(struct lttng_load_session_attr *attr)
 607 {
 608         int ret;
 609         const char *url, *session_name;
 610
 611         if (!attr) {
 612                 ret = -LTTNG_ERR_INVALID;
 613                 goto end;
 614         }
 615
 616         ret = validate_attr(attr);
 617         if (ret) {
 618                 goto end;
 619         }
 620
 621         url = attr->input_url[0] != '\0' ? attr->input_url : NULL;
 622         session_name = attr->session_name[0] != '\0' ?
 623                         attr->session_name : NULL;
 624
 625         ret = config_load_session(url, session_name, attr->overwrite, 0,
 626                         attr->override_attr);
 627
 628 end:
 629         return ret;
 630 }