haiku.git

// NetAddress.cpp

#include <new>
#include <compatibility/bsd/features.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>

#if defined(HAIKU_TARGET_PLATFORM_DANO) || defined(HAIKU_TARGET_PLATFORM_DANO)
#	include <net/route.h>
#	include <sys/sockio.h>
#	include <stdlib.h>
#endif

#include <AutoLocker.h>
#include <ByteOrder.h>
#include <HashString.h>
#include <Referenceable.h>

#include "Compatibility.h"
#include "Locker.h"
#include "NetAddress.h"

// constructor
NetAddress::NetAddress()
{
	fAddress.sin_family = AF_INET;
	fAddress.sin_addr.s_addr = 0;
	fAddress.sin_port = 0;
}

// constructor
NetAddress::NetAddress(const sockaddr_in& address)
{
	fAddress = address;
}

// copy constructor
NetAddress::NetAddress(const NetAddress& address)
{
	fAddress = address.fAddress;
}

// SetIP
void
NetAddress::SetIP(int32 address)
{
	fAddress.sin_addr.s_addr = B_HOST_TO_BENDIAN_INT32(address);
}

// GetIP
int32
NetAddress::GetIP() const
{
	return B_BENDIAN_TO_HOST_INT32(fAddress.sin_addr.s_addr);
}

// SetPort
void
NetAddress::SetPort(uint16 port)
{
	fAddress.sin_port = B_HOST_TO_BENDIAN_INT32(port);
}

// GetPort
uint16
NetAddress::GetPort() const
{
	return B_BENDIAN_TO_HOST_INT16(fAddress.sin_port);
}

// SetAddress
void
NetAddress::SetAddress(const sockaddr_in& address)
{
	fAddress = address;
}

// GetAddress
const sockaddr_in&
NetAddress::GetAddress() const
{
	return fAddress;
}

// IsLocal
bool
NetAddress::IsLocal() const
{
	// special address?
	if (fAddress.sin_addr.s_addr == INADDR_ANY
		|| fAddress.sin_addr.s_addr == INADDR_BROADCAST) {
		return false;
	}
	// create a socket and try to bind it to a port of this address
	int fd = socket(AF_INET, SOCK_DGRAM, 0);
	if (fd < 0)
		return false;
#if defined(HAIKU_TARGET_PLATFORM_DANO)
	// BONE does allow you to bind to any address!
	// Therefore, we iterate over all routes, and see if there are any local
	// ones for this address.

	bool result = false;
	uint32 count;
	if (ioctl(fd, SIOCGRTSIZE, &count) == 0) {
		route_req_t* routes = (route_req_t*)malloc(count * sizeof(route_req_t));
		if (routes != NULL) {
			route_table_req table;
			table.rrtp = routes;
			table.len = count * sizeof(route_req_t);
			table.cnt = count;
			if (ioctl(fd, SIOCGRTTABLE, &table) == 0) {
				for (uint32 i = 0; i < table.cnt; i++) {
					if ((routes[i].flags & RTF_LOCAL) == 0)
						continue;
					if (((sockaddr_in*)&routes[i].dst)->sin_addr.s_addr
							== fAddress.sin_addr.s_addr) {
						result = true;
						break;
					}
				}
			}
			free(routes);
		}
	}
#else
	// bind it to a port
	sockaddr_in addr = fAddress;
	addr.sin_port = 0;
	bool result = (bind(fd, (sockaddr*)&addr, sizeof(addr)) == 0);
#endif
	closesocket(fd);

	return result;
}


// GetString
status_t
NetAddress::GetString(HashString* string, bool includePort) const
{
	if (!string)
		return B_BAD_VALUE;
	char buffer[32];
	uint32 ip = GetIP();
	if (includePort) {
		sprintf(buffer, "%" B_PRIu32 ".%" B_PRIu32 ".%" B_PRIu32 ".%" B_PRIu32
			":%hu", ip >> 24, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff,
			GetPort());
	} else {
		sprintf(buffer, "%" B_PRIu32 ".%" B_PRIu32 ".%" B_PRIu32 ".%" B_PRIu32,
			ip >> 24, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
	}
	return (string->SetTo(buffer) ? B_OK : B_NO_MEMORY);
}

// GetHashCode
uint32
NetAddress::GetHashCode() const
{
	return (fAddress.sin_addr.s_addr * 31 + fAddress.sin_port);
}

// =
NetAddress&
NetAddress::operator=(const NetAddress& address)
{
	fAddress = address.fAddress;
	return *this;
}

// ==
bool
NetAddress::operator==(const NetAddress& address) const
{
	return (fAddress.sin_addr.s_addr == address.fAddress.sin_addr.s_addr
		&& fAddress.sin_port == address.fAddress.sin_port);
}

// !=
bool
NetAddress::operator!=(const NetAddress& address) const
{
	return !(*this == address);
}


// #pragma mark -

// Resolver
class NetAddressResolver::Resolver : public BReferenceable {
public:
	Resolver()
		: BReferenceable(),
		  fLock()
	{
	}

	status_t InitCheck() const
	{
		return fLock.InitCheck();
	}

	status_t GetHostAddress(const char* hostName, NetAddress* address)
	{
		AutoLocker<Locker> _(fLock);
		struct hostent* host = gethostbyname(hostName);
		if (!host)
			return h_errno;
		if (host->h_addrtype != AF_INET || !host->h_addr_list[0])
			return B_BAD_VALUE;
		sockaddr_in addr;
		addr.sin_family = AF_INET;
		addr.sin_port = 0;
		addr.sin_addr = *(in_addr*)host->h_addr_list[0];
		*address = addr;
		return B_OK;
	}

protected:
	virtual void LastReferenceReleased()
	{
		// don't delete
	}

private:
	Locker	fLock;
};

// constructor
NetAddressResolver::NetAddressResolver()
{
	_Lock();
	// initialize static instance, if not done yet
	if (sResolver) {
		sResolver->AcquireReference();
		fResolver = sResolver;
	} else {
		sResolver = new(std::nothrow) Resolver;
		if (sResolver) {
			if (sResolver->InitCheck() != B_OK) {
				delete sResolver;
				sResolver = NULL;
			}
		}
		fResolver = sResolver;
	}
	_Unlock();
}

// destructor
NetAddressResolver::~NetAddressResolver()
{
	if (fResolver) {
		_Lock();
		if (sResolver->ReleaseReference() == 1) {
			delete sResolver;
			sResolver = NULL;
		}
		_Unlock();
	}
}

// InitCheck
status_t
NetAddressResolver::InitCheck() const
{
	return (fResolver ? B_OK : B_NO_INIT);
}

// GetAddress
status_t
NetAddressResolver::GetHostAddress(const char* hostName, NetAddress* address)
{
	if (!fResolver)
		return B_NO_INIT;
	if (!hostName || !address)
		return B_BAD_VALUE;
	return fResolver->GetHostAddress(hostName, address);
}

// _Lock
void
NetAddressResolver::_Lock()
{
	while (atomic_add(&sLockCounter, 1) > 0) {
		atomic_add(&sLockCounter, -1);
		snooze(10000);
	}
}

// _Unlock
void
NetAddressResolver::_Unlock()
{
	atomic_add(&sLockCounter, -1);
}


// sResolver
NetAddressResolver::Resolver* volatile NetAddressResolver::sResolver = NULL;

// sLockCounter
int32 NetAddressResolver::sLockCounter = 0;