test (abc2464d) · Commits · tuxist / authdb

src/admin.cpp

+52 −64

Changes for src/admin.cpp: 52 added lines, 64 removed lines.
Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		*******************************************************************************/

		#include <algorithm>
		#include <functional>
		#include <iostream>
		#include <fstream>
		#include <cstring>
		@@ -136,10 +137,13 @@ namespace authdb {
		}
		};

		void setDomainResolver(std::function<AuthBackend(const char)> resolver) {
		_DomainResolver = std::move(resolver);
		}

		/* ---- JSON API: List Users ---- */
		void apiListUsers(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("listUsers: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -184,8 +188,7 @@ namespace authdb {

		/* ---- JSON API: Get User (for edit form) ---- */
		void apiGetUser(libhttppp::HttpRequest &curreq, const char cdid, const char cuid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("getUser: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -221,8 +224,7 @@ namespace authdb {

		/* ---- JSON API: Create User ---- */
		void apiCreateUser(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("createUser: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -352,8 +354,7 @@ namespace authdb {

		/* ---- JSON API: Remove User ---- */
		void apiRemoveUser(libhttppp::HttpRequest &curreq, const char cdid, const char cuid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("removeUser: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -370,8 +371,7 @@ namespace authdb {

		/* ---- JSON API: Edit User ---- */
		void apiEditUser(libhttppp::HttpRequest &curreq, const char cdid, const char cuid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("editUser: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -809,8 +809,7 @@ namespace authdb {

		// Auto-create "Domain Admins" group and admin login GPO
		{
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *domBackend = resolveDomain(uid.c_str(), _AdminBackend, dbackend);
		AuthBackend *domBackend = getDomain(uid.c_str());
		if (domBackend) {
		AuthBackend::Guard dguard(*domBackend);

		@@ -872,8 +871,7 @@ namespace authdb {

		/* ---- JSON API: List Groups ---- */
		void apiListGroups(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("listGroups: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -913,8 +911,7 @@ namespace authdb {

		/* ---- JSON API: Get Group (for edit) ---- */
		void apiGetGroup(libhttppp::HttpRequest &curreq, const char cdid, const char cgid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("getGroup: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -966,8 +963,7 @@ namespace authdb {

		/* ---- JSON API: Create Group ---- */
		void apiCreateGroup(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("createGroup: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1005,8 +1001,7 @@ namespace authdb {

		/* ---- JSON API: Remove Group ---- */
		void apiRemoveGroup(libhttppp::HttpRequest &curreq, const char cdid, const char cgid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("removeGroup: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1023,8 +1018,7 @@ namespace authdb {

		/* ---- JSON API: Edit Group ---- */
		void apiEditGroup(libhttppp::HttpRequest &curreq, const char cdid, const char cgid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("editGroup: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1113,8 +1107,7 @@ namespace authdb {
		uuid::uuid sid, did;
		sid.parse(csid);

		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("reloadSession: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1128,8 +1121,7 @@ namespace authdb {

		/* ---- JSON API: List GPOs ---- */
		void apiListGpos(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("listGpos: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1176,8 +1168,7 @@ namespace authdb {

		/* ---- JSON API: Get GPO (for edit) ---- */
		void apiGetGpo(libhttppp::HttpRequest &curreq, const char cdid, const char cgpid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("getGpo: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1240,8 +1231,7 @@ namespace authdb {

		/* ---- JSON API: Create GPO ---- */
		void apiCreateGpo(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("createGpo: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1290,8 +1280,7 @@ namespace authdb {

		/* ---- JSON API: Remove GPO ---- */
		void apiRemoveGpo(libhttppp::HttpRequest &curreq, const char cdid, const char cgpid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("removeGpo: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1309,8 +1298,7 @@ namespace authdb {

		/* ---- JSON API: Edit GPO ---- */
		void apiEditGpo(libhttppp::HttpRequest &curreq, const char cdid, const char cgpid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("editGpo: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1359,8 +1347,7 @@ namespace authdb {

		/* ---- JSON API: List Services ---- */
		void apiListServices(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("listServices: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1411,8 +1398,7 @@ namespace authdb {

		/* ---- JSON API: Get Service (for edit) ---- */
		void apiGetService(libhttppp::HttpRequest &curreq, const char cdid, const char csid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("getService: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1443,8 +1429,7 @@ namespace authdb {

		/* ---- JSON API: Create Service ---- */
		void apiCreateService(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("createService: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1521,8 +1506,7 @@ namespace authdb {

		/* ---- JSON API: Remove Service ---- */
		void apiRemoveService(libhttppp::HttpRequest &curreq, const char cdid, const char csid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("removeService: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1540,8 +1524,7 @@ namespace authdb {

		/* ---- JSON API: Edit Service ---- */
		void apiEditService(libhttppp::HttpRequest &curreq, const char cdid, const char csid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("editService: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1626,8 +1609,7 @@ namespace authdb {

		/* ---- JSON API: List Clients ---- */
		void apiListClients(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("listClients: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1668,8 +1650,7 @@ namespace authdb {

		/* ---- JSON API: Get Client (for edit) ---- */
		void apiGetClient(libhttppp::HttpRequest &curreq, const char cdid, const char cclid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("getClient: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1691,8 +1672,7 @@ namespace authdb {

		/* ---- JSON API: Create Client ---- */
		void apiCreateClient(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("createClient: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1743,8 +1723,7 @@ namespace authdb {

		/* ---- JSON API: Remove Client ---- */
		void apiRemoveClient(libhttppp::HttpRequest &curreq, const char cdid, const char cclid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("removeClient: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1762,8 +1741,7 @@ namespace authdb {

		/* ---- JSON API: Edit Client ---- */
		void apiEditClient(libhttppp::HttpRequest &curreq, const char cdid, const char cclid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("editClient: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1820,8 +1798,7 @@ namespace authdb {

		/* ---- JSON API: Export Database ---- */
		void apiExportDb(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("export: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1832,8 +1809,7 @@ namespace authdb {

		/* ---- JSON API: Import Database ---- */
		void apiImportDb(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("import: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1853,8 +1829,7 @@ namespace authdb {

		/* ---- JSON API: Vacuum Database ---- */
		void apiVacuum(libhttppp::HttpRequest &curreq, const char *cdid) {
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = resolveDomain(cdid, _AdminBackend, dbackend);
		AuthBackend *backend = getDomain(cdid);
		if (!backend) throw AuthBackendError("vacuum: could not resolve domain!");
		AuthBackend::Guard guard(*backend);

		@@ -1893,15 +1868,14 @@ namespace authdb {
		sha512 hash;
		hash.hash(password, pwhash);

		uuid::uuid did;
		DomainBackend dbackend(_AdminBackend);
		AuthBackend *backend = nullptr;

		if (domain.empty() \|\| domain == "admin") {
		backend = &_AdminBackend;
		} else if (did.parse(domain.c_str()) == 0) {
		backend = dbackend.data(did);
		} else {
		backend = getDomain(domain.c_str());
		}
		if (!backend) {
		throw AuthBackendError("login: could not parse uuid!");
		}

		@@ -2199,10 +2173,20 @@ namespace authdb {
		}

		private:
		AuthBackend* getDomain(const char *cdid) {
		if (strcmp(cdid, "admin") == 0)
		return &_AdminBackend;
		if (_DomainResolver)
		return _DomainResolver(cdid);
		DomainBackend dbackend(_AdminBackend);
		return resolveDomain(cdid, _AdminBackend, dbackend);
		}

		authdb::AuthBackend _AdminBackend;
		std::shared_ptr<libhtmlpp::HtmlElement> _LoginElement;
		std::shared_ptr<libhtmlpp::HtmlPage> _Loginpage;
		std::vector<char> _AdminHtml;
		std::function<AuthBackend(const char)> _DomainResolver;
		};

		AdminInterface::AdminInterface(AuthBackend &bck, std::vector<netplus::socket*> ssock) : _bck(bck) {
		@@ -2213,6 +2197,10 @@ namespace authdb {
		delete _ctl;
		}

		void AdminInterface::setDomainResolver(std::function<AuthBackend(const char)> resolver) {
		_ctl->setDomainResolver(std::move(resolver));
		}

		void AdminInterface::Request(libhttppp::HttpRequest &curreq, const int tid, ULONG_PTR args) {
		if (curreq.getRequestURL().compare(0, 9, "/settings", 9) == 0) {
		_ctl->SettingsController(curreq, tid, args);

src/admin.h

+2 −0

Changes for src/admin.h: 2 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@
		*******************************************************************************/

		#include <httppp/http.h>
		#include <functional>

		#include "backend.h"
		#include "session.h"
		@@ -40,6 +41,7 @@ namespace authdb {
		AdminInterface(AuthBackend &bck,std::vector<netplus::socket*> ssock);
		~AdminInterface();
		void Request(libhttppp::HttpRequest &curreq, const int tid, ULONG_PTR args);
		void setDomainResolver(std::function<AuthBackend(const char)> resolver);
		public:
		AdminController * _ctl;
		AuthBackend &_bck;

src/authdb.cpp

+7 −0

Changes for src/authdb.cpp: 7 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		@@ -105,6 +105,13 @@ namespace authdb {
		_AuthCss.resize(csssize);
		cssfs.seekg(0);
		cssfs.read(_AuthCss.data(),csssize);

		_AdminInterface.setDomainResolver([this](const char cdid) -> AuthBackend {
		uuid::uuid did;
		if (did.parse(cdid) != 0)
		return nullptr;
		return getDomainBackend(did);
		});
		};

		void WizzardEvent(libhttppp::HttpRequest &curreq, const int tid, ULONG_PTR args){