Normalized structure of http_response.

Now it has to use pointers to make use of polymorphism.
Used shared_ptr to guarantee memory management.
Removed internal smart pointer implementation.
Removed internal binder implementation.

Author: etr

ChangeLog

@@ -1,3 +1,11 @@
+Sat Jan 12 00:51:00 2018 -0800
+	Removed the support for integrated COMET logic.
+	Removed the support for caching logic.
+	Added integ tests.
+	Changed http_resource interface to use shared_ptr.
+	Improved interface of the http_response object.
+	Deprecated http_response_builder object.
+
 Thu Dec 26 10:00:30 2018 -0800
 	Fixed IPV6 parsing logic.
 	Added tests to support IP parsing, URL parsing and utilities

configure.ac

@@ -21,7 +21,7 @@
 
 AC_PREREQ(2.57)
 m4_define([libhttpserver_MAJOR_VERSION],[0])dnl
-m4_define([libhttpserver_MINOR_VERSION],[16])dnl
+m4_define([libhttpserver_MINOR_VERSION],[17])dnl
 m4_define([libhttpserver_REVISION],[0])dnl
 m4_define([libhttpserver_PKG_VERSION],[libhttpserver_MAJOR_VERSION.libhttpserver_MINOR_VERSION.libhttpserver_REVISION])dnl
 m4_define([libhttpserver_LDF_VERSION],[libhttpserver_MAJOR_VERSION:libhttpserver_MINOR_VERSION:libhttpserver_REVISION])dnl

examples/hello_world.cpp

@@ -25,13 +25,13 @@ using namespace httpserver;
 
 class hello_world_resource : public http_resource {
 	public:
-        const http_response render(const http_request&);
+        const std::shared_ptr<http_response> render(const http_request&);
         void set_some_data(const std::string &s) {data = s;}
         std::string data;
 };
 
 //using the render method you are able to catch each type of request you receive
-const http_response hello_world_resource::render(const http_request& req)
+const std::shared_ptr<http_response> hello_world_resource::render(const http_request& req)
 {
     //it is possible to store data inside the resource object that can be altered
     //through the requests
@@ -42,7 +42,7 @@ const http_response hello_world_resource::render(const http_request& req)
 
     //it is possible to send a response initializing an http_string_response
     //that reads the content to send in response from a string.
-    return http_response_builder("Hello World!!!", 200).string_response();
+    return std::shared_ptr<http_response>(new string_response("Hello World!!!", 200));
 }
 
 int main()

examples/service.cpp

@@ -32,15 +32,15 @@ class service_resource: public http_resource {
 	service_resource();
 
 	~service_resource();
-	
-	const http_response render_GET(const http_request &req);
-	const http_response render_PUT(const http_request &req);
-	const http_response render_POST(const http_request &req);	
-	const http_response render(const http_request &req);
-	const http_response render_HEAD(const http_request &req);
-	const http_response render_OPTIONS(const http_request &req);
-	const http_response render_CONNECT(const http_request &req);
-	const http_response render_DELETE(const http_request &req);
+
+	const std::shared_ptr<http_response> render_GET(const http_request &req);
+	const std::shared_ptr<http_response> render_PUT(const http_request &req);
+	const std::shared_ptr<http_response> render_POST(const http_request &req);
+	const std::shared_ptr<http_response> render(const http_request &req);
+	const std::shared_ptr<http_response> render_HEAD(const http_request &req);
+	const std::shared_ptr<http_response> render_OPTIONS(const http_request &req);
+	const std::shared_ptr<http_response> render_CONNECT(const http_request &req);
+	const std::shared_ptr<http_response> render_DELETE(const http_request &req);
 
 private:
 
@@ -53,120 +53,118 @@ service_resource::service_resource()
 service_resource::~service_resource()
 {}
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_GET(const http_request &req)
 {
     std::cout << "service_resource::render_GET()" << std::endl;
 
     if (verbose) std::cout << req;
+    string_response* res = new string_response("GET response", 200);
 
-    http_response res(http_response_builder("GET response", 200).string_response());
-
-    if (verbose) std::cout << res;    
-
-    return res;
+    if (verbose) std::cout << *res;
 
+    return std::shared_ptr<http_response>(res);
 }
 
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_PUT(const http_request &req)
 {
-    std::cout << "service_resource::render_PUT()" << std::endl;	
+    std::cout << "service_resource::render_PUT()" << std::endl;
 
     if (verbose) std::cout << req;
-    
-    http_response res(http_response_builder("PUT response", 200).string_response());
 
-    if (verbose) std::cout << res;
+    string_response* res = new string_response("PUT response", 200);
 
-    return res;
+    if (verbose) std::cout << *res;
+
+    return std::shared_ptr<http_response>(res);
 }
 
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_POST(const http_request &req)
 {
-    std::cout << "service_resource::render_POST()" << std::endl;	
+    std::cout << "service_resource::render_POST()" << std::endl;
 
     if (verbose) std::cout << req;
-    
-    http_response res(http_response_builder("POST response", 200).string_response());
 
-    if (verbose) std::cout << res;
+    string_response* res = new string_response("POST response", 200);
+
+    if (verbose) std::cout << *res;
 
-    return res;    
+    return std::shared_ptr<http_response>(res);
 }
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render(const http_request &req)
 {
-    std::cout << "service_resource::render()" << std::endl;	
+    std::cout << "service_resource::render()" << std::endl;
 
     if (verbose) std::cout << req;
 
-    http_response res(http_response_builder("generic response", 200).string_response());
+    string_response* res = new string_response("generic response", 200);
 
-    if (verbose) std::cout << res;
+    if (verbose) std::cout << *res;
 
-    return res;    
+    return std::shared_ptr<http_response>(res);
 }
 
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_HEAD(const http_request &req)
 {
     std::cout << "service_resource::render_HEAD()" << std::endl;
 
     if (verbose) std::cout << req;
-    
-    http_response res(http_response_builder("HEAD response", 200).string_response());
 
-    if (verbose) std::cout << res;
+    string_response* res = new string_response("HEAD response", 200);
 
-    return res;    
+    if (verbose) std::cout << *res;
+
+    return std::shared_ptr<http_response>(res);
 }
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_OPTIONS(const http_request &req)
 {
     std::cout << "service_resource::render_OPTIONS()" << std::endl;
 
     if (verbose) std::cout << req;
-    
-    http_response res(http_response_builder("OPTIONS response", 200).string_response());
 
-    if (verbose) std::cout << res;
+    string_response* res = new string_response("OPTIONS response", 200);
+
+    if (verbose) std::cout << *res;
 
-    return res;    
+    return std::shared_ptr<http_response>(res);
 }
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_CONNECT(const http_request &req)
 {
-    std::cout << "service_resource::render_CONNECT()" << std::endl;	
+    std::cout << "service_resource::render_CONNECT()" << std::endl;
 
     if (verbose) std::cout << req;
-    
-    http_response res(http_response_builder("CONNECT response", 200).string_response());
 
-    if (verbose) std::cout << res;
+    string_response* res = new string_response("CONNECT response", 200);
 
-    return res;    
+    if (verbose) std::cout << *res;
+
+    return std::shared_ptr<http_response>(res);
 }
 
-const http_response
+const std::shared_ptr<http_response>
 service_resource::render_DELETE(const http_request &req)
 {
-    std::cout << "service_resource::render_DELETE()" << std::endl;	
+    std::cout << "service_resource::render_DELETE()" << std::endl;
 
     if (verbose) std::cout << req;
-    
-    http_response res(http_response_builder("DELETE response", 200).string_response());
 
-    if (verbose) std::cout << res;
+    string_response* res = new string_response("DELETE response", 200);
+
+    if (verbose) std::cout << *res;
 
-    return res;    
+    return std::shared_ptr<http_response>(res);
 }
 
 void usage()

src/Makefile.am

@@ -19,9 +19,9 @@
 AM_CPPFLAGS = -I../ -I$(srcdir)/httpserver/
 METASOURCES = AUTO
 lib_LTLIBRARIES = libhttpserver.la
-libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp http_utils.cpp http_request.cpp http_response.cpp http_resource.cpp details/http_endpoint.cpp
-noinst_HEADERS = httpserver/string_utilities.hpp httpserver/details/modded_request.hpp httpserver/details/http_response_ptr.hpp gettext.h
-nobase_include_HEADERS = httpserver.hpp httpserver/create_webserver.hpp httpserver/webserver.hpp httpserver/http_utils.hpp httpserver/details/http_endpoint.hpp httpserver/http_request.hpp httpserver/http_response.hpp httpserver/http_resource.hpp httpserver/binders.hpp httpserver/http_response_builder.hpp
+libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp http_utils.cpp http_request.cpp http_response.cpp string_response.cpp basic_auth_fail_response.cpp digest_auth_fail_response.cpp deferred_response.cpp file_response.cpp http_resource.cpp details/http_endpoint.cpp
+noinst_HEADERS = httpserver/string_utilities.hpp httpserver/details/modded_request.hpp gettext.h
+nobase_include_HEADERS = httpserver.hpp httpserver/create_webserver.hpp httpserver/webserver.hpp httpserver/http_utils.hpp httpserver/details/http_endpoint.hpp httpserver/http_request.hpp httpserver/http_response.hpp httpserver/http_resource.hpp httpserver/string_response.hpp httpserver/basic_auth_fail_response.hpp httpserver/digest_auth_fail_response.hpp httpserver/deferred_response.hpp httpserver/file_response.hpp
 
 AM_CXXFLAGS += -fPIC -Wall
 

src/basic_auth_fail_response.cpp

@@ -0,0 +1,37 @@
+/*
+     This file is part of libhttpserver
+     Copyright (C) 2011-2019 Sebastiano Merlino
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+     USA
+*/
+
+#include "basic_auth_fail_response.hpp"
+
+using namespace std;
+
+namespace httpserver
+{
+
+int basic_auth_fail_response::enqueue_response(MHD_Connection* connection, MHD_Response* response)
+{
+    return MHD_queue_basic_auth_fail_response(
+            connection,
+            realm.c_str(),
+            response
+    );
+}
+
+}

src/deferred_response.cpp

@@ -0,0 +1,71 @@
+/*
+     This file is part of libhttpserver
+     Copyright (C) 2011-2019 Sebastiano Merlino
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+     USA
+*/
+
+#include "deferred_response.hpp"
+
+using namespace std;
+
+namespace httpserver
+{
+
+namespace details
+{
+
+ssize_t cb(void* cls, uint64_t pos, char* buf, size_t max)
+{
+    ssize_t val = static_cast<deferred_response*>(cls)->cycle_callback(buf, max);
+    if(val == -1)
+    {
+        static_cast<deferred_response*>(cls)->completed = true;
+    }
+
+    return val;
+}
+
+}
+
+MHD_Response* deferred_response::get_raw_response()
+{
+    if(!completed)
+    {
+        return MHD_create_response_from_callback(
+                MHD_SIZE_UNKNOWN,
+                1024,
+                &details::cb,
+                this,
+                NULL
+        );
+    }
+    else
+    {
+        return static_cast<string_response*>(this)->get_raw_response();
+    }
+}
+
+void deferred_response::decorate_response(MHD_Response* response)
+{
+    if(completed)
+    {
+        static_cast<string_response*>(this)->decorate_response(response);
+    }
+}
+
+}
+

src/digest_auth_fail_response.cpp

@@ -0,0 +1,39 @@
+/*
+     This file is part of libhttpserver
+     Copyright (C) 2011-2019 Sebastiano Merlino
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+     USA
+*/
+
+#include "digest_auth_fail_response.hpp"
+
+using namespace std;
+
+namespace httpserver
+{
+
+int digest_auth_fail_response::enqueue_response(MHD_Connection* connection, MHD_Response* response)
+{
+    return MHD_queue_auth_fail_response(
+            connection,
+            realm.c_str(),
+            opaque.c_str(),
+            response,
+            reload_nonce ? MHD_YES : MHD_NO
+    );
+}
+
+}