diff options
Diffstat (limited to 'rpc/rpc-transport/socket/src/name.c')
| -rw-r--r-- | rpc/rpc-transport/socket/src/name.c | 768 |
1 files changed, 768 insertions, 0 deletions
diff --git a/rpc/rpc-transport/socket/src/name.c b/rpc/rpc-transport/socket/src/name.c new file mode 100644 index 00000000000..9286bbb236d --- /dev/null +++ b/rpc/rpc-transport/socket/src/name.c @@ -0,0 +1,768 @@ +/* + Copyright (c) 2008-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ + +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <errno.h> +#include <netdb.h> +#include <string.h> + +#ifndef AF_INET_SDP +#define AF_INET_SDP 27 +#endif + +#include "rpc-transport.h" +#include "socket.h" +#include <glusterfs/common-utils.h> + +static void +_assign_port(struct sockaddr *sockaddr, uint16_t port) +{ + switch (sockaddr->sa_family) { + case AF_INET6: + ((struct sockaddr_in6 *)sockaddr)->sin6_port = htons(port); + break; + + case AF_INET_SDP: + case AF_INET: + ((struct sockaddr_in *)sockaddr)->sin_port = htons(port); + break; + } +} + +static int32_t +af_inet_bind_to_port_lt_ceiling(int fd, struct sockaddr *sockaddr, + socklen_t sockaddr_len, uint32_t ceiling) +{ +#if GF_DISABLE_PRIVPORT_TRACKING + _assign_port(sockaddr, 0); + return bind(fd, sockaddr, sockaddr_len); +#else + int32_t ret = -1; + uint16_t port = ceiling - 1; + unsigned char ports[GF_PORT_ARRAY_SIZE] = { + 0, + }; + int i = 0; + +loop: + ret = gf_process_reserved_ports(ports, ceiling); + + while (port) { + if (port == GF_CLIENT_PORT_CEILING) { + ret = -1; + break; + } + + /* ignore the reserved ports */ + if (BIT_VALUE(ports, port)) { + port--; + continue; + } + + _assign_port(sockaddr, port); + + ret = bind(fd, sockaddr, sockaddr_len); + + if (ret == 0) + break; + + if (ret == -1 && errno == EACCES) + break; + + port--; + } + + /* In case if all the secure ports are exhausted, we are no more + * binding to secure ports, hence instead of getting a random + * port, lets define the range to restrict it from getting from + * ports reserved for bricks i.e from range of 49152 - 65535 + * which further may lead to port clash */ + if (!port) { + ceiling = port = GF_CLNT_INSECURE_PORT_CEILING; + for (i = 0; i <= ceiling; i++) + BIT_CLEAR(ports, i); + goto loop; + } + + return ret; +#endif /* GF_DISABLE_PRIVPORT_TRACKING */ +} + +static int32_t +af_unix_client_bind(rpc_transport_t *this, struct sockaddr *sockaddr, + socklen_t sockaddr_len, int sock) +{ + data_t *path_data = NULL; + struct sockaddr_un *addr = NULL; + int32_t ret = 0; + + path_data = dict_get_sizen(this->options, "transport.socket.bind-path"); + if (path_data) { + char *path = data_to_str(path_data); + if (!path || path_data->len > 108) { /* 108 = addr->sun_path length */ + gf_log(this->name, GF_LOG_TRACE, + "bind-path not specified for unix socket, " + "letting connect to assign default value"); + goto err; + } + + addr = (struct sockaddr_un *)sockaddr; + strcpy(addr->sun_path, path); + ret = bind(sock, (struct sockaddr *)addr, sockaddr_len); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "cannot bind to unix-domain socket %d (%s)", sock, + strerror(errno)); + goto err; + } + } else { + gf_log(this->name, GF_LOG_TRACE, + "bind-path not specified for unix socket, " + "letting connect to assign default value"); + } + +err: + return ret; +} + +static int32_t +client_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family) +{ + data_t *address_family_data = NULL; + int32_t ret = -1; + + if (sa_family == NULL) { + gf_log_callingfn("", GF_LOG_WARNING, "sa_family argument is NULL"); + goto out; + } + + address_family_data = dict_get_sizen(this->options, + "transport.address-family"); + if (!address_family_data) { + data_t *remote_host_data = NULL, *connect_path_data = NULL; + remote_host_data = dict_get_sizen(this->options, "remote-host"); + connect_path_data = dict_get_sizen(this->options, + "transport.socket.connect-path"); + + if (!(remote_host_data || connect_path_data) || + (remote_host_data && connect_path_data)) { + gf_log(this->name, GF_LOG_ERROR, + "transport.address-family not specified. " + "Could not guess default value from (remote-host:%s or " + "transport.unix.connect-path:%s) options", + data_to_str(remote_host_data), + data_to_str(connect_path_data)); + *sa_family = AF_UNSPEC; + goto out; + } + + if (remote_host_data) { + gf_log(this->name, GF_LOG_DEBUG, + "address-family not specified, marking it as unspec " + "for getaddrinfo to resolve from (remote-host: %s)", + data_to_str(remote_host_data)); + *sa_family = AF_UNSPEC; + } else { + gf_log(this->name, GF_LOG_DEBUG, + "address-family not specified, guessing it " + "to be unix from (transport.unix.connect-path: %s)", + data_to_str(connect_path_data)); + *sa_family = AF_UNIX; + } + + } else { + const char *address_family = data_to_str(address_family_data); + if (!strcasecmp(address_family, "unix")) { + *sa_family = AF_UNIX; + } else if (!strcasecmp(address_family, "inet")) { + *sa_family = AF_INET; + } else if (!strcasecmp(address_family, "inet6")) { + *sa_family = AF_INET6; + } else if (!strcasecmp(address_family, "inet-sdp")) { + *sa_family = AF_INET_SDP; + } else { + gf_log(this->name, GF_LOG_ERROR, + "unknown address-family (%s) specified", address_family); + *sa_family = AF_UNSPEC; + goto out; + } + } + + ret = 0; + +out: + return ret; +} + +static int32_t +af_inet_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len) +{ + dict_t *options = this->options; + data_t *remote_host_data = NULL; + data_t *remote_port_data = NULL; + char *remote_host = NULL; + uint16_t remote_port = GF_DEFAULT_SOCKET_LISTEN_PORT; + struct addrinfo *addr_info = NULL; + int32_t ret = 0; + struct in6_addr serveraddr; + + remote_host_data = dict_get_sizen(options, "remote-host"); + if (remote_host_data == NULL) { + gf_log(this->name, GF_LOG_ERROR, + "option remote-host missing in volume %s", this->name); + ret = -1; + goto err; + } + + remote_host = data_to_str(remote_host_data); + if (remote_host == NULL) { + gf_log(this->name, GF_LOG_ERROR, + "option remote-host has data NULL in volume %s", this->name); + ret = -1; + goto err; + } + + remote_port_data = dict_get_sizen(options, "remote-port"); + if (remote_port_data == NULL) { + gf_log(this->name, GF_LOG_TRACE, + "option remote-port missing in volume %s. Defaulting to %d", + this->name, GF_DEFAULT_SOCKET_LISTEN_PORT); + } else { + remote_port = data_to_uint16(remote_port_data); + if (remote_port == (uint16_t)-1) { + gf_log(this->name, GF_LOG_ERROR, + "option remote-port has invalid port in volume %s", + this->name); + ret = -1; + goto err; + } + } + + /* Need to update transport-address family if address-family is not provided + to command-line arguments + */ + if (inet_pton(AF_INET6, remote_host, &serveraddr)) { + sockaddr->sa_family = AF_INET6; + } + + /* TODO: gf_resolve is a blocking call. kick in some + non blocking dns techniques */ + ret = gf_resolve_ip6(remote_host, remote_port, sockaddr->sa_family, + &this->dnscache, &addr_info); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, "DNS resolution failed on host %s", + remote_host); + goto err; + } + + memcpy(sockaddr, addr_info->ai_addr, addr_info->ai_addrlen); + *sockaddr_len = addr_info->ai_addrlen; + +err: + return ret; +} + +static int32_t +af_unix_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len) +{ + struct sockaddr_un *sockaddr_un = NULL; + char *connect_path = NULL; + data_t *connect_path_data = NULL; + int32_t ret = -1; + + connect_path_data = dict_get_sizen(this->options, + "transport.socket.connect-path"); + if (!connect_path_data) { + gf_log(this->name, GF_LOG_ERROR, + "option transport.unix.connect-path not specified for " + "address-family unix"); + goto err; + } + + /* 108 = sockaddr_un->sun_path length */ + if ((connect_path_data->len + 1) > 108) { + gf_log(this->name, GF_LOG_ERROR, + "connect-path value length %d > %d octets", + connect_path_data->len + 1, UNIX_PATH_MAX); + goto err; + } + + connect_path = data_to_str(connect_path_data); + if (!connect_path) { + gf_log(this->name, GF_LOG_ERROR, + "transport.unix.connect-path is null-string"); + goto err; + } + + gf_log(this->name, GF_LOG_TRACE, "using connect-path %s", connect_path); + sockaddr_un = (struct sockaddr_un *)sockaddr; + strcpy(sockaddr_un->sun_path, connect_path); + *sockaddr_len = sizeof(struct sockaddr_un); + + ret = 0; +err: + return ret; +} + +static int32_t +af_unix_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) +{ + data_t *listen_path_data = NULL; + char *listen_path = NULL; + int32_t ret = 0; + struct sockaddr_un *sunaddr = (struct sockaddr_un *)addr; + + listen_path_data = dict_get_sizen(this->options, + "transport.socket.listen-path"); + if (!listen_path_data) { + gf_log(this->name, GF_LOG_ERROR, + "missing option transport.socket.listen-path"); + ret = -1; + goto err; + } + + listen_path = data_to_str(listen_path_data); + +#ifndef UNIX_PATH_MAX +#define UNIX_PATH_MAX 108 +#endif + + if ((listen_path_data->len + 1) > UNIX_PATH_MAX) { + gf_log(this->name, GF_LOG_ERROR, + "option transport.unix.listen-path has value length " + "%" GF_PRI_SIZET " > %d", + strlen(listen_path), UNIX_PATH_MAX); + ret = -1; + goto err; + } + + sunaddr->sun_family = AF_UNIX; + strcpy(sunaddr->sun_path, listen_path); + *addr_len = sizeof(struct sockaddr_un); + +err: + return ret; +} + +static int32_t +af_inet_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len) +{ + struct addrinfo hints, *res = 0, *rp = NULL; + data_t *listen_port_data = NULL, *listen_host_data = NULL; + uint16_t listen_port = 0; + char service[NI_MAXSERV], *listen_host = NULL; + dict_t *options = NULL; + int32_t ret = 0; + + /* initializes addr_len */ + *addr_len = 0; + + options = this->options; + + listen_port_data = dict_get_sizen(options, "transport.socket.listen-port"); + if (listen_port_data) { + listen_port = data_to_uint16(listen_port_data); + } else { + listen_port = GF_DEFAULT_SOCKET_LISTEN_PORT; + } + + listen_host_data = dict_get_sizen(options, "transport.socket.bind-address"); + if (listen_host_data) { + listen_host = data_to_str(listen_host_data); + } else { + if (addr->sa_family == AF_INET6) { + struct sockaddr_in6 *in = (struct sockaddr_in6 *)addr; + in->sin6_addr = in6addr_any; + in->sin6_port = htons(listen_port); + *addr_len = sizeof(struct sockaddr_in6); + goto out; + } else if (addr->sa_family == AF_INET) { + struct sockaddr_in *in = (struct sockaddr_in *)addr; + in->sin_addr.s_addr = htonl(INADDR_ANY); + in->sin_port = htons(listen_port); + *addr_len = sizeof(struct sockaddr_in); + goto out; + } + } + + sprintf(service, "%d", listen_port); + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = addr->sa_family; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + + ret = getaddrinfo(listen_host, service, &hints, &res); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, + "getaddrinfo failed for host %s, service %s (%s)", listen_host, + service, gai_strerror(ret)); + ret = -1; + goto out; + } + /* IPV6 server can handle both ipv4 and ipv6 clients */ + for (rp = res; rp != NULL; rp = rp->ai_next) { + if (rp->ai_addr == NULL) + continue; + if (rp->ai_family == AF_INET6) { + memcpy(addr, rp->ai_addr, rp->ai_addrlen); + *addr_len = rp->ai_addrlen; + } + } + + if (!(*addr_len)) { + if (res && res->ai_addr) { + memcpy(addr, res->ai_addr, res->ai_addrlen); + *addr_len = res->ai_addrlen; + } else { + ret = -1; + } + } + + freeaddrinfo(res); + +out: + return ret; +} + +int32_t +client_bind(rpc_transport_t *this, struct sockaddr *sockaddr, + socklen_t *sockaddr_len, int sock) +{ + int ret = 0; + + *sockaddr_len = sizeof(struct sockaddr_in6); + switch (sockaddr->sa_family) { + case AF_INET_SDP: + case AF_INET: + *sockaddr_len = sizeof(struct sockaddr_in); + /* Fall through */ + case AF_INET6: + if (!this->bind_insecure) { + ret = af_inet_bind_to_port_lt_ceiling( + sock, sockaddr, *sockaddr_len, GF_CLIENT_PORT_CEILING); + if (ret == -1) { + gf_log(this->name, GF_LOG_DEBUG, + "cannot bind inet socket (%d) " + "to port less than %d (%s)", + sock, GF_CLIENT_PORT_CEILING, strerror(errno)); + ret = 0; + } + } else { + ret = af_inet_bind_to_port_lt_ceiling( + sock, sockaddr, *sockaddr_len, GF_IANA_PRIV_PORTS_START); + if (ret == -1) { + gf_log(this->name, GF_LOG_DEBUG, + "failed while binding to less than " + "%d (%s)", + GF_IANA_PRIV_PORTS_START, strerror(errno)); + ret = 0; + } + } + break; + + case AF_UNIX: + *sockaddr_len = sizeof(struct sockaddr_un); + ret = af_unix_client_bind(this, (struct sockaddr *)sockaddr, + *sockaddr_len, sock); + break; + + default: + gf_log(this->name, GF_LOG_ERROR, "unknown address family %d", + sockaddr->sa_family); + ret = -1; + break; + } + + return ret; +} + +int32_t +socket_client_get_remote_sockaddr(rpc_transport_t *this, + struct sockaddr *sockaddr, + socklen_t *sockaddr_len, + sa_family_t *sa_family) +{ + int32_t ret = 0; + + GF_VALIDATE_OR_GOTO("socket", sockaddr, err); + GF_VALIDATE_OR_GOTO("socket", sockaddr_len, err); + GF_VALIDATE_OR_GOTO("socket", sa_family, err); + + ret = client_fill_address_family(this, &sockaddr->sa_family); + if (ret) { + ret = -1; + goto err; + } + + *sa_family = sockaddr->sa_family; + + switch (sockaddr->sa_family) { + case AF_INET_SDP: + sockaddr->sa_family = AF_INET; + /* Fall through */ + case AF_INET: + case AF_INET6: + case AF_UNSPEC: + ret = af_inet_client_get_remote_sockaddr(this, sockaddr, + sockaddr_len); + break; + + case AF_UNIX: + ret = af_unix_client_get_remote_sockaddr(this, sockaddr, + sockaddr_len); + break; + + default: + gf_log(this->name, GF_LOG_ERROR, "unknown address-family %d", + sockaddr->sa_family); + ret = -1; + } + + /* Address-family is updated based on remote_host in + af_inet_client_get_remote_sockaddr + */ + if (*sa_family != sockaddr->sa_family) { + *sa_family = sockaddr->sa_family; + } + +err: + return ret; +} + +static int32_t +server_fill_address_family(rpc_transport_t *this, sa_family_t *sa_family) +{ + data_t *address_family_data = NULL; + int32_t ret = -1; + +#ifdef IPV6_DEFAULT + const char *addr_family = "inet6"; + sa_family_t default_family = AF_INET6; +#else + const char *addr_family = "inet"; + sa_family_t default_family = AF_INET; +#endif + + GF_VALIDATE_OR_GOTO("socket", sa_family, out); + + address_family_data = dict_get_sizen(this->options, + "transport.address-family"); + if (address_family_data) { + char *address_family = NULL; + address_family = data_to_str(address_family_data); + + if (!strcasecmp(address_family, "inet")) { + *sa_family = AF_INET; + } else if (!strcasecmp(address_family, "inet6")) { + *sa_family = AF_INET6; + } else if (!strcasecmp(address_family, "inet-sdp")) { + *sa_family = AF_INET_SDP; + } else if (!strcasecmp(address_family, "unix")) { + *sa_family = AF_UNIX; + } else { + gf_log(this->name, GF_LOG_ERROR, + "unknown address family (%s) specified", address_family); + *sa_family = AF_UNSPEC; + goto out; + } + } else { + gf_log(this->name, GF_LOG_DEBUG, + "option address-family not specified, " + "defaulting to %s", + addr_family); + *sa_family = default_family; + } + + ret = 0; +out: + return ret; +} + +int32_t +socket_server_get_local_sockaddr(rpc_transport_t *this, struct sockaddr *addr, + socklen_t *addr_len, sa_family_t *sa_family) +{ + int32_t ret = -1; + + GF_VALIDATE_OR_GOTO("socket", sa_family, err); + GF_VALIDATE_OR_GOTO("socket", addr, err); + GF_VALIDATE_OR_GOTO("socket", addr_len, err); + + ret = server_fill_address_family(this, &addr->sa_family); + if (ret == -1) { + goto err; + } + + *sa_family = addr->sa_family; + + switch (addr->sa_family) { + case AF_INET_SDP: + addr->sa_family = AF_INET; + /* Fall through */ + case AF_INET: + case AF_INET6: + case AF_UNSPEC: + ret = af_inet_server_get_local_sockaddr(this, addr, addr_len); + break; + + case AF_UNIX: + ret = af_unix_server_get_local_sockaddr(this, addr, addr_len); + break; + } + + if (*sa_family == AF_UNSPEC) { + *sa_family = addr->sa_family; + } + +err: + return ret; +} + +static int32_t +fill_inet6_inet_identifiers(rpc_transport_t *this, + struct sockaddr_storage *addr, int32_t addr_len, + char *identifier) +{ + union gf_sock_union sock_union; + + char service[NI_MAXSERV] = { + 0, + }; + char host[NI_MAXHOST] = { + 0, + }; + int32_t ret = 0; + int32_t tmpaddr_len = 0; + int32_t one_to_four = 0; + int32_t four_to_eight = 0; + int32_t twelve_to_sixteen = 0; + int16_t eight_to_ten = 0; + int16_t ten_to_twelve = 0; + + memset(&sock_union, 0, sizeof(sock_union)); + sock_union.storage = *addr; + tmpaddr_len = addr_len; + + if (sock_union.sa.sa_family == AF_INET6) { + one_to_four = sock_union.sin6.sin6_addr.s6_addr32[0]; + four_to_eight = sock_union.sin6.sin6_addr.s6_addr32[1]; +#ifdef GF_SOLARIS_HOST_OS + eight_to_ten = S6_ADDR16(sock_union.sin6.sin6_addr)[4]; +#else + eight_to_ten = sock_union.sin6.sin6_addr.s6_addr16[4]; +#endif + +#ifdef GF_SOLARIS_HOST_OS + ten_to_twelve = S6_ADDR16(sock_union.sin6.sin6_addr)[5]; +#else + ten_to_twelve = sock_union.sin6.sin6_addr.s6_addr16[5]; +#endif + + twelve_to_sixteen = sock_union.sin6.sin6_addr.s6_addr32[3]; + + /* ipv4 mapped ipv6 address has + bits 0-80: 0 + bits 80-96: 0xffff + bits 96-128: ipv4 address + */ + + if (one_to_four == 0 && four_to_eight == 0 && eight_to_ten == 0 && + ten_to_twelve == -1) { + struct sockaddr_in *in_ptr = &sock_union.sin; + memset(&sock_union, 0, sizeof(sock_union)); + + in_ptr->sin_family = AF_INET; + in_ptr->sin_port = ((struct sockaddr_in6 *)addr)->sin6_port; + in_ptr->sin_addr.s_addr = twelve_to_sixteen; + tmpaddr_len = sizeof(*in_ptr); + } + } + + ret = getnameinfo(&sock_union.sa, tmpaddr_len, host, sizeof(host), service, + sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, "getnameinfo failed (%s)", + gai_strerror(ret)); + } + + sprintf(identifier, "%s:%s", host, service); + + return ret; +} + +int32_t +get_transport_identifiers(rpc_transport_t *this) +{ + int32_t ret = 0; + char is_inet_sdp = 0; + + switch (((struct sockaddr *)&this->myinfo.sockaddr)->sa_family) { + case AF_INET_SDP: + is_inet_sdp = 1; + ((struct sockaddr *)&this->peerinfo.sockaddr) + ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr) + ->sa_family = AF_INET; + /* Fall through */ + case AF_INET: + case AF_INET6: { + ret = fill_inet6_inet_identifiers(this, &this->myinfo.sockaddr, + this->myinfo.sockaddr_len, + this->myinfo.identifier); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "cannot fill inet/inet6 identifier for server"); + goto err; + } + + ret = fill_inet6_inet_identifiers(this, &this->peerinfo.sockaddr, + this->peerinfo.sockaddr_len, + this->peerinfo.identifier); + if (ret == -1) { + gf_log(this->name, GF_LOG_ERROR, + "cannot fill inet/inet6 identifier for client"); + goto err; + } + + if (is_inet_sdp) { + ((struct sockaddr *)&this->peerinfo.sockaddr) + ->sa_family = ((struct sockaddr *)&this->myinfo.sockaddr) + ->sa_family = AF_INET_SDP; + } + } break; + + case AF_UNIX: { + struct sockaddr_un *sunaddr = NULL; + + sunaddr = (struct sockaddr_un *)&this->myinfo.sockaddr; + strcpy(this->myinfo.identifier, sunaddr->sun_path); + + sunaddr = (struct sockaddr_un *)&this->peerinfo.sockaddr; + strcpy(this->peerinfo.identifier, sunaddr->sun_path); + } break; + + default: + gf_log(this->name, GF_LOG_ERROR, "unknown address family (%d)", + ((struct sockaddr *)&this->myinfo.sockaddr)->sa_family); + ret = -1; + break; + } + +err: + return ret; +} |