barrier/lib/arch/CArchNetworkBSD.cpp

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package 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.
 */

#include "CArchNetworkBSD.h"
#include "CArch.h"
#include "CArchMultithreadPosix.h"
#include "XArchUnix.h"
#if HAVE_UNISTD_H
#	include <unistd.h>
#endif
#include <netinet/in.h>
#include <netdb.h>
#if !defined(TCP_NODELAY)
#	include <netinet/tcp.h>
#endif
#include <arpa/inet.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

#if HAVE_POLL
#	include <poll.h>
#else
#	if HAVE_SYS_SELECT_H
#		include <sys/select.h>
#	endif
#	if HAVE_SYS_TIME_H
#		include <sys/time.h>
#	endif
#endif

#if !HAVE_INET_ATON
#	include <stdio.h>
#endif

static const int s_family[] = {
	PF_UNSPEC,
	PF_INET
};
static const int s_type[] = {
	SOCK_DGRAM,
	SOCK_STREAM
};

#if !HAVE_INET_ATON
// parse dotted quad addresses.  we don't bother with the weird BSD'ism
// of handling octal and hex and partial forms.
static
in_addr_t
inet_aton(const char* cp, struct in_addr* inp)
{
	unsigned int a, b, c, d;
	if (sscanf(cp, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) {
		return 0;
	}
	if (a >= 256 || b >= 256 || c >= 256 || d >= 256) {
		return 0;
	}
	unsigned char* incp = (unsigned char*)inp;
	incp[0] = (unsigned char)(a & 0xffu);
	incp[1] = (unsigned char)(b & 0xffu);
	incp[2] = (unsigned char)(c & 0xffu);
	incp[3] = (unsigned char)(d & 0xffu);
	return inp->s_addr;
}
#endif

//
// CArchNetworkBSD
//

CArchNetworkBSD::CArchNetworkBSD()
{
	// create mutex to make some calls thread safe
	m_mutex = ARCH->newMutex();
}

CArchNetworkBSD::~CArchNetworkBSD()
{
	ARCH->closeMutex(m_mutex);
}

CArchSocket
CArchNetworkBSD::newSocket(EAddressFamily family, ESocketType type)
{
	// create socket
	int fd = socket(s_family[family], s_type[type], 0);
	if (fd == -1) {
		throwError(errno);
	}
	try {
		setBlockingOnSocket(fd, false);
	}
	catch (...) {
		close(fd);
		throw;
	}

	// allocate socket object
	CArchSocketImpl* newSocket = new CArchSocketImpl;
	newSocket->m_fd            = fd;
	newSocket->m_refCount      = 1;
	return newSocket;
}

CArchSocket
CArchNetworkBSD::copySocket(CArchSocket s)
{
	assert(s != NULL);

	// ref the socket and return it
	ARCH->lockMutex(m_mutex);
	++s->m_refCount;
	ARCH->unlockMutex(m_mutex);
	return s;
}

void
CArchNetworkBSD::closeSocket(CArchSocket s)
{
	assert(s != NULL);

	// unref the socket and note if it should be released
	ARCH->lockMutex(m_mutex);
	const bool doClose = (--s->m_refCount == 0);
	ARCH->unlockMutex(m_mutex);

	// close the socket if necessary
	if (doClose) {
		if (close(s->m_fd) == -1) {
			// close failed.  restore the last ref and throw.
			int err = errno;
			ARCH->lockMutex(m_mutex);
			++s->m_refCount;
			ARCH->unlockMutex(m_mutex);
			throwError(err);
		}
		delete s;
	}
}

void
CArchNetworkBSD::closeSocketForRead(CArchSocket s)
{
	assert(s != NULL);

	if (shutdown(s->m_fd, 0) == -1) {
		if (errno != ENOTCONN) {
			throwError(errno);
		}
	}
}

void
CArchNetworkBSD::closeSocketForWrite(CArchSocket s)
{
	assert(s != NULL);

	if (shutdown(s->m_fd, 1) == -1) {
		if (errno != ENOTCONN) {
			throwError(errno);
		}
	}
}

void
CArchNetworkBSD::bindSocket(CArchSocket s, CArchNetAddress addr)
{
	assert(s    != NULL);
	assert(addr != NULL);

	if (bind(s->m_fd, &addr->m_addr, addr->m_len) == -1) {
		throwError(errno);
	}
}

void
CArchNetworkBSD::listenOnSocket(CArchSocket s)
{
	assert(s != NULL);

	// hardcoding backlog
	if (listen(s->m_fd, 3) == -1) {
		throwError(errno);
	}
}

CArchSocket
CArchNetworkBSD::acceptSocket(CArchSocket s, CArchNetAddress* addr)
{
	assert(s != NULL);

	// if user passed NULL in addr then use scratch space
	CArchNetAddress dummy;
	if (addr == NULL) {
		addr = &dummy;
	}

	// create new socket and address
	CArchSocketImpl* newSocket = new CArchSocketImpl;
	*addr                      = new CArchNetAddressImpl;

	// accept on socket
	ACCEPT_TYPE_ARG3 len = (ACCEPT_TYPE_ARG3)((*addr)->m_len);
	int fd = accept(s->m_fd, &(*addr)->m_addr, &len);
	(*addr)->m_len = (socklen_t)len;
	if (fd == -1) {
		int err = errno;
		delete newSocket;
		delete *addr;
		*addr = NULL;
		if (err == EAGAIN) {
			return NULL;
		}
		throwError(err);
	}

	try {
		setBlockingOnSocket(fd, false);
	}
	catch (...) {
		close(fd);
		delete newSocket;
		delete *addr;
		*addr = NULL;
		throw;
	}

	// initialize socket
	newSocket->m_fd       = fd;
	newSocket->m_refCount = 1;

	// discard address if not requested
	if (addr == &dummy) {
		ARCH->closeAddr(dummy);
	}

	return newSocket;
}

bool
CArchNetworkBSD::connectSocket(CArchSocket s, CArchNetAddress addr)
{
	assert(s    != NULL);
	assert(addr != NULL);

	if (connect(s->m_fd, &addr->m_addr, addr->m_len) == -1) {
		if (errno == EISCONN) {
			return true;
		}
		if (errno == EINPROGRESS) {
			return false;
		}
		throwError(errno);
	}
	return true;
}

#if HAVE_POLL

int
CArchNetworkBSD::pollSocket(CPollEntry pe[], int num, double timeout)
{
	assert(pe != NULL || num == 0);

	// return if nothing to do
	if (num == 0) {
		if (timeout > 0.0) {
			ARCH->sleep(timeout);
		}
		return 0;
	}

	// allocate space for translated query
	struct pollfd* pfd = new struct pollfd[1 + num];

	// translate query
	for (int i = 0; i < num; ++i) {
		pfd[i].fd     = (pe[i].m_socket == NULL) ? -1 : pe[i].m_socket->m_fd;
		pfd[i].events = 0;
		if ((pe[i].m_events & kPOLLIN) != 0) {
			pfd[i].events |= POLLIN;
		}
		if ((pe[i].m_events & kPOLLOUT) != 0) {
			pfd[i].events |= POLLOUT;
		}
	}
	int n = num;

	// add the unblock pipe
	const int* unblockPipe = getUnblockPipe();
	if (unblockPipe != NULL) {
		pfd[n].fd     = unblockPipe[0];
		pfd[n].events = POLLIN;
		++n;
	}

	// prepare timeout
	int t = (timeout < 0.0) ? -1 : static_cast<int>(1000.0 * timeout);

	// do the poll
	n = poll(pfd, n, t);

	// reset the unblock pipe
	if (n > 0 && unblockPipe != NULL && (pfd[num].revents & POLLIN) != 0) {
		// the unblock event was signalled.  flush the pipe.
		char dummy[100];
		do {
			read(unblockPipe[0], dummy, sizeof(dummy));
		} while (errno != EAGAIN);

		// don't count this unblock pipe in return value
		--n;
	}

	// handle results
	if (n == -1) {
		if (errno == EINTR) {
			// interrupted system call
			ARCH->testCancelThread();
			delete[] pfd;
			return 0;
		}
		delete[] pfd;
		throwError(errno);
	}

	// translate back
	for (int i = 0; i < num; ++i) {
		pe[i].m_revents = 0;
		if ((pfd[i].revents & POLLIN) != 0) {
			pe[i].m_revents |= kPOLLIN;
		}
		if ((pfd[i].revents & POLLOUT) != 0) {
			pe[i].m_revents |= kPOLLOUT;
		}
		if ((pfd[i].revents & POLLERR) != 0) {
			pe[i].m_revents |= kPOLLERR;
		}
		if ((pfd[i].revents & POLLNVAL) != 0) {
			pe[i].m_revents |= kPOLLNVAL;
		}
	}

	delete[] pfd;
	return n;
}

#else

int
CArchNetworkBSD::pollSocket(CPollEntry pe[], int num, double timeout)
{
	int i, n;

	// prepare sets for select
	n = 0;
	fd_set readSet, writeSet, errSet;
	fd_set* readSetP  = NULL;
	fd_set* writeSetP = NULL;
	fd_set* errSetP   = NULL;
	FD_ZERO(&readSet);
	FD_ZERO(&writeSet);
	FD_ZERO(&errSet);
	for (i = 0; i < num; ++i) {
		// reset return flags
		pe[i].m_revents = 0;

		// set invalid flag if socket is bogus then go to next socket
		if (pe[i].m_socket == NULL) {
			pe[i].m_revents |= kPOLLNVAL;
			continue;
		}

		int fdi = pe[i].m_socket->m_fd;
		if (pe[i].m_events & kPOLLIN) {
			FD_SET(pe[i].m_socket->m_fd, &readSet);
			readSetP = &readSet;
			if (fdi > n) {
				n = fdi;
			}
		}
		if (pe[i].m_events & kPOLLOUT) {
			FD_SET(pe[i].m_socket->m_fd, &writeSet);
			writeSetP = &writeSet;
			if (fdi > n) {
				n = fdi;
			}
		}
		if (true) {
			FD_SET(pe[i].m_socket->m_fd, &errSet);
			errSetP = &errSet;
			if (fdi > n) {
				n = fdi;
			}
		}
	}

	// add the unblock pipe
	const int* unblockPipe = getUnblockPipe();
	if (unblockPipe != NULL) {
		FD_SET(unblockPipe[0], &readSet);
		readSetP = &readSet;
		if (unblockPipe[0] > n) {
			n = unblockPipe[0];
		}
	}

	// if there are no sockets then don't block forever
	if (n == 0 && timeout < 0.0) {
		timeout = 0.0;
	}

	// prepare timeout for select
	struct timeval timeout2;
	struct timeval* timeout2P;
	if (timeout < 0.0) {
		timeout2P = NULL;
	}
	else {
		timeout2P = &timeout2;
		timeout2.tv_sec  = static_cast<int>(timeout);
		timeout2.tv_usec = static_cast<int>(1.0e+6 *
										(timeout - timeout2.tv_sec));
	}

	// do the select
	n = select((SELECT_TYPE_ARG1)  n + 1,
				SELECT_TYPE_ARG234 readSetP,
				SELECT_TYPE_ARG234 writeSetP,
				SELECT_TYPE_ARG234 errSetP,
				SELECT_TYPE_ARG5   timeout2P);

	// reset the unblock pipe
	if (n > 0 && unblockPipe != NULL && FD_ISSET(unblockPipe[0], &readSet)) {
		// the unblock event was signalled.  flush the pipe.
		char dummy[100];
		do {
			read(unblockPipe[0], dummy, sizeof(dummy));
		} while (errno != EAGAIN);
	}

	// handle results
	if (n == -1) {
		if (errno == EINTR) {
			// interrupted system call
			ARCH->testCancelThread();
			return 0;
		}
		throwError(errno);
	}
	n = 0;
	for (i = 0; i < num; ++i) {
		if (pe[i].m_socket != NULL) {
			if (FD_ISSET(pe[i].m_socket->m_fd, &readSet)) {
				pe[i].m_revents |= kPOLLIN;
			}
			if (FD_ISSET(pe[i].m_socket->m_fd, &writeSet)) {
				pe[i].m_revents |= kPOLLOUT;
			}
			if (FD_ISSET(pe[i].m_socket->m_fd, &errSet)) {
				pe[i].m_revents |= kPOLLERR;
			}
		}
		if (pe[i].m_revents != 0) {
			++n;
		}
	}

	return n;
}

#endif

void
CArchNetworkBSD::unblockPollSocket(CArchThread thread)
{
	const int* unblockPipe = getUnblockPipeForThread(thread);
	if (unblockPipe != NULL) {
		char dummy = 0;
		write(unblockPipe[1], &dummy, 1);
	}
}

size_t
CArchNetworkBSD::readSocket(CArchSocket s, void* buf, size_t len)
{
	assert(s != NULL);

	ssize_t n = read(s->m_fd, buf, len);
	if (n == -1) {
		if (errno == EINTR || errno == EAGAIN) {
			return 0;
		}
		throwError(errno);
	}
	return n;
}

size_t
CArchNetworkBSD::writeSocket(CArchSocket s, const void* buf, size_t len)
{
	assert(s != NULL);

	ssize_t n = write(s->m_fd, buf, len);
	if (n == -1) {
		if (errno == EINTR || errno == EAGAIN) {
			return 0;
		}
		throwError(errno);
	}
	return n;
}

void
CArchNetworkBSD::throwErrorOnSocket(CArchSocket s)
{
	assert(s != NULL);

	// get the error from the socket layer
	int err        = 0;
	socklen_t size = (socklen_t)sizeof(err);
	if (getsockopt(s->m_fd, SOL_SOCKET, SO_ERROR,
							(optval_t*)&err, &size) == -1) {
		err = errno;
	}

	// throw if there's an error
	if (err != 0) {
		throwError(err);
	}
}

void
CArchNetworkBSD::setBlockingOnSocket(int fd, bool blocking)
{
	assert(fd != -1);

	int mode = fcntl(fd, F_GETFL, 0);
	if (mode == -1) {
		throwError(errno);
	}
	if (blocking) {
		mode &= ~O_NONBLOCK;
	}
	else {
		mode |= O_NONBLOCK;
	}
	if (fcntl(fd, F_SETFL, mode) == -1) {
		throwError(errno);
	}
}

bool
CArchNetworkBSD::setNoDelayOnSocket(CArchSocket s, bool noDelay)
{
	assert(s != NULL);

	// get old state
	int oflag;
	socklen_t size = (socklen_t)sizeof(oflag);
	if (getsockopt(s->m_fd, IPPROTO_TCP, TCP_NODELAY,
							(optval_t*)&oflag, &size) == -1) {
		throwError(errno);
	}

	int flag = noDelay ? 1 : 0;
	size     = (socklen_t)sizeof(flag);
	if (setsockopt(s->m_fd, IPPROTO_TCP, TCP_NODELAY,
							(optval_t*)&flag, size) == -1) {
		throwError(errno);
	}

	return (oflag != 0);
}

bool
CArchNetworkBSD::setReuseAddrOnSocket(CArchSocket s, bool reuse)
{
	assert(s != NULL);

	// get old state
	int oflag;
	socklen_t size = (socklen_t)sizeof(oflag);
	if (getsockopt(s->m_fd, SOL_SOCKET, SO_REUSEADDR,
							(optval_t*)&oflag, &size) == -1) {
		throwError(errno);
	}

	int flag = reuse ? 1 : 0;
	size     = (socklen_t)sizeof(flag);
	if (setsockopt(s->m_fd, SOL_SOCKET, SO_REUSEADDR,
							(optval_t*)&flag, size) == -1) {
		throwError(errno);
	}

	return (oflag != 0);
}

std::string
CArchNetworkBSD::getHostName()
{
	char name[256];
	if (gethostname(name, sizeof(name)) == -1) {
		name[0] = '\0';
	}
	else {
		name[sizeof(name) - 1] = '\0';
	}
	return name;
}

CArchNetAddress
CArchNetworkBSD::newAnyAddr(EAddressFamily family)
{
	// allocate address
	CArchNetAddressImpl* addr = new CArchNetAddressImpl;

	// fill it in
	switch (family) {
	case kINET: {
		struct sockaddr_in* ipAddr =
			reinterpret_cast<struct sockaddr_in*>(&addr->m_addr);
		ipAddr->sin_family         = AF_INET;
		ipAddr->sin_port           = 0;
		ipAddr->sin_addr.s_addr    = INADDR_ANY;
		addr->m_len                = (socklen_t)sizeof(struct sockaddr_in);
		break;
	}

	default:
		delete addr;
		assert(0 && "invalid family");
	}

	return addr;
}

CArchNetAddress
CArchNetworkBSD::copyAddr(CArchNetAddress addr)
{
	assert(addr != NULL);

	// allocate and copy address
	return new CArchNetAddressImpl(*addr);
}

CArchNetAddress
CArchNetworkBSD::nameToAddr(const std::string& name)
{
	// allocate address
	CArchNetAddressImpl* addr = new CArchNetAddressImpl;

	// try to convert assuming an IPv4 dot notation address
	struct sockaddr_in inaddr;
	memset(&inaddr, 0, sizeof(inaddr));
	if (inet_aton(name.c_str(), &inaddr.sin_addr) != 0) {
		// it's a dot notation address
		addr->m_len       = (socklen_t)sizeof(struct sockaddr_in);
		inaddr.sin_family = AF_INET;
		inaddr.sin_port   = 0;
		memcpy(&addr->m_addr, &inaddr, addr->m_len);
	}

	else {
		// mutexed address lookup (ugh)
		ARCH->lockMutex(m_mutex);
		struct hostent* info = gethostbyname(name.c_str());
		if (info == NULL) {
			ARCH->unlockMutex(m_mutex);
			delete addr;
			throwNameError(h_errno);
		}

		// copy over address (only IPv4 currently supported)
		if (info->h_addrtype == AF_INET) {
			addr->m_len       = (socklen_t)sizeof(struct sockaddr_in);
			inaddr.sin_family = info->h_addrtype;
			inaddr.sin_port   = 0;
			memcpy(&inaddr.sin_addr, info->h_addr_list[0],
								sizeof(inaddr.sin_addr));
			memcpy(&addr->m_addr, &inaddr, addr->m_len);
		}
		else {
			ARCH->unlockMutex(m_mutex);
			delete addr;
			throw XArchNetworkNameUnsupported(
					"The requested name is valid but "
					"does not have a supported address family");
		}

		// done with static buffer
		ARCH->unlockMutex(m_mutex);
	}

	return addr;
}

void
CArchNetworkBSD::closeAddr(CArchNetAddress addr)
{
	assert(addr != NULL);

	delete addr;
}

std::string
CArchNetworkBSD::addrToName(CArchNetAddress addr)
{
	assert(addr != NULL);

	// mutexed name lookup (ugh)
	ARCH->lockMutex(m_mutex);
	struct hostent* info = gethostbyaddr(
							reinterpret_cast<const char*>(&addr->m_addr),
							addr->m_len, addr->m_addr.sa_family);
	if (info == NULL) {
		ARCH->unlockMutex(m_mutex);
		throwNameError(h_errno);
	}

	// save (primary) name
	std::string name = info->h_name;

	// done with static buffer
	ARCH->unlockMutex(m_mutex);

	return name;
}

std::string
CArchNetworkBSD::addrToString(CArchNetAddress addr)
{
	assert(addr != NULL);

	switch (getAddrFamily(addr)) {
	case kINET: {
		struct sockaddr_in* ipAddr =
			reinterpret_cast<struct sockaddr_in*>(&addr->m_addr);
		ARCH->lockMutex(m_mutex);
		std::string s = inet_ntoa(ipAddr->sin_addr);
		ARCH->unlockMutex(m_mutex);
		return s;
	}

	default:
		assert(0 && "unknown address family");
		return "";
	}
}

IArchNetwork::EAddressFamily
CArchNetworkBSD::getAddrFamily(CArchNetAddress addr)
{
	assert(addr != NULL);

	switch (addr->m_addr.sa_family) {
	case AF_INET:
		return kINET;

	default:
		return kUNKNOWN;
	}
}

void
CArchNetworkBSD::setAddrPort(CArchNetAddress addr, int port)
{
	assert(addr != NULL);

	switch (getAddrFamily(addr)) {
	case kINET: {
		struct sockaddr_in* ipAddr =
			reinterpret_cast<struct sockaddr_in*>(&addr->m_addr);
		ipAddr->sin_port = htons(port);
		break;
	}

	default:
		assert(0 && "unknown address family");
		break;
	}
}

int
CArchNetworkBSD::getAddrPort(CArchNetAddress addr)
{
	assert(addr != NULL);

	switch (getAddrFamily(addr)) {
	case kINET: {
		struct sockaddr_in* ipAddr =
			reinterpret_cast<struct sockaddr_in*>(&addr->m_addr);
		return ntohs(ipAddr->sin_port);
	}

	default:
		assert(0 && "unknown address family");
		return 0;
	}
}

bool
CArchNetworkBSD::isAnyAddr(CArchNetAddress addr)
{
	assert(addr != NULL);

	switch (getAddrFamily(addr)) {
	case kINET: {
		struct sockaddr_in* ipAddr =
			reinterpret_cast<struct sockaddr_in*>(&addr->m_addr);
		return (ipAddr->sin_addr.s_addr == INADDR_ANY &&
				addr->m_len == (socklen_t)sizeof(struct sockaddr_in));
	}

	default:
		assert(0 && "unknown address family");
		return true;
	}
}

bool
CArchNetworkBSD::isEqualAddr(CArchNetAddress a, CArchNetAddress b)
{
	return (a->m_len == b->m_len &&
			memcmp(&a->m_addr, &b->m_addr, a->m_len) == 0);
}

const int*
CArchNetworkBSD::getUnblockPipe()
{
	CArchMultithreadPosix* mt = CArchMultithreadPosix::getInstance();
	CArchThread thread        = mt->newCurrentThread();
	const int* p              = getUnblockPipeForThread(thread);
	ARCH->closeThread(thread);
	return p;
}

const int*
CArchNetworkBSD::getUnblockPipeForThread(CArchThread thread)
{
	CArchMultithreadPosix* mt = CArchMultithreadPosix::getInstance();
	int* unblockPipe          = (int*)mt->getNetworkDataForThread(thread);
	if (unblockPipe == NULL) {
		unblockPipe = new int[2];
		if (pipe(unblockPipe) != -1) {
			try {
				setBlockingOnSocket(unblockPipe[0], false);
				mt->setNetworkDataForCurrentThread(unblockPipe);
			}
			catch (...) {
				delete[] unblockPipe;
				unblockPipe = NULL;
			}
		}
		else {
			delete[] unblockPipe;
			unblockPipe = NULL;
		}
	}
	return unblockPipe;
}

void
CArchNetworkBSD::throwError(int err)
{
	switch (err) {
	case EINTR:
		ARCH->testCancelThread();
		throw XArchNetworkInterrupted(new XArchEvalUnix(err));

	case EACCES:
	case EPERM:
		throw XArchNetworkAccess(new XArchEvalUnix(err));

	case ENFILE:
	case EMFILE:
	case ENODEV:
	case ENOBUFS:
	case ENOMEM:
	case ENETDOWN:
#if defined(ENOSR)
	case ENOSR:
#endif
		throw XArchNetworkResource(new XArchEvalUnix(err));

	case EPROTOTYPE:
	case EPROTONOSUPPORT:
	case EAFNOSUPPORT:
	case EPFNOSUPPORT:
	case ESOCKTNOSUPPORT:
	case EINVAL:
	case ENOPROTOOPT:
	case EOPNOTSUPP:
	case ESHUTDOWN:
#if defined(ENOPKG)
	case ENOPKG:
#endif
		throw XArchNetworkSupport(new XArchEvalUnix(err));

	case EIO:
		throw XArchNetworkIO(new XArchEvalUnix(err));

	case EADDRNOTAVAIL:
		throw XArchNetworkNoAddress(new XArchEvalUnix(err));

	case EADDRINUSE:
		throw XArchNetworkAddressInUse(new XArchEvalUnix(err));

	case EHOSTUNREACH:
	case ENETUNREACH:
		throw XArchNetworkNoRoute(new XArchEvalUnix(err));

	case ENOTCONN:
		throw XArchNetworkNotConnected(new XArchEvalUnix(err));

	case EPIPE:
		throw XArchNetworkShutdown(new XArchEvalUnix(err));

	case ECONNABORTED:
	case ECONNRESET:
		throw XArchNetworkDisconnected(new XArchEvalUnix(err));

	case ECONNREFUSED:
		throw XArchNetworkConnectionRefused(new XArchEvalUnix(err));

	case EHOSTDOWN:
	case ETIMEDOUT:
		throw XArchNetworkTimedOut(new XArchEvalUnix(err));

	default:
		throw XArchNetwork(new XArchEvalUnix(err));
	}
}

void
CArchNetworkBSD::throwNameError(int err)
{
	static const char* s_msg[] = {
		"The specified host is unknown",
		"The requested name is valid but does not have an IP address",
		"A non-recoverable name server error occurred",
		"A temporary error occurred on an authoritative name server",
		"An unknown name server error occurred"
	};

	switch (err) {
	case HOST_NOT_FOUND:
		throw XArchNetworkNameUnknown(s_msg[0]);

	case NO_DATA:
		throw XArchNetworkNameNoAddress(s_msg[1]);

	case NO_RECOVERY:
		throw XArchNetworkNameFailure(s_msg[2]);

	case TRY_AGAIN:
		throw XArchNetworkNameUnavailable(s_msg[3]);

	default:
		throw XArchNetworkName(s_msg[4]);
	}
}