int
accept_listener_source_address(struct Listener *listener, char *source) {
if (listener->source_address != NULL) {
err("Duplicate source address: %s", source);
return 0;
}
listener->source_address = new_address(source);
if (listener->source_address == NULL) {
err("Unable to parse source address: %s", source);
return 0;
}
if (!address_is_sockaddr(listener->source_address)) {
err("Only source socket addresses permitted");
free(listener->source_address);
listener->source_address = NULL;
return 0;
}
if (address_port(listener->source_address) != 0) {
char address[256];
err("Source address on listener %s set to non zero port, "
"this prevents multiple connection to each backend server.",
display_address(listener->address, address, sizeof(address)));
}
return 1;
}
int
accept_listener_arg(struct Listener *listener, char *arg) {
if (listener->address == NULL && !is_numeric(arg)) {
listener->address = new_address(arg);
if (listener->address == NULL ||
!address_is_sockaddr(listener->address)) {
fprintf(stderr, "Invalid listener argument %s\n", arg);
return -1;
}
} else if (listener->address == NULL && is_numeric(arg)) {
listener->address = new_address("[::]");
if (listener->address == NULL ||
!address_is_sockaddr(listener->address)) {
fprintf(stderr, "Unable to initialize default address\n");
return -1;
}
address_set_port(listener->address, atoi(arg));
} else if (address_port(listener->address) == 0 && is_numeric(arg)) {
address_set_port(listener->address, atoi(arg));
} else {
fprintf(stderr, "Invalid listener argument %s\n", arg);
}
return 1;
}
int
accept_backend_arg(struct Backend *backend, const char *arg) {
if (backend->pattern == NULL) {
backend->pattern = strdup(arg);
if (backend->pattern == NULL) {
err("strdup failed");
return -1;
}
} else if (backend->address == NULL) {
backend->address = new_address(arg);
if (backend->address == NULL) {
err("invalid address: %s", arg);
return -1;
}
#ifndef HAVE_LIBUDNS
if (!address_is_sockaddr(backend->address)) {
err("Only socket address backends are permitted when compiled without libudns");
return -1;
}
#endif
} else if (address_port(backend->address) == 0 && is_numeric(arg)) {
address_set_port(backend->address, atoi(arg));
} else {
err("Unexpected table backend argument: %s", arg);
return -1;
}
return 1;
}
int
accept_backend_arg(struct Backend *backend, char *arg) {
if (backend->name == NULL) {
backend->name = strdup(arg);
if (backend->name == NULL) {
err("strdup failed");
return -1;
}
} else if (backend->address == NULL) {
/* Store address in lower case */
for (char *c = arg; *c != '\0'; c++)
*c = tolower(*c);
backend->address = new_address(arg);
if (backend->address == NULL) {
err("invalid address: %s", arg);
return -1;
}
#ifndef HAVE_LIBUDNS
if (!address_is_sockaddr(backend->address)) {
err("Only socket address backends are permitted when compiled without libudns");
return -1;
}
#endif
} else if (address_port(backend->address) == 0 && is_numeric(arg)) {
address_set_port(backend->address, atoi(arg));
} else {
err("Unexpected table backend argument: %s", arg);
return -1;
}
return 1;
}
int
valid_listener(const struct Listener *listener) {
if (listener->address == NULL) {
fprintf(stderr, "No address specified\n");
return 0;
}
if (!address_is_sockaddr(listener->address)) {
fprintf(stderr, "Address not specified as IP/socket\n");
return 0;
}
switch (address_sa(listener->address)->sa_family) {
case AF_UNIX:
break;
case AF_INET:
/* fall through */
case AF_INET6:
if (address_port(listener->address) == 0) {
fprintf(stderr, "No port specified\n");
return 0;
}
break;
default:
fprintf(stderr, "Invalid address family\n");
return 0;
}
if (listener->protocol != tls_protocol && listener->protocol != http_protocol) {
fprintf(stderr, "Invalid protocol\n");
return 0;
}
return 1;
}
int
accept_listener_fallback_address(struct Listener *listener, char *fallback) {
if (listener->fallback_address != NULL) {
err("Duplicate fallback address: %s", fallback);
return 0;
}
listener->fallback_address = new_address(fallback);
if (listener->fallback_address == NULL) {
err("Unable to parse fallback address: %s", fallback);
return 0;
}
#ifndef HAVE_LIBUDNS
if (!address_is_sockaddr(listener->fallback_address)) {
err("Only fallback socket addresses permitted when compiled without libudns");
free(listener->fallback_address);
listener->fallback_address = NULL;
return 0;
}
#endif
if (address_is_wildcard(listener->fallback_address)) {
free(listener->fallback_address);
listener->fallback_address = NULL;
/* The wildcard functionality requires successfully parsing the
* hostname from the client's request, if we couldn't find the
* hostname and are using a fallback address it doesn't make
* much sense to configure it as a wildcard. */
err("Wildcard address prohibited as fallback address");
return 0;
}
return 1;
}
struct Address *
listener_lookup_server_address(const struct Listener *listener,
const char *name, size_t name_len) {
struct Address *new_addr = NULL;
short set_to_fallback = 0;
const struct Address *addr =
table_lookup_server_address(listener->table, name, name_len);
if (addr == NULL)
addr = listener->fallback_address;
if (addr == NULL)
return NULL;
int port = address_port(addr);
if (address_is_wildcard(addr)) {
new_addr = new_address(name);
if (new_addr == NULL) {
warn("Invalid hostname %.*s in client request",
(int)name_len, name);
set_to_fallback = 1;
} else if (address_is_sockaddr(new_addr)) {
warn("Refusing to proxy to socket address literal %.*s in request",
(int)name_len, name);
set_to_fallback = 1;
}
if (!set_to_fallback && port != 0)
address_set_port(new_addr, port);
} else {
size_t len = address_len(addr);
new_addr = malloc(len);
if (new_addr == NULL) {
err("%s: malloc", __func__);
set_to_fallback = 1;
}
memcpy(new_addr, addr, len);
}
if (set_to_fallback) {
size_t len = address_len(listener->fallback_address);
new_addr = malloc(len);
if (new_addr == NULL) {
err("%s: malloc", __func__);
return NULL;
}
memcpy(new_addr, listener->fallback_address, len);
}
if (!set_to_fallback && port == 0)
address_set_port(new_addr, address_port(listener->address));
return new_addr;
}
int main() {
/* using volatile variables so we can example core dumps */
struct Address *addr;
char buffer[255];
int port;
for (volatile unsigned int i = 0; i < sizeof(good) / sizeof(struct Test); i++) {
addr = new_address(good[i].input);
assert(addr != NULL);
if (good[i].expected_type & TYPE_HOSTNAME && !address_is_hostname(addr)) {
fprintf(stderr, "Expected %s to be a hostname\n", buffer);
return 1;
}
if (good[i].expected_type & TYPE_SOCKADDR && !address_is_sockaddr(addr)) {
fprintf(stderr, "Expected %s to be a sockaddr\n", buffer);
return 1;
}
if (good[i].expected_type & TYPE_WILDCARD && !address_is_wildcard(addr)) {
fprintf(stderr, "Expected %s to be a wildcard\n", buffer);
return 1;
}
display_address(addr, buffer, sizeof(buffer));
if (strcmp(buffer, good[i].output)) {
fprintf(stderr, "display_address(%p) returned \"%s\", expected \"%s\"\n", addr, buffer, good[i].output);
return 1;
}
port = address_port(addr);
if (good[i].port != port) {
fprintf(stderr, "address_port(%p) return %d, expected %d\n", addr, port, good[i].port);
return 1;
}
free(addr);
}
for (volatile unsigned int i = 0; i < sizeof(bad) / sizeof(const char *); i++) {
addr = new_address(bad[i]);
if (addr != NULL) {
fprintf(stderr, "Accepted bad hostname \"%s\"\n", bad[i]);
return 1;
}
}
return 0;
}
static void query_cb(struct Address *result, void *data) {
int *query_count = (int *)data;
char ip_buf[128];
if (result != NULL &&
address_is_sockaddr(result) &&
display_address(result, ip_buf, sizeof(ip_buf))) {
fprintf(stderr, "query resolved to %s\n", ip_buf);
query_count++;
}
}
int
accept_listener_fallback_address(struct Listener *listener, char *fallback) {
if (listener->fallback_address != NULL) {
err("Duplicate fallback address: %s", fallback);
return 0;
}
struct Address *fallback_address = new_address(fallback);
if (fallback_address == NULL) {
err("Unable to parse fallback address: %s", fallback);
return 0;
} else if (address_is_sockaddr(fallback_address)) {
listener->fallback_address = fallback_address;
return 1;
} else if (address_is_hostname(fallback_address)) {
#ifndef HAVE_LIBUDNS
err("Only fallback socket addresses permitted when compiled without libudns");
free(fallback_address);
return 0;
#else
warn("Using hostname as fallback address is strongly discouraged");
listener->fallback_address = fallback_address;
return 1;
#endif
} else if (address_is_wildcard(fallback_address)) {
/* The wildcard functionality requires successfully parsing the
* hostname from the client's request, if we couldn't find the
* hostname and are using a fallback address it doesn't make
* much sense to configure it as a wildcard. */
err("Wildcard address prohibited as fallback address");
free(fallback_address);
return 0;
} else {
fatal("Unexpected fallback address type");
return 0;
}
}
int main() {
/* using volatile variables so we can example core dumps */
for (volatile unsigned int i = 0; i < sizeof(good) / sizeof(struct Test); i++) {
int port;
char buffer[255];
struct Address *addr = new_address(good[i].input);
assert(addr != NULL);
assert(address_compare(addr, addr) == 0);
assert(address_compare(NULL, addr) < 0);
assert(address_compare(addr, NULL) > 0);
assert(address_len(addr) > 0);
if (good[i].expected_type & TYPE_HOSTNAME) {
assert(address_is_hostname(addr));
assert(!address_is_sockaddr(addr));
assert(!address_is_wildcard(addr));
assert(address_hostname(addr) != NULL);
assert(address_sa(addr) == NULL);
assert(address_sa_len(addr) == 0);
} else if (good[i].expected_type & TYPE_SOCKADDR) {
assert(!address_is_hostname(addr));
assert(address_is_sockaddr(addr));
assert(!address_is_wildcard(addr));
assert(address_hostname(addr) == NULL);
assert(address_sa(addr) != NULL);
assert(address_sa_len(addr) > 0);
} else if (good[i].expected_type & TYPE_WILDCARD) {
assert(!address_is_hostname(addr));
assert(!address_is_sockaddr(addr));
assert(address_is_wildcard(addr));
assert(address_hostname(addr) == NULL);
assert(address_sa(addr) == NULL);
assert(address_sa_len(addr) == 0);
}
display_address(addr, buffer, sizeof(buffer));
if (strcmp(buffer, good[i].output)) {
fprintf(stderr, "display_address(%p) returned \"%s\", expected \"%s\"\n", addr, buffer, good[i].output);
return 1;
}
assert(display_address(addr, NULL, 0) == NULL);
port = address_port(addr);
if (good[i].port != port) {
fprintf(stderr, "address_port(%p) return %d, expected %d\n", addr, port, good[i].port);
return 1;
}
address_set_port(addr, port);
if (good[i].port != port) {
fprintf(stderr, "address_port(%p) return %d, expected %d\n", addr, port, good[i].port);
return 1;
}
free(addr);
}
for (volatile unsigned int i = 0; i < sizeof(bad) / sizeof(const char *); i++) {
struct Address *addr = new_address(bad[i]);
if (addr != NULL) {
fprintf(stderr, "Accepted bad hostname \"%s\"\n", bad[i]);
return 1;
}
}
assert(compare_address_strings("unix:/dev/log", "127.0.0.1") < 0);
assert(compare_address_strings("unix:/dev/log", "unix:/dev/logsocket") < 0);
assert(compare_address_strings("0.0.0.0", "127.0.0.1") < 0);
assert(compare_address_strings("127.0.0.1", "0.0.0.0") > 0);
assert(compare_address_strings("127.0.0.1", "127.0.0.1") == 0);
assert(compare_address_strings("127.0.0.1:80", "127.0.0.1:81") < 0);
assert(compare_address_strings("*:80", "*:81") < 0);
assert(compare_address_strings("*:81", "*:80") > 0);
assert(compare_address_strings("example.com", "example.net") < 0);
assert(compare_address_strings("example.net", "example.com") > 0);
assert(compare_address_strings("example.com", "example.com.net") < 0);
assert(compare_address_strings("example.com.net", "example.com") > 0);
assert(compare_address_strings("example.com", "example.com:80") < 0);
assert(compare_address_strings("example.com:80", "example.com") > 0);
assert(compare_address_strings(NULL, "example.com") < 0);
assert(compare_address_strings("example.com", NULL) > 0);
assert(compare_address_strings("example.com", "::") < 0);
assert(compare_address_strings("::", "example.com") > 0);
assert(compare_address_strings("0.0.0.0", "*") < 0);
assert(compare_address_strings("*", "0.0.0.0") > 0);
do {
struct Address *addr = new_address("*");
assert(addr != NULL);
assert(address_len(addr) > 0);
free(addr);
} while (0);
return 0;
}
