/*
 * Copyright (C) 2005 Jan Kiszka <jan.kiszka@web.de>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  USA.
 */

#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/mman.h>
#include <rtdm/rtdm.h>
#include <cobalt/uapi/syscall.h>
#include <asm/xenomai/syscall.h>
#include "internal.h"

/* support for very old c libraries not supporting O_TMPFILE */
#ifndef O_TMPFILE
#define O_TMPFILE (020000000 | 0200000)
#endif


static inline int set_errno(int ret)
{
	if (ret >= 0)
		return ret;

	errno = -ret;
	return -1;
}

static int do_open(const char *path, int oflag, mode_t mode)
{
	int fd, oldtype;

	/*
	 * Don't dereference path, as it might be invalid. Leave it to
	 * the kernel service.
	 */
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);
	fd = XENOMAI_SYSCALL2( sc_cobalt_open, path, oflag);
	pthread_setcanceltype(oldtype, NULL);
	if (fd < 0) {
		if (fd != -EADV && fd != -ENOSYS)
			return set_errno(fd);

		fd = __STD(open(path, oflag, mode));
	}

	return fd;
}

COBALT_IMPL(int, open, (const char *path, int oflag, ...))
{
	mode_t mode = 0;
	va_list ap;

	if ((oflag & O_CREAT)  || (oflag & O_TMPFILE) == O_TMPFILE) {
		va_start(ap, oflag);
		mode = va_arg(ap, int);
		va_end(ap);
	}

	return do_open(path, oflag, mode);
}

COBALT_IMPL(int, open64, (const char *path, int oflag, ...))
{
	mode_t mode = 0;
	va_list ap;

	if ((oflag & O_CREAT)  || (oflag & O_TMPFILE) == O_TMPFILE) {
		va_start(ap, oflag);
		mode = va_arg(ap, int);
		va_end(ap);
	}

	return do_open(path, oflag | O_LARGEFILE, mode);
}

COBALT_IMPL(int, __open_2, (const char *path, int oflag))
{
	/* __open_2() from glibc adds a runtime precondition test for the 'oflag'
	 * parameter to the functionality of open(). It may be used when the macro
	 * _FORTIFY_SOURCE is defined when compiling the application code.
	 */
	if (__OPEN_NEEDS_MODE(oflag)) {
		const char *msg =
			"invalid open call: O_CREAT or O_TMPFILE without mode\n";
		ssize_t n = __STD(write(STDERR_FILENO, msg, strlen(msg)));
		(void)n;
		abort();
	}

	return do_open(path, oflag, 0);
}

COBALT_IMPL(int, __open64_2, (const char *path, int oflag))
{
	/* just like __open_2() and open64() */
	if (__OPEN_NEEDS_MODE(oflag)) {
		const char *msg =
			"invalid open64 call: O_CREAT or O_TMPFILE without mode\n";
		ssize_t n = __STD(write(STDERR_FILENO, msg, strlen(msg)));
		(void)n;
		abort();
	}

	return do_open(path, oflag | O_LARGEFILE, 0);
}

COBALT_IMPL(int, socket, (int protocol_family, int socket_type, int protocol))
{
	int s;

	s = XENOMAI_SYSCALL3(sc_cobalt_socket, protocol_family,
			     socket_type, protocol);
	if (s < 0) {
		if (s != -EAFNOSUPPORT &&
		    s != -EPROTONOSUPPORT &&
		    s != -ENOSYS)
			return set_errno(s);

		s = __STD(socket(protocol_family, socket_type, protocol));
	}

	return s;
}

COBALT_IMPL(int, close, (int fd))
{
	int oldtype;
	int ret;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL1(sc_cobalt_close, fd);

	pthread_setcanceltype(oldtype, NULL);

	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(close(fd));
}

static int do_ioctl(int fd, unsigned int request, void *arg)
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL3(sc_cobalt_ioctl,	fd, request, arg);

	pthread_setcanceltype(oldtype, NULL);

	return ret;
}

COBALT_IMPL(int, fcntl, (int fd, int cmd, ...))
{
	va_list ap;
	long arg;
	int ret;

	va_start(ap, cmd);
	arg = va_arg(ap, long);
	va_end(ap);

	ret = XENOMAI_SYSCALL3(sc_cobalt_fcntl, fd, cmd, arg);

	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(fcntl(fd, cmd, arg));
}

COBALT_IMPL(int, ioctl, (int fd, unsigned int request, ...))
{
	va_list ap;
	void *arg;
	int ret;

	va_start(ap, request);
	arg = va_arg(ap, void *);
	va_end(ap);

	ret = do_ioctl(fd, request, arg);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(ioctl(fd, request, arg));
}

COBALT_IMPL(ssize_t, read, (int fd, void *buf, size_t nbyte))
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL3(sc_cobalt_read, fd, buf, nbyte);

	pthread_setcanceltype(oldtype, NULL);

	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(read(fd, buf, nbyte));
}

COBALT_IMPL(ssize_t, write, (int fd, const void *buf, size_t nbyte))
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL3(sc_cobalt_write,	fd, buf, nbyte);

	pthread_setcanceltype(oldtype, NULL);

	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(write(fd, buf, nbyte));
}

static ssize_t do_recvmsg(int fd, struct msghdr *msg, int flags)
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL3(sc_cobalt_recvmsg, fd, msg, flags);

	pthread_setcanceltype(oldtype, NULL);

	return ret;
}

COBALT_IMPL(ssize_t, recvmsg, (int fd, struct msghdr *msg, int flags))
{
	int ret;

	ret = do_recvmsg(fd, msg, flags);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(recvmsg(fd, msg, flags));
}

COBALT_IMPL(int, recvmmsg, (int fd, struct mmsghdr *msgvec, unsigned int vlen,
			    unsigned int flags, struct timespec *timeout))
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

#ifdef __USE_TIME_BITS64
	ret = XENOMAI_SYSCALL5(sc_cobalt_recvmmsg64, fd, msgvec,
				vlen, flags, timeout);
#else
	ret = XENOMAI_SYSCALL5(sc_cobalt_recvmmsg, fd, msgvec, vlen, flags, timeout);
#endif

	pthread_setcanceltype(oldtype, NULL);

	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(recvmmsg(fd, msgvec, vlen, flags, timeout));
}

static ssize_t do_sendmsg(int fd, const struct msghdr *msg, int flags)
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL3(sc_cobalt_sendmsg, fd, msg, flags);

	pthread_setcanceltype(oldtype, NULL);

	return ret;
}

COBALT_IMPL(ssize_t, sendmsg, (int fd, const struct msghdr *msg, int flags))
{
	int ret;

	ret = do_sendmsg(fd, msg, flags);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(sendmsg(fd, msg, flags));
}

COBALT_IMPL(int, sendmmsg, (int fd, struct mmsghdr *msgvec,
			    unsigned int vlen, unsigned int flags))
{
	int ret, oldtype;

	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);

	ret = XENOMAI_SYSCALL4(sc_cobalt_sendmmsg, fd, msgvec, vlen, flags);

	pthread_setcanceltype(oldtype, NULL);

	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(sendmmsg(fd, msgvec, vlen, flags));
}

COBALT_IMPL(ssize_t, recvfrom, (int fd, void *buf, size_t len, int flags,
				struct sockaddr *from, socklen_t *fromlen))
{
	struct iovec iov = {
		.iov_base = buf,
		.iov_len = len,
	};
	struct msghdr msg = {
		.msg_name = from,
		.msg_namelen = from != NULL ? *fromlen : 0,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = NULL,
		.msg_controllen = 0,
	};
	int ret;

	ret = do_recvmsg(fd, &msg, flags);
	if (ret != -EADV && ret != -ENOSYS) {
		if (ret < 0)
			return set_errno(ret);

		if (from)
			*fromlen = msg.msg_namelen;

		return ret;
	}

	return __STD(recvfrom(fd, buf, len, flags, from, fromlen));
}

COBALT_IMPL(ssize_t, sendto, (int fd, const void *buf, size_t len, int flags,
			      const struct sockaddr *to, socklen_t tolen))
{
	struct iovec iov = {
		.iov_base = (void *)buf,
		.iov_len = len,
	};
	struct msghdr msg = {
		.msg_name = (struct sockaddr *)to,
		.msg_namelen = tolen,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = NULL,
		.msg_controllen = 0,
	};
	int ret;

	ret = do_sendmsg(fd, &msg, flags);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(sendto(fd, buf, len, flags, to, tolen));
}

COBALT_IMPL(ssize_t, recv, (int fd, void *buf, size_t len, int flags))
{
	struct iovec iov = {
		.iov_base = (void *)buf,
		.iov_len = len,
	};
	struct msghdr msg = {
		.msg_name = NULL,
		.msg_namelen = 0,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = NULL,
		.msg_controllen = 0,
	};
	int ret;

	ret = do_recvmsg(fd, &msg, flags);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(recv(fd, buf, len, flags));
}

COBALT_IMPL(ssize_t, send, (int fd, const void *buf, size_t len, int flags))
{
	struct iovec iov = {
		.iov_base = (void *)buf,
		.iov_len = len,
	};
	struct msghdr msg = {
		.msg_name = NULL,
		.msg_namelen = 0,
		.msg_iov = &iov,
		.msg_iovlen = 1,
		.msg_control = NULL,
		.msg_controllen = 0,
	};
	int ret;

	ret = do_sendmsg(fd, &msg, flags);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(send(fd, buf, len, flags));
}

COBALT_IMPL(int, getsockopt, (int fd, int level, int optname, void *optval,
			      socklen_t *optlen))
{
	struct _rtdm_getsockopt_args args = { level, optname, optval, optlen };
	int ret;

	ret = do_ioctl(fd, _RTIOC_GETSOCKOPT, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(getsockopt(fd, level, optname, optval, optlen));
}

COBALT_IMPL(int, setsockopt, (int fd, int level, int optname, const void *optval,
			      socklen_t optlen))
{
	struct _rtdm_setsockopt_args args = {
		level, optname, (void *)optval, optlen
	};
	int ret;

	ret = do_ioctl(fd, _RTIOC_SETSOCKOPT, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(setsockopt(fd, level, optname, optval, optlen));
}

COBALT_IMPL(int, bind, (int fd, const struct sockaddr *my_addr, socklen_t addrlen))
{
	struct _rtdm_setsockaddr_args args = { my_addr, addrlen };
	int ret;

	ret = do_ioctl(fd, _RTIOC_BIND, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(bind(fd, my_addr, addrlen));
}

COBALT_IMPL(int, connect, (int fd, const struct sockaddr *serv_addr, socklen_t addrlen))
{
	struct _rtdm_setsockaddr_args args = { serv_addr, addrlen };
	int ret;

	ret = do_ioctl(fd, _RTIOC_CONNECT, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(connect(fd, serv_addr, addrlen));
}

COBALT_IMPL(int, listen, (int fd, int backlog))
{
	int ret;

	ret = do_ioctl(fd, _RTIOC_LISTEN, (void *)(long)backlog);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(listen(fd, backlog));
}

COBALT_IMPL(int, accept, (int fd, struct sockaddr *addr, socklen_t *addrlen))
{
	struct _rtdm_getsockaddr_args args = { addr, addrlen };
	int ret;

	ret = do_ioctl(fd, _RTIOC_ACCEPT, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(accept(fd, addr, addrlen));
}

COBALT_IMPL(int, getsockname, (int fd, struct sockaddr *name, socklen_t *namelen))
{
	struct _rtdm_getsockaddr_args args = { name, namelen };
	int ret;

	ret = do_ioctl(fd, _RTIOC_GETSOCKNAME, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(getsockname(fd, name, namelen));
}

COBALT_IMPL(int, getpeername, (int fd, struct sockaddr *name, socklen_t *namelen))
{
	struct _rtdm_getsockaddr_args args = { name, namelen };
	int ret;

	ret = do_ioctl(fd, _RTIOC_GETPEERNAME, &args);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(getpeername(fd, name, namelen));
}

COBALT_IMPL(int, shutdown, (int fd, int how))
{
	int ret;

	ret = do_ioctl(fd, _RTIOC_SHUTDOWN, (void *)(long)how);
	if (ret != -EADV && ret != -ENOSYS)
		return set_errno(ret);

	return __STD(shutdown(fd, how));
}

COBALT_IMPL(void *, mmap64, (void *addr, size_t length, int prot, int flags,
			     int fd, off64_t offset))
{
	struct _rtdm_mmap_request rma;
	int ret;

	if (fd < 0) /* We don't do anonymous mappings. */
		goto regular;

	/* RTDM ignores the address hint, and rejects MAP_FIXED. */
	rma.length = length;
	rma.offset = offset;
	rma.prot = prot;
	rma.flags = flags;

	ret = XENOMAI_SYSCALL3(sc_cobalt_mmap, fd, &rma, &addr);
	if (ret != -EADV && ret != -ENOSYS) {
		ret = set_errno(ret);
		if (ret)
			return MAP_FAILED;

		return addr;
	}

regular:
#if mmap64 == mmap
	return __STD(mmap(addr, length, prot, flags, fd, offset));
#else
	return __STD(mmap64(addr, length, prot, flags, fd, offset));
#endif
}

COBALT_IMPL(void *, mmap, (void *addr, size_t length, int prot, int flags,
			   int fd, off_t offset))
{
	return __COBALT(mmap64(addr, length, prot, flags, fd, offset));
}