the whole library rewritten

Signed-off-by: Michael Krelin <hacker@klever.net>

10 files changed, 495 insertions, 132 deletions

diff --git a/include/Makefile.am b/include/Makefile.am
index 51dcea1..50fcb62 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -1,3 +1,6 @@
-nobase_include_HEADERS = \
+NODIST_HEADERS_ = \
 	opkele/acconfig.h \
+	opkele/tr1-mem.h
+
+nobase_include_HEADERS = \
 	opkele/opkele-config.h \
@@ -13,6 +16,10 @@ nobase_include_HEADERS = \
 	opkele/xserver.h \
-	opkele/discovery.h \
 	opkele/uris.h \
-	opkele/tr1-mem.h
-EXTRA_DIST = \
+	opkele/tr1-mem.h \
+	opkele/basic_rp.h \
+	opkele/prequeue_rp.h \
+	opkele/iterator.h \
+	${NODIST_HEADERS_}
+
+noinst_HEADERS = \
 	opkele/data.h \
@@ -20,2 +27,6 @@ EXTRA_DIST = \
 	opkele/util.h \
-	opkele/debug.h
+	opkele/debug.h \
+	opkele/discovery.h
+
+dist-hook:
+	rm -f $(addprefix ${distdir}/,${NODIST_HEADERS_})
diff --git a/include/opkele/basic_rp.h b/include/opkele/basic_rp.h
new file mode 100644
index 0000000..3f17fd9
--- a/dev/null
+++ b/include/opkele/basic_rp.h
@@ -0,0 +1,218 @@
+#ifndef __OPKELE_BASIC_RP_H
+#define __OPKELE_BASIC_RP_H
+
+#include <cstring>
+#include <string>
+#include <opkele/types.h>
+#include <opkele/extension.h>
+
+namespace opkele {
+    using std::string;
+
+    struct openid_endpoint_t {
+	string uri;
+	string claimed_id;
+	string local_id;
+
+	openid_endpoint_t() { }
+	openid_endpoint_t(const string& u,const string& cid,const string& lid)
+	    : uri(u), claimed_id(cid), local_id(lid) { }
+
+	bool operator==(const openid_endpoint_t& x) const {
+	    return uri==x.uri && local_id==x.local_id; }
+	bool operator<(const openid_endpoint_t& x) const {
+	    int c;
+	    return (c=strcmp(uri.c_str(),x.uri.c_str()))
+		? (c<0) : (strcmp(local_id.c_str(),x.local_id.c_str())<0); }
+    };
+
+    class basic_RP {
+	public:
+
+	    virtual ~basic_RP() { }
+
+	    /**
+	     * @name Global persistent store API
+	     * These are functions related to the associations with OP storage
+	     * and retrieval and nonce records. They provide an interface to
+	     * the persistent storage which is shared by all sessions. If the
+	     * implementor prefers the dumb mode instead, the function should
+	     * throw dumb_RP exception instead.
+	     * @see opkele::dumb_RP
+	     * @{
+	     */
+	    /**
+	     * Store association and return allocated association object.
+	     * @param OP OP endpoint
+	     * @param handle association handle
+	     * @param type association type
+	     * @param secret association secret
+	     * @params expires_in the number of seconds association expires in
+	     * @return the association object
+	     * @throw dumb_RP for dumb RP
+	     */
+	    virtual assoc_t store_assoc(
+		    const string& OP,const string& handle,
+		    const string& type,const secret_t& secret,
+		    int expires_in) = 0;
+	    /**
+	     * Find valid unexpired association with an OP.
+	     * @param OP OP endpoint URL
+	     * @return association found
+	     * @throw failed_lookup if no association found
+	     * @throw dumb_RP for dumb RP
+	     */
+	    virtual assoc_t find_assoc(
+		    const string& OP) = 0;
+	    /**
+	     * Retrieve valid association handle for an OP by handle.
+	     * @param OP OP endpoint URL
+	     * @param handle association handle
+	     * @return association found
+	     * @throw failed_lookup if no association found
+	     * @throw dumb_RP for dumb RP
+	     */
+	    virtual assoc_t retrieve_assoc(
+		    const string& OP,const string& handle) = 0;
+	    /**
+	     * Invalidate association with OP
+	     * @param OP OP endpoint URL
+	     * @param handle association handle
+	     * @throw dumb_RP for dumb RP
+	     */
+	    virtual void invalidate_assoc(const string& OP,const string& handle) = 0;
+
+	    /**
+	     * Check the nonce validity. That is, check that we haven't
+	     * accepted request with this nonce from this OP, yet. May involve
+	     * cutting off by the timestamp and checking the rest against the
+	     * store of seen nonces.
+	     * @param OP OP endpoint URL
+	     * @param nonce nonce value
+	     * @throw id_res_bad_nonce if the nonce is not to be accepted, i.e.
+	     * either too old or seen.
+	     */
+	    virtual void check_nonce(const string& OP,const string& nonce) = 0;
+	    /**
+	     * @}
+	     */
+
+	    /**
+	     * @name Session persistent store API
+	     * @{
+	     */
+	    /**
+	     * Retrieve OpenID endpoint being currently used for
+	     * authentication. If there is no endpoint available, throw a
+	     * no_endpoint exception.
+	     * @return reference to the service endpoint object
+	     * @see next_endpoint
+	     * @throw no_endpoint if no endpoint available
+	     */
+	    virtual const openid_endpoint_t& get_endpoint() const = 0;
+	    /**
+	     * Advance to the next endpoint to try.
+	     * @see get_endpoint()
+	     * @throw no_endpoint if there are no more endpoints
+	     */
+	    virtual void next_endpoint() = 0;
+	    /**
+	     * @}
+	     */
+
+	    /**
+	     * @name Site particulars API
+	     * @{
+	     */
+	    /**
+	     * Return an absolute URL of the page being processed, includining
+	     * query parameters. It is used to validate return_to URL on
+	     * positive assertions.
+	     * @return fully qualified url of the page being processed.
+	     */
+	    virtual const string get_this_url() const = 0;
+	    /**
+	     * @}
+	     */
+
+	    /**
+	     * @name OpenID actions
+	     * @{
+	     */
+	    /**
+	     * Initiates authentication session, doing discovery, normalization
+	     * and whatever implementor wants to do at this point.
+	     * @param usi User-supplied identity
+	     */
+	    virtual void initiate(const string& usi) = 0;
+	    /**
+	     * Prepare checkid_request.
+	     * @param rv reference to the openid message to prepare
+	     * @param mode checkid_setup or checkid_immediate
+	     * @param return_to the URL OP should redirect to after completion
+	     * @param realm authentication realm to pass to OP
+	     * @param ext pointer to extension to use in request preparation
+	     * @return reference to the openid message
+	     */
+	    basic_openid_message& checkid_(
+		    basic_openid_message& rv,
+		    mode_t mode,
+		    const string& return_to,const string& realm,
+		    extension_t *ext=0);
+	    /**
+	     * Verify assertion at the end of round-trip.
+	     * @param om incoming openid message
+	     * @param ext pointer to extention to use in parsing assertion
+	     * @throw id_res_setup if checkid_immediate request could not be
+	     * completed
+	     * @throw id_res_cancel if authentication request was canceled
+	     * @throw id_res_mismatch in case of signature mismatch
+	     * @throw id_res_bad_return_to if return_to url seems to be
+	     * tampered with
+	     * @throw id_res_unauthorized if OP is not authorized to make
+	     * assertions regarding the identity
+	     */
+	    void id_res(const basic_openid_message& om,extension_t *ext=0);
+
+	    /**
+	     * Establish association with OP
+	     * @param OP OP to establish association with
+	     * @throw dumb_RP if for a dumb RP
+	     */
+	    virtual assoc_t associate(const string& OP);
+	    /**
+	     * Check authentication with OP and invalidate handle if requested
+	     * and confirmed
+	     * @param OP OP to check with
+	     * @param om message to check
+	     * @throw failed_check_authentication if OP fails to confirm
+	     * authenticity of the assertion
+	     */
+	    void check_authentication(const string& OP,const basic_openid_message& om);
+	    /**
+	     * @}
+	     */
+
+	    /**
+	     * @name Miscellanea
+	     * @{
+	     */
+	    /**
+	     * Verify OP authority. Return normally if OP is authorized to make
+	     * an assertion, throw an exception otherwise.
+	     * @param OP OP endpoint
+	     * @param claimed_id claimed identity
+	     * @param identity OP-Local identifier
+	     * @throw id_res_unauthorized if OP is not authorized to make
+	     * assertion regarding this identity.
+	     */
+	    virtual void verify_OP(const string& OP,
+		    const string& claimed_id,const string& identity) const = 0;
+	    /**
+	     * @}
+	     */
+    };
+
+}
+
+#endif /* __OPKELE_BASIC_RP_H */
diff --git a/include/opkele/discovery.h b/include/opkele/discovery.h
index af4aa29..ab4b9d9 100644
--- a/include/opkele/discovery.h
+++ b/include/opkele/discovery.h
@@ -5,2 +5,3 @@
 #include <opkele/types.h>
+#include <opkele/basic_rp.h>
 
@@ -9,5 +10,78 @@ namespace opkele {
 
-    struct idiscovery_t;
+    namespace xrd {
 
-    void idiscover(idiscovery_t& result,const string& identity);
+	struct priority_compare {
+	    inline bool operator()(long a,long b) const {
+		return (a<0) ? false : (b<0) ? true : (a<b);
+	    }
+	};
+
+	template <typename _DT>
+	    class priority_map : public multimap<long,_DT,priority_compare> {
+		typedef multimap<long,_DT,priority_compare> map_type;
+		public:
+
+		    inline _DT& add(long priority,const _DT& d) {
+			return insert(typename map_type::value_type(priority,d))->second;
+		    }
+
+		    bool has_value(const _DT& d) const {
+			for(typename map_type::const_iterator i=this->begin();i!=this->end();++i)
+			    if(i->second==d) return true;
+			return false;
+		    }
+	    };
+
+	typedef priority_map<string> canonical_ids_t;
+	typedef priority_map<string> local_ids_t;
+	typedef set<string> types_t;
+	typedef priority_map<string> uris_t;
+
+	class service_t {
+	    public:
+		types_t types;
+		uris_t uris;
+		local_ids_t local_ids;
+		string provider_id;
+
+		void clear() {
+		    types.clear();
+		    uris.clear(); local_ids.clear();
+		    provider_id.clear();
+		}
+	};
+	typedef priority_map<service_t> services_t;
+
+	class XRD_t {
+	    public:
+		time_t expires;
+
+		canonical_ids_t canonical_ids;
+		local_ids_t local_ids;
+		services_t services;
+		string provider_id;
+
+		void clear() {
+		    expires = 0;
+		    canonical_ids.clear(); local_ids.clear();
+		    services.clear();
+		    provider_id.clear();
+		}
+		bool empty() const {
+		    return
+			canonical_ids.empty()
+			&& local_ids.empty()
+			&& services.empty();
+		}
+
+	};
+
+    }
+
+    typedef util::output_iterator_proxy<openid_endpoint_t>
+	endpoint_discovery_iterator;
+
+    string idiscover(
+	    endpoint_discovery_iterator oi,
+	    const string& identity);
 
@@ -20,8 +94,2 @@ namespace opkele {
 	idiscovery_t() { }
-	idiscovery_t(const string& i) {
-	    idiscover(*this,i);
-	}
-	idiscovery_t(const char *i) {
-	    idiscover(*this,i);
-	}
 
@@ -32,6 +100,2 @@ namespace opkele {
 
-	idiscovery_t& operator=(const string& i) {
-	    idiscover(*this,i); return *this; }
-	idiscovery_t& operator=(const char *i) {
-	    idiscover(*this,i); return *this; }
     };
diff --git a/include/opkele/exception.h b/include/opkele/exception.h
index a8c3339..ccb39d9 100644
--- a/include/opkele/exception.h
+++ b/include/opkele/exception.h
@@ -313,2 +313,21 @@ namespace opkele {
 
+    /**
+     * thrown by associations store related functions in case of dumb RP.
+     */
+    class dumb_RP : public exception {
+	public:
+	    dumb_RP(OPKELE_E_PARS)
+		: exception(OPKELE_E_CONS) { }
+    };
+
+    /**
+     * thrown by endpoint-queue related function if endpoint is being
+     * accessed but there's no endpoint available.
+     */
+    class no_endpoint : public exception {
+	public:
+	    no_endpoint(OPKELE_E_PARS)
+		: exception(OPKELE_E_CONS) { }
+    };
+
 }
diff --git a/include/opkele/extension.h b/include/opkele/extension.h
index 513672f..3ee25ee 100644
--- a/include/opkele/extension.h
+++ b/include/opkele/extension.h
@@ -19,2 +19,3 @@ namespace opkele {
 	    virtual ~extension_t() { }
+
 	    /**
@@ -29,3 +30,3 @@ namespace opkele {
 	     */
-	    virtual void checkid_hook(params_t& p,const string& identity);
+	    virtual void checkid_hook(basic_openid_message& om);
 	    /**
@@ -41,3 +42,3 @@ namespace opkele {
 	     */
-	    virtual void id_res_hook(const params_t& p,const params_t& sp,const string& identity);
+	    virtual void id_res_hook(const basic_openid_message& om,const basic_openid_message& sp);
 
@@ -53,3 +54,3 @@ namespace opkele {
 	     */
-	    virtual void checkid_hook(const params_t& pin,params_t& pout);
+	    virtual void checkid_hook(const basic_openid_message& inm,basic_openid_message& oum);
 
diff --git a/include/opkele/extension_chain.h b/include/opkele/extension_chain.h
index f0eea94..fb9bc84 100644
--- a/include/opkele/extension_chain.h
+++ b/include/opkele/extension_chain.h
@@ -30,5 +30,5 @@ namespace opkele {
 
-	    virtual void checkid_hook(params_t& p,const string& identity);
-	    virtual void id_res_hook(const params_t& p,const params_t& sp,const string& identity);
-	    virtual void checkid_hook(const params_t& pin,params_t& pout);
+	    virtual void checkid_hook(basic_openid_message& om);
+	    virtual void id_res_hook(const basic_openid_message& om,const basic_openid_message& sp);
+	    virtual void checkid_hook(const basic_openid_message& inm,basic_openid_message& oum);
     };
diff --git a/include/opkele/prequeue_rp.h b/include/opkele/prequeue_rp.h
new file mode 100644
index 0000000..b98dd5a
--- a/dev/null
+++ b/include/opkele/prequeue_rp.h
@@ -0,0 +1,81 @@
+#ifndef __OPKELE_RP_H
+#define __OPKELE_RP_H
+
+#include <string>
+#include <set>
+#include <iterator>
+#include <opkele/basic_rp.h>
+
+namespace opkele {
+    using std::string;
+    using std::set;
+    using std::iterator;
+    using std::output_iterator_tag;
+
+    class prequeue_RP : public basic_RP {
+	public:
+	    /**
+	     * @name Session persistent store API
+	     * @{
+	     */
+	    /**
+	     * Called before queueing discovered endpoints. Typically happens
+	     * while initiating authentication session.
+	     * @see queue_endpoint()
+	     * @see end_queueing()
+	     */
+	    virtual void begin_queueing() { }
+	    /**
+	     * Used to queue discovered endpoint. It is implementors
+	     * responsibility to store the endpoint wherever he choses to store
+	     * it.
+	     * @param oep the endpoint to queue
+	     * @see begin_queueing()
+	     * @see end_queueing()
+	     */
+	    virtual void queue_endpoint(const openid_endpoint_t& oep) = 0;
+	    /**
+	     * Called after all discovered endpoints were queued. Implementor
+	     * may chose to use this virtual to commit endpoints queue to
+	     * persistent store.
+	     * @see begin_queueing()
+	     * @see queue_endpoint()
+	     */
+	    virtual void end_queueing() { }
+
+	    /**
+	     * Used to store normalized id when initiating request.
+	     * The default implementation does nothing, because implementor
+	     * doesn't have to care.
+	     * @param nid normalized id
+	     * @see get_normalzied_id()
+	     */
+	    virtual void set_normalized_id(const string& nid);
+	    /**
+	     * Return the normalized id previously set by set_normalized_id().
+	     * Provided for the sake of completeness because default
+	     * implementation doesn't use it.
+	     * @return the normalized identity
+	     */
+	    virtual const string get_normalized_id() const;
+	    /**
+	     * @}
+	     */
+
+	    /**
+	     * @name Actions
+	     * @{
+	     */
+	    void initiate(const string& usi);
+
+	    /**
+	     * @}
+	     */
+
+	    void verify_OP(const string& OP,
+		    const string& claimed_id,const string& identity) const;
+    };
+
+}
+
+#endif /* __OPKELE_RP_H */
diff --git a/include/opkele/sreg.h b/include/opkele/sreg.h
index df37a86..24cb315 100644
--- a/include/opkele/sreg.h
+++ b/include/opkele/sreg.h
@@ -140,3 +140,3 @@ namespace opkele {
 	     */
-	    virtual void checkid_hook(params_t& p,const string& identity);
+	    virtual void checkid_hook(basic_openid_message& om);
 	    /**
@@ -144,3 +144,3 @@ namespace opkele {
 	     */
-	    virtual void id_res_hook(const params_t& p,const params_t& sp,const string& identity);
+	    virtual void id_res_hook(const basic_openid_message& om,const basic_openid_message& sp);
 	    /**
@@ -148,3 +148,3 @@ namespace opkele {
 	     */
-	    virtual void checkid_hook(const params_t& pin,params_t& pout);
+	    virtual void checkid_hook(const basic_openid_message& inm,basic_openid_message& oum);
 
@@ -197,3 +197,3 @@ namespace opkele {
 	     */
-	    virtual void setup_response(const params_t& pin,params_t& pout);
+	    virtual void setup_response(const basic_openid_message& inm,basic_openid_message& oum);
 
diff --git a/include/opkele/types.h b/include/opkele/types.h
index de44a5c..d5ad258 100644
--- a/include/opkele/types.h
+++ b/include/opkele/types.h
@@ -13,2 +13,4 @@
 #include <set>
+#include <list>
+#include <opkele/iterator.h>
 #include <opkele/tr1-mem.h>
@@ -22,2 +24,5 @@ namespace opkele {
     using std::set;
+    using std::list;
+    using std::iterator;
+    using std::forward_iterator_tag;
 
@@ -113,2 +118,55 @@ namespace opkele {
 
+    class basic_openid_message {
+	public:
+	    typedef list<string> fields_t;
+	    typedef util::forward_iterator_proxy<
+		string,const string&,const string*
+		> fields_iterator;
+
+	    basic_openid_message() { }
+	    basic_openid_message(const basic_openid_message& x);
+	    void copy_to(basic_openid_message& x) const;
+
+	    virtual bool has_field(const string& n) const = 0;
+	    virtual const string& get_field(const string& n) const = 0;
+
+	    virtual bool has_ns(const string& uri) const;
+	    virtual string get_ns(const string& uri) const;
+
+	    virtual fields_iterator fields_begin() const = 0;
+	    virtual fields_iterator fields_end() const = 0;
+
+	    virtual string append_query(const string& url) const;
+	    virtual string query_string() const;
+
+
+	    virtual void reset_fields();
+	    virtual void set_field(const string& n,const string& v);
+	    virtual void reset_field(const string& n);
+
+	    virtual void from_keyvalues(const string& kv);
+
+	    void add_to_signed(const string& fields);
+	    string find_ns(const string& uri,const char *pfx) const;
+	    string allocate_ns(const string& uri,const char *pfx);
+    };
+
+    class openid_message_t : public basic_openid_message, public map<string,string> {
+	public:
+	    openid_message_t() { }
+	    openid_message_t(const basic_openid_message& x)
+		: basic_openid_message(x) { }
+
+	    void copy_to(basic_openid_message& x) const;
+
+	    bool has_field(const string& n) const;
+	    const string& get_field(const string& n) const;
+	    virtual fields_iterator fields_begin() const;
+	    virtual fields_iterator fields_end() const;
+
+	    void reset_fields();
+	    void set_field(const string& n,const string& v);
+	    void reset_field(const string& n);
+    };
+
     /**
@@ -116,3 +174,3 @@ namespace opkele {
      */
-    class params_t : public map<string,string> {
+    class params_t : public openid_message_t {
 	public:
@@ -124,3 +182,4 @@ namespace opkele {
 	     */
-	    bool has_param(const string& n) const;
+	    bool has_param(const string& n) const {
+		return has_field(n); }
 	    /**
@@ -131,10 +190,4 @@ namespace opkele {
 	     */
-	    const string& get_param(const string& n) const;
-	    /**
-	     * retrieve the parameter.
-	     * @param n the parameter name
-	     * @return the parameter value
-	     * @throw failed_lookup if there is no such parameter
-	     */
-	    string& get_param(const string& n);
+	    const string& get_param(const string& n) const {
+		return get_field(n); }
 
@@ -144,101 +197,9 @@ namespace opkele {
 	     */
-	    void parse_keyvalues(const string& kv);
-	    /**
-	     * sign the fields.
-	     * @param secret the secret used for signing
-	     * @param sig reference to the string, containing base64-encoded
-	     * result
-	     * @param slist the comma-separated list of fields to sign
-	     * @param prefix the string to prepend to parameter names
-	     */
-	    void sign(secret_t secret,string& sig,const string& slist,const char *prefix=0) const;
+	    void parse_keyvalues(const string& kv) {
+		from_keyvalues(kv); }
 
-	    /**
-	     * append parameters to the URL as a GET-request parameters.
-	     * @param url the base URL
-	     * @param prefix the string to prepend to parameter names
-	     * @return the ready-to-use location
-	     */
-	    string append_query(const string& url,const char *prefix = "openid.") const;
+	    string append_query(const string& url,const char *prefix="openid.") const;
 
-	    /**
-	     * make up a query string suitable for use in GET and POST
-	     * requests.
-	     * @param prefix string to prened to parameter names
-	     * @return query string
-	     */
-	    string query_string(const char *prefix = "openid.") const;
     };
 
-    /**
-     * dump the key/value pairs for the parameters to the stream.
-     * @param o output stream
-     * @param p the parameters
-     */
-    ostream& operator << (ostream& o,const params_t& p);
-
-    namespace xrd {
-
-	struct priority_compare {
-	    inline bool operator()(long a,long b) const {
-		return (a<0) ? false : (b<0) ? true : (a<b);
-	    }
-	};
-
-	template <typename _DT>
-	    class priority_map : public multimap<long,_DT,priority_compare> {
-		typedef multimap<long,_DT,priority_compare> map_type;
-		public:
-
-		    inline _DT& add(long priority,const _DT& d) {
-			return insert(typename map_type::value_type(priority,d))->second;
-		    }
-	    };
-
-	typedef priority_map<string> canonical_ids_t;
-	typedef priority_map<string> local_ids_t;
-	typedef set<string> types_t;
-	typedef priority_map<string> uris_t;
-
-	class service_t {
-	    public:
-		types_t types;
-		uris_t uris;
-		local_ids_t local_ids;
-		string provider_id;
-
-		void clear() {
-		    types.clear();
-		    uris.clear(); local_ids.clear();
-		    provider_id.clear();
-		}
-	};
-	typedef priority_map<service_t> services_t;
-
-	class XRD_t {
-	    public:
-		time_t expires;
-
-		canonical_ids_t canonical_ids;
-		local_ids_t local_ids;
-		services_t services;
-		string provider_id;
-
-		void clear() {
-		    expires = 0;
-		    canonical_ids.clear(); local_ids.clear();
-		    services.clear();
-		    provider_id.clear();
-		}
-		bool empty() const {
-		    return
-			canonical_ids.empty()
-			&& local_ids.empty()
-			&& services.empty();
-		}
-
-	};
-
-    }
-
 }
diff --git a/include/opkele/util.h b/include/opkele/util.h
index 085c9e6..e9176b0 100644
--- a/include/opkele/util.h
+++ b/include/opkele/util.h
@@ -8,2 +8,3 @@
 #include <openssl/dh.h>
+#include <opkele/types.h>
 
@@ -138,2 +139,9 @@ namespace opkele {
 	string rfc_3986_normalize_uri(const string& uri);
+
+	string& strip_uri_fragment_part(string& uri);
+
+	string abi_demangle(const char* mn);
+
+	string base64_signature(const assoc_t& assoc,const basic_openid_message& om);
+
     }