/*
 * Copyright 2012-2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Paweł Dziepak, pdziepak@quarnos.org
 */
#ifndef CONNECTION_H
#define CONNECTION_H


#include <netinet/in.h>

#include <lock.h>
#include <SupportDefs.h>


struct PeerAddress {
			sockaddr_storage	fAddress;
			int					fProtocol;

			bool				operator==(const PeerAddress& address);
			bool				operator<(const PeerAddress& address);

			PeerAddress&		operator=(const PeerAddress& address);

								PeerAddress();
								PeerAddress(int networkFamily);

	inline	int					Family() const;

			const char*			ProtocolString() const;
			void				SetProtocol(const char* protocol);

			char*				UniversalAddress() const;

			socklen_t			AddressSize() const;

			void				SetPort(uint16 port);
			uint16				Port() const;

			const void*			InAddr() const;
			size_t				InAddrSize() const;
};


inline int
PeerAddress::Family() const
{
	return fAddress.ss_family;
}


struct addrinfo;

class AddressResolver {
public:
								AddressResolver(const char* name);
								~AddressResolver();

			status_t			GetNextAddress(PeerAddress* address);

			void				ForceProtocol(const char* protocol);
			void				ForcePort(uint16 port);

protected:
			status_t			ResolveAddress(const char* name);

private:
			addrinfo*			fHead;
			addrinfo*			fCurrent;

			PeerAddress			fAddress;

			uint16				fForcedPort;
			int					fForcedProtocol;

			status_t			fStatus;
};

class ConnectionBase {
public:
								ConnectionBase(const PeerAddress& address);
	virtual						~ConnectionBase();

			status_t			GetLocalAddress(PeerAddress* address);

			void				Disconnect();

protected:
			sem_id				fWaitCancel;
			int					fSocket;
			mutex				fSocketLock;

			const PeerAddress	fPeerAddress;
};

class Connection : public ConnectionBase {
public:
	static	status_t			Connect(Connection **connection,
									const PeerAddress& address);
	static	status_t			SetTo(Connection **connection, int socket,
									const PeerAddress& address);

	virtual	status_t			Send(const void* buffer, uint32 size) = 0;
	virtual	status_t			Receive(void** buffer, uint32* size) = 0;

			status_t			Reconnect();

protected:
	static	Connection*			CreateObject(const PeerAddress& address);

								Connection(const PeerAddress& address);
			status_t			Connect();

};

class ConnectionStream : public Connection {
public:
								ConnectionStream(const PeerAddress& address);

	virtual	status_t			Send(const void* buffer, uint32 size);
	virtual	status_t			Receive(void** buffer, uint32* size);
};

class ConnectionPacket : public Connection {
public:
								ConnectionPacket(const PeerAddress& address);

	virtual	status_t			Send(const void* buffer, uint32 size);
	virtual	status_t			Receive(void** buffer, uint32* size);
};

class ConnectionListener : public ConnectionBase {
public:
	static	status_t	Listen(ConnectionListener** listener, int networkFamily,
							uint16 port = 0);

			status_t	AcceptConnection(Connection** connection);

protected:
						ConnectionListener(const PeerAddress& address);
};

#endif	// CONNECTION_H