minor fixes and making compiler a bit happier

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

4 files changed, 20 insertions, 18 deletions

diff --git a/include/opkele/basic_op.h b/include/opkele/basic_op.h
index 0326508..12306dd 100644
--- a/include/opkele/basic_op.h
+++ b/include/opkele/basic_op.h
@@ -1,250 +1,252 @@
 #ifndef __OPKELE_BASIC_OP_H
 #define __OPKELE_BASIC_OP_H
 
 #include <string>
 #include <opkele/types.h>
 #include <opkele/extension.h>
 
 namespace opkele {
     using std::string;
 
     /**
      * Implementation of basic OP functionality
      */
     class basic_OP {
 	public:
 	    /**
 	     * The request mode for the request being processed
 	     */
 	    mode_t mode;
 	    /**
 	     * association used in transaction. reset in case of dumb operation
 	     */
 	    assoc_t assoc;
 	    /**
 	     * true if the request is openid2 request
 	     */
 	    bool openid2;
 	    /**
 	     * The return_to RP endpoint
 	     */
 	    string return_to;
 	    /**
 	     * The realm we authenticate for
 	     */
 	    string realm;
 	    /**
 	     * Claimed identifier
 	     */
 	    string claimed_id;
 	    /**
 	     * The OP-Local identifier
 	     */
 	    string identity;
 	    /**
 	     * The invalidate handle for the reply request
 	     */
 	    string invalidate_handle;
 
+	    virtual ~basic_OP() { }
+
 	    void reset_vars();
 
 	    /**
 	     * @name Request information access
 	     * Setting and retrieval of the information pertaining to the request being processed
 	     * @{
 	     */
 	    /**
 	     * Check if the RP expects us to get back to them.
 	     * @return true if RP supplied return_to URL
 	     */
 	    bool has_return_to() const;
 	    /**
 	     * Find out where the RP is waiting for us.
 	     * @return the return_to URL supplied
 	     * @throw no_return_to if no return_to is supplied with the request
 	     */
 	    const string& get_return_to() const;
 
 	    /**
 	     * Find out what realm we are authenticating user for
 	     * @return the realm
 	     */
 	    const string& get_realm() const;
 
 	    /**
 	     * Check if request is about identity
 	     * @return true if so
 	     */
 	    bool has_identity() const;
 	    /**
 	     * Get claimed identifier supplied with the request
 	     * @return claimed identifier
 	     * @throw non_identity if request is not about identity
 	     */
 	    const string& get_claimed_id() const;
 	    /**
 	     * Get the identity (OP-Local identifier) being confirmed
 	     * @return identity
 	     * @throw non_identity if request is not about identity
 	     */
 	    const string& get_identity() const;
 
 	    /**
 	     * Is identifier supposed to be selected on our side?
 	     * @return true if identity is a special identifier select URI
 	     */
 	    bool is_id_select() const;
 
 	    /**
 	     * Select the identity for identifier select request
 	     * @param cid claimed identifier
 	     * @param lid local identifier
 	     */
 	    void select_identity(const string& cid,const string& lid);
 	    /**
 	     * Set claimed identifier (for instance if it's supposed to have
 	     * fragment part)
 	     * @param cid claimed identifier
 	     */
 	    void set_claimed_id(const string& cid);
 	    /**
 	     * @}
 	     */
 
 	    /** @name OpenID operations
 	     * @{
 	     */
 	    /**
 	     * Establish association with RP
 	     * @param oum reply message
 	     * @param inm request message
 	     */
 	    basic_openid_message& associate(
 		    basic_openid_message& oum,
 		    const basic_openid_message& inm);
 
 	    /**
 	     * Parse the checkid_* request. The function parses input message,
 	     * retrieves the information needed for further processing,
 	     * verifies what can be verified at this stage.
 	     * @param inm incoming OpenID message
 	     * @param ext extension/chain of extensions supported
 	     */
 	    void checkid_(const basic_openid_message& inm,extension_t *ext=0);
 	    /**
 	     * Build and sign a positive assertion message
 	     * @param om outpu OpenID message
 	     * @param ext extension/chain of extensions supported
 	     * @return reference to om
 	     */
 	    basic_openid_message& id_res(basic_openid_message& om,
 		    extension_t *ext=0);
 	    /**
 	     * Build a 'cancel' negative assertion
 	     * @param om output OpenID message
 	     * @return reference to om
 	     */
 	    basic_openid_message& cancel(basic_openid_message& om);
 	    /**
 	     * Build an 'error' reply
 	     * @param om output OpenID message
 	     * @param error a human-readable message indicating the cause
 	     * @param contact contact address for the server administrator (can be empty)
 	     * @param reference a reference token (can be empty)
 	     * @return reference to om
 	     */
 	    basic_openid_message& error(basic_openid_message& om,
 		    const string& error,const string& contact,
 		    const string& reference );
 	    /**
 	     * Build a setup_needed reply to checkid_immediate request
 	     * @param oum output OpenID message
 	     * @param inm incoming OpenID request being processed
 	     * @return reference to oum
 	     */
 	    basic_openid_message& setup_needed(
 		    basic_openid_message& oum,const basic_openid_message& inm);
 
 	    /**
 	     * Process check_authentication request
 	     * @param oum output OpenID message
 	     * @param inm incoming request
 	     * @return reference to oum
 	     */
 	    basic_openid_message& check_authentication(
 		    basic_openid_message& oum,const basic_openid_message& inm);
 	    /**
 	     * @}
 	     */
 
 	    /**
 	     * Verify return_to url. The default implementation checks whether
 	     * return_to URI matches the realm
 	     * @throw bad_realm in case of invalid realm
 	     * @throw bad_return_to if return_to doesn't match the realm
 	     * @see verify_OP::verify_return_to()
 	     */
 	    virtual void verify_return_to();
 
 	    /**
 	     * @name Global persistent store API
 	     * These functions are related to the associations with RPs storage
 	     * and retrieval and nonce management.
 	     * @{
 	     */
 	    /**
 	     * Allocate association.
 	     * @param type association type
 	     * @param kl association key length
 	     * @param sl true if the association is stateless
 	     * @return association object
 	     */
 	    virtual assoc_t alloc_assoc(const string& type,size_t kl,bool sl) = 0;
 	    /**
 	     * Retrieve valid unexpired association
 	     * @param handle association handle
 	     * @return association object
 	     */
 	    virtual assoc_t retrieve_assoc(const string& handle) = 0;
 	    /**
 	     * Allocate nonce.
 	     * @param nonce input-output parameter containing timestamp part of
 	     * the nonce on input
 	     * @param sl true if the nonce is
 	     * @return reference to nonce
 	     * @throw failed_lookup if no such valid unexpired association
 	     * could be retrieved
 	     */
 	    virtual string& alloc_nonce(string& nonce) = 0;
 	    /**
 	     * Check nonce validity
 	     * @param nonce nonce to check
 	     * @return true if nonce found and isn't yet invalidated
 	     */
 	    virtual bool check_nonce(const string& nonce) = 0;
 	    /**
 	     * Invalidate nonce
 	     * @param nonce nonce to check
 	     */
 	    virtual void invalidate_nonce(const string& nonce) = 0;
 	    /**
 	     * @}
 	     */
 
 	    /**
 	     * @name Site particulars API
 	     * @{
 	     */
 	    /**
 	     * Query the absolute URL of the op endpoint
 	     * @return fully qualified url of the OP endpoint
 	     */
 	    virtual const string get_op_endpoint() const = 0;
 	    /**
 	     * @}
 	     */
 
     };
 }
 
 #endif /* __OPKELE_BASIC_OP_H */
diff --git a/include/opkele/expat.h b/include/opkele/expat.h
index 60c41ac..3ab1630 100644
--- a/include/opkele/expat.h
+++ b/include/opkele/expat.h
@@ -1,91 +1,91 @@
 #ifndef __OPKELE_EXPAT_H
 #define __OPKELE_EXPAT_H
 
 #include <cassert>
 #include <expat.h>
 
 namespace opkele {
 
     namespace util {
 
 	class expat_t {
 	    public:
 		XML_Parser _x;
 
 		expat_t() : _x(0) { }
 		expat_t(XML_Parser x) : _x(x) { }
 		virtual ~expat_t() throw();
 
 		expat_t& operator=(XML_Parser x);
 
 		operator const XML_Parser(void) const { return _x; }
 		operator XML_Parser(void) { return _x; }
 
 		inline bool parse(const char *s,int len,bool final=false) {
 		    assert(_x);
 		    return XML_Parse(_x,s,len,final);
 		}
 
-		virtual void start_element(const XML_Char *n,const XML_Char **a) { }
-		virtual void end_element(const XML_Char *n) { }
+		virtual void start_element(const XML_Char * /* n */,const XML_Char ** /* a */) { }
+		virtual void end_element(const XML_Char * /* n */) { }
 		void set_element_handler();
 
-		virtual void character_data(const XML_Char *s,int l) { }
+		virtual void character_data(const XML_Char * /* s */,int /* l */) { }
 		void set_character_data_handler();
 
-		virtual void processing_instruction(const XML_Char *t,const XML_Char *d) { }
+		virtual void processing_instruction(const XML_Char * /* t */,const XML_Char * /* d */) { }
 		void set_processing_instruction_handler();
 
-		virtual void comment(const XML_Char *d) { }
+		virtual void comment(const XML_Char * /* d */) { }
 		void set_comment_handler();
 
 		virtual void start_cdata_section() { }
 		virtual void end_cdata_section() { }
 		void set_cdata_section_handler();
 
-		virtual void default_handler(const XML_Char *s,int l) { }
+		virtual void default_handler(const XML_Char * /* s */,int /* l */) { }
 		void set_default_handler();
 		void set_default_handler_expand();
 
-		virtual void start_namespace_decl(const XML_Char *p,const XML_Char *u) { }
-		virtual void end_namespace_decl(const XML_Char *p) { }
+		virtual void start_namespace_decl(const XML_Char * /* p */,const XML_Char * /* u */) { }
+		virtual void end_namespace_decl(const XML_Char * /* p */) { }
 		void set_namespace_decl_handler();
 
 		inline enum XML_Error get_error_code() {
 		    assert(_x); return XML_GetErrorCode(_x); }
 		static inline const XML_LChar *error_string(XML_Error c) {
 		    return XML_ErrorString(c); }
 
 		inline long get_current_byte_index() {
 		    assert(_x); return XML_GetCurrentByteIndex(_x); }
 		inline int get_current_line_number() {
 		    assert(_x); return XML_GetCurrentLineNumber(_x); }
 		inline int get_current_column_number() {
 		    assert(_x); return XML_GetCurrentColumnNumber(_x); }
 
 		inline void set_user_data() {
 		    assert(_x); XML_SetUserData(_x,this); }
 
 		inline bool set_base(const XML_Char *b) {
 		    assert(_x); return XML_SetBase(_x,b); }
 		inline const XML_Char *get_base() {
 		    assert(_x); return XML_GetBase(_x); }
 
 		inline int get_specified_attribute_count() {
 		    assert(_x); return XML_GetSpecifiedAttributeCount(_x); }
 
 		inline bool set_param_entity_parsing(enum XML_ParamEntityParsing c) {
 		    assert(_x); return XML_SetParamEntityParsing(_x,c); }
 
 		inline static XML_Parser parser_create(const XML_Char *e=0) {
 		    return XML_ParserCreate(e); }
 		inline static XML_Parser parser_create_ns(const XML_Char *e=0,XML_Char s='\t') {
 		    return XML_ParserCreateNS(e,s); }
 
 	};
 
     }
 
 }
 
 #endif /* __OPKELE_EXPAT_H */
diff --git a/include/opkele/iterator.h b/include/opkele/iterator.h
index 812a786..28c1c83 100644
--- a/include/opkele/iterator.h
+++ b/include/opkele/iterator.h
@@ -1,217 +1,216 @@
 #ifndef __OPKELE_ITERATOR_H
 #define __OPKELE_ITERATOR_H
 
 #include <cassert>
 #include <iterator>
 
 namespace opkele {
     namespace util {
 	using std::iterator;
 	using std::forward_iterator_tag;
 	using std::output_iterator_tag;
 
 	template <typename T>
 	class basic_output_iterator_proxy_impl : public iterator<output_iterator_tag,T,void,T*,T&> {
 	    public:
 		virtual ~basic_output_iterator_proxy_impl() { }
 
 		virtual basic_output_iterator_proxy_impl<T>* dup() const = 0;
 		basic_output_iterator_proxy_impl<T>& operator*() { return *this; };
 		virtual basic_output_iterator_proxy_impl<T>& operator=(const T& x) = 0;
 
 	};
 
 	template<typename IT,typename T=typename IT::value_type>
 	class output_iterator_proxy_impl : public basic_output_iterator_proxy_impl<T> {
 	    public:
 		IT i;
 
-		output_iterator_proxy_impl(const IT& i) : i(i) { }
+		output_iterator_proxy_impl(const IT& _i) : i(_i) { }
 		basic_output_iterator_proxy_impl<T>* dup() const {
 		    return new output_iterator_proxy_impl<IT,T>(i); }
 		basic_output_iterator_proxy_impl<T>& operator=(const T& x) {
-		    (*i) = x;
-		}
+		    (*i) = x; return *this; }
 	};
 
 	template<typename T>
 	class output_iterator_proxy : public iterator<output_iterator_tag,T,void,T*,T&> {
 	    public:
 		basic_output_iterator_proxy_impl<T> *I;
 
 		template<typename IT>
 		    output_iterator_proxy(const IT& i)
 		    : I(new output_iterator_proxy_impl<IT,T>(i)) { }
 		output_iterator_proxy(const output_iterator_proxy<T>& x)
 		    : I(x.I->dup()) { }
 		~output_iterator_proxy() { delete I; }
 
 		output_iterator_proxy& operator=(const output_iterator_proxy<T>& x) {
 		    delete I; I = x.I->dup(); }
 
 		output_iterator_proxy& operator*() { return *this; }
 		output_iterator_proxy& operator=(const T& x) {
-		    (**I) = x; }
+		    (**I) = x; return *this; }
 
 		output_iterator_proxy& operator++() { return *this; }
 		output_iterator_proxy& operator++(int) { return *this; }
 	};
 
 	template <typename T,typename TR=T&,typename TP=T*>
 	class basic_forward_iterator_proxy_impl : public iterator<forward_iterator_tag,T,void,TP,TR> {
 	    public:
 		virtual ~basic_forward_iterator_proxy_impl() { }
 
 		virtual basic_forward_iterator_proxy_impl<T,TR,TP>* dup() const = 0;
 
 		virtual bool operator==(const basic_forward_iterator_proxy_impl<T,TR,TP>& x) const = 0;
 		virtual bool operator!=(const basic_forward_iterator_proxy_impl<T,TR,TP>& x) const {
 		    return !((*this)==x); }
 		virtual TR operator*() const = 0;
 		virtual TP operator->() const = 0;
 		virtual void advance() = 0;
 	};
 
 	template <typename IT>
 	class forward_iterator_proxy_impl : public basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer> {
 	    public:
 		IT i;
 
-		forward_iterator_proxy_impl(const IT& i) : i(i) { }
+		forward_iterator_proxy_impl(const IT& _i) : i(_i) { }
 
 		virtual basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>* dup() const {
 		    return new forward_iterator_proxy_impl<IT>(i); }
 
 		virtual bool operator==(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
 		    return i==static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
 		virtual bool operator!=(const basic_forward_iterator_proxy_impl<typename IT::value_type,typename IT::reference,typename IT::pointer>& x) const {
 		    return i!=static_cast<const forward_iterator_proxy_impl<IT>*>(&x)->i; }
 		virtual typename IT::reference operator*() const { return *i; }
 		virtual typename IT::pointer operator->() const { return i.operator->(); }
 		virtual void advance() { ++i; }
 	};
 
 	template<typename T,typename TR=T&,typename TP=T*>
 	class forward_iterator_proxy : public iterator<forward_iterator_tag,T,void,TP,TR> {
 	    public:
 		basic_forward_iterator_proxy_impl<T,TR,TP> *I;
 
 		template<typename IT>
 		    forward_iterator_proxy(const IT& i)
 		    : I(new forward_iterator_proxy_impl<IT>(i)) { }
 		forward_iterator_proxy(const forward_iterator_proxy<T,TR,TP>& x)
 		    : I(x.I->dup()) { }
 		~forward_iterator_proxy() { delete I; }
 
 		forward_iterator_proxy& operator=(const forward_iterator_proxy<T,TR,TP>& x) {
 		    delete I; I = x.I->dup(); }
 
 		bool operator==(const forward_iterator_proxy<T,TR,TP>& x) const {
 		    return (*I)==(*(x.I)); }
 		bool operator!=(const forward_iterator_proxy<T,TR,TP>& x) const {
 		    return (*I)!=(*(x.I)); }
 
 		TR operator*() const {
 		    return **I; }
 		TP operator->() const {
 		    return I->operator->(); }
 
 		forward_iterator_proxy<T,TR,TP>& operator++() {
 		    I->advance(); return *this; }
 		forward_iterator_proxy<T,TR,TP>& operator++(int) {
 		    forward_iterator_proxy<T,TR,TP> rv(*this);
 		    I->advance(); return rv; }
 	};
 
 	template<typename IT>
 	    class basic_filterator : public iterator<
 					  typename IT::iterator_category,
 					  typename IT::value_type,
 					  typename IT::difference_type,
 					  typename IT::pointer,
 					  typename IT::reference> {
 		public:
 		    IT it;
 		    IT ei;
 		    bool empty;
 
 		    basic_filterator() : empty(true) { }
-		    basic_filterator(const IT& bi,const IT& ei)
-			: it(bi), ei(ei) { empty = (bi==ei); }
+		    basic_filterator(const IT& _bi,const IT& _ei)
+			: it(_bi), ei(_ei) { empty = (it==ei); }
 		    basic_filterator(const basic_filterator<IT>& x)
 			: it(x.it), ei(x.ei), empty(x.empty) { }
 		    virtual ~basic_filterator() { }
 
 		    bool operator==(const basic_filterator<IT>& x) const {
 			return empty?x.empty:(it==x.it); }
 		    bool operator!=(const basic_filterator<IT>& x) const {
 			return empty!=x.empty || it!=x.it; }
 
 		    typename IT::reference operator*() const {
 			assert(!empty);
 			return *it; }
 		    typename IT::pointer operator->() const {
 			assert(!empty);
 			return it.operator->(); }
 
 		    basic_filterator<IT>& operator++() {
 			bool found = false;
 			for(++it;!(it==ei || (found=is_interesting()));++it);
 			if(!found) empty=true;
 			return *this;
 		    }
 		    basic_filterator<IT> operator++(int) {
 			basic_filterator<IT> rv(*this);
 			++(*this);
 			return rv;
 		    }
 
 		    void prepare() {
 			bool found = false;
 			for(;!(it==ei || (found=is_interesting()));++it);
 			if(!found) empty = true;
 		    }
 		    virtual bool is_interesting() const = 0;
 	    };
 
 	template<typename IT,typename T=typename IT::value_type::first_type,typename TR=T&,typename TP=T*>
 	    class map_keys_iterator : public iterator<
 				      typename IT::iterator_category,
 				      T,void,TP,TR> {
 		public:
 		    typedef map_keys_iterator<IT,T,TR,TP> self_type;
 		    IT it;
 		    IT ei;
 		    bool empty;
 
 		    map_keys_iterator() : empty(true) { }
-		    map_keys_iterator(const IT& bi,
-			    const IT& ei)
-			: it(bi), ei(ei) { empty = (bi==ei); }
+		    map_keys_iterator(const IT& _bi,
+			    const IT& _ei)
+			: it(_bi), ei(_ei) { empty = (it==ei); }
 		    map_keys_iterator(const self_type& x)
 			: it(x.it), ei(x.ei), empty(x.empty) { }
 
 		    bool operator==(const self_type& x) const {
 			return empty?x.empty:(it==x.it); }
 		    bool operator!=(const self_type& x) const {
 			return empty!=x.empty || it!=x.it; }
 
 		    TR operator*() const {
 			assert(!empty);
 			return it->first; }
 		    TP operator->() const {
 			assert(!empty);
 			return &(it->first); }
 
 		    self_type& operator++() {
 			assert(!empty);
 			empty=((++it)==ei); return *this; }
 		    self_type operator++(int) {
 			self_type rv(*this);
 			++(*this); return rv; }
 	    };
 
     }
 }
 
 #endif /* __OPKELE_ITERATOR_H */
diff --git a/include/opkele/types.h b/include/opkele/types.h
index 6ab51ef..a3b657d 100644
--- a/include/opkele/types.h
+++ b/include/opkele/types.h
@@ -1,229 +1,230 @@
 #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;
 
 	    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); }
     };
 
 }
 
 #endif /* __OPKELE_TYPES_H */