WIP. User authentication on remote interface

remote/server/AuthRequestHandler.cpp

@@ -0,0 +1,81 @@
+#include <Wt/Auth/Identity>
+
+#include "AuthRequestHandler.hpp"
+
+namespace Remote {
+namespace Server {
+
+AuthRequestHandler::AuthRequestHandler(Database::Handler& db)
+: _db(db)
+{
+}
+
+bool
+AuthRequestHandler::process(const AuthRequest& request, AuthResponse& response)
+{
+	bool res = false;
+
+	switch (request.type())
+	{
+		case AuthRequest::TypePassword:
+			if (request.has_password())
+			{
+				res = processPassword(request.password(), *response.mutable_password_result());
+				if (res)
+					response.set_type(AuthResponse::TypePasswordResult);
+			}
+			else
+				std::cerr << "Bad AuthRequest::TypePassword" << std::endl;
+			break;
+	}
+
+	return res;
+}
+
+
+bool
+AuthRequestHandler::processPassword(const AuthRequest::Password& request, AuthResponse::PasswordResult& response)
+{
+	bool res = false;
+
+	// Get the user
+	const Wt::Auth::User& user = _db.getUserDatabase().findWithIdentity(Wt::Auth::Identity::LoginName, request.user_login());
+	if (user.isValid())
+	{
+		// Now attempt to log the user in
+
+		Wt::Auth::PasswordResult result = _db.getPasswordService().verifyPassword(user, request.user_password());
+		switch( result )
+		{
+			case Wt::Auth::PasswordInvalid:
+				response.set_type(AuthResponse::PasswordResult::TypePasswordInvalid);
+				res = true;
+				break;
+			case Wt::Auth::LoginThrottling:
+				response.set_type(AuthResponse::PasswordResult::TypeLoginThrottling);
+				response.set_delay(_db.getPasswordService().delayForNextAttempt(user));
+				res = true;
+				break;
+			case Wt::Auth::PasswordValid:
+				response.set_type(AuthResponse::PasswordResult::TypePasswordValid);
+				// Log the user in
+				_db.getLogin().login( user );
+				res = true;
+				break;
+			default:
+				break;
+		}
+
+	}
+	else
+	{
+		std::cerr << "Invalid user '" << request.user_login() << std::endl;
+		response.set_type(AuthResponse::PasswordResult::TypePasswordInvalid);
+	}
+
+	return res;
+}
+
+} // namespace Remote
+} // namespace Server
+

remote/server/AuthRequestHandler.hpp

@@ -0,0 +1,28 @@
+#ifndef REMOTE_AUTH_REQUEST_HANDLER
+#define REMOTE_AUTH_REQUEST_HANDLER
+
+#include "messages/messages.pb.h"
+
+#include "database/DatabaseHandler.hpp"
+
+namespace Remote {
+namespace Server {
+
+class AuthRequestHandler
+{
+	public:
+		AuthRequestHandler(Database::Handler& db);
+
+		bool process(const AuthRequest& request, AuthResponse& response);
+
+	private:
+
+		bool processPassword(const AuthRequest::Password& request, AuthResponse::PasswordResult& response);
+
+		Database::Handler& _db;
+};
+
+} // namespace Remote
+} // namespace Server
+
+#endif

remote/server/RequestHandler.cpp

@@ -6,11 +6,18 @@ namespace Server {
 
 RequestHandler::RequestHandler(boost::filesystem::path dbPath)
 : _db( dbPath ),
+_authRequestHandler(_db),
 _audioCollectionRequestHandler(_db),
 _mediaRequestHandler(_db)
 {
 }
 
+RequestHandler::~RequestHandler()
+{
+	// TODO manually log out user if needed?
+	_db.getLogin().logout();
+}
+
 bool
 RequestHandler::process(const ClientMessage& request, ServerMessage& response)
 {
@@ -19,30 +26,44 @@ RequestHandler::process(const ClientMessage& request, ServerMessage& response)
 	switch(request.type())
 	{
 
-		case ClientMessage_Type_AuthRequest:
-
-			break;
-		case ClientMessage_Type_AudioCollectionRequest:
-			if (request.has_audio_collection_request())
+		case ClientMessage::AuthRequest:
+			if (request.has_auth_request())
 			{
-				res = _audioCollectionRequestHandler.process(request.audio_collection_request(), *response.mutable_audio_collection_response());
+				res = _authRequestHandler.process(request.auth_request(), *response.mutable_auth_response());
 				if (res)
-					response.set_type( ServerMessage::AudioCollectionResponse);
+					response.set_type(ServerMessage::AuthResponse);
 			}
 			else
-				std::cerr << "Malformed AudioCollectionRequest message!" << std::endl;
+				std::cerr << "Bad ClientMessage::AuthRequest !" << std::endl;
+			break;
+		case ClientMessage::AudioCollectionRequest:
+			// Not allowed if the user is not logged in
+			if (_db.getLogin().loggedIn())
+			{
+				if (request.has_audio_collection_request())
+				{
+					res = _audioCollectionRequestHandler.process(request.audio_collection_request(), *response.mutable_audio_collection_response());
+					if (res)
+						response.set_type( ServerMessage::AudioCollectionResponse);
+				}
+				else
+					std::cerr << "Bad ClientMessage::AudioCollectionRequest message!" << std::endl;
+			}
 			break;
 
-		case ClientMessage_Type_MediaRequest:
-			if (request.has_media_request())
+		case ClientMessage::MediaRequest:
+			// Not allowed if the user is not logged in
+			if (_db.getLogin().loggedIn())
 			{
-				res = _mediaRequestHandler.process(request.media_request(), *response.mutable_media_response());
-				if (res)
-					response.set_type( ServerMessage::MediaResponse);
+				if (request.has_media_request())
+				{
+					res = _mediaRequestHandler.process(request.media_request(), *response.mutable_media_response());
+					if (res)
+						response.set_type( ServerMessage::MediaResponse);
+				}
+				else
+					std::cerr << "Malformed ClientMessage::MediaRequest message!" << std::endl;
 			}
-			else
-				std::cerr << "Malformed AudioCollectionRequest message!" << std::endl;
-			break;
 			break;
 
 		default:

remote/server/RequestHandler.hpp

@@ -7,6 +7,7 @@
 
 #include "database/DatabaseHandler.hpp"
 
+#include "AuthRequestHandler.hpp"
 #include "AudioCollectionRequestHandler.hpp"
 #include "MediaRequestHandler.hpp"
 
@@ -18,15 +19,15 @@ class RequestHandler
 	public:
 
 		RequestHandler(boost::filesystem::path dbPath);
+		~RequestHandler();
 
 		bool process(const ClientMessage& request, ServerMessage& response);
 
-		bool processAudioCollectionRequest(const AudioCollectionRequest& request, ServerMessage& response);
-
 	private:
 
 		Database::Handler _db;
 
+		AuthRequestHandler		_authRequestHandler;
 		AudioCollectionRequestHandler	_audioCollectionRequestHandler;
 		MediaRequestHandler		_mediaRequestHandler;
 };