-/* $Id: client.c,v 1.1 2007-04-23 21:05:23 adam Exp $
- Copyright (c) 2006-2007, Index Data.
-
-This file is part of Pazpar2.
+/* This file is part of Pazpar2.
+ Copyright (C) 2006-2008 Index Data
Pazpar2 is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
for more details.
You should have received a copy of the GNU General Public License
-along with Pazpar2; see the file LICENSE. If not, write to the
-Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.
- */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+*/
/** \file client.c
\brief Z39.50 client
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#if HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif
+#if HAVE_UNISTD_H
#include <unistd.h>
+#endif
+#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
+#endif
+#if HAVE_NETDB_H
#include <netdb.h>
+#endif
#include <signal.h>
#include <ctype.h>
#include <assert.h>
#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"
+#include <config.h>
#endif
#define USE_TIMING 0
#include <yaz/timing.h>
#endif
+#if HAVE_NETINET_IN_H
#include <netinet/in.h>
+#endif
#include "pazpar2.h"
#include "connection.h"
#include "settings.h"
-// Represents client state for a connection to one search target
+/** \brief Represents client state for a connection to one search target */
struct client {
struct session_database *database;
struct connection *connection;
int hits;
int records;
int setno;
- int requestid; // ID of current outstanding request
+ int requestid; // ID of current outstanding request
int diagnostic;
enum client_state state;
- struct client *next;
+ 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;
+ int binary;
+ 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;
+ struct show_raw *next;
};
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);
}
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;
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),
+ void **data2,
+ int binary)
+{
+ struct show_raw *rr, **rrp;
+ if (!cl->connection)
+ { /* the client has no connection */
+ return -1;
+ }
+ rr = xmalloc(sizeof(*rr));
+ *data2 = rr;
+ rr->position = position;
+ rr->active = 0;
+ rr->data = data;
+ rr->error_handler = error_handler;
+ rr->record_handler = record_handler;
+ rr->binary = binary;
+ if (syntax)
+ rr->syntax = xstrdup(syntax);
+ else
+ rr->syntax = 0;
+ if (esn)
+ rr->esn = xstrdup(esn);
+ else
+ rr->esn = 0;
+ rr->next = 0;
+
+ for (rrp = &cl->show_raw; *rrp; rrp = &(*rrp)->next)
+ ;
+ *rrp = rr;
+
+ 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_remove(struct client *cl, void *data)
+{
+ struct show_raw *rr = data;
+ struct show_raw **rrp = &cl->show_raw;
+ while (*rrp != rr)
+ rrp = &(*rrp)->next;
+ if (*rrp)
+ {
+ *rrp = rr->next;
+ xfree(rr);
+ }
+}
+
+void client_show_raw_dequeue(struct client *cl)
+{
+ struct show_raw *rr = cl->show_raw;
+
+ cl->show_raw = rr->next;
+ xfree(rr);
+}
+
+static void client_show_raw_error(struct client *cl, const char *addinfo)
+{
+ while (cl->show_raw)
+ {
+ cl->show_raw->error_handler(cl->show_raw->data, addinfo);
+ client_show_raw_dequeue(cl);
+ }
+}
+
+static void client_show_raw_cancel(struct client *cl)
+{
+ while (cl->show_raw)
+ {
+ cl->show_raw->error_handler(cl->show_raw->data, "cancel");
+ client_show_raw_dequeue(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)
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;
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));
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,
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;
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;
+ }
+
+ if (cl->show_raw && cl->show_raw->binary)
+ {
+ Z_External *rec = npr->u.databaseRecord;
+ if (rec->which == Z_External_octet)
+ {
+ cl->show_raw->record_handler(cl->show_raw->data,
+ (const char *)
+ rec->u.octet_aligned->buf,
+ rec->u.octet_aligned->len);
+ client_show_raw_dequeue(cl);
+ }
+ else
+ client_show_raw_error(cl, "no records");
+ }
+
+ 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);
+
+ if (cl->show_raw)
+ {
+ cl->show_raw->record_handler(cl->show_raw->data,
+ (const char *) buf_out, len_out);
+ client_show_raw_dequeue(cl);
+ }
+ xmlFree(buf_out);
+}
+
static void ingest_records(struct client *cl, Z_Records *r)
{
#if USE_TIMING
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);
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",
- cl->database->database->url);
- 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);
}
}
}
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");
}
}
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)
+ if (*auth)
{
+ struct connection *co = client_get_connection(cl);
+ struct session *se = client_get_session(cl);
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));
}
}
+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;
+ const char *zproxy = session_setting_oneval(sdb, PZ_ZPROXY);
+
+ if (*zproxy)
+ yaz_oi_set_string_oid(&req->otherInfo,
+ global_parameters.odr_out,
+ yaz_oid_userinfo_proxy,
+ 1, ztarget);
+}
+
+
static void client_init_request(struct client *cl)
{
Z_APDU *a = zget_APDU(global_parameters.odr_out, Z_APDU_initRequest);
ODR_MASK_SET(a->u.initRequest->protocolVersion, Z_ProtocolVersion_3);
init_authentication(cl, a->u.initRequest);
-
- /* add virtual host if tunneling through Z39.50 proxy */
-
- if (0 < strlen(global_parameters.zproxy_override)
- && 0 < strlen(client_get_database(cl)->database->url))
- {
-#if YAZ_VERSIONL >= 0x020163
- yaz_oi_set_string_oid(&a->u.initRequest->otherInfo,
- global_parameters.odr_out,
- yaz_oid_userinfo_proxy,
- 1, client_get_database(cl)->database->url);
-#else
- yaz_oi_set_string_oidval(&a->u.initRequest->otherInfo,
- global_parameters.odr_out, VAL_PROXY,
- 1, client_get_database(cl->database)->url);
-#endif
- }
+ init_zproxy(cl, a->u.initRequest);
if (send_apdu(cl, a) >= 0)
client_set_state(cl, Client_Initializing);
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);
}
}
r->requestid = -1;
r->diagnostic = 0;
r->state = Client_Disconnected;
+ r->show_raw = 0;
r->next = 0;
return r;
}
if (cc)
cc->next = c->next;
}
+ xfree(c->pquery);
+
if (c->connection)
connection_release(c->connection);
c->next = client_freelist;
void client_disconnect(struct client *cl)
{
if (cl->state != Client_Idle)
- cl->state = Client_Disconnected;
+ client_set_state(cl, Client_Disconnected);
client_set_connection(cl, 0);
}
if (!ccl_map)
return -1;
+
cn = ccl_find_str(ccl_map, query, &cerror, &cpos);
ccl_qual_rm(&ccl_map);
if (!cn)
}
wrbuf_rewind(se->wrbuf);
ccl_pquery(se->wrbuf, cn);
- wrbuf_putc(se->wrbuf, '\0');
- if (cl->pquery)
- xfree(cl->pquery);
- cl->pquery = xstrdup(wrbuf_buf(se->wrbuf));
+ xfree(cl->pquery);
+ cl->pquery = xstrdup(wrbuf_cstr(se->wrbuf));
if (!se->relevance)
{
// Initialize relevance structure with query terms
char *p[512];
extract_terms(se->nmem, cn, p);
- se->relevance = relevance_create(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);
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))
projects / pazpar2-moved-to-github.git / blobdiff