don't include ext/algorithm if there's no suchHEADmaster

2 files changed, 6 insertions, 1 deletions

diff --git a/configure.ac b/configure.ac
index e636253..606e644 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,143 +1,144 @@
 AC_INIT([libopkele], [2.0.4], [libopkele-bugs@klever.net])
 AC_CONFIG_SRCDIR([include/opkele/opkele-config.h])
 AC_CONFIG_HEADERS([config.h include/opkele/acconfig.h])
 AC_CONFIG_MACRO_DIR([aclocal.d])
 AC_CONFIG_AUX_DIR([aux.d])
 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_CHECK_FUNCS([timegm])
+AC_CHECK_HEADERS([ext/algorithm.h])
 
 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],[
diff --git a/test/OP.cc b/test/OP.cc
index 6012b2e..4e2a5ed 100644
--- a/test/OP.cc
+++ b/test/OP.cc
@@ -1,146 +1,150 @@
 #include <uuid/uuid.h>
 #include <iostream>
 #include <cassert>
 #include <string>
-#include <ext/algorithm>
 using namespace std;
 #include <kingate/exception.h>
 #include <kingate/plaincgi.h>
 #include <kingate/cgi_gateway.h>
 #include <opkele/exception.h>
 #include <opkele/util.h>
 #include <opkele/uris.h>
 #include <opkele/extension.h>
 #include <opkele/association.h>
 #include <opkele/debug.h>
 #include <opkele/verify_op.h>
 #include <opkele/sreg.h>
 
+#include "config.h"
+#ifdef HAVE_EXT_ALGORITHM_H
+# include <ext/algorithm>
+#endif
+
 #include "sqlite.h"
 #include "kingate_openid_message.h"
 
 static const string get_self_url(const kingate::cgi_gateway& gw) {
     bool s = gw.has_meta("SSL_PROTOCOL_VERSION");
     string rv = s?"https://":"http://";
     rv += gw.http_request_header("Host");
     const string& port = gw.get_meta("SERVER_PORT");
     if( port!=(s?"443":"80") ) {
         rv += ':'; rv += port;
     }
     rv += gw.get_meta("REQUEST_URI");
     string::size_type q = rv.find('?');
     if(q!=string::npos)
         rv.erase(q);
     return rv;
 }
 
 class opdb_t : public sqlite3_t {
     public:
         opdb_t()
             : sqlite3_t("/tmp/OP.db") {
                 assert(_D);
                 char **resp; int nr,nc; char *errm;
                 if(sqlite3_get_table(
                             _D, "SELECT a_op FROM assoc LIMIT 0",
                             &resp,&nr,&nc,&errm)!=SQLITE_OK) {
                     extern const char *__OP_db_bootstrap;
                     DOUT_("Bootstrapping DB");
                     if(sqlite3_exec(_D,__OP_db_bootstrap,NULL,NULL,&errm)!=SQLITE_OK)
                         throw opkele::exception(OPKELE_CP_ string("Failed to boostrap SQLite database: ")+errm);
                 }else
                     sqlite3_free_table(resp);
             }
 };
 
 class example_op_t : public opkele::verify_OP {
     public:
         kingate::cgi_gateway& gw;
         opdb_t db;
         kingate::cookie htc;
 
 
         example_op_t(kingate::cgi_gateway& g)
         : gw(g) {
             try {
                 htc = gw.cookies.get_cookie("htop_session");
                 sqlite3_mem_t<char*> S = sqlite3_mprintf(
                         "SELECT 1 FROM ht_sessions WHERE hts_id=%Q",
                         htc.get_value().c_str());
                 sqlite3_table_t T; int nr,nc;
                 db.get_table(S,T,&nr,&nc);
                 if(nr<1)
                     throw kingate::exception_notfound(CODEPOINT,"forcing cookie generation");
             }catch(kingate::exception_notfound& kenf) {
                 uuid_t uuid; uuid_generate(uuid);
                 htc = kingate::cookie("htop_session",opkele::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);
             }
         }
 
         void set_authorized(bool a) {
             sqlite3_mem_t<char*>
                 S = sqlite3_mprintf(
                         "UPDATE ht_sessions"
                         " SET authorized=%d"
                         " WHERE hts_id=%Q",
                         (int)a,htc.get_value().c_str());
             db.exec(S);
         }
         bool get_authorized() {
             sqlite3_mem_t<char*>
                 S = sqlite3_mprintf(
                         "SELECT authorized"
                         " FROM ht_sessions"
                         " WHERE hts_id=%Q",
                         htc.get_value().c_str());
             sqlite3_table_t T; int nr,nc;
             db.get_table(S,T,&nr,&nc);
             assert(nr==1); assert(nc=1);
             return opkele::util::string_to_long(T.get(1,0,nc));
         }
 
         ostream& cookie_header(ostream& o) const {
             o << "Set-Cookie: " << htc.set_cookie_header() << "\n";
             return o;
         }
 
         opkele::assoc_t alloc_assoc(const string& type,size_t klength,bool sl) {
             uuid_t uuid; uuid_generate(uuid);
             string a_handle = opkele::util::encode_base64(uuid,sizeof(uuid));
             opkele::secret_t a_secret;
             generate_n(
                     back_insert_iterator<opkele::secret_t>(a_secret),klength,
                     rand );
             string ssecret; a_secret.to_base64(ssecret);
             time_t now = time(0);
             int expires_in = sl?3600*2:3600*24*7*2;
             sqlite3_mem_t<char*>
                 S = sqlite3_mprintf(
                         "INSERT INTO assoc"
                         " (a_handle,a_type,a_ctime,a_etime,a_secret,a_stateless)"
                         " VALUES ("
                         "  %Q,%Q,datetime('now'),"
                         "  datetime('now','+%d seconds'),"
                         "  %Q,%d );",
                         a_handle.c_str(), type.c_str(),
                         expires_in,
                         ssecret.c_str(), sl );
             db.exec(S);
             return opkele::assoc_t(new opkele::association(
                         "",
                         a_handle, type, a_secret,
                         now+expires_in, sl ));
         }
 
         opkele::assoc_t retrieve_assoc(const string& h) {
             sqlite3_mem_t<char*>
                 S = sqlite3_mprintf(
                         "SELECT"
                         "  a_handle,a_type,a_secret,a_stateless,"
                         "  strftime('%%s',a_etime) AS a_etime,"
                         "  a_itime"
                         " FROM assoc"
                         " WHERE a_handle=%Q AND a_itime IS NULL"