1 files changed, 1 insertions, 109 deletions

diff --git a/test/RP.cc b/test/RP.cc
index f2f8851..e9744a4 100644
--- a/test/RP.cc
+++ b/test/RP.cc
@@ -1,237 +1,129 @@
 #include <uuid/uuid.h>
 #include <iostream>
 #include <cassert>
 #include <stdexcept>
 #include <string>
 #include <set>
 #include <iterator>
 using namespace std;
 #include <kingate/exception.h>
 #include <kingate/plaincgi.h>
 #include <kingate/cgi_gateway.h>
 #include <opkele/exception.h>
 #include <opkele/types.h>
 #include <opkele/util.h>
 #include <opkele/uris.h>
 #include <opkele/discovery.h>
 #include <opkele/association.h>
 #include <opkele/sreg.h>
 using namespace opkele;
 #include <opkele/prequeue_rp.h>
 #include <opkele/debug.h>
 
 #include "sqlite.h"
+#include "kingate_openid_message.h"
 
 #undef DUMB_RP
 
 #ifdef DUMB_RP
 # define DUMBTHROW throw opkele::dumb_RP(OPKELE_CP_ "This RP is dumb")
 #else
 # define DUMBTHROW (void)0
 #endif
 
-template<typename IT>
-class join_iterator : public iterator<
-                      input_iterator_tag,typename IT::value_type,
-                      void,typename IT::pointer,typename IT::reference> {
-    public:
-        typedef pair<IT,IT> range_t;
-        typedef list<range_t> ranges_t;
-        ranges_t ranges;
-
-        join_iterator() { }
-
-        bool cleanup() {
-            bool rv = false;
-            while(!(ranges.empty() || ranges.front().first!=ranges.front().second)) {
-                ranges.pop_front(); rv = true;
-            }
-            return rv;
-        }
-
-        join_iterator<IT>& add_range(const IT& b,const IT& e) {
-            ranges.push_back(typename ranges_t::value_type(b,e));
-            cleanup();
-            return *this;
-        }
-
-        bool operator==(const join_iterator<IT>& x) const {
-            return ranges==x.ranges; }
-        bool operator!=(const join_iterator<IT>& x) const {
-            return ranges!=x.ranges; }
-
-        typename IT::reference operator*() const {
-            assert(!ranges.empty());
-            assert(ranges.front().first!=ranges.front().second);
-            return *ranges.front().first; }
-        typename IT::pointer operator->() const {
-            assert(!ranges.empty());
-            assert(ranges.front().first!=ranges.front().second);
-            return ranges.front().first.operator->(); }
-
-        join_iterator<IT>& operator++() {
-            cleanup();
-            if(ranges.empty()) return *this;
-            do {
-                ++ranges.front().first;
-            }while(cleanup() && !ranges.empty());
-            return *this;
-        }
-        join_iterator<IT> operator++(int) {
-            join_iterator<IT> rv(*this);
-            ++(*this); return rv; }
-};
-
-template<typename IT>
-class cut_prefix_filterator : public opkele::util::basic_filterator<IT> {
-    public:
-        string pfx;
-        mutable string tmp;
-
-        cut_prefix_filterator() { }
-        cut_prefix_filterator(const IT& bi,const IT&ei,const string& pfx)
-            : opkele::util::basic_filterator<IT>(bi,ei), pfx(pfx) {
-                this->prepare();
-            }
-
-        bool is_interesting() const {
-            return pfx.length()==0 || !strncmp(this->it->c_str(),pfx.c_str(),pfx.length());
-        }
-
-        typename IT::reference operator*() const {
-            assert(!this->empty);
-            tmp = *this->it; tmp.erase(0,pfx.length());
-            return tmp; }
-        typename IT::pointer operator->() const {
-            assert(!this->empty);
-            return &this->operator*(); }
-};
-
-class kingate_openid_message_t : public opkele::basic_openid_message {
-            typedef join_iterator<kingate::cgi_gateway::params_t::const_iterator> jitterator;
-        typedef opkele::util::map_keys_iterator<
-            jitterator,
-            fields_iterator::value_type,
-            fields_iterator::reference,
-            fields_iterator::pointer> keys_iterator;
-        typedef cut_prefix_filterator<keys_iterator> pfilterator;
-    public:
-        const kingate::cgi_gateway& gw;
-
-        kingate_openid_message_t(const kingate::cgi_gateway& g) : gw(g) { }
-
-        bool has_field(const string& n) const {
-            return gw.has_param("openid."+n); }
-        const string& get_field(const string& n) const {
-            return gw.get_param("openid."+n); }
-
-        fields_iterator fields_begin() const {
-            return
-                pfilterator( keys_iterator(
-                            jitterator()
-                            .add_range( gw.get.begin(), gw.get.end() )
-                            .add_range( gw.post.begin(), gw.post.end() ),
-                            jitterator()
-                            ), keys_iterator(), "openid." );
-        }
-        fields_iterator fields_end() const {
-            return pfilterator();
-        }
-};
-
 class rpdb_t : public sqlite3_t {
     public:
         rpdb_t()
             : sqlite3_t("/tmp/RP.db") {
                 assert(_D);
                 char **resp; int nrow,ncol; char *errm;
                 if(sqlite3_get_table(
                         _D,"SELECT a_op FROM assoc LIMIT 0",
                         &resp,&nrow,&ncol,&errm)!=SQLITE_OK) {
                     extern const char *__RP_db_bootstrap;
                     DOUT_("Bootstrapping DB");
                     if(sqlite3_exec(_D,__RP_db_bootstrap,NULL,NULL,&errm)!=SQLITE_OK)
                         throw opkele::exception(OPKELE_CP_ string("Failed to bootstrap SQLite database: ")+errm);
                 }else
                     sqlite3_free_table(resp);
 
             }
 };
 
 class example_rp_t : public opkele::prequeue_RP {
     public:
         mutable rpdb_t db;
         kingate::cookie htc;
         long as_id;
         int ordinal;
         kingate::cgi_gateway& gw;
 
         example_rp_t(kingate::cgi_gateway& gw)
         : ordinal(0), have_eqtop(false), gw(gw), as_id(-1) {
             try {
                 htc = gw.cookies.get_cookie("ht_session");
                 as_id = opkele::util::string_to_long(gw.get_param("asid"));
             }catch(kingate::exception_notfound& kenf) {
                 uuid_t uuid; uuid_generate(uuid);
                 htc = kingate::cookie("ht_session",util::encode_base64(uuid,sizeof(uuid)));
                 sqlite3_mem_t<char*> S = sqlite3_mprintf(
                         "INSERT INTO ht_sessions (hts_id) VALUES (%Q)",
                         htc.get_value().c_str());
                 db.exec(S);
             }
         }
 
         /* Global persistent store */
 
         opkele::assoc_t store_assoc(
                 const string& OP,const string& handle,
                 const string& type,const secret_t& secret,
                 int expires_in) {
             DUMBTHROW;
             DOUT_("Storing '" << handle << "' assoc with '" << OP << "'");
             time_t exp = time(0)+expires_in;
             sqlite3_mem_t<char*>
                 S = sqlite3_mprintf(
                         "INSERT INTO assoc"
                         " (a_op,a_handle,a_type,a_ctime,a_etime,a_secret)"
                         " VALUES ("
                         "  %Q,%Q,%Q,"
                         "  datetime('now'), datetime('now','+%d seconds'),"
                         "  %Q"
                         " );", OP.c_str(), handle.c_str(), type.c_str(),
                         expires_in,
                         util::encode_base64(&(secret.front()),secret.size()).c_str() );
             db.exec(S);
             return opkele::assoc_t(new opkele::association(
                         OP, handle, type, secret, exp, false ));
         }
 
         opkele::assoc_t find_assoc(
                 const string& OP) {
             DUMBTHROW;
             DOUT_("Looking for an assoc with '" << OP << '\'');
             sqlite3_mem_t<char*>
                 S = sqlite3_mprintf(
                         "SELECT"
                         "  a_op,a_handle,a_type,a_secret,"
                         "  strftime('%%s',a_etime) AS a_etime"
                         " FROM assoc"
                         " WHERE a_op=%Q AND a_itime IS NULL AND NOT a_stateless"
                         "  AND ( a_etime > datetime('now','-30 seconds') )"
                         " LIMIT 1",
                         OP.c_str());
             sqlite3_table_t T;
             int nr,nc;
             db.get_table(S,T,&nr,&nc);
             if(nr<1)
                 throw opkele::failed_lookup(OPKELE_CP_ "Couldn't find unexpired handle");
             assert(nr==1);
             assert(nc==5);
             secret_t secret;
             util::decode_base64(T.get(1,3,nc),secret);
             DOUT_(" found '" << T.get(1,1,nc) << '\'');
             return opkele::assoc_t(new opkele::association(
                         T.get(1,0,nc), T.get(1,1,nc), T.get(1,2,nc),
                         secret, strtol(T.get(1,4,nc),0,0), false ));
         }