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