/* 
   Socket wrapper library. Passes all socket communication over 
   unix domain sockets if the environment variable SOCKET_WRAPPER_DIR 
   is set.
   Copyright (C) Jelmer Vernooij 2005
   
   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, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifdef _SAMBA_BUILD
#include "includes.h"
#include "system/network.h"
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include "dlinklist.h"
#endif

/* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
 * for now */
#define REWRITE_CALLS 

#ifdef REWRITE_CALLS
#define real_accept accept
#define real_connect connect
#define real_bind bind
#define real_getpeername getpeername
#define real_getsockname getsockname
#define real_getsockopt getsockopt
#define real_setsockopt setsockopt
#define real_recvfrom recvfrom
#define real_sendto sendto
#define real_socket socket
#define real_close close
#endif

static struct sockaddr *sockaddr_dup(const void *data, socklen_t len)
{
	struct sockaddr *ret = (struct sockaddr *)malloc(len);
	memcpy(ret, data, len);
	return ret;
}

struct socket_info
{
	int fd;

	int domain;
	int type;
	int protocol;

	char *path;

	struct sockaddr *myname;
	socklen_t myname_len;

	struct sockaddr *peername;
	socklen_t peername_len;

	struct socket_info *prev, *next;
} *sockets = NULL;

static int convert_un_in(const struct sockaddr_un *un, struct sockaddr_in *in, socklen_t *len)
{
	unsigned int prt;
	const char *p;
	int type;

	if ((*len) < sizeof(struct sockaddr_in)) {
		return 0;
	}

	in->sin_family = AF_INET;
	in->sin_port = 1025; /* Default to 1025 */
	p = strchr(un->sun_path, '/');
	if (p) p++; else p = un->sun_path;

	if(sscanf(p, "sock_ip_%d_%u", &type, &prt) == 1) 
	{
		in->sin_port = htons(prt);
	}
	in->sin_addr.s_addr = INADDR_LOOPBACK;
	*len = sizeof(struct sockaddr_in);
	return 0;
}

static int convert_in_un(int type, const struct sockaddr_in *in, struct sockaddr_un *un)
{
	uint16_t prt = ntohs(in->sin_port);
	/* FIXME: ENETUNREACH if in->sin_addr is not loopback */
	snprintf(un->sun_path, sizeof(un->sun_path), "%s/sock_ip_%d_%u", getenv("SOCKET_WRAPPER_DIR"), type, prt);
	return 0;
}

static struct socket_info *find_socket_info(int fd)
{
	struct socket_info *i;
	for (i = sockets; i; i = i->next) {
		if (i->fd == fd) 
			return i;
	}

	return NULL;
}

static int sockaddr_convert_to_un(const struct socket_info *si, const struct sockaddr *in_addr, socklen_t in_len, 
					 struct sockaddr_un *out_addr)
{
	if (!out_addr)
		return 0;

	out_addr->sun_family = AF_UNIX;

	switch (in_addr->sa_family) {
	case AF_INET:
		return convert_in_un(si->type, (const struct sockaddr_in *)in_addr, out_addr);
	case AF_UNIX:
		memcpy(out_addr, in_addr, sizeof(*out_addr));
		return 0;
	default:
		break;
	}
	
	errno = EAFNOSUPPORT;
	return -1;
}

static int sockaddr_convert_from_un(const struct socket_info *si, 
									const struct sockaddr_un *in_addr, 
									int family,
					 	 struct sockaddr *out_addr,
						 socklen_t *out_len)
{
	if (!out_addr) 
		return 0;

	switch (family) {
	case AF_INET:
		return convert_un_in(in_addr, (struct sockaddr_in *)out_addr, out_len);
	case AF_UNIX:
		memcpy(out_addr, in_addr, sizeof(*in_addr));
		*out_len = sizeof(*in_addr);
		return 0;
	default:
		break;
	}

	errno = EAFNOSUPPORT;
	return -1;
}

int swrap_socket(int domain, int type, int protocol)
{
	struct socket_info *si;
	int fd;

	if (!getenv("SOCKET_WRAPPER_DIR")) {
		return real_socket(domain, type, protocol);
	}
	
	fd = real_socket(AF_UNIX, type, 0);

	if (fd < 0) 
		return fd;

	si = malloc(sizeof(struct socket_info));
	memset(si, 0, sizeof(*si));

	si->domain = domain;
	si->type = type;
	si->protocol = protocol;
	si->fd = fd;

	DLIST_ADD(sockets, si);

	return si->fd;
}

int swrap_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
	struct socket_info *parent_si, *child_si;
	int fd;
	socklen_t un_addrlen = sizeof(struct sockaddr_un);
	struct sockaddr_un un_addr;
	int ret;

	parent_si = find_socket_info(s);
	if (!parent_si) {
		return real_accept(s, addr, addrlen);
	}

	ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
	if (ret < 0) return ret;

	fd = ret;

	ret = sockaddr_convert_from_un(parent_si, &un_addr, parent_si->domain, addr, addrlen);

	if (ret < 0) return ret;

	child_si = malloc(sizeof(struct socket_info));
	memset(child_si, 0, sizeof(*child_si));

	child_si->fd = fd;

	if (addr && addrlen) {
		child_si->myname_len = *addrlen;
		child_si->myname = sockaddr_dup(addr, *addrlen);
	}

	return fd;
}

int swrap_connect(int s, const struct sockaddr *serv_addr, socklen_t addrlen)
{
	int ret;
	struct sockaddr_un un_addr;
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_connect(s, serv_addr, addrlen);
	}

	ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr);
	if (ret < 0) return ret;

	ret = real_connect(s, 
					   (struct sockaddr *)&un_addr, 
					   sizeof(struct sockaddr_un));

	if (ret >= 0) {
		si->peername_len = addrlen;
		si->peername = sockaddr_dup(serv_addr, addrlen);
	}

	return ret;
}

int swrap_bind(int s, const struct sockaddr *myaddr, socklen_t addrlen)
{
	int ret;
	struct sockaddr_un un_addr;
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_bind(s, myaddr, addrlen);
	}

	ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr);
	if (ret < 0) return ret;

	unlink(un_addr.sun_path);

	ret = real_bind(s, 
					(struct sockaddr *)&un_addr,
					sizeof(struct sockaddr_un));

	if (ret >= 0) {
		si->myname_len = addrlen;
		si->myname = sockaddr_dup(myaddr, addrlen);
	}

	return ret;
}

int swrap_getpeername(int s, struct sockaddr *name, socklen_t *addrlen)
{
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_getpeername(s, name, addrlen);
	}

	if (!si->peername) 
	{
		errno = ENOTCONN;
		return -1;
	}

	memcpy(name, si->peername, si->peername_len);
	*addrlen = si->peername_len;

	return 0;
}

int swrap_getsockname(int s, struct sockaddr *name, socklen_t *addrlen)
{
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_getpeername(s, name, addrlen);
	}

	memcpy(name, si->myname, si->myname_len);
	*addrlen = si->myname_len;

	return 0;
}

int swrap_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen)
{
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_getsockopt(s, level, optname, optval, optlen);
	}

	if (level == SOL_SOCKET) {
		return real_getsockopt(s, level, optname, optval, optlen);
	} 

	switch (si->domain) {
	case AF_UNIX:
		return real_getsockopt(s, level, optname, optval, optlen);
	default:
		errno = ENOPROTOOPT;
		return -1;
	}
}

int swrap_setsockopt(int s, int  level,  int  optname,  const  void  *optval, socklen_t optlen)
{
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_setsockopt(s, level, optname, optval, optlen);
	}

	if (level == SOL_SOCKET) {
		return real_setsockopt(s, level, optname, optval, optlen);
	}

	switch (si->domain) {
	case AF_UNIX:
		return real_setsockopt(s, level, optname, optval, optlen);
	case AF_INET:
		/* Silence some warnings */
#ifdef TCP_NODELAY
		if (optname == TCP_NODELAY) 
			return 0;
#endif
	default:
		errno = ENOPROTOOPT;
		return -1;
	}
}

ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
{
	socklen_t un_addrlen;
	struct sockaddr_un un_addr;
	int ret;
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_recvfrom(s, buf, len, flags, from, fromlen);
	}

	ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
	if (ret < 0) 
		return ret;

	ret = sockaddr_convert_from_un(si, &un_addr, si->domain, from, fromlen);
	
	return ret;
}

ssize_t swrap_sendto(int  s,  const  void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
{
	struct sockaddr_un un_addr;
	int ret;
	struct socket_info *si = find_socket_info(s);

	if (!si) {
		return real_sendto(s, buf, len, flags, to, tolen);
	}

	ret = sockaddr_convert_to_un(si, to, tolen, &un_addr);
	if (ret < 0) 
		return ret;

	ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
	
	return ret;
}

int swrap_close(int fd)
{
	struct socket_info *si = find_socket_info(fd);

	if (si) {
		DLIST_REMOVE(sockets, si);

		free(si->path);
		free(si->myname);
		free(si->peername);
		free(si);
	}

	return real_close(fd);
}