Implement support for lttng-modules syscall filtering
[lttng-tools.git] / src / common / uri.c
CommitLineData
3a5713da
DG
1/*
2 * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program 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 General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18#define _GNU_SOURCE
13083fa6 19#include <assert.h>
3a5713da
DG
20#include <arpa/inet.h>
21#include <netdb.h>
22#include <stdlib.h>
23#include <string.h>
24#include <sys/socket.h>
25
26#include <common/common.h>
27#include <common/defaults.h>
a4b92340 28#include <common/utils.h>
3a5713da
DG
29
30#include "uri.h"
31
32enum uri_proto_code {
33 P_NET, P_NET6, P_FILE, P_TCP, P_TCP6,
34};
35
36struct uri_proto {
a4b92340
DG
37 const char *name;
38 const char *leading_string;
3a5713da
DG
39 enum uri_proto_code code;
40 enum lttng_proto_type type;
41 enum lttng_dst_type dtype;
42};
43
44/* Supported protocols */
45static const struct uri_proto proto_uri[] = {
a4b92340
DG
46 { .name = "file", .leading_string = "file://", .code = P_FILE, .type = 0, .dtype = LTTNG_DST_PATH },
47 { .name = "net", .leading_string = "net://", .code = P_NET, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 },
60782118 48 { .name = "net4", .leading_string = "net4://", .code = P_NET, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 },
a4b92340
DG
49 { .name = "net6", .leading_string = "net6://", .code = P_NET6, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV6 },
50 { .name = "tcp", .leading_string = "tcp://", .code = P_TCP, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 },
60782118 51 { .name = "tcp4", .leading_string = "tcp4://", .code = P_TCP, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 },
a4b92340
DG
52 { .name = "tcp6", .leading_string = "tcp6://", .code = P_TCP6, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV6 },
53 /* Invalid proto marking the end of the array. */
54 { NULL, NULL, 0, 0, 0 }
3a5713da
DG
55};
56
a4b92340
DG
57/*
58 * Return pointer to the character in s matching one of the characters in
59 * accept. If nothing is found, return pointer to the end of string (eos).
60 */
32dd26fb 61static const inline char *strpbrk_or_eos(const char *s, const char *accept)
a4b92340
DG
62{
63 char *p = strpbrk(s, accept);
64 if (p == NULL) {
65 p = strchr(s, '\0');
66 }
67
68 return p;
69}
70
71
3a5713da
DG
72/*
73 * Validate if proto is a supported protocol from proto_uri array.
74 */
a4b92340 75static const struct uri_proto *get_uri_proto(const char *uri_str)
3a5713da 76{
a4b92340 77 const struct uri_proto *supported = NULL;
3a5713da
DG
78
79 /* Safety net */
a4b92340 80 if (uri_str == NULL) {
3a5713da
DG
81 goto end;
82 }
83
84 for (supported = &proto_uri[0];
a4b92340
DG
85 supported->leading_string != NULL; ++supported) {
86 if (strncasecmp(uri_str, supported->leading_string,
87 strlen(supported->leading_string)) == 0) {
3a5713da
DG
88 goto end;
89 }
90 }
91
92 /* Proto not found */
93 return NULL;
94
95end:
96 return supported;
97}
98
00e2e675
DG
99/*
100 * Set network address from string into dst. Supports both IP string and
101 * hostname.
102 */
103static int set_ip_address(const char *addr, int af, char *dst, size_t size)
104{
105 int ret;
106 unsigned char buf[sizeof(struct in6_addr)];
107 struct hostent *record;
108
13083fa6
DG
109 assert(addr);
110 assert(dst);
111
112 memset(dst, 0, size);
113
00e2e675
DG
114 /* Network protocol */
115 ret = inet_pton(af, addr, buf);
116 if (ret < 1) {
117 /* We consider the dst to be an hostname or an invalid IP char */
118 record = gethostbyname2(addr, af);
119 if (record == NULL) {
120 /* At this point, the IP or the hostname is bad */
b3e12287 121 ERR("URI parse bad hostname %s for af %d", addr, af);
00e2e675
DG
122 goto error;
123 }
124
125 /* Translate IP to string */
126 (void) inet_ntop(af, record->h_addr_list[0], dst, size);
127 } else {
13083fa6
DG
128 if (size > 0) {
129 strncpy(dst, addr, size);
130 dst[size - 1] = '\0';
131 }
00e2e675
DG
132 }
133
a4b92340
DG
134 DBG2("IP address resolved to %s", dst);
135
00e2e675
DG
136 return 0;
137
138error:
139 return -1;
140}
141
bc894455
DG
142/*
143 * Set default URI attribute which is basically the given stream type and the
144 * default port if none is set in the URI.
145 */
146static void set_default_uri_attr(struct lttng_uri *uri,
147 enum lttng_stream_type stype)
148{
149 uri->stype = stype;
150 if (uri->dtype != LTTNG_DST_PATH && uri->port == 0) {
151 uri->port = (stype == LTTNG_STREAM_CONTROL) ?
152 DEFAULT_NETWORK_CONTROL_PORT : DEFAULT_NETWORK_DATA_PORT;
153 }
154}
155
156/*
157 * Compare two URL destination.
158 *
159 * Return 0 is equal else is not equal.
160 */
161static int compare_destination(struct lttng_uri *ctrl, struct lttng_uri *data)
162{
163 int ret;
164
165 assert(ctrl);
166 assert(data);
167
168 switch (ctrl->dtype) {
169 case LTTNG_DST_IPV4:
170 ret = strncmp(ctrl->dst.ipv4, data->dst.ipv4, sizeof(ctrl->dst.ipv4));
171 break;
172 case LTTNG_DST_IPV6:
173 ret = strncmp(ctrl->dst.ipv6, data->dst.ipv6, sizeof(ctrl->dst.ipv6));
174 break;
175 default:
176 ret = -1;
177 break;
178 }
179
180 return ret;
181}
182
ad20f474
DG
183/*
184 * Build a string URL from a lttng_uri object.
185 */
90e535ef 186LTTNG_HIDDEN
ad20f474
DG
187int uri_to_str_url(struct lttng_uri *uri, char *dst, size_t size)
188{
189 int ipver, ret;
190 const char *addr;
07b86b52 191 char proto[5], port[7];
ad20f474
DG
192
193 assert(uri);
194 assert(dst);
195
196 if (uri->dtype == LTTNG_DST_PATH) {
197 ipver = 0;
198 addr = uri->dst.path;
28fcbaeb
JD
199 (void) snprintf(proto, sizeof(proto), "file");
200 (void) snprintf(port, sizeof(port), "%s", "");
ad20f474
DG
201 } else {
202 ipver = (uri->dtype == LTTNG_DST_IPV4) ? 4 : 6;
203 addr = (ipver == 4) ? uri->dst.ipv4 : uri->dst.ipv6;
b664f89a 204 (void) snprintf(proto, sizeof(proto), "tcp%d", ipver);
28fcbaeb 205 (void) snprintf(port, sizeof(port), ":%d", uri->port);
ad20f474
DG
206 }
207
208 ret = snprintf(dst, size, "%s://%s%s%s%s/%s", proto,
209 (ipver == 6) ? "[" : "", addr, (ipver == 6) ? "]" : "",
210 port, uri->subdir);
211 if (ret < 0) {
212 PERROR("snprintf uri to url");
213 }
214
215 return ret;
216}
217
3a5713da
DG
218/*
219 * Compare two URIs.
220 *
221 * Return 0 if equal else 1.
222 */
90e535ef 223LTTNG_HIDDEN
3a5713da
DG
224int uri_compare(struct lttng_uri *uri1, struct lttng_uri *uri2)
225{
226 return memcmp(uri1, uri2, sizeof(struct lttng_uri));
227}
228
229/*
230 * Free URI memory.
231 */
90e535ef 232LTTNG_HIDDEN
3a5713da
DG
233void uri_free(struct lttng_uri *uri)
234{
0e428499 235 free(uri);
3a5713da
DG
236}
237
238/*
239 * Return an allocated URI.
240 */
90e535ef 241LTTNG_HIDDEN
3a5713da
DG
242struct lttng_uri *uri_create(void)
243{
244 struct lttng_uri *uri;
245
246 uri = zmalloc(sizeof(struct lttng_uri));
247 if (uri == NULL) {
248 PERROR("zmalloc uri");
249 }
250
251 return uri;
252}
253
00e2e675
DG
254/*
255 * Parses a string URI to a lttng_uri. This function can potentially return
256 * more than one URI in uris so the size of the array is returned and uris is
257 * allocated and populated. Caller must free(3) the array.
258 *
259 * This function can not detect the stream type of the URI so the caller has to
260 * make sure the correct type (stype) is set on the return URI(s). The default
261 * port must also be set by the caller if the returned URI has its port set to
262 * zero.
a4b92340
DG
263 *
264 * NOTE: A good part of the following code was inspired from the "wget" source
265 * tree from the src/url.c file and url_parse() function. Also, the
266 * strpbrk_or_eos() function found above is also inspired by the same code.
267 * This code was originally licensed GPLv2 so we acknolwedge the Free Software
268 * Foundation here for the work and to make sure we are compliant with it.
00e2e675 269 */
90e535ef 270LTTNG_HIDDEN
3a5713da
DG
271ssize_t uri_parse(const char *str_uri, struct lttng_uri **uris)
272{
a4b92340 273 int ret, i = 0;
3a5713da
DG
274 /* Size of the uris array. Default is 1 */
275 ssize_t size = 1;
a4b92340 276 char subdir[PATH_MAX];
b35d8a57
DG
277 unsigned int ctrl_port = 0;
278 unsigned int data_port = 0;
a4b92340
DG
279 struct lttng_uri *tmp_uris;
280 char *addr_f = NULL;
3a5713da 281 const struct uri_proto *proto;
a4b92340
DG
282 const char *purl, *addr_e, *addr_b, *subdir_b = NULL;
283 const char *seps = ":/\0";
3a5713da
DG
284
285 /*
286 * The first part is the protocol portion of a maximum of 5 bytes for now.
b35d8a57
DG
287 * The second part is the hostname or IP address. The 255 bytes size is the
288 * limit found in the RFC 1035 for the total length of a domain name
289 * (https://www.ietf.org/rfc/rfc1035.txt). Finally, for the net://
290 * protocol, two ports CAN be specified.
3a5713da
DG
291 */
292
00e2e675 293 DBG3("URI string: %s", str_uri);
3a5713da 294
a4b92340 295 proto = get_uri_proto(str_uri);
3a5713da 296 if (proto == NULL) {
a4b92340 297 ERR("URI parse unknown protocol %s", str_uri);
3a5713da
DG
298 goto error;
299 }
300
a4b92340
DG
301 purl = str_uri;
302
3a5713da 303 if (proto->code == P_NET || proto->code == P_NET6) {
a4b92340 304 /* Special case for net:// which requires two URI objects */
3a5713da
DG
305 size = 2;
306 }
307
a4b92340
DG
308 /* Allocate URI array */
309 tmp_uris = zmalloc(sizeof(struct lttng_uri) * size);
310 if (tmp_uris == NULL) {
311 PERROR("zmalloc uri");
312 goto error;
313 }
314
00e2e675 315 memset(subdir, 0, sizeof(subdir));
a4b92340
DG
316 purl += strlen(proto->leading_string);
317
318 /* Copy known value to the first URI. */
319 tmp_uris[0].dtype = proto->dtype;
320 tmp_uris[0].proto = proto->type;
321
322 if (proto->code == P_FILE) {
323 if (*purl != '/') {
324 ERR("Missing destination full path.");
325 goto free_error;
00e2e675 326 }
a4b92340
DG
327
328 strncpy(tmp_uris[0].dst.path, purl, sizeof(tmp_uris[0].dst.path));
329 tmp_uris[0].dst.path[sizeof(tmp_uris[0].dst.path) - 1] = '\0';
330 DBG3("URI file destination: %s", purl);
331 goto end;
3a5713da
DG
332 }
333
a4b92340
DG
334 /* Assume we are at the beginning of an address or host of some sort. */
335 addr_b = purl;
3a5713da 336
a4b92340
DG
337 /*
338 * Handle IPv6 address inside square brackets as mention by RFC 2732. IPv6
339 * address that does not start AND end with brackets will be rejected even
340 * if valid.
341 *
342 * proto://[<addr>]...
343 * ^
344 */
345 if (*purl == '[') {
346 /* Address begins after '[' */
347 addr_b = purl + 1;
348 addr_e = strchr(addr_b, ']');
349 if (addr_e == NULL || addr_b == addr_e) {
350 ERR("Broken IPv6 address %s", addr_b);
351 goto free_error;
352 }
353
354 /* Moving parsed URL pointer after the final bracket ']' */
355 purl = addr_e + 1;
356
357 /*
358 * The closing bracket must be followed by a seperator or NULL char.
359 */
360 if (strchr(seps, *purl) == NULL) {
361 ERR("Unknown symbol after IPv6 address: %s", purl);
362 goto free_error;
363 }
364 } else {
365 purl = strpbrk_or_eos(purl, seps);
366 addr_e = purl;
367 }
368
369 /* Check if we at least have a char for the addr or hostname. */
370 if (addr_b == addr_e) {
371 ERR("No address or hostname detected.");
372 goto free_error;
373 }
374
375 addr_f = utils_strdupdelim(addr_b, addr_e);
376 if (addr_f == NULL) {
377 goto free_error;
3a5713da
DG
378 }
379
a4b92340
DG
380 /*
381 * Detect PORT after address. The net/net6 protocol allows up to two port
382 * so we can define the control and data port.
383 */
384 while (*purl == ':') {
a4b92340
DG
385 const char *port_b, *port_e;
386 char *port_f;
387
388 /* Update pass counter */
389 i++;
390
391 /*
392 * Maximum of two ports is possible if P_NET/NET6. Bigger than that,
393 * two much stuff.
394 */
395 if ((i == 2 && (proto->code != P_NET && proto->code != P_NET6))
396 || i > 2) {
397 break;
398 }
399
400 /*
401 * Move parsed URL to port value.
402 * proto://addr_host:PORT1:PORT2/foo/bar
403 * ^
404 */
405 ++purl;
406 port_b = purl;
407 purl = strpbrk_or_eos(purl, seps);
408 port_e = purl;
409
410 if (port_b != port_e) {
c617c0c6
MD
411 int port;
412
a4b92340
DG
413 port_f = utils_strdupdelim(port_b, port_e);
414 if (port_f == NULL) {
415 goto free_error;
416 }
417
418 port = atoi(port_f);
419 if (port > 0xffff || port <= 0x0) {
420 ERR("Invalid port number %d", port);
421 free(port_f);
422 goto free_error;
423 }
424 free(port_f);
425
426 if (i == 1) {
427 ctrl_port = port;
428 } else {
429 data_port = port;
430 }
431 }
432 };
433
434 /* Check for a valid subdir or trailing garbage */
435 if (*purl == '/') {
436 /*
437 * Move to subdir value.
438 * proto://addr_host:PORT1:PORT2/foo/bar
439 * ^
440 */
441 ++purl;
442 subdir_b = purl;
443 } else if (*purl != '\0') {
444 ERR("Trailing characters not recognized: %s", purl);
445 goto free_error;
446 }
447
448 /* We have enough valid information to create URI(s) object */
449
3a5713da 450 /* Copy generic information */
a4b92340 451 tmp_uris[0].port = ctrl_port;
3a5713da 452
a4b92340
DG
453 /* Copy subdirectory if one. */
454 if (subdir_b) {
455 strncpy(tmp_uris[0].subdir, subdir_b, sizeof(tmp_uris[0].subdir));
456 tmp_uris[0].subdir[sizeof(tmp_uris[0].subdir) - 1] = '\0';
457 }
3a5713da
DG
458
459 switch (proto->code) {
3a5713da 460 case P_NET:
a4b92340
DG
461 ret = set_ip_address(addr_f, AF_INET, tmp_uris[0].dst.ipv4,
462 sizeof(tmp_uris[0].dst.ipv4));
3a5713da
DG
463 if (ret < 0) {
464 goto free_error;
465 }
466
a4b92340 467 memcpy(tmp_uris[1].dst.ipv4, tmp_uris[0].dst.ipv4, sizeof(tmp_uris[1].dst.ipv4));
3a5713da 468
a4b92340
DG
469 tmp_uris[1].dtype = proto->dtype;
470 tmp_uris[1].proto = proto->type;
471 tmp_uris[1].port = data_port;
3a5713da
DG
472 break;
473 case P_NET6:
a4b92340
DG
474 ret = set_ip_address(addr_f, AF_INET6, tmp_uris[0].dst.ipv6,
475 sizeof(tmp_uris[0].dst.ipv6));
3a5713da
DG
476 if (ret < 0) {
477 goto free_error;
478 }
479
a4b92340 480 memcpy(tmp_uris[1].dst.ipv6, tmp_uris[0].dst.ipv6, sizeof(tmp_uris[1].dst.ipv6));
3a5713da 481
a4b92340
DG
482 tmp_uris[1].dtype = proto->dtype;
483 tmp_uris[1].proto = proto->type;
484 tmp_uris[1].port = data_port;
3a5713da
DG
485 break;
486 case P_TCP:
a4b92340
DG
487 ret = set_ip_address(addr_f, AF_INET, tmp_uris[0].dst.ipv4,
488 sizeof(tmp_uris[0].dst.ipv4));
3a5713da
DG
489 if (ret < 0) {
490 goto free_error;
491 }
492 break;
493 case P_TCP6:
a4b92340
DG
494 ret = set_ip_address(addr_f, AF_INET6, tmp_uris[0].dst.ipv6,
495 sizeof(tmp_uris[0].dst.ipv6));
3a5713da
DG
496 if (ret < 0) {
497 goto free_error;
498 }
499 break;
500 default:
501 goto free_error;
502 }
503
a4b92340
DG
504end:
505 DBG3("URI dtype: %d, proto: %d, host: %s, subdir: %s, ctrl: %d, data: %d",
506 proto->dtype, proto->type, (addr_f == NULL) ? "" : addr_f,
507 (subdir_b == NULL) ? "" : subdir_b, ctrl_port, data_port);
508
509 free(addr_f);
3a5713da 510
a4b92340 511 *uris = tmp_uris;
3a5713da
DG
512 return size;
513
514free_error:
a4b92340
DG
515 free(addr_f);
516 free(tmp_uris);
3a5713da
DG
517error:
518 return -1;
519}
bc894455
DG
520
521/*
522 * Parse a string URL and creates URI(s) returning the size of the populated
523 * array.
524 */
525LTTNG_HIDDEN
526ssize_t uri_parse_str_urls(const char *ctrl_url, const char *data_url,
527 struct lttng_uri **uris)
528{
529 unsigned int equal = 1, idx = 0;
530 /* Add the "file://" size to the URL maximum size */
531 char url[PATH_MAX + 7];
532 ssize_t size_ctrl = 0, size_data = 0, size;
533 struct lttng_uri *ctrl_uris = NULL, *data_uris = NULL;
534 struct lttng_uri *tmp_uris = NULL;
535
536 /* No URL(s) is allowed. This means that the consumer will be disabled. */
537 if (ctrl_url == NULL && data_url == NULL) {
538 return 0;
539 }
540
541 /* Check if URLs are equal and if so, only use the control URL */
542 if ((ctrl_url && *ctrl_url != '\0') && (data_url && *data_url != '\0')) {
543 equal = !strcmp(ctrl_url, data_url);
544 }
545
546 /*
547 * Since we allow the str_url to be a full local filesystem path, we are
548 * going to create a valid file:// URL if it's the case.
549 *
550 * Check if first character is a '/' or else reject the URL.
551 */
552 if (ctrl_url && ctrl_url[0] == '/') {
553 int ret;
554
555 ret = snprintf(url, sizeof(url), "file://%s", ctrl_url);
556 if (ret < 0) {
557 PERROR("snprintf file url");
558 goto parse_error;
559 }
560 ctrl_url = url;
561 }
562
563 /* Parse the control URL if there is one */
564 if (ctrl_url && *ctrl_url != '\0') {
565 size_ctrl = uri_parse(ctrl_url, &ctrl_uris);
566 if (size_ctrl < 1) {
567 ERR("Unable to parse the URL %s", ctrl_url);
568 goto parse_error;
569 }
570
571 /* At this point, we know there is at least one URI in the array */
572 set_default_uri_attr(&ctrl_uris[0], LTTNG_STREAM_CONTROL);
573
574 if (ctrl_uris[0].dtype == LTTNG_DST_PATH &&
575 (data_url && *data_url != '\0')) {
576 ERR("Can not have a data URL when destination is file://");
577 goto error;
578 }
579
580 /* URL are not equal but the control URL uses a net:// protocol */
581 if (size_ctrl == 2) {
582 if (!equal) {
583 ERR("Control URL uses the net:// protocol and the data URL is "
584 "different. Not allowed.");
585 goto error;
586 } else {
587 set_default_uri_attr(&ctrl_uris[1], LTTNG_STREAM_DATA);
588 /*
589 * The data_url and ctrl_url are equal and the ctrl_url
590 * contains a net:// protocol so we just skip the data part.
591 */
592 data_url = NULL;
593 }
594 }
595 }
596
597 if (data_url && *data_url != '\0') {
598 int ret;
599
600 /* We have to parse the data URL in this case */
601 size_data = uri_parse(data_url, &data_uris);
602 if (size_data < 1) {
603 ERR("Unable to parse the URL %s", data_url);
604 goto error;
605 } else if (size_data == 2) {
606 ERR("Data URL can not be set with the net[4|6]:// protocol");
607 goto error;
608 }
609
610 set_default_uri_attr(&data_uris[0], LTTNG_STREAM_DATA);
611
612 ret = compare_destination(&ctrl_uris[0], &data_uris[0]);
613 if (ret != 0) {
614 ERR("Control and data destination mismatch");
615 goto error;
616 }
617 }
618
619 /* Compute total size */
620 size = size_ctrl + size_data;
621
622 tmp_uris = zmalloc(sizeof(struct lttng_uri) * size);
623 if (tmp_uris == NULL) {
624 PERROR("zmalloc uris");
625 goto error;
626 }
627
628 if (ctrl_uris) {
629 /* It's possible the control URIs array contains more than one URI */
630 memcpy(tmp_uris, ctrl_uris, sizeof(struct lttng_uri) * size_ctrl);
631 ++idx;
632 free(ctrl_uris);
633 }
634
635 if (data_uris) {
636 memcpy(&tmp_uris[idx], data_uris, sizeof(struct lttng_uri));
637 free(data_uris);
638 }
639
640 *uris = tmp_uris;
641
642 return size;
643
644error:
645 free(ctrl_uris);
646 free(data_uris);
647 free(tmp_uris);
648parse_error:
649 return -1;
650}
This page took 0.066114 seconds and 5 git commands to generate.