/**
 * mds — A micro-display server
 * Copyright © 2014, 2015, 2016, 2017  Mattias Andrée (m@maandree.se)
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "address.h"

#include <stddef.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netdb.h>
#include <netinet/ip.h>
#include <limits.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <alloca.h>

#include <libmdsserver/config.h>



/**
 * Check whether a string is a radix-10 non-negative integer
 * 
 * @param   str  The string
 * @return       Whether a string is a radix-10 non-negative integer
 */
static int __attribute__((nonnull))
is_pzinteger(const char *restrict str)
{
	for (; *str; str++)
		if ('0' > *str || *str > '9')
			return 0;
	return 1;
}


/**
 * Set the socket address, with the address family `AF_UNIX`
 * 
 * @param   out_address  Output parameter for the socket address
 * @param   pathlen      Pointer to a variable where the length of the pathname will be stored
 * @param   format       Formatting string for the pathname (should end with "%zn")
 * @param   ...          Formatting arguments for the pathname (should end with `pathlen`)
 * @return               Zero on success, -1 on error, `errno`
 *                       will have been set accordinly on error
 * 
 * @throws  ENOMEM        Out of memory. Possibly, the application hit the
 *                        RLIMIT_AS or RLIMIT_DATA limit described in getrlimit(2).
 * @throws  ENAMETOOLONG  The filename of the target socket is too long
 */
static int __attribute__((nonnull, format(gnu_printf, 3, 4)))
set_af_unix(struct sockaddr **restrict out_address, ssize_t *pathlen, const char *format, ...)
#define set_af_unix(a, f, ...) ((set_af_unix)(a, &pathlen, f "%zn", __VA_ARGS__, &pathlen))
{
	struct sockaddr_un *address;
	size_t maxlen;
	va_list args;

	address = malloc(sizeof(struct sockaddr_un));
	*out_address = (struct sockaddr*)address;
	if (!address)
		return -1;

	maxlen = sizeof(address->sun_path) / sizeof(address->sun_path[0]);

	va_start(args, format);

	address->sun_family = AF_UNIX;
	vsnprintf(address->sun_path, maxlen, format, args);

	va_end(args);

	if ((size_t)*pathlen > maxlen)
		return errno = ENAMETOOLONG, -1;

	return 0;
}


/**
 * Set the socket address, with either of the address
 * families `AF_INET` and `AF_INET6`
 * 
 * @param   out_address      Output parameter for the socket address
 * @param   out_address_len  Output parameter for the socket address's allocation size
 * @param   out_gai_error    Output parameter for error at `getaddrinfo`
 * @param   out_domain       Output parameter for the protocol famility,
 *                           unused unless the address familiy is unknown
 * @param   address_family   The address family, `AF_UNSPEC` if unknown
 * @param   host             The host
 * @param   port             The address
 * @return                   Zero on success, -1 on error, `errno` will have been
 *                           set accordinly on error, `*out_gai_error` may be set
 *                           on error and zero returned
 * 
 * @throws  ENOMEM  Out of memory. Possibly, the application hit the
 *                  RLIMIT_AS or RLIMIT_DATA limit described in getrlimit(2).
 */
static int __attribute__((nonnull))
set_af_inet(struct sockaddr **restrict out_address, socklen_t *restrict out_address_len,
            int *restrict out_gai_error, int *restrict out_domain, int address_family,
            const char *restrict host, const char *restrict port)
{
	struct addrinfo hints;
	struct addrinfo *result;
	int saved_errno;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = address_family;

	*out_gai_error = getaddrinfo(host, port, &hints, &result);
	if (*out_gai_error)
		return 0;

	*out_address = malloc(result->ai_addrlen);
	if (!*out_address)
		return saved_errno = errno, freeaddrinfo(result), errno = saved_errno, -1;
	memcpy(*out_address, result->ai_addr, result->ai_addrlen);

	*out_address_len = result->ai_addrlen;
	*out_domain =
		result->ai_family == AF_UNSPEC ? PF_UNSPEC :
		result->ai_family == AF_INET   ? PF_INET   :
		result->ai_family == AF_INET6  ? PF_INET6  :
		result->ai_family;

	freeaddrinfo(result);
	return 0;
}


/**
 * Parse a display address string
 * 
 * @param   display  The address in MDS_DISPLAY-formatting, must not be `NULL`
 * @param   address  Output parameter for parsed address, must not be `NULL`
 * @return           Zero on success, even if parsing failed, -1 on error,
 *                   `errno` will have been set accordinly on error
 * 
 * @throws  ENOMEM        Out of memory. Possibly, the application hit the
 *                        RLIMIT_AS or RLIMIT_DATA limit described in getrlimit(2).
 * @throws  ENAMETOOLONG  The filename of the target socket is too long
 */
int
libmds_parse_display_address(const char *restrict display, libmds_display_address_t *restrict address)
{
	ssize_t pathlen = 0;
	char *host;
	char *port;
	char *params;
	size_t i = 0;
	char c;
	int esc = 0;
	int colesc = 0;

	address->domain = -1;
	address->type = -1;
	address->protocol = -1;
	address->address = NULL;
	address->address_len = 0;
	address->gai_error = 0;

	if (!strchr(display, ':'))
		return 0;

	if (*display == ':') {
		address->domain = PF_UNIX;
		address->type = SOCK_STREAM;
		address->protocol = 0;
		address->address_len = sizeof(struct sockaddr_un);

		if (strstr(display, ":file:") == display)
			return set_af_unix(&(address->address), "%s", display + 6);
		else if (display[1] && is_pzinteger(display + 1))
			return set_af_unix(&(address->address), "%s/%s.socket",
			                   MDS_RUNTIME_ROOT_DIRECTORY, display + 1);
		return 0;
	}

	host = alloca((strlen(display) + 1) * sizeof(char));

	if (*display == '[')
		colesc = 1, i++;
	for (; (c = display[i]); i++) {
		if (esc) {
			host[pathlen++] = c;
			esc = 0;
		} else if (c == '\\') {
			esc = 1;
		} else if (c == ']') {
			if (colesc)
				{ i++; break; }
			else
				host[pathlen++] = c;
		} else if (c == ':') {
			if (colesc)
				host[pathlen++] = c;
			else
				break;
		} else {
			host[pathlen++] = c;
		}
	}
	if (esc || display[i++] != ':')
		return 0;
	host[pathlen++] = '\0';

	port = host + pathlen;
	memcpy(port, display + i, (strlen(display) + 1 - i) * sizeof(char));
	params = strchr(port, ':');
	if (params)
		*params++ = '\0';

#define param_test(f, n, a, b, c)\
	((n >= 3 && !strcasecmp(params, a ":" b ":" c)) ||\
	 (n >= 2 && !strcasecmp(params, a ":" b)) ||\
	 (n >= 1 && !strcasecmp(params, a)) ||\
	 (!f ? 0 : !strcasecmp(params, f)))
#define set(d, t, p)\
	(address->domain = (d), address->type = (t), address->protocol = (p))

	if      (!params)                                              set(PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
	else if (param_test("ip/tcp",    1, "ip",    "stream", "tcp")) set(PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
	else if (param_test("ipv4/tcp",  1, "ipv4",  "stream", "tcp")) set(PF_INET,   SOCK_STREAM, IPPROTO_TCP);
	else if (param_test("ipv6/tcp",  1, "ipv6",  "stream", "tcp")) set(PF_INET6,  SOCK_STREAM, IPPROTO_TCP);
	else if (param_test("inet/tcp",  1, "inet",  "stream", "tcp")) set(PF_INET,   SOCK_STREAM, IPPROTO_TCP);
	else if (param_test("inet6/tcp", 1, "inet6", "stream", "tcp")) set(PF_INET6,  SOCK_STREAM, IPPROTO_TCP);
	else
		return 0;

#undef set
#undef param_test

	return set_af_inet(&(address->address), &(address->address_len),
	                   &(address->gai_error), &(address->domain),
	                   address->domain == PF_UNSPEC ? AF_UNSPEC :
	                   address->domain == PF_INET   ? AF_INET   :
	                   address->domain == PF_INET6  ? AF_INET6  :
	                   address->domain, host, port);
}