/*
 * librelay.c
 *
 * RELAY userspace library.
 *
 * Please note that this library is still developmental, and there may
 * be some API changes.
 *
 * ----------, James Morris, original libipq cod
 * 2003-10-29, Don Mahurin, adopted for use with iptables RELAY module
 *
 * Copyright (c) 2000-2001 Netfilter Core Team
 *
 * 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 2 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.
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <netinet/in.h>

#include "librelaynl.h"

/****************************************************************************
 *
 * Private interface
 *
 ****************************************************************************/

enum {
	RELAY_ERR_NONE = 0,
	RELAY_ERR_IMPL,
	RELAY_ERR_HANDLE,
	RELAY_ERR_SOCKET,
	RELAY_ERR_BIND,
	RELAY_ERR_BUFFER,
	RELAY_ERR_RECV,
	RELAY_ERR_NLEOF,
	RELAY_ERR_ADDRLEN,
	RELAY_ERR_STRUNC,
	RELAY_ERR_RTRUNC,
	RELAY_ERR_NLRECV,
	RELAY_ERR_SEND,
	RELAY_ERR_SUPP,
	RELAY_ERR_RECVBUF,
	RELAY_ERR_TIMEOUT,
        RELAY_ERR_PROTOCOL
};
#define RELAY_MAXERR RELAY_ERR_PROTOCOL

struct relay_errmap_t {
	int errcode;
	char *message;
} relay_errmap[] = {
	{ RELAY_ERR_NONE, "Unknown error" },
	{ RELAY_ERR_IMPL, "Implementation error" },
	{ RELAY_ERR_HANDLE, "Unable to create netlink handle" },
	{ RELAY_ERR_SOCKET, "Unable to create netlink socket" },
	{ RELAY_ERR_BIND, "Unable to bind netlink socket" },
	{ RELAY_ERR_BUFFER, "Unable to allocate buffer" },
	{ RELAY_ERR_RECV, "Failed to receive netlink message" },
	{ RELAY_ERR_NLEOF, "Received EOF on netlink socket" },
	{ RELAY_ERR_ADDRLEN, "Invalid peer address length" },
	{ RELAY_ERR_STRUNC, "Sent message truncated" },
	{ RELAY_ERR_RTRUNC, "Received message truncated" },
	{ RELAY_ERR_NLRECV, "Received error from netlink" },
	{ RELAY_ERR_SEND, "Failed to send netlink message" },
	{ RELAY_ERR_SUPP, "Operation not supported" },
	{ RELAY_ERR_RECVBUF, "Receive buffer size invalid" },
	{ RELAY_ERR_TIMEOUT, "Timeout"},
	{ RELAY_ERR_PROTOCOL, "Invalid protocol specified" }
};

static int relay_errno = RELAY_ERR_NONE;

static ssize_t relay_netlink_sendto(const struct relay_handle *h,
                                  const void *msg, size_t len);

static ssize_t relay_netlink_recvfrom(const struct relay_handle *h,
                                    unsigned char *buf, size_t len,
                                    int timeout);

static ssize_t relay_netlink_sendmsg(const struct relay_handle *h,
                                   const struct msghdr *msg,
                                   unsigned int flags);

static char *relay_strerror(int errcode);

static ssize_t relay_netlink_sendto(const struct relay_handle *h,
                                  const void *msg, size_t len)
{
	int status = sendto(h->fd, msg, len, 0,
	                    (struct sockaddr *)&h->peer, sizeof(h->peer));
	if (status < 0)
		relay_errno = RELAY_ERR_SEND;
	return status;
}

static ssize_t relay_netlink_sendmsg(const struct relay_handle *h,
                                   const struct msghdr *msg,
                                   unsigned int flags)
{
	int status = sendmsg(h->fd, msg, flags);
	if (status < 0)
		relay_errno = RELAY_ERR_SEND;
	return status;
}

static ssize_t relay_netlink_recvfrom(const struct relay_handle *h,
                                    unsigned char *buf, size_t len,
                                    int timeout)
{
	int addrlen, status;
	struct nlmsghdr *nlh;

	if (len < sizeof(struct nlmsgerr)) {
		relay_errno = RELAY_ERR_RECVBUF;
		return -1;
	}
	addrlen = sizeof(h->peer);

	if (timeout != 0) {
		int ret;
		struct timeval tv;
		fd_set read_fds;
		
		if (timeout < 0) {
			/* non-block non-timeout */
			tv.tv_sec = 0;
			tv.tv_usec = 0;
		} else {
			tv.tv_sec = timeout / 1000000;
			tv.tv_usec = timeout % 1000000;
		}

		FD_ZERO(&read_fds);
		FD_SET(h->fd, &read_fds);
		ret = select(h->fd+1, &read_fds, NULL, NULL, &tv);
		if (ret < 0) {
			if (errno == EINTR) {
				return 0;
			} else {
				relay_errno = RELAY_ERR_RECV;
				return -1;
			}
		}
		if (!FD_ISSET(h->fd, &read_fds)) {
			relay_errno = RELAY_ERR_TIMEOUT;
			return 0;
		}
	}
	status = recvfrom(h->fd, buf, len, 0,
	                      (struct sockaddr *)&h->peer, &addrlen);
	if (status < 0) {
		relay_errno = RELAY_ERR_RECV;
		return status;
	}
	if (addrlen != sizeof(h->peer)) {
		relay_errno = RELAY_ERR_RECV;
		return -1;
	}
	if (status == 0) {
		relay_errno = RELAY_ERR_NLEOF;
		return -1;
	}
	nlh = (struct nlmsghdr *)buf;
	if (nlh->nlmsg_flags & MSG_TRUNC || nlh->nlmsg_len > status) {
		relay_errno = RELAY_ERR_RTRUNC;
		return -1;
	}
	return status;
}

static char *relay_strerror(int errcode)
{
	if (errcode < 0 || errcode > RELAY_MAXERR)
		errcode = RELAY_ERR_IMPL;
	return relay_errmap[errcode].message;
}

/****************************************************************************
 *
 * Public interface
 *
 ****************************************************************************/

/*
 * Create and initialise an relay handle.
 */
struct relay_handle *relay_create_handle(u_int32_t flags, u_int32_t protocol)
{
	int status;
	struct relay_handle *h;

	h = (struct relay_handle *)malloc(sizeof(struct relay_handle));
	if (h == NULL) {
		relay_errno = RELAY_ERR_HANDLE;
		return NULL;
	}
	
	memset(h, 0, sizeof(struct relay_handle));
	
        if (protocol == PF_INET)
                h->fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_FIREWALL);
        else if (protocol == PF_INET6)
                h->fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_IP6_FW);
        else {
		relay_errno = RELAY_ERR_PROTOCOL;
		free(h);
		return NULL;
        }
        
	if (h->fd == -1) {
		relay_errno = RELAY_ERR_SOCKET;
		close(h->fd);
		free(h);
		return NULL;
	}
	memset(&h->local, 0, sizeof(struct sockaddr_nl));
	h->local.nl_family = AF_NETLINK;
	h->local.nl_pid = getpid();
	h->local.nl_groups = 0;
	status = bind(h->fd, (struct sockaddr *)&h->local, sizeof(h->local));
	if (status == -1) {
		relay_errno = RELAY_ERR_BIND;
		close(h->fd);
		free(h);
		return NULL;
	}
	memset(&h->peer, 0, sizeof(struct sockaddr_nl));
	h->peer.nl_family = AF_NETLINK;
	h->peer.nl_pid = 0;
	h->peer.nl_groups = 0;
	return h;
}

/*
 * No error condition is checked here at this stage, but it may happen
 * if/when reliable messaging is implemented.
 */
int relay_destroy_handle(struct relay_handle *h)
{
	if (h) {
		close(h->fd);
		free(h);
	}
	return 0;
}

int relay_send_op(const struct relay_handle *h, int op, unsigned short int port, int addr1, int addr2)
{
	struct {
		struct nlmsghdr nlh;
		relay_peer_msg_t pm;
	} req;

	memset(&req, 0, sizeof(req));
	req.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(req));
	req.nlh.nlmsg_flags = NLM_F_REQUEST;
	req.nlh.nlmsg_type = op;
	req.nlh.nlmsg_pid = h->local.nl_pid;
	req.pm.port = port;
	req.pm.addr1 = addr1;
	req.pm.addr2 = addr2;
	return relay_netlink_sendto(h, (void *)&req, req.nlh.nlmsg_len);
}

/*
 * timeout is in microseconds (1 second is 1000000 (1 million) microseconds)
 *
 */
ssize_t relay_read(const struct relay_handle *h,
                 unsigned char *buf, size_t len, int timeout)
{
	return relay_netlink_recvfrom(h, buf, len, timeout);
}

int relay_message_type(const unsigned char *buf)
{
	return ((struct nlmsghdr*)buf)->nlmsg_type;
}

int relay_get_msgerr(const unsigned char *buf)
{
	struct nlmsghdr *h = (struct nlmsghdr *)buf;
	struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
	return -err->error;
}

char *relay_errstr(void)
{
	return relay_strerror(relay_errno);
}

void relay_perror(const char *s)
{
	if (s)
		fputs(s, stderr);
	else
		fputs("ERROR", stderr);
	if (relay_errno)
		fprintf(stderr, ": %s", relay_errstr());
	if (errno)
		fprintf(stderr, ": %s", strerror(errno));
	fputc('\n', stderr);
}