/*

 * Copyright (C) 2010  Miroslav Lichvar <mlichvar@redhat.com>

 * 

 * 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.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#define _GNU_SOURCE

#include <sys/utsname.h>

#include <sys/time.h>

#include <sys/timex.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/syscall.h>

#include <sys/timerfd.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <time.h>

#include <stdio.h>

#include <dlfcn.h>

#include <sys/un.h>

#include <unistd.h>

#include <assert.h>

#include <stddef.h>

#include <stdlib.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <net/if.h>

#include <pwd.h>

#include <stdarg.h>

#include <signal.h>

#include <ifaddrs.h>

#include <linux/types.h>

#include <linux/ethtool.h>

#include <linux/sockios.h>

#ifdef SO_TIMESTAMPING

#include <linux/ptp_clock.h>

#include <linux/net_tstamp.h>

#endif

#include "protocol.h"

#include "client_fuzz.c"

/* first node in first subnet is 192.168.123.1 */

#define BASE_ADDR 0xc0a87b00

#define NETMASK 0xffffff00

#define NODE_ADDR(subnet, node) (BASE_ADDR + 0x100 * (subnet) + (node) + 1)

#define BROADCAST_ADDR(subnet) (NODE_ADDR(subnet, 0) | 0xff)

#define NODE_FROM_ADDR(addr) (((addr) & ~NETMASK) - 1)

#define SUBNET_FROM_ADDR(addr) ((((addr) & NETMASK) - BASE_ADDR) / 0x100)

#define PTP_PRIMARY_MCAST_ADDR 0xe0000181 /* 224.0.1.129 */

#define PTP_PDELAY_MCAST_ADDR 0xe000006b /* 224.0.0.107 */

#define REFCLK_FD 1000

#define REFCLK_ID ((~(clockid_t)REFCLK_FD << 3) | 3)

#define REFCLK_PHC_INDEX 0

#define SYSCLK_FD 1001

#define SYSCLK_CLOCKID ((~(clockid_t)SYSCLK_FD << 3) | 3)

#define SYSCLK_PHC_INDEX 1

#define MAX_SOCKETS 20

#define BASE_SOCKET_FD 100

#define BASE_SOCKET_DEFAULT_PORT 60000

#define MAX_TIMERS 40

#define BASE_TIMER_ID 0xC1230123

#define BASE_TIMER_FD 200

#define URANDOM_FILE (void *)0xD1230123

static FILE *(*_fopen)(const char *path, const char *mode);

static size_t (*_fread)(void *ptr, size_t size, size_t nmemb, FILE *stream);

static int (*_fileno)(FILE *stream);

static int (*_fclose)(FILE *fp);

static int (*_open)(const char *pathname, int flags);

static int (*_close)(int fd);

static int (*_socket)(int domain, int type, int protocol);

static int (*_connect)(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

static ssize_t (*_recvmsg)(int sockfd, struct msghdr *msg, int flags);

static ssize_t (*_send)(int sockfd, const void *buf, size_t len, int flags);

static int (*_usleep)(useconds_t usec);

static void (*_srandom)(unsigned int seed);

static int (*_shmget)(key_t key, size_t size, int shmflg);

static void *(*_shmat)(int shmid, const void *shmaddr, int shmflg);

static unsigned int node;

static int initialized = 0;

static int clknetsim_fd;

static int precision_hack = 1;

static unsigned int random_seed = 0;

static int recv_multiply = 1;

static int timestamping = 1;

enum {

	IFACE_NONE = 0,

	IFACE_LO,

	IFACE_ALL,

	IFACE_ETH0,

};

struct ts_message {

	char data[MAX_PACKET_SIZE];

	unsigned int len;

	unsigned int subnet;

	unsigned int to;

	unsigned int port;

};

struct socket {

	int used;

	int type;

	int port;

	int iface;

	int remote_node;

	int remote_port;

	int broadcast;

	int pkt_info;

	int time_stamping;

	struct ts_message last_ts_msg;

};

static struct socket sockets[MAX_SOCKETS];

static int subnets;

static double real_time = 0.0;

static double monotonic_time = 0.0;

static double network_time = 0.0;

static int local_time_valid = 0;

static time_t system_time_offset = 1262304000; /* 2010-01-01 0:00 UTC */

#define TIMER_TYPE_SIGNAL 1

#define TIMER_TYPE_FD 2

struct timer {

	int used;

	int armed;

	int type;

	clockid_t clock_id;

	double timeout;

	double interval;

};

static struct timer timers[MAX_TIMERS];

static timer_t itimer_real_id;

#define SHM_KEY 0x4e545030

#define SHM_REFCLOCKS 4

static struct shmTime {

  int    mode;

  int    count;

  time_t clockTimeStampSec;

  int    clockTimeStampUSec;

  time_t receiveTimeStampSec;

  int    receiveTimeStampUSec;

  int    leap;

  int    precision;

  int    nsamples;

  int    valid;

  int    clockTimeStampNSec;

  int    receiveTimeStampNSec;

  int    dummy[8]; 

} shm_time[SHM_REFCLOCKS];

static int shm_refclocks = 0;

static double shm_refclock_time = 0.0;

static struct Reply_getrefoffsets refclock_offsets;

static int refclock_offsets_used = REPLY_GETREFOFFSETS_SIZE;

static void make_request(int request_id, const void *request_data, int reqlen, void *reply, int replylen);

__attribute__((constructor))

static void init(void) {

	struct Request_register req;

	struct Reply_register rep;

	struct sockaddr_un s = {AF_UNIX, "clknetsim.sock"};

	const char *env;

	unsigned int connect_retries = 100; /* 10 seconds */

	if (initialized)

		return;

	_fopen = (FILE *(*)(const char *path, const char *mode))dlsym(RTLD_NEXT, "fopen");

	_fread = (size_t (*)(void *ptr, size_t size, size_t nmemb, FILE *stream))dlsym(RTLD_NEXT, "fread");

	_fileno = (int (*)(FILE *stream))dlsym(RTLD_NEXT, "fileno");

	_fclose = (int (*)(FILE *fp))dlsym(RTLD_NEXT, "fclose");

	_open = (int (*)(const char *pathname, int flags))dlsym(RTLD_NEXT, "open");

	_close = (int (*)(int fd))dlsym(RTLD_NEXT, "close");

	_socket = (int (*)(int domain, int type, int protocol))dlsym(RTLD_NEXT, "socket");

	_connect = (int (*)(int sockfd, const struct sockaddr *addr, socklen_t addrlen))dlsym(RTLD_NEXT, "connect");

	_recvmsg = (ssize_t (*)(int sockfd, struct msghdr *msg, int flags))dlsym(RTLD_NEXT, "recvmsg");

	_send = (ssize_t (*)(int sockfd, const void *buf, size_t len, int flags))dlsym(RTLD_NEXT, "send");

	_usleep = (int (*)(useconds_t usec))dlsym(RTLD_NEXT, "usleep");

	_srandom = (void (*)(unsigned int seed))dlsym(RTLD_NEXT, "srandom");

	_shmget = (int (*)(key_t key, size_t size, int shmflg))dlsym(RTLD_NEXT, "shmget");

	_shmat = (void *(*)(int shmid, const void *shmaddr, int shmflg))dlsym(RTLD_NEXT, "shmat");

	env = getenv("CLKNETSIM_START_DATE");

	if (env)

		system_time_offset = atol(env);

	env = getenv("CLKNETSIM_RANDOM_SEED");

	if (env)

		random_seed = atoi(env);

	env = getenv("CLKNETSIM_RECV_MULTIPLY");

	if (env)

		recv_multiply = atoi(env);

	env = getenv("CLKNETSIM_TIMESTAMPING");

	if (env)

		timestamping = atoi(env);

	if (fuzz_init()) {

		node = 0;

		subnets = 1;

		initialized = 1;

		return;

	}

	env = getenv("CLKNETSIM_NODE");

	if (!env) {

		fprintf(stderr, "clknetsim: CLKNETSIM_NODE variable not set.\n");

		exit(1);

	}

	node = atoi(env) - 1;

	env = getenv("CLKNETSIM_SOCKET");

	if (env)

		snprintf(s.sun_path, sizeof (s.sun_path), "%s", env);

	env = getenv("CLKNETSIM_CONNECT_TIMEOUT");

	if (env)

		connect_retries = 10 * atoi(env);

	clknetsim_fd = _socket(AF_UNIX, SOCK_SEQPACKET, 0);

	assert(clknetsim_fd >= 0);

	while (_connect(clknetsim_fd, (struct sockaddr *)&s, sizeof (s)) < 0) {

		if (!--connect_retries) {

			fprintf(stderr, "clknetsim: could not connect to server.\n");

			exit(1);

		}

		_usleep(100000);

	}

	/* this requires the node variable to be already set */

	srandom(0);

	initialized = 1;

	req.node = node;

	make_request(REQ_REGISTER, &req, sizeof (req), &rep, sizeof (rep));

	subnets = rep.subnets;

}

__attribute__((destructor))

static void fini(void) {

	if (initialized)

		make_request(REQ_DEREGISTER, NULL, 0, NULL, 0);

}

static void make_request(int request_id, const void *request_data, int reqlen, void *reply, int replylen) {

	struct Request_packet request;

	int sent, received = 0;

	assert(initialized);

	if (fuzz_mode) {

		fuzz_process_reply(request_id, request_data, reply, replylen);

		return;

	}

	request.header.request = request_id;

	request.header._pad = 0;

	assert(offsetof(struct Request_packet, data) + reqlen <= sizeof (request));

	if (request_data)

		memcpy(&request.data, request_data, reqlen);

	reqlen += offsetof(struct Request_packet, data);

	if ((sent = _send(clknetsim_fd, &request, reqlen, 0)) <= 0 ||

			(reply && (received = recv(clknetsim_fd, reply, replylen, 0)) <= 0)) {

		fprintf(stderr, "clknetsim: server connection closed.\n");

		initialized = 0;

		exit(1);

	}

	assert(sent == reqlen);

	if (!reply)

		return;

	/* check reply length */

	switch (request_id) {

		case REQ_RECV:

			/* reply with variable length */

			assert(received >= offsetof(struct Reply_recv, data));

			assert(offsetof(struct Reply_recv, data) +

				((struct Reply_recv *)reply)->len <= received);

			break;

		default:

			assert(received == replylen);

	}

}

static void fetch_time(void) {

	struct Reply_gettime r;

	if (!local_time_valid) {

		make_request(REQ_GETTIME, NULL, 0, &r, sizeof (r));

		real_time = r.real_time;

		monotonic_time = r.monotonic_time;

		network_time = r.network_time;

		local_time_valid = 1;

	}

}

static double get_real_time(void) {

	fetch_time();

	return real_time;

}

static double get_monotonic_time(void) {

	fetch_time();

	return monotonic_time;

}

static double get_refclock_offset(void) {

	if (refclock_offsets_used >= REPLY_GETREFOFFSETS_SIZE) {

		make_request(REQ_GETREFOFFSETS, NULL, 0, &refclock_offsets, sizeof (refclock_offsets));

		refclock_offsets_used = 0;

	}

	return refclock_offsets.offsets[refclock_offsets_used++];

}

static double get_refclock_time(void) {

	fetch_time();

	return network_time - get_refclock_offset();

}

static void settime(double time) {

	struct Request_settime req;

	req.time = time;

	make_request(REQ_SETTIME, &req, sizeof (req), NULL, 0);

	local_time_valid = 0;

}

static void fill_refclock_sample(void) {

	struct Reply_getrefsample r;

	double clock_time, receive_time, round_corr;

	int i;

	if (!shm_refclocks)

		return;

	make_request(REQ_GETREFSAMPLE, NULL, 0, &r, sizeof (r));

	if (r.time == shm_refclock_time || !r.valid)

		return;

	shm_refclock_time = r.time;

	for (i = 0; i < shm_refclocks; i++) {

		if (shm_refclocks == 1) {

			clock_time = r.time - r.offset;

			receive_time = r.time;

		} else {

			clock_time = get_refclock_time();

			receive_time = get_real_time();

		}

		round_corr = (clock_time * 1e6 - floor(clock_time * 1e6) + 0.5) / 1e6;

		clock_time -= round_corr;

		receive_time -= round_corr;

		shm_time[i].count++;

		shm_time[i].clockTimeStampSec = floor(clock_time);

		shm_time[i].clockTimeStampUSec = (clock_time - shm_time[i].clockTimeStampSec) * 1e6;

		shm_time[i].clockTimeStampNSec = (clock_time - shm_time[i].clockTimeStampSec) * 1e9;

		shm_time[i].clockTimeStampSec += system_time_offset;

		shm_time[i].receiveTimeStampSec = floor(receive_time);

		shm_time[i].receiveTimeStampUSec = (receive_time - shm_time[i].receiveTimeStampSec) * 1e6;

		shm_time[i].receiveTimeStampNSec = (receive_time - shm_time[i].receiveTimeStampSec) * 1e9;

		shm_time[i].receiveTimeStampSec += system_time_offset;

		shm_time[i].leap = 0;

		shm_time[i].valid = 1;

	}

}

static int socket_in_subnet(int socket, int subnet) {

	switch (sockets[socket].iface) {

		case IFACE_LO:

			return 0;

		case IFACE_NONE:

		case IFACE_ALL:

			return 1;

		default:

			return sockets[socket].iface - IFACE_ETH0 == subnet;

	}

}

static void get_target(int socket, uint32_t addr, unsigned int *subnet, unsigned int *node) {

	if (addr == PTP_PRIMARY_MCAST_ADDR || addr == PTP_PDELAY_MCAST_ADDR) {

		assert(sockets[socket].iface >= IFACE_ETH0);

		*subnet = sockets[socket].iface - IFACE_ETH0;

		*node = -1; /* multicast as broadcast */

	} else {

		*subnet = SUBNET_FROM_ADDR(addr);

		assert(*subnet >= 0 && *subnet < subnets);

		assert(socket_in_subnet(socket, *subnet));

		if (addr == BROADCAST_ADDR(*subnet))

			*node = -1; /* broadcast */

		else

			*node = NODE_FROM_ADDR(addr);

	}

}

static int get_network_from_iface(const char *iface) {

	if (strncmp(iface, "eth", 3))

		return -1;

	return atoi(iface + 3);

}

static int get_free_socket(void) {

	int i;

	for (i = 0; i < MAX_SOCKETS; i++) {

		if (!sockets[i].used)

			return i;

	}

	return -1;

}

static int get_socket_from_fd(int fd) {

	int s = fd - BASE_SOCKET_FD;

	if (s >= 0 && s < MAX_SOCKETS && sockets[s].used)

		return s;

	return -1;

}

static int get_socket_fd(int s) {

	return s + BASE_SOCKET_FD;

}

static int find_recv_socket(int subnet, int port, int broadcast) {

	int i, s = -1;

	for (i = 0; i < MAX_SOCKETS; i++) {

		if (!sockets[i].used ||

				!socket_in_subnet(i, subnet) ||

				sockets[i].type != SOCK_DGRAM ||

				(port && sockets[i].port != port))

			continue;

		if (s < 0 || sockets[s].iface < sockets[i].iface ||

				(broadcast && sockets[i].broadcast) ||

				(!broadcast && sockets[s].broadcast &&

				 !sockets[i].broadcast))

			s = i;

	}

	return s;

}

static int get_free_timer(void) {

	int i;

	for (i = 0; i < MAX_TIMERS; i++) {

		if (!timers[i].used)

			return i;

	}

	return -1;

}

static timer_t get_timerid(int timer) {

	return (timer_t)((long)timer + BASE_TIMER_ID);

}

static int get_timer_from_id(timer_t timerid) {

	int t = (long)timerid - BASE_TIMER_ID;

	if (t >= 0 && t < MAX_TIMERS && timers[t].used)

		return t;

	return -1;

}

static int get_timerfd(int timer) {

	return timer + BASE_TIMER_FD;

}

static int get_timer_from_fd(int fd) {

	int t = fd - BASE_TIMER_FD;

	if (t >= 0 && t < MAX_TIMERS && timers[t].used)

		return t;

	return -1;

}

static int get_first_timer(fd_set *timerfds) {

	int i, r = -1;

	for (i = 0; i < MAX_TIMERS; i++) {

		if (!timers[i].used || !timers[i].armed)

			continue;

		if (timers[i].type == TIMER_TYPE_FD &&

				!(timerfds && FD_ISSET(get_timerfd(i), timerfds)))

			continue;

		if (r < 0 || timers[r].timeout > timers[i].timeout)

			r = i;

	}

	return r;

}

static void rearm_timer(int timer)

{

	assert(timers[timer].armed);

	if (timers[timer].interval > 0.0)

		timers[timer].timeout += timers[timer].interval;

	else

		timers[timer].armed = 0;

}

static void time_to_timeval(double d, struct timeval *tv) {

	tv->tv_sec = floor(d);

	tv->tv_usec = (d - tv->tv_sec) * 1e6;

}

static void time_to_timespec(double d, struct timespec *tp) {

	tp->tv_sec = floor(d);

	tp->tv_nsec = (d - tp->tv_sec) * 1e9;

}

static double timeval_to_time(const struct timeval *tv, time_t offset) {

	return tv->tv_sec + offset + tv->tv_usec / 1e6;

}

static double timespec_to_time(const struct timespec *tp, time_t offset) {

	return tp->tv_sec + offset + tp->tv_nsec / 1e9;

}

int gettimeofday(struct timeval *tv, struct timezone *tz) {

	double time;

	time = get_real_time() + 0.5e-6;

	time_to_timeval(time, tv);

	tv->tv_sec += system_time_offset;

	/* chrony clock precision routine hack */

	if (precision_hack)

		tv->tv_usec += random() % 2;

	return 0;

}

int clock_gettime(clockid_t which_clock, struct timespec *tp) {

	double time;

	switch (which_clock) {

		case CLOCK_REALTIME:

		case SYSCLK_CLOCKID:

			time = get_real_time();

			break;

		case CLOCK_MONOTONIC:

			time = get_monotonic_time();

			break;

		case REFCLK_ID:

			time = get_refclock_time();

			break;

		default:

			assert(0);

	}

	time += 0.5e-9;

	time_to_timespec(time, tp);

	if (which_clock == CLOCK_REALTIME || which_clock == REFCLK_ID)

		tp->tv_sec += system_time_offset;

	/* ntpd clock precision routine hack */

	if (precision_hack) {

		static int x = 0;

		tp->tv_nsec += x++ * 101;

	}

	return 0;

}

time_t time(time_t *t) {

	time_t time;

	time = floor(get_real_time());

	time += system_time_offset;

	if (t)

		*t = time;

	return time;

}

int settimeofday(const struct timeval *tv, const struct timezone *tz) {

	assert(tv);

	settime(timeval_to_time(tv, -system_time_offset));

	return 0;

}

int clock_settime(clockid_t which_clock, const struct timespec *tp) {

	assert(tp && which_clock == CLOCK_REALTIME);

	settime(timespec_to_time(tp, -system_time_offset));

	return 0;

}

int adjtimex(struct timex *buf) {

	struct Request_adjtimex req;

	struct Reply_adjtimex rep;

	if (buf->modes & ADJ_SETOFFSET)

		local_time_valid = 0;

	req.timex = *buf;

	make_request(REQ_ADJTIMEX, &req, sizeof (req), &rep, sizeof (rep));

	*buf = rep.timex;

	if (rep.ret < 0)

		errno = EINVAL;

	return rep.ret;

}

int ntp_adjtime(struct timex *buf) {

	return adjtimex(buf);

}

int clock_adjtime(clockid_t id, struct timex *tx) {

	assert(id == CLOCK_REALTIME || id == SYSCLK_CLOCKID || id == REFCLK_ID);

	if (id == SYSCLK_CLOCKID) {

		/* allow large frequency adjustment by setting ticks */

		long hz, base_tick, scaled_ppm_per_tick;

		int r;

		hz = sysconf(_SC_CLK_TCK);

		assert(hz > 0);

		base_tick = (1000000 + hz / 2) / hz;

		scaled_ppm_per_tick = 65536 * hz;

		if (tx->modes & ADJ_FREQUENCY && !(tx->modes & ADJ_TICK))

			tx->tick = base_tick, tx->modes |= ADJ_TICK;

		tx->tick += tx->freq / scaled_ppm_per_tick;

		tx->freq = tx->freq % scaled_ppm_per_tick;

		r = adjtimex(tx);

		tx->freq += (tx->tick - base_tick) * scaled_ppm_per_tick;

		tx->tick = base_tick;

		return r;

	} else if (id == REFCLK_ID) {

		if (tx->modes) {

			errno = EINVAL;

			return -1;

		}

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

		return 0;

	}

	return adjtimex(tx);

}

int adjtime(const struct timeval *delta, struct timeval *olddelta) {

	struct Request_adjtime req;

	struct Reply_adjtime rep;

	if (delta)

		req.tv = *delta;

	else

		time_to_timeval(0.0, &req.tv);

	make_request(REQ_ADJTIME, &req, sizeof (req), &rep, sizeof (rep));

	if (olddelta)

		*olddelta = rep.tv;

	if (!delta) {

		req.tv = rep.tv;

		make_request(REQ_ADJTIME, &req, sizeof (req), &rep, sizeof (rep));

	}

	return 0;

}

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {

	struct Request_select req;

	struct Reply_select rep;

	int i, timer, s, recv_fd = -1;

	double elapsed = 0.0;

	if (writefds)

		FD_ZERO(writefds);

	if (exceptfds) {

		/* chronyd waiting for TX timestamp from the error queue */

		for (i = 0; i < nfds; i++) {

			if (!FD_ISSET(i, exceptfds) || get_socket_from_fd(i) < 0 ||

					!sockets[get_socket_from_fd(i)].last_ts_msg.len)

				continue;

			if (readfds)

				FD_ZERO(readfds);

			FD_ZERO(exceptfds);

			FD_SET(i, exceptfds);

			return 1;

		}

		FD_ZERO(exceptfds);

	}

	req.read = 0;

	req._pad = 0;

	/* unknown reading fds are always ready (e.g. chronyd waiting

	   for name resolving notification, or OpenSSL waiting for

	   /dev/urandom) */

	if (readfds) {

		for (i = 0; i < nfds; i++) {

			if (!FD_ISSET(i, readfds))

				continue;

			if (get_socket_from_fd(i) < 0 &&

					get_timer_from_fd(i) < 0) {

				FD_ZERO(readfds);

				FD_SET(i, readfds);

				return 1;

			}

			req.read = 1;

		}

	}

	timer = get_first_timer(readfds);

	assert((timeout && (timeout->tv_sec > 0 || timeout->tv_usec > 0)) ||

			timer >= 0 || find_recv_socket(0, 0, 0) >= 0);

	fetch_time();

	if (timeout)

		req.timeout = timeout->tv_sec + (timeout->tv_usec + 1) / 1e6;

	else

		req.timeout = 1e20;

try_again:

	if (timer >= 0 && timers[timer].timeout <= monotonic_time) {

		/* avoid unnecessary requests */

		rep.ret = REPLY_SELECT_TIMEOUT;

	} else {

		if (timer >= 0 && monotonic_time + req.timeout > timers[timer].timeout)

			req.timeout = timers[timer].timeout - monotonic_time;

		make_request(REQ_SELECT, &req, sizeof (req), &rep, sizeof (rep));

		elapsed += rep.time.monotonic_time - monotonic_time;

		req.timeout -= rep.time.monotonic_time - monotonic_time;

		real_time = rep.time.real_time;

		monotonic_time = rep.time.monotonic_time;

		network_time = rep.time.network_time;

		local_time_valid = 1;

		fill_refclock_sample();

		if (monotonic_time >= 0.1 || timer >= 0 || rep.ret != REPLY_SELECT_TIMEOUT)

			precision_hack = 0;

	}

	switch (rep.ret) {

		case REPLY_SELECT_TERMINATE:

			kill(getpid(), SIGTERM);

			errno = EINTR;

			return -1;

		case REPLY_SELECT_TIMEOUT:

			if (timer >= 0 && monotonic_time >= timers[timer].timeout) {

				rearm_timer(timer);

				switch (timers[timer].type) {

					case TIMER_TYPE_SIGNAL:

						kill(getpid(), SIGALRM);

						errno = EINTR;

						return -1;

					case TIMER_TYPE_FD:

						recv_fd = get_timerfd(timer);

						break;

					default:

						assert(0);

				}

			} else

				recv_fd = 0;

			break;

		case REPLY_SELECT_NORMAL:

		case REPLY_SELECT_BROADCAST:

			s = find_recv_socket(rep.subnet, rep.dst_port,

					rep.ret == REPLY_SELECT_BROADCAST);

			recv_fd = s >= 0 ? get_socket_fd(s) : 0;

			/* fetch and drop the packet if no fd is waiting for it */

			if (!readfds || !recv_fd || !FD_ISSET(recv_fd, readfds)) {

				struct Reply_recv recv_rep;

				make_request(REQ_RECV, NULL, 0, &recv_rep, sizeof (recv_rep));

				if (rep.ret != REPLY_SELECT_BROADCAST)

					fprintf(stderr, "clknetsim: dropped packet from "

							"node %d on port %d in subnet %d\n",

							recv_rep.from + 1, recv_rep.dst_port,

							recv_rep.subnet + 1);

				goto try_again;

			}

			break;

		default:

			assert(0);

			return 0;

	}

	assert(!recv_fd || (readfds && FD_ISSET(recv_fd, readfds)));

	assert(!recv_fd || (recv_fd >= BASE_SOCKET_FD && recv_fd < BASE_SOCKET_FD + MAX_SOCKETS) ||

			(recv_fd >= BASE_TIMER_FD && recv_fd < BASE_TIMER_FD + MAX_TIMERS));

	if (readfds) {

		FD_ZERO(readfds);

		if (recv_fd)

			FD_SET(recv_fd, readfds);

	}

	if (timeout) {

		time_to_timeval(timeval_to_time(timeout, 0) - elapsed, timeout);

		if (timeout->tv_sec < 0) {

			timeout->tv_sec = 0;

			timeout->tv_usec = 0;

		}

	}

	return recv_fd ? 1 : 0;

}

#ifndef CLKNETSIM_DISABLE_POLL

int poll(struct pollfd *fds, nfds_t nfds, int timeout) {

	struct timeval tv, *ptv = NULL;

	int r, maxfd = 0;

	nfds_t i;

	fd_set rfds;

	/* ptp4l waiting for tx SO_TIMESTAMPING */

	if (nfds == 1 && fds[0].events != POLLOUT && get_socket_from_fd(fds[0].fd) >= 0 &&

	    sockets[get_socket_from_fd(fds[0].fd)].time_stamping &

	    (SOF_TIMESTAMPING_TX_SOFTWARE | SOF_TIMESTAMPING_TX_HARDWARE)) {

		if (!fds[0].events) {