haiku.git

// AuthenticationServer.cpp

#include "AuthenticationServer.h"

#include <new>

#include <HashMap.h>
#include <HashString.h>
#include <util/KMessage.h>

#include "AuthenticationPanel.h"
#include "AuthenticationServerDefs.h"
#include "DebugSupport.h"
#include "TaskManager.h"


// Authentication
class AuthenticationServer::Authentication {
public:
	Authentication()
		: fUser(),
		  fPassword()
	{
	}

	Authentication(const char* user, const char* password)
		: fUser(user),
		  fPassword(password)
	{
	}

	status_t SetTo(const char* user, const char* password)
	{
		if (fUser.SetTo(user) && fPassword.SetTo(password))
			return B_OK;
		return B_NO_MEMORY;
	}

	bool IsValid() const
	{
		return (fUser.GetLength() > 0);
	}

	const char* GetUser() const
	{
		return fUser.GetString();
	}

	const char* GetPassword() const
	{
		return fPassword.GetString();
	}

private:
	HashString	fUser;
	HashString	fPassword;
};

// ServerKey
class AuthenticationServer::ServerKey {
public:
	ServerKey()
		: fContext(),
		  fServer()
	{
	}

	ServerKey(const char* context, const char* server)
		: fContext(context),
		  fServer(server)
	{
	}

	ServerKey(const ServerKey& other)
		: fContext(other.fContext),
		  fServer(other.fServer)
	{
	}

	uint32 GetHashCode() const
	{
		return fContext.GetHashCode() * 17 + fServer.GetHashCode();
	}

	ServerKey& operator=(const ServerKey& other)
	{
		fContext = other.fContext;
		fServer = other.fServer;
		return *this;
	}

	bool operator==(const ServerKey& other) const
	{
		return (fContext == other.fContext && fServer == other.fServer);
	}

	bool operator!=(const ServerKey& other) const
	{
		return !(*this == other);
	}

private:
	HashString	fContext;
	HashString	fServer;
};

// ServerEntry
class AuthenticationServer::ServerEntry {
public:
	ServerEntry()
		: fDefaultAuthentication(),
		  fUseDefaultAuthentication(false)
	{
	}

	~ServerEntry()
	{
		// delete the authentications
		for (AuthenticationMap::Iterator it = fAuthentications.GetIterator();
			 it.HasNext();) {
			delete it.Next().value;
		}
	}

	void SetUseDefaultAuthentication(bool useDefaultAuthentication)
	{
		fUseDefaultAuthentication = useDefaultAuthentication;
	}

	bool UseDefaultAuthentication() const
	{
		return fUseDefaultAuthentication;
	}

	status_t SetDefaultAuthentication(const char* user, const char* password)
	{
		return fDefaultAuthentication.SetTo(user, password);
	}

	const Authentication& GetDefaultAuthentication() const
	{
		return fDefaultAuthentication;
	}

	status_t SetAuthentication(const char* share, const char* user,
		const char* password)
	{
		// check, if an entry already exists for the share -- if it does,
		// just set it
		Authentication* authentication = fAuthentications.Get(share);
		if (authentication)
			return authentication->SetTo(user, password);
		// the entry does not exist yet: create and add a new one
		authentication = new(std::nothrow) Authentication;
		if (!authentication)
			return B_NO_MEMORY;
		status_t error = authentication->SetTo(user, password);
		if (error == B_OK)
			error = fAuthentications.Put(share, authentication);
		if (error != B_OK)
			delete authentication;
		return error;
	}

	Authentication* GetAuthentication(const char* share) const
	{
		return fAuthentications.Get(share);
	}

private:
	typedef HashMap<HashString, Authentication*> AuthenticationMap;

	Authentication		fDefaultAuthentication;
	bool				fUseDefaultAuthentication;
	AuthenticationMap	fAuthentications;
};

// ServerEntryMap
struct AuthenticationServer::ServerEntryMap
	: HashMap<ServerKey, ServerEntry*> {
};

// UserDialogTask
class AuthenticationServer::UserDialogTask : public Task {
public:
	UserDialogTask(AuthenticationServer* authenticationServer,
		const char* context, const char* server, const char* share,
		bool badPassword, port_id replyPort,
		int32 replyToken)
		: Task("user dialog task"),
		  fAuthenticationServer(authenticationServer),
		  fContext(context),
		  fServer(server),
		  fShare(share),
		  fBadPassword(badPassword),
		  fReplyPort(replyPort),
		  fReplyToken(replyToken),
		  fPanel(NULL)
	{
	}

	virtual status_t Execute()
	{
		// open the panel
		char user[B_OS_NAME_LENGTH];
		char password[B_OS_NAME_LENGTH];
		bool keep = true;
		fPanel = new(std::nothrow) AuthenticationPanel();
		status_t error = (fPanel ? B_OK : B_NO_MEMORY);
		bool cancelled = false;
		HashString defaultUser;
		HashString defaultPassword;
		fAuthenticationServer->_GetAuthentication(fContext.GetString(),
			fServer.GetString(), NULL, &defaultUser, &defaultPassword);
		if (error == B_OK) {
			cancelled = fPanel->GetAuthentication(fServer.GetString(),
				fShare.GetString(), defaultUser.GetString(),
				defaultPassword.GetString(), false, fBadPassword, user,
				password, &keep);
		}
		fPanel = NULL;
		// send the reply
		if (error != B_OK) {
			fAuthenticationServer->_SendRequestReply(fReplyPort, fReplyToken,
				error, true, NULL, NULL);
		} else if (cancelled) {
			fAuthenticationServer->_SendRequestReply(fReplyPort, fReplyToken,
				B_OK, true, NULL, NULL);
		} else {
			fAuthenticationServer->_AddAuthentication(fContext.GetString(),
				fServer.GetString(), fShare.GetString(), user, password,
				keep);
			fAuthenticationServer->_SendRequestReply(fReplyPort, fReplyToken,
				B_OK, false, user, password);
		}
		return error;
	}

	virtual void Stop()
	{
		if (fPanel)
			fPanel->Cancel();
	}

private:
	AuthenticationServer*	fAuthenticationServer;
	HashString				fContext;
	HashString				fServer;
	HashString				fShare;
	bool					fBadPassword;
	port_id					fReplyPort;
	int32					fReplyToken;
	AuthenticationPanel*	fPanel;
};


// constructor
AuthenticationServer::AuthenticationServer()
	:
	BApplication("application/x-vnd.haiku-authentication_server"),
	fLock(),
	fRequestPort(-1),
	fRequestThread(-1),
	fServerEntries(NULL),
	fTerminating(false)
{
}

// destructor
AuthenticationServer::~AuthenticationServer()
{
	fTerminating = true;
	// terminate the request thread
	if (fRequestPort >= 0)
		delete_port(fRequestPort);
	if (fRequestThread >= 0) {
		int32 result;
		wait_for_thread(fRequestPort, &result);
	}
	// delete the server entries
	for (ServerEntryMap::Iterator it = fServerEntries->GetIterator();
		 it.HasNext();) {
		delete it.Next().value;
	}
}

// Init
status_t
AuthenticationServer::Init()
{
	// create the server entry map
	fServerEntries = new(std::nothrow) ServerEntryMap;
	if (!fServerEntries)
		return B_NO_MEMORY;
	status_t error = fServerEntries->InitCheck();
	if (error != B_OK)
		return error;
	// create the request port
	fRequestPort = create_port(10, kAuthenticationServerPortName);
	if (fRequestPort < 0)
		return fRequestPort;
	// spawn the request thread
	fRequestThread = spawn_thread(&_RequestThreadEntry, "request thread",
		B_NORMAL_PRIORITY, this);
	if (fRequestThread < 0)
		return fRequestThread;
	resume_thread(fRequestThread);
	return B_OK;
}

// _RequestThreadEntry
int32
AuthenticationServer::_RequestThreadEntry(void* data)
{
	return ((AuthenticationServer*)data)->_RequestThread();
}

// _RequestThread
int32
AuthenticationServer::_RequestThread()
{
	TaskManager taskManager;
	while (!fTerminating) {
		taskManager.RemoveDoneTasks();
		// read the request
		KMessage request;
		status_t error = request.ReceiveFrom(fRequestPort);
		if (error != B_OK)
			continue;
		// get the parameters
		const char* context = NULL;
		const char* server = NULL;
		const char* share = NULL;
		bool badPassword = true;
		request.FindString("context", &context);
		request.FindString("server", &server);
		request.FindString("share", &share);
		request.FindBool("badPassword", &badPassword);
		if (!context || !server || !share)
			continue;
		HashString foundUser;
		HashString foundPassword;
		if (!badPassword && _GetAuthentication(context, server, share,
			&foundUser, &foundPassword)) {
			_SendRequestReply(request.ReplyPort(), request.ReplyToken(),
				error, false, foundUser.GetString(), foundPassword.GetString());
		} else {
			// we need to ask the user: create a task that does it
			UserDialogTask* task = new(std::nothrow) UserDialogTask(this,
				context, server, share, badPassword, request.ReplyPort(),
				request.ReplyToken());
			if (!task) {
				ERROR("AuthenticationServer::_RequestThread(): ERROR: "
					"failed to allocate ");
				continue;
			}
			status_t error = taskManager.RunTask(task);
			if (error != B_OK) {
				ERROR("AuthenticationServer::_RequestThread(): Failed to "
					"start server info task: %s\n", strerror(error));
				continue;
			}
		}
	}
	return 0;
}

// _GetAuthentication
/*!
	If share is NULL, the default authentication for the server is returned.
*/
bool
AuthenticationServer::_GetAuthentication(const char* context,
	const char* server, const char* share, HashString* user,
	HashString* password)
{
	if (!context || !server || !user || !password)
		return B_BAD_VALUE;
	// get the server entry
	AutoLocker<BLocker> _(fLock);
	ServerKey key(context, server);
	ServerEntry* serverEntry = fServerEntries->Get(key);
	if (!serverEntry)
		return false;
	// get the authentication
	const Authentication* authentication = NULL;
	if (share) {
		serverEntry->GetAuthentication(share);
		if (!authentication && serverEntry->UseDefaultAuthentication())
			authentication = &serverEntry->GetDefaultAuthentication();
	} else
		authentication = &serverEntry->GetDefaultAuthentication();
	if (!authentication || !authentication->IsValid())
		return false;
	return (user->SetTo(authentication->GetUser())
		&& password->SetTo(authentication->GetPassword()));
}

// _AddAuthentication
status_t
AuthenticationServer::_AddAuthentication(const char* context,
	const char* server, const char* share, const char* user,
	const char* password, bool makeDefault)
{
	AutoLocker<BLocker> _(fLock);
	ServerKey key(context, server);
	// get the server entry
	ServerEntry* serverEntry = fServerEntries->Get(key);
	if (!serverEntry) {
		// server entry does not exist yet: create a new one
		serverEntry = new(std::nothrow) ServerEntry;
		if (!serverEntry)
			return B_NO_MEMORY;
		status_t error = fServerEntries->Put(key, serverEntry);
		if (error != B_OK) {
			delete serverEntry;
			return error;
		}
	}
	// put the authentication
	status_t error = serverEntry->SetAuthentication(share, user, password);
	if (error == B_OK) {
		if (makeDefault || !serverEntry->UseDefaultAuthentication())
			serverEntry->SetDefaultAuthentication(user, password);
		if (makeDefault)
			serverEntry->SetUseDefaultAuthentication(true);
	}
	return error;
}

// _SendRequestReply
status_t
AuthenticationServer::_SendRequestReply(port_id port, int32 token,
	status_t error, bool cancelled, const char* user, const char* password)
{
	// prepare the reply
	KMessage reply;
	reply.AddInt32("error", error);
	if (error == B_OK) {
		reply.AddBool("cancelled", cancelled);
		if (!cancelled) {
			reply.AddString("user", user);
			reply.AddString("password", password);
		}
	}
	// send the reply
	return reply.SendTo(port, token);
}


// main
int
main()
{
	AuthenticationServer app;
	status_t error = app.Init();
	if (error != B_OK)
		return 1;
	app.Run();
	return 0;
}