* Copyright (c) 1995-2003, Index Data
* See the file LICENSE for details.
*
- * $Id: seshigh.c,v 1.136 2003-02-17 14:35:42 adam Exp $
+ * $Id: seshigh.c,v 1.161 2003-09-09 16:03:46 mike Exp $
*/
/*
#include <io.h>
#define S_ISREG(x) (x & _S_IFREG)
#include <process.h>
+#include <sys/stat.h>
#else
#include <sys/stat.h>
#include <unistd.h>
#endif
#include <assert.h>
+#include <ctype.h>
#include <yaz/yconfig.h>
#include <yaz/xmalloc.h>
#include <yaz/charneg.h>
#include <yaz/otherinfo.h>
#include <yaz/yaz-util.h>
+#include <yaz/pquery.h>
#include <yaz/srw.h>
#include <yaz/backend.h>
static int process_gdu_response(association *assoc, request *req, Z_GDU *res);
static int process_z_response(association *assoc, request *req, Z_APDU *res);
static Z_APDU *process_initRequest(association *assoc, request *reqb);
+static Z_External *init_diagnostics(ODR odr, int errcode, char *errstring);
static Z_APDU *process_searchRequest(association *assoc, request *reqb,
int *fd);
static Z_APDU *response_searchRequest(association *assoc, request *reqb,
if (!(anew = (association *)xmalloc(sizeof(*anew))))
return 0;
anew->init = 0;
+ anew->version = 0;
anew->client_chan = channel;
anew->client_link = link;
anew->cs_get_mask = 0;
xfree(h);
xmalloc_trav("session closed");
if (control_block && control_block->one_shot)
+ {
exit (0);
+ }
}
static void do_close_req(association *a, int reason, char *message,
*cls->closeReason = reason;
cls->diagnosticInformation = message;
process_z_response(a, req, &apdu);
- iochan_settimeout(a->client_chan, 60);
+ iochan_settimeout(a->client_chan, 20);
}
else
{
/* We aren't speaking to this fellow */
if (assoc->state == ASSOC_DEAD)
{
- yaz_log(LOG_LOG, "Closed connection after reject");
+ yaz_log(LOG_LOG, "Connection closed - end of session");
cs_close(conn);
destroy_association(assoc);
iochan_destroy(h);
assoc->input_buffer[0] & 0xff,
assoc->input_buffer[1] & 0xff,
assoc->input_buffer[2] & 0xff);
- req = request_get(&assoc->incoming); /* get a new request structure */
+ req = request_get(&assoc->incoming); /* get a new request */
odr_reset(assoc->decode);
odr_setbuf(assoc->decode, assoc->input_buffer, res, 0);
if (!z_GDU(assoc->decode, &req->gdu_request, 0, 0))
{
- yaz_log(LOG_LOG, "ODR error on incoming PDU: %s [near byte %d] ",
+ yaz_log(LOG_LOG, "ODR error on incoming PDU: %s [element %s] "
+ "[near byte %d] ",
odr_errmsg(odr_geterror(assoc->decode)),
+ odr_getelement(assoc->decode),
odr_offset(assoc->decode));
if (assoc->decode->error != OHTTP)
{
{ /* restore mask for cs_get operation ... */
iochan_clearflag(h, EVENT_OUTPUT|EVENT_INPUT);
iochan_setflag(h, assoc->cs_get_mask);
- yaz_log(LOG_LOG, "queue empty mask=%d", assoc->cs_get_mask);
if (assoc->state == ASSOC_DEAD)
iochan_setevent(assoc->client_chan, EVENT_TIMEOUT);
}
else
{
assoc->cs_put_mask = EVENT_OUTPUT;
- yaz_log(LOG_LOG, "queue not empty");
}
break;
default:
static int process_z_request(association *assoc, request *req, char **msg);
-static int srw_bend_init(association *assoc)
+static void assoc_init_reset(association *assoc)
{
- bend_initresult *binitres;
- statserv_options_block *cb = statserv_getcontrol();
-
+ xfree (assoc->init);
assoc->init = (bend_initrequest *) xmalloc (sizeof(*assoc->init));
assoc->init->stream = assoc->encode;
assoc->init->bend_scan = NULL;
assoc->init->bend_segment = NULL;
assoc->init->bend_fetch = NULL;
+ assoc->init->bend_explain = NULL;
+
assoc->init->charneg_request = NULL;
assoc->init->charneg_response = NULL;
+
assoc->init->decode = assoc->decode;
+ assoc->init->peer_name =
+ odr_strdup (assoc->encode, cs_addrstr(assoc->client_link));
+}
+
+static int srw_bend_init(association *assoc)
+{
+ const char *encoding = "UTF-8";
+ Z_External *ce;
+ bend_initresult *binitres;
+ statserv_options_block *cb = statserv_getcontrol();
+
+ assoc_init_reset(assoc);
- assoc->init->peer_name =
- odr_strdup (assoc->encode, cs_addrstr(assoc->client_link));
+ assoc->maximumRecordSize = 3000000;
+ assoc->preferredMessageSize = 3000000;
+#if 1
+ ce = yaz_set_proposal_charneg(assoc->decode, &encoding, 1, 0, 0, 1);
+ assoc->init->charneg_request = ce->u.charNeg3;
+#endif
if (!(binitres = (*cb->bend_init)(assoc->init)))
{
yaz_log(LOG_WARN, "Bad response from backend.");
return 1;
}
-static void srw_bend_fetch(association *assoc, int pos,
- Z_SRW_searchRetrieveRequest *srw_req,
- Z_SRW_record *record)
+static int srw_bend_fetch(association *assoc, int pos,
+ Z_SRW_searchRetrieveRequest *srw_req,
+ Z_SRW_record *record)
{
bend_fetch_rr rr;
ODR o = assoc->encode;
rr.comp->u.complex->generic = (Z_Specification *)
odr_malloc(assoc->decode, sizeof(Z_Specification));
- rr.comp->u.complex->generic->which = Z_Specification_uri;
- rr.comp->u.complex->generic->u.uri = srw_req->recordSchema;
+ rr.comp->u.complex->generic->which = Z_Schema_uri;
+ rr.comp->u.complex->generic->schema.uri = srw_req->recordSchema;
rr.comp->u.complex->generic->elementSpec = 0;
rr.stream = assoc->encode;
rr.errcode = 0;
rr.errstring = 0;
rr.surrogate_flag = 0;
-
+ rr.schema = srw_req->recordSchema;
+
+ if (!assoc->init->bend_fetch)
+ return 1;
+
(*assoc->init->bend_fetch)(assoc->backend, &rr);
if (rr.len >= 0)
record->recordData_buf = rr.record;
record->recordData_len = rr.len;
record->recordPosition = odr_intdup(o, pos);
- record->recordSchema = 0;
- if (srw_req->recordSchema)
- record->recordSchema = odr_strdup(o, srw_req->recordSchema);
+ if (rr.schema)
+ record->recordSchema = odr_strdup(o, rr.schema);
+ else
+ record->recordSchema = 0;
}
+ return rr.errcode;
}
static void srw_bend_search(association *assoc, request *req,
Z_SRW_searchRetrieveRequest *srw_req,
Z_SRW_searchRetrieveResponse *srw_res)
{
- char *base = "Default";
+ int srw_error = 0;
bend_search_rr rr;
Z_External *ext;
-
+
+ yaz_log(LOG_LOG, "Got SRW SearchRetrieveRequest");
+ yaz_log(LOG_DEBUG, "srw_bend_search");
if (!assoc->init)
- srw_bend_init(assoc);
-
+ {
+ yaz_log(LOG_DEBUG, "srw_bend_init");
+ if (!srw_bend_init(assoc))
+ {
+ srw_error = 3; /* assume Authentication error */
+
+ srw_res->num_diagnostics = 1;
+ srw_res->diagnostics = (Z_SRW_diagnostic *)
+ odr_malloc(assoc->encode, sizeof(*srw_res->diagnostics));
+ srw_res->diagnostics[0].code =
+ odr_intdup(assoc->encode, srw_error);
+ srw_res->diagnostics[0].details = 0;
+ return;
+ }
+ }
+
rr.setname = "default";
rr.replace_set = 1;
rr.num_bases = 1;
rr.basenames = &srw_req->database;
rr.referenceId = 0;
- ext = (Z_External *) odr_malloc(assoc->decode, sizeof(*ext));
- ext->direct_reference = odr_getoidbystr(assoc->decode,
- "1.2.840.10003.16.2");
- ext->indirect_reference = 0;
- ext->descriptor = 0;
- ext->which = Z_External_CQL;
- if (srw_req->query)
- ext->u.cql = srw_req->query;
- else
- ext->u.cql = "noterm";
-
rr.query = (Z_Query *) odr_malloc (assoc->decode, sizeof(*rr.query));
- rr.query->which = Z_Query_type_104;
- rr.query->u.type_104 = ext;
+
+ if (srw_req->query_type == Z_SRW_query_type_cql)
+ {
+ ext = (Z_External *) odr_malloc(assoc->decode, sizeof(*ext));
+ ext->direct_reference = odr_getoidbystr(assoc->decode,
+ "1.2.840.10003.16.2");
+ ext->indirect_reference = 0;
+ ext->descriptor = 0;
+ ext->which = Z_External_CQL;
+ ext->u.cql = srw_req->query.cql;
+
+ rr.query->which = Z_Query_type_104;
+ rr.query->u.type_104 = ext;
+ }
+ else if (srw_req->query_type == Z_SRW_query_type_pqf)
+ {
+ Z_RPNQuery *RPNquery;
+ YAZ_PQF_Parser pqf_parser;
+
+ pqf_parser = yaz_pqf_create ();
+
+ RPNquery = yaz_pqf_parse (pqf_parser, assoc->decode,
+ srw_req->query.pqf);
+ if (!RPNquery)
+ {
+ const char *pqf_msg;
+ size_t off;
+ int code = yaz_pqf_error (pqf_parser, &pqf_msg, &off);
+ yaz_log(LOG_LOG, "%*s^\n", off+4, "");
+ yaz_log(LOG_LOG, "Bad PQF: %s (code %d)\n", pqf_msg, code);
+
+ srw_error = 10;
+ }
+
+ rr.query->which = Z_Query_type_1;
+ rr.query->u.type_1 = RPNquery;
+
+ yaz_pqf_destroy (pqf_parser);
+ }
+ else
+ srw_error = 11;
+
+ if (!srw_error && srw_req->sort_type != Z_SRW_sort_type_none)
+ srw_error = 80;
+
+ if (!srw_error && !assoc->init->bend_search)
+ srw_error = 1;
+
+ if (srw_error)
+ {
+ yaz_log(LOG_DEBUG, "srw_bend_search returned SRW error %d", srw_error);
+ srw_res->num_diagnostics = 1;
+ srw_res->diagnostics = (Z_SRW_diagnostic *)
+ odr_malloc(assoc->encode, sizeof(*srw_res->diagnostics));
+ srw_res->diagnostics[0].code =
+ odr_intdup(assoc->encode, srw_error);
+ srw_res->diagnostics[0].details = 0;
+ return;
+ }
rr.stream = assoc->encode;
rr.decode = assoc->decode;
srw_res->numberOfRecords = odr_intdup(assoc->encode, rr.hits);
if (rr.errcode)
{
+ yaz_log(LOG_DEBUG, "bend_search returned Bib-1 code %d", rr.errcode);
srw_res->num_diagnostics = 1;
srw_res->diagnostics = (Z_SRW_diagnostic *)
odr_malloc(assoc->encode, sizeof(*srw_res->diagnostics));
srw_res->diagnostics[0].code =
- odr_intdup(assoc->encode, rr.errcode);
+ odr_intdup(assoc->encode,
+ yaz_diag_bib1_to_srw (rr.errcode));
srw_res->diagnostics[0].details = rr.errstring;
+ yaz_log(LOG_DEBUG, "srw_bend_search returned SRW error %d",
+ *srw_res->diagnostics[0].code);
+
}
else
{
+ int number = srw_req->maximumRecords ? *srw_req->maximumRecords : 0;
+ int start = srw_req->startRecord ? *srw_req->startRecord : 1;
+
+ yaz_log(LOG_LOG, "Request to pack %d+%d out of %d",
+ start, number, rr.hits);
+
srw_res->numberOfRecords = odr_intdup(assoc->encode, rr.hits);
- if (srw_req->maximumRecords && *srw_req->maximumRecords > 0)
+ if (number > 0)
{
- int number = *srw_req->maximumRecords;
- int start = 1;
int i;
- if (srw_req->startRecord)
- start = *srw_req->startRecord;
- if (start <= rr.hits)
+
+ if (start > rr.hits)
+ {
+ yaz_log(LOG_LOG, "Request out or range");
+ }
+ else
{
int j = 0;
+ int packing = Z_SRW_recordPacking_string;
if (start + number > rr.hits)
number = rr.hits - start + 1;
+ if (srw_req->recordPacking &&
+ !strcmp(srw_req->recordPacking, "xml"))
+ packing = Z_SRW_recordPacking_XML;
srw_res->records = (Z_SRW_record *)
odr_malloc(assoc->encode,
number * sizeof(*srw_res->records));
for (i = 0; i<number; i++)
{
+ int errcode;
+
+ srw_res->records[j].recordPacking = packing;
srw_res->records[j].recordData_buf = 0;
- srw_bend_fetch(assoc, i+start, srw_req,
- srw_res->records + j);
+ yaz_log(LOG_DEBUG, "srw_bend_fetch %d", i+start);
+ errcode = srw_bend_fetch(assoc, i+start, srw_req,
+ srw_res->records + j);
+ if (errcode)
+ {
+ srw_res->num_diagnostics = 1;
+ srw_res->diagnostics = (Z_SRW_diagnostic *)
+ odr_malloc(assoc->encode,
+ sizeof(*srw_res->diagnostics));
+ srw_res->diagnostics[0].code =
+ odr_intdup(assoc->encode,
+ yaz_diag_bib1_to_srw (errcode));
+ srw_res->diagnostics[0].details = rr.errstring;
+ break;
+ }
if (srw_res->records[j].recordData_buf)
j++;
}
srw_res->num_records = j;
if (!j)
srw_res->records = 0;
- yaz_log(LOG_LOG, "got %d records", j);
}
}
}
}
+
+static void srw_bend_explain(association *assoc, request *req,
+ Z_SRW_explainRequest *srw_req,
+ Z_SRW_explainResponse *srw_res)
+{
+ yaz_log(LOG_LOG, "Got SRW ExplainRequest");
+ if (!assoc->init)
+ {
+ yaz_log(LOG_DEBUG, "srw_bend_init");
+ if (!srw_bend_init(assoc))
+ return;
+ }
+ if (assoc->init && assoc->init->bend_explain)
+ {
+ bend_explain_rr rr;
+
+ rr.stream = assoc->encode;
+ rr.decode = assoc->decode;
+ rr.print = assoc->print;
+ rr.explain_buf = 0;
+ (*assoc->init->bend_explain)(assoc->backend, &rr);
+ if (rr.explain_buf)
+ {
+ srw_res->explainData_buf = rr.explain_buf;
+ srw_res->explainData_len = strlen(rr.explain_buf);
+ }
+ }
+}
+
+static int hex_digit (int ch)
+{
+ if (ch >= '0' && ch <= '9')
+ return ch - '0';
+ else if (ch >= 'a' && ch <= 'f')
+ return ch - 'a'+10;
+ else if (ch >= 'A' && ch <= 'F')
+ return ch - 'A'+10;
+ return 0;
+}
+
+static char *uri_val(const char *path, const char *name, ODR o)
+{
+ size_t nlen = strlen(name);
+ if (*path != '?')
+ return 0;
+ path++;
+ while (path && *path)
+ {
+ const char *p1 = strchr(path, '=');
+ if (!p1)
+ break;
+ if ((size_t)(p1 - path) == nlen && !memcmp(path, name, nlen))
+ {
+ size_t i = 0;
+ char *ret;
+
+ path = p1 + 1;
+ p1 = strchr(path, '&');
+ if (!p1)
+ p1 = strlen(path) + path;
+ ret = odr_malloc(o, p1 - path + 1);
+ while (*path && *path != '&')
+ {
+ if (*path == '+')
+ {
+ ret[i++] = ' ';
+ path++;
+ }
+ else if (*path == '%' && path[1] && path[2])
+ {
+ ret[i++] = hex_digit (path[1])*16 + hex_digit (path[2]);
+ path = path + 3;
+ }
+ else
+ ret[i++] = *path++;
+ }
+ ret[i] = '\0';
+ return ret;
+ }
+ path = strchr(p1, '&');
+ if (path)
+ path++;
+ }
+ return 0;
+}
+
+void uri_val_int(const char *path, const char *name, ODR o, int **intp)
+{
+ const char *v = uri_val(path, name, o);
+ if (v)
+ *intp = odr_intdup(o, atoi(v));
+}
+
static void process_http_request(association *assoc, request *req)
{
Z_HTTP_Request *hreq = req->gdu_request->u.HTTP_Request;
if (!strcmp(hreq->method, "GET"))
{
+ char *db = "Default";
+ const char *p0 = hreq->path, *p1;
+#if HAVE_XML2
+ int ret = -1;
+ char *charset = 0;
+ Z_SOAP *soap_package = 0;
+ static Z_SOAP_Handler soap_handlers[2] = {
+ {"http://www.loc.gov/zing/srw/v1.0/", 0,
+ (Z_SOAP_fun) yaz_srw_codec},
+ {0, 0, 0}
+ };
+#endif
+
+ if (*p0 == '/')
+ p0++;
+ p1 = strchr(p0, '?');
+ if (!p1)
+ p1 = p0 + strlen(p0);
+ if (p1 != p0)
+ {
+ db = odr_malloc(assoc->decode, p1 - p0 + 1);
+ memcpy (db, p0, p1 - p0);
+ db[p1 - p0] = '\0';
+ }
+#if HAVE_XML2
+ if (p1 && *p1 == '?' && p1[1])
+ {
+ Z_SRW_PDU *res = yaz_srw_get(o, Z_SRW_searchRetrieve_response);
+ Z_SRW_PDU *sr = yaz_srw_get(o, Z_SRW_searchRetrieve_request);
+ char *query = uri_val(p1, "query", o);
+ char *pQuery = uri_val(p1, "pQuery", o);
+ char *sortKeys = uri_val(p1, "sortKeys", o);
+
+ if (query)
+ {
+ sr->u.request->query_type = Z_SRW_query_type_cql;
+ sr->u.request->query.cql = query;
+ }
+ if (pQuery)
+ {
+ sr->u.request->query_type = Z_SRW_query_type_pqf;
+ sr->u.request->query.pqf = pQuery;
+ }
+ if (sortKeys)
+ {
+ sr->u.request->sort_type = Z_SRW_sort_type_sort;
+ sr->u.request->sort.sortKeys = sortKeys;
+ }
+ sr->u.request->recordSchema = uri_val(p1, "recordSchema", o);
+ sr->u.request->recordPacking = uri_val(p1, "recordPacking", o);
+ if (!sr->u.request->recordPacking)
+ sr->u.request->recordPacking = "xml";
+ uri_val_int(p1, "maximumRecords", o,
+ &sr->u.request->maximumRecords);
+ uri_val_int(p1, "startRecord", o,
+ &sr->u.request->startRecord);
+ if (sr->u.request->startRecord)
+ yaz_log(LOG_LOG, "startRecord=%d", *sr->u.request->startRecord);
+ sr->u.request->database = db;
+ srw_bend_search(assoc, req, sr->u.request, res->u.response);
+
+ soap_package = odr_malloc(o, sizeof(*soap_package));
+ soap_package->which = Z_SOAP_generic;
+
+ soap_package->u.generic =
+ odr_malloc(o, sizeof(*soap_package->u.generic));
+
+ soap_package->u.generic->p = res;
+ soap_package->u.generic->ns = soap_handlers[0].ns;
+ soap_package->u.generic->no = 0;
+
+ soap_package->ns = "SRU";
+
+ p = z_get_HTTP_Response(o, 200);
+ hres = p->u.HTTP_Response;
+
+ ret = z_soap_codec_enc(assoc->encode, &soap_package,
+ &hres->content_buf, &hres->content_len,
+ soap_handlers, charset);
+ if (!charset)
+ z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/xml");
+ else
+ {
+ char ctype[60];
+ strcpy(ctype, "text/xml; charset=");
+ strcat(ctype, charset);
+ z_HTTP_header_add(o, &hres->headers, "Content-Type", ctype);
+ }
+
+ }
+ else
+ {
+ Z_SRW_PDU *res = yaz_srw_get(o, Z_SRW_explain_response);
+ Z_SRW_PDU *sr = yaz_srw_get(o, Z_SRW_explain_request);
+
+ srw_bend_explain(assoc, req, sr->u.explain_request,
+ res->u.explain_response);
+
+ if (res->u.explain_response->explainData_buf)
+ {
+ soap_package = odr_malloc(o, sizeof(*soap_package));
+ soap_package->which = Z_SOAP_generic;
+
+ soap_package->u.generic =
+ odr_malloc(o, sizeof(*soap_package->u.generic));
+
+ soap_package->u.generic->p = res;
+ soap_package->u.generic->ns = soap_handlers[0].ns;
+ soap_package->u.generic->no = 0;
+
+ soap_package->ns = "SRU";
+
+ p = z_get_HTTP_Response(o, 200);
+ hres = p->u.HTTP_Response;
+
+ ret = z_soap_codec_enc(assoc->encode, &soap_package,
+ &hres->content_buf, &hres->content_len,
+ soap_handlers, charset);
+ if (!charset)
+ z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/xml");
+ else
+ {
+ char ctype[60];
+ strcpy(ctype, "text/xml; charset=");
+ strcat(ctype, charset);
+ z_HTTP_header_add(o, &hres->headers, "Content-Type",
+ ctype);
+ }
+ }
+ }
+#endif
#ifdef DOCDIR
if (strlen(hreq->path) >= 5 && strlen(hreq->path) < 80 &&
!memcmp(hreq->path, "/doc/", 5))
ctype = "text/html";
}
z_HTTP_header_add(o, &hres->headers, "Content-Type", ctype);
- yaz_log(LOG_LOG, "OK send page %s size=%ld", fpath, sz);
}
fclose(f);
}
}
#endif
+
+#if 0
if (!strcmp(hreq->path, "/"))
{
+#ifdef DOCDIR
struct stat sbuf;
+#endif
const char *doclink = "";
p = z_get_HTTP_Response(o, 200);
hres = p->u.HTTP_Response;
hres->content_len = strlen(hres->content_buf);
z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/html");
}
+#endif
+
if (!p)
{
p = z_get_HTTP_Response(o, 404);
}
else if (!strcmp(hreq->method, "POST"))
{
-#if HAVE_XSLT
const char *content_type = z_HTTP_header_lookup(hreq->headers,
"Content-Type");
- const char *soap_action = z_HTTP_header_lookup(hreq->headers,
- "SOAPAction");
- if (content_type && soap_action &&
- !yaz_strcmp_del("text/xml", content_type, "; "))
+ if (content_type && !yaz_strcmp_del("text/xml", content_type, "; "))
{
Z_SOAP *soap_package = 0;
- int ret;
+ int ret = -1;
int http_code = 500;
+ const char *charset_p = 0;
+ char *charset = 0;
static Z_SOAP_Handler soap_handlers[2] = {
+#if HAVE_XML2
{"http://www.loc.gov/zing/srw/v1.0/", 0,
- (Z_SOAP_fun) yaz_srw_codec},
+ (Z_SOAP_fun) yaz_srw_codec},
+#endif
{0, 0, 0}
};
-
+ if ((charset_p = strstr(content_type, "; charset=")))
+ {
+ int i = 0;
+ charset_p += 10;
+ while (i < 20 && charset_p[i] &&
+ !strchr("; \n\r", charset_p[i]))
+ i++;
+ charset = odr_malloc(assoc->encode, i+1);
+ memcpy(charset, charset_p, i);
+ charset[i] = '\0';
+ yaz_log(LOG_LOG, "SOAP encoding %s", charset);
+ }
ret = z_soap_codec(assoc->decode, &soap_package,
&hreq->content_buf, &hreq->content_len,
soap_handlers);
-
+#if HAVE_XML2
if (!ret && soap_package->which == Z_SOAP_generic &&
soap_package->u.generic->no == 0)
{
/* SRW package */
- Z_SRW_searchRetrieve *sr = soap_package->u.generic->p;
+ Z_SRW_PDU *sr = soap_package->u.generic->p;
if (sr->which == Z_SRW_searchRetrieve_request)
{
- Z_SRW_searchRetrieve *res =
+ Z_SRW_PDU *res =
yaz_srw_get(assoc->encode,
Z_SRW_searchRetrieve_response);
soap_package->u.generic->p = res;
http_code = 200;
}
- }
+ else if (sr->which == Z_SRW_explain_request)
+ {
+ Z_SRW_PDU *res =
+ yaz_srw_get(assoc->encode, Z_SRW_explain_response);
+ srw_bend_explain(assoc, req, sr->u.explain_request,
+ res->u.explain_response);
+ if (!res->u.explain_response->explainData_buf)
+ {
+ z_soap_error(assoc->encode, soap_package,
+ "SOAP-ENV:Client", "Explain Not Supported", 0);
+ }
+ else
+ {
+ soap_package->u.generic->p = res;
+ http_code = 200;
+ }
+ }
+ else
+ {
+ z_soap_error(assoc->encode, soap_package,
+ "SOAP-ENV:Client", "Bad method", 0);
+ }
+ }
+#endif
p = z_get_HTTP_Response(o, 200);
hres = p->u.HTTP_Response;
- ret = z_soap_codec(assoc->encode, &soap_package,
- &hres->content_buf, &hres->content_len,
- soap_handlers);
+ ret = z_soap_codec_enc(assoc->encode, &soap_package,
+ &hres->content_buf, &hres->content_len,
+ soap_handlers, charset);
hres->code = http_code;
- z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/xml");
+ if (!charset)
+ z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/xml");
+ else
+ {
+ char ctype[60];
+ strcpy(ctype, "text/xml; charset=");
+ strcat(ctype, charset);
+ z_HTTP_header_add(o, &hres->headers, "Content-Type", ctype);
+ }
}
-#endif
if (!p) /* still no response ? */
p = z_get_HTTP_Response(o, 500);
}
}
else
{
+ int t;
+ const char *alive = z_HTTP_header_lookup(hreq->headers, "Keep-Alive");
+
+ if (alive && isdigit(*alive))
+ t = atoi(alive);
+ else
+ t = 15;
+ if (t < 0 || t > 3600)
+ t = 3600;
+ iochan_settimeout(assoc->client_chan,t);
z_HTTP_header_add(o, &hres->headers, "Connection", "Keep-Alive");
}
process_gdu_response(assoc, req, p);
switch (req->apdu_request->which)
{
case Z_APDU_initRequest:
+ iochan_settimeout(assoc->client_chan,
+ statserv_getcontrol()->idle_timeout * 60);
res = process_initRequest(assoc, req); break;
case Z_APDU_searchRequest:
res = process_searchRequest(assoc, req, &fd); break;
}
if (!z_GDU(assoc->encode, &res, 0, 0))
{
- yaz_log(LOG_WARN, "ODR error when encoding response: %s",
- odr_errmsg(odr_geterror(assoc->decode)));
+ yaz_log(LOG_WARN, "ODR error when decoding PDU: %s [element %s]",
+ odr_errmsg(odr_geterror(assoc->decode)),
+ odr_getelement(assoc->decode));
return -1;
}
req->response = odr_getbuf(assoc->encode, &req->len_response,
*/
static int process_z_response(association *assoc, request *req, Z_APDU *res)
{
- odr_setbuf(assoc->encode, req->response, req->size_response, 1);
+ Z_GDU *gres = (Z_GDU *) odr_malloc(assoc->encode, sizeof(*res));
+ gres->which = Z_GDU_Z3950;
+ gres->u.z3950 = res;
- if (assoc->print && !z_APDU(assoc->print, &res, 0, 0))
- {
- yaz_log(LOG_WARN, "ODR print error: %s",
- odr_errmsg(odr_geterror(assoc->print)));
- odr_reset(assoc->print);
- }
- if (!z_APDU(assoc->encode, &res, 0, 0))
- {
- yaz_log(LOG_WARN, "ODR error when encoding response: %s",
- odr_errmsg(odr_geterror(assoc->decode)));
- return -1;
- }
- req->response = odr_getbuf(assoc->encode, &req->len_response,
- &req->size_response);
- odr_setbuf(assoc->encode, 0, 0, 0); /* don'txfree if we abort later */
- odr_reset(assoc->encode);
- req->state = REQUEST_IDLE;
- request_enq(&assoc->outgoing, req);
- /* turn the work over to the ir_session handler */
- iochan_setflag(assoc->client_chan, EVENT_OUTPUT);
- assoc->cs_put_mask = EVENT_OUTPUT;
- /* Is there more work to be done? give that to the input handler too */
-#if 1
- if (request_head(&assoc->incoming))
- {
- yaz_log (LOG_DEBUG, "more work to be done");
- iochan_setevent(assoc->client_chan, EVENT_WORK);
- }
-#endif
- return 0;
+ return process_gdu_response(assoc, req, gres);
}
+
/*
* Handle init request.
* At the moment, we don't check the options
char options[140];
- xfree (assoc->init);
- assoc->init = (bend_initrequest *) xmalloc (sizeof(*assoc->init));
-
yaz_log(LOG_LOG, "Got initRequest");
if (req->implementationId)
yaz_log(LOG_LOG, "Id: %s", req->implementationId);
if (req->implementationVersion)
yaz_log(LOG_LOG, "Version: %s", req->implementationVersion);
- assoc->init->stream = assoc->encode;
- assoc->init->print = assoc->print;
+ assoc_init_reset(assoc);
+
assoc->init->auth = req->idAuthentication;
assoc->init->referenceId = req->referenceId;
- assoc->init->implementation_version = 0;
- assoc->init->implementation_id = 0;
- assoc->init->implementation_name = 0;
- assoc->init->bend_sort = NULL;
- assoc->init->bend_search = NULL;
- assoc->init->bend_present = NULL;
- assoc->init->bend_esrequest = NULL;
- assoc->init->bend_delete = NULL;
- assoc->init->bend_scan = NULL;
- assoc->init->bend_segment = NULL;
- assoc->init->bend_fetch = NULL;
- assoc->init->charneg_request = NULL;
- assoc->init->charneg_response = NULL;
- assoc->init->decode = assoc->decode;
if (ODR_MASK_GET(req->options, Z_Options_negotiationModel))
{
assoc->init->charneg_request = negotiation;
}
- assoc->init->peer_name =
- odr_strdup (assoc->encode, cs_addrstr(assoc->client_link));
if (!(binitres = (*cb->bend_init)(assoc->init)))
{
yaz_log(LOG_WARN, "Bad response from backend.");
if (assoc->preferredMessageSize > assoc->maximumRecordSize)
assoc->preferredMessageSize = assoc->maximumRecordSize;
-#if 0
- assoc->maximumRecordSize = 3000000;
- assoc->preferredMessageSize = 3000000;
-#endif
-
resp->preferredMessageSize = &assoc->preferredMessageSize;
resp->maximumRecordSize = &assoc->maximumRecordSize;
yaz_log(LOG_LOG, "Connection rejected by backend.");
*resp->result = 0;
assoc->state = ASSOC_DEAD;
+ resp->userInformationField = init_diagnostics(assoc->encode,
+ binitres->errcode,
+ binitres->errstring);
}
else
assoc->state = ASSOC_UP;
}
/*
- * These functions should be merged.
+ * Diagnostic in default format, to be returned as either a surrogate
+ * or non-surrogate diagnostic in the context of an open session, or
+ * as User-information when an Init is refused.
*/
-
-static void set_addinfo (Z_DefaultDiagFormat *dr, char *addinfo, ODR odr)
+static Z_DefaultDiagFormat *justdiag(ODR odr, int error, char *addinfo)
{
+ int *err = odr_intdup(odr, error);
+ Z_DefaultDiagFormat *dr = (Z_DefaultDiagFormat *)
+ odr_malloc (odr, sizeof(*dr));
+
+ yaz_log(LOG_LOG, "[%d] %s%s%s", error, diagbib1_str(error),
+ addinfo ? " -- " : "", addinfo ? addinfo : "");
+
+ dr->diagnosticSetId =
+ yaz_oidval_to_z3950oid (odr, CLASS_DIAGSET, VAL_BIB1);
+ dr->condition = err;
dr->which = Z_DefaultDiagFormat_v2Addinfo;
dr->u.v2Addinfo = odr_strdup (odr, addinfo ? addinfo : "");
+ return dr;
+}
+
+/*
+ * Set the specified `errcode' and `errstring' into a UserInfo-1
+ * external to be returned to the client in accordance with Z35.90
+ * Implementor Agreement 5 (Returning diagnostics in an InitResponse):
+ * http://lcweb.loc.gov/z3950/agency/agree/initdiag.html
+ */
+static Z_External *init_diagnostics(ODR odr, int error, char *addinfo)
+{
+ Z_External *x, *x2;
+ oident oid;
+ Z_OtherInformation *u;
+ Z_OtherInformationUnit *l;
+ Z_DiagnosticFormat *d;
+ Z_DiagnosticFormat_s *e;
+
+ x = (Z_External*) odr_malloc(odr, sizeof *x);
+ x->descriptor = 0;
+ x->indirect_reference = 0;
+ oid.proto = PROTO_Z3950;
+ oid.oclass = CLASS_USERINFO;
+ oid.value = VAL_USERINFO1;
+ x->direct_reference = odr_oiddup(odr, oid_getoidbyent(&oid));
+ x->which = Z_External_userInfo1;
+
+ u = odr_malloc(odr, sizeof *u);
+ x->u.userInfo1 = u;
+ u->num_elements = 1;
+ u->list = (Z_OtherInformationUnit**) odr_malloc(odr, sizeof *u->list);
+ u->list[0] = (Z_OtherInformationUnit*) odr_malloc(odr, sizeof *u->list[0]);
+ l = u->list[0];
+ l->category = 0;
+ l->which = Z_OtherInfo_externallyDefinedInfo;
+
+ x2 = (Z_External*) odr_malloc(odr, sizeof *x);
+ l->information.externallyDefinedInfo = x2;
+ x2->descriptor = 0;
+ x2->indirect_reference = 0;
+ oid.oclass = CLASS_DIAGSET;
+ oid.value = VAL_DIAG1;
+ x2->direct_reference = odr_oiddup(odr, oid_getoidbyent(&oid));
+ x2->which = Z_External_diag1;
+
+ d = (Z_DiagnosticFormat*) odr_malloc(odr, sizeof *d);
+ x2->u.diag1 = d;
+ d->num = 1;
+ d->elements = (Z_DiagnosticFormat_s**) odr_malloc (odr, sizeof *d->elements);
+ d->elements[0] = (Z_DiagnosticFormat_s*) odr_malloc (odr, sizeof *d->elements[0]);
+ e = d->elements[0];
+
+ e->which = Z_DiagnosticFormat_s_defaultDiagRec;
+ e->u.defaultDiagRec = justdiag(odr, error, addinfo);
+ return x;
}
/*
{
Z_Records *rec = (Z_Records *)
odr_malloc (assoc->encode, sizeof(*rec));
- int *err = odr_intdup(assoc->encode, error);
- Z_DiagRec *drec = (Z_DiagRec *)
- odr_malloc (assoc->encode, sizeof(*drec));
- Z_DefaultDiagFormat *dr = (Z_DefaultDiagFormat *)
- odr_malloc (assoc->encode, sizeof(*dr));
-
- yaz_log(LOG_LOG, "[%d] %s %s%s", error, diagbib1_str(error),
- addinfo ? " -- " : "", addinfo ? addinfo : "");
rec->which = Z_Records_NSD;
- rec->u.nonSurrogateDiagnostic = dr;
- dr->diagnosticSetId =
- yaz_oidval_to_z3950oid (assoc->encode, CLASS_DIAGSET, VAL_BIB1);
- dr->condition = err;
- set_addinfo (dr, addinfo, assoc->encode);
+ rec->u.nonSurrogateDiagnostic = justdiag(assoc->encode, error, addinfo);
return rec;
}
{
Z_NamePlusRecord *rec = (Z_NamePlusRecord *)
odr_malloc (assoc->encode, sizeof(*rec));
- int *err = odr_intdup(assoc->encode, error);
Z_DiagRec *drec = (Z_DiagRec *)odr_malloc (assoc->encode, sizeof(*drec));
- Z_DefaultDiagFormat *dr = (Z_DefaultDiagFormat *)
- odr_malloc (assoc->encode, sizeof(*dr));
yaz_log(LOG_DEBUG, "SurrogateDiagnotic: %d -- %s", error, addinfo);
rec->databaseName = dbname;
rec->which = Z_NamePlusRecord_surrogateDiagnostic;
rec->u.surrogateDiagnostic = drec;
drec->which = Z_DiagRec_defaultFormat;
- drec->u.defaultFormat = dr;
- dr->diagnosticSetId =
- yaz_oidval_to_z3950oid (assoc->encode, CLASS_DIAGSET, VAL_BIB1);
- dr->condition = err;
- set_addinfo (dr, addinfo, assoc->encode);
+ drec->u.defaultFormat = justdiag(assoc->encode, error, addinfo);
return rec;
}
freq.output_format_raw = 0;
freq.stream = a->encode;
freq.print = a->print;
- freq.surrogate_flag = 0;
freq.referenceId = referenceId;
+ freq.schema = 0;
(*a->init->bend_fetch)(a->backend, &freq);
/* backend should be able to signal whether error is system-wide
or only pertaining to current record */
oident *attset;
bend_scan_rr *bsrr = (bend_scan_rr *)
odr_malloc (assoc->encode, sizeof(*bsrr));
+ struct scan_entry *save_entries;
yaz_log(LOG_LOG, "Got ScanRequest");
bsrr->stream = assoc->encode;
bsrr->print = assoc->print;
bsrr->step_size = res->stepSize;
+ bsrr->entries = 0;
+ /* Note that version 2.0 of YAZ and older did not set entries ..
+ We do now. And when we do it's easier to extend the scan entry
+ We know that if the scan handler did set entries, it will
+ not know of new member display_term.
+ */
+ if (bsrr->num_entries > 0)
+ {
+ int i;
+ bsrr->entries = odr_malloc(assoc->decode, sizeof(*bsrr->entries) *
+ bsrr->num_entries);
+ for (i = 0; i<bsrr->num_entries; i++)
+ {
+ bsrr->entries[i].term = 0;
+ bsrr->entries[i].occurrences = 0;
+ bsrr->entries[i].errcode = 0;
+ bsrr->entries[i].errstring = 0;
+ bsrr->entries[i].display_term = 0;
+ }
+ }
+ save_entries = bsrr->entries; /* save it so we can compare later */
+
if (req->attributeSet &&
(attset = oid_getentbyoid(req->attributeSet)) &&
(attset->oclass == CLASS_ATTSET || attset->oclass == CLASS_GENERAL))
odr_malloc(assoc->encode, sizeof(*t));
t->suggestedAttributes = 0;
t->displayTerm = 0;
+ if (save_entries == bsrr->entries &&
+ bsrr->entries[i].display_term)
+ {
+ /* the entries was NOT set by the handler. So it's
+ safe to test for new member display_term. It is
+ NULL'ed by us.
+ */
+ t->displayTerm = odr_strdup(assoc->encode,
+ bsrr->entries[i].display_term);
+ }
t->alternativeTerm = 0;
t->byAttributes = 0;
t->otherTermInfo = 0;
res->num_diagnostics = 0;
res->diagnostics = 0;
}
+ res->resultCount = 0;
res->otherInfo = 0;
apdu->which = Z_APDU_sortResponse;
projects / yaz-moved-to-github.git / blobdiff