slight api improvement to ease caching of discovery information

* added opend_endpoint_output_iterator to types.h
* changed endpoint_discovery_iterator to the aforementioned iterator typedef
* added discover() virtual to prequeue_RP and made use thereof.

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

4 files changed, 19 insertions, 4 deletions

diff --git a/include/opkele/discovery.h b/include/opkele/discovery.h
index 4471597..f2721a6 100644
--- a/include/opkele/discovery.h
+++ b/include/opkele/discovery.h
@@ -1,115 +1,114 @@
 #ifndef __OPKELE_DISCOVERY_H
 #define __OPKELE_DISCOVERY_H
 
 #include <string>
 #include <opkele/types.h>
 
 namespace opkele {
     using std::string;
 
     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;
                     }
 
                     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;
         struct uri_t {
             string uri;
             string append;
 
             uri_t() { }
             uri_t(const string& u) : uri(u) { }
             uri_t(const string& u,const string& a) : uri(u), append(a) { }
         };
         typedef priority_map<uri_t> 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;
+    typedef openid_endpoint_output_iterator endpoint_discovery_iterator;
 
     string idiscover(
             endpoint_discovery_iterator oi,
             const string& identity);
     void yadiscover(
             endpoint_discovery_iterator oi,
             const string& yurl,
             const char **types, bool redirs=false);
 
     struct idiscovery_t {
         bool xri_identity;
         string normalized_id;
         string canonicalized_id;
         xrd::XRD_t xrd;
 
         idiscovery_t() { }
 
         void clear() {
             normalized_id.clear(); canonicalized_id.clear();
             xrd.clear();
         }
 
     };
 }
 
 #endif /* __OPKELE_DISCOVERY_H */
diff --git a/include/opkele/prequeue_rp.h b/include/opkele/prequeue_rp.h
index 68fe03d..6f1fda9 100644
--- a/include/opkele/prequeue_rp.h
+++ b/include/opkele/prequeue_rp.h
@@ -1,88 +1,96 @@
 #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;
 
     /**
      * discovery-enabled RP implementation, prequeueing discovered endpoints
      */
     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
              * @{
              */
             /**
              * In addition to base class implementation it does endpoints
              * discovery and queueing
              * @param usi User-suppled identifier
              */
             void initiate(const string& usi);
             /**
              * @}
              */
 
             void verify_OP(const string& OP,
                     const string& claimed_id,const string& identity) const;
+
+            /**
+             * Perform full discovery on identity
+             * @param it iterator used for feeding discovered endpoints back to caller
+             * @param id user supplied identity
+             * @returns normalized identity (canonical identifier can be found in endpoints)
+             */
+            virtual const string discover(openid_endpoint_output_iterator it,const string& id) const;
     };
 
 }
 
 #endif /* __OPKELE_RP_H */
diff --git a/include/opkele/types.h b/include/opkele/types.h
index 1f48362..1fab869 100644
--- a/include/opkele/types.h
+++ b/include/opkele/types.h
@@ -1,230 +1,233 @@
 #ifndef __OPKELE_TYPES_H
 #define __OPKELE_TYPES_H
 
 /**
  * @file
  * @brief various types declarations
  */
 
 #include <cstring>
 #include <ostream>
 #include <vector>
 #include <string>
 #include <map>
 #include <set>
 #include <list>
 #include <opkele/iterator.h>
 #include <opkele/tr1-mem.h>
 
 namespace opkele {
     using std::vector;
     using std::string;
     using std::map;
     using std::ostream;
     using std::multimap;
     using std::set;
     using std::list;
     using std::iterator;
     using std::forward_iterator_tag;
 
     /**
      * the OpenID operation mode
      */
     typedef enum _mode_t {
         mode_unknown = 0,
         mode_associate,
         mode_checkid_immediate,
         mode_checkid_setup,
         mode_check_association
     } mode_t;
 
     /**
      * the association secret container
      */
     class secret_t : public vector<unsigned char> {
         public:
 
             /**
              * xor the secret and hmac together and encode, using base64
              * @param key_d pointer to the message digest
              * @param rv reference to the return value
              */
             void enxor_to_base64(const unsigned char *key_d,string& rv) const;
             /**
              * decode base64-encoded secret and xor it with the message digest
              * @param key_d pointer to the message digest
              * @param b64 base64-encoded secret value
              */
             void enxor_from_base64(const unsigned char *key_d,const string& b64);
             /**
              * plainly encode to base64 representation
              * @param rv reference to the return value
              */
             void to_base64(string& rv) const;
             /**
              * decode cleartext secret from base64
              * @param b64 base64-encoded representation of the secret value
              */
             void from_base64(const string& b64);
     };
 
     /**
      * Interface to the association.
      */
     class association_t {
         public:
 
             virtual ~association_t() { }
 
             /**
              * retrieve the server with which association was established.
              * @return server name
              */
             virtual string server() const = 0;
             /**
              * retrieve the association handle.
              * @return handle
              */
             virtual string handle() const = 0;
             /**
              * retrieve the association type.
              * @return association type
              */
             virtual string assoc_type() const = 0;
             /**
              * retrieve the association secret.
              * @return association secret
              */
             virtual secret_t secret() const = 0; 
             /**
              * retrieve the number of seconds the association expires in.
              * @return seconds till expiration
              */
             virtual int expires_in() const = 0;
             /**
              * check whether the association is stateless.
              * @return true if stateless
              */
             virtual bool stateless() const = 0;
             /**
              * check whether the association is expired.
              * @return true if expired
              */
             virtual bool is_expired() const = 0;
     };
 
     /**
      * the shared_ptr<> for association_t object type
      */
     typedef tr1mem::shared_ptr<association_t> assoc_t;
 
     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() { }
             virtual ~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);
             virtual void to_keyvalues(ostream& o) const;
 
             virtual void to_htmlhiddens(ostream& o,const char* pfx=0) const;
 
             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);
     };
 
     /**
      * request/response parameters map
      */
     class params_t : public openid_message_t {
         public:
 
             /**
              * check whether the parameter is present.
              * @param n the parameter name
              * @return true if yes
              */
             bool has_param(const string& n) const {
                 return has_field(n); }
             /**
              * retrieve the parameter (const version)
              * @param n the parameter name
              * @return the parameter value
              * @throw failed_lookup if there is no such parameter
              */
             const string& get_param(const string& n) const {
                 return get_field(n); }
 
             /**
              * parse the OpenID key/value data.
              * @param kv the OpenID key/value data
              */
             void parse_keyvalues(const string& kv) {
                 from_keyvalues(kv); }
 
             string append_query(const string& url,const char *prefix="openid.") const;
 
     };
 
     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); }
     };
 
+    typedef util::output_iterator_proxy<openid_endpoint_t>
+        openid_endpoint_output_iterator;
+
 }
 
 #endif /* __OPKELE_TYPES_H */
diff --git a/lib/prequeue_rp.cc b/lib/prequeue_rp.cc
index 3aa960f..ed1ddfe 100644
--- a/lib/prequeue_rp.cc
+++ b/lib/prequeue_rp.cc
@@ -1,81 +1,86 @@
 #include <iostream>
 #include <openssl/sha.h>
 #include <openssl/hmac.h>
 #include <opkele/exception.h>
 #include <opkele/prequeue_rp.h>
 #include <opkele/discovery.h>
 #include <opkele/uris.h>
 #include <opkele/data.h>
 #include <opkele/util.h>
 #include <opkele/curl.h>
 #include <opkele/debug.h>
 
 namespace opkele {
 
     class __OP_verifier_good_input : public exception {
         public:
             __OP_verifier_good_input(OPKELE_E_PARS)
                 : exception(OPKELE_E_CONS) { }
     };
 
     class OP_verifier : public iterator<output_iterator_tag,openid_endpoint_t,void> {
         public:
             const string& OP;
             const string& id;
 
             OP_verifier(const string& o,const string& i)
                 : OP(o), id(i) { }
 
             OP_verifier& operator*() { return *this; }
             OP_verifier& operator=(const openid_endpoint_t& oep) {
                 if(oep.uri==OP) {
                     if(oep.claimed_id==IDURI_SELECT20
                             || oep.local_id==IDURI_SELECT20 )
                         throw bad_input(OPKELE_CP_ "claimed_id is an OP-Id");
                     if(oep.local_id==id)
                         throw __OP_verifier_good_input(OPKELE_CP_ "Found corresponding endpoint");
                 }
                 return *this;
             }
 
             OP_verifier& operator++() { return *this; }
             OP_verifier& operator++(int) { return *this; }
     };
 
     void prequeue_RP::verify_OP(const string& OP,const string& claimed_id,const string& identity) const {
         try {
-            idiscover(OP_verifier(OP,identity),claimed_id);
+            discover(OP_verifier(OP,identity),claimed_id);
             throw id_res_unauthorized(OPKELE_CP_
                     "OP is not authorized to make an assertion regarding the identity");
         }catch(__OP_verifier_good_input& ovgi) {
         }
     }
 
     class endpoint_queuer : public iterator<output_iterator_tag,openid_endpoint_t,void> {
         public:
             prequeue_RP& rp;
 
             endpoint_queuer(prequeue_RP& r) : rp(r) { }
 
             endpoint_queuer& operator*() { return *this; }
             endpoint_queuer& operator=(const openid_endpoint_t& oep) {
                 rp.queue_endpoint(oep); return *this; }
 
             endpoint_queuer& operator++() { return *this; }
             endpoint_queuer& operator++(int) { return *this; }
     };
 
     void prequeue_RP::initiate(const string& usi) {
         begin_queueing();
-        set_normalized_id( idiscover(endpoint_queuer(*this),usi) );
+        set_normalized_id( discover(endpoint_queuer(*this),usi) );
         end_queueing();
     }
 
     void prequeue_RP::set_normalized_id(const string&) {
     }
 
     const string prequeue_RP::get_normalized_id() const {
         throw not_implemented(OPKELE_CP_ "get_normalized_id() is not implemented");
     }
 
+    const string prequeue_RP::discover(openid_endpoint_output_iterator it,
+            const string& id) const {
+        return idiscover(it,id);
+    }
+
 }