src/lib/lttng-ctl/load.c

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