/*
 * IPv4 getaddrinfo/getnameinfo for the RISC OS build of libpq, using the
 * gethostbyname/inet_* functions exported by the !ODBC manager.
 */

#include "cheader.h"

#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

const char *
gai_strerror(int errcode)
{
	switch (errcode)
	{
		case 0:
			return "Success";
#ifdef EAI_ADDRFAMILY
		case EAI_ADDRFAMILY:
			return "Address family for hostname not supported";
#endif
#ifdef EAI_AGAIN
		case EAI_AGAIN:
			return "Temporary failure in name resolution";
#endif
#ifdef EAI_BADFLAGS
		case EAI_BADFLAGS:
			return "Invalid value for ai_flags";
#endif
#ifdef EAI_FAIL
		case EAI_FAIL:
			return "Non-recoverable failure in name resolution";
#endif
#ifdef EAI_FAMILY
		case EAI_FAMILY:
			return "ai_family not supported";
#endif
#ifdef EAI_MEMORY
		case EAI_MEMORY:
			return "Memory allocation failure";
#endif
#ifdef EAI_NODATA
		case EAI_NODATA:
			return "No address associated with hostname";
#endif
#ifdef EAI_NONAME
		case EAI_NONAME:
			return "Name or service not known";
#endif
#ifdef EAI_SERVICE
		case EAI_SERVICE:
			return "Servname not supported for ai_socktype";
#endif
#ifdef EAI_SOCKTYPE
		case EAI_SOCKTYPE:
			return "ai_socktype not supported";
#endif
#ifdef EAI_SYSTEM
		case EAI_SYSTEM:
			return "System error";
#endif
#ifdef EAI_BADHINTS
		case EAI_BADHINTS:
			return "Invalid value for hints";
#endif
#ifdef EAI_PROTOCOL
		case EAI_PROTOCOL:
			return "Resolved protocol is unknown";
#endif
	}
	return "Unknown resolver error";
}

static struct addrinfo *
new_addrinfo(const struct addrinfo *hints, struct in_addr addr, int port)
{
	struct addrinfo *ai;
	struct sockaddr_in *sin;

	ai = (struct addrinfo *) calloc(1, sizeof(struct addrinfo) + sizeof(struct sockaddr_in));
	if (ai == NULL)
		return NULL;
	sin = (struct sockaddr_in *) (ai + 1);
	sin->sin_len = sizeof(struct sockaddr_in);
	sin->sin_family = AF_INET;
	sin->sin_port = htons((unsigned short) port);
	sin->sin_addr = addr;

	ai->ai_family = AF_INET;
	ai->ai_socktype = hints ? hints->ai_socktype : 0;
	ai->ai_protocol = hints ? hints->ai_protocol : 0;
	if (ai->ai_socktype == 0)
		ai->ai_socktype = SOCK_STREAM;
	ai->ai_addrlen = sizeof(struct sockaddr_in);
	ai->ai_addr = (struct sockaddr *) sin;
	return ai;
}

int
getaddrinfo(const char *node, const char *service,
			const struct addrinfo *hints, struct addrinfo **res)
{
	struct addrinfo *head = NULL;
	struct addrinfo **tail = &head;
	struct in_addr addr;
	int			flags = hints ? hints->ai_flags : 0;
	int			port = 0;

	*res = NULL;

	if (hints && hints->ai_family != AF_UNSPEC && hints->ai_family != AF_INET)
		return EAI_FAMILY;
	if (node == NULL && service == NULL)
		return EAI_NONAME;

	if (service != NULL && service[0] != '\0')
	{
		char	   *end;
		long		p = strtol(service, &end, 10);

		if (*end != '\0' || p < 0 || p > 65535)
			return EAI_SERVICE;
		port = (int) p;
	}

	if (node == NULL)
	{
		addr.s_addr = htonl((flags & AI_PASSIVE) ? INADDR_ANY : INADDR_LOOPBACK);
		*res = new_addrinfo(hints, addr, port);
		return *res ? 0 : EAI_MEMORY;
	}

	if (inet_aton(node, &addr))
	{
		*res = new_addrinfo(hints, addr, port);
		return *res ? 0 : EAI_MEMORY;
	}

	if (flags & AI_NUMERICHOST)
		return EAI_NONAME;

	{
		struct hostent *hp = gethostbyname(node);
		char	  **ap;

		if (hp == NULL || hp->h_addrtype != AF_INET || hp->h_addr_list == NULL)
			return EAI_NONAME;

		for (ap = hp->h_addr_list; *ap != NULL; ap++)
		{
			struct addrinfo *ai;

			memcpy(&addr, *ap, sizeof(addr));
			ai = new_addrinfo(hints, addr, port);
			if (ai == NULL)
			{
				freeaddrinfo(head);
				return EAI_MEMORY;
			}
			*tail = ai;
			tail = &ai->ai_next;
		}
	}

	if (head == NULL)
		return EAI_NODATA;
	*res = head;
	return 0;
}

void
freeaddrinfo(struct addrinfo *ai)
{
	while (ai != NULL)
	{
		struct addrinfo *next = ai->ai_next;

		free(ai->ai_canonname);
		free(ai);
		ai = next;
	}
}

int
getnameinfo(const struct sockaddr *sa, socklen_t salen,
			char *host, size_t hostlen,
			char *serv, size_t servlen, int flags)
{
	const struct sockaddr_in *sin = (const struct sockaddr_in *) sa;

	if (sa == NULL || sa->sa_family != AF_INET || salen < (socklen_t) sizeof(struct sockaddr_in))
		return EAI_FAMILY;

	if (host != NULL && hostlen > 0)
	{
		struct hostent *hp = NULL;

		if (!(flags & NI_NUMERICHOST))
			hp = gethostbyaddr((const char *) &sin->sin_addr, sizeof(sin->sin_addr), AF_INET);
		if (hp != NULL && hp->h_name != NULL)
			strlcpy(host, hp->h_name, hostlen);
		else if (flags & NI_NAMEREQD)
			return EAI_NONAME;
		else
			strlcpy(host, inet_ntoa(sin->sin_addr), hostlen);
	}

	if (serv != NULL && servlen > 0)
		snprintf(serv, servlen, "%d", (int) ntohs(sin->sin_port));

	return 0;
}
