//
// VMime library (http://www.vmime.org)
// Copyright (C) 2002 Vincent Richard <vincent@vmime.org>
//
// 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 3 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.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// Linking this library statically or dynamically with other modules is making
// a combined work based on this library.  Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//

#include "vmime/config.hpp"


#if VMIME_PLATFORM_IS_POSIX && VMIME_HAVE_MESSAGING_FEATURES


#include "vmime/platforms/posix/posixSocket.hpp"
#include "vmime/platforms/posix/posixHandler.hpp"

#ifndef _GNU_SOURCE
#define _GNU_SOURCE  // for getaddrinfo_a() in <netdb.h>
#endif

#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <poll.h>

#include "vmime/utility/stringUtils.hpp"

#include "vmime/exception.hpp"


#if defined(EWOULDBLOCK)
#   define IS_EAGAIN(x)  ((x) == EAGAIN || (x) == EWOULDBLOCK || (x) == EINTR || (x) == EINPROGRESS)
#else
#   define IS_EAGAIN(x)  ((x) == EAGAIN || (x) == EINTR || (x) == EINPROGRESS)
#endif


// Workaround for detection of strerror_r variants
#if VMIME_HAVE_STRERROR_R

namespace {

char* vmime_strerror_r_result(int /* res */, char* buf) {

	// XSI-compliant prototype:
	// int strerror_r(int errnum, char *buf, size_t buflen);
	return buf;
}

char* vmime_strerror_r_result(char* res, char* /* buf */) {

	// GNU-specific prototype:
	// char *strerror_r(int errnum, char *buf, size_t buflen);
	return res;
}

}

#endif // VMIME_HAVE_STRERROR_R



namespace vmime {
namespace platforms {
namespace posix {


//
// posixSocket
//

posixSocket::posixSocket(shared_ptr <vmime::net::timeoutHandler> th)
	: m_timeoutHandler(th),
	  m_desc(-1),
	  m_status(0) {

}


posixSocket::~posixSocket() {

	if (m_desc != -1) {
		::close(m_desc);
	}
}


void posixSocket::connect(const vmime::string& address, const vmime::port_t port) {

	// Close current connection, if any
	if (m_desc != -1) {
		::close(m_desc);
		m_desc = -1;
	}

	if (m_tracer) {

		std::ostringstream trace;
		trace << "Connecting to " << address << ", port " << port;

		m_tracer->traceSend(trace.str());
	}

#if VMIME_HAVE_GETADDRINFO  // use thread-safe and IPv6-aware getaddrinfo() if available

	// Resolve address, if needed
	m_serverAddress = address;

	struct ::addrinfo* addrInfo = NULL;  // resolved addresses
	resolve(&addrInfo, address, port);

	// Connect to host
	int sock = -1;
	int connectErrno = 0;

	if (m_timeoutHandler != NULL) {
		m_timeoutHandler->resetTimeOut();
	}

	for (struct ::addrinfo* curAddrInfo = addrInfo ;
	     sock == -1 && curAddrInfo != NULL ;
	     curAddrInfo = curAddrInfo->ai_next, connectErrno = ETIMEDOUT) {

		if (curAddrInfo->ai_family != AF_INET && curAddrInfo->ai_family != AF_INET6) {
			continue;
		}

		sock = ::socket(curAddrInfo->ai_family, curAddrInfo->ai_socktype, curAddrInfo->ai_protocol);

		if (sock < 0) {
			connectErrno = errno;
			continue;  // try next
		}

#if VMIME_HAVE_SO_KEEPALIVE

		// Enable TCP Keepalive
		int keepAlive_optval = 1;
		socklen_t keepAlive_optlen = sizeof(keepAlive_optval);

		::setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &keepAlive_optval, keepAlive_optlen);

#endif // VMIME_HAVE_SO_KEEPALIVE

#if VMIME_HAVE_SO_NOSIGPIPE

		// Return EPIPE instead of generating SIGPIPE
		int nosigpipe_optval = 1;
		socklen_t nosigpipe_optlen = sizeof(nosigpipe_optval);

		::setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe_optval, nosigpipe_optlen);

#endif // VMIME_HAVE_SO_NOSIGPIPE


		if (m_timeoutHandler) {

			::fcntl(sock, F_SETFL, ::fcntl(sock, F_GETFL) | O_NONBLOCK);

			if (::connect(sock, curAddrInfo->ai_addr, curAddrInfo->ai_addrlen) < 0) {

				switch (errno) {

					case 0:
					case EINPROGRESS:
					case EINTR:
#if defined(EAGAIN)
					case EAGAIN:
#endif // EAGAIN
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
					case EWOULDBLOCK:
#endif // EWOULDBLOCK

						// Connection in progress
						break;

					default:

						connectErrno = errno;
						::close(sock);
						sock = -1;
						continue;  // try next
				}

				// Wait for socket to be connected.
				bool connected = false;

				const int pollTimeout = 1000;   // poll() timeout (ms)
				const int tryNextTimeout = 5000;  // maximum time before trying next (ms)

				timeval startTime = { 0, 0 };
				gettimeofday(&startTime, /* timezone */ NULL);

				do {

					pollfd fds[1];
					fds[0].fd = sock;
					fds[0].events = POLLIN | POLLOUT;

					const int ret = ::poll(fds, sizeof(fds) / sizeof(fds[0]), pollTimeout);

					// Success
					if (ret > 0) {

						if (fds[0].revents & (POLLIN | POLLOUT)) {

							int error = 0;
							socklen_t len = sizeof(error);

							if (getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {

								connectErrno = errno;

							} else {

								if (error != 0) {
									connectErrno = error;
								} else {
									connected = true;
								}
							}
						}

						break;

					// Error
					} else if (ret < -1) {

						if (errno != EAGAIN && errno != EINTR) {

							// Cancel connection
							connectErrno = errno;
							break;
						}
					}

					// Check for timeout
					if (m_timeoutHandler->isTimeOut()) {

						if (!m_timeoutHandler->handleTimeOut()) {

							// Cancel connection
							connectErrno = ETIMEDOUT;
							break;

						} else {

							// Reset timeout and keep waiting for connection
							m_timeoutHandler->resetTimeOut();
						}

					} else {

						// Keep waiting for connection
					}

					timeval curTime = { 0, 0 };
					gettimeofday(&curTime, /* timezone */ NULL);

					if (curAddrInfo->ai_next != NULL &&
						curTime.tv_usec - startTime.tv_usec >= tryNextTimeout * 1000) {

						connectErrno = ETIMEDOUT;
						break;
					}

				} while (true);

				if (!connected) {

					::close(sock);
					sock = -1;
					continue;  // try next
				}

				break;

			} else {

				// Connection successful
				break;
			}

		} else {

			if (::connect(sock, curAddrInfo->ai_addr, curAddrInfo->ai_addrlen) < 0) {

				connectErrno = errno;
				::close(sock);
				sock = -1;
				continue;  // try next
			}
		}
	}

	::freeaddrinfo(addrInfo);

	if (sock == -1) {

		try {
			throwSocketError(connectErrno);
		} catch (exceptions::socket_exception& e) {  // wrap
			throw vmime::exceptions::connection_error("Error while connecting socket.", e);
		}
	}

	m_desc = sock;

#else // !VMIME_HAVE_GETADDRINFO

	// Resolve address
	::sockaddr_in addr;

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

	addr.sin_family = AF_INET;
	addr.sin_port = htons(static_cast <unsigned short>(port));
	addr.sin_addr.s_addr = ::inet_addr(address.c_str());

	if (addr.sin_addr.s_addr == static_cast <in_addr_t>(-1)) {

		::hostent* hostInfo = ::gethostbyname(address.c_str());

		if (hostInfo == NULL) {
			// Error: cannot resolve address
			throw vmime::exceptions::connection_error("Cannot resolve address.");
		}

		::memcpy(reinterpret_cast <char*>(&addr.sin_addr), hostInfo->h_addr, hostInfo->h_length);
	}

	m_serverAddress = address;

	// Get a new socket
	m_desc = ::socket(AF_INET, SOCK_STREAM, 0);

	if (m_desc == -1) {

		try {
			throwSocketError(errno);
		} catch (exceptions::socket_exception& e) {  // wrap
			throw vmime::exceptions::connection_error("Error while creating socket.", e);
		}
	}

	// Start connection
	if (::connect(m_desc, reinterpret_cast <sockaddr*>(&addr), sizeof(addr)) == -1) {

		try {

			throwSocketError(errno);

		} catch (exceptions::socket_exception& e) {  // wrap

			::close(m_desc);
			m_desc = -1;

			// Error
			throw vmime::exceptions::connection_error("Error while connecting socket.", e);
		}
	}

#endif // VMIME_HAVE_GETADDRINFO

	::fcntl(m_desc, F_SETFL, ::fcntl(m_desc, F_GETFL) | O_NONBLOCK);
}


void posixSocket::resolve(
	struct ::addrinfo** addrInfo,
	const vmime::string& address,
	const vmime::port_t port
) {

	char portStr[16];
	snprintf(portStr, sizeof(portStr), "%u", static_cast <unsigned int>(port));


	struct ::addrinfo hints;
	memset(&hints, 0, sizeof(hints));

	hints.ai_flags = AI_CANONNAME | AI_NUMERICSERV;
	hints.ai_family = PF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;

#if VMIME_HAVE_GETADDRINFO_A

	// If getaddrinfo_a() is available, use asynchronous resolving to allow
	// the timeout handler to cancel the operation

	struct ::gaicb gaiRequest;
	memset(&gaiRequest, 0, sizeof(gaiRequest));

	gaiRequest.ar_name = address.c_str();
	gaiRequest.ar_service = portStr;
	gaiRequest.ar_request = &hints;

	struct ::gaicb* gaiRequests = &gaiRequest;
	int gaiError;

	if ((gaiError = getaddrinfo_a(GAI_NOWAIT, &gaiRequests, 1, NULL)) != 0) {

		throw vmime::exceptions::connection_error(
			"getaddrinfo_a() failed: " + std::string(gai_strerror(gaiError))
		);
	}

	if (m_timeoutHandler) {
		m_timeoutHandler->resetTimeOut();
	}

	while (true) {

		struct timespec gaiTimeout;
		gaiTimeout.tv_sec = 1;  // query timeout handler every second
		gaiTimeout.tv_nsec = 0;

		gaiError = gai_suspend(&gaiRequests, 1, &gaiTimeout);

		if (gaiError == 0 || gaiError == EAI_ALLDONE) {

			const int ret = gai_error(&gaiRequest);

			if (ret != 0) {

				throw vmime::exceptions::connection_error(
					"getaddrinfo_a() request failed: " + std::string(gai_strerror(ret))
				);

			} else {

				*addrInfo = gaiRequest.ar_result;
				break;
			}

		} else if (gaiError != EAI_AGAIN) {

			if (gaiError == EAI_SYSTEM) {

				const int ret = gai_error(&gaiRequest);

				if (ret != EAI_INPROGRESS && errno != 0) {

					try {
						throwSocketError(errno);
					} catch (exceptions::socket_exception& e) {  // wrap
						throw vmime::exceptions::connection_error("Error while connecting socket.", e);
					}
				}

			} else {

				throw vmime::exceptions::connection_error(
					"gai_suspend() failed: " + std::string(gai_strerror(gaiError))
				);
			}
		}

		// Check for timeout
		if (m_timeoutHandler && m_timeoutHandler->isTimeOut()) {

			if (!m_timeoutHandler->handleTimeOut()) {

				throw exceptions::operation_timed_out();

			} else {

				// Reset timeout and keep waiting for connection
				m_timeoutHandler->resetTimeOut();
			}
		}
	}

#else  // !VMIME_HAVE_GETADDRINFO_A

	if (::getaddrinfo(address.c_str(), portStr, &hints, addrInfo) != 0) {

		// Error: cannot resolve address
		throw vmime::exceptions::connection_error("Cannot resolve address.");
	}

#endif  // VMIME_HAVE_GETADDRINFO_A

}


bool posixSocket::isConnected() const {

	if (m_desc == -1) {
		return false;
	}

	char buff;

	return ::recv(m_desc, &buff, 1, MSG_PEEK) != 0;
}


void posixSocket::disconnect() {

	if (m_desc != -1) {

		if (m_tracer) {
			m_tracer->traceSend("Disconnecting");
		}

		::shutdown(m_desc, SHUT_RDWR);
		::close(m_desc);

		m_desc = -1;
	}
}


static bool isNumericAddress(const char* address) {

#if VMIME_HAVE_GETADDRINFO

	struct addrinfo hint, *info = NULL;
	memset(&hint, 0, sizeof(hint));

	hint.ai_family = AF_UNSPEC;
	hint.ai_flags = AI_NUMERICHOST;

	if (getaddrinfo(address, 0, &hint, &info) == 0) {

		freeaddrinfo(info);
		return true;

	} else {

		return false;
	}

#else

	return inet_addr(address) != INADDR_NONE;

#endif

}


const string posixSocket::getPeerAddress() const {

	// Get address of connected peer
	sockaddr peer;
	socklen_t peerLen = sizeof(peer);

	if (getpeername(m_desc, &peer, &peerLen) != 0) {
		throwSocketError(errno);
	}

	// Convert to numerical presentation format
	char buf[INET6_ADDRSTRLEN];

	if (!inet_ntop(peer.sa_family, &(reinterpret_cast <struct sockaddr_in *>(&peer))->sin_addr, buf, sizeof(buf))) {
		throwSocketError(errno);
	}

	return string(buf);
}


const string posixSocket::getPeerName() const {

	// Get address of connected peer
	sockaddr peer;
	socklen_t peerLen = sizeof(peer);

	if (getpeername(m_desc, &peer, &peerLen) != 0) {
		throwSocketError(errno);
	}

	// If server address as specified when connecting is a numeric
	// address, try to get a host name for it
	if (isNumericAddress(m_serverAddress.c_str())) {

#if VMIME_HAVE_GETNAMEINFO

		char host[NI_MAXHOST + 1];
		char service[NI_MAXSERV + 1];

		if (getnameinfo(reinterpret_cast <sockaddr *>(&peer), peerLen,
				host, sizeof(host), service, sizeof(service),
				/* flags */ NI_NAMEREQD) == 0) {

			return string(host);
		}

#else

		struct hostent *hp;

		if ((hp = gethostbyaddr(reinterpret_cast <const void *>(&peer),
				sizeof(peer), peer.sa_family)) != NULL) {

			return string(hp->h_name);
		}

#endif

	}

	return m_serverAddress;
}


size_t posixSocket::getBlockSize() const {

	return 16384;  // 16 KB
}


bool posixSocket::waitForData(const bool read, const bool write, const int msecs) {

	for (int i = 0 ; i <= msecs / 10 ; ++i) {

		// Check whether data is available
		pollfd fds[1];
		fds[0].fd = m_desc;
		fds[0].events = 0;

		if (read) {
			fds[0].events |= POLLIN;
		}

		if (write) {
			fds[0].events |= POLLOUT;
		}

		const int ret = ::poll(fds, sizeof(fds) / sizeof(fds[0]), 10 /* ms */);

		if (ret < 0) {

			if (errno != EAGAIN && errno != EINTR) {
				throwSocketError(errno);
			}

		} else if (ret > 0) {

			if (fds[0].revents & (POLLIN | POLLOUT)) {
				return true;
			}
		}

		// No data available at this time
		// Check if we are timed out
		if (m_timeoutHandler &&
		    m_timeoutHandler->isTimeOut()) {

			if (!m_timeoutHandler->handleTimeOut()) {

				// Server did not react within timeout delay
				throw exceptions::operation_timed_out();

			} else {

				// Reset timeout
				m_timeoutHandler->resetTimeOut();
			}
		}
	}

	return false;  // time out
}


bool posixSocket::waitForRead(const int msecs) {

	return waitForData(/* read */ true, /* write */ false, msecs);
}


bool posixSocket::waitForWrite(const int msecs) {

	return waitForData(/* read */ false, /* write */ true, msecs);
}


void posixSocket::receive(vmime::string& buffer) {

	const size_t size = receiveRaw(m_buffer, sizeof(m_buffer));
	buffer = utility::stringUtils::makeStringFromBytes(m_buffer, size);
}


size_t posixSocket::receiveRaw(byte_t* buffer, const size_t count) {

	m_status &= ~STATUS_WOULDBLOCK;

	// Check whether data is available
	if (!waitForRead(50 /* msecs */)) {

		m_status |= STATUS_WOULDBLOCK;

		// Continue waiting for data
		return 0;
	}

	// Read available data
	ssize_t ret = ::recv(m_desc, buffer, count, 0);

	if (ret < 0) {

		if (!IS_EAGAIN(errno)) {
			throwSocketError(errno);
		}

		// Check if we are timed out
		if (m_timeoutHandler &&
		    m_timeoutHandler->isTimeOut()) {

			if (!m_timeoutHandler->handleTimeOut()) {

				// Server did not react within timeout delay
				throwSocketError(errno);

			} else {

				// Reset timeout
				m_timeoutHandler->resetTimeOut();
			}
		}

		m_status |= STATUS_WOULDBLOCK;

		// No data available at this time
		return 0;

	} else if (ret == 0) {

		// Host shutdown
		throwSocketError(ENOTCONN);

	} else {

		// Data received, reset timeout
		if (m_timeoutHandler) {
			m_timeoutHandler->resetTimeOut();
		}
	}

	return ret;
}


void posixSocket::send(const vmime::string& buffer) {

	sendRaw(reinterpret_cast <const byte_t*>(buffer.data()), buffer.length());
}


void posixSocket::send(const char* str) {

	sendRaw(reinterpret_cast <const byte_t*>(str), ::strlen(str));
}


void posixSocket::sendRaw(const byte_t* buffer, const size_t count) {

	m_status &= ~STATUS_WOULDBLOCK;

	size_t size = count;

	while (size > 0) {

#if VMIME_HAVE_MSG_NOSIGNAL
		const ssize_t ret = ::send(m_desc, buffer, size, MSG_NOSIGNAL);
#else
		const ssize_t ret = ::send(m_desc, buffer, size, 0);
#endif

		if (ret <= 0) {

			if (ret < 0 && !IS_EAGAIN(errno)) {
				throwSocketError(errno);
			}

			waitForWrite(50 /* msecs */);

		} else {

			buffer += ret;
			size -= ret;
		}
	}

	// Reset timeout
	if (m_timeoutHandler) {
		m_timeoutHandler->resetTimeOut();
	}
}


size_t posixSocket::sendRawNonBlocking(const byte_t* buffer, const size_t count) {

	m_status &= ~STATUS_WOULDBLOCK;

#if VMIME_HAVE_MSG_NOSIGNAL
	const ssize_t ret = ::send(m_desc, buffer, count, MSG_NOSIGNAL);
#else
	const ssize_t ret = ::send(m_desc, buffer, count, 0);
#endif

	if (ret <= 0) {

		if (ret < 0 && !IS_EAGAIN(errno)) {
			throwSocketError(errno);
		}

		// Check if we are timed out
		if (m_timeoutHandler &&
		    m_timeoutHandler->isTimeOut()) {

			if (!m_timeoutHandler->handleTimeOut()) {

				// Could not send data within timeout delay
				throw exceptions::operation_timed_out();

			} else {

				// Reset timeout
				m_timeoutHandler->resetTimeOut();
			}
		}

		m_status |= STATUS_WOULDBLOCK;

		// No data can be written at this time
		return 0;
	}

	// Reset timeout
	if (m_timeoutHandler) {
		m_timeoutHandler->resetTimeOut();
	}

	return ret;
}


void posixSocket::throwSocketError(const int err) {

	const char* msg = NULL;

	switch (err) {

		case EACCES:          msg = "EACCES: permission denied"; break;
		case EAFNOSUPPORT:    msg = "EAFNOSUPPORT: address family not supported"; break;
		case EMFILE:          msg = "EMFILE: process file table overflow"; break;
		case ENFILE:          msg = "ENFILE: system limit reached"; break;
		case EPROTONOSUPPORT: msg = "EPROTONOSUPPORT: protocol not supported"; break;
		case EAGAIN:          msg = "EGAIN: blocking operation"; break;
		case EBADF:           msg = "EBADF: invalid descriptor"; break;
		case ECONNRESET:      msg = "ECONNRESET: connection reset by peer"; break;
		case EFAULT:          msg = "EFAULT: bad user space address"; break;
		case EINTR:           msg = "EINTR: signal occurred before transmission"; break;
		case EINVAL:          msg = "EINVAL: invalid argument"; break;
		case EMSGSIZE:        msg = "EMSGSIZE: message cannot be sent atomically"; break;
		case ENOBUFS:         msg = "ENOBUFS: output queue is full"; break;
		case ENOMEM:          msg = "ENOMEM: out of memory"; break;
		case EPIPE:           msg = "EPIPE: broken pipe"; break;
		case ENOTCONN:        msg = "ENOTCONN: not connected"; break;
		case ECONNREFUSED:    msg = "ECONNREFUSED: connection refused"; break;
	}

	if (msg) {

		throw exceptions::socket_exception(msg);

	} else {

		// Use strerror() to get string describing error number

#if VMIME_HAVE_STRERROR_R

		char errbuf[512];

		throw exceptions::socket_exception(
			vmime_strerror_r_result(
				strerror_r(err, errbuf, sizeof(errbuf)),
				errbuf
			)
		);

#else  // !VMIME_HAVE_STRERROR_R

		const std::string strmsg(strerror(err));
		throw exceptions::socket_exception(strmsg);

#endif  // VMIME_HAVE_STRERROR_R

	}
}


unsigned int posixSocket::getStatus() const {

	return m_status;
}


shared_ptr <net::timeoutHandler> posixSocket::getTimeoutHandler() {

	return m_timeoutHandler;
}


void posixSocket::setTracer(const shared_ptr <net::tracer>& tracer) {

	m_tracer = tracer;
}


shared_ptr <net::tracer> posixSocket::getTracer() {

	return m_tracer;
}



//
// posixSocketFactory
//

shared_ptr <vmime::net::socket> posixSocketFactory::create() {

	shared_ptr <vmime::net::timeoutHandler> th;
	return make_shared <posixSocket>(th);
}


shared_ptr <vmime::net::socket> posixSocketFactory::create(const shared_ptr <vmime::net::timeoutHandler>& th) {

	return make_shared <posixSocket>(th);
}


} // posix
} // platforms
} // vmime


#endif // VMIME_PLATFORM_IS_POSIX && VMIME_HAVE_MESSAGING_FEATURES