8 files changed, 157 insertions, 100 deletions
diff --git a/configure.ac b/configure.ac
index a49177f..0aa1272 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,253 +1,257 @@
 AC_INIT([libopkele], [1.1.99.0], [libopkele-bugs@klever.net])
 AC_CONFIG_SRCDIR([include/opkele/opkele-config.h])
 AC_CONFIG_HEADERS([config.h include/opkele/acconfig.h])
 AM_INIT_AUTOMAKE([dist-bzip2])
 AC_PROG_INSTALL
 AC_PROG_CXX
 AC_PROG_CC
 AC_PROG_LIBTOOL
 PKG_PROG_PKG_CONFIG
 AC_HEADER_STDC
 AC_PATH_PROG([XSLTPROC],[xsltproc],[true])
 AC_MSG_CHECKING([for source tree version])
 if headrev=$(cd $srcdir && git rev-parse --verify HEAD 2>/dev/null) ; then
 PACKAGE_SRC_VERSION="$(cd $srcdir && git describe --tags $headrev)"
 test "$PACKAGE_SRC_VERSION" = "$PACKAGE_VERSION" \
  -o "${PACKAGE_SRC_VERSION#${PACKAGE_VERSION}-}" != "$PACKAGE_SRC_VERSION" || PACKAGE_SRC_VERSION="${PACKAGE_VERSION}:${PACKAGE_SRC_VERSION}"
 ( cd $srcdir && git diff-index $headrev | read dirt ) && PACKAGE_SRC_VERSION="${PACKAGE_SRC_VERSION}-dirty"
 else
 PACKAGE_SRC_VERSION="$PACKAGE_VERSION"
 fi
 AC_MSG_RESULT([$PACKAGE_SRC_VERSION])
 AC_SUBST([PACKAGE_SRC_VERSION])
 AC_DEFINE_UNQUOTED([PACKAGE_SRC_VERSION],["$PACKAGE_SRC_VERSION"],[more or less precise source tree version])
 tr1_mem_std="false"
 tr1_mem_boost="false"
 AC_CHECK_SHAREDPTR(std::tr1,tr1/memory,[ tr1_mem_std=true ])
 AC_CHECK_SHAREDPTR(boost,boost/shared_ptr.hpp,[ tr1_mem_boost=true ])
 tr1_mem=""
 AC_ARG_WITH([tr1-memory],
 AC_HELP_STRING([--with-tr1-memory=<boost|std>],[select tr1/memory (shared_ptr<>) implementation to use]),
 [ tr1_mem="$withval" ]
 )
 AC_MSG_CHECKING([for tr1/memory implementation to use])
 test -z "$tr1_mem" && $tr1_mem_std && tr1_mem=std
 test -z "$tr1_mem" && $tr1_mem_boost && tr1_mem=boost
 if test -z "$tr1_mem" ; then
 AC_MSG_RESULT([none found])
 else
 AC_MSG_RESULT([$tr1_mem])
 fi
 case "$tr1_mem" in
 std)
  $tr1_mem_std || AC_MSG_ERROR([std implementation requested, but not found])
  OPKELE_TR1_MEM_NS=std::tr1
  OPKELE_TR1_MEM_HEADER=tr1/memory
  ;;
 boost)
  $tr1_mem_boost || AC_MSG_ERROR([boost implementation requested, but not found])
  OPKELE_TR1_MEM_NS=boost
  OPKELE_TR1_MEM_HEADER=boost/shared_ptr.hpp
  ;;
 *)
  AC_MSG_ERROR([no shared_ptr<> implementation found])
  ;;
 esac
 AC_SUBST([OPKELE_TR1_MEM_NS])
 AC_SUBST([OPKELE_TR1_MEM_HEADER])
 AC_MSG_CHECKING([for deprecated attribute support])
 AC_COMPILE_IFELSE([
  int __attribute__((deprecated)) deprecated_function();
 ],[
  AC_MSG_RESULT([yes])
  AC_DEFINE([OPKELE_DEPRECATE],[__attribute__((deprecated))],[deprecated function attribute])
 ],[
  AC_MSG_RESULT([no])
  AC_DEFINE([OPKELE_DEPRECATE],,[deprecated function attribute])
 ]
 )
 AC_LANG_PUSH([C++])
 AC_MSG_CHECKING([for abi::__cxa_demangle])
 AC_COMPILE_IFELSE([
  #include <typeinfo>
  using namespace std;
  #include <cxxabi.h>
  int main(int c,char **v) {
   int dstat;
   char *demangled = abi::__cxa_demangle(typeid(dstat).name(),0,0,&dstat);
   return 0;
  }
 ],[
  AC_MSG_RESULT([yes])
  AC_DEFINE([HAVE_DEMANGLE],,[defined if abi::__cxa_demangle is available])
 ],[
  AC_MSG_RESULT([no])
 ]
 )
 AC_LANG_POP([C++])
 PKG_CHECK_MODULES([OPENSSL],[openssl],,[
 AC_MSG_ERROR([no openssl library found. get one from http://www.openssl.org/])
 ])
 WANT_KONFORKA="yes"
 AC_ARG_ENABLE([konforka],
 AC_HELP_STRING([--disable-konforka],[do not use konforka library (default: use if found)]),
 [
  test "${enableval}" = "no" && WANT_KONFORKA="no"
 ]
 )
 if test "${WANT_KONFORKA}" = "yes" ; then
 PKG_CHECK_MODULES([KONFORKA],[konforka],[
  AC_SUBST([KONFORKA_CFLAGS])
  AC_SUBST([KONFORKA_LIBS])
  AC_DEFINE([HAVE_KONFORKA],,[defined in presence of konforka library])
  AC_DEFINE([OPKELE_HAVE_KONFORKA],,[defined in presence of konforka library])
  AC_SUBST([KONFORKA_KONFORKA],[konforka])
 ],[true])
 fi
 WANT_DOXYGEN="yes"
 AC_ARG_ENABLE([doxygen],
 AC_HELP_STRING([--disable-doxygen],[do not generate documentation]),
 [
  test "${enableval}" = "no" && WANT_DOXYGEN="no"
 ]
 )
 if test "${WANT_DOXYGEN}" = "yes" ; then
 AC_WITH_DOXYGEN
 AC_WITH_DOT
 else
 AM_CONDITIONAL([HAVE_DOXYGEN],[false])
 AM_CONDITIONAL([HAVE_DOT],[false])
 fi
 LIBCURL_CHECK_CONFIG(,,,[
 AC_MSG_ERROR([no required libcurl library. get one from http://curl.haxx.se/])
 ])
 AC_CHECK_HEADER([expat.h],[
 AC_CHECK_LIB([expat],[XML_ParserCreate],[
  EXPAT_LIBS=-lexpat
  EXPAT_CFLAGS=
  AC_SUBST([EXPAT_LIBS])
  AC_SUBST([EXPAT_CFLAGS])
 ],[
  AC_MSG_ERROR([no required expat library. get one from http://expat.sourceforge.net/])
 ])
 ],[
 AC_MSG_ERROR([no required expat library. get one from http://expat.sourceforge.net/])
 ])
 AC_CHECK_HEADER([tidy.h],[
 AC_CHECK_LIB([tidy],[tidyParseBuffer],[
  TIDY_LIBS=-ltidy
  TIDY_CFLAGS=
  AC_SUBST([TIDY_LIBS])
  AC_SUBST([TIDY_CFLAGS])
 ],[
  AC_MSG_ERROR([no required htmltidy library found. get one from http://tidy.sourceforge.net/])
 ])
 ],[
 AC_MSG_ERROR([no required htmltidy library found. get one from http://tidy.sourceforge.net/])
 ])
 if test -n "$PCRE_LIBS" -a -n "$PCRE_CFLAGS" ; then
 AC_SUBST([PCRE_CFLAGS])
 AC_SUBST([PCRE_LIBS])
 :
 else
 PKG_CHECK_MODULES([PCRE],[libpcre],,[
  AC_MSG_ERROR([no libpcre found, go get it at http://www.pcre.org/])
 ])
 fi
 PKG_CHECK_MODULES([SQLITE3],[sqlite3],[have_sqlite3=true],[have_sqlite3=false])
 AM_CONDITIONAL([HAVE_SQLITE3],[$have_sqlite3])
 PKG_CHECK_MODULES([KINGATE],[kingate-plaincgi],[have_kingate=true],[have_kingate=false])
 AM_CONDITIONAL([HAVE_KINGATE],[$have_kingate])
 PKG_CHECK_MODULES([UUID],[uuid],[have_uuid=true],[have_uuid=false])
 AM_CONDITIONAL([HAVE_UUID],[$have_uuid])
+if $have_uuid ; then
+ AC_DEFINE([HAVE_LIBUUID],,[defined in presence of libuuid])
+ AC_SUBST([UUID_UUID],[uuid])
+fi
 curl_ssl_verify_host="true"
 AC_ARG_ENABLE([ssl-verify-host],
 AC_HELP_STRING([--disable-ssl-verify-host],[disable cURL cert/host relationships verification]),
 [ test "${enableval}" = "no" && curl_ssl_verify_host="false" ]
 )
 ${curl_ssl_verify_host} || AC_DEFINE([DISABLE_CURL_SSL_VERIFYHOST],,[defined if cURL is not to verify cert/host])
 curl_ssl_verify_peer="true"
 AC_ARG_ENABLE([ssl-verify-peer],
 AC_HELP_STRING([--disable-ssl-verify-peer],[disable cURL cert validity verification]),
 [ test "${enableval}" = "no" && curl_ssl_verify_peer="false" ]
 )
 ${curl_ssl_verify_peer} || AC_DEFINE([DISABLE_CURL_SSL_VERIFYPEER],,[defined if cURL is not to verify cert validity])
 postels_law=true
 AC_ARG_ENABLE([postels-law],
 AC_HELP_STRING([--disable-postels-law],[Be strict, do not adhere to Postel's Law ("be conservative in what you do, be liberal in what you accept from others", RFC 793)]),
 [ test "${enableval}" = "no" && postels_law=false ]
 )
 $postels_law && AC_DEFINE([POSTELS_LAW],,[defined if we want to adhere to Postel's Law])
 AC_DEFINE_UNQUOTED([OPKELE_SRC_DIR],["$PWD"],[source directory])
 nitpick=false
 AC_ARG_ENABLE([nitpicking],
 AC_HELP_STRING([--enable-nitpicking],[make compiler somewhat overly fastidious about the code it deals with]),
 [ test "$enableval" = "no" || nitpick=true ]
 )
 if $nitpick ; then
 CPP_NITPICK="-pedantic -Wall -Wextra -Wundef -Wshadow \
  -Wunsafe-loop-optimizations -Wconversion -Wmissing-format-attribute \
  -Wredundant-decls -ansi"
 # -Wlogical-op -Wmissing-noreturn 
 C_NITPICK="$CPP_NITPICK"
 CXX_NITPICK="$C_NITPICK"
 CPPFLAGS="$CPPFLAGS $CPP_NITPICK"
 CFLAGS="$CFLAGS $C_NITPICK"
 CXXFLAGS="$CXXFLAGS $CXX_NITPICK"
 fi
 ndebug=true
 AC_ARG_ENABLE([debug],
 AC_HELP_STRING([--enable-debug],[enable debugging code]),
 [ test "$enableval" = "no" || ndebug=false ]
 )
 if $ndebug ; then
 CPPFLAGS_DEBUG="-DNDEBUG"
 else
 CPPFLAGS_DEBUG=""
 fi
 AC_SUBST([CPPFLAGS_DEBUG])
 xri_proxy_url="https://xri.net/"
 AC_MSG_CHECKING([for XRI resolver proxy])
 AC_ARG_ENABLE([xri-proxy],
 AC_HELP_STRING([--with-xri-proxy=url],[set xri proxy for use when resolving xri identities, default is https://xri.net/]),
 [ xri_proxy_url="$withval" ]
 )
 AC_MSG_RESULT([$xri_proxy_url])
 AC_DEFINE_UNQUOTED([XRI_PROXY_URL],["$xri_proxy_url"],[XRI proxy resolver URL])
 AC_CONFIG_FILES([
 Makefile
  libopkele.pc
  Doxyfile
 include/Makefile
  include/opkele/tr1-mem.h
 lib/Makefile
 test/Makefile
 ])
 AC_OUTPUT
diff --git a/include/opkele/curl.h b/include/opkele/curl.h
index 5cf8e48..bcaf11d 100644
--- a/include/opkele/curl.h
+++ b/include/opkele/curl.h
@@ -1,72 +1,92 @@
 #ifndef __OPKELE_CURL_H
 #define __OPKELE_CURL_H
 #include <cassert>
 #include <string>
 #include <algorithm>
 #include <curl/curl.h>
 namespace opkele {
    using std::min;
    using std::string;
    namespace util {
+        class curl_slist_t {
+            public:
+                curl_slist *_s;
+                curl_slist_t() : _s(0) { }
+                curl_slist_t(curl_slist *s) : _s(s) { }
+                virtual ~curl_slist_t() throw();
+                curl_slist_t& operator=(curl_slist *s);
+                operator const curl_slist*(void) const { return _s; }
+                operator curl_slist*(void) { return _s; }
+                void append(const char *str);
+                void append(const string& str) {
+                    append(str.c_str()); }
+        };
        class curl_t {
            public:
                CURL *_c;
                curl_t() : _c(0) { }
                curl_t(CURL *c) : _c(c) { }
                virtual ~curl_t() throw();
                curl_t& operator=(CURL *c);
                operator const CURL*(void) const { return _c; }
                operator CURL*(void) { return _c; }
                CURLcode misc_sets();
                template<typename PT>
                    inline CURLcode easy_setopt(CURLoption o,PT p) { assert(_c); return curl_easy_setopt(_c,o,p); }
+                inline CURLcode easy_setopt(CURLoption o,const curl_slist_t& p) {
+                    assert(_c); return curl_easy_setopt(_c,o,(const curl_slist*)p); }
                CURLcode easy_perform() { assert(_c); return curl_easy_perform(_c); }
                template<typename IT>
                    inline CURLcode easy_getinfo(CURLINFO i,IT p) { assert(_c); return curl_easy_getinfo(_c,i,p); }
                static inline CURL *easy_init() { return curl_easy_init(); }
                virtual size_t write(void* /* p */,size_t /* s */,size_t /* nm */) { return 0; }
                CURLcode set_write();
                virtual int progress(double /* dlt */,double /* dln*/ ,double /* ult */,double /* uln */) { return 0; }
                CURLcode set_progress();
                virtual size_t header(void* /* p */,size_t s,size_t nm) { return s*nm; }
                CURLcode set_header();
        };
        template<int lim>
            class curl_fetch_string_t : public curl_t {
                public:
                    curl_fetch_string_t(CURL *c)
                        : curl_t(c) { }
                    ~curl_fetch_string_t() throw() { }
                    string response;
                    size_t write(void *p,size_t size,size_t nmemb) {
                        size_t bytes = size*nmemb;
                        size_t get = min(lim-response.length(),bytes);
                        response.append((const char *)p,get);
                        return get;
                    }
            };
        typedef curl_fetch_string_t<16384> curl_pick_t;
    }
 }
 #endif /* __OPKELE_CURL_H */
diff --git a/include/opkele/types.h b/include/opkele/types.h
index ffb9afb..f63bf5d 100644
--- a/include/opkele/types.h
+++ b/include/opkele/types.h
@@ -1,234 +1,243 @@
 #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 {
+    class basic_fields {
        public:
-            typedef list<string> fields_t;
            typedef util::forward_iterator_proxy<
                string,const string&,const string*
                > fields_iterator;
-            basic_openid_message() { }
+            basic_fields() { }
-            virtual ~basic_openid_message() { }
+            virtual ~basic_fields() { }
-            basic_openid_message(const basic_openid_message& x);
+            basic_fields(const basic_fields& x);
-            void copy_to(basic_openid_message& x) const;
+            void copy_to(basic_fields& x) const;
-            void append_to(basic_openid_message& x) const;
+            void append_to(basic_fields& 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 char *pfx="openid.") const;
+            virtual string append_query(const string& url,const char *pfx=0) const;
-            virtual string query_string(const char *pfx="openid.") const;
+            virtual string query_string(const char *pfx=0) const;
            virtual void reset_fields();
            virtual void set_field(const string& n,const string& v);
            virtual void reset_field(const string& n);
+    };
+    class basic_openid_message : public basic_fields {
+        public:
+            basic_openid_message() { }
+            basic_openid_message(const basic_openid_message& x);
+            virtual bool has_ns(const string& uri) const;
+            virtual string get_ns(const string& uri) const;
+            virtual string append_query(const string& url,const char *pfx="openid.") const {
+                return basic_fields::append_query(url,pfx); }
+            virtual string query_string(const char *pfx="openid.") const {
+                return basic_fields::query_string(pfx); }
            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/Makefile.am b/lib/Makefile.am
index e8bfbf5..20d15b8 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -1,34 +1,34 @@
 lib_LTLIBRARIES = libopkele.la
 AM_CPPFLAGS = ${CPPFLAGS_DEBUG}
 DEFAULT_INCLUDES = -I${top_builddir}
 INCLUDES = \
           -I${top_builddir}/include/ -I${top_srcdir}/include/ \
           ${KONFORKA_CFLAGS} \
           ${OPENSSL_CFLAGS} \
           ${LIBCURL_CPPFLAGS} \
           ${PCRE_CFLAGS} ${EXPAT_CFLAGS} ${TIDY_CFLAGS}
 libopkele_la_LIBADD = \
        ${LIBCURL} \
        ${PCRE_LIBS} ${EXPAT_LIBS} \
        ${OPENSSL_LIBS} \
        ${KONFORKA_LIBS} ${TIDY_LIBS}
 libopkele_la_SOURCES = \
                       params.cc \
                       util.cc \
                       server.cc \
                       secret.cc \
                       data.cc \
                       consumer.cc \
                       exception.cc \
                       extension.cc \
                       sreg.cc \
                       extension_chain.cc \
                       curl.cc expat.cc \
                       discovery.cc \
                       basic_rp.cc prequeue_rp.cc \
-                       openid_message.cc \
+                       fields.cc message.cc \
                       basic_op.cc verify_op.cc
 libopkele_la_LDFLAGS = \
        -version-info 2:0:0
diff --git a/lib/curl.cc b/lib/curl.cc
index 6172828..734e2ca 100644
--- a/lib/curl.cc
+++ b/lib/curl.cc
@@ -1,79 +1,99 @@
+#include <opkele/exception.h>
 #include <opkele/curl.h>
 #include "config.h"
 namespace opkele {
    namespace util {
+        curl_slist_t::~curl_slist_t() throw() {
+            if(_s)
+                curl_slist_free_all(_s);
+        }
+        curl_slist_t& curl_slist_t::operator=(curl_slist *s) {
+            if(_s)
+                curl_slist_free_all(_s);
+            _s = s;
+            return *this;
+        }
+        void curl_slist_t::append(const char *str) {
+            curl_slist *s = curl_slist_append(_s,str);
+            if(!s)
+                throw opkele::exception(OPKELE_CP_ "failed to curl_slist_append()");
+            _s=s;
+        }
        curl_t::~curl_t() throw() {
            if(_c)
                curl_easy_cleanup(_c);
        }
        curl_t& curl_t::operator=(CURL *c) {
            if(_c)
                curl_easy_cleanup(_c);
            _c = c;
            return *this;
        }
        CURLcode curl_t::misc_sets() {
            assert(_c);
            CURLcode r;
            (r=easy_setopt(CURLOPT_FOLLOWLOCATION,1))
            || (r=easy_setopt(CURLOPT_MAXREDIRS,5))
            || (r=easy_setopt(CURLOPT_DNS_CACHE_TIMEOUT,120))
            || (r=easy_setopt(CURLOPT_DNS_USE_GLOBAL_CACHE,1))
            || (r=easy_setopt(CURLOPT_USERAGENT,PACKAGE_NAME"/"PACKAGE_SRC_VERSION))
            || (r=easy_setopt(CURLOPT_TIMEOUT,20))
        #ifdefDISABLE_CURL_SSL_VERIFYHOST
            || (r=easy_setopt(CURLOPT_SSL_VERIFYHOST,0))
 #endif
        #ifdefDISABLE_CURL_SSL_VERIFYPEER
            || (r=easy_setopt(CURLOPT_SSL_VERIFYPEER,0))
 #endif
            ;
            return r;
        }
        static size_t _write(void *p,size_t s,size_t nm,void *stream) {
            return ((curl_t*)stream)->write(p,s,nm);
        }
        CURLcode curl_t::set_write() {
            assert(_c);
            CURLcode r;
            (r = easy_setopt(CURLOPT_WRITEDATA,this))
            || (r = easy_setopt(CURLOPT_WRITEFUNCTION,_write));
            return r;
        }
        static int _progress(void *cp,double dlt,double dln,double ult,double uln) {
            return ((curl_t*)cp)->progress(dlt,dln,ult,uln);
        }
        CURLcode curl_t::set_progress() {
            assert(_c);
            CURLcode r;
            (r = easy_setopt(CURLOPT_PROGRESSDATA,this))
            || (r = easy_setopt(CURLOPT_PROGRESSFUNCTION,_progress))
            || (r = easy_setopt(CURLOPT_NOPROGRESS,0));
            return r;
        }
        static size_t _header(void *p,size_t s,size_t nm,void *stream) {
            return ((curl_t*)stream)->header(p,s,nm);
        }
        CURLcode curl_t::set_header() {
            assert(_c);
            CURLcode r;
            (r = easy_setopt(CURLOPT_HEADERDATA,this))
            || (r=easy_setopt(CURLOPT_HEADERFUNCTION,_header));
            return r;
        }
    }
 }
diff --git a/lib/fields.cc b/lib/fields.cc
new file mode 100644
index 0000000..d494098
--- a/dev/null
+++ b/lib/fields.cc
@@ -0,0 +1,86 @@
+#include <opkele/types.h>
+#include <opkele/exception.h>
+#include <opkele/util.h>
+namespace opkele {
+    using std::unary_function;
+    struct __om_copier : public unary_function<const string&,void> {
+        public:
+            const basic_fields& from;
+            basic_fields& to;
+            __om_copier(basic_fields& t,const basic_fields& f)
+                : from(f), to(t) { }
+            result_type operator()(argument_type f) {
+                to.set_field(f,from.get_field(f)); }
+    };
+    basic_fields::basic_fields(const basic_fields& x) {
+        x.copy_to(*this);
+    }
+    void basic_fields::copy_to(basic_fields& x) const {
+        x.reset_fields();
+        for_each(fields_begin(),fields_end(),
+                __om_copier(x,*this) );
+    }
+    void basic_fields::append_to(basic_fields& x) const {
+        for_each(fields_begin(),fields_end(),
+                __om_copier(x,*this) );
+    }
+    struct __om_query_builder : public unary_function<const string&,void> {
+        public:
+            const basic_fields& om;
+            bool first;
+            string& rv;
+            const char *pfx;
+            __om_query_builder(const char *p,string& r,const basic_fields& m)
+                : om(m), first(true), rv(r), pfx(p) {
+                    for_each(om.fields_begin(),om.fields_end(),*this);
+                }
+            __om_query_builder(const char *p,string& r,const basic_fields& m,const string& u)
+                : om(m), first(true), rv(r), pfx(p) {
+                    rv = u;
+                    if(rv.find('?')==string::npos)
+                        rv += '?';
+                    else
+                        first = false;
+                    for_each(om.fields_begin(),om.fields_end(),*this);
+                }
+            result_type operator()(argument_type f) {
+                if(first)
+                    first = false;
+                else
+                    rv += '&';
+                if(pfx) rv += pfx;
+                rv+= f;
+                rv += '=';
+                rv += util::url_encode(om.get_field(f));
+            }
+    };
+    string basic_fields::append_query(const string& url,const char *pfx) const {
+        string rv;
+        return __om_query_builder(pfx,rv,*this,url).rv;
+    }
+    string basic_fields::query_string(const char *pfx) const {
+        string rv;
+        return __om_query_builder(pfx,rv,*this).rv;
+    }
+    void basic_fields::reset_fields() {
+        throw not_implemented(OPKELE_CP_ "reset_fields() not implemented");
+    }
+    void basic_fields::set_field(const string&,const string&) {
+        throw not_implemented(OPKELE_CP_ "set_field() not implemented");
+    }
+    void basic_fields::reset_field(const string&) {
+        throw not_implemented(OPKELE_CP_ "reset_field() not implemented");
+    }
+}
diff --git a/lib/openid_message.cc b/lib/message.cc
index e244f43..b2324b7 100644
--- a/lib/openid_message.cc
+++ b/lib/message.cc
@@ -1,276 +1,194 @@
 #include <cassert>
 #include <opkele/types.h>
 #include <opkele/exception.h>
 #include <opkele/util.h>
 #include <opkele/debug.h>
 #include "config.h"
 namespace opkele {
    using std::input_iterator_tag;
    using std::unary_function;
-    struct __om_copier : public unary_function<const string&,void> {
-        public:
-            const basic_openid_message& from;
-            basic_openid_message& to;
-            __om_copier(basic_openid_message& t,const basic_openid_message& f)
-                : from(f), to(t) { }
-            result_type operator()(argument_type f) {
-                to.set_field(f,from.get_field(f)); }
-    };
-    basic_openid_message::basic_openid_message(const basic_openid_message& x) {
-        x.copy_to(*this);
-    }
-    void basic_openid_message::copy_to(basic_openid_message& x) const {
-        x.reset_fields();
-        for_each(fields_begin(),fields_end(),
-                __om_copier(x,*this) );
-    }
-    void basic_openid_message::append_to(basic_openid_message& x) const {
-        for_each(fields_begin(),fields_end(),
-                __om_copier(x,*this) );
-    }
    struct __om_ns_finder : public unary_function<const string&,bool> {
        public:
            const basic_openid_message& om;
            const string& uri;
            __om_ns_finder(const basic_openid_message& m,
                    const string& u) : om(m), uri(u) { }
            result_type operator()(argument_type f) {
                return
                    (!strncmp(f.c_str(),"ns.",sizeof("ns.")-1))
                        && om.get_field(f)==uri ;
            }
    };
    bool basic_openid_message::has_ns(const string& uri) const {
        fields_iterator ei = fields_end();
        fields_iterator i = find_if(fields_begin(),fields_end(),
                __om_ns_finder(*this,uri));
        return !(i==ei);
    }
    string basic_openid_message::get_ns(const string& uri) const {
        fields_iterator ei = fields_end();
        fields_iterator i = find_if(fields_begin(),fields_end(),
                __om_ns_finder(*this,uri));
        if(i==ei)
            throw failed_lookup(OPKELE_CP_ string("failed to find namespace ")+uri);
        return i->substr(3);
    }
-    struct __om_query_builder : public unary_function<const string&,void> {
-        public:
-            const basic_openid_message& om;
-            bool first;
-            string& rv;
-            const char *pfx;
-            __om_query_builder(const char *p,string& r,const basic_openid_message& m)
-                : om(m), first(true), rv(r), pfx(p) {
-                    for_each(om.fields_begin(),om.fields_end(),*this);
-                }
-            __om_query_builder(const char *p,string& r,const basic_openid_message& m,const string& u)
-                : om(m), first(true), rv(r), pfx(p) {
-                    rv = u;
-                    if(rv.find('?')==string::npos)
-                        rv += '?';
-                    else
-                        first = false;
-                    for_each(om.fields_begin(),om.fields_end(),*this);
-                }
-            result_type operator()(argument_type f) {
-                if(first)
-                    first = false;
-                else
-                    rv += '&';
-                if(pfx) rv += pfx;
-                rv+= f;
-                rv += '=';
-                rv += util::url_encode(om.get_field(f));
-            }
-    };
-    string basic_openid_message::append_query(const string& url,const char *pfx) const {
-        string rv;
-        return __om_query_builder(pfx,rv,*this,url).rv;
-    }
-    string basic_openid_message::query_string(const char *pfx) const {
-        string rv;
-        return __om_query_builder(pfx,rv,*this).rv;
-    }
-    void basic_openid_message::reset_fields() {
-        throw not_implemented(OPKELE_CP_ "reset_fields() not implemented");
-    }
-    void basic_openid_message::set_field(const string&,const string&) {
-        throw not_implemented(OPKELE_CP_ "set_field() not implemented");
-    }
-    void basic_openid_message::reset_field(const string&) {
-        throw not_implemented(OPKELE_CP_ "reset_field() not implemented");
-    }
    void basic_openid_message::from_keyvalues(const string& kv) {
        reset_fields();
        string::size_type p = 0;
        while(true) {
            string::size_type co = kv.find(':',p);
            if(co==string::npos)
                break;
 #ifndef POSTELS_LAW
            string::size_type nl = kv.find('\n',co+1);
            if(nl==string::npos)
                throw bad_input(OPKELE_CP_ "malformed input");
            if(nl>co)
-                insert(value_type(kv.substr(p,co-p),kv.substr(co+1,nl-co-1)));
+                set_field(kv.substr(p,co-p),kv.substr(co+1,nl-co-1));
            p = nl+1;
 #else /* POSTELS_LAW */
            string::size_type lb = kv.find_first_of("\r\n",co+1);
            if(lb==string::npos) {
                set_field(kv.substr(p,co-p),kv.substr(co+1));
                break;
            }
            if(lb>co)
                set_field(kv.substr(p,co-p),kv.substr(co+1,lb-co-1));
            string::size_type nolb = kv.find_first_not_of("\r\n",lb);
            if(nolb==string::npos)
                break;
            p = nolb;
 #endif /* POSTELS_LAW */
        }
    }
    struct __om_kv_outputter : public unary_function<const string&,void> {
        public:
            const basic_openid_message& om;
            ostream& os;
            __om_kv_outputter(const basic_openid_message& m,ostream& s)
                : om(m), os(s) { }
            result_type operator()(argument_type f) {
                os << f << ':' << om.get_field(f) << '\n';
            }
    };
    void basic_openid_message::to_keyvalues(ostream& o) const {
        for_each(fields_begin(),fields_end(),__om_kv_outputter(*this,o));
    }
    struct __om_html_outputter : public unary_function<const string&,void> {
        public:
            const basic_openid_message& om;
            ostream& os;
            const char *pfx;
            __om_html_outputter(const basic_openid_message& m,ostream& s,const char *p=0)
                : om(m), os(s), pfx(p) { }
            result_type operator()(argument_type f) {
                os <<
                    "<input type=\"hidden\""
                    " name=\"";
                if(pfx)
                    os << util::attr_escape(pfx);
                os << util::attr_escape(f) << "\""
                    " value=\"" << util::attr_escape(om.get_field(f)) << "\" />";
            }
    };
    void basic_openid_message::to_htmlhiddens(ostream& o,const char* pfx) const {
        for_each(fields_begin(),fields_end(),__om_html_outputter(*this,o,pfx));
    }
    void basic_openid_message::add_to_signed(const string& fields) {
        string::size_type fnc = fields.find_first_not_of(",");
        if(fnc==string::npos)
            throw bad_input(OPKELE_CP_ "Trying to add nothing in particular to the list of signed fields");
        string signeds;
        try {
            signeds = get_field("signed");
            string::size_type lnc = signeds.find_last_not_of(",");
            if(lnc==string::npos)
                signeds.assign(fields,fnc,fields.size()-fnc);
            else{
                string::size_type ss = signeds.size();
                if(lnc==(ss-1)) {
                    signeds+= ',';
                    signeds.append(fields,fnc,fields.size()-fnc);
                }else{
                    if(lnc<(ss-2))
                        signeds.replace(lnc+2,ss-lnc-2,
                                fields,fnc,fields.size()-fnc);
                    else
                        signeds.append(fields,fnc,fields.size()-fnc);
                }
            }
        }catch(failed_lookup&) {
            signeds.assign(fields,fnc,fields.size()-fnc);
        }
        set_field("signed",signeds);
    }
    string basic_openid_message::find_ns(const string& uri,const char *pfx) const {
        try {
            return get_ns(uri);
        }catch(failed_lookup&) {
            return pfx;
        }
    }
    string basic_openid_message::allocate_ns(const string& uri,const char *pfx) {
        if(!has_field("ns"))
            return pfx;
        if(has_ns(uri))
            throw bad_input(OPKELE_CP_ "OpenID message already contains namespace");
        string rv = pfx;
        if(has_field("ns."+rv)) {
            string::reference c=rv[rv.length()];
            for(c='a';c<='z' && has_field("ns."+rv);++c);
            if(c=='z')
                throw exception(OPKELE_CP_ "Failed to allocate namespace");
        }
        set_field("ns."+rv,uri);
        return rv;
    }
-    void openid_message_t::copy_to(basic_openid_message& x) const {
-        x.reset_fields();
-        for(const_iterator i=begin();i!=end();++i)
-            x.set_field(i->first,i->second);
-    }
    bool openid_message_t::has_field(const string& n) const {
        return find(n)!=end();
    }
    const string& openid_message_t::get_field(const string& n) const {
        const_iterator i=find(n);
        if(i==end())
            throw failed_lookup(OPKELE_CP_ n+": no such field");
        return i->second;
    }
    openid_message_t::fields_iterator openid_message_t::fields_begin() const {
        return util::map_keys_iterator<const_iterator,string,const string&,const string*>(begin(),end());
    }
    openid_message_t::fields_iterator openid_message_t::fields_end() const {
        return util::map_keys_iterator<const_iterator,string,const string&,const string*>(end(),end());
    }
    void openid_message_t::reset_fields() {
        clear();
    }
    void openid_message_t::set_field(const string& n,const string& v) {
        (*this)[n]=v;
    }
    void openid_message_t::reset_field(const string& n) {
        erase(n);
    }
 }
diff --git a/libopkele.pc.in b/libopkele.pc.in
index 011f2fe..2720a6a 100644
--- a/libopkele.pc.in
+++ b/libopkele.pc.in
@@ -1,11 +1,11 @@
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
 includedir=@includedir@
 Name: libopkele
 Description: C++ implementation of OpenID protocol
 Version: @VERSION@
-Requires: openssl libpcre @KONFORKA_KONFORKA@
+Requires: openssl libpcre @KONFORKA_KONFORKA@ @UUID_UUID@
 Cflags: -I${includedir} @LIBCURL_CPPFLAGS@ @PCRE_CFLAGS@ @EXPAT_CFLAGS@ @TIDY_CFLAGS@
 Libs: -L${libdir} -lopkele @LIBCURL@ @PCRE_LIBS@ @EXPAT_LIBS@ @TIDY_LIBS@