zhangyang-libzt/src/libzt.cpp

/*
 * ZeroTier SDK - Network Virtualization Everywhere
 * Copyright (C) 2011-2018  ZeroTier, Inc.  https://www.zerotier.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 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, see <http://www.gnu.org/licenses/>.
 *
 * --
 *
 * You can be released from the requirements of the license by purchasing
 * a commercial license. Buying such a license is mandatory as soon as you
 * develop commercial closed-source software that incorporates or links
 * directly against ZeroTier software without disclosing the source code
 * of your own application.
 */

/**
 * @file
 *
 * Application-facing, socket-like API
 */

#include "libztDefs.h"

#include "lwip/sockets.h"
#include "lwip/ip_addr.h"
#include "lwip/netdb.h"

#include "libztDebug.h"

#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

int platform_adjusted_socket_family(int family);
void fix_addr_socket_family(struct sockaddr *addr);
bool zts_ready();

int zts_socket(int socket_family, int socket_type, int protocol)
{
	DEBUG_EXTRA("family=%d, type=%d, proto=%d", socket_family, socket_type, protocol);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	int socket_family_adj = platform_adjusted_socket_family(socket_family);
	int err = lwip_socket(socket_family_adj, socket_type, protocol);
	return err;
}

int zts_connect(int fd, const struct sockaddr *addr, socklen_t addrlen)
{
	DEBUG_EXTRA("fd=%d",fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	struct sockaddr_storage ss;
	memcpy(&ss, addr, addrlen);
	fix_addr_socket_family((struct sockaddr*)&ss);
	return lwip_connect(fd, (struct sockaddr*)&ss, addrlen);
}

int zts_bind(int fd, const struct sockaddr *addr, socklen_t addrlen)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	struct sockaddr_storage ss;
	memcpy(&ss, addr, addrlen);
	fix_addr_socket_family((struct sockaddr*)&ss);
	return lwip_bind(fd, (struct sockaddr*)&ss, addrlen);
}

int zts_listen(int fd, int backlog)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_listen(fd, backlog);
}

int zts_accept(int fd, struct sockaddr *addr, socklen_t *addrlen)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_accept(fd, addr, addrlen);
}

#if defined(__linux__)
int zts_accept4(int fd, struct sockaddr *addr, socklen_t *addrlen, int flags)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	// lwip_accept4(fd, addr, addrlen, flags);
	return -1;
}
#endif

int zts_setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen)
{
	DEBUG_EXTRA("fd=%d, level=%d, optname=%d", fd, level, optname);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_setsockopt(fd, level, optname, optval, optlen);
}

int zts_getsockopt(int fd, int level, int optname, void *optval, socklen_t *optlen)
{
	DEBUG_EXTRA("fd=%d, level=%d, optname=%d", fd, level, optname);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_getsockopt(fd, level, optname, optval, optlen);
}

int zts_getsockname(int fd, struct sockaddr *addr, socklen_t *addrlen)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_getsockname(fd, addr, addrlen);
}

int zts_getpeername(int fd, struct sockaddr *addr, socklen_t *addrlen)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_getpeername(fd, addr, addrlen);
}

int zts_gethostname(char *name, size_t len)
{
	DEBUG_EXTRA("");
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return -1;
}

int zts_sethostname(const char *name, size_t len)
{
	DEBUG_EXTRA("");
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return -1;
}

struct hostent *zts_gethostbyname(const char *name)
{
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return NULL;
	}
	// TODO: Test thread safety
	/*
	char buf[256];
	int buflen = 256;
	int h_err = 0;
	struct hostent hret;
	struct hostent **result = NULL;
	int err = 0;
	if ((err = lwip_gethostbyname_r(name, &hret, buf, buflen, result, &h_err)) != 0) {
		DEBUG_ERROR("err = %d", err);
		DEBUG_ERROR("h_err = %d", h_err);
		errno = h_err;
		return NULL; // failure
	}
	return *result;
	
	return lwip_gethostbyname(name);
	*/
	return NULL;
}

int zts_close(int fd)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_close(fd);
}

#if defined(__linux__)
/*
int zts_poll(struct pollfd *fds, nfds_t nfds, int timeout)
{
	DEBUG_ERROR("warning, this is not implemented");
	if (zts_ready() == false) {
		DEBUG_ERROR("service not started yet, call zts_startjoin()");
		return -1;
	}
	return poll(fds, nfds, timeout);
}
*/
#endif

int zts_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
	struct timeval *timeout)
{
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_select(nfds, readfds, writefds, exceptfds, timeout);
}

int zts_fcntl(int fd, int cmd, int flags)
{
	DEBUG_EXTRA("fd=%d, cmd=%d, flags=%d", fd, cmd, flags);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	// translation from platform flag values to stack flag values
	int translated_flags = 0;
#if defined(__linux__)
	if (flags == 2048) {
		translated_flags = 1;
	}
#endif
#if defined(__APPLE__)
	if (flags == 4) {
		translated_flags = 1;
	}
#endif
	return lwip_fcntl(fd, cmd, translated_flags);
}

int zts_ioctl(int fd, unsigned long request, void *argp)
{
	DEBUG_EXTRA("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_ioctl(fd, request, argp);
}

ssize_t zts_sendto(int fd, const void *buf, size_t len, int flags,
	const struct sockaddr *addr, socklen_t addrlen)
{
	DEBUG_TRANS("fd=%d, len=%zu", fd, len);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	struct sockaddr_storage ss;
	memcpy(&ss, addr, addrlen);
	fix_addr_socket_family((struct sockaddr*)&ss);
	return lwip_sendto(fd, buf, len, flags, (struct sockaddr*)&ss, addrlen);
}

ssize_t zts_send(int fd, const void *buf, size_t len, int flags)
{
	DEBUG_TRANS("fd=%d, len=%zu", fd, len);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_send(fd, buf, len, flags);
}

ssize_t zts_sendmsg(int fd, const struct msghdr *msg, int flags)
{
	DEBUG_TRANS("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_sendmsg(fd, msg, flags);
}

ssize_t zts_recv(int fd, void *buf, size_t len, int flags)
{
	DEBUG_TRANS("fd=%d, len=%zu", fd, len);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_recv(fd, buf, len, flags);
}

ssize_t zts_recvfrom(int fd, void *buf, size_t len, int flags,
	struct sockaddr *addr, socklen_t *addrlen)
{
	DEBUG_TRANS("fd=%d, len=%zu", fd, len);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_recvfrom(fd, buf, len, flags, addr, addrlen);
}

ssize_t zts_recvmsg(int fd, struct msghdr *msg, int flags)
{
	DEBUG_TRANS("fd=%d", fd);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return -1; // lwip_recvmsg(fd, msg, flags);
	// Not currently implemented by stack
}

int zts_read(int fd, void *buf, size_t len)
{
	DEBUG_TRANS("fd=%d, len=%zu", fd, len);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_read(fd, buf, len);
}

int zts_write(int fd, const void *buf, size_t len)
{
	DEBUG_TRANS("fd=%d, len=%zu", fd, len);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_write(fd, buf, len);
}

int zts_shutdown(int fd, int how)
{
	DEBUG_EXTRA("fd=%d, how=%d", fd, how);
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	return lwip_shutdown(fd, how);
}

int zts_add_dns_nameserver(struct sockaddr *addr)
{
	DEBUG_EXTRA("");
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	// TODO
	return -1;
}

int zts_del_dns_nameserver(struct sockaddr *addr)
{
	DEBUG_EXTRA("");
	if (zts_ready() == false) {
		DEBUG_ERROR(LIBZT_SERVICE_NOT_STARTED_STR);
		return -1;
	}
	// TODO
	return -1;
}

/* The rationale for the following correctional methods is as follows:

	Since we don't want the user of this library to worry about naming conflicts
	with their native OS/platform's socket facilities we deliberately isolate what
	is used by the userspace network stack and stack drivers from the user's
	application. As a result of this, we must compensate for a few things on our
	side. For instance, differing values for AF_INET6 on major operating systems, and
	differing structure definitions for sockaddr.
*/

/* adjust socket_family value (when AF_INET6) for various platforms:
	linux  : 10
	macOS  : 30
	windows: 23
*/
int platform_adjusted_socket_family(int family)
{
#if defined(__linux__)
	return family; // do nothing
#endif
#if defined(__APPLE__)
	 return family == 30 ? AF_INET6 : family; // 10
#endif
#if defined(_WIN32)
	 if (family == 23) {
		 return AF_INET6;
	 }
	 if (family == 2) {
		 return AF_INET;
	 }
	 return -1;
#endif
}

void fix_addr_socket_family(struct sockaddr *addr)
{
#if defined(__linux__) || defined(_WIN32)
	/* struct sockaddr on Linux and Windows don't contain an sa_len field
	so we must adjust it here before feeding it into the stack. */
	if (addr->sa_len == 2) {
		if (addr->sa_family == 0) {
			addr->sa_family = addr->sa_len;
			addr->sa_len = 0;
		}
	}
	if (addr->sa_len == 10 || addr->sa_len == 23 || addr->sa_len == 30) {
		if (addr->sa_family == 0) {
			addr->sa_family = addr->sa_len;
			addr->sa_len = 0;
		}
	}
	/* once we've moved the value to its anticipated location, convert it from
	its platform-specific value to one that the network stack can work with */
#endif
	addr->sa_family = platform_adjusted_socket_family(addr->sa_family);
}

#ifdef __cplusplus
}
#endif