X-Git-Url: http://jsfdemo.indexdata.com/?a=blobdiff_plain;f=src%2Fclient.c;h=02419cebafb5193a591bfc5b112c63f7cb732e43;hb=401d3364f84085a8b665a78aad7864fe5eabe095;hp=bb1fd0c91228bf06dad6d0cf430fee74bbdbd062;hpb=dc9f59ce5f4bedc6cd1cc68e0309b74d241f434d;p=pazpar2-moved-to-github.git

diff --git a/src/client.c b/src/client.c
index bb1fd0c..02419ce 100644
--- a/src/client.c
+++ b/src/client.c
@@ -1,4 +1,4 @@
-/* $Id: client.c,v 1.7 2007-06-06 11:49:48 marc Exp $
+/* $Id: client.c,v 1.25 2007-09-20 09:22:37 adam Exp $
    Copyright (c) 2006-2007, Index Data.
 
 This file is part of Pazpar2.
@@ -45,9 +45,8 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include <yaz/nmem.h>
 #include <yaz/query-charset.h>
 #include <yaz/querytowrbuf.h>
-#if YAZ_VERSIONL >= 0x020163
 #include <yaz/oid_db.h>
-#endif
+#include <yaz/diagbib1.h>
 
 #if HAVE_CONFIG_H
 #include "cconfig.h"
@@ -78,9 +77,20 @@ struct client {
     int requestid;            // ID of current outstanding request
     int diagnostic;
     enum client_state state;
+    struct show_raw *show_raw;
     struct client *next;     // next client in session or next in free list
 };
 
+struct show_raw {
+    int active; // whether this request has been sent to the server
+    int position;
+    char *syntax;
+    char *esn;
+    void (*error_handler)(void *data, const char *addinfo);
+    void (*record_handler)(void *data, const char *buf, size_t sz);
+    void *data;
+};
+
 static const char *client_states[] = {
     "Client_Connecting",
     "Client_Connected",
@@ -91,13 +101,26 @@ static const char *client_states[] = {
     "Client_Error",
     "Client_Failed",
     "Client_Disconnected",
-    "Client_Stopped"
+    "Client_Stopped",
+    "Client_Continue"
 };
 
 static struct client *client_freelist = 0;
 
 static int send_apdu(struct client *c, Z_APDU *a)
 {
+    struct session_database *sdb = client_get_database(c);
+    const char *apdulog = session_setting_oneval(sdb, PZ_APDULOG);
+    if (apdulog && *apdulog && *apdulog != '0')
+    {
+        ODR p = odr_createmem(ODR_PRINT);
+        yaz_log(YLOG_LOG, "send APDU %s", client_get_url(c));
+
+        odr_setprint(p, yaz_log_file());
+        z_APDU(p, &a, 0, 0);
+        odr_setprint(p, stderr);
+        odr_destroy(p);
+    }
     return connection_send_apdu(client_get_connection(c), a);
 }
 
@@ -115,16 +138,74 @@ enum client_state client_get_state(struct client *cl)
 void client_set_state(struct client *cl, enum client_state st)
 {
     cl->state = st;
+    if (cl->session)
+    {
+        int no_active = session_active_clients(cl->session);
+        if (no_active == 0)
+            session_alert_watch(cl->session, SESSION_WATCH_SHOW);
+    }
 }
 
+static void client_show_raw_error(struct client *cl, const char *addinfo);
+
 // Close connection and set state to error
 void client_fatal(struct client *cl)
 {
+    client_show_raw_error(cl, "client connection failure");
     yaz_log(YLOG_WARN, "Fatal error from %s", client_get_url(cl));
     connection_destroy(cl->connection);
-    cl->state = Client_Error;
+    client_set_state(cl, Client_Error);
+}
+
+
+static int diag_to_wrbuf(Z_DiagRec **pp, int num, WRBUF w)
+{
+    int code = 0;
+    int i;
+    for (i = 0; i<num; i++)
+    {
+        Z_DiagRec *p = pp[i];
+        if (i)
+            wrbuf_puts(w, "; ");
+        if (p->which != Z_DiagRec_defaultFormat)
+        {
+            wrbuf_puts(w, "? Not in default format");
+        }
+        else
+        {
+            Z_DefaultDiagFormat *r = p->u.defaultFormat;
+            
+            if (!r->diagnosticSetId)
+                wrbuf_puts(w, "? Missing diagset");
+            else
+            {
+                oid_class oclass;
+                char diag_name_buf[OID_STR_MAX];
+                const char *diag_name = 0;
+                diag_name = yaz_oid_to_string_buf
+                    (r->diagnosticSetId, &oclass, diag_name_buf);
+                wrbuf_puts(w, diag_name);
+            }
+            if (!code)
+                code = *r->condition;
+            wrbuf_printf(w, " %d %s", *r->condition,
+                         diagbib1_str(*r->condition));
+            switch (r->which)
+            {
+            case Z_DefaultDiagFormat_v2Addinfo:
+                wrbuf_printf(w, " -- v2 addinfo '%s'", r->u.v2Addinfo);
+                break;
+            case Z_DefaultDiagFormat_v3Addinfo:
+                wrbuf_printf(w, " -- v3 addinfo '%s'", r->u.v3Addinfo);
+                break;
+            }
+        }
+    }
+    return code;
 }
 
+
+
 struct connection *client_get_connection(struct client *cl)
 {
     return cl->connection;
@@ -150,13 +231,149 @@ void client_set_requestid(struct client *cl, int id)
     cl->requestid = id;
 }
 
+int client_show_raw_begin(struct client *cl, int position,
+                          const char *syntax, const char *esn,
+                          void *data,
+                          void (*error_handler)(void *data, const char *addinfo),
+                          void (*record_handler)(void *data, const char *buf,
+                                                 size_t sz))
+{
+    if (cl->show_raw)
+        return -1;
+    cl->show_raw = xmalloc(sizeof(*cl->show_raw));
+    cl->show_raw->position = position;
+    cl->show_raw->active = 0;
+    cl->show_raw->data = data;
+    cl->show_raw->error_handler = error_handler;
+    cl->show_raw->record_handler = record_handler;
+    if (syntax)
+        cl->show_raw->syntax = xstrdup(syntax);
+    else
+        cl->show_raw->syntax = 0;
+    if (esn)
+        cl->show_raw->esn = xstrdup(esn);
+    else
+        cl->show_raw->esn = 0;
+    
+
+    if (cl->state == Client_Failed)
+    {
+        client_show_raw_error(cl, "client failed");
+    }
+    else if (cl->state == Client_Disconnected)
+    {
+        client_show_raw_error(cl, "client disconnected");
+    }
+    else
+    {
+        client_continue(cl);
+    }
+    return 0;
+}
+
+void client_show_raw_reset(struct client *cl)
+{
+    xfree(cl->show_raw);
+    cl->show_raw = 0;
+}
+
+static void client_show_raw_error(struct client *cl, const char *addinfo)
+{
+    if (cl->show_raw)
+    {
+        cl->show_raw->error_handler(cl->show_raw->data, addinfo);
+        client_show_raw_reset(cl);
+    }
+}
+
+static void client_show_raw_cancel(struct client *cl)
+{
+    if (cl->show_raw)
+    {
+        cl->show_raw->error_handler(cl->show_raw->data, "cancel");
+        client_show_raw_reset(cl);
+    }
+}
+
+static void client_present_syntax(Z_APDU *a, const char *syntax)
+{
+    // empty string for syntax OMITS preferredRecordSyntax (OPTIONAL)
+    if (syntax && *syntax)
+        a->u.presentRequest->preferredRecordSyntax =
+            yaz_string_to_oid_odr(yaz_oid_std(),
+                                  CLASS_RECSYN, syntax,
+                                  global_parameters.odr_out);
+}
+
+static void client_present_elements(Z_APDU *a, const char *elements)
+{
+    if (elements && *elements)  // element set is optional
+    {
+        Z_ElementSetNames *elementSetNames =
+            odr_malloc(global_parameters.odr_out, sizeof(*elementSetNames));
+        Z_RecordComposition *compo = 
+            odr_malloc(global_parameters.odr_out, sizeof(*compo));
+        a->u.presentRequest->recordComposition = compo;
+
+        compo->which = Z_RecordComp_simple;
+        compo->u.simple = elementSetNames;
+
+        elementSetNames->which = Z_ElementSetNames_generic;
+        elementSetNames->u.generic = 
+            odr_strdup(global_parameters.odr_out, elements);
+    }
+}
+
+void client_send_raw_present(struct client *cl)
+{
+    struct session_database *sdb = client_get_database(cl);
+    Z_APDU *a = zget_APDU(global_parameters.odr_out, Z_APDU_presentRequest);
+    int toget = 1;
+    int start = cl->show_raw->position;
+    const char *syntax = 0;
+    const char *elements = 0;
+
+    assert(cl->show_raw);
+
+    yaz_log(YLOG_DEBUG, "%s: trying to present %d record(s) from %d",
+            client_get_url(cl), toget, start);
+
+    a->u.presentRequest->resultSetStartPoint = &start;
+    a->u.presentRequest->numberOfRecordsRequested = &toget;
+
+    if (cl->show_raw->syntax)
+        syntax = cl->show_raw->syntax;
+    else
+        syntax = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
+
+    client_present_syntax(a, syntax);
+    if (cl->show_raw->esn)
+        elements = cl->show_raw->esn;
+    else
+        elements = session_setting_oneval(sdb, PZ_ELEMENTS);
+    client_present_elements(a, elements);
+
+    if (send_apdu(cl, a) >= 0)
+    {
+        cl->show_raw->active = 1;
+	cl->state = Client_Presenting;
+    }
+    else
+    {
+        client_show_raw_error(cl, "send_apdu failed");
+        cl->state = Client_Error;
+    }
+    odr_reset(global_parameters.odr_out);
+}
+
 void client_send_present(struct client *cl)
 {
     struct session_database *sdb = client_get_database(cl);
     Z_APDU *a = zget_APDU(global_parameters.odr_out, Z_APDU_presentRequest);
     int toget;
     int start = cl->records + 1;
-    char *recsyn;
+    const char *syntax = 0;
+    const char *elements = 0;
 
     toget = global_parameters.chunk;
     if (toget > global_parameters.toget - cl->records)
@@ -164,26 +381,17 @@ void client_send_present(struct client *cl)
     if (toget > cl->hits - cl->records)
 	toget = cl->hits - cl->records;
 
-    yaz_log(YLOG_DEBUG, "Trying to present %d records\n", toget);
+    yaz_log(YLOG_DEBUG, "Trying to present %d record(s) from %d",
+            toget, start);
 
     a->u.presentRequest->resultSetStartPoint = &start;
     a->u.presentRequest->numberOfRecordsRequested = &toget;
 
-    a->u.presentRequest->resultSetId = "Default";
+    syntax = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
+    client_present_syntax(a, syntax);
 
-    if ((recsyn = session_setting_oneval(sdb, PZ_REQUESTSYNTAX)))
-    {
-#if YAZ_VERSIONL >= 0x020163
-        a->u.presentRequest->preferredRecordSyntax =
-            yaz_string_to_oid_odr(yaz_oid_std(),
-                                  CLASS_RECSYN, recsyn,
-                                  global_parameters.odr_out);
-#else
-        a->u.presentRequest->preferredRecordSyntax =
-            yaz_str_to_z3950oid(global_parameters.odr_out,
-                                CLASS_RECSYN, recsyn);
-#endif
-    }
+    elements = session_setting_oneval(sdb, PZ_ELEMENTS);
+    client_present_elements(a, elements);
 
     if (send_apdu(cl, a) >= 0)
 	cl->state = Client_Presenting;
@@ -202,13 +410,12 @@ void client_send_search(struct client *cl)
     char **databaselist;
     Z_Query *zquery;
     int ssub = 0, lslb = 100000, mspn = 10;
-    char *recsyn = 0;
-    char *piggyback = 0;
-    char *queryenc = 0;
-    yaz_iconv_t iconv = 0;
+    const char *piggyback = session_setting_oneval(sdb, PZ_PIGGYBACK);
+    const char *queryenc = session_setting_oneval(sdb, PZ_QUERYENCODING);
 
     yaz_log(YLOG_DEBUG, "Sending search to %s", sdb->database->url);
 
+    
     // constructing RPN query
     a->u.searchRequest->query = zquery = odr_malloc(global_parameters.odr_out,
                                                     sizeof(Z_Query));
@@ -217,8 +424,9 @@ void client_send_search(struct client *cl)
                                    client_get_pquery(cl));
 
     // converting to target encoding
-    if ((queryenc = session_setting_oneval(sdb, PZ_QUERYENCODING))){
-        iconv = yaz_iconv_open(queryenc, "UTF-8");
+    if (queryenc && *queryenc)
+    {
+        yaz_iconv_t iconv = yaz_iconv_open(queryenc, "UTF-8");
         if (iconv){
             yaz_query_charset_convert_rpnquery(zquery->u.type_1, 
                                                global_parameters.odr_out, 
@@ -235,26 +443,31 @@ void client_send_search(struct client *cl)
     for (ndb = 0; sdb->database->databases[ndb]; ndb++)
 	databaselist[ndb] = sdb->database->databases[ndb];
 
-    if (!(piggyback = session_setting_oneval(sdb, PZ_PIGGYBACK)) || *piggyback == '1')
+    if (!piggyback || *piggyback == '1')
     {
-        if ((recsyn = session_setting_oneval(sdb, PZ_REQUESTSYNTAX)))
+        const char *elements = session_setting_oneval(sdb, PZ_ELEMENTS);
+        const char *recsyn = session_setting_oneval(sdb, PZ_REQUESTSYNTAX);
+        if (recsyn && *recsyn)
         {
-#if YAZ_VERSIONL >= 0x020163
             a->u.searchRequest->preferredRecordSyntax =
                 yaz_string_to_oid_odr(yaz_oid_std(),
                                       CLASS_RECSYN, recsyn,
                                       global_parameters.odr_out);
-#else
-            a->u.searchRequest->preferredRecordSyntax =
-                yaz_str_to_z3950oid(global_parameters.odr_out,
-                                    CLASS_RECSYN, recsyn);
-#endif
+        }
+        if (elements && *elements)
+        {
+            Z_ElementSetNames *esn =
+                odr_malloc(global_parameters.odr_out, sizeof(*esn));
+            esn->which = Z_ElementSetNames_generic;
+            esn->u.generic = odr_strdup(global_parameters.odr_out, elements);
+
+            a->u.searchRequest->smallSetElementSetNames = esn;
+            a->u.searchRequest->mediumSetElementSetNames = esn;
         }
         a->u.searchRequest->smallSetUpperBound = &ssub;
         a->u.searchRequest->largeSetLowerBound = &lslb;
         a->u.searchRequest->mediumSetPresentNumber = &mspn;
     }
-    a->u.searchRequest->resultSetName = "Default";
     a->u.searchRequest->databaseNames = databaselist;
     a->u.searchRequest->num_databaseNames = ndb;
 
@@ -294,14 +507,56 @@ void client_init_response(struct client *cl, Z_APDU *a)
     yaz_log(YLOG_DEBUG, "Init response %s", cl->database->database->url);
 
     if (*r->result)
-    {
-	cl->state = Client_Idle;
-    }
+	cl->state = Client_Continue;
     else
         cl->state = Client_Failed; // FIXME need to do something to the connection
 }
 
 
+static void ingest_raw_records(struct client *cl, Z_Records *r)
+{
+    Z_NamePlusRecordList *rlist;
+    Z_NamePlusRecord *npr;
+    xmlDoc *doc;
+    xmlChar *buf_out;
+    int len_out;
+    if (r->which != Z_Records_DBOSD)
+    {
+        client_show_raw_error(cl, "non-surrogate diagnostics");
+        return;
+    }
+
+    rlist = r->u.databaseOrSurDiagnostics;
+    if (rlist->num_records != 1 || !rlist->records || !rlist->records[0])
+    {
+        client_show_raw_error(cl, "no records");
+        return;
+    }
+    npr = rlist->records[0];
+    if (npr->which != Z_NamePlusRecord_databaseRecord)
+    {
+        client_show_raw_error(cl, "surrogate diagnostic");
+        return;
+    }
+
+    doc = record_to_xml(client_get_database(cl), npr->u.databaseRecord);
+    if (!doc)
+    {
+        client_show_raw_error(cl, "unable to convert record to xml");
+        return;
+    }
+
+    xmlDocDumpMemory(doc, &buf_out, &len_out);
+    xmlFreeDoc(doc);
+
+    cl->show_raw->record_handler(cl->show_raw->data,
+                                 (const char *) buf_out, len_out);
+    
+    xmlFree(buf_out);
+    xfree(cl->show_raw);
+    cl->show_raw = 0;
+}
+
 static void ingest_records(struct client *cl, Z_Records *r)
 {
 #if USE_TIMING
@@ -333,7 +588,9 @@ static void ingest_records(struct client *cl, Z_Records *r)
             continue;
     }
     if (rlist->num_records)
-        session_alert_watch(s, SESSION_WATCH_RECORDS);
+        session_alert_watch(s, SESSION_WATCH_SHOW);
+    if (rlist->num_records)
+        session_alert_watch(s, SESSION_WATCH_RECORD);
 
 #if USE_TIMING
     yaz_timing_stop(t);
@@ -356,30 +613,57 @@ void client_search_response(struct client *cl, Z_APDU *a)
     if (*r->searchStatus)
     {
 	cl->hits = *r->resultCount;
-        se->total_hits += cl->hits;
+        if (cl->hits < 0)
+        {
+            yaz_log(YLOG_WARN, "Target %s returns hit count %d",
+                    cl->database->database->url, cl->hits);
+        }
+        else
+            se->total_hits += cl->hits;
         if (r->presentStatus && !*r->presentStatus && r->records)
         {
             yaz_log(YLOG_DEBUG, "Records in search response %s", 
                     cl->database->database->url);
             ingest_records(cl, r->records);
         }
-        cl->state = Client_Idle;
+        cl->state = Client_Continue;
     }
     else
     {          /*"FAILED"*/
+        Z_Records *recs = r->records;
 	cl->hits = 0;
         cl->state = Client_Error;
-        if (r->records) {
-            Z_Records *recs = r->records;
-            if (recs->which == Z_Records_NSD)
-            {
-                yaz_log(YLOG_WARN,  
-                    "Search response: Non-surrogate diagnostic %s (%d)", 
-                    cl->database->database->url, 
-                    *recs->u.nonSurrogateDiagnostic->condition); 
-                cl->diagnostic = *recs->u.nonSurrogateDiagnostic->condition;
-                cl->state = Client_Error;
-            }
+        if (recs && recs->which == Z_Records_NSD)
+        {
+            WRBUF w = wrbuf_alloc();
+
+            Z_DiagRec dr, *dr_p = &dr;
+            dr.which = Z_DiagRec_defaultFormat;
+            dr.u.defaultFormat = recs->u.nonSurrogateDiagnostic;
+            
+            wrbuf_printf(w, "Search response NSD %s: ",
+                         cl->database->database->url);
+            
+            cl->diagnostic = diag_to_wrbuf(&dr_p, 1, w);
+
+            yaz_log(YLOG_WARN, "%s", wrbuf_cstr(w));
+
+            cl->state = Client_Error;
+            wrbuf_destroy(w);
+        }
+        else if (recs && recs->which == Z_Records_multipleNSD)
+        {
+            WRBUF w = wrbuf_alloc();
+
+            wrbuf_printf(w, "Search response multipleNSD %s: ",
+                         cl->database->database->url);
+            cl->diagnostic = 
+                diag_to_wrbuf(recs->u.multipleNonSurDiagnostics->diagRecs,
+                              recs->u.multipleNonSurDiagnostics->num_diagRecs,
+                              w);
+            yaz_log(YLOG_WARN, "%s", wrbuf_cstr(w));
+            cl->state = Client_Error;
+            wrbuf_destroy(w);
         }
     }
 }
@@ -387,30 +671,63 @@ void client_search_response(struct client *cl, Z_APDU *a)
 void client_present_response(struct client *cl, Z_APDU *a)
 {
     Z_PresentResponse *r = a->u.presentResponse;
+    Z_Records *recs = r->records;
+        
+    if (recs && recs->which == Z_Records_NSD)
+    {
+        WRBUF w = wrbuf_alloc();
+        
+        Z_DiagRec dr, *dr_p = &dr;
+        dr.which = Z_DiagRec_defaultFormat;
+        dr.u.defaultFormat = recs->u.nonSurrogateDiagnostic;
+        
+        wrbuf_printf(w, "Present response NSD %s: ",
+                     cl->database->database->url);
+        
+        cl->diagnostic = diag_to_wrbuf(&dr_p, 1, w);
+        
+        yaz_log(YLOG_WARN, "%s", wrbuf_cstr(w));
+        
+        cl->state = Client_Error;
+        wrbuf_destroy(w);
 
-    if (r->records) {
-        Z_Records *recs = r->records;
-        if (recs->which == Z_Records_NSD)
-        {
-            yaz_log(YLOG_WARN, "Non-surrogate diagnostic %s",
-                    cl->database->database->url);
-            cl->diagnostic = *recs->u.nonSurrogateDiagnostic->condition;
-            cl->state = Client_Error;
-        }
+        client_show_raw_error(cl, "non surrogate diagnostics");
     }
-
-    if (!*r->presentStatus && cl->state != Client_Error)
+    else if (recs && recs->which == Z_Records_multipleNSD)
+    {
+        WRBUF w = wrbuf_alloc();
+        
+        wrbuf_printf(w, "Present response multipleNSD %s: ",
+                     cl->database->database->url);
+        cl->diagnostic = 
+            diag_to_wrbuf(recs->u.multipleNonSurDiagnostics->diagRecs,
+                          recs->u.multipleNonSurDiagnostics->num_diagRecs,
+                          w);
+        yaz_log(YLOG_WARN, "%s", wrbuf_cstr(w));
+        cl->state = Client_Error;
+        wrbuf_destroy(w);
+    }
+    else if (recs && !*r->presentStatus && cl->state != Client_Error)
     {
         yaz_log(YLOG_DEBUG, "Good Present response %s",
                 cl->database->database->url);
-        ingest_records(cl, r->records);
-        cl->state = Client_Idle;
+
+        // we can mix show raw and normal show ..
+        if (cl->show_raw && cl->show_raw->active)
+        {
+            cl->show_raw->active = 0; // no longer active
+            ingest_raw_records(cl, recs);
+        }
+        else
+            ingest_records(cl, recs);
+        cl->state = Client_Continue;
     }
     else if (*r->presentStatus) 
     {
         yaz_log(YLOG_WARN, "Bad Present response %s",
                 cl->database->database->url);
         cl->state = Client_Error;
+        client_show_raw_error(cl, "bad present response");
     }
 }
 
@@ -440,7 +757,7 @@ int client_is_our_response(struct client *cl)
 static void init_authentication(struct client *cl, Z_InitRequest *req)
 {
     struct session_database *sdb = client_get_database(cl);
-    char *auth = session_setting_oneval(sdb, PZ_AUTHENTICATION);
+    const char *auth = session_setting_oneval(sdb, PZ_AUTHENTICATION);
 
     if (*auth)
     {
@@ -449,7 +766,7 @@ static void init_authentication(struct client *cl, Z_InitRequest *req)
         Z_IdAuthentication *idAuth = odr_malloc(global_parameters.odr_out,
                 sizeof(*idAuth));
         idAuth->which = Z_IdAuthentication_open;
-        idAuth->u.open = auth;
+        idAuth->u.open = odr_strdup(global_parameters.odr_out, auth);
         req->idAuthentication = idAuth;
         connection_set_authentication(co, nmem_strdup(se->session_nmem, auth));
     }
@@ -460,19 +777,13 @@ static void init_zproxy(struct client *cl, Z_InitRequest *req)
     struct session_database *sdb = client_get_database(cl);
     char *ztarget = sdb->database->url;
     //char *ztarget = sdb->url;    
-    char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
-
+    const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
+    
     if (*zproxy)
-#if YAZ_VERSIONL >= 0x020163
         yaz_oi_set_string_oid(&req->otherInfo,
                               global_parameters.odr_out,
                               yaz_oid_userinfo_proxy,
                               1, ztarget);
-#else
-        yaz_oi_set_string_oidval(&req->otherInfo,
-                                 global_parameters.odr_out, VAL_PROXY,
-                                 1, ztarget);
-#endif
 }
 
 
@@ -495,8 +806,6 @@ static void client_init_request(struct client *cl)
     init_authentication(cl, a->u.initRequest);
     init_zproxy(cl, a->u.initRequest);
 
-
-
     if (send_apdu(cl, a) >= 0)
 	client_set_state(cl, Client_Initializing);
     else
@@ -509,17 +818,24 @@ void client_continue(struct client *cl)
     if (cl->state == Client_Connected) {
         client_init_request(cl);
     }
-
-    if (cl->state == Client_Idle)
+    if (cl->state == Client_Continue || cl->state == Client_Idle)
     {
         struct session *se = client_get_session(cl);
         if (cl->requestid != se->requestid && cl->pquery) {
+            // we'll have to abort this because result set is to be deleted
+            client_show_raw_cancel(cl);   
             client_send_search(cl);
         }
+        else if (cl->show_raw)
+        {
+            client_send_raw_present(cl);
+        }
         else if (cl->hits > 0 && cl->records < global_parameters.toget &&
             cl->records < cl->hits) {
             client_send_present(cl);
         }
+        else
+            client_set_state(cl, Client_Idle);
     }
 }
 
@@ -543,6 +859,7 @@ struct client *client_create(void)
     r->requestid = -1;
     r->diagnostic = 0;
     r->state = Client_Disconnected;
+    r->show_raw = 0;
     r->next = 0;
     return r;
 }
@@ -560,6 +877,8 @@ void client_destroy(struct client *c)
         if (cc)
             cc->next = c->next;
     }
+    xfree(c->pquery);
+
     if (c->connection)
         connection_release(c->connection);
     c->next = client_freelist;
@@ -622,6 +941,7 @@ int client_parse_query(struct client *cl, const char *query)
 
     if (!ccl_map)
         return -1;
+
     cn = ccl_find_str(ccl_map, query, &cerror, &cpos);
     ccl_qual_rm(&ccl_map);
     if (!cn)
@@ -641,9 +961,10 @@ int client_parse_query(struct client *cl, const char *query)
         // Initialize relevance structure with query terms
         char *p[512];
         extract_terms(se->nmem, cn, p);
-        se->relevance = relevance_create(client_get_database(cl)->pct,
-                                         se->nmem, (const char **) p,
-                                         se->expected_maxrecs);
+        se->relevance = relevance_create(
+            global_parameters.server->relevance_pct,
+            se->nmem, (const char **) p,
+            se->expected_maxrecs);
     }
 
     ccl_rpn_delete(cn);
@@ -659,7 +980,9 @@ void client_set_session(struct client *cl, struct session *se)
 
 int client_is_active(struct client *cl)
 {
-    if (cl->connection && (cl->state == Client_Connecting ||
+    if (cl->connection && (cl->state == Client_Continue ||
+                           cl->state == Client_Connecting ||
+                           cl->state == Client_Connected ||
                            cl->state == Client_Initializing ||
                            cl->state == Client_Searching ||
                            cl->state == Client_Presenting))