Adhere to Postel's Law.

That is, be liberal when parsing key/value parameters from remote.
Along with configure switch to disable it.

2 files changed, 23 insertions, 0 deletions

diff --git a/configure.ac b/configure.ac
index 8397914..19e7832 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,85 +1,92 @@
 AC_INIT([libopkele], [0.1.1], [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
 
 AC_HEADER_STDC
 
 AC_PATH_PROG([XSLTPROC],[xsltproc],[true])
 AC_WITH_PKGCONFIG
 
 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_WITH_PCRE([
   AC_WITH_PCREPP(,[
    AC_MSG_ERROR([no pcre++ library found. get one at http://www.daemon.de/PCRE])
   ])
  ],[
   AC_MSG_ERROR([no pcre library found. get one at http://www.pcre.org/])
  ]
 )
 
 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_CONFIG_FILES([
  Makefile
   libopkele.pc
   Doxyfile
  include/Makefile
  lib/Makefile
 ])
 AC_OUTPUT
diff --git a/lib/params.cc b/lib/params.cc
index b181811..ea86d3a 100644
--- a/lib/params.cc
+++ b/lib/params.cc
@@ -1,92 +1,108 @@
 #include <opkele/types.h>
 #include <opkele/exception.h>
 #include <opkele/util.h>
 #include <openssl/sha.h>
 #include <openssl/hmac.h>
 
+#include "config.h"
+
 namespace opkele {
     using namespace std;
 
     bool params_t::has_param(const string& n) const {
         return find(n)!=end();
     }
     const string& params_t::get_param(const string& n) const {
         const_iterator i = find(n);
         if(i==end())
             throw failed_lookup(OPKELE_CP_ n+": no such parameter");
         return i->second;
     }
     string& params_t::get_param(const string& n) {
         iterator i = find(n);
         if(i==end())
             throw failed_lookup(OPKELE_CP_ n+": no such parameter");
         return i->second;
     }
 
     void params_t::parse_keyvalues(const string& kv) {
         clear();
         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)));
             p = nl+1;
+#else /* POSTELS_LAW */
+            string::size_type lb = kv.find_first_of("\r\n",co+1);
+            if(lb==string::npos) {
+                insert(value_type(kv.substr(p,co-p),kv.substr(co+1)));
+                break;
+            }
+            if(lb>co)
+                insert(value_type(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 */
         }
     }
 
     void params_t::sign(secret_t secret,string& sig,const string& slist,const char *prefix) const {
         string kv;
         string::size_type p = 0;
         while(true) {
             string::size_type co = slist.find(',',p);
             string f = (co==string::npos)?slist.substr(p):slist.substr(p,co-p);
             kv += f;
             kv += ':';
             if(prefix) f.insert(0,prefix);
             kv += get_param(f);
             kv += '\n';
             if(co==string::npos)
                 break;
             p = co+1;
         }
         unsigned int md_len = 0;
         unsigned char *md = HMAC(
                 EVP_sha1(),
                 &(secret.front()),secret.size(),
                 (const unsigned char *)kv.data(),kv.length(),
                 0,&md_len);
         sig = util::encode_base64(md,md_len);
     }
 
     string params_t::append_query(const string& url,const char *prefix) const {
         string rv = url;
         bool p = true;
         if(rv.find('?')==string::npos) {
             rv += '?';
             p = false;
         }
         for(const_iterator i=begin();i!=end();++i) {
             if(p)
                 rv += '&';
             else
                 p = true;
             rv += prefix;
             rv += i->first;
             rv += '=';
             rv += util::url_encode(i->second);
         }
         return rv;
     }
 
     ostream& operator << (ostream& o,const params_t& p) {
         for(params_t::const_iterator i=p.begin();i!=p.end();++i)
             o << i->first << ':' << i->second << '\n';
         return o;
     }
 
 }