Merge pull request #8 from coding-cpp/fix/1

add cookies and other stuff

Author: Jadit19

include/mochios/client/client.h

@@ -8,6 +8,7 @@
 
 #include <mochios/client/options.h>
 #include <mochios/interceptors/interceptor.h>
+#include <mochios/interceptors/request/cookie.h>
 #include <mochios/interceptors/request/user_agent.h>
 #include <mochios/interceptors/response/json.h>
 
@@ -19,6 +20,7 @@ class Client {
   struct addrinfo *server;
 
   mochios::client::Connection connection;
+  mochios::interceptor::Interceptors internalInterceptors;
 
   void connect();
   mochios::messages::Response sendHelper(mochios::messages::Request &request);

include/mochios/helpers/cookie.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <mochios/messages/cookie.h>
+
+namespace mochios {
+
+namespace helpers {
+
+namespace cookie {
+
+std::string serialize(const mochios::messages::Cookie &cookie);
+
+} // namespace cookie
+
+} // namespace helpers
+
+} // namespace mochios

include/mochios/interceptors/request/cookie.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <mochios/messages/cookie.h>
+#include <mochios/messages/request.h>
+
+namespace mochios {
+
+namespace interceptor {
+
+namespace request {
+
+void cookie(mochios::messages::Request &request);
+
+} // namespace request
+
+} // namespace interceptor
+
+} // namespace mochios

include/mochios/messages/cookie.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <brewtils/string.h>
+#include <brewtils/url.h>
+#include <logger/log.h>
+
+namespace mochios {
+
+namespace messages {
+
+class Cookie {
+public:
+  bool secure;
+  bool httpOnly;
+  bool partitioned;
+
+  std::string name;
+  std::string value;
+  std::string domain;
+  std::string path;
+  std::string expires;
+  std::string maxAge;
+  std::string sameSite;
+
+  Cookie();
+  Cookie(const std::string &data);
+  ~Cookie();
+
+  std::string serialize() const;
+};
+
+} // namespace messages
+
+} // namespace mochios

include/mochios/messages/message.h

@@ -3,6 +3,8 @@
 #include <brewtils/string.h>
 #include <json/parse.h>
 
+#include <mochios/messages/cookie.h>
+
 namespace mochios {
 
 namespace messages {
@@ -19,6 +21,7 @@ class Message {
   std::map<std::string, std::string> headers;
   std::map<std::string, std::string> params;
   std::map<std::string, std::string> queries;
+  std::vector<mochios::messages::Cookie *> cookies;
   json::object body;
 
   void set(const std::string &key, const std::string &value);

src/client/client.cpp

@@ -18,8 +18,10 @@ mochios::Client::Client(const mochios::client::Connection &connection)
   this->connect();
   close(this->socket);
 
-  this->interceptors.request.use(mochios::interceptor::request::userAgent);
-  this->interceptors.response.use(mochios::interceptor::response::json);
+  this->internalInterceptors.request.use(
+      mochios::interceptor::request::userAgent);
+  this->internalInterceptors.request.use(mochios::interceptor::request::cookie);
+  this->internalInterceptors.response.use(mochios::interceptor::response::json);
   return;
 }
 
@@ -101,9 +103,19 @@ mochios::Client::sendHelper(mochios::messages::Request &request) {
            &requestInterceptor : this->interceptors.request.interceptors) {
     requestInterceptor(request);
   }
+  for (const std::function<void(mochios::messages::Request &)>
+           &requestInterceptor :
+       this->internalInterceptors.request.interceptors) {
+    requestInterceptor(request);
+  }
   this->connect();
   mochios::messages::Response res =
       mochios::helpers::send(request, this->socket);
+  for (const std::function<void(mochios::messages::Response &)>
+           &responseInterceptor :
+       this->internalInterceptors.response.interceptors) {
+    responseInterceptor(res);
+  }
   for (const std::function<void(mochios::messages::Response &)>
            &responseInterceptor : this->interceptors.response.interceptors) {
     responseInterceptor(res);

src/helpers/client.cpp

@@ -46,8 +46,15 @@ void mochios::helpers::buildResponse(mochios::messages::Response &res,
       continue;
     }
 
-    std::string key = line.substr(0, separator);
+    std::string key = brewtils::string::lower(line.substr(0, separator));
     std::string value = line.substr(separator + 2, line.size() - separator - 3);
+    if (key == "set-cookie") {
+      mochios::messages::Cookie *newCookie =
+          new mochios::messages::Cookie(value);
+      res.cookies.push_back(newCookie);
+      continue;
+    }
+
     res.set(key, value);
   }
 

src/helpers/cookie.cpp

@@ -0,0 +1,32 @@
+#include <mochios/helpers/cookie.h>
+
+std::string
+mochios::helpers::cookie::serialize(const mochios::messages::Cookie &cookie) {
+  std::string cookieString = brewtils::url::encode(cookie.name) + "=" +
+                             brewtils::url::encode(cookie.value);
+  if (!cookie.domain.empty()) {
+    cookieString += "; Domain=" + cookie.domain;
+  }
+  if (!cookie.path.empty()) {
+    cookieString += "; Path=" + cookie.path;
+  }
+  if (!cookie.expires.empty()) {
+    cookieString += "; Expires=" + cookie.expires;
+  }
+  if (!cookie.maxAge.empty()) {
+    cookieString += "; Max-Age=" + cookie.maxAge;
+  }
+  if (!cookie.sameSite.empty()) {
+    cookieString += "; SameSite=" + cookie.sameSite;
+  }
+  if (cookie.secure) {
+    cookieString += "; Secure";
+  }
+  if (cookie.httpOnly) {
+    cookieString += "; HttpOnly";
+  }
+  if (cookie.partitioned) {
+    cookieString += "; Partitioned";
+  }
+  return cookieString;
+}

src/interceptors/request/cookie.cpp

@@ -0,0 +1,20 @@
+#include <mochios/interceptors/request/cookie.h>
+
+void mochios::interceptor::request::cookie(
+    mochios::messages::Request &request) {
+  bool isFirst = true;
+  std::string value = "";
+  for (const mochios::messages::Cookie *cookie : request.cookies) {
+    if (isFirst) {
+      isFirst = false;
+    } else {
+      value += "; ";
+    }
+    value += cookie->name + "=" + cookie->value;
+  }
+
+  if (!value.empty()) {
+    request.headers["Cookie"] = value;
+  }
+  return;
+}

src/messages/cookie.cpp

@@ -0,0 +1,62 @@
+#include <mochios/helpers/cookie.h>
+#include <mochios/messages/cookie.h>
+
+mochios::messages::Cookie::Cookie()
+    : secure(false), httpOnly(false), partitioned(false), name(""), value(""),
+      domain(""), path(""), expires(""), maxAge(""), sameSite("") {
+  return;
+}
+
+mochios::messages::Cookie::Cookie(const std::string &data) {
+  std::string key, value;
+  std::vector<std::string> kv;
+  std::vector<std::string> parts = brewtils::string::split(data, ";");
+
+  for (const std::string &part : parts) {
+    kv = brewtils::string::split(part, "=");
+    if (kv.size() == 0) {
+      continue;
+    }
+
+    key = brewtils::string::lower(
+        brewtils::url::decode(brewtils::string::trim(kv[0])));
+    if (kv.size() == 1) {
+      if (key == "secure") {
+        this->secure = true;
+      } else if (key == "httponly") {
+        this->httpOnly = true;
+      } else if (key == "partitioned") {
+        this->partitioned = true;
+      }
+      continue;
+    }
+
+    value = brewtils::url::decode(brewtils::string::trim(kv[1]));
+    if (key == "domain") {
+      this->domain = value;
+    } else if (key == "path") {
+      this->path = value;
+    } else if (key == "expires") {
+      this->expires = value;
+    } else if (key == "max-age") {
+      this->maxAge = value;
+    } else if (key == "samesite") {
+      this->sameSite = value;
+    } else {
+      this->name = brewtils::url::decode(brewtils::string::trim(kv[0]));
+      this->value = value;
+    }
+  }
+
+  if (this->name.empty()) {
+    logger::warning("Cookie name empty in data: " + data);
+  }
+
+  return;
+}
+
+mochios::messages::Cookie::~Cookie() { return; }
+
+std::string mochios::messages::Cookie::serialize() const {
+  return mochios::helpers::cookie::serialize(*this);
+}