// InsecureConnectionListener.cpp

#include <new>

#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "Compatibility.h"
#include "Debug.h"
#include "InsecureChannel.h"
#include "InsecureConnection.h"
#include "InsecureConnectionListener.h"
#include "NetFSDefs.h"
#include "Utils.h"

using namespace InsecureConnectionDefs;

// constructor
InsecureConnectionListener::InsecureConnectionListener()
	: ConnectionListener(),
	  fSocket(-1)
{
}

// destructor
InsecureConnectionListener::~InsecureConnectionListener()
{
	safe_closesocket(fSocket);
}

// Init
status_t
InsecureConnectionListener::Init(const char* parameters)
{
	// parse the parameters
	// parameter format is "[port]"
	uint16 port = kDefaultInsecureConnectionPort;
	if (parameters && strlen(parameters) > 0) {
		int result = sscanf(parameters, "%hu", &port);
		if (result < 1)
			return B_BAD_VALUE;
	}
	// create a listener socket
	fSocket = socket(AF_INET, SOCK_STREAM, 0);
	if (fSocket < 0)
		return errno;
	// bind it to the port
	sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = INADDR_ANY;
	if (bind(fSocket, (sockaddr*)&addr, sizeof(addr)) < 0)
		return errno;
	// start listening
	if (listen(fSocket, 5) < 0)
		return errno;
	return B_OK;
}

// Listen
status_t
InsecureConnectionListener::Listen(Connection** _connection)
{
	if (!_connection || fSocket < 0)
		return B_BAD_VALUE;
	// accept a connection
	int fd = -1;
	do {
		fd = accept(fSocket, NULL, 0);
		if (fd < 0) {
			status_t error = errno;
			if (error != B_INTERRUPTED)
				return error;
		}
	} while (fd < 0);
	// create a connection
	InsecureConnection* connection = new(nothrow) InsecureConnection;
	if (!connection) {
		closesocket(fd);
		return B_NO_MEMORY;
	}
	status_t error = connection->Init(fd);
	if (error != B_OK) {
		delete connection;
		return error;
	}
	*_connection = connection;
	return B_OK;
}

// StopListening
void
InsecureConnectionListener::StopListening()
{
	safe_closesocket(fSocket);
}

// FinishInitialization
status_t
InsecureConnectionListener::FinishInitialization(Connection* _connection,
	SecurityContext* securityContext, User** user)
{
	InsecureConnection* connection
		= dynamic_cast<InsecureConnection*>(_connection);
	if (!connection)
		return B_BAD_VALUE;
	*user = NULL;
	return connection->FinishInitialization();
}