/*
 * Copyright 2002-2006,2008, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Scott T. Mansfield, thephantom@mac.com
 *		Oliver Tappe, zooey@hirschkaefer.de
 */

/*!
	NetAddress.cpp -- Implementation of the BNetAddress class.
	Remarks:
	 * In all accessors, non-struct output values are converted from network to
	   host byte order.
	 * In all mutators, non-struct input values are converted from host to
	   network byte order.
	 * No trouts were harmed during the development of this class.
*/

#include <r5_compatibility.h>

#include <ByteOrder.h>
#include <NetAddress.h>
#include <Message.h>

#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <new>
#include <string.h>


BNetAddress::BNetAddress(const char* hostname, unsigned short port)
	:
	fInit(B_NO_INIT)
{
	SetTo(hostname, port);
}


BNetAddress::BNetAddress(const struct sockaddr_in& addr)
	:
	fInit(B_NO_INIT)
{
	SetTo(addr);
}


BNetAddress::BNetAddress(in_addr addr, int port)
	:
	fInit(B_NO_INIT)
{
	SetTo(addr, port);
}


BNetAddress::BNetAddress(uint32 addr, int port)
	:
	fInit(B_NO_INIT)
{
	SetTo(addr, port);
}


BNetAddress::BNetAddress(const char* hostname, const char* protocol,
	const char* service)
	:
	fInit(B_NO_INIT)
{
	SetTo(hostname, protocol, service);
}


BNetAddress::BNetAddress(const BNetAddress& other)
{
	*this = other;
}


BNetAddress::BNetAddress(BMessage* archive)
{
	int16 int16value;
	if (archive->FindInt16("bnaddr_family", &int16value) != B_OK)
		return;

	fFamily = int16value;

	if (archive->FindInt16("bnaddr_port", &int16value) != B_OK)
		return;

	fPort = int16value;

	if (archive->FindInt32("bnaddr_addr", &fAddress) != B_OK)
		return;

	fInit = B_OK;
}


BNetAddress::~BNetAddress()
{
}


BNetAddress&
BNetAddress::operator=(const BNetAddress& other)
{
	fInit = other.fInit;
	fFamily = other.fFamily;
	fPort = other.fPort;
	fAddress = other.fAddress;

	return *this;
}


/* GetAddr
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Class accessor.
 *
 * Output parameters:
 *		hostname:		Host name associated with this instance (default: NULL).
 *						In this particular implementation, hostname will be an
 *						ASCII-fied representation of an IP address.
 *
 *		port:			Port number associated with this instance
 *						(default: NULL).  Will be converted to host byte order
 *						here, so it is not necessary to call ntohs() after
 *						calling this method.
 *
 * Returns:
 *	B_OK for success, B_NO_INIT if instance was not properly constructed.
 *
 * Remarks:
 *		Hostname and/or port can be NULL; although having them both NULL would
 *		be a pointless waste of CPU cycles.  ;-)
 *
 *		The hostname output parameter can be a variety of things, but in this
 *		method we convert the IP address to a string.  See the relevant
 *		documentation about inet_ntoa() for details.
 *
 *		Make sure hostname is large enough or you will step on someone
 *		else's toes.  (Can you say "buffer overflow exploit" boys and girls?)
 *		You can generally be safe using the MAXHOSTNAMELEN define, which
 *		defaults to 64 bytes--don't forget to leave room for the NULL!
 */
status_t
BNetAddress::GetAddr(char* hostname, unsigned short* port) const
{
	if (fInit != B_OK)
		return B_NO_INIT;

	if (port != NULL)
		*port = ntohs(fPort);

	if (hostname != NULL) {
		struct in_addr addr;
		addr.s_addr = fAddress;

		char* text = inet_ntoa(addr);
		if (text != NULL)
			strcpy(hostname, text);
	}

	return B_OK;
}


/* GetAddr
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Class accessor.
 *
 * Output parameter:
 *		sa:					sockaddr_in struct to be filled.
 *
 * Returns:
 *		B_OK for success, B_NO_INIT if instance was not properly constructed.
 *
 * Remarks:
 *		This method fills in the sin_addr, sin_family, and sin_port fields of
 *		the output parameter, all other fields are untouched so we can work
 *		with both POSIX and non-POSIX versions of said struct.  The port and
 *		address values added to the output parameter are in network byte order.
 */
status_t BNetAddress::GetAddr(struct sockaddr_in& sa) const
{
	if (fInit != B_OK)
		return B_NO_INIT;

	sa.sin_port = fPort;
	sa.sin_addr.s_addr = fAddress;
	if (check_r5_compatibility()) {
		r5_sockaddr_in* r5Addr = (r5_sockaddr_in*)&sa;
		if (fFamily == AF_INET)
			r5Addr->sin_family = R5_AF_INET;
		else
			r5Addr->sin_family = fFamily;
	} else
		sa.sin_family = fFamily;

	return B_OK;
}


/* GetAddr
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Class accessor.
 *
 * Output parameters:
 *		addr:			in_addr struct to fill.
 *		port:			optional port number to fill.
 *
 * Returns:
 *		B_OK for success, B_NO_INIT if instance was not properly constructed.
 *
 * Remarks:
 *		Output port will be in host byte order, but addr will be in the usual
 *		network byte order (ready to be used by other network functions).
 */
status_t BNetAddress::GetAddr(in_addr& addr, unsigned short* port) const
{
	if (fInit != B_OK)
		return B_NO_INIT;

	addr.s_addr = fAddress;

	if (port != NULL)
		*port = ntohs(fPort);

	return B_OK;
}


/* InitCheck
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Determine whether or not this instance is properly initialized.
 *
 * Returns:
 *		B_OK if this instance is initialized, B_ERROR if not.
 */
status_t BNetAddress::InitCheck() const
{
	return fInit == B_OK ? B_OK : B_ERROR;
}


status_t BNetAddress::InitCheck()
{
	return const_cast<const BNetAddress*>(this)->InitCheck();
}


/* Archive
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Serialize this instance into the passed BMessage parameter.
 *
 * Input parameter:
 *		deep:			[ignored] default==true.
 *
 * Output parameter:
 *		into:			BMessage object to serialize into.
 *
 * Returns:
 *		B_OK/BERROR on success/failure.  Returns B_NO_INIT if instance not
 *		properly initialized.
 */
status_t BNetAddress::Archive(BMessage* into, bool deep) const
{
	if (fInit != B_OK)
		return B_NO_INIT;

	if (into->AddInt16("bnaddr_family", fFamily) != B_OK)
		return B_ERROR;

	if (into->AddInt16("bnaddr_port", fPort) != B_OK)
		return B_ERROR;

	if (into->AddInt32("bnaddr_addr", fAddress) != B_OK)
		return B_ERROR;

	return B_OK;
}


/* Instantiate
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Un-serialize and instantiate from the passed BMessage parameter.
 *
 * Input parameter:
 *		archive:		Archived BMessage object for (de)serialization.
 *
 * Returns:
 *		NULL if a BNetAddress instance can not be initialized, otherwise
 *		a new BNetAddress object instantiated from the BMessage parameter.
 */
BArchivable*
BNetAddress::Instantiate(BMessage* archive)
{
	if (!validate_instantiation(archive, "BNetAddress"))
		return NULL;

	BNetAddress* address = new (std::nothrow) BNetAddress(archive);
	if (address == NULL)
		return NULL;

	if (address->InitCheck() != B_OK) {
		delete address;
		return NULL;
	}

	return address;
}


/* SetTo
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *	 Set hostname and port network address data.
 *
 * Input parameters:
 *		hostname:		Can be one of three things:
 *						1. An ASCII-string representation of an IP address.
 *						2. A canonical hostname.
 *						3. NULL.  If NULL, then by default the address will be
 *							set to INADDR_ANY (0.0.0.0).
 *		port:			Duh.
 *
 * Returns:
 *		B_OK/B_ERROR for success/failure.
 */
status_t
BNetAddress::SetTo(const char* hostname, unsigned short port)
{
	if (hostname == NULL)
		return B_ERROR;

	in_addr_t addr = INADDR_ANY;

	// Try like all git-out to set the address from the given hostname.

	// See if the string is an ASCII-fied IP address.
	addr = inet_addr(hostname);
	if (addr == INADDR_ANY || addr == (in_addr_t)-1) {
		// See if we can resolve the hostname to an IP address.
		struct hostent* host = gethostbyname(hostname);
		if (host != NULL)
			addr = *(int*)host->h_addr_list[0];
		else
			return B_ERROR;
	}

	fFamily = AF_INET;
	fPort = htons(port);
	fAddress = addr;

	return fInit = B_OK;
}


/*!
	Set from passed in sockaddr_in address.

	\param addr address
	\return B_OK.
*/
status_t
BNetAddress::SetTo(const struct sockaddr_in& addr)
{
	fPort = addr.sin_port;
	fAddress = addr.sin_addr.s_addr;

	if (check_r5_compatibility()) {
		const r5_sockaddr_in* r5Addr = (const r5_sockaddr_in*)&addr;
		if (r5Addr->sin_family == R5_AF_INET)
			fFamily = AF_INET;
		else
			fFamily = r5Addr->sin_family;
	} else
		fFamily = addr.sin_family;

	return fInit = B_OK;
}


/*!
	Set from passed in address and port.

	\param addr IP address in network form.
	\param port Optional port number.

	\return B_OK.
*/
status_t
BNetAddress::SetTo(in_addr addr, int port)
{
	fFamily = AF_INET;
	fPort = htons((short)port);
	fAddress = addr.s_addr;

	return fInit = B_OK;
}


/*!
	Set from passed in address and port.

	\param addr IP address in network form.
	\param port Optional port number.

	\return B_OK.
*/
status_t
BNetAddress::SetTo(uint32 addr, int port)
{
	fFamily = AF_INET;
	fPort = htons((short)port);
	fAddress = addr;

	return fInit = B_OK;
}


/* SetTo
 *=--------------------------------------------------------------------------=*
 * Purpose:
 *		Set from passed in hostname and protocol/service information.
 *
 * Input parameters:
 *		hostname:		Can be one of three things:
 *						1. An ASCII-string representation of an IP address.
 *						2. A canonical hostname.
 *						3. NULL.  If NULL, then by default the address will be
 *							set to INADDR_ANY (0.0.0.0).
 *		protocol:		Datagram type, typically "TCP" or "UDP"
 *		service:		The name of the service, such as http, ftp, et al. This
 *						must be one of the official service names listed in
 *						/etc/services -- but you already knew that because
 *						you're doing network/sockets programming, RIIIGHT???.
 *
 * Returns:
 *		B_OK/B_ERROR on success/failure.
 *
 * Remarks:
 *		The protocol and service input parameters must be one of the official
 *		types listed in /etc/services.  We use these two parameters to
 *		determine the port number (see getservbyname(3)).  This method will
 *		fail if the aforementioned precondition is not met.
 */
status_t
BNetAddress::SetTo(const char* hostname, const char* protocol,
	const char* service)
{
	struct servent* serviceEntry = getservbyname(service, protocol);
	if (serviceEntry == NULL)
		return B_ERROR;

	return SetTo(hostname, serviceEntry->s_port);
}


//	#pragma mark - FBC


void BNetAddress::_ReservedBNetAddressFBCCruft1() {}
void BNetAddress::_ReservedBNetAddressFBCCruft2() {}
void BNetAddress::_ReservedBNetAddressFBCCruft3() {}
void BNetAddress::_ReservedBNetAddressFBCCruft4() {}
void BNetAddress::_ReservedBNetAddressFBCCruft5() {}
void BNetAddress::_ReservedBNetAddressFBCCruft6() {}