Fix for latest version of Poco

README.md

@@ -182,34 +182,6 @@ You should now have the following:
   +-- ucentralgw.properties
 ```
 
-### Default username and password
-The default username and password are set in `ucentralgw.properties` file. The following entries manage the username and password
-```text
-authentication.default.username = tip@ucentral.com
-authentication.default.password = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-```
-The password is a long sequence of hexadecimal digits. It is the result of hashing the `username` and the `password`.
-In order to create the password, please follow these simple instructions.
-```bash
-echo -n "<password><username>" | shasum -a 256
-```
- Here is a complete example for username "root@system.com" and the password being "weLoveWifi".
-```bash
-echo -n "weLoveWifiroot@system.com" | shasum -a 256
-b5bfed31e2a272e52973a57b95042ab842db3999475f3d79f1ce0f45f465e34c  -
-```
-Then you need to modify your properties file like this
-```text
-authentication.default.username = root@system.com
-authentication.default.password = b5bfed31e2a272e52973a57b95042ab842db3999475f3d79f1ce0f45f465e34c
-```
-Remember, when you login you use `root@system.com` with the password `weLoveWifi`, not this monster digit sequence.
-
-#### Is this safe?
-s this safe to show the hash in a text file? Let me put it this way, if you can find a way to break this encryption, you
-would have control over the entire internet. It's incredible safe. if you love math, you can find a lot of videos explaining
-how hashes work and why they are safe.
-
 ### Certificates
 Love'em of hate'em, we gotta use'em. So we tried to make this as easy as possible for you. 
 

build

@@ -1 +1 @@
-108
+109

src/MicroService.cpp

@@ -194,6 +194,7 @@ namespace uCentral {
 			DebugMode_ = ConfigGetBool("ucentral.system.debug",false);
 		MyPrivateEndPoint_ = ConfigGetString("ucentral.system.uri.private");
 		MyPublicEndPoint_ = ConfigGetString("ucentral.system.uri.public");
+		UIURI_ = ConfigGetString("ucentral.system.uri.ui");
 		MyHash_ = CreateHash(MyPublicEndPoint_);
 		InitializeSubSystemServers();
 		ServerApplication::initialize(self);
@@ -451,12 +452,25 @@ namespace uCentral {
 		return false;
 	}
 
+	void MicroService::SavePID() {
+		try {
+			std::ofstream O;
+			O.open(Daemon()->DataDir() + "/pidfile",std::ios::binary | std::ios::trunc);
+			O << Poco::Process::id();
+			O.close();
+		} catch (...)
+		{
+			std::cout << "Could not save system ID" << std::endl;
+		}
+	}
+
 	int MicroService::main(const ArgVec &args) {
 
 		MyErrorHandler	ErrorHandler(*this);
 		Poco::ErrorHandler::set(&ErrorHandler);
 
 		if (!HelpRequested_) {
+			SavePID();
 			Poco::Logger &logger = Poco::Logger::get(DAEMON_APP_NAME);
 			logger.notice(Poco::format("Starting %s version %s.",DAEMON_APP_NAME, Version()));
 

src/MicroService.h

@@ -22,6 +22,7 @@
 #include "Poco/Crypto/Cipher.h"
 #include "Poco/SHA2Engine.h"
 #include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Process.h"
 
 #include "uCentralTypes.h"
 #include "SubSystemServer.h"
@@ -129,6 +130,11 @@ namespace uCentral {
 		[[nodiscard]] MicroServiceMetaVec GetServices();
 		[[nodiscard]] bool IsValidAPIKEY(const Poco::Net::HTTPServerRequest &Request);
 
+		void SavePID();
+		inline uint64_t GetPID() { return Poco::Process::id(); };
+		[[nodiscard]] inline const std::string GetPublicAPIEndPoint() const { return MyPublicEndPoint_ + "/api/v1"; };
+		[[nodiscard]] inline const std::string & GetUIURI() const { return UIURI_;};
+
 	  private:
 		bool                        HelpRequested_ = false;
 		std::string                 LogDir_;
@@ -146,6 +152,7 @@ namespace uCentral {
 		std::string 				MyHash_;
 		std::string 				MyPrivateEndPoint_;
 		std::string 				MyPublicEndPoint_;
+		std::string                 UIURI_;
 		std::string 				Version_;
 		BusEventManager				BusEventManager_;
 		SubMutex 					InfraMutex_;

src/RESTAPI_handler.cpp

@@ -194,12 +194,13 @@ namespace uCentral {
 	}
 
 	void RESTAPIHandler::UnAuthorized(Poco::Net::HTTPServerRequest &Request,
-									  Poco::Net::HTTPServerResponse &Response) {
+									  Poco::Net::HTTPServerResponse &Response,
+                                      const std::string & Reason) {
 		PrepareResponse(Request, Response, Poco::Net::HTTPResponse::HTTP_FORBIDDEN);
 		Poco::JSON::Object	ErrorObject;
 		ErrorObject.set("ErrorCode",403);
 		ErrorObject.set("ErrorDetails",Request.getMethod());
-		ErrorObject.set("ErrorDescription","You do not have access to this resource.");
+		ErrorObject.set("ErrorDescription",Reason.empty() ? "No access allowed." : Reason) ;
 		std::ostream &Answer = Response.send();
 		Poco::JSON::Stringifier::stringify(ErrorObject, Answer);
 	}
@@ -244,7 +245,37 @@ namespace uCentral {
 		Response.sendFile(File.path(),"application/octet-stream");
 	}
 
-	void RESTAPIHandler::ReturnStatus(Poco::Net::HTTPServerRequest &Request,
+    void RESTAPIHandler::SendFile(Poco::File & File, Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response) {
+        Response.set("Content-Type",Utils::FindMediaType(File));
+        Poco::Path  P(File.path());
+        Response.set("Content-Disposition", "attachment; filename=" + P.getBaseName()  );
+        Response.set("Content-Transfer-Encoding","binary");
+        Response.set("Accept-Ranges", "bytes");
+        Response.set("Cache-Control", "private");
+        Response.set("Pragma", "private");
+        Response.set("Expires", "Mon, 26 Jul 2027 05:00:00 GMT");
+        Response.set("Content-Length", std::to_string(File.getSize()));
+        AddCORS(Request, Response);
+        Response.sendFile(File.path(),Utils::FindMediaType(File));
+    }
+
+    void RESTAPIHandler::SendHTMLFileBack(Poco::File & File,
+                          Poco::Net::HTTPServerRequest &Request,
+                          Poco::Net::HTTPServerResponse &Response ,
+                          const Types::StringPairVec & FormVars) {
+        Response.set("Pragma", "private");
+        Response.set("Expires", "Mon, 26 Jul 2027 05:00:00 GMT");
+        Response.set("Content-Length", std::to_string(File.getSize()));
+        AddCORS(Request, Response);
+        auto FormContent = Utils::LoadFile(File.path());
+        Utils::ReplaceVariables(FormContent, FormVars);
+        Response.setChunkedTransferEncoding(true);
+        Response.setContentType("text/html");
+        std::ostream& ostr = Response.send();
+        ostr << FormContent;
+	}
+
+    void RESTAPIHandler::ReturnStatus(Poco::Net::HTTPServerRequest &Request,
 									  Poco::Net::HTTPServerResponse &Response,
 									  Poco::Net::HTTPResponse::HTTPStatus Status,
 									  bool CloseConnection) {

src/RESTAPI_handler.h

@@ -15,15 +15,72 @@
 #include "Poco/Net/HTTPServerRequest.h"
 #include "Poco/Net/HTTPServerResponse.h"
 #include "Poco/Net/NetException.h"
+#include "Poco/Net/PartHandler.h"
+
 #include "Poco/Logger.h"
 #include "Poco/File.h"
 #include "Poco/JSON/Object.h"
+#include "Poco/CountingStream.h"
+#include "Poco/NullStream.h"
 
 #include "RESTAPI_SecurityObjects.h"
 
 namespace uCentral {
 
-	class RESTAPIHandler : public Poco::Net::HTTPRequestHandler {
+    class RESTAPI_PartHandler: public Poco::Net::PartHandler
+    {
+    public:
+        RESTAPI_PartHandler():
+                _length(0)
+        {
+        }
+
+        void handlePart(const Poco::Net::MessageHeader& header, std::istream& stream) override
+        {
+            _type = header.get("Content-Type", "(unspecified)");
+            if (header.has("Content-Disposition"))
+            {
+                std::string disp;
+                Poco::Net::NameValueCollection params;
+                Poco::Net::MessageHeader::splitParameters(header["Content-Disposition"], disp, params);
+                _name = params.get("name", "(unnamed)");
+                _fileName = params.get("filename", "(unnamed)");
+            }
+
+            Poco::CountingInputStream istr(stream);
+            Poco::NullOutputStream ostr;
+            Poco::StreamCopier::copyStream(istr, ostr);
+            _length = (int)istr.chars();
+        }
+
+        [[nodiscard]] int length() const
+        {
+            return _length;
+        }
+
+        [[nodiscard]] const std::string& name() const
+        {
+            return _name;
+        }
+
+        [[nodiscard]] const std::string& fileName() const
+        {
+            return _fileName;
+        }
+
+        [[nodiscard]] const std::string& contentType() const
+        {
+            return _type;
+        }
+
+    private:
+        int _length;
+        std::string _type;
+        std::string _name;
+        std::string _fileName;
+    };
+
+    class RESTAPIHandler : public Poco::Net::HTTPRequestHandler {
 	  public:
 		struct QueryBlock {
 			uint64_t StartDate = 0 , EndDate = 0 , Offset = 0 , Limit = 0, LogType = 0 ;
@@ -64,7 +121,7 @@ namespace uCentral {
 
 		void BadRequest(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response, const std::string &Reason = "");
 		void UnAuthorized(Poco::Net::HTTPServerRequest &Request,
-						  Poco::Net::HTTPServerResponse &Response);
+						  Poco::Net::HTTPServerResponse &Response, const std::string &Reason = "");
 		void ReturnObject(Poco::Net::HTTPServerRequest &Request, Poco::JSON::Object &Object,
 						  Poco::Net::HTTPServerResponse &Response);
 		void NotFound(Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response);
@@ -75,8 +132,14 @@ namespace uCentral {
 						  bool CloseConnection=false);
 		void SendFile(Poco::File & File, const std::string & UUID,
 					  Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response);
+		void SendHTMLFileBack(Poco::File & File,
+                              Poco::Net::HTTPServerRequest &Request,
+                              Poco::Net::HTTPServerResponse &Response ,
+                              const Types::StringPairVec & FormVars);
 
-		const std::string &GetBinding(const std::string &Name, const std::string &Default);
+        void SendFile(Poco::File & File, Poco::Net::HTTPServerRequest &Request, Poco::Net::HTTPServerResponse &Response);
+
+        const std::string &GetBinding(const std::string &Name, const std::string &Default);
 		void InitQueryBlock();
 
 		[[nodiscard]] static uint64_t Get(const char *Parameter,const Poco::JSON::Object::Ptr &Obj, uint64_t Default=0);

src/Utils.cpp

@@ -18,9 +18,10 @@
 #include "Poco/DateTime.h"
 #include "Poco/DateTimeParser.h"
 #include "Poco/StringTokenizer.h"
-#include "Poco/Logger.h"
 #include "Poco/Message.h"
 #include "Poco/File.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Path.h"
 
 #include "uCentralProtocol.h"
 #include "Daemon.h"
@@ -399,4 +400,72 @@ namespace uCentral::Utils {
 		// try to match the string with the regular expression
 		return std::regex_match(email, pattern);
 	}
+
+	std::string LoadFile( const Poco::File & F) {
+	    std::string Result;
+	    try {
+	        std::ostringstream OS;
+	        std::ifstream   IF(F.path());
+	        Poco::StreamCopier::copyStream(IF, OS);
+	        Result = OS.str();
+	    } catch (...) {
+
+	    }
+	    return Result;
+	}
+
+    void ReplaceVariables( std::string & Content , const Types::StringPairVec & P) {
+	    for(const auto &[Variable,Value]:P) {
+	        Poco::replaceInPlace(Content,"${" + Variable + "}", Value);
+	    }
+	}
+
+    std::string FindMediaType(const Poco::File &F) {
+	    Poco::Path  P(F.path());
+	    const auto E = P.getExtension();
+	    if(E=="png")
+	        return "image/png";
+	    if(E=="gif")
+            return "image/gif";
+        if(E=="jpeg")
+            return "image/jpeg";
+        if(E=="jpg")
+            return "image/jpeg";
+        if(E=="svg")
+            return "image/svg";
+        if(E=="html")
+            return "text/html";
+        if(E=="css")
+            return "text/css";
+        if(E=="js")
+            return "application/javascript";
+        return "application/octet-stream";
+	}
+
+	std::string BinaryFileToHexString(const Poco::File &F) {
+        static const char hex[] = "0123456789abcdef";
+        std::string Result;
+        try {
+            std::ifstream IF(F.path());
+
+            int Count = 0;
+            while (IF.good()) {
+                if (Count)
+                    Result += ", ";
+                if ((Count % 32) == 0)
+                    Result += "\r\n";
+                Count++;
+                unsigned char C = IF.get();
+                Result += "0x";
+                Result += (char) (hex[(C & 0xf0) >> 4]);
+                Result += (char) (hex[(C & 0x0f)]);
+            }
+        } catch(...) {
+
+        }
+        return Result;
+	}
+
+
+
 }

src/Utils.h

@@ -13,6 +13,9 @@
 #include <string>
 
 #include "Poco/Net/NetworkInterface.h"
+#include "Poco/String.h"
+#include "Poco/File.h"
+#include "uCentralTypes.h"
 
 #define DBGLINE { std::cout << __FILE__ << ":" << __func__ << ":" << __LINE__ << std::endl; };
 
@@ -50,5 +53,10 @@ namespace uCentral::Utils {
 	[[nodiscard]] uint64_t GetSystemId();
 
 	[[nodiscard]] bool ValidEMailAddress(const std::string &E);
+	[[nodiscard]] std::string LoadFile( const Poco::File & F);
+    void ReplaceVariables( std::string & Content , const Types::StringPairVec & P);
+
+    [[nodiscard]] std::string FindMediaType(const Poco::File &F);
+    [[nodiscard]] std::string BinaryFileToHexString( const Poco::File &F);
 }
 #endif // UCENTRALGW_UTILS_H

ucentralgw.properties

@@ -62,6 +62,7 @@ ucentral.system.data = $UCENTRALGW_ROOT/data
 ucentral.system.debug = true
 ucentral.system.uri.private = https://localhost:17002
 ucentral.system.uri.public = https://local.dpaas.arilia.com:16002
+ucentral.system.uri.ui = https://ucentral-ui.arilia.com
 ucentral.system.commandchannel = /tmp/app.ucentralgw
 
 #
@@ -109,8 +110,8 @@ ucentral.kafka.queue.buffering.max.ms = 50
 # Only one selected at a time. If you select multiple, this service will die if a horrible
 # death and might make your beer flat.
 #
-#storage.type = sqlite
-storage.type = postgresql
+storage.type = sqlite
+#storage.type = postgresql
 #storage.type = mysql
 #storage.type = odbc
 

ucentralgw.properties.aws

@@ -62,6 +62,7 @@ ucentral.system.data = $UCENTRALGW_ROOT/data
 ucentral.system.debug = true
 ucentral.system.uri.private = https://localhost:17002
 ucentral.system.uri.public = https://ucentral.dpaas.arilia.com:16002
+ucentral.system.uri.ui = https://ucentral-ui.arilia.com
 ucentral.system.commandchannel = /tmp/app.ucentralgw
 
 #

ucentralgw.properties.priv

@@ -62,6 +62,7 @@ ucentral.system.data = $UCENTRALGW_ROOT/data
 ucentral.system.debug = true
 ucentral.system.uri.private = https://localhost:17002
 ucentral.system.uri.public = https://local.dpaas.arilia.com:16002
+ucentral.system.uri.ui = https://ucentral-ui.arilia.com
 ucentral.system.commandchannel = /tmp/app.ucentralgw
 
 #