src/common/session-descriptor.cpp

   1 /*
   2  * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  */
   6
   7 #include <lttng/session-descriptor-internal.h>
   8 #include <common/macros.h>
   9 #include <common/uri.h>
  10 #include <common/defaults.h>
  11 #include <common/error.h>
  12 #include <time.h>
  13 #include <stdio.h>
  14
  15 struct lttng_session_descriptor_network_location {
  16         struct lttng_uri *control;
  17         struct lttng_uri *data;
  18 };
  19
  20 struct lttng_session_descriptor {
  21         enum lttng_session_descriptor_type type;
  22         /*
  23          * If an output type that is not OUTPUT_TYPE_NONE is specified,
  24          * it means that an output of that type must be generated at
  25          * session-creation time.
  26          */
  27         enum lttng_session_descriptor_output_type output_type;
  28         char *name;
  29         union {
  30                 struct lttng_session_descriptor_network_location network;
  31                 struct lttng_uri *local;
  32         } output;
  33 };
  34
  35 struct lttng_session_descriptor_snapshot {
  36         struct lttng_session_descriptor base;
  37         /*
  38          * Assumes at-most one snapshot output is supported. Uses
  39          * the output field of the base class.
  40          */
  41 };
  42
  43 struct lttng_session_descriptor_live {
  44         struct lttng_session_descriptor base;
  45         unsigned long long live_timer_us;
  46 };
  47
  48 struct lttng_session_descriptor_comm {
  49         /* enum lttng_session_descriptor_type */
  50         uint8_t type;
  51         /* enum lttng_session_descriptor_output_type */
  52         uint8_t output_type;
  53         /* Includes trailing null. */
  54         uint32_t name_len;
  55         /* Name follows, followed by URIs */
  56         uint8_t uri_count;
  57 } LTTNG_PACKED;
  58
  59 struct lttng_session_descriptor_live_comm {
  60         struct lttng_session_descriptor_comm base;
  61         /* Live-specific parameters. */
  62         uint64_t live_timer_us;
  63 } LTTNG_PACKED;
  64
  65 static
  66 struct lttng_uri *uri_copy(const struct lttng_uri *uri)
  67 {
  68         struct lttng_uri *new_uri = NULL;
  69
  70         if (!uri) {
  71                 goto end;
  72         }
  73
  74         new_uri = (lttng_uri *) zmalloc(sizeof(*new_uri));
  75         if (!new_uri) {
  76                 goto end;
  77         }
  78         memcpy(new_uri, uri, sizeof(*new_uri));
  79 end:
  80         return new_uri;
  81 }
  82
  83 static
  84 struct lttng_uri *uri_from_path(const char *path)
  85 {
  86         struct lttng_uri *uris = NULL;
  87         ssize_t uri_count;
  88         char local_protocol_string[LTTNG_PATH_MAX + sizeof("file://")] =
  89                         "file://";
  90
  91         if (strlen(path) >= LTTNG_PATH_MAX) {
  92                 goto end;
  93         }
  94
  95         if (path[0] != '/') {
  96                 /* Not an absolute path. */
  97                 goto end;
  98         }
  99
 100         strncat(local_protocol_string, path, LTTNG_PATH_MAX);
 101         uri_count = uri_parse(local_protocol_string, &uris);
 102         if (uri_count != 1) {
 103                 goto error;
 104         }
 105         if (uris[0].dtype != LTTNG_DST_PATH) {
 106                 goto error;
 107         }
 108
 109 end:
 110         return uris;
 111 error:
 112         free(uris);
 113         return NULL;
 114 }
 115
 116 static
 117 void network_location_fini(
 118                 struct lttng_session_descriptor_network_location *location)
 119 {
 120         free(location->control);
 121         free(location->data);
 122 }
 123
 124 /* Assumes ownership of control and data. */
 125 static
 126 int network_location_set_from_lttng_uris(
 127                 struct lttng_session_descriptor_network_location *location,
 128                 struct lttng_uri *control, struct lttng_uri *data)
 129 {
 130         int ret = 0;
 131
 132         if (!control && !data) {
 133                 goto end;
 134         }
 135
 136         if (!(control && data)) {
 137                 /* None or both must be set. */
 138                 ret = -1;
 139                 goto end;
 140         }
 141
 142         if (control->stype != LTTNG_STREAM_CONTROL ||
 143                         data->stype != LTTNG_STREAM_DATA) {
 144                 ret = -1;
 145                 goto end;
 146         }
 147
 148         free(location->control);
 149         free(location->data);
 150         location->control = control;
 151         location->data = data;
 152         control = NULL;
 153         data = NULL;
 154 end:
 155         free(control);
 156         free(data);
 157         return ret;
 158 }
 159
 160 static
 161 int network_location_set_from_uri_strings(
 162                 struct lttng_session_descriptor_network_location *location,
 163                 const char *control, const char *data)
 164 {
 165         int ret = 0;
 166         ssize_t uri_count;
 167         struct lttng_uri *parsed_uris = NULL;
 168         struct lttng_uri *control_uri = NULL;
 169         struct lttng_uri *data_uri = NULL;
 170
 171         uri_count = uri_parse_str_urls(control, data, &parsed_uris);
 172         if (uri_count != 2 && uri_count != 0) {
 173                 ret = -1;
 174                 goto end;
 175         }
 176
 177         /*
 178          * uri_parse_str_urls returns a contiguous array of lttng_uris whereas
 179          * session descriptors expect individually allocated lttng_uris.
 180          */
 181         if (uri_count == 2) {
 182                 control_uri = (lttng_uri *) zmalloc(sizeof(*control_uri));
 183                 data_uri = (lttng_uri *) zmalloc(sizeof(*data_uri));
 184                 if (!control_uri || !data_uri) {
 185                         ret = -1;
 186                         goto end;
 187                 }
 188                 memcpy(control_uri, &parsed_uris[0], sizeof(*control_uri));
 189                 memcpy(data_uri, &parsed_uris[1], sizeof(*data_uri));
 190         }
 191
 192         /* Ownership of control and data uris is transferred. */
 193         ret = network_location_set_from_lttng_uris(
 194                         location,
 195                         control_uri,
 196                         data_uri);
 197         control_uri = NULL;
 198         data_uri = NULL;
 199 end:
 200         free(parsed_uris);
 201         free(control_uri);
 202         free(data_uri);
 203         return ret;
 204 }
 205
 206 struct lttng_session_descriptor *
 207 lttng_session_descriptor_create(const char *name)
 208 {
 209         struct lttng_session_descriptor *descriptor;
 210
 211         descriptor = (lttng_session_descriptor *) zmalloc(sizeof(*descriptor));
 212         if (!descriptor) {
 213                 goto error;
 214         }
 215
 216         descriptor->type = LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR;
 217         descriptor->output_type =
 218                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE;
 219         if (lttng_session_descriptor_set_session_name(descriptor, name)) {
 220                 goto error;
 221         }
 222         return descriptor;
 223 error:
 224         lttng_session_descriptor_destroy(descriptor);
 225         return NULL;
 226 }
 227
 228 /* Ownership of uri is transferred. */
 229 static
 230 struct lttng_session_descriptor *
 231 _lttng_session_descriptor_local_create(const char *name,
 232                 struct lttng_uri *uri)
 233 {
 234         struct lttng_session_descriptor *descriptor;
 235
 236         descriptor = lttng_session_descriptor_create(name);
 237         if (!descriptor) {
 238                 goto error;
 239         }
 240         descriptor->type = LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR;
 241         descriptor->output_type =
 242                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL;
 243         if (uri) {
 244                 if (uri->dtype != LTTNG_DST_PATH) {
 245                         goto error;
 246                 }
 247                 descriptor->output.local = uri;
 248                 uri = NULL;
 249         }
 250         return descriptor;
 251 error:
 252         free(uri);
 253         lttng_session_descriptor_destroy(descriptor);
 254         return NULL;
 255 }
 256
 257 struct lttng_session_descriptor *
 258 lttng_session_descriptor_local_create(const char *name, const char *path)
 259 {
 260         struct lttng_uri *uri = NULL;
 261         struct lttng_session_descriptor *descriptor;
 262
 263         if (path) {
 264                 uri = uri_from_path(path);
 265                 if (!uri) {
 266                         goto error;
 267                 }
 268         }
 269         descriptor = _lttng_session_descriptor_local_create(name, uri);
 270         return descriptor;
 271 error:
 272         return NULL;
 273 }
 274
 275 /* Assumes the ownership of both uris. */
 276 static
 277 struct lttng_session_descriptor *
 278 _lttng_session_descriptor_network_create(const char *name,
 279                 struct lttng_uri *control, struct lttng_uri *data)
 280 {
 281         int ret;
 282         struct lttng_session_descriptor *descriptor;
 283
 284         descriptor = lttng_session_descriptor_create(name);
 285         if (!descriptor) {
 286                 goto error;
 287         }
 288
 289         descriptor->type = LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR;
 290         descriptor->output_type = LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK;
 291         /* Assumes the ownership of both uris. */
 292         ret = network_location_set_from_lttng_uris(&descriptor->output.network,
 293                         control, data);
 294         control = NULL;
 295         data = NULL;
 296         if (ret) {
 297                 goto error;
 298         }
 299         return descriptor;
 300 error:
 301         lttng_session_descriptor_destroy(descriptor);
 302         free(control);
 303         free(data);
 304         return NULL;
 305 }
 306
 307 struct lttng_session_descriptor *
 308 lttng_session_descriptor_network_create(const char *name,
 309                 const char *control_url, const char *data_url)
 310 {
 311         int ret;
 312         struct lttng_session_descriptor *descriptor;
 313
 314         descriptor = _lttng_session_descriptor_network_create(name,
 315                         NULL, NULL);
 316         if (!descriptor) {
 317                 goto error;
 318         }
 319
 320         ret = network_location_set_from_uri_strings(&descriptor->output.network,
 321                         control_url, data_url);
 322         if (ret) {
 323                 goto error;
 324         }
 325         return descriptor;
 326 error:
 327         lttng_session_descriptor_destroy(descriptor);
 328         return NULL;
 329 }
 330
 331 static
 332 struct lttng_session_descriptor_snapshot *
 333 _lttng_session_descriptor_snapshot_create(const char *name)
 334 {
 335         struct lttng_session_descriptor_snapshot *descriptor;
 336
 337         descriptor = (lttng_session_descriptor_snapshot *) zmalloc(sizeof(*descriptor));
 338         if (!descriptor) {
 339                 goto error;
 340         }
 341
 342         descriptor->base.type = LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT;
 343         descriptor->base.output_type =
 344                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE;
 345         if (lttng_session_descriptor_set_session_name(&descriptor->base,
 346                         name)) {
 347                 goto error;
 348         }
 349         return descriptor;
 350 error:
 351         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 352         return NULL;
 353 }
 354
 355 /* Ownership of control and data is transferred. */
 356 static
 357 struct lttng_session_descriptor_snapshot *
 358 _lttng_session_descriptor_snapshot_network_create(const char *name,
 359                 struct lttng_uri *control, struct lttng_uri *data)
 360 {
 361         int ret;
 362         struct lttng_session_descriptor_snapshot *descriptor;
 363
 364         descriptor = _lttng_session_descriptor_snapshot_create(name);
 365         if (!descriptor) {
 366                 goto error;
 367         }
 368
 369         descriptor->base.output_type =
 370                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK;
 371         /* Ownership of control and data is transferred. */
 372         ret = network_location_set_from_lttng_uris(
 373                         &descriptor->base.output.network,
 374                         control, data);
 375         control = NULL;
 376         data = NULL;
 377         if (ret) {
 378                 goto error;
 379         }
 380         return descriptor;
 381 error:
 382         free(control);
 383         free(data);
 384         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 385         return NULL;
 386 }
 387
 388 struct lttng_session_descriptor *
 389 lttng_session_descriptor_snapshot_create(const char *name)
 390 {
 391         struct lttng_session_descriptor_snapshot *descriptor;
 392
 393         descriptor = _lttng_session_descriptor_snapshot_create(name);
 394         return descriptor ? &descriptor->base : NULL;
 395 }
 396
 397 struct lttng_session_descriptor *
 398 lttng_session_descriptor_snapshot_network_create(const char *name,
 399                 const char *control_url, const char *data_url)
 400 {
 401         int ret;
 402         struct lttng_session_descriptor_snapshot *descriptor;
 403
 404         descriptor = _lttng_session_descriptor_snapshot_network_create(name,
 405                         NULL, NULL);
 406         if (!descriptor) {
 407                 goto error;
 408         }
 409
 410         ret = network_location_set_from_uri_strings(
 411                         &descriptor->base.output.network,
 412                         control_url, data_url);
 413         if (ret) {
 414                 goto error;
 415         }
 416         return &descriptor->base;
 417 error:
 418         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 419         return NULL;
 420 }
 421
 422 /* Ownership of uri is transferred. */
 423 static
 424 struct lttng_session_descriptor_snapshot *
 425 _lttng_session_descriptor_snapshot_local_create(const char *name,
 426                 struct lttng_uri *uri)
 427 {
 428         struct lttng_session_descriptor_snapshot *descriptor;
 429
 430         descriptor = _lttng_session_descriptor_snapshot_create(name);
 431         if (!descriptor) {
 432                 goto error;
 433         }
 434         descriptor->base.output_type =
 435                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL;
 436         if (uri) {
 437                 if (uri->dtype != LTTNG_DST_PATH) {
 438                         goto error;
 439                 }
 440                 descriptor->base.output.local = uri;
 441                 uri = NULL;
 442         }
 443         return descriptor;
 444 error:
 445         free(uri);
 446         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 447         return NULL;
 448 }
 449
 450 struct lttng_session_descriptor *
 451 lttng_session_descriptor_snapshot_local_create(const char *name,
 452                 const char *path)
 453 {
 454         struct lttng_uri *path_uri = NULL;
 455         struct lttng_session_descriptor_snapshot *descriptor;
 456
 457         if (path) {
 458                 path_uri = uri_from_path(path);
 459                 if (!path_uri) {
 460                         goto error;
 461                 }
 462         }
 463         descriptor = _lttng_session_descriptor_snapshot_local_create(name,
 464                         path_uri);
 465         return descriptor ? &descriptor->base : NULL;
 466 error:
 467         return NULL;
 468 }
 469
 470 static
 471 struct lttng_session_descriptor_live *
 472 _lttng_session_descriptor_live_create(const char *name,
 473                 unsigned long long live_timer_interval_us)
 474 {
 475         struct lttng_session_descriptor_live *descriptor = NULL;
 476
 477         if (live_timer_interval_us == 0) {
 478                 goto error;
 479         }
 480         descriptor = (lttng_session_descriptor_live *) zmalloc(sizeof(*descriptor));
 481         if (!descriptor) {
 482                 goto error;
 483         }
 484
 485         descriptor->base.type = LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE;
 486         descriptor->base.output_type =
 487                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE;
 488         descriptor->live_timer_us = live_timer_interval_us;
 489         if (lttng_session_descriptor_set_session_name(&descriptor->base,
 490                         name)) {
 491                 goto error;
 492         }
 493
 494         return descriptor;
 495 error:
 496         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 497         return NULL;
 498 }
 499
 500 /* Ownership of control and data is transferred. */
 501 static
 502 struct lttng_session_descriptor_live *
 503 _lttng_session_descriptor_live_network_create(
 504                 const char *name,
 505                 struct lttng_uri *control, struct lttng_uri *data,
 506                 unsigned long long live_timer_interval_us)
 507 {
 508         int ret;
 509         struct lttng_session_descriptor_live *descriptor;
 510
 511         descriptor = _lttng_session_descriptor_live_create(name,
 512                         live_timer_interval_us);
 513         if (!descriptor) {
 514                 goto error;
 515         }
 516
 517         descriptor->base.output_type =
 518                         LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK;
 519
 520         /* Ownerwhip of control and data is transferred. */
 521         ret = network_location_set_from_lttng_uris(
 522                         &descriptor->base.output.network,
 523                         control, data);
 524         control = NULL;
 525         data = NULL;
 526         if (ret) {
 527                 goto error;
 528         }
 529         return descriptor;
 530 error:
 531         free(control);
 532         free(data);
 533         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 534         return NULL;
 535 }
 536
 537 struct lttng_session_descriptor *
 538 lttng_session_descriptor_live_create(
 539                 const char *name,
 540                 unsigned long long live_timer_us)
 541 {
 542         struct lttng_session_descriptor_live *descriptor;
 543
 544         descriptor = _lttng_session_descriptor_live_create(name, live_timer_us);
 545
 546         return descriptor ? &descriptor->base : NULL;
 547 }
 548
 549 struct lttng_session_descriptor *
 550 lttng_session_descriptor_live_network_create(
 551                 const char *name,
 552                 const char *control_url, const char *data_url,
 553                 unsigned long long live_timer_us)
 554 {
 555         int ret;
 556         struct lttng_session_descriptor_live *descriptor;
 557
 558         descriptor = _lttng_session_descriptor_live_network_create(name,
 559                         NULL, NULL, live_timer_us);
 560         if (!descriptor) {
 561                 goto error;
 562         }
 563
 564         ret = network_location_set_from_uri_strings(
 565                         &descriptor->base.output.network,
 566                         control_url, data_url);
 567         if (ret) {
 568                 goto error;
 569         }
 570         return &descriptor->base;
 571 error:
 572         lttng_session_descriptor_destroy(descriptor ? &descriptor->base : NULL);
 573         return NULL;
 574 }
 575
 576 void lttng_session_descriptor_destroy(
 577                 struct lttng_session_descriptor *descriptor)
 578 {
 579         if (!descriptor) {
 580                 return;
 581         }
 582
 583         switch (descriptor->output_type) {
 584         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 585                 break;
 586         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 587                 free(descriptor->output.local);
 588                 break;
 589         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 590                 network_location_fini(&descriptor->output.network);
 591                 break;
 592         default:
 593                 abort();
 594         }
 595
 596         free(descriptor->name);
 597         free(descriptor);
 598 }
 599
 600 ssize_t lttng_session_descriptor_create_from_buffer(
 601                 const struct lttng_buffer_view *payload,
 602                 struct lttng_session_descriptor **descriptor)
 603 {
 604         int i;
 605         ssize_t offset = 0, ret;
 606         struct lttng_buffer_view current_view;
 607         const char *name = NULL;
 608         const struct lttng_session_descriptor_comm *base_header;
 609         size_t max_expected_uri_count;
 610         uint64_t live_timer_us = 0;
 611         struct lttng_uri *uris[2] = {};
 612         enum lttng_session_descriptor_type type;
 613         enum lttng_session_descriptor_output_type output_type;
 614
 615         current_view = lttng_buffer_view_from_view(payload, offset,
 616                         sizeof(*base_header));
 617         if (!lttng_buffer_view_is_valid(&current_view)) {
 618                 ret = -1;
 619                 goto end;
 620         }
 621
 622         base_header = (typeof(base_header)) current_view.data;
 623         switch (base_header->type) {
 624         case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR:
 625         case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
 626                 break;
 627         case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
 628         {
 629                 const struct lttng_session_descriptor_live_comm *live_header;
 630
 631                 current_view = lttng_buffer_view_from_view(payload, offset,
 632                                 sizeof(*live_header));
 633                 if (!lttng_buffer_view_is_valid(&current_view)) {
 634                         ret = -1;
 635                         goto end;
 636                 }
 637
 638                 live_header = (typeof(live_header)) current_view.data;
 639                 live_timer_us = live_header->live_timer_us;
 640                 break;
 641         }
 642         default:
 643                 ret = -1;
 644                 goto end;
 645         }
 646         /* type has been validated. */
 647         type = (lttng_session_descriptor_type) base_header->type;
 648
 649         switch (base_header->output_type) {
 650         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 651                 max_expected_uri_count = 0;
 652                 break;
 653         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 654                 max_expected_uri_count = 1;
 655                 break;
 656         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 657                 max_expected_uri_count = 2;
 658                 break;
 659         default:
 660                 ret = -1;
 661                 goto end;
 662         }
 663         /* output_type has been validated. */
 664         output_type = (lttng_session_descriptor_output_type) base_header->output_type;
 665
 666         /* Skip after header. */
 667         offset += current_view.size;
 668         if (!base_header->name_len) {
 669                 goto skip_name;
 670         }
 671
 672         /* Map the name. */
 673         current_view = lttng_buffer_view_from_view(payload, offset,
 674                         base_header->name_len);
 675         if (!lttng_buffer_view_is_valid(&current_view)) {
 676                 ret = -1;
 677                 goto end;
 678         }
 679
 680         name = current_view.data;
 681         if (base_header->name_len == 1 ||
 682                         name[base_header->name_len - 1] ||
 683                         strlen(name) != base_header->name_len - 1) {
 684                 /*
 685                  * Check that the name is not NULL, is NULL-terminated, and
 686                  * does not contain a NULL before the last byte.
 687                  */
 688                 ret = -1;
 689                 goto end;
 690         }
 691
 692         /* Skip after the name. */
 693         offset += base_header->name_len;
 694 skip_name:
 695         if (base_header->uri_count > max_expected_uri_count) {
 696                 ret = -1;
 697                 goto end;
 698         }
 699
 700         for (i = 0; i < base_header->uri_count; i++) {
 701                 struct lttng_uri *uri;
 702
 703                 /* Map a URI. */
 704                 current_view = lttng_buffer_view_from_view(payload,
 705                                 offset, sizeof(*uri));
 706                 if (!lttng_buffer_view_is_valid(&current_view)) {
 707                         ret = -1;
 708                         goto end;
 709                 }
 710
 711                 uri = (typeof(uri)) current_view.data;
 712                 uris[i] = (lttng_uri *) zmalloc(sizeof(*uri));
 713                 if (!uris[i]) {
 714                         ret = -1;
 715                         goto end;
 716                 }
 717                 memcpy(uris[i], uri, sizeof(*uri));
 718                 offset += sizeof(*uri);
 719         }
 720
 721         switch (type) {
 722         case LTTNG_SESSION_DESCRIPTOR_TYPE_REGULAR:
 723                 switch (output_type) {
 724                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 725                         *descriptor = lttng_session_descriptor_create(name);
 726                         break;
 727                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 728                         *descriptor = _lttng_session_descriptor_local_create(
 729                                         name, uris[0]);
 730                         break;
 731                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 732                         *descriptor = _lttng_session_descriptor_network_create(
 733                                         name, uris[0], uris[1]);
 734                         break;
 735                 default:
 736                         /* Already checked. */
 737                         abort();
 738                 }
 739                 break;
 740         case LTTNG_SESSION_DESCRIPTOR_TYPE_SNAPSHOT:
 741         {
 742                 struct lttng_session_descriptor_snapshot *snapshot;
 743                 switch (output_type) {
 744                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 745                         snapshot = _lttng_session_descriptor_snapshot_create(
 746                                         name);
 747                         break;
 748                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 749                         snapshot = _lttng_session_descriptor_snapshot_local_create(
 750                                         name, uris[0]);
 751                         break;
 752                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 753                         snapshot = _lttng_session_descriptor_snapshot_network_create(
 754                                         name, uris[0], uris[1]);
 755                         break;
 756                 default:
 757                         /* Already checked. */
 758                         abort();
 759                 }
 760                 *descriptor = snapshot ? &snapshot->base : NULL;
 761                 break;
 762         }
 763         case LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE:
 764         {
 765                 struct lttng_session_descriptor_live *live;
 766
 767                 switch (output_type) {
 768                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 769                         live = _lttng_session_descriptor_live_create(
 770                                         name, live_timer_us);
 771                         break;
 772                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 773                         live = _lttng_session_descriptor_live_network_create(
 774                                         name, uris[0], uris[1],
 775                                         live_timer_us);
 776                         break;
 777                 case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 778                         ret = -1;
 779                         goto end;
 780                 default:
 781                         /* Already checked. */
 782                         abort();
 783                 }
 784                 *descriptor = live ? &live->base : NULL;
 785                 break;
 786         }
 787         default:
 788                 /* Already checked. */
 789                 abort();
 790         }
 791         memset(uris, 0, sizeof(uris));
 792         if (!*descriptor) {
 793                 ret = -1;
 794                 goto end;
 795         }
 796
 797         ret = offset;
 798 end:
 799         free(uris[0]);
 800         free(uris[1]);
 801         return ret;
 802 }
 803
 804 int lttng_session_descriptor_serialize(
 805                 const struct lttng_session_descriptor *descriptor,
 806                 struct lttng_dynamic_buffer *buffer)
 807 {
 808         int ret, i;
 809         /* There are, at most, two URIs to serialize. */
 810         struct lttng_uri *uris[2] = {};
 811         size_t uri_count = 0;
 812         /* The live header is a superset of all headers. */
 813         struct lttng_session_descriptor_live_comm header = {
 814                 .base = {
 815                         .type = (uint8_t) descriptor->type,
 816                         .output_type = (uint8_t) descriptor->output_type,
 817                         .name_len = (uint32_t) (descriptor->name ?
 818                                 strlen(descriptor->name) + 1 : 0),
 819                 }
 820         };
 821         const void *header_ptr = NULL;
 822         size_t header_size;
 823
 824         switch (descriptor->output_type) {
 825         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 826                 break;
 827         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 828                 uris[0] = descriptor->output.local;
 829                 break;
 830         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 831                 uris[0] = descriptor->output.network.control;
 832                 uris[1] = descriptor->output.network.data;
 833                 break;
 834         default:
 835                 ret = -1;
 836                 goto end;
 837         }
 838         uri_count += !!uris[0];
 839         uri_count += !!uris[1];
 840
 841         header.base.uri_count = uri_count;
 842         if (descriptor->type == LTTNG_SESSION_DESCRIPTOR_TYPE_LIVE) {
 843                 const struct lttng_session_descriptor_live *live =
 844                                 container_of(descriptor, typeof(*live),
 845                                 base);
 846
 847                 header.live_timer_us = live->live_timer_us;
 848                 header_ptr = &header;
 849                 header_size = sizeof(header);
 850         } else {
 851                 header_ptr = &header.base;
 852                 header_size = sizeof(header.base);
 853         }
 854
 855         ret = lttng_dynamic_buffer_append(buffer, header_ptr, header_size);
 856         if (ret) {
 857                 goto end;
 858         }
 859         if (header.base.name_len) {
 860                 ret = lttng_dynamic_buffer_append(buffer, descriptor->name,
 861                                 header.base.name_len);
 862                 if (ret) {
 863                         goto end;
 864                 }
 865         }
 866
 867         for (i = 0; i < uri_count; i++) {
 868                 ret = lttng_dynamic_buffer_append(buffer, uris[i],
 869                                 sizeof(struct lttng_uri));
 870                 if (ret) {
 871                         goto end;
 872                 }
 873         }
 874 end:
 875         return ret;
 876 }
 877
 878 enum lttng_session_descriptor_type
 879 lttng_session_descriptor_get_type(
 880                 const struct lttng_session_descriptor *descriptor)
 881 {
 882         return descriptor->type;
 883 }
 884
 885 enum lttng_session_descriptor_output_type
 886 lttng_session_descriptor_get_output_type(
 887                 const struct lttng_session_descriptor *descriptor)
 888 {
 889         return descriptor->output_type;
 890 }
 891
 892 void lttng_session_descriptor_get_local_output_uri(
 893                 const struct lttng_session_descriptor *descriptor,
 894                 struct lttng_uri *local_uri)
 895 {
 896         memcpy(local_uri, descriptor->output.local, sizeof(*local_uri));
 897 }
 898
 899 void lttng_session_descriptor_get_network_output_uris(
 900                 const struct lttng_session_descriptor *descriptor,
 901                 struct lttng_uri *control,
 902                 struct lttng_uri *data)
 903 {
 904         memcpy(control, descriptor->output.network.control, sizeof(*control));
 905         memcpy(data, descriptor->output.network.data, sizeof(*data));
 906 }
 907
 908 unsigned long long
 909 lttng_session_descriptor_live_get_timer_interval(
 910                 const struct lttng_session_descriptor *descriptor)
 911 {
 912         struct lttng_session_descriptor_live *live;
 913
 914         live = container_of(descriptor, typeof(*live), base);
 915         return live->live_timer_us;
 916 }
 917
 918 enum lttng_session_descriptor_status
 919 lttng_session_descriptor_get_session_name(
 920                 const struct lttng_session_descriptor *descriptor,
 921                 const char **session_name)
 922 {
 923         enum lttng_session_descriptor_status status;
 924
 925         if (!descriptor || !session_name) {
 926                 status = LTTNG_SESSION_DESCRIPTOR_STATUS_INVALID;
 927                 goto end;
 928         }
 929
 930         *session_name = descriptor->name;
 931         status = descriptor->name ?
 932                         LTTNG_SESSION_DESCRIPTOR_STATUS_OK :
 933                         LTTNG_SESSION_DESCRIPTOR_STATUS_UNSET;
 934 end:
 935         return status;
 936 }
 937
 938 int lttng_session_descriptor_set_session_name(
 939                 struct lttng_session_descriptor *descriptor,
 940                 const char *name)
 941 {
 942         int ret = 0;
 943         char *new_name;
 944
 945         if (!name) {
 946                 goto end;
 947         }
 948         if (strlen(name) >= LTTNG_NAME_MAX) {
 949                 ret = -1;
 950                 goto end;
 951         }
 952         new_name = strdup(name);
 953         if (!new_name) {
 954                 ret = -1;
 955                 goto end;
 956         }
 957         free(descriptor->name);
 958         descriptor->name = new_name;
 959 end:
 960         return ret;
 961 }
 962
 963 bool lttng_session_descriptor_is_output_destination_initialized(
 964                 const struct lttng_session_descriptor *descriptor)
 965 {
 966         switch (descriptor->output_type) {
 967         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 968                 return true;
 969         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 970                 return descriptor->output.local;
 971         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 972                 return descriptor->output.network.control;
 973         default:
 974                 abort();
 975         }
 976 }
 977
 978 bool lttng_session_descriptor_has_output_directory(
 979                 const struct lttng_session_descriptor *descriptor)
 980 {
 981         switch (descriptor->output_type) {
 982         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
 983                 break;
 984         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
 985                 if (descriptor->output.local) {
 986                         return *descriptor->output.local->dst.path;
 987                 }
 988                 break;
 989         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
 990                 if (descriptor->output.network.control) {
 991                         return *descriptor->output.network.control->subdir;
 992                 }
 993                 break;
 994         default:
 995                 abort();
 996         }
 997         return false;
 998 }
 999
1000 enum lttng_error_code lttng_session_descriptor_set_default_output(
1001                 struct lttng_session_descriptor *descriptor,
1002                 time_t *session_creation_time,
1003                 const char *absolute_home_path)
1004 {
1005         enum lttng_error_code ret_code = LTTNG_OK;
1006         struct lttng_uri *uris = NULL;
1007
1008         switch (descriptor->output_type) {
1009         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
1010                 goto end;
1011         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
1012         {
1013                 int ret;
1014                 ssize_t uri_ret;
1015                 char local_uri[LTTNG_PATH_MAX];
1016                 char creation_datetime_suffix[17] = {};
1017
1018                 if (session_creation_time) {
1019                         size_t strftime_ret;
1020                         struct tm *timeinfo;
1021
1022                         timeinfo = localtime(session_creation_time);
1023                         if (!timeinfo) {
1024                                 ret_code = LTTNG_ERR_FATAL;
1025                                 goto end;
1026                         }
1027                         strftime_ret = strftime(creation_datetime_suffix,
1028                                         sizeof(creation_datetime_suffix),
1029                                         "-%Y%m%d-%H%M%S", timeinfo);
1030                         if (strftime_ret == 0) {
1031                                 ERR("Failed to format session creation timestamp while setting default local output destination");
1032                                 ret_code = LTTNG_ERR_FATAL;
1033                                 goto end;
1034                         }
1035                 }
1036                 LTTNG_ASSERT(descriptor->name);
1037                 ret = snprintf(local_uri, sizeof(local_uri),
1038                                 "file://%s/%s/%s%s",
1039                                 absolute_home_path,
1040                                 DEFAULT_TRACE_DIR_NAME, descriptor->name,
1041                                 creation_datetime_suffix);
1042                 if (ret >= sizeof(local_uri)) {
1043                         ERR("Truncation occurred while setting default local output destination");
1044                         ret_code = LTTNG_ERR_SET_URL;
1045                         goto end;
1046                 } else if (ret < 0) {
1047                         PERROR("Failed to format default local output URI");
1048                         ret_code = LTTNG_ERR_SET_URL;
1049                         goto end;
1050                 }
1051
1052                 uri_ret = uri_parse(local_uri, &uris);
1053                 if (uri_ret != 1) {
1054                         ret_code = LTTNG_ERR_SET_URL;
1055                         goto end;
1056                 }
1057                 free(descriptor->output.local);
1058                 descriptor->output.local = &uris[0];
1059                 uris = NULL;
1060                 break;
1061         }
1062         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
1063         {
1064                 int ret;
1065                 ssize_t uri_ret;
1066                 struct lttng_uri *control = NULL, *data = NULL;
1067
1068                 uri_ret = uri_parse_str_urls("net://127.0.0.1", NULL, &uris);
1069                 if (uri_ret != 2) {
1070                         ret_code = LTTNG_ERR_SET_URL;
1071                         goto end;
1072                 }
1073
1074                 control = uri_copy(&uris[0]);
1075                 data = uri_copy(&uris[1]);
1076                 if (!control || !data) {
1077                         free(control);
1078                         free(data);
1079                         ret_code = LTTNG_ERR_SET_URL;
1080                         goto end;
1081                 }
1082
1083                 /* Ownership of uris is transferred. */
1084                 ret = network_location_set_from_lttng_uris(
1085                                 &descriptor->output.network,
1086                                 control, data);
1087                 if (ret) {
1088                         abort();
1089                         ret_code = LTTNG_ERR_SET_URL;
1090                         goto end;
1091                 }
1092                 break;
1093         }
1094         default:
1095                 abort();
1096         }
1097 end:
1098         free(uris);
1099         return ret_code;
1100 }
1101
1102 /*
1103  * Note that only properties that can be populated by the session daemon
1104  * (output destination and name) are assigned.
1105  */
1106 int lttng_session_descriptor_assign(
1107                 struct lttng_session_descriptor *dst,
1108                 const struct lttng_session_descriptor *src)
1109 {
1110         int ret = 0;
1111
1112         if (dst->type != src->type) {
1113                 ret = -1;
1114                 goto end;
1115         }
1116         if (dst->output_type != src->output_type) {
1117                 ret = -1;
1118                 goto end;
1119         }
1120         ret = lttng_session_descriptor_set_session_name(dst, src->name);
1121         if (ret) {
1122                 goto end;
1123         }
1124         switch (dst->output_type) {
1125         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_LOCAL:
1126                 free(dst->output.local);
1127                 dst->output.local = uri_copy(src->output.local);
1128                 if (!dst->output.local) {
1129                         ret = -1;
1130                         goto end;
1131                 }
1132                 break;
1133         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NETWORK:
1134         {
1135                 struct lttng_uri *control_copy = NULL, *data_copy = NULL;
1136
1137                 control_copy = uri_copy(dst->output.network.control);
1138                 if (!control_copy && dst->output.network.control) {
1139                         ret = -1;
1140                         goto end;
1141                 }
1142                 data_copy = uri_copy(dst->output.network.data);
1143                 if (!data_copy && dst->output.network.data) {
1144                         free(control_copy);
1145                         ret = -1;
1146                         goto end;
1147                 }
1148                 ret = network_location_set_from_lttng_uris(&dst->output.network,
1149                                 control_copy, data_copy);
1150                 break;
1151         }
1152         case LTTNG_SESSION_DESCRIPTOR_OUTPUT_TYPE_NONE:
1153                 goto end;
1154         }
1155 end:
1156         return ret;
1157 }