#include "CliServer.hh"

#include "CliConnection.hh"

#include "FileOperations.hh"

#include "GlobalCliComm.hh"

#include "MSXException.hh"

#include "one_of.hh"

#include "random.hh"

#include "xrange.hh"

#include <bit>

#include <memory>

#include <string>

#ifdef _WIN32

#include <fstream>

#include <ctime>

#else

#include <fcntl.h>

#include <pwd.h>

#include <unistd.h>

#endif

namespace openmsx {

[[nodiscard]] static std::string getUserName()

{

#ifdef _WIN32

	return "default";

#else

	const struct passwd* pw = getpwuid(getuid());

	return (pw && pw->pw_name) ? pw->pw_name : std::string{};

#endif

}

[[nodiscard]] static bool checkSocketDir(zstring_view dir)

{

	auto st = FileOperations::getStat(dir);

	if (!st) {

		// error during stat()

		return false;

	}

	if (!FileOperations::isDirectory(*st)) {

		// not a directory

		return false;

	}

#ifndef _WIN32

	// only do permission and owner checks on *nix

	if ((st->st_mode & 0777) != 0700) {

		// wrong permissions

		return false;

	}

	if (st->st_uid != getuid()) {

		// wrong uid

		return false;

	}

#endif

	return true;

}

[[nodiscard]] static bool checkSocket(zstring_view socket)

{

	if (auto name = FileOperations::getFilename(socket);

	    !name.starts_with("socket.")) {

		return false; // wrong name

	}

	auto st = FileOperations::getStat(socket);

	if (!st) {

		// error during stat()

		return false;

	}

#ifdef _WIN32

	if (!FileOperations::isRegularFile(*st)) {

		// not a regular file

		return false;

	}

#else

	if (!S_ISSOCK(st->st_mode)) {

		// not a socket

		return false;

	}

#endif

#ifndef _WIN32

	// only do permission and owner checks on *nix

	if ((st->st_mode & 0777) != 0600) {

		// check will be different on win32 (!= 777) thus actually useless

		// wrong permissions

		return false;

	}

	if (st->st_uid != getuid()) {

		// does this work on win32? is this check meaningful?

		// wrong uid

		return false;

	}

#endif

	return true;

}

#ifdef _WIN32

[[nodiscard]] static int openPort(SOCKET listenSock)

{

	const int BASE = 9938;

	const int RANGE = 64;

	int first = random_int(0, RANGE - 1); // [0, RANGE)

	for (auto n : xrange(RANGE)) {

		int port = BASE + ((first + n) % RANGE);

		sockaddr_in server_address;

		memset(&server_address, 0, sizeof(server_address));

		server_address.sin_family = AF_INET;

		server_address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

		server_address.sin_port = htons(port);

		if (bind(listenSock, std::bit_cast<sockaddr*>(&server_address),

		         sizeof(server_address)) != -1) {

			return port;

		}

	}

	throw MSXException("Couldn't open socket.");

}

#endif

SOCKET CliServer::createSocket()

{

	auto dir = tmpStrCat(FileOperations::getTempDir(), "/openmsx-", getUserName());

	FileOperations::mkdir(dir, 0700);

	if (!checkSocketDir(dir)) {

		throw MSXException("Couldn't create socket directory.");

	}

	socketName = strCat(dir, "/socket.", int(getpid()));

#ifdef _WIN32

	SOCKET sd = socket(AF_INET, SOCK_STREAM, 0);

	if (sd == OPENMSX_INVALID_SOCKET) {

		throw MSXException(sock_error());

	}

	int portNumber = openPort(sd);

	// write port number to file

	FileOperations::unlink(socketName); // ignore error

	std::ofstream out;

	FileOperations::openOfStream(out, socketName);

	out << portNumber << '\n';

	if (!out.good()) {

		sock_close(sd);

		throw MSXException("Couldn't write socket port file.");

	}

#else

	SOCKET sd = socket(AF_UNIX, SOCK_STREAM, 0);

	if (sd == OPENMSX_INVALID_SOCKET) {

		throw MSXException(sock_error());

	}

	FileOperations::unlink(socketName); // ignore error

	sockaddr_un addr;

	strncpy(addr.sun_path, socketName.c_str(), sizeof(addr.sun_path) - 1);

	addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';

	addr.sun_family = AF_UNIX;

	if (bind(sd, std::bit_cast<sockaddr*>(&addr), sizeof(addr)) == -1) {

		sock_close(sd);

		throw MSXException("Couldn't bind socket.");

	}

	if (chmod(socketName.c_str(), 0600) == -1) {

		sock_close(sd);

		throw MSXException("Couldn't set socket permissions.");

	}

#endif

	if (!checkSocket(socketName)) {

		sock_close(sd);

		throw MSXException("Opened socket fails sanity check.");

	}

	if (listen(sd, SOMAXCONN) == SOCKET_ERROR) {

		sock_close(sd);

		throw MSXException("Couldn't listen to socket: ", sock_error());

	}

	return sd;

}

void CliServer::exitAcceptLoop()

{

	sock_close(listenSock);

	poller.abort();

}

static void deleteSocket(const std::string& socket)

{

	FileOperations::unlink(socket); // ignore errors

	auto dir = socket.substr(0, socket.find_last_of('/'));

	FileOperations::rmdir(dir); // ignore errors

}

CliServer::CliServer(CommandController& commandController_,

                     EventDistributor& eventDistributor_,

                     GlobalCliComm& cliComm_)

	: commandController(commandController_)

	, eventDistributor(eventDistributor_)

	, cliComm(cliComm_)

{

	try {

		listenSock = createSocket();

		thread = std::thread([this]() { mainLoop(); });

	} catch (MSXException& e) {

		cliComm.printWarning(e.getMessage());

	}

}

CliServer::~CliServer()

{

	if (listenSock != OPENMSX_INVALID_SOCKET) {

		exitAcceptLoop();

		thread.join();

	}

	deleteSocket(socketName);

}

void CliServer::mainLoop()

{

#ifndef _WIN32

	// Set socket to non-blocking to make sure accept() doesn't hang when

	// a connection attempt is dropped between poll() and accept().

	fcntl(listenSock, F_SETFL, O_NONBLOCK);

#endif

	while (true) {

		// wait for incoming connection

		// Note: On Windows, closing the socket is sufficient to exit the

		//       accept() call.

#ifndef _WIN32

		if (poller.poll(listenSock)) {

			break;

		}

#endif

		SOCKET sd = accept(listenSock, nullptr, nullptr);

		if (poller.aborted()) {

			if (sd != OPENMSX_INVALID_SOCKET) {

				sock_close(sd);

			}

			break;

		}

		if (sd == OPENMSX_INVALID_SOCKET) {

			if (errno == one_of(EAGAIN, EWOULDBLOCK)) {

				continue;

			} else {

				break;

			}

		}

#ifndef _WIN32

		// The BSD/OSX sockets implementation inherits O_NONBLOCK, while Linux

		// does not. To be on the safe side, we explicitly reset file flags.

		fcntl(sd, F_SETFL, 0);

#endif

		cliComm.addListener(std::make_unique<SocketConnection>(

			commandController, eventDistributor, sd));

	}

}

} // namespace openmsx