/*

 * Copyright (c) 2010-2011, Red Hat, Inc.

 *

 * Permission to use, copy, modify, and/or distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND RED HAT, INC. DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RED HAT, INC. BE LIABLE

 * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

/*

 * Author: Jan Friesse <jfriesse@redhat.com>

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/uio.h>

#include <net/if.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <err.h>

#include <errno.h>

#include <netdb.h>

#include <poll.h>

#include <string.h>

#include "addrfunc.h"

#include "logging.h"

#include "rsfunc.h"

#include "util.h"

/*

 * Wrapper on top of poll. This poll stores old timestamp so it's possible to put always same

 * timeout but correct timeout is computed from old_tstamp and current time. In other words, this

 * function will always after timeout expire return timeout (0) not depending on number of times

 * this function was called.

 * unicast_socket and multicast_socket are two sockets, timeout is absolute timeout (after this

 * value, function returns 0) and old_tstamp is internal state variable (on first call value

 * must be zeroed).

 * Function return bit field (unicast_socket - bit 1, multicast_socket - bit 2) if something was

 * read, 0 on timeout, -1 on fail (use errno) and -2 on interrupt.

 */

int

rs_poll_timeout(int unicast_socket, int multicast_socket, int timeout, struct timeval *old_tstamp)

{

	struct pollfd pfds[2];

	struct timeval cur_time;

	int poll_timeout;

	int poll_res;

	int res;

	cur_time = util_get_time();

	if (old_tstamp->tv_sec == 0 && old_tstamp->tv_usec == 0) {

		*old_tstamp = cur_time;

	}

	if ((int)util_time_absdiff(cur_time, *old_tstamp) > timeout) {

		memset(old_tstamp, 0, sizeof(*old_tstamp));

		return (0);

	}

	poll_timeout = timeout - util_time_absdiff(cur_time, *old_tstamp);

	if (poll_timeout < 0) {

		poll_timeout = 0;

	}

	memset(pfds, 0, sizeof(struct pollfd) * 2);

	pfds[0].fd = unicast_socket;

	pfds[0].events = POLLIN;

	pfds[1].fd = multicast_socket;

	pfds[1].events = POLLIN;

	poll_res = poll(pfds, 2, poll_timeout);

	if (poll_res == 0) {

		memset(old_tstamp, 0, sizeof(*old_tstamp));

		return (0);

	}

	if (poll_res == -1) {

		if (errno == EINTR) {

			DEBUG2_PRINTF("poll error - EINTR");

			return (-2);

		} else {

			DEBUG2_PRINTF("poll error - errno = %d", errno);

			return (-1);

		}

	}

	if (pfds[0].revents & POLLERR || pfds[0].revents & POLLHUP || pfds[0].revents & POLLNVAL) {

		DEBUG2_PRINTF("poll error. pfds[0] revents = %d", pfds[0].revents);

		return (-1);

	}

	if (pfds[1].revents & POLLERR || pfds[1].revents & POLLHUP || pfds[1].revents & POLLNVAL) {

		DEBUG2_PRINTF("poll error. pfds[1] revents = %d", pfds[1].revents);

		return (-1);

	}

	res = 0;

	if (pfds[0].revents & POLLIN) {

		res |= 1;

	}

	if (pfds[1].revents & POLLIN) {

		res |= 2;

	}

	return (res);

}

/*

 * Wrapper on top of recvmsg which emulates recvfrom but it's also able to return ttl. sock is

 * socket where to make recvmsg. from_addr is address where address of source will be stored. msg is

 * buffer where to store message with maximum msg_len size. ttl is pointer where TTL (time-to-live)

 * from packet will be stored (or 0 if no such information is available). Timestamp is filled

 * either by SCM_TIMESTAMP directly from packet (if supported) or current get gettimeofday.

 * NULL can be passed as timestamp pointer.

 * Return number of received bytes, or -2 on EINTR, -3 on one of EHOSTUNREACH | ENETDOWN |

 * EHOSTDOWN | ECONNRESET, -4 if message is truncated, or -1 on different error.

 */

ssize_t

rs_receive_msg(int sock, struct sockaddr_storage *from_addr, char *msg, size_t msg_len,

    uint8_t *ttl, struct timeval *timestamp)

{

	char cmsg_buf[CMSG_SPACE(1024)];

	struct cmsghdr *cmsg;

	struct iovec msg_iovec;

	struct msghdr msg_hdr;

	ssize_t recv_size;

	int ittl;

	int timestamp_set;

	ittl = 0;

	timestamp_set = 0;

	memset(&msg_iovec, 0, sizeof(msg_iovec));

	msg_iovec.iov_base = msg;

	msg_iovec.iov_len = msg_len;

	memset(&msg_hdr, 0, sizeof(msg_hdr));

	msg_hdr.msg_name = from_addr;

	msg_hdr.msg_namelen = sizeof(struct sockaddr_storage);

	msg_hdr.msg_iov = &msg_iovec;

	msg_hdr.msg_iovlen = 1;

	msg_hdr.msg_control = cmsg_buf;

	msg_hdr.msg_controllen = sizeof(cmsg_buf);

	recv_size = recvmsg(sock, &msg_hdr, 0);

	if (recv_size == -1) {

		if (errno == EINTR) {

			DEBUG2_PRINTF("recvmsg error - EINTR");

			return (-2);

		}

		if (errno == EHOSTUNREACH || errno == EHOSTDOWN || errno == ENETDOWN ||

		    errno == ECONNRESET) {

			DEBUG2_PRINTF("recvmsg error - EHOSTUNREACH || EHOSTDOWN || ENETDOWN ||"

			    " ECONNRESET");

			return (-3);

		}

		DEBUG2_PRINTF("recvmsg error - errno = %d", errno);

		return (-1);

	}

	if (msg_hdr.msg_flags & MSG_TRUNC || msg_hdr.msg_flags & MSG_CTRUNC) {

		DEBUG2_PRINTF("recvmsg error - MSG_TRUNC | MSG_CTRUNC");

		return (-4);

	}

	for (cmsg = CMSG_FIRSTHDR(&msg_hdr); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg_hdr, cmsg)) {

		switch (cmsg->cmsg_level) {

		case SOL_SOCKET:

#ifdef SCM_TIMESTAMP

			if (cmsg->cmsg_type == SCM_TIMESTAMP &&

			    cmsg->cmsg_len >= sizeof(struct timeval) && timestamp != NULL) {

				memcpy(timestamp, CMSG_DATA(cmsg), sizeof(struct timeval));

				timestamp_set = 1;

			}

#endif

		case IPPROTO_IP:

			if (cmsg->cmsg_type == IP_TTL && cmsg->cmsg_len == CMSG_LEN(sizeof(int))) {

				memcpy(&ittl, CMSG_DATA(cmsg), sizeof(ittl));

			}

#ifdef IP_RECVTTL

			if (cmsg->cmsg_type == IP_RECVTTL && cmsg->cmsg_len > 1) {

				ittl = *(uint8_t *)CMSG_DATA(cmsg);

			}

#endif

			break;

		case IPPROTO_IPV6:

			if (cmsg->cmsg_type == IPV6_HOPLIMIT && cmsg->cmsg_len ==

			    CMSG_LEN(sizeof(int))) {

				memcpy(&ittl, CMSG_DATA(cmsg), sizeof(ittl));

			}

			break;

		}

	}

	*ttl = (uint8_t)ittl;

	if (!timestamp_set && timestamp != NULL) {

		*timestamp = util_get_time();

	}

	return (recv_size);

}

/*

 * Thin wrapper on top of sendto. sock is socket, msg is message with msg_size length to send and to

 * is address where to send message.

 * Return number of sent bytes or -2 on EINTR, -3 on one of EHOSTDOWN | ENETDOWN | EHOSTUNREACH |

 * ENOBUFS or -1 on some different error (sent != msg_size).

 */

ssize_t

rs_sendto(int sock, const char *msg, size_t msg_size, const struct sockaddr_storage *to)

{

	ssize_t sent;

	sent = sendto(sock, msg, msg_size, 0, (struct sockaddr *)to, af_sas_len(to));

	if (sent == -1) {

		if (errno == EINTR) {

			DEBUG2_PRINTF("sendto error - EINTR");

			return (-2);

		}

		if (errno == EHOSTUNREACH || errno == EHOSTDOWN || errno == ENETDOWN ||

		    errno == ENOBUFS) {

			DEBUG2_PRINTF("sendto error - EHOSTUNREACH || EHOSTDOWN || ENETDOWN ||"

			    "ENOBUFS");

			return (-3);

		}

		DEBUG2_PRINTF("sendto error - errno = %d", errno);

		return (-1);

	}

	if ((size_t)sent != msg_size) {

		DEBUG2_PRINTF("sendto error - sent != msg_size");

		return (-1);

	}

	return (sent);

}