initial commit into repository0.0

7 files changed, 410 insertions, 0 deletions

diff --git a/include/.gitignore b/include/.gitignore
new file mode 100644
index 0000000..3dda729
--- a/dev/null
+++ b/include/.gitignore
@@ -0,0 +1,2 @@
+Makefile.in
+Makefile
diff --git a/include/Makefile.am b/include/Makefile.am
new file mode 100644
index 0000000..c1ec36e
--- a/dev/null
+++ b/include/Makefile.am
@@ -0,0 +1,6 @@
+nobase_include_HEADERS = \
+    kingate/cgi_gateway.h \
+    kingate/cgi_interface.h \
+    kingate/fastcgi.h \
+    kingate/exception.h \
+    kingate/util.h
diff --git a/include/kingate/cgi_gateway.h b/include/kingate/cgi_gateway.h
new file mode 100644
index 0000000..f683580
--- a/dev/null
+++ b/include/kingate/cgi_gateway.h
@@ -0,0 +1,164 @@
+#ifndef __KINGATE_CGI_GATEWAY_H
+#define __KINGATE_CGI_GATEWAY_H
+
+#include <map>
+#include "kingate/cgi_interface.h"
+
+/**
+ * @file
+ * @brief the cgi_gateway -- main interface to CGI.
+ */
+
+namespace kingate {
+    using namespace std;
+
+    /**
+     * The main class interfacing with the CGI environment.
+     */
+    class cgi_gateway {
+	public:
+	    /**
+	     * The interface to CGI environment (e.g. fastcgi).
+	     */
+	    cgi_interface& iface;
+	    /**
+	     * The type describing map holding parameters parsed from query string or input.
+	     */
+	    typedef multimap<string,string> params_t;
+	    /**
+	     * The GET-passed parameters.
+	     */
+	    params_t get;
+	    /**
+	     * The POST-passed parameters.
+	     */
+	    params_t post;
+	    /**
+	     * Was the stdin content parsed?
+	     */
+	    bool b_parsed_content;
+
+	    /**
+	     * @param ci the interface to use.
+	     */
+	    cgi_gateway(cgi_interface& ci);
+
+	    /**
+	     * Check whether there is an 'environment' meta-variable with specific name
+	     * passed to CGI.
+	     * @param n variable name.
+	     * @return true if yes.
+	     * @see cgi_interface::has_meta()
+	     * @see get_meta()
+	     */
+	    bool has_meta(const string& n) const { return iface.has_meta(n); }
+	    /**
+	     * Retrieve the 'environment' meta-variable value.
+	     * @param n variable name.
+	     * @return variable contents.
+	     * @see exception_notfound
+	     * @see cgi_interface::get_meta()
+	     */
+	    string get_meta(const string& n) const { return iface.get_meta(n); }
+
+	    /**
+	     * fetch reference to the 'stdin' stream.
+	     * @return the reference to the corresponding istream object.
+	     * @see cgi_interface::in()
+	     */
+	    istream& in() { return iface.in(); }
+	    /**
+	     * fetch reference to the 'stdout' stream.
+	     * @return the reference to the corresponding ostream object.
+	     * @see cgi_interface::out()
+	     */
+	    ostream& out() { return iface.out(); }
+	    /**
+	     * fetch reference to the 'stderr' stream.
+	     * @return the reference to the corresponding ostream object.
+	     * @see cgi_interface::err()
+	     */
+	    ostream& err() { return iface.err(); }
+	    /**
+	     * cast to the ostream -- fetches the reference to the 'stdout'
+	     * stream.
+	     * @see out()
+	     */
+	    operator ostream& (void) { return out(); }
+
+	    /**
+	     * Check to see whether the parameter was passed via GET.
+	     * @param n the parameter name.
+	     * @return true if yes.
+	     */
+	    bool has_GET(const string& n) const;
+	    /**
+	     * Retrieve the parameter passed via GET.
+	     * @param n the parameter name.
+	     * @return the parameter contents.
+	     * @see exception_notfound
+	     */
+	    string get_GET(const string& n) const;
+	    /**
+	     * Check to see whether the parameter was passed via POST.
+	     * @param n the parameter name.
+	     * @return true if yes.
+	     */
+	    bool has_POST(const string& n) const;
+	    /**
+	     * Retrieve the POST-parameter.
+	     * @param n the parameter name.
+	     * @return the parameter contents.
+	     * @see exception_notfound
+	     */
+	    string get_POST(const string& n) const;
+	    /**
+	     * Check to see whether the parameter was passed either via POST or
+	     * GET.
+	     * @param n the parameter name.
+	     * @return true if yes.
+	     */
+	    bool has_param(const string& n) const;
+	    /**
+	     * Retrieve the parameter passed either via POST or GET
+	     * (GET-parameter takes precedence).
+	     * @param n the parameter name.
+	     * @return true if yes.
+	     * @see exception_notfound.
+	     */
+	    string get_param(const string& n) const;
+
+	    /**
+	     * Retrieve the POST content-type (as passed via CONTENT_TYPE
+	     * environment variable).
+	     * @return the content type.
+	     */
+	    const string& get_content_type() const;
+	    /**
+	     * Retrieve the POST content length (as passed via the
+	     * CONTENT_LENGTH environment variable).
+	     * @return the content length.
+	     */
+	    unsigned long get_content_length() const;
+
+	    /**
+	     * Check to see whether the content from stdin stream was parsed.
+	     * @return true if yes.
+	     */
+	    bool is_content_parsed() const { return b_parsed_content; }
+	private:
+	    /**
+	     * Parse the query string, putting the parameters into the map
+	     * specified.
+	     * @param q the query string.
+	     * @param p destination parameters map.
+	     */
+	    static void parse_query(string& q,params_t& p);
+    };
+
+}
+
+#endif /* __KINGATE_CGI_GATEWAY_H */
+/*
+ * vim:set ft=cpp:
+ */
diff --git a/include/kingate/cgi_interface.h b/include/kingate/cgi_interface.h
new file mode 100644
index 0000000..84ea6dd
--- a/dev/null
+++ b/include/kingate/cgi_interface.h
@@ -0,0 +1,70 @@
+#ifndef __KINGATE_CGI_INTERFACE_H
+#define __KINGATE_CGI_INTERFACE_H
+
+#include <iostream>
+#include <string>
+#include <map>
+
+/**
+ * @file
+ * @brief the abstract base for various interfaces to CGI.
+ */
+
+namespace kingate {
+    using namespace std;
+
+    /**
+     * The abstract base class for interface to CGI subsystem.
+     */
+    class cgi_interface {
+	public:
+	    /**
+	     * The type for map holding 'environment' meta-variables.
+	     */
+	    typedef map<string,string> metavars_t;
+	    /**
+	     * The environment variables.
+	     */
+	    metavars_t metavars;
+
+	    cgi_interface() { }
+	    virtual ~cgi_interface() { }
+
+	    /**
+	     * Check to see whether there is a particular 'environment'
+	     * meta-variable passed.
+	     * @param n the variable name.
+	     * @return true if yes.
+	     */
+	    bool has_meta(const string& n) const;
+	    /**
+	     * Retrieve the 'environment' variable.
+	     * @param n the variable name.
+	     * @return the variable contents.
+	     * @see exception_notfound
+	     */
+	    const string& get_meta(const string& n) const;
+
+	    /**
+	     * Fetch reference to CGI 'stdout' stream.
+	     * @return reference to the corresponding ostream object.
+	     */
+	    virtual ostream& out() = 0;
+	    /**
+	     * Fetch reference to CGI 'stdin' stream.
+	     * @return reference to the corresponding istream object.
+	     */
+	    virtual istream& in() = 0;
+	    /**
+	     * Fetch reference to CGI 'stderr' stream.
+	     * @return reference to the corresponding ostream object.
+	     */
+	    virtual ostream& err() = 0;
+    };
+
+}
+
+#endif /* __KINGATE_CGI_INTERFACE_H */
+/*
+ * vim:set ft=cpp:
+ */
diff --git a/include/kingate/exception.h b/include/kingate/exception.h
new file mode 100644
index 0000000..6ebb361
--- a/dev/null
+++ b/include/kingate/exception.h
@@ -0,0 +1,44 @@
+#ifndef __KINGATE_EXCEPTION_H
+#define __KINGATE_EXCEPTION_H
+
+#include <stdexcept>
+#include <konforka/exception.h>
+
+/**
+ * @file
+ * @brief The kingate-specific exceptions.
+ */
+
+/**
+ * @brief the main kingate namespace.
+ */
+namespace kingate {
+    using namespace std;
+
+    /**
+     * The base for kingate-specific exception.
+     */
+    class exception : public konforka::exception {
+	public:
+	    explicit exception(const string& w)
+		: konforka::exception(NOCODEPOINT,w) { }
+	    exception(const string& fi,const string& fu,int l,const string &w)
+		: konforka::exception(fi,fu,l,w) { }
+    };
+
+    /**
+     * Thrown if the specified variable or parameter wasn't found.
+     */
+    class exception_notfound : public exception {
+	public:
+	    explicit exception_notfound(const string& w)
+		: exception(w) { }
+	    exception_notfound(const string& fi,const string& fu,int l,const string& w)
+		: exception(fi,fu,l,w) { }
+    };
+}
+
+#endif /* __KINGATE_EXCEPTION_H */
+/*
+ * vim:set ft=cpp:
+ */
diff --git a/include/kingate/fastcgi.h b/include/kingate/fastcgi.h
new file mode 100644
index 0000000..fd293b9
--- a/dev/null
+++ b/include/kingate/fastcgi.h
@@ -0,0 +1,98 @@
+#ifndef __KINGATE_FASTCGI_H
+#define __KINGATE_FASTCGI_H
+
+#include "kingate/cgi_interface.h"
+#include <fcgio.h>
+
+/**
+ * @file
+ * @brief the fastcgi-specific implementation.
+ */
+
+namespace kingate {
+
+    /**
+     * The fcgi listening socket.
+     */
+    class fcgi_socket {
+	    static bool _initialized;
+	public:
+	    /**
+	     * socket file descriptor.
+	     */
+	    int sock;
+
+	    /**
+	     * @param s the socket name. (if the socket starts with a colon,
+	     * then it is interpreted as a tcp port number.
+	     * @param bl backlog listen queue depth.
+	     */
+	    fcgi_socket(const char* s,int bl);
+	    /**
+	     * @param s the file descriptor of preopened socket.
+	     */
+	    fcgi_socket(int s);
+	    ~fcgi_socket();
+    };
+
+    /**
+     * The implementation of the interface to the FastCGI.
+     */
+    class fcgi_interface : public cgi_interface {
+	public:
+	    /**
+	     * stdin fcgi streambuf.
+	     */
+	    fcgi_streambuf sbin;
+	    /**
+	     * stdout fcgi streambuf.
+	     */
+	    fcgi_streambuf sbout;
+	    /**
+	     * stderr fcgi streambuf.
+	     */
+	    fcgi_streambuf sberr;
+	    /**
+	     * stdin istream.
+	     */
+	    istream sin;
+	    /**
+	     * stdout ostream.
+	     */
+	    ostream sout;
+	    /**
+	     * stderr ostream.
+	     */
+	    ostream serr;
+	    /**
+	     * The FCGI request.
+	     */
+	    FCGX_Request request;
+
+	    /**
+	     * @param s the socked used for interfacing with the server.
+	     * @param f the request flags (e.g. FCGI_FAIL_ON_INTR).
+	     */
+	    fcgi_interface(fcgi_socket& s,int f=0);
+	    virtual ~fcgi_interface();
+
+	    /**
+	     * @overload cgi_interface::in()
+	     */
+	    istream& in() { return sin; }
+	    /**
+	     * @overload cgi_interface::out()
+	     */
+	    ostream& out() { return sout; }
+	    /**
+	     * @overload cgi_interface::out()
+	     */
+	    ostream& err() { return serr; }
+    };
+
+}
+
+#endif /* __KINGATE_FASTCGI_H */
+/*
+ * vim:set ft=cpp:
+ */
diff --git a/include/kingate/util.h b/include/kingate/util.h
new file mode 100644
index 0000000..4b0dca8
--- a/dev/null
+++ b/include/kingate/util.h
@@ -0,0 +1,26 @@
+#ifndef __KINGATE_UTIL_H
+#define __KINGATE_UTIL_H
+
+#include <string>
+
+namespace kingate {
+    using namespace std;
+
+    /**
+     * Escape string for passing via URL.
+     * @param str string unescaped.
+     * @return the escaped string.
+     */
+    string url_escape(const string& str);
+    /**
+     * Remove URL-encoding from the string.
+     * @param str the URL-encoded string.
+     * @return the unescaped string.
+     */
+    string url_unescape(const string& str);
+}
+
+#endif /* __KINGATE_UTIL_H */
+/*
+ * vim:set ft=cpp:
+ */