Fix: relayd: rotation failure for multi-domain session
[lttng-tools.git] / src / common / session-descriptor.cpp
1 /*
2 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0-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 }
This page took 0.053113 seconds and 4 git commands to generate.