Merge commit 'devel.vz/next' into next

2 files changed, 3 insertions, 0 deletions

diff --git a/autoregen.sh b/autoregen.sh
new file mode 100644
index 0000000..ca4f880
--- a/dev/null
+++ b/autoregen.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+eval sh autogen.sh $(./config.status --version | grep '^  with options "'|sed -e 's/^[^"]\+"//' -e 's/"$//')
diff --git a/test/RP.cc b/test/RP.cc
index 35ee71d..f015723 100644
--- a/test/RP.cc
+++ b/test/RP.cc
@@ -1,259 +1,260 @@
 #include <uuid/uuid.h>
 #include <iostream>
 #include <cassert>
+#include <cstdlib>
 #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
 
 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& g)
 	: as_id(-1), ordinal(0), gw(g), have_eqtop(false)  {
 	    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 ));
 	}
 
 	opkele::assoc_t retrieve_assoc(
 		const string& OP,const string& handle) {
 	    DUMBTHROW;
 	    DOUT_("Retrieving assoc '" << handle << "' 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_handle=%Q"
 			"  AND a_itime IS NULL AND NOT a_stateless"
 			" LIMIT 1",
 			OP.c_str(),handle.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 retrieve valid association");
 	    assert(nr==1); assert(nc==5);
 	    secret_t secret; util::decode_base64(T.get(1,3,nc),secret);
 	    DOUT_(" found. type=" << T.get(1,2,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 ));
 	}
 
 	void invalidate_assoc(
 		const string& OP,const string& handle) {
 	    DUMBTHROW;
 	    DOUT_("Invalidating assoc '" << handle << "' with '" << OP << '\'');
 	    sqlite3_mem_t<char*>
 		S = sqlite3_mprintf(
 			"UPDATE assoc SET a_itime=datetime('now')"
 			" WHERE a_op=%Q AND a_handle=%Q",
 			OP.c_str(), handle.c_str() );
 	    db.exec(S);
 	}
 
 	void check_nonce(const string& OP,const string& nonce) {
 	    DOUT_("Checking nonce '" << nonce << "' from '" << OP << '\'');
 	    sqlite3_mem_t<char*>
 		S = sqlite3_mprintf(
 			"SELECT 1 FROM nonces WHERE n_op=%Q AND n_once=%Q",
 			OP.c_str(), nonce.c_str());
 	    sqlite3_table_t T;
 	    int nr,nc;
 	    db.get_table(S,T,&nr,&nc);
 	    if(nr)
 		throw opkele::id_res_bad_nonce(OPKELE_CP_ "already seen that nonce");
 	    sqlite3_mem_t<char*>
 		SS = sqlite3_mprintf(
 			"INSERT INTO nonces (n_op,n_once) VALUES (%Q,%Q)",
 			OP.c_str(), nonce.c_str());
 	    db.exec(SS);
 	}
 
 	/* Session perisistent store */
 
 	void begin_queueing() {
 	    assert(as_id>=0);
 	    DOUT_("Resetting queue for session '" << htc.get_value() << "'/" << as_id);
 	    sqlite3_mem_t<char*> S = sqlite3_mprintf(
 		    "DELETE FROM endpoints_queue"
 		    " WHERE as_id=%ld",
 		    as_id);
 	    db.exec(S);
 	}
 
 	void queue_endpoint(const opkele::openid_endpoint_t& ep) {
 	    assert(as_id>=0);
 	    DOUT_("Queueing endpoint " << ep.claimed_id << " : " << ep.local_id << " @ " << ep.uri);
 	    sqlite3_mem_t<char*> S = sqlite3_mprintf(
 		    "INSERT INTO endpoints_queue"
 		    " (as_id,eq_ctime,eq_ordinal,eq_uri,eq_claimed_id,eq_local_id)"
 		    " VALUES (%ld,strftime('%%s','now'),%d,%Q,%Q,%Q)",
 		    as_id,ordinal++,
 		    ep.uri.c_str(),ep.claimed_id.c_str(),ep.local_id.c_str());
 	    db.exec(S);
 	}
 
 	mutable openid_endpoint_t eqtop;
 	mutable bool have_eqtop;
 
 	const openid_endpoint_t& get_endpoint() const {
 	    assert(as_id>=0);
 	    if(!have_eqtop) {
 		sqlite3_mem_t<char*>
 		    S = sqlite3_mprintf(
 			    "SELECT"
 			    "  eq_uri, eq_claimed_id, eq_local_id"
 			    " FROM endpoints_queue"
 			    "  JOIN auth_sessions USING(as_id)"
 			    " WHERE hts_id=%Q AND as_id=%ld"
 			    " ORDER BY eq_ctime,eq_ordinal"
 			    " LIMIT 1",htc.get_value().c_str(),as_id);
 		sqlite3_table_t T; int nr,nc;
 		db.get_table(S,T,&nr,&nc);
 		if(nr<1)
 		    throw opkele::exception(OPKELE_CP_ "No more endpoints queued");
 		assert(nr==1); assert(nc==3);
 		eqtop.uri = T.get(1,0,nc);
 		eqtop.claimed_id = T.get(1,1,nc);
 		eqtop.local_id = T.get(1,2,nc);
 		have_eqtop = true;
 	    }
 	    return eqtop;
 	}
 
 	void next_endpoint() {
 	    assert(as_id>=0);
 	    get_endpoint();
 	    have_eqtop = false;
 	    sqlite3_mem_t<char*> S = sqlite3_mprintf(
 		    "DELETE FROM endpoints_queue"
 		    " WHERE as_id=%ld AND eq_uri=%Q AND eq_local_id=%Q",
 		    htc.get_value().c_str(),as_id,
 		    eqtop.uri.c_str());
 	    db.exec(S);
 	}
 
 	mutable string _nid;
 
 	void set_normalized_id(const string& nid) {
 	    assert(as_id>=0);
 	    sqlite3_mem_t<char*> S = sqlite3_mprintf(
 		    "UPDATE auth_sessions"
 		    " SET as_normalized_id=%Q"
 		    " WHERE hts_id=%Q and as_id=%ld",
 		    nid.c_str(),