X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Furi.c;h=58ffcbcd66de518c8fba4ee4c470609af5ec8491;hp=3581e307d33a0dfa5bdcb5932b0e5fb648b30114;hb=1b7c93cbef5f1c0497f65c9b48b3487e1f6c6034;hpb=a4b92340642035d1eafeb1eead0ad01f64d2007d diff --git a/src/common/uri.c b/src/common/uri.c index 3581e307d..58ffcbcd6 100644 --- a/src/common/uri.c +++ b/src/common/uri.c @@ -15,9 +15,10 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE +#include #include -#include +#include #include #include #include @@ -28,6 +29,9 @@ #include "uri.h" +#define LOOPBACK_ADDR_IPV4 "127.0.0.1" +#define LOOPBACK_ADDR_IPV6 "::1" + enum uri_proto_code { P_NET, P_NET6, P_FILE, P_TCP, P_TCP6, }; @@ -44,8 +48,10 @@ struct uri_proto { static const struct uri_proto proto_uri[] = { { .name = "file", .leading_string = "file://", .code = P_FILE, .type = 0, .dtype = LTTNG_DST_PATH }, { .name = "net", .leading_string = "net://", .code = P_NET, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 }, + { .name = "net4", .leading_string = "net4://", .code = P_NET, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 }, { .name = "net6", .leading_string = "net6://", .code = P_NET6, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV6 }, { .name = "tcp", .leading_string = "tcp://", .code = P_TCP, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 }, + { .name = "tcp4", .leading_string = "tcp4://", .code = P_TCP, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV4 }, { .name = "tcp6", .leading_string = "tcp6://", .code = P_TCP6, .type = LTTNG_TCP, .dtype = LTTNG_DST_IPV6 }, /* Invalid proto marking the end of the array. */ { NULL, NULL, 0, 0, 0 } @@ -55,7 +61,7 @@ static const struct uri_proto proto_uri[] = { * Return pointer to the character in s matching one of the characters in * accept. If nothing is found, return pointer to the end of string (eos). */ -const inline char *strpbrk_or_eos(const char *s, const char *accept) +static const inline char *strpbrk_or_eos(const char *s, const char *accept) { char *p = strpbrk(s, accept); if (p == NULL) { @@ -65,7 +71,6 @@ const inline char *strpbrk_or_eos(const char *s, const char *accept) return p; } - /* * Validate if proto is a supported protocol from proto_uri array. */ @@ -103,36 +108,150 @@ static int set_ip_address(const char *addr, int af, char *dst, size_t size) unsigned char buf[sizeof(struct in6_addr)]; struct hostent *record; + assert(addr); + assert(dst); + + memset(dst, 0, size); + /* Network protocol */ ret = inet_pton(af, addr, buf); if (ret < 1) { /* We consider the dst to be an hostname or an invalid IP char */ - record = gethostbyname2(addr, af); - if (record == NULL) { + record = lttng_gethostbyname2(addr, af); + if (record) { + /* Translate IP to string */ + if (!inet_ntop(af, record->h_addr_list[0], dst, size)) { + PERROR("inet_ntop"); + goto error; + } + } else if (!strcmp(addr, "localhost") && + (af == AF_INET || af == AF_INET6)) { + /* + * Some systems may not have "localhost" defined in + * accordance with IETF RFC 6761. According to this RFC, + * applications may recognize "localhost" names as + * special and resolve to the appropriate loopback + * address. + * + * We choose to use the system name resolution API first + * to honor its network configuration. If this fails, we + * resolve to the appropriate loopback address. This is + * done to accomodate systems which may want to start + * tracing before their network configured. + */ + const char *loopback_addr = af == AF_INET ? + LOOPBACK_ADDR_IPV4 : LOOPBACK_ADDR_IPV6; + const size_t loopback_addr_len = af == AF_INET ? + sizeof(LOOPBACK_ADDR_IPV4) : + sizeof(LOOPBACK_ADDR_IPV6); + + DBG2("Could not resolve localhost address, using fallback"); + if (loopback_addr_len > size) { + ERR("Could not resolve localhost address; destination string is too short"); + goto error; + } + strcpy(dst, loopback_addr); + } else { /* At this point, the IP or the hostname is bad */ - ERR("URI parse bad hostname %s for af %d", addr, af); goto error; } - - /* Translate IP to string */ - (void) inet_ntop(af, record->h_addr_list[0], dst, size); } else { - memcpy(dst, addr, size); + if (size > 0) { + strncpy(dst, addr, size); + dst[size - 1] = '\0'; + } } DBG2("IP address resolved to %s", dst); - return 0; error: + ERR("URI parse bad hostname %s for af %d", addr, af); return -1; } +/* + * Set default URI attribute which is basically the given stream type and the + * default port if none is set in the URI. + */ +static void set_default_uri_attr(struct lttng_uri *uri, + enum lttng_stream_type stype) +{ + uri->stype = stype; + if (uri->dtype != LTTNG_DST_PATH && uri->port == 0) { + uri->port = (stype == LTTNG_STREAM_CONTROL) ? + DEFAULT_NETWORK_CONTROL_PORT : DEFAULT_NETWORK_DATA_PORT; + } +} + +/* + * Compare two URL destination. + * + * Return 0 is equal else is not equal. + */ +static int compare_destination(struct lttng_uri *ctrl, struct lttng_uri *data) +{ + int ret; + + assert(ctrl); + assert(data); + + switch (ctrl->dtype) { + case LTTNG_DST_IPV4: + ret = strncmp(ctrl->dst.ipv4, data->dst.ipv4, sizeof(ctrl->dst.ipv4)); + break; + case LTTNG_DST_IPV6: + ret = strncmp(ctrl->dst.ipv6, data->dst.ipv6, sizeof(ctrl->dst.ipv6)); + break; + default: + ret = -1; + break; + } + + return ret; +} + +/* + * Build a string URL from a lttng_uri object. + */ +LTTNG_HIDDEN +int uri_to_str_url(struct lttng_uri *uri, char *dst, size_t size) +{ + int ipver, ret; + const char *addr; + char proto[5], port[7]; + + assert(uri); + assert(dst); + + if (uri->dtype == LTTNG_DST_PATH) { + ipver = 0; + addr = uri->dst.path; + (void) snprintf(proto, sizeof(proto), "file"); + (void) snprintf(port, sizeof(port), "%s", ""); + } else { + ipver = (uri->dtype == LTTNG_DST_IPV4) ? 4 : 6; + addr = (ipver == 4) ? uri->dst.ipv4 : uri->dst.ipv6; + (void) snprintf(proto, sizeof(proto), "tcp%d", ipver); + (void) snprintf(port, sizeof(port), ":%d", uri->port); + } + + ret = snprintf(dst, size, "%s://%s%s%s%s/%s", proto, + (ipver == 6) ? "[" : "", addr, (ipver == 6) ? "]" : "", + port, uri->subdir); + if (ret < 0) { + PERROR("snprintf uri to url"); + } + + return ret; +} + /* * Compare two URIs. * * Return 0 if equal else 1. */ +LTTNG_HIDDEN int uri_compare(struct lttng_uri *uri1, struct lttng_uri *uri2) { return memcmp(uri1, uri2, sizeof(struct lttng_uri)); @@ -141,17 +260,16 @@ int uri_compare(struct lttng_uri *uri1, struct lttng_uri *uri2) /* * Free URI memory. */ +LTTNG_HIDDEN void uri_free(struct lttng_uri *uri) { - /* Safety check */ - if (uri != NULL) { - free(uri); - } + free(uri); } /* * Return an allocated URI. */ +LTTNG_HIDDEN struct lttng_uri *uri_create(void) { struct lttng_uri *uri; @@ -180,6 +298,7 @@ struct lttng_uri *uri_create(void) * This code was originally licensed GPLv2 so we acknolwedge the Free Software * Foundation here for the work and to make sure we are compliant with it. */ +LTTNG_HIDDEN ssize_t uri_parse(const char *str_uri, struct lttng_uri **uris) { int ret, i = 0; @@ -294,7 +413,6 @@ ssize_t uri_parse(const char *str_uri, struct lttng_uri **uris) * so we can define the control and data port. */ while (*purl == ':') { - int port; const char *port_b, *port_e; char *port_f; @@ -321,6 +439,8 @@ ssize_t uri_parse(const char *str_uri, struct lttng_uri **uris) port_e = purl; if (port_b != port_e) { + int port; + port_f = utils_strdupdelim(port_b, port_e); if (port_f == NULL) { goto free_error; @@ -428,3 +548,134 @@ free_error: error: return -1; } + +/* + * Parse a string URL and creates URI(s) returning the size of the populated + * array. + */ +LTTNG_HIDDEN +ssize_t uri_parse_str_urls(const char *ctrl_url, const char *data_url, + struct lttng_uri **uris) +{ + unsigned int equal = 1, idx = 0; + /* Add the "file://" size to the URL maximum size */ + char url[PATH_MAX + 7]; + ssize_t size_ctrl = 0, size_data = 0, size; + struct lttng_uri *ctrl_uris = NULL, *data_uris = NULL; + struct lttng_uri *tmp_uris = NULL; + + /* No URL(s) is allowed. This means that the consumer will be disabled. */ + if (ctrl_url == NULL && data_url == NULL) { + return 0; + } + + /* Check if URLs are equal and if so, only use the control URL */ + if ((ctrl_url && *ctrl_url != '\0') && (data_url && *data_url != '\0')) { + equal = !strcmp(ctrl_url, data_url); + } + + /* + * Since we allow the str_url to be a full local filesystem path, we are + * going to create a valid file:// URL if it's the case. + * + * Check if first character is a '/' or else reject the URL. + */ + if (ctrl_url && ctrl_url[0] == '/') { + int ret; + + ret = snprintf(url, sizeof(url), "file://%s", ctrl_url); + if (ret < 0) { + PERROR("snprintf file url"); + goto parse_error; + } + ctrl_url = url; + } + + /* Parse the control URL if there is one */ + if (ctrl_url && *ctrl_url != '\0') { + size_ctrl = uri_parse(ctrl_url, &ctrl_uris); + if (size_ctrl < 1) { + ERR("Unable to parse the URL %s", ctrl_url); + goto parse_error; + } + + /* At this point, we know there is at least one URI in the array */ + set_default_uri_attr(&ctrl_uris[0], LTTNG_STREAM_CONTROL); + + if (ctrl_uris[0].dtype == LTTNG_DST_PATH && + (data_url && *data_url != '\0')) { + ERR("Can not have a data URL when destination is file://"); + goto error; + } + + /* URL are not equal but the control URL uses a net:// protocol */ + if (size_ctrl == 2) { + if (!equal) { + ERR("Control URL uses the net:// protocol and the data URL is " + "different. Not allowed."); + goto error; + } else { + set_default_uri_attr(&ctrl_uris[1], LTTNG_STREAM_DATA); + /* + * The data_url and ctrl_url are equal and the ctrl_url + * contains a net:// protocol so we just skip the data part. + */ + data_url = NULL; + } + } + } + + if (data_url && *data_url != '\0') { + int ret; + + /* We have to parse the data URL in this case */ + size_data = uri_parse(data_url, &data_uris); + if (size_data < 1) { + ERR("Unable to parse the URL %s", data_url); + goto error; + } else if (size_data == 2) { + ERR("Data URL can not be set with the net[4|6]:// protocol"); + goto error; + } + + set_default_uri_attr(&data_uris[0], LTTNG_STREAM_DATA); + + ret = compare_destination(&ctrl_uris[0], &data_uris[0]); + if (ret != 0) { + ERR("Control and data destination mismatch"); + goto error; + } + } + + /* Compute total size */ + size = size_ctrl + size_data; + + tmp_uris = zmalloc(sizeof(struct lttng_uri) * size); + if (tmp_uris == NULL) { + PERROR("zmalloc uris"); + goto error; + } + + if (ctrl_uris) { + /* It's possible the control URIs array contains more than one URI */ + memcpy(tmp_uris, ctrl_uris, sizeof(struct lttng_uri) * size_ctrl); + ++idx; + free(ctrl_uris); + } + + if (data_uris) { + memcpy(&tmp_uris[idx], data_uris, sizeof(struct lttng_uri)); + free(data_uris); + } + + *uris = tmp_uris; + + return size; + +error: + free(ctrl_uris); + free(data_uris); + free(tmp_uris); +parse_error: + return -1; +}