PackageLogger control by SRU opt x-log-anable
[metaproxy-moved-to-github.git] / src / filter_zoom.cpp
index 76992fa..b48b58f 100644 (file)
@@ -17,10 +17,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "config.hpp"
+
+#include <stdlib.h>
+#include <sys/types.h>
 #include "filter_zoom.hpp"
-#include <yaz/zoom.h>
-#include <yaz/yaz-version.h>
-#include <yaz/srw.h>
 #include <metaproxy/package.hpp>
 #include <metaproxy/util.hpp>
 #include <metaproxy/xmlutil.hpp>
@@ -31,6 +31,10 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
+
+#include <yaz/yaz-version.h>
+#include <yaz/tpath.h>
+#include <yaz/srw.h>
 #include <yaz/ccl_xml.h>
 #include <yaz/ccl.h>
 #include <yaz/rpn2cql.h>
@@ -42,29 +46,38 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include <yaz/log.h>
 #include <yaz/zgdu.h>
 #include <yaz/querytowrbuf.h>
+#include <yaz/sortspec.h>
+#include <yaz/tokenizer.h>
+#include <yaz/zoom.h>
 
 namespace mp = metaproxy_1;
 namespace yf = mp::filter;
 
 namespace metaproxy_1 {
     namespace filter {
-        struct Zoom::Searchable : boost::noncopyable {
+        class Zoom::Searchable : boost::noncopyable {
+          public:
             std::string authentication;
             std::string cfAuth;
             std::string cfProxy;
-            std::string cfSubDb;
+            std::string cfSubDB;
             std::string udb;
             std::string target;
             std::string query_encoding;
             std::string sru;
+            std::string sru_version;
             std::string request_syntax;
             std::string element_set;
             std::string record_encoding;
             std::string transform_xsl_fname;
+            std::string transform_xsl_content;
             std::string urlRecipe;
+            std::string contentConnector;
+            std::string sortStrategy;
             bool use_turbomarc;
             bool piggyback;
             CCL_bibset ccl_bibset;
+            std::map<std::string, std::string> sortmap;
             Searchable(CCL_bibset base);
             ~Searchable();
         };
@@ -72,24 +85,26 @@ namespace metaproxy_1 {
             friend class Impl;
             friend class Frontend;
             std::string zurl;
+            WRBUF m_apdu_wrbuf;
             ZOOM_connection m_connection;
             ZOOM_resultset m_resultset;
             std::string m_frontend_database;
             SearchablePtr sptr;
             xsltStylesheetPtr xsp;
+            std::string content_session_id;
         public:
             Backend(SearchablePtr sptr);
             ~Backend();
-            void connect(std::string zurl, int *error, const char **addinfo);
-            void search_pqf(const char *pqf, Odr_int *hits,
-                            int *error, const char **addinfo);
-            void search_cql(const char *cql, Odr_int *hits,
-                            int *error, const char **addinfo);
+            void connect(std::string zurl, int *error, char **addinfo,
+                         ODR odr);
+            void search(ZOOM_query q, Odr_int *hits,
+                        int *error, char **addinfo, ODR odr);
             void present(Odr_int start, Odr_int number, ZOOM_record *recs,
-                         int *error, const char **addinfo);
+                         int *error, char **addinfo, ODR odr);
             void set_option(const char *name, const char *value);
+            void set_option(const char *name, std::string value);
             const char *get_option(const char *name);
-            void get_zoom_error(int *error, const char **addinfo);
+            void get_zoom_error(int *error, char **addinfo, ODR odr);
         };
         class Zoom::Frontend : boost::noncopyable {
             friend class Impl;
@@ -101,14 +116,24 @@ namespace metaproxy_1 {
             void handle_package(mp::Package &package);
             void handle_search(mp::Package &package);
             void handle_present(mp::Package &package);
-            BackendPtr get_backend_from_databases(std::string &database,
+            BackendPtr get_backend_from_databases(mp::Package &package,
+                                                  std::string &database,
                                                   int *error,
                                                   char **addinfo,
                                                   ODR odr);
+
+
+            void prepare_elements(BackendPtr b,
+                                  Odr_oid *preferredRecordSyntax,
+                                  const char *element_set_name,
+                                  bool &enable_pz2_retrieval,
+                                  bool &enable_pz2_transform,
+                                  bool &assume_marc8_charset);
+
             Z_Records *get_records(Odr_int start,
                                    Odr_int number_to_present,
                                    int *error,
-                                   const char **addinfo,
+                                   char **addinfo,
                                    Odr_int *number_of_records_returned,
                                    ODR odr, BackendPtr b,
                                    Odr_oid *preferredRecordSyntax,
@@ -123,7 +148,8 @@ namespace metaproxy_1 {
             Impl();
             ~Impl();
             void process(metaproxy_1::Package & package);
-            void configure(const xmlNode * ptr, bool test_only);
+            void configure(const xmlNode * ptr, bool test_only,
+                           const char *path);
         private:
             void configure_local_records(const xmlNode * ptr, bool test_only);
             FrontendPtr get_frontend(mp::Package &package);
@@ -134,11 +160,17 @@ namespace metaproxy_1 {
             boost::mutex m_mutex;
             boost::condition m_cond_session_ready;
             std::string torus_url;
+            std::string default_realm;
             std::map<std::string,std::string> fieldmap;
             std::string xsldir;
+            std::string file_path;
+            std::string content_proxy_server;
+            std::string content_tmp_file;
+            bool apdu_log;
             CCL_bibset bibset;
             std::string element_transform;
             std::string element_raw;
+            std::string proxy;
             std::map<std::string,SearchablePtr> s_map;
         };
     }
@@ -154,9 +186,10 @@ yf::Zoom::~Zoom()
 {  // must have a destructor because of boost::scoped_ptr
 }
 
-void yf::Zoom::configure(const xmlNode *xmlnode, bool test_only)
+void yf::Zoom::configure(const xmlNode *xmlnode, bool test_only,
+                         const char *path)
 {
-    m_p->configure(xmlnode, test_only);
+    m_p->configure(xmlnode, test_only, path);
 }
 
 void yf::Zoom::process(mp::Package &package) const
@@ -169,7 +202,9 @@ void yf::Zoom::process(mp::Package &package) const
 
 yf::Zoom::Backend::Backend(SearchablePtr ptr) : sptr(ptr)
 {
+    m_apdu_wrbuf = wrbuf_alloc();
     m_connection = ZOOM_connection_create(0);
+    ZOOM_connection_save_apdu_wrbuf(m_connection, m_apdu_wrbuf);
     m_resultset = 0;
     xsp = 0;
 }
@@ -183,50 +218,60 @@ yf::Zoom::Backend::~Backend()
 }
 
 
-void yf::Zoom::Backend::get_zoom_error(int *error, const char **addinfo)
+void yf::Zoom::Backend::get_zoom_error(int *error, char **addinfo,
+                                       ODR odr)
 {
     const char *msg = 0;
-    *error = ZOOM_connection_error(m_connection, &msg, addinfo);
+    const char *zoom_addinfo = 0;
+    const char *dset = 0;
+    *error = ZOOM_connection_error_x(m_connection, &msg, &zoom_addinfo, &dset);
     if (*error)
     {
         if (*error >= ZOOM_ERROR_CONNECT)
         {
             // turn ZOOM diagnostic into a Bib-1 2: with addinfo=zoom err msg
             *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
-            if (addinfo)
-                *addinfo = msg;
+            *addinfo = (char *) odr_malloc(
+                odr, 20 + strlen(msg) + 
+                (zoom_addinfo ? strlen(zoom_addinfo) : 0));
+            strcpy(*addinfo, msg);
+            if (zoom_addinfo)
+            {
+                strcat(*addinfo, ": ");
+                strcat(*addinfo, zoom_addinfo);
+                strcat(*addinfo, " ");
+            }
+        }
+        else
+        {
+            if (dset && !strcmp(dset, "info:srw/diagnostic/1"))
+                *error = yaz_diag_srw_to_bib1(*error);
+            *addinfo = (char *) odr_malloc(
+                odr, 20 + (zoom_addinfo ? strlen(zoom_addinfo) : 0));
+            **addinfo = '\0';
+            if (zoom_addinfo && *zoom_addinfo)
+            {
+                strcpy(*addinfo, zoom_addinfo);
+                strcat(*addinfo, " ");
+            }
+            strcat(*addinfo, "(backend)");
         }
     }
 }
 
 void yf::Zoom::Backend::connect(std::string zurl,
-                                int *error, const char **addinfo)
+                                int *error, char **addinfo,
+                                ODR odr)
 {
     ZOOM_connection_connect(m_connection, zurl.c_str(), 0);
-    get_zoom_error(error, addinfo);
+    get_zoom_error(error, addinfo, odr);
 }
 
-void yf::Zoom::Backend::search_pqf(const char *pqf, Odr_int *hits,
-                                   int *error, const char **addinfo)
+void yf::Zoom::Backend::search(ZOOM_query q, Odr_int *hits,
+                               int *error, char **addinfo, ODR odr)
 {
-    m_resultset = ZOOM_connection_search_pqf(m_connection, pqf);
-    get_zoom_error(error, addinfo);
-    if (*error == 0)
-        *hits = ZOOM_resultset_size(m_resultset);
-    else
-        *hits = 0;
-}
-
-void yf::Zoom::Backend::search_cql(const char *cql, Odr_int *hits,
-                                   int *error, const char **addinfo)
-{
-    ZOOM_query q = ZOOM_query_create();
-
-    ZOOM_query_cql(q, cql);
-
     m_resultset = ZOOM_connection_search(m_connection, q);
-    ZOOM_query_destroy(q);
-    get_zoom_error(error, addinfo);
+    get_zoom_error(error, addinfo, odr);
     if (*error == 0)
         *hits = ZOOM_resultset_size(m_resultset);
     else
@@ -235,10 +280,10 @@ void yf::Zoom::Backend::search_cql(const char *cql, Odr_int *hits,
 
 void yf::Zoom::Backend::present(Odr_int start, Odr_int number,
                                 ZOOM_record *recs,
-                                int *error, const char **addinfo)
+                                int *error, char **addinfo, ODR odr)
 {
     ZOOM_resultset_records(m_resultset, recs, start, number);
-    get_zoom_error(error, addinfo);
+    get_zoom_error(error, addinfo, odr);
 }
 
 void yf::Zoom::Backend::set_option(const char *name, const char *value)
@@ -248,6 +293,11 @@ void yf::Zoom::Backend::set_option(const char *name, const char *value)
         ZOOM_resultset_option_set(m_resultset, name, value);
 }
 
+void yf::Zoom::Backend::set_option(const char *name, std::string value)
+{
+    set_option(name, value.c_str());
+}
+
 const char *yf::Zoom::Backend::get_option(const char *name)
 {
     return ZOOM_connection_option_get(m_connection, name);
@@ -257,6 +307,7 @@ yf::Zoom::Searchable::Searchable(CCL_bibset base)
 {
     piggyback = true;
     use_turbomarc = true;
+    sortStrategy = "embed";
     ccl_bibset = ccl_qual_dup(base);
 }
 
@@ -319,9 +370,12 @@ void yf::Zoom::Impl::release_frontend(mp::Package &package)
     }
 }
 
-yf::Zoom::Impl::Impl() : element_transform("pz2") , element_raw("raw")
+yf::Zoom::Impl::Impl() :
+    apdu_log(false), element_transform("pz2") , element_raw("raw")
 {
     bibset = ccl_qual_mk();
+
+    srand((unsigned int) time(0));
 }
 
 yf::Zoom::Impl::~Impl()
@@ -355,9 +409,14 @@ yf::Zoom::SearchablePtr yf::Zoom::Impl::parse_torus_record(const xmlNode *ptr)
             s->cfProxy = mp::xml::get_text(ptr);
         }  
         else if (!strcmp((const char *) ptr->name,
-                         "cfSubDb"))
+                         "cfSubDB"))
+        {
+            s->cfSubDB = mp::xml::get_text(ptr);
+        }  
+        else if (!strcmp((const char *) ptr->name,
+                         "contentConnector"))
         {
-            s->cfSubDb = mp::xml::get_text(ptr);
+            s->contentConnector = mp::xml::get_text(ptr);
         }  
         else if (!strcmp((const char *) ptr->name, "udb"))
         {
@@ -371,6 +430,10 @@ yf::Zoom::SearchablePtr yf::Zoom::Impl::parse_torus_record(const xmlNode *ptr)
         {
             s->sru = mp::xml::get_text(ptr);
         }
+        else if (!strcmp((const char *) ptr->name, "SRUVersion"))
+        {
+            s->sru_version = mp::xml::get_text(ptr);
+        }
         else if (!strcmp((const char *) ptr->name,
                          "queryEncoding"))
         {
@@ -402,6 +465,11 @@ yf::Zoom::SearchablePtr yf::Zoom::Impl::parse_torus_record(const xmlNode *ptr)
             s->transform_xsl_fname = mp::xml::get_text(ptr);
         }
         else if (!strcmp((const char *) ptr->name,
+                         "literalTransform"))
+        {
+            s->transform_xsl_content = mp::xml::get_text(ptr);
+        }
+        else if (!strcmp((const char *) ptr->name,
                          "urlRecipe"))
         {
             s->urlRecipe = mp::xml::get_text(ptr);
@@ -418,6 +486,17 @@ yf::Zoom::SearchablePtr yf::Zoom::Impl::parse_torus_record(const xmlNode *ptr)
             ccl_qual_fitem(s->ccl_bibset, value.c_str(),
                            (const char *) ptr->name + 7);
         }
+        else if (!strncmp((const char *) ptr->name,
+                          "sortmap_", 8))
+        {
+            std::string value = mp::xml::get_text(ptr);
+            s->sortmap[(const char *) ptr->name + 8] = value;
+        }
+        else if (!strcmp((const char *) ptr->name,
+                          "sortStrategy"))
+        {
+            s->sortStrategy = mp::xml::get_text(ptr);
+        }
     }
     return s;
 }
@@ -470,8 +549,14 @@ void yf::Zoom::Impl::configure_local_records(const xmlNode *ptr, bool test_only)
     }
 }
 
-void yf::Zoom::Impl::configure(const xmlNode *ptr, bool test_only)
+void yf::Zoom::Impl::configure(const xmlNode *ptr, bool test_only,
+                               const char *path)
 {
+    content_tmp_file = "/tmp/cf.XXXXXX.p";
+    if (path && *path)
+    {
+        file_path = path;
+    }
     for (ptr = ptr->children; ptr; ptr = ptr->next)
     {
         if (ptr->type != XML_ELEMENT_NODE)
@@ -483,12 +568,16 @@ void yf::Zoom::Impl::configure(const xmlNode *ptr, bool test_only)
             {
                 if (!strcmp((const char *) attr->name, "url"))
                     torus_url = mp::xml::get_text(attr->children);
+                else if (!strcmp((const char *) attr->name, "realm"))
+                    default_realm = mp::xml::get_text(attr->children);
                 else if (!strcmp((const char *) attr->name, "xsldir"))
                     xsldir = mp::xml::get_text(attr->children);
                 else if (!strcmp((const char *) attr->name, "element_transform"))
                     element_transform = mp::xml::get_text(attr->children);
                 else if (!strcmp((const char *) attr->name, "element_raw"))
                     element_raw = mp::xml::get_text(attr->children);
+                else if (!strcmp((const char *) attr->name, "proxy"))
+                    proxy = mp::xml::get_text(attr->children);
                 else
                     throw mp::filter::FilterException(
                         "Bad attribute " + std::string((const char *)
@@ -520,6 +609,34 @@ void yf::Zoom::Impl::configure(const xmlNode *ptr, bool test_only)
             if (cql_field.length())
                 fieldmap[cql_field] = ccl_field;
         }
+        else if (!strcmp((const char *) ptr->name, "contentProxy"))
+        {
+            const struct _xmlAttr *attr;
+            for (attr = ptr->properties; attr; attr = attr->next)
+            {
+                if (!strcmp((const char *) attr->name, "server"))
+                    content_proxy_server = mp::xml::get_text(attr->children);
+                else if (!strcmp((const char *) attr->name, "tmp_file"))
+                    content_tmp_file = mp::xml::get_text(attr->children);
+                else
+                    throw mp::filter::FilterException(
+                        "Bad attribute " + std::string((const char *)
+                                                       attr->name));
+            }
+        }
+        else if (!strcmp((const char *) ptr->name, "log"))
+        { 
+            const struct _xmlAttr *attr;
+            for (attr = ptr->properties; attr; attr = attr->next)
+            {
+                if (!strcmp((const char *) attr->name, "apdu"))
+                    apdu_log = mp::xml::get_bool(attr->children, false);
+                else
+                    throw mp::filter::FilterException(
+                        "Bad attribute " + std::string((const char *)
+                                                       attr->name));
+            }
+        }
         else
         {
             throw mp::filter::FilterException
@@ -531,33 +648,95 @@ void yf::Zoom::Impl::configure(const xmlNode *ptr, bool test_only)
 }
 
 yf::Zoom::BackendPtr yf::Zoom::Frontend::get_backend_from_databases(
+    mp::Package &package,
     std::string &database, int *error, char **addinfo, ODR odr)
 {
     std::list<BackendPtr>::const_iterator map_it;
     if (m_backend && m_backend->m_frontend_database == database)
         return m_backend;
 
-    const char *sru_proxy = 0;
-    std::string db_args;
+    std::string input_args;
     std::string torus_db;
     size_t db_arg_pos = database.find(',');
     if (db_arg_pos != std::string::npos)
     {
         torus_db = database.substr(0, db_arg_pos);
-        db_args = database.substr(db_arg_pos + 1);
+        input_args = database.substr(db_arg_pos + 1);
     }
     else
         torus_db = database;
+
+    std::string authentication;
+    std::string proxy;
+    std::string realm = m_p->default_realm;
+
+    const char *param_user = 0;
+    const char *param_password = 0;
+    int no_parms = 0;
+
+    char **names;
+    char **values;
+    int no_out_args = 0;
+    if (input_args.length())
+        no_parms = yaz_uri_to_array(input_args.c_str(),
+                                    odr, &names, &values);
+    // adding 10 because we'll be adding other URL args
+    const char **out_names = (const char **)
+        odr_malloc(odr, (10 + no_parms) * sizeof(*out_names));
+    const char **out_values = (const char **)
+        odr_malloc(odr, (10 + no_parms) * sizeof(*out_values));
+    
+    int i;
+    for (i = 0; i < no_parms; i++)
+    {
+        const char *name = names[i];
+        const char *value = values[i];
+        assert(name);
+        assert(value);
+        if (!strcmp(name, "user"))
+            param_user = value;
+        else if (!strcmp(name, "password"))
+            param_password = value;
+        else if (!strcmp(name, "proxy"))
+            proxy = value;
+        else if (!strcmp(name, "cproxysession"))
+        {
+            out_names[no_out_args] = name;
+            out_values[no_out_args++] = value;
+        }
+        else if (!strcmp(name, "realm"))
+            realm = value;
+        else if (name[0] == 'x' && name[1] == '-')
+        {
+            out_names[no_out_args] = name;
+            out_values[no_out_args++] = value;
+        }
+        else
+        {
+            BackendPtr notfound;
+            char *msg = (char*) odr_malloc(odr, strlen(name) + 30);
+            *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
+            sprintf(msg, "Bad database argument: %s", name);
+            *addinfo = msg;
+            return notfound;
+        }
+    }
+    if (param_user)
+    {
+        authentication = std::string(param_user);
+        if (param_password)
+            authentication += "/" + std::string(param_password);
+    }
     SearchablePtr sptr;
 
     std::map<std::string,SearchablePtr>::iterator it;
     it = m_p->s_map.find(torus_db);
     if (it != m_p->s_map.end())
         sptr = it->second;
-    else
+    else if (m_p->torus_url.length() > 0)
     {
-        xmlDoc *doc = mp::get_searchable(m_p->torus_url, torus_db);
+        xmlDoc *doc = mp::get_searchable(m_p->torus_url, torus_db, realm,
+                                         m_p->proxy);
         if (!doc)
         {
             *error = YAZ_BIB1_DATABASE_DOES_NOT_EXIST;
@@ -574,8 +753,17 @@ yf::Zoom::BackendPtr yf::Zoom::Frontend::get_backend_from_databases(
                 if (ptr->type == XML_ELEMENT_NODE
                     && !strcmp((const char *) ptr->name, "record"))
                 {
+                    if (sptr)
+                    {
+                        *error = YAZ_BIB1_UNSPECIFIED_ERROR;
+                        *addinfo = (char*) odr_malloc(odr, 40 + database.length()),
+                        sprintf(*addinfo, "multiple records for udb=%s",
+                                 database.c_str());
+                        xmlFreeDoc(doc);
+                        BackendPtr b;
+                        return b;
+                    }
                     sptr = m_p->parse_torus_record(ptr);
-                    break;
                 }
             }
         }
@@ -591,20 +779,59 @@ yf::Zoom::BackendPtr yf::Zoom::Frontend::get_backend_from_databases(
     }
         
     xsltStylesheetPtr xsp = 0;
-    if (sptr->transform_xsl_fname.length())
+    if (sptr->transform_xsl_content.length())
+    {
+        xmlDoc *xsp_doc = xmlParseMemory(sptr->transform_xsl_content.c_str(),
+                                         sptr->transform_xsl_content.length());
+        if (!xsp_doc)
+        {
+            *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
+            *addinfo = (char *) odr_malloc(odr, 40);
+            sprintf(*addinfo, "xmlParseMemory failed");
+            BackendPtr b;
+            return b;
+        }
+        xsp = xsltParseStylesheetDoc(xsp_doc);
+        if (!xsp)
+        {
+            *error = YAZ_BIB1_DATABASE_DOES_NOT_EXIST;
+            *addinfo = odr_strdup(odr, "xsltParseStylesheetDoc failed");
+            BackendPtr b;
+            xmlFreeDoc(xsp_doc);
+            return b;
+        }
+    }
+    else if (sptr->transform_xsl_fname.length())
     {
+        const char *path = 0;
+
+        if (m_p->xsldir.length())
+            path = m_p->xsldir.c_str();
+        else
+            path = m_p->file_path.c_str();
         std::string fname;
 
-        if (m_p->xsldir.length()) 
-            fname = m_p->xsldir + "/" + sptr->transform_xsl_fname;
+        char fullpath[1024];
+        char *cp = yaz_filepath_resolve(sptr->transform_xsl_fname.c_str(),
+                                        path, 0, fullpath);
+        if (cp)
+            fname.assign(cp);
         else
-            fname = sptr->transform_xsl_fname;
+        {
+            *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
+            *addinfo = (char *)
+                odr_malloc(odr, 40 + sptr->transform_xsl_fname.length());
+            sprintf(*addinfo, "File could not be read: %s", 
+                    sptr->transform_xsl_fname.c_str());
+            BackendPtr b;
+            return b;
+        }
         xmlDoc *xsp_doc = xmlParseFile(fname.c_str());
         if (!xsp_doc)
         {
             *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
-            *addinfo = (char *) odr_malloc(odr, 40 + strlen(fname.c_str()));
-            sprintf(*addinfo, "xmlParseFile failed. File %s", fname.c_str());
+            *addinfo = (char *) odr_malloc(odr, 40 + fname.length());
+            sprintf(*addinfo, "xmlParseFile failed. File: %s", fname.c_str());
             BackendPtr b;
             return b;
         }
@@ -625,119 +852,142 @@ yf::Zoom::BackendPtr yf::Zoom::Frontend::get_backend_from_databases(
 
     b->xsp = xsp;
     b->m_frontend_database = database;
-    std::string authentication = sptr->authentication;
-        
-    b->set_option("timeout", "40");
 
     if (sptr->query_encoding.length())
-        b->set_option("rpnCharset", sptr->query_encoding.c_str());
+        b->set_option("rpnCharset", sptr->query_encoding);
+
+    b->set_option("timeout", "40");
+    
+    if (m_p->apdu_log) 
+        b->set_option("apdulog", "1");
+
+    if (sptr->piggyback)
+        b->set_option("count", "1"); /* some SRU servers INSIST on getting
+                                        maximumRecords > 0 */
+    b->set_option("piggyback", sptr->piggyback ? "1" : "0");
+
+    if (authentication.length() == 0)
+        authentication = sptr->authentication;
 
+    if (proxy.length() == 0)
+        proxy = sptr->cfProxy;
+    
     if (sptr->cfAuth.length())
     {
         // A CF target
-        b->set_option("user", sptr->cfAuth.c_str());
-        if (db_args.length() == 0)
+        b->set_option("user", sptr->cfAuth);
+        if (authentication.length())
         {
-            if (authentication.length())
+            size_t found = authentication.find('/');
+            if (found != std::string::npos)
             {
-                // no database (auth) args specified already.. and the
-                // Torus authentication has it.. Generate the args that CF
-                // understands..
-                size_t found = authentication.find('/');
-                if (found != std::string::npos)
-                {
-                    db_args += "user=" + mp::util::uri_encode(authentication.substr(0, found))
-                        + "&password=" + mp::util::uri_encode(authentication.substr(found+1));
-                }
-                else
-                    db_args += "user=" + mp::util::uri_encode(authentication);
+                out_names[no_out_args] = "user";
+                out_values[no_out_args++] =
+                    odr_strdup(odr, authentication.substr(0, found).c_str());
+
+                out_names[no_out_args] = "password";
+                out_values[no_out_args++] =
+                    odr_strdup(odr, authentication.substr(found+1).c_str());
             }
-            if (sptr->cfProxy.length())
+            else
             {
-                if (db_args.length())
-                    db_args += "&";
-                db_args += "proxy=" + mp::util::uri_encode(sptr->cfProxy);
-            }
+                out_names[no_out_args] = "user";
+                out_values[no_out_args++] =
+                    odr_strdup(odr, authentication.c_str());
+            }                
         }
-        if (sptr->cfSubDb.length())
+        if (proxy.length())
         {
-            if (db_args.length())
-                db_args += "&";
-            db_args += "subdatabase=" + mp::util::uri_encode(sptr->cfSubDb);
+            out_names[no_out_args] = "proxy";
+            out_values[no_out_args++] = odr_strdup(odr, proxy.c_str());
+        }
+        if (sptr->cfSubDB.length())
+        {
+            out_names[no_out_args] = "subdatabase";
+            out_values[no_out_args++] = odr_strdup(odr, sptr->cfSubDB.c_str());
         }
     }
     else
     {
-        // A non-CF target
-        if (db_args.length())
-        {
-            // user has specified backend authentication
-            const char *param_user = 0;
-            const char *param_password = 0;
-            char **names;
-            char **values;
-            int i;
-            int no_parms = yaz_uri_to_array(db_args.c_str(),
-                                            odr, &names, &values);
-            for (i = 0; i < no_parms; i++)
-            {
-                const char *name = names[i];
-                const char *value = values[i];
-                if (!strcmp(name, "user"))
-                    param_user = value;
-                else if (!strcmp(name, "password"))
-                    param_password = value;
-                else if (!strcmp(name, "proxy"))
-                    sru_proxy = value;
-                else
-                {
-                    BackendPtr notfound;
-                    char *msg = (char*) odr_malloc(odr, strlen(name) + 30);
-                    *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
-                    sprintf(msg, "Bad database argument: %s", name);
-                    *addinfo = msg;
-                    return notfound;
-                }
-            }
-            if (param_user && param_password)
-            {
-                char *auth = (char*) odr_malloc(
-                    odr, strlen(param_user) + strlen(param_password) + 2);
-                strcpy(auth, param_user);
-                strcat(auth, "/");
-                strcat(auth, param_password);
-                b->set_option("user", auth);
-            }
-            db_args.clear(); // no arguments to be passed (non-CF)
+        size_t found = authentication.find('/');
+        
+        if (sptr->sru.length() && found != std::string::npos)
+        {
+            b->set_option("user", authentication.substr(0, found));
+            b->set_option("password", authentication.substr(found+1));
         }
         else
+            b->set_option("user", authentication);
+
+        if (proxy.length())
+            b->set_option("proxy", proxy);
+    }
+    if (b->sptr->contentConnector.length())
+    {
+        char *fname = (char *) xmalloc(m_p->content_tmp_file.length() + 8);
+        strcpy(fname, m_p->content_tmp_file.c_str());
+        char *xx = strstr(fname, "XXXXXX");
+        if (!xx)
         {
-            // use authentication from Torus, if given
-            if (authentication.length())
-                b->set_option("user", authentication.c_str());
+            xx = fname + strlen(fname);
+            strcat(fname, "XXXXXX");
         }
-    }
+        char tmp_char = xx[6];
+        sprintf(xx, "%06d", ((unsigned) rand()) % 1000000);
+        xx[6] = tmp_char;
 
-    if (sru_proxy)
-        b->set_option("proxy", sru_proxy);
+        FILE *file = fopen(fname, "w");
+        if (!file)
+        {
+            package.log("zoom", YLOG_WARN|YLOG_ERRNO, "create %s", fname);
+            *error = YAZ_BIB1_TEMPORARY_SYSTEM_ERROR;
+            *addinfo = (char *)  odr_malloc(odr, 40 + strlen(fname));
+            sprintf(*addinfo, "Could not create %s", fname);
+            xfree(fname);
+            BackendPtr backend_null;
+            return backend_null;
+        }
+        b->content_session_id.assign(xx, 6);
+        WRBUF w = wrbuf_alloc();
+        wrbuf_puts(w, "#content_proxy\n");
+        wrbuf_printf(w, "connector: %s\n", b->sptr->contentConnector.c_str());
+        if (authentication.length())
+            wrbuf_printf(w, "auth: %s\n", authentication.c_str());
+        if (proxy.length())
+            wrbuf_printf(w, "proxy: %s\n", proxy.c_str());
+        if (sptr->cfProxy.length())
+            wrbuf_printf(w, "cfproxy: %s\n", sptr->cfProxy.c_str());
+
+        fwrite(wrbuf_buf(w), 1, wrbuf_len(w), file);
+        fclose(file);
+        package.log("zoom", YLOG_LOG, "file %s created", fname);
+        xfree(fname);
+    }
 
     std::string url;
     if (sptr->sru.length())
     {
         url = "http://" + sptr->target;
-        b->set_option("sru", sptr->sru.c_str());
+        b->set_option("sru", sptr->sru);
+
+        if (sptr->sru_version.length())
+            b->set_option("sru_version", sptr->sru_version);
     }
     else
     {
         url = sptr->target;
     }
-    if (db_args.length())
-        url += "," + db_args;
-    yaz_log(YLOG_LOG, "url=%s", url.c_str());
-    const char *addinfo_c = 0;
-    b->connect(url, error, &addinfo_c);
-    if (addinfo_c)
-        *addinfo = odr_strdup(odr, addinfo_c);
+    if (no_out_args)
+    {
+        char *x_args = 0;
+        out_names[no_out_args] = 0; // terminate list
+        
+        yaz_array_to_uri(&x_args, odr, (char **) out_names,
+                         (char **) out_values);
+        url += "," + std::string(x_args);
+    }
+    package.log("zoom", YLOG_LOG, "url: %s", url.c_str());
+    b->connect(url, error, addinfo, odr);
     if (*error == 0)
     {
         m_backend = b;
@@ -745,31 +995,14 @@ yf::Zoom::BackendPtr yf::Zoom::Frontend::get_backend_from_databases(
     return b;
 }
 
-Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
-                                           Odr_int number_to_present,
-                                           int *error,
-                                           const char **addinfo,
-                                           Odr_int *number_of_records_returned,
-                                           ODR odr,
-                                           BackendPtr b,
-                                           Odr_oid *preferredRecordSyntax,
-                                           const char *element_set_name)
-{
-    *number_of_records_returned = 0;
-    Z_Records *records = 0;
-    bool enable_pz2_retrieval = false; // whether target profile is used
-    bool enable_pz2_transform = false; // whether XSLT is used as well
-    bool assume_marc8_charset = false;
-
-    if (start < 0 || number_to_present <= 0)
-        return records;
-    
-    if (number_to_present > 10000)
-        number_to_present = 10000;
-    
-    ZOOM_record *recs = (ZOOM_record *)
-        odr_malloc(odr, number_to_present * sizeof(*recs));
+void yf::Zoom::Frontend::prepare_elements(BackendPtr b,
+                                          Odr_oid *preferredRecordSyntax,
+                                          const char *element_set_name,
+                                          bool &enable_pz2_retrieval,
+                                          bool &enable_pz2_transform,
+                                          bool &assume_marc8_charset)
 
+{
     char oid_name_str[OID_STR_MAX];
     const char *syntax_name = 0;
     
@@ -790,9 +1023,10 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
     
     if (enable_pz2_retrieval)
     {
-        if (b->sptr->request_syntax.length())
+        std::string configured_request_syntax = b->sptr->request_syntax;
+        if (configured_request_syntax.length())
         {
-            syntax_name = b->sptr->request_syntax.c_str();
+            syntax_name = configured_request_syntax.c_str();
             const Odr_oid *syntax_oid = 
                 yaz_string_to_oid(yaz_oid_std(), CLASS_RECSYN, syntax_name);
             if (!oid_oidcmp(syntax_oid, yaz_oid_recsyn_usmarc)
@@ -804,6 +1038,9 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
         syntax_name =
             yaz_oid_to_string_buf(preferredRecordSyntax, 0, oid_name_str);
 
+    if (b->sptr->sru.length())
+        syntax_name = "XML";
+
     b->set_option("preferredRecordSyntax", syntax_name);
 
     if (enable_pz2_retrieval)
@@ -814,10 +1051,44 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
     }
 
     b->set_option("elementSetName", element_set_name);
+    if (b->sptr->sru.length() && element_set_name)
+        b->set_option("schema", element_set_name);
+}
+
+Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
+                                           Odr_int number_to_present,
+                                           int *error,
+                                           char **addinfo,
+                                           Odr_int *number_of_records_returned,
+                                           ODR odr,
+                                           BackendPtr b,
+                                           Odr_oid *preferredRecordSyntax,
+                                           const char *element_set_name)
+{
+    *number_of_records_returned = 0;
+    Z_Records *records = 0;
+    bool enable_pz2_retrieval = false; // whether target profile is used
+    bool enable_pz2_transform = false; // whether XSLT is used as well
+    bool assume_marc8_charset = false;
 
-    b->present(start, number_to_present, recs, error, addinfo);
+    prepare_elements(b, preferredRecordSyntax,
+                     element_set_name,
+                     enable_pz2_retrieval,
+                     enable_pz2_transform,
+                     assume_marc8_charset);
 
-    Odr_int i = 0;
+    if (start < 0 || number_to_present <=0)
+        return records;
+    
+    if (number_to_present > 10000)
+        number_to_present = 10000;
+
+    ZOOM_record *recs = (ZOOM_record *)
+        odr_malloc(odr, (size_t) number_to_present * sizeof(*recs));
+
+    b->present(start, number_to_present, recs, error, addinfo, odr);
+
+    int i = 0;
     if (!*error)
     {
         for (i = 0; i < number_to_present; i++)
@@ -867,20 +1138,52 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
                 xmlChar *xmlrec_buf = 0;
                 const char *rec_buf = ZOOM_record_get(recs[i], rec_type_str,
                                                       &rec_len);
+                if (!rec_buf && !npr)
+                {
+                    std::string addinfo("ZOOM_record_get failed for type ");
+
+                    addinfo += rec_type_str;
+                    npr = zget_surrogateDiagRec(
+                        odr, odr_database, 
+                        YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
+                        addinfo.c_str());
+                }
+
                 if (rec_buf && b->xsp && enable_pz2_transform)
                 {
                     xmlDoc *rec_doc = xmlParseMemory(rec_buf, rec_len);
-                    if (rec_doc)
+                    if (!rec_doc)
+                    {
+                        npr = zget_surrogateDiagRec(
+                            odr, odr_database, 
+                            YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
+                            "xml parse failed for record");
+                    }
+                    else
                     { 
-                        xmlDoc *rec_res;
-                        rec_res = xsltApplyStylesheet(b->xsp, rec_doc, 0);
+                        xmlDoc *rec_res = 
+                            xsltApplyStylesheet(b->xsp, rec_doc, 0);
 
                         if (rec_res)
+                        {
                             xsltSaveResultToString(&xmlrec_buf, &rec_len,
                                                    rec_res, b->xsp);
-                        rec_buf = (const char *) xmlrec_buf;
+                            rec_buf = (const char *) xmlrec_buf;
+
+                            xmlFreeDoc(rec_res);
+                        }
+                        if (!rec_buf)
+                        {
+                            std::string addinfo;
+
+                            addinfo = "xslt apply failed for "
+                                + b->sptr->transform_xsl_fname;
+                            npr = zget_surrogateDiagRec(
+                                odr, odr_database, 
+                                YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
+                                addinfo.c_str());
+                        }
                         xmlFreeDoc(rec_doc);
-                        xmlFreeDoc(rec_res);
                     }
                 }
 
@@ -889,13 +1192,27 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
                     xmlDoc *doc = xmlParseMemory(rec_buf, rec_len);
                     std::string res = 
                         mp::xml::url_recipe_handle(doc, b->sptr->urlRecipe);
+                    if (res.length() && b->content_session_id.length())
+                    {
+                        size_t off = res.find_first_of("://");
+                        if (off != std::string::npos)
+                        {
+                            char tmp[1024];
+                            sprintf(tmp, "%s.%s/",
+                                    b->content_session_id.c_str(),
+                                    m_p->content_proxy_server.c_str());
+                            res.insert(off + 3, tmp);
+                        }
+                    }
                     if (res.length())
                     {
                         xmlNode *ptr = xmlDocGetRootElement(doc);
                         while (ptr && ptr->type != XML_ELEMENT_NODE)
                             ptr = ptr->next;
                         xmlNode *c = 
-                            xmlNewChild(ptr, 0, BAD_CAST "generated-url", 0);
+                            xmlNewChild(ptr, 0, BAD_CAST "metadata", 0);
+                        xmlNewProp(c, BAD_CAST "type", BAD_CAST
+                                   "generated-url");
                         xmlNode * t = xmlNewText(BAD_CAST res.c_str());
                         xmlAddChild(c, t);
 
@@ -907,20 +1224,22 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
                     }
                     xmlFreeDoc(doc);
                 }
-                if (rec_buf)
+                if (!npr)
                 {
-                    npr = (Z_NamePlusRecord *) odr_malloc(odr, sizeof(*npr));
-                    npr->databaseName = odr_database;
-                    npr->which = Z_NamePlusRecord_databaseRecord;
-                    npr->u.databaseRecord =
-                        z_ext_record_xml(odr, rec_buf, rec_len);
-                }
-                else
-                {
-                    npr = zget_surrogateDiagRec(
-                        odr, odr_database, 
-                        YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
-                        rec_type_str);
+                    if (!rec_buf)
+                        npr = zget_surrogateDiagRec(
+                            odr, odr_database, 
+                            YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
+                            rec_type_str);
+                    else
+                    {
+                        npr = (Z_NamePlusRecord *)
+                            odr_malloc(odr, sizeof(*npr));
+                        npr->databaseName = odr_database;
+                        npr->which = Z_NamePlusRecord_databaseRecord;
+                        npr->u.databaseRecord =
+                            z_ext_record_xml(odr, rec_buf, rec_len);
+                    }
                 }
                 if (xmlrec_buf)
                     xmlFree(xmlrec_buf);
@@ -952,7 +1271,7 @@ Z_Records *yf::Zoom::Frontend::get_records(Odr_int start,
     }
     return records;
 }
-    
+
 struct cql_node *yf::Zoom::Impl::convert_cql_fields(struct cql_node *cn,
                                                     ODR odr)
 {
@@ -1002,25 +1321,33 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
     }
 
     int error = 0;
-    char *addinfo_s = 0;
+    char *addinfo = 0;
     std::string db(sr->databaseNames[0]);
-    BackendPtr b = get_backend_from_databases(db, &error, &addinfo_s, odr);
+    BackendPtr b = get_backend_from_databases(package, db, &error,
+                                              &addinfo, odr);
     if (error)
     {
         apdu_res = 
-            odr.create_searchResponse(
-                apdu_req, error, addinfo_s);
+            odr.create_searchResponse(apdu_req, error, addinfo);
         package.response() = apdu_res;
         return;
     }
 
-    const char *addinfo_c = 0;
     b->set_option("setname", "default");
 
+    bool enable_pz2_retrieval = false;
+    bool enable_pz2_transform = false;
+    bool assume_marc8_charset = false;
+    prepare_elements(b, sr->preferredRecordSyntax, 0 /*element_set_name */,
+                     enable_pz2_retrieval,
+                     enable_pz2_transform,
+                     assume_marc8_charset);
+
     Odr_int hits = 0;
     Z_Query *query = sr->query;
     WRBUF ccl_wrbuf = 0;
     WRBUF pqf_wrbuf = 0;
+    std::string sortkeys;
 
     if (query->which == Z_Query_type_1 || query->which == Z_Query_type_101)
     {
@@ -1042,9 +1369,11 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
         const char *cql = query->u.type_104->u.cql;
         CQL_parser cp = cql_parser_create();
         int r = cql_parser_string(cp, cql);
+        package.log("zoom", YLOG_LOG, "CQL: %s", cql);
         if (r)
         {
             cql_parser_destroy(cp);
+            package.log("zoom", YLOG_WARN, "CQL syntax error");
             apdu_res = 
                 odr.create_searchResponse(apdu_req, 
                                           YAZ_BIB1_MALFORMED_QUERY,
@@ -1057,14 +1386,14 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
         if (cn_error)
         {
             // hopefully we are getting a ptr to a index+relation+term node
-            addinfo_c = 0;
+            addinfo = 0;
             if (cn_error->which == CQL_NODE_ST)
-                addinfo_c = cn_error->u.st.index;
+                addinfo = cn_error->u.st.index;
 
             apdu_res = 
                 odr.create_searchResponse(apdu_req, 
                                           YAZ_BIB1_UNSUPP_USE_ATTRIBUTE,
-                                          addinfo_c);
+                                          addinfo);
             package.response() = apdu_res;
             return;
         }
@@ -1075,6 +1404,48 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
         {
             ccl_wrbuf = wrbuf_alloc();
             wrbuf_puts(ccl_wrbuf, ccl_buf);
+            
+            WRBUF sru_sortkeys_wrbuf = wrbuf_alloc();
+
+            cql_sortby_to_sortkeys(cn, wrbuf_vp_puts, sru_sortkeys_wrbuf);
+            WRBUF sort_spec_wrbuf = wrbuf_alloc();
+            yaz_srw_sortkeys_to_sort_spec(wrbuf_cstr(sru_sortkeys_wrbuf),
+                                          sort_spec_wrbuf);
+            wrbuf_destroy(sru_sortkeys_wrbuf);
+
+            yaz_tok_cfg_t tc = yaz_tok_cfg_create();
+            yaz_tok_parse_t tp =
+                yaz_tok_parse_buf(tc, wrbuf_cstr(sort_spec_wrbuf));
+            yaz_tok_cfg_destroy(tc);
+
+            /* go through sortspec and map fields */
+            int token = yaz_tok_move(tp);
+            while (token != YAZ_TOK_EOF)
+            {
+                if (token == YAZ_TOK_STRING)
+                {
+                    const char *field = yaz_tok_parse_string(tp);
+                    std::map<std::string,std::string>::iterator it;
+                    it = b->sptr->sortmap.find(field);
+                    if (it != b->sptr->sortmap.end())
+                        sortkeys += it->second;
+                    else
+                        sortkeys += field;
+                }
+                sortkeys += " ";
+                token = yaz_tok_move(tp);
+                if (token == YAZ_TOK_STRING)
+                {
+                    sortkeys += yaz_tok_parse_string(tp);
+                }
+                if (token != YAZ_TOK_EOF)
+                {
+                    sortkeys += " ";
+                    token = yaz_tok_move(tp);
+                }
+            }
+            yaz_tok_parse_destroy(tp);
+            wrbuf_destroy(sort_spec_wrbuf);
         }
         cql_parser_destroy(cp);
         if (r)
@@ -1101,7 +1472,7 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
         assert(pqf_wrbuf == 0);
         int cerror, cpos;
         struct ccl_rpn_node *cn;
-        yaz_log(YLOG_LOG, "CCL: %s", wrbuf_cstr(ccl_wrbuf));
+        package.log("zoom", YLOG_LOG, "CCL: %s", wrbuf_cstr(ccl_wrbuf));
         cn = ccl_find_str(b->sptr->ccl_bibset, wrbuf_cstr(ccl_wrbuf),
                           &cerror, &cpos);
         wrbuf_destroy(ccl_wrbuf);
@@ -1128,10 +1499,15 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
         }
         pqf_wrbuf = wrbuf_alloc();
         ccl_pquery(pqf_wrbuf, cn);
+        package.log("zoom", YLOG_LOG, "RPN: %s", wrbuf_cstr(pqf_wrbuf));
         ccl_rpn_delete(cn);
     }
     
     assert(pqf_wrbuf);
+
+    ZOOM_query q = ZOOM_query_create();
+    ZOOM_query_sortby2(q, b->sptr->sortStrategy.c_str(), sortkeys.c_str());
+
     if (b->get_option("sru"))
     {
         int status = 0;
@@ -1157,9 +1533,11 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
         }
         if (status == 0)
         {
-            yaz_log(YLOG_LOG, "search CQL: %s", wrbuf_cstr(wrb));
-            b->search_cql(wrbuf_cstr(wrb), &hits, &error, &addinfo_c);
+            ZOOM_query_cql(q, wrbuf_cstr(wrb));
+            package.log("zoom", YLOG_LOG, "CQL: %s", wrbuf_cstr(wrb));
+            b->search(q, &hits, &error, &addinfo, odr);
         }
+        ZOOM_query_destroy(q);
         
         wrbuf_destroy(wrb);
         wrbuf_destroy(pqf_wrbuf);
@@ -1174,12 +1552,13 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
     }
     else
     {
-        yaz_log(YLOG_LOG, "search PQF: %s", wrbuf_cstr(pqf_wrbuf));
-        b->search_pqf(wrbuf_cstr(pqf_wrbuf), &hits, &error, &addinfo_c);
+        ZOOM_query_prefix(q, wrbuf_cstr(pqf_wrbuf));
+        package.log("zoom", YLOG_LOG, "search PQF: %s", wrbuf_cstr(pqf_wrbuf));
+        b->search(q, &hits, &error, &addinfo, odr);
+        ZOOM_query_destroy(q);
         wrbuf_destroy(pqf_wrbuf);
     }
-    
-    
+
     const char *element_set_name = 0;
     Odr_int number_to_present = 0;
     if (!error)
@@ -1187,10 +1566,10 @@ void yf::Zoom::Frontend::handle_search(mp::Package &package)
     
     Odr_int number_of_records_returned = 0;
     Z_Records *records = get_records(
-        0, number_to_present, &error, &addinfo_c,
+        0, number_to_present, &error, &addinfo,
         &number_of_records_returned, odr, b, sr->preferredRecordSyntax,
         element_set_name);
-    apdu_res = odr.create_searchResponse(apdu_req, error, addinfo_c);
+    apdu_res = odr.create_searchResponse(apdu_req, error, addinfo);
     if (records)
     {
         apdu_res->u.searchResponse->records = records;
@@ -1228,7 +1607,7 @@ void yf::Zoom::Frontend::handle_present(mp::Package &package)
         element_set_name = comp->u.simple->u.generic;
     Odr_int number_of_records_returned = 0;
     int error = 0;
-    const char *addinfo = 0;
+    char *addinfo = 0;
     Z_Records *records = get_records(
         *pr->resultSetStartPoint - 1, *pr->numberOfRecordsRequested,
         &error, &addinfo, &number_of_records_returned, odr, m_backend,
@@ -1252,6 +1631,9 @@ void yf::Zoom::Frontend::handle_package(mp::Package &package)
     else if (gdu->which == Z_GDU_Z3950)
     {
         Z_APDU *apdu_req = gdu->u.z3950;
+
+        if (m_backend)
+            wrbuf_rewind(m_backend->m_apdu_wrbuf);
         if (apdu_req->which == Z_APDU_initRequest)
         {
             mp::odr odr;
@@ -1277,6 +1659,11 @@ void yf::Zoom::Frontend::handle_package(mp::Package &package)
                 "zoom filter cannot handle this APDU");
             package.session().close();
         }
+        if (m_backend)
+        {
+            WRBUF w = m_backend->m_apdu_wrbuf;
+            package.log_write(wrbuf_buf(w), wrbuf_len(w));
+        }
     }
     else
     {