/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2010 Index Data
+ * Copyright (C) Index Data
* See the file LICENSE for details.
*/
/**
* minimize memory allocation/deallocation during normal operation.
*
*/
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
-#include <ctype.h>
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#include <libxml/tree.h>
#endif
-#include <yaz/yconfig.h>
+#include <yaz/facet.h>
#include <yaz/xmalloc.h>
#include <yaz/comstack.h>
#include "eventl.h"
#include <yaz/yaz-util.h>
#include <yaz/pquery.h>
#include <yaz/oid_db.h>
-
+#include <yaz/query-charset.h>
#include <yaz/srw.h>
#include <yaz/backend.h>
#include <yaz/yaz-ccl.h>
if (!logbits_set)
{
logbits_set = 1;
- log_session = yaz_log_module_level("session");
+ log_session = yaz_log_module_level("session");
log_sessiondetail = yaz_log_module_level("sessiondetail");
log_request = yaz_log_module_level("request");
- log_requestdetail = yaz_log_module_level("requestdetail");
+ log_requestdetail = yaz_log_module_level("requestdetail");
}
}
wrbuf_puts(w, "+");
wrbuf_puts_replace_char(w, addinfo, ' ', '_');
}
- wrbuf_puts(w, " ");
+ wrbuf_puts(w, " ");
}
static int odr_int_to_int(Odr_int v)
if (*apdufile == '@')
{
odr_setprint(anew->print, yaz_log_file());
- }
+ }
else if (*apdufile != '-')
{
char filename[256];
request_delq(&h->outgoing);
xfree(h);
xmalloc_trav("session closed");
- if (cb && cb->one_shot)
- {
- exit(0);
- }
}
static void do_close_req(association *a, int reason, char *message,
{
Z_APDU *apdu = zget_APDU(a->encode, Z_APDU_close);
Z_Close *cls = apdu->u.close;
-
+
/* Purge request queue */
while (request_deq(&a->incoming));
while (request_deq(&a->outgoing));
association *assoc = (association *)iochan_getdata(h);
COMSTACK conn = assoc->client_link;
request *req;
-
+
if ((assoc->cs_put_mask & EVENT_INPUT) == 0 && (event & assoc->cs_get_mask))
{
- yaz_log(YLOG_DEBUG, "ir_session (input)");
/* We aren't speaking to this fellow */
if (assoc->state == ASSOC_DEAD)
{
- yaz_log(log_sessiondetail, "Connection closed - end of session");
+ yaz_log(log_session, "Connection closed - end of session");
cs_close(conn);
destroy_association(assoc);
iochan_destroy(h);
yaz_log(log_session, "Connection error: %s res=%d",
cs_errmsg(cs_errno(conn)), res);
req = request_get(&assoc->incoming); /* get a new request */
- do_close_req(assoc, Z_Close_protocolError,
+ do_close_req(assoc, Z_Close_protocolError,
"Incoming package too large", req);
return 0;
}
else if (res <= 0)
{
- yaz_log(log_session, "Connection closed by client");
assoc->state = ASSOC_DEAD;
+ yaz_log(log_session, "Connection closed by client");
return 0;
}
else if (res == 1) /* incomplete read - wait for more */
return 0;
}
req->request_mem = odr_extract_mem(assoc->decode);
- if (assoc->print)
+ if (assoc->print)
{
if (!z_GDU(assoc->print, &req->gdu_request, 0, 0))
- yaz_log(YLOG_WARN, "ODR print error: %s",
+ yaz_log(YLOG_WARN, "ODR print error: %s",
odr_errmsg(odr_geterror(assoc->print)));
odr_reset(assoc->print);
}
* processing is initiated. Flow of control moves down through the
* various process_* functions below, until the encoded result comes back up
* to the output handler in here.
- *
+ *
* h : the I/O channel that has an outstanding event.
* event : the current outstanding event.
*/
return;
}
iochan_clearflag(h, EVENT_OUTPUT);
- if (conn->io_pending)
+ if (conn->io_pending)
{ /* cs_accept didn't complete */
- assoc->cs_accept_mask =
+ assoc->cs_accept_mask =
((conn->io_pending & CS_WANT_WRITE) ? EVENT_OUTPUT : 0) |
((conn->io_pending & CS_WANT_READ) ? EVENT_INPUT : 0);
yaz_log(YLOG_DEBUG, "HTTP out:\n%.*s", req->len_response,
req->response);
#endif
- nmem_destroy(req->request_mem);
request_deq(&assoc->outgoing);
request_release(req);
if (!request_head(&assoc->outgoing))
static int process_z_request(association *assoc, request *req, char **msg);
-static void assoc_init_reset(association *assoc)
+static void assoc_init_reset(association *assoc, const char *peer_name1)
{
+ const char *peer_name2 = cs_addrstr(assoc->client_link);
+
xfree(assoc->init);
assoc->init = (bend_initrequest *) xmalloc(sizeof(*assoc->init));
assoc->init->charneg_response = NULL;
assoc->init->decode = assoc->decode;
- assoc->init->peer_name =
- odr_strdup(assoc->encode, cs_addrstr(assoc->client_link));
+
+ assoc->init->peer_name = (char *)
+ odr_malloc(assoc->encode,
+ (peer_name1 ? strlen(peer_name1) : 0)
+ + 4 + strlen(peer_name2));
+ strcpy(assoc->init->peer_name, "");
+ if (peer_name1)
+ {
+ strcat(assoc->init->peer_name, peer_name1);
+ strcat(assoc->init->peer_name, ", ");
+ }
+ strcat(assoc->init->peer_name, peer_name2);
yaz_log(log_requestdetail, "peer %s", assoc->init->peer_name);
}
-static int srw_bend_init(association *assoc, Z_SRW_diagnostic **d, int *num, Z_SRW_PDU *sr)
+static int srw_bend_init(association *assoc, Z_HTTP_Header *headers,
+ Z_SRW_diagnostic **d, int *num, Z_SRW_PDU *sr)
{
statserv_options_block *cb = statserv_getcontrol();
if (!assoc->init)
bend_initresult *binitres;
yaz_log(log_requestdetail, "srw_bend_init config=%s", cb->configname);
- assoc_init_reset(assoc);
-
+ assoc_init_reset(assoc, z_HTTP_header_lookup(headers, "X-Forwarded-For"));
+
if (sr->username)
{
Z_IdAuthentication *auth = (Z_IdAuthentication *)
size_t len;
len = strlen(sr->username) + 1;
- if (sr->password)
+ if (sr->password)
len += strlen(sr->password) + 2;
+ yaz_log(log_requestdetail, "username=%s password-len=%ld",
+ sr->username, (long)
+ (sr->password ? strlen(sr->password) : 0));
auth->which = Z_IdAuthentication_open;
auth->u.open = (char *) odr_malloc(assoc->decode, len);
strcpy(auth->u.open, sr->username);
int r;
const char *input_schema = yaz_get_esn(rr->comp);
Odr_oid *input_syntax_raw = rr->request_format;
-
+
const char *backend_schema = 0;
Odr_oid *backend_syntax = 0;
rr->request_format = backend_syntax;
}
(*assoc->init->bend_fetch)(assoc->backend, rr);
- if (rc && rr->record && rr->errcode == 0 && rr->len > 0)
+ if (rc && rr->record && rr->errcode == 0)
{ /* post conversion must take place .. */
WRBUF output_record = wrbuf_alloc();
- int r = yaz_record_conv_record(rc, rr->record, rr->len, output_record);
- if (r)
- {
- const char *details = yaz_record_conv_get_error(rc);
- rr->errcode = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
- if (details)
- rr->errstring = odr_strdup(rr->stream, details);
+ int r = 1;
+ const char *details = 0;
+ if (rr->len > 0)
+ {
+ r = yaz_record_conv_record(rc, rr->record, rr->len, output_record);
+ if (r)
+ details = yaz_record_conv_get_error(rc);
+ }
+ else if (rr->len == -1 && rr->output_format &&
+ !oid_oidcmp(rr->output_format, yaz_oid_recsyn_opac))
+ {
+ r = yaz_record_conv_opac_record(
+ rc, (Z_OPACRecord *) rr->record, output_record);
+ if (r)
+ details = yaz_record_conv_get_error(rc);
+ }
+ if (r == 0 && match_syntax &&
+ !oid_oidcmp(match_syntax, yaz_oid_recsyn_opac))
+ {
+ yaz_marc_t mt = yaz_marc_create();
+ Z_OPACRecord *opac = 0;
+ if (yaz_xml_to_opac(mt, wrbuf_buf(output_record),
+ wrbuf_len(output_record),
+ &opac, 0 /* iconv */, rr->stream->mem, 0)
+ && opac)
+ {
+ rr->len = -1;
+ rr->record = (char *) opac;
+ }
+ else
+ {
+ details = "XML to OPAC conversion failed";
+ r = 1;
+ }
+ yaz_marc_destroy(mt);
}
- else
+ else if (r == 0)
{
rr->len = wrbuf_len(output_record);
rr->record = (char *) odr_malloc(rr->stream, rr->len);
memcpy(rr->record, wrbuf_buf(output_record), rr->len);
}
+ if (r)
+ {
+ rr->errcode = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
+ rr->surrogate_flag = 1;
+ if (details)
+ rr->errstring = odr_strdup(rr->stream, details);
+ }
wrbuf_destroy(output_record);
}
if (match_syntax)
static int srw_bend_fetch(association *assoc, int pos,
Z_SRW_searchRetrieveRequest *srw_req,
Z_SRW_record *record,
- const char **addinfo)
+ const char **addinfo, int *last_in_set)
{
bend_fetch_rr rr;
ODR o = assoc->encode;
odr_malloc(assoc->decode, sizeof(Z_CompSpec));
rr.comp->u.complex->selectAlternativeSyntax = (bool_t *)
odr_malloc(assoc->encode, sizeof(bool_t));
- *rr.comp->u.complex->selectAlternativeSyntax = 0;
+ *rr.comp->u.complex->selectAlternativeSyntax = 0;
rr.comp->u.complex->num_dbSpecific = 0;
rr.comp->u.complex->dbSpecific = 0;
- rr.comp->u.complex->num_recordSyntax = 0;
+ rr.comp->u.complex->num_recordSyntax = 0;
rr.comp->u.complex->recordSyntax = 0;
- rr.comp->u.complex->generic = (Z_Specification *)
+ rr.comp->u.complex->generic = (Z_Specification *)
odr_malloc(assoc->decode, sizeof(Z_Specification));
/* schema uri = recordSchema (or NULL if recordSchema is not given) */
rr.comp->u.complex->generic->elementSpec = 0;
if (srw_req->recordSchema)
{
- rr.comp->u.complex->generic->elementSpec =
+ rr.comp->u.complex->generic->elementSpec =
(Z_ElementSpec *) odr_malloc(assoc->encode, sizeof(Z_ElementSpec));
- rr.comp->u.complex->generic->elementSpec->which =
+ rr.comp->u.complex->generic->elementSpec->which =
Z_ElementSpec_elementSetName;
rr.comp->u.complex->generic->elementSpec->u.elementSetName =
srw_req->recordSchema;
}
-
+
rr.stream = assoc->encode;
rr.print = assoc->print;
retrieve_fetch(assoc, &rr);
+ *last_in_set = rr.last_in_set;
+
if (rr.errcode && rr.surrogate_flag)
{
int code = yaz_diag_bib1_to_srw(rr.errcode);
}
static int cql2pqf(ODR odr, const char *cql, cql_transform_t ct,
- Z_Query *query_result)
+ Z_Query *query_result, char **sortkeys_p)
{
/* have a CQL query and CQL to PQF transform .. */
CQL_parser cp = cql_parser_create();
int r;
int srw_errcode = 0;
const char *add = 0;
- char rpn_buf[5120];
-
+ WRBUF rpn_buf = wrbuf_alloc();
+
+ *sortkeys_p = 0;
r = cql_parser_string(cp, cql);
if (r)
{
}
if (!r)
{
+ struct cql_node *cn = cql_parser_result(cp);
+
/* Syntax OK */
- r = cql_transform_buf(ct,
- cql_parser_result(cp),
- rpn_buf, sizeof(rpn_buf)-1);
+ r = cql_transform(ct, cn, wrbuf_vp_puts, rpn_buf);
if (r)
srw_errcode = cql_transform_error(ct, &add);
+ else
+ {
+ char out[100];
+ int r = cql_sortby_to_sortkeys_buf(cn, out, sizeof(out)-1);
+
+ if (r == 0)
+ {
+ if (*out)
+ yaz_log(log_requestdetail, "srw_sortKeys '%s'", out);
+ *sortkeys_p = odr_strdup(odr, out);
+ }
+ else
+ {
+ yaz_log(log_requestdetail, "failed to create srw_sortKeys");
+ srw_errcode = YAZ_SRW_UNSUPP_SORT_TYPE;
+ }
+ }
}
if (!r)
{
/* Syntax & transform OK. */
/* Convert PQF string to Z39.50 to RPN query struct */
YAZ_PQF_Parser pp = yaz_pqf_create();
- Z_RPNQuery *rpnquery = yaz_pqf_parse(pp, odr, rpn_buf);
+ Z_RPNQuery *rpnquery = yaz_pqf_parse(pp, odr, wrbuf_cstr(rpn_buf));
if (!rpnquery)
{
size_t off;
yaz_pqf_destroy(pp);
}
cql_parser_destroy(cp);
+ wrbuf_destroy(rpn_buf);
return srw_errcode;
}
{
Z_Query query;
Z_RPNQuery *rpn;
- int srw_error = cql2pqf(odr, cql, ct, &query);
+ char *sortkeys = 0;
+ int srw_error = cql2pqf(odr, cql, ct, &query, &sortkeys);
if (srw_error)
return srw_error;
if (query.which != Z_Query_type_1 && query.which != Z_Query_type_101)
return YAZ_SRW_QUERY_SYNTAX_ERROR; /* bad query type */
rpn = query.u.type_1;
- if (!rpn->RPNStructure)
+ if (!rpn->RPNStructure)
return YAZ_SRW_QUERY_SYNTAX_ERROR; /* must be structure */
if (rpn->RPNStructure->which != Z_RPNStructure_simple)
return YAZ_SRW_QUERY_SYNTAX_ERROR; /* must be simple */
sizeof(*result));
return 0;
}
-
+
static int ccl2pqf(ODR odr, const Odr_oct *ccl, CCL_bibset bibset,
bend_search_rr *bsrr)
}
static void srw_bend_search(association *assoc,
+ Z_HTTP_Header *headers,
Z_SRW_PDU *sr,
Z_SRW_PDU *res,
int *http_code)
int srw_error = 0;
Z_External *ext;
Z_SRW_searchRetrieveRequest *srw_req = sr->u.request;
-
+
*http_code = 200;
yaz_log(log_requestdetail, "Got SRW SearchRetrieveRequest");
- srw_bend_init(assoc, &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
+ srw_bend_init(assoc, headers,
+ &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
if (srw_res->num_diagnostics == 0 && assoc->init)
{
bend_search_rr rr;
rr.query->u.type_1 = 0;
rr.extra_args = sr->extra_args;
rr.extra_response_data = 0;
-
- if (srw_req->query_type == Z_SRW_query_type_cql)
+ rr.present_number = srw_req->maximumRecords ?
+ *srw_req->maximumRecords : 0;
+
+ if (!srw_req->queryType || !strcmp(srw_req->queryType, "cql"))
{
if (assoc->server && assoc->server->cql_transform)
{
- int srw_errcode = cql2pqf(assoc->encode, srw_req->query.cql,
+ int srw_errcode = cql2pqf(assoc->encode, srw_req->query,
assoc->server->cql_transform,
- rr.query);
+ rr.query,
+ &rr.srw_sortKeys);
+
if (srw_errcode)
{
yaz_add_srw_diagnostic(assoc->encode,
{
/* CQL query to backend. Wrap it - Z39.50 style */
ext = (Z_External *) odr_malloc(assoc->decode, sizeof(*ext));
- ext->direct_reference = odr_getoidbystr(assoc->decode,
+ 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;
-
+ ext->u.cql = srw_req->query;
+
rr.query->which = Z_Query_type_104;
rr.query->u.type_104 = ext;
}
}
- else if (srw_req->query_type == Z_SRW_query_type_pqf)
+ else if (!strcmp(srw_req->queryType, "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);
+
+ RPNquery = yaz_pqf_parse(pqf_parser, assoc->decode, srw_req->query);
if (!RPNquery)
{
const char *pqf_msg;
code, pqf_msg, (long) off);
srw_error = YAZ_SRW_QUERY_SYNTAX_ERROR;
}
-
+
rr.query->which = Z_Query_type_1;
rr.query->u.type_1 = RPNquery;
-
+
yaz_pqf_destroy(pqf_parser);
}
else
rr.stream = assoc->encode;
rr.decode = assoc->decode;
rr.print = assoc->print;
- if ( srw_req->sort.sortKeys )
- rr.srw_sortKeys = odr_strdup(assoc->encode,
- srw_req->sort.sortKeys );
+ if (srw_req->sort.sortKeys)
+ rr.srw_sortKeys = odr_strdup(assoc->encode,
+ srw_req->sort.sortKeys);
rr.association = assoc;
rr.hits = 0;
rr.errcode = 0;
rr.errstring = 0;
rr.search_info = 0;
+ rr.search_input = 0;
+
+ if (srw_req->facetList)
+ yaz_oi_set_facetlist(&rr.search_input, assoc->encode,
+ srw_req->facetList);
+
yaz_log_zquery_level(log_requestdetail,rr.query);
-
+
(assoc->init->bend_search)(assoc->backend, &rr);
if (rr.errcode)
{
odr_int_to_int(*srw_req->maximumRecords) : 0;
int start = srw_req->startRecord ?
odr_int_to_int(*srw_req->startRecord) : 1;
-
+
yaz_log(log_requestdetail, "Request to pack %d+%d out of "
ODR_INT_PRINTF,
start, number, rr.hits);
-
+
srw_res->numberOfRecords = odr_intdup(assoc->encode, rr.hits);
if (rr.srw_setname)
{
srw_res->resultSetIdleTime =
odr_intdup(assoc->encode, *rr.srw_setnameIdleTime );
}
-
+
+ srw_res->facetList = yaz_oi_get_facetlist(&rr.search_info);
if (start > rr.hits || start < 1)
{
/* if hits<=0 and start=1 we don't return a diagnostic */
if (start != 1)
yaz_add_srw_diagnostic(
- assoc->encode,
+ assoc->encode,
&srw_res->diagnostics, &srw_res->num_diagnostics,
YAZ_SRW_FIRST_RECORD_POSITION_OUT_OF_RANGE, 0);
}
int ok = 1;
if (start + number > rr.hits)
number = odr_int_to_int(rr.hits) - start + 1;
-
+
/* Call bend_present if defined */
if (assoc->init->bend_present)
{
bprr->errcode = 0;
bprr->errstring = NULL;
(*assoc->init->bend_present)(assoc->backend, bprr);
-
+
if (bprr->errcode)
{
srw_error = yaz_diag_bib1_to_srw(bprr->errcode);
ok = 0;
}
}
-
+
if (ok)
{
int j = 0;
int packing = Z_SRW_recordPacking_string;
if (srw_req->recordPacking)
{
- packing =
+ packing =
yaz_srw_str_to_pack(srw_req->recordPacking);
if (packing == -1)
packing = Z_SRW_recordPacking_string;
srw_res->records = (Z_SRW_record *)
odr_malloc(assoc->encode,
number * sizeof(*srw_res->records));
-
+
srw_res->extra_records = (Z_SRW_extra_record **)
odr_malloc(assoc->encode,
number*sizeof(*srw_res->extra_records));
for (i = 0; i<number; i++)
{
int errcode;
+ int last_in_set = 0;
const char *addinfo = 0;
-
+
srw_res->records[j].recordPacking = packing;
srw_res->records[j].recordData_buf = 0;
srw_res->extra_records[j] = 0;
yaz_log(YLOG_DEBUG, "srw_bend_fetch %d", i+start);
errcode = srw_bend_fetch(assoc, i+start, srw_req,
srw_res->records + j,
- &addinfo);
+ &addinfo, &last_in_set);
if (errcode)
{
yaz_add_srw_diagnostic(assoc->encode,
&srw_res->num_diagnostics,
yaz_diag_bib1_to_srw(errcode),
addinfo);
-
+
break;
}
if (srw_res->records[j].recordData_buf)
j++;
+ if (last_in_set)
+ break;
}
srw_res->num_records = j;
if (!j)
res->extraResponseData_buf = rr.extra_response_data;
res->extraResponseData_len = strlen(rr.extra_response_data);
}
- if (rr.estimated_hit_count || rr.partial_resultset)
+ if (strcmp(res->srw_version, "2.") > 0)
+ {
+ if (rr.estimated_hit_count)
+ srw_res->resultCountPrecision =
+ odr_strdup(assoc->encode, "estimate");
+ else if (rr.partial_resultset)
+ srw_res->resultCountPrecision =
+ odr_strdup(assoc->encode, "minimum");
+ else
+ srw_res->resultCountPrecision =
+ odr_strdup(assoc->encode, "exact");
+ }
+ else if (rr.estimated_hit_count || rr.partial_resultset)
{
yaz_add_srw_diagnostic(
assoc->encode,
}
if (log_request)
{
- const char *querystr = "?";
- const char *querytype = "?";
WRBUF wr = wrbuf_alloc();
- switch (srw_req->query_type)
- {
- case Z_SRW_query_type_cql:
- querytype = "CQL";
- querystr = srw_req->query.cql;
- break;
- case Z_SRW_query_type_pqf:
- querytype = "PQF";
- querystr = srw_req->query.pqf;
- break;
- }
wrbuf_printf(wr, "SRWSearch %s ", srw_req->database);
if (srw_res->num_diagnostics)
wrbuf_printf(wr, "ERROR %s", srw_res->diagnostics[0].uri);
(srw_res->numberOfRecords ?
*srw_res->numberOfRecords : 0));
}
- wrbuf_printf(wr, " %s " ODR_INT_PRINTF " +%d",
+ wrbuf_printf(wr, " %s " ODR_INT_PRINTF "+%d",
(srw_res->resultSetId ?
srw_res->resultSetId : "-"),
- (srw_req->startRecord ? *srw_req->startRecord : 1),
+ (srw_req->startRecord ? *srw_req->startRecord : 1),
srw_res->num_records);
- yaz_log(log_request, "%s %s: %s", wrbuf_cstr(wr), querytype, querystr);
+ yaz_log(log_request, "%s %s: %s", wrbuf_cstr(wr), srw_req->queryType,
+ srw_req->query);
wrbuf_destroy(wr);
}
}
char *content;
ptr = xmlCopyNode(ptr, 1);
-
+
xmlDocSetRootElement(doc, ptr);
-
+
xmlDocDumpMemory(doc, &buf_out, &len);
content = (char*) odr_malloc(rr->stream, 1+len);
memcpy(content, buf_out, len);
content[len] = '\0';
-
+
xmlFree(buf_out);
xmlFreeDoc(doc);
rr->explain_buf = content;
}
static void srw_bend_explain(association *assoc,
+ Z_HTTP_Header *headers,
Z_SRW_PDU *sr,
Z_SRW_explainResponse *srw_res,
int *http_code)
{
Z_SRW_explainRequest *srw_req = sr->u.explain_request;
yaz_log(log_requestdetail, "Got SRW ExplainRequest");
- *http_code = 404;
- srw_bend_init(assoc, &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
+ srw_bend_init(assoc, headers,
+ &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
+ if (!assoc->init && srw_res->num_diagnostics == 0)
+ *http_code = 404;
if (assoc->init)
{
bend_explain_rr rr;
-
+
rr.stream = assoc->encode;
rr.decode = assoc->decode;
rr.print = assoc->print;
int packing = Z_SRW_recordPacking_string;
if (srw_req->recordPacking)
{
- packing =
+ packing =
yaz_srw_str_to_pack(srw_req->recordPacking);
if (packing == -1)
packing = Z_SRW_recordPacking_string;
}
static void srw_bend_scan(association *assoc,
+ Z_HTTP_Header *headers,
Z_SRW_PDU *sr,
- Z_SRW_scanResponse *srw_res,
+ Z_SRW_PDU *res,
int *http_code)
{
Z_SRW_scanRequest *srw_req = sr->u.scan_request;
+ Z_SRW_scanResponse *srw_res = res->u.scan_response;
yaz_log(log_requestdetail, "Got SRW ScanRequest");
*http_code = 200;
- srw_bend_init(assoc, &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
+ srw_bend_init(assoc, headers,
+ &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
if (srw_res->num_diagnostics == 0 && assoc->init)
{
int step_size = 0;
bsrr->step_size = &step_size;
bsrr->entries = 0;
bsrr->setname = 0;
+ bsrr->extra_args = sr->extra_args;
+ bsrr->extra_response_data = 0;
- if (bsrr->num_entries > 0)
+ if (bsrr->num_entries > 0)
{
int i;
- bsrr->entries = (struct scan_entry *)
+ bsrr->entries = (struct scan_entry *)
odr_malloc(assoc->decode, sizeof(*bsrr->entries) *
bsrr->num_entries);
for (i = 0; i<bsrr->num_entries; i++)
}
save_entries = bsrr->entries; /* save it so we can compare later */
- if (srw_req->query_type == Z_SRW_query_type_pqf &&
+ if (srw_req->queryType && !strcmp(srw_req->queryType, "pqf") &&
assoc->init->bend_scan)
{
YAZ_PQF_Parser pqf_parser = yaz_pqf_create();
-
+
bsrr->term = yaz_pqf_scan(pqf_parser, assoc->decode,
- &bsrr->attributeset,
- srw_req->scanClause.pqf);
+ &bsrr->attributeset,
+ srw_req->scanClause);
yaz_pqf_destroy(pqf_parser);
bsrr->scanClause = 0;
((int (*)(void *, bend_scan_rr *))
(*assoc->init->bend_scan))(assoc->backend, bsrr);
}
- else if (srw_req->query_type == Z_SRW_query_type_cql
+ else if ((!srw_req->queryType || !strcmp(srw_req->queryType, "cql"))
&& assoc->init->bend_scan && assoc->server
&& assoc->server->cql_transform)
{
bsrr->term = (Z_AttributesPlusTerm *)
odr_malloc(assoc->decode, sizeof(*bsrr->term));
srw_error = cql2pqf_scan(assoc->encode,
- srw_req->scanClause.cql,
+ srw_req->scanClause,
assoc->server->cql_transform,
bsrr->term);
if (srw_error)
(*assoc->init->bend_scan))(assoc->backend, bsrr);
}
}
- else if (srw_req->query_type == Z_SRW_query_type_cql
+ else if ((!srw_req->queryType || !strcmp(srw_req->queryType, "cql"))
&& assoc->init->bend_srw_scan)
{
bsrr->term = 0;
bsrr->attributeset = 0;
- bsrr->scanClause = srw_req->scanClause.cql;
+ bsrr->scanClause = srw_req->scanClause;
((int (*)(void *, bend_scan_rr *))
(*assoc->init->bend_srw_scan))(assoc->backend, bsrr);
}
&srw_res->num_diagnostics,
YAZ_SRW_UNSUPP_OPERATION, "scan");
}
+ if (bsrr->extra_response_data)
+ {
+ res->extraResponseData_buf = bsrr->extra_response_data;
+ res->extraResponseData_len = strlen(bsrr->extra_response_data);
+ }
if (bsrr->errcode)
{
int srw_error;
t->numberOfRecords =
odr_intdup(assoc->encode, bsrr->entries[i].occurrences);
t->displayTerm = 0;
- if (save_entries == bsrr->entries &&
+ 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,
+ t->displayTerm = odr_strdup(assoc->encode,
bsrr->entries[i].display_term);
}
t->whereInList = 0;
if (log_request)
{
WRBUF wr = wrbuf_alloc();
- const char *querytype = 0;
- const char *querystr = 0;
-
- switch(srw_req->query_type)
- {
- case Z_SRW_query_type_pqf:
- querytype = "PQF";
- querystr = srw_req->scanClause.pqf;
- break;
- case Z_SRW_query_type_cql:
- querytype = "CQL";
- querystr = srw_req->scanClause.cql;
- break;
- default:
- querytype = "UNKNOWN";
- querystr = "";
- }
-
wrbuf_printf(wr, "SRWScan %s ", srw_req->database);
if (srw_res->num_diagnostics)
wrbuf_printf(wr, "OK - - ");
wrbuf_printf(wr, ODR_INT_PRINTF "+" ODR_INT_PRINTF " ",
- (srw_req->responsePosition ?
+ (srw_req->responsePosition ?
*srw_req->responsePosition : 1),
(srw_req->maximumTerms ?
*srw_req->maximumTerms : 1));
/* there is no step size in SRU/W ??? */
- wrbuf_printf(wr, "%s: %s ", querytype, querystr);
+ wrbuf_printf(wr, "%s: %s ", srw_req->queryType, srw_req->scanClause);
yaz_log(log_request, "%s ", wrbuf_cstr(wr) );
wrbuf_destroy(wr);
}
}
static void srw_bend_update(association *assoc,
+ Z_HTTP_Header *headers,
Z_SRW_PDU *sr,
Z_SRW_updateResponse *srw_res,
int *http_code)
Z_SRW_updateRequest *srw_req = sr->u.update_request;
yaz_log(log_session, "SRWUpdate action=%s", srw_req->operation);
yaz_log(YLOG_DEBUG, "num_diag = %d", srw_res->num_diagnostics );
- *http_code = 404;
- srw_bend_init(assoc, &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
+ srw_bend_init(assoc, headers,
+ &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
+ if (!assoc->init && srw_res->num_diagnostics == 0)
+ *http_code = 404;
if (assoc->init)
{
bend_update_rr rr;
Z_SRW_extra_record *extra = srw_req->extra_record;
-
+
rr.stream = assoc->encode;
rr.print = assoc->print;
rr.num_bases = 1;
rr.uri = 0;
rr.message = 0;
rr.details = 0;
-
+
*http_code = 200;
if (rr.operation == 0)
{
if (srw_req->record)
{
rr.record_data = odr_strdupn(
- assoc->encode,
+ assoc->encode,
srw_req->record->recordData_buf,
srw_req->record->recordData_len );
}
if (extra && extra->extraRecordData_len)
{
rr.extra_record_data = odr_strdupn(
- assoc->encode,
+ assoc->encode,
extra->extraRecordData_buf,
extra->extraRecordData_len );
}
rr.record_id = srw_req->recordId;
else if (extra && extra->recordIdentifier)
rr.record_id = extra->recordIdentifier;
- else
+ else
{
yaz_add_sru_update_diagnostic(
assoc->encode, &srw_res->diagnostics,
YAZ_SRU_UPDATE_MISSING_MANDATORY_ELEMENT_RECORD_REJECTED,
"record");
}
- else
+ else
{
if (srw_req->record->recordSchema)
rr.record_schema = odr_strdup(
assoc->encode, srw_req->record->recordSchema);
if (srw_req->record->recordData_len )
{
- rr.record_data = odr_strdupn(assoc->encode,
+ rr.record_data = odr_strdupn(assoc->encode,
srw_req->record->recordData_buf,
srw_req->record->recordData_len );
}
- else
+ else
{
yaz_add_sru_update_diagnostic(
assoc->encode, &srw_res->diagnostics,
&srw_res->num_diagnostics,
- YAZ_SRU_UPDATE_MISSING_MANDATORY_ELEMENT_RECORD_REJECTED,
+ YAZ_SRU_UPDATE_MISSING_MANDATORY_ELEMENT_RECORD_REJECTED,
"recordData" );
}
}
if (extra && extra->extraRecordData_len)
{
rr.extra_record_data = odr_strdupn(
- assoc->encode,
+ assoc->encode,
extra->extraRecordData_buf,
extra->extraRecordData_len );
}
else if (!strcmp(rr.operation, "insert"))
{
if (srw_req->recordId)
- rr.record_id = srw_req->recordId;
+ rr.record_id = srw_req->recordId;
else if (extra)
rr.record_id = extra->recordIdentifier;
-
+
if (srw_req->record)
{
if (srw_req->record->recordSchema)
rr.record_schema = odr_strdup(
assoc->encode, srw_req->record->recordSchema);
-
+
if (srw_req->record->recordData_len)
rr.record_data = odr_strdupn(
- assoc->encode,
+ assoc->encode,
srw_req->record->recordData_buf,
srw_req->record->recordData_len );
}
if (extra && extra->extraRecordData_len)
{
rr.extra_record_data = odr_strdupn(
- assoc->encode,
+ assoc->encode,
extra->extraRecordData_buf,
extra->extraRecordData_len );
}
}
- else
+ else
yaz_add_sru_update_diagnostic(assoc->encode, &srw_res->diagnostics,
&srw_res->num_diagnostics,
YAZ_SRU_UPDATE_INVALID_ACTION,
if (srw_req->record)
{
- const char *pack_str =
+ const char *pack_str =
yaz_srw_pack_to_str(srw_req->record->recordPacking);
if (pack_str)
rr.record_packing = odr_strdup(assoc->encode, pack_str);
{
if ( assoc->init->bend_srw_update)
(*assoc->init->bend_srw_update)(assoc->backend, &rr);
- else
+ else
yaz_add_sru_update_diagnostic(
assoc->encode, &srw_res->diagnostics,
&srw_res->num_diagnostics,
yaz_add_srw_diagnostic_uri(assoc->encode,
&srw_res->diagnostics,
&srw_res->num_diagnostics,
- rr.uri,
+ rr.uri,
rr.message,
rr.details);
srw_res->recordId = rr.record_id;
srw_res->record->recordData_len = strlen(rr.record_data);
if (rr.extra_record_data)
{
- Z_SRW_extra_record *ex =
+ Z_SRW_extra_record *ex =
yaz_srw_get_extra_record(assoc->encode);
srw_res->extra_record = ex;
ex->extraRecordData_buf = rr.extra_record_data;
if (fread(buf, 1, *sz, inf) != *sz)
yaz_log(YLOG_WARN|YLOG_ERRNO, "short read %s", fname);
fclose(inf);
- return buf;
+ return buf;
}
static void process_http_request(association *assoc, request *req)
r = 1;
}
if (r == 2 && assoc->server && assoc->server->docpath
- && hreq->path[0] == '/'
- &&
+ && hreq->path[0] == '/'
+ &&
/* check if path is a proper prefix of documentroot */
strncmp(hreq->path+1, assoc->server->docpath,
strlen(assoc->server->docpath))
== 0)
- {
+ {
if (!check_path(hreq->path))
{
yaz_log(YLOG_LOG, "File %s access forbidden", hreq->path+1);
{
const char *ctype = 0;
yaz_mime_types types = yaz_mime_types_create();
-
+
yaz_mime_types_add(types, "xsl", "application/xml");
yaz_mime_types_add(types, "xml", "application/xml");
yaz_mime_types_add(types, "css", "text/css");
yaz_mime_types_add(types, "htm", "text/html");
yaz_mime_types_add(types, "txt", "text/plain");
yaz_mime_types_add(types, "js", "application/x-javascript");
-
+
yaz_mime_types_add(types, "gif", "image/gif");
yaz_mime_types_add(types, "png", "image/png");
yaz_mime_types_add(types, "jpg", "image/jpeg");
yaz_mime_types_add(types, "jpeg", "image/jpeg");
-
+
ctype = yaz_mime_lookup_fname(types, hreq->path);
if (!ctype)
{
if (sr->which == Z_SRW_searchRetrieve_request)
{
Z_SRW_PDU *res =
- yaz_srw_get_pdu(assoc->encode, Z_SRW_searchRetrieve_response,
- sr->srw_version);
+ yaz_srw_get_pdu_e(assoc->encode, Z_SRW_searchRetrieve_response,
+ sr);
stylesheet = sr->u.request->stylesheet;
if (num_diagnostic)
{
}
else
{
- srw_bend_search(assoc, sr, res, &http_code);
+ srw_bend_search(assoc, hreq->headers, sr, res, &http_code);
}
if (http_code == 200)
soap_package->u.generic->p = res;
}
else if (sr->which == Z_SRW_explain_request)
{
- Z_SRW_PDU *res = yaz_srw_get_pdu(o, Z_SRW_explain_response,
- sr->srw_version);
+ Z_SRW_PDU *res = yaz_srw_get_pdu_e(o, Z_SRW_explain_response, sr);
stylesheet = sr->u.explain_request->stylesheet;
if (num_diagnostic)
- {
+ {
res->u.explain_response->diagnostics = diagnostic;
res->u.explain_response->num_diagnostics = num_diagnostic;
}
- srw_bend_explain(assoc, sr, res->u.explain_response, &http_code);
+ srw_bend_explain(assoc, hreq->headers,
+ sr, res->u.explain_response, &http_code);
if (http_code == 200)
soap_package->u.generic->p = res;
}
else if (sr->which == Z_SRW_scan_request)
{
- Z_SRW_PDU *res = yaz_srw_get_pdu(o, Z_SRW_scan_response,
- sr->srw_version);
+ Z_SRW_PDU *res = yaz_srw_get_pdu_e(o, Z_SRW_scan_response, sr);
stylesheet = sr->u.scan_request->stylesheet;
if (num_diagnostic)
- {
+ {
res->u.scan_response->diagnostics = diagnostic;
res->u.scan_response->num_diagnostics = num_diagnostic;
}
- srw_bend_scan(assoc, sr, res->u.scan_response, &http_code);
+ srw_bend_scan(assoc, hreq->headers, sr, res, &http_code);
if (http_code == 200)
soap_package->u.generic->p = res;
}
sr->srw_version);
yaz_log(YLOG_DEBUG, "handling SRW UpdateRequest");
if (num_diagnostic)
- {
+ {
res->u.update_response->diagnostics = diagnostic;
res->u.update_response->num_diagnostics = num_diagnostic;
}
yaz_log(YLOG_DEBUG, "num_diag = %d", res->u.update_response->num_diagnostics );
- srw_bend_update(assoc, sr, res->u.update_response, &http_code);
+ srw_bend_update(assoc, hreq->headers,
+ sr, res->u.update_response, &http_code);
if (http_code == 200)
soap_package->u.generic->p = res;
}
else
{
- yaz_log(log_request, "SOAP ERROR");
+ yaz_log(log_request, "SOAP ERROR");
/* FIXME - what error, what query */
http_code = 500;
z_soap_error(assoc->encode, soap_package,
- "SOAP-ENV:Client", "Bad method", 0);
+ "SOAP-ENV:Client", "Bad method", 0);
}
if (http_code == 200 || http_code == 500)
{
{0, 0, 0}
};
char ctype[80];
- int ret;
p = z_get_HTTP_Response(o, 200);
hres = p->u.HTTP_Response;
if (stylesheet && *stylesheet == '\0')
stylesheet = 0;
- ret = z_soap_codec_enc_xsl(assoc->encode, &soap_package,
- &hres->content_buf, &hres->content_len,
- soap_handlers, charset, stylesheet);
+ z_soap_codec_enc_xsl(assoc->encode, &soap_package,
+ &hres->content_buf, &hres->content_len,
+ soap_handlers, charset, stylesheet);
hres->code = http_code;
strcpy(ctype, "text/xml");
- if (charset && strlen(charset) < sizeof(ctype)-30)
- {
- strcat(ctype, "; charset=");
- strcat(ctype, charset);
- }
z_HTTP_header_add(o, &hres->headers, "Content-Type", ctype);
}
else
if (p == 0)
p = z_get_HTTP_Response(o, 500);
hres = p->u.HTTP_Response;
- if (!strcmp(hreq->version, "1.0"))
+ if (!strcmp(hreq->version, "1.0"))
{
const char *v = z_HTTP_header_lookup(hreq->headers, "Connection");
if (v && !strcmp(v, "Keep-Alive"))
keepalive = 1;
hres->version = "1.1";
}
- if (!keepalive)
+ if (!keepalive || !assoc->last_control->keepalive)
{
z_HTTP_header_add(o, &hres->headers, "Connection", "close");
assoc->state = ASSOC_DEAD;
int t;
const char *alive = z_HTTP_header_lookup(hreq->headers, "Keep-Alive");
- if (alive && isdigit(*(const unsigned char *) alive))
+ if (alive && yaz_isdigit(*(const unsigned char *) alive))
t = atoi(alive);
else
t = 15;
{
Z_APDU *res;
int retval;
-
+
*msg = "Unknown Error";
assert(req && req->state == REQUEST_IDLE);
if (req->apdu_request->which != Z_APDU_initRequest && !assoc->init)
}
else
{
- yaz_log(YLOG_DEBUG, " result unavailble");
+ yaz_log(YLOG_DEBUG, " result unavailable");
retval = -1;
}
return retval;
if (assoc->print)
{
if (!z_GDU(assoc->print, &res, 0, 0))
- yaz_log(YLOG_WARN, "ODR print error: %s",
+ yaz_log(YLOG_WARN, "ODR print error: %s",
odr_errmsg(odr_geterror(assoc->print)));
odr_reset(assoc->print);
}
if (req->implementationVersion)
yaz_log(log_requestdetail, "Version: %s",
req->implementationVersion);
-
- assoc_init_reset(assoc);
+ assoc_init_reset(assoc,
+ yaz_oi_get_string_oid(&req->otherInfo,
+ yaz_oid_userinfo_client_ip, 1, 0));
assoc->init->auth = req->idAuthentication;
assoc->init->referenceId = req->referenceId;
if (req->implementationVersion)
yaz_log(log_requestdetail, "Config: %s",
cb->configname);
-
- iochan_settimeout(assoc->client_chan, cb->idle_timeout * 60);
-
+
+ iochan_settimeout(assoc->client_chan, cb->idle_timeout);
+
/* we have a backend control block, so call that init function */
if (!(binitres = (*cb->bend_init)(assoc->init)))
{
if ((assoc->init->bend_search))
yaz_log(YLOG_DEBUG, "Search handler installed");
if ((assoc->init->bend_present))
- yaz_log(YLOG_DEBUG, "Present handler installed");
+ yaz_log(YLOG_DEBUG, "Present handler installed");
if ((assoc->init->bend_esrequest))
- yaz_log(YLOG_DEBUG, "ESRequest handler installed");
+ yaz_log(YLOG_DEBUG, "ESRequest handler installed");
if ((assoc->init->bend_delete))
- yaz_log(YLOG_DEBUG, "Delete handler installed");
+ yaz_log(YLOG_DEBUG, "Delete handler installed");
if ((assoc->init->bend_scan))
- yaz_log(YLOG_DEBUG, "Scan handler installed");
+ yaz_log(YLOG_DEBUG, "Scan handler installed");
if ((assoc->init->bend_segment))
- yaz_log(YLOG_DEBUG, "Segment handler installed");
-
+ yaz_log(YLOG_DEBUG, "Segment handler installed");
+
resp->referenceId = req->referenceId;
*options = '\0';
/* let's tell the client what we can do */
ODR_MASK_SET(resp->options, Z_Options_sort);
strcat(options, " sort");
}
-
+
if (ODR_MASK_GET(req->options, Z_Options_negotiationModel))
{
Z_OtherInformationUnit *p0;
if (assoc->init->query_charset)
{
assoc->init->charneg_response = yaz_set_response_charneg(
- assoc->encode, assoc->init->query_charset, 0,
+ assoc->encode, assoc->init->query_charset, 0,
assoc->init->records_in_same_charset);
}
else
resp->preferredMessageSize =
odr_intdup(assoc->encode, assoc->preferredMessageSize);
- resp->maximumRecordSize =
+ resp->maximumRecordSize =
odr_intdup(assoc->encode, assoc->maximumRecordSize);
resp->implementationId = odr_prepend(assoc->encode,
assoc->init->implementation_id,
resp->implementationId);
+ resp->implementationVersion = odr_prepend(assoc->encode,
+ assoc->init->implementation_version,
+ resp->implementationVersion);
+
resp->implementationName = odr_prepend(assoc->encode,
assoc->init->implementation_name,
odr_prepend(assoc->encode, "GFS", resp->implementationName));
}
else
assoc->state = ASSOC_UP;
-
+
if (log_request)
{
if (!req->idAuthentication)
yaz_log(log_request, "Auth idPass %s %s",
user ? user : "-", group ? group : "-");
}
- else if (req->idAuthentication->which
+ else if (req->idAuthentication->which
== Z_IdAuthentication_anonymous)
{
yaz_log(log_request, "Auth anonymous");
else
wrbuf_printf(wr, "OK -");
wrbuf_printf(wr, " ID:%s Name:%s Version:%s",
- (req->implementationId ? req->implementationId :"-"),
+ (req->implementationId ? req->implementationId :"-"),
(req->implementationName ?
req->implementationName : "-"),
(req->implementationVersion ?
/*
* surrogate diagnostic.
*/
-static Z_NamePlusRecord *surrogatediagrec(association *assoc,
+static Z_NamePlusRecord *surrogatediagrec(association *assoc,
const char *dbname,
int error, const char *addinfo)
{
Z_ReferenceId *referenceId,
Odr_oid *oid, int *errcode)
{
- int recno, total_length = 0, dumped_records = 0;
+ int recno;
+ Odr_int dumped_records = 0;
int toget = odr_int_to_int(*num);
Z_Records *records =
(Z_Records *) odr_malloc(a->encode, sizeof(*records));
{
bend_fetch_rr freq;
Z_NamePlusRecord *thisrec;
- int this_length = 0;
+ Odr_int this_length = 0;
/*
* we get the number of bytes allocated on the stream before any
* allocation done by the backend - this should give us a reasonable
* idea of the total size of the data so far.
*/
- total_length = odr_total(a->encode) - dumped_records;
+ Odr_int total_length = odr_total(a->encode) - dumped_records;
freq.errcode = 0;
freq.errstring = 0;
freq.basename = 0;
*pres = Z_PresentStatus_failure;
/* for 'present request out of range',
set addinfo to record position if not set */
- if (freq.errcode == YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE &&
+ if (freq.errcode == YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE &&
freq.errstring == 0)
{
sprintf(s, "%d", recno);
}
if (freq.record == 0) /* no error and no record ? */
{
+ *pres = Z_PresentStatus_partial_4;
*next = 0; /* signal end-of-set and stop */
break;
}
this_length = freq.len;
else
this_length = odr_total(a->encode) - total_length - dumped_records;
- yaz_log(YLOG_DEBUG, " fetched record, len=%d, total=%d dumped=%d",
- this_length, total_length, dumped_records);
+ yaz_log(log_requestdetail, " fetched record, len=" ODR_INT_PRINTF
+ " total=" ODR_INT_PRINTF " dumped=" ODR_INT_PRINTF,
+ this_length, total_length, dumped_records);
if (a->preferredMessageSize > 0 &&
- this_length + total_length > a->preferredMessageSize)
+ this_length + total_length > a->preferredMessageSize)
{
/* record is small enough, really */
if (this_length <= a->preferredMessageSize && recno > start)
{
yaz_log(log_requestdetail, " Dropped last normal-sized record");
*pres = Z_PresentStatus_partial_2;
+ if (*next > 0)
+ (*next)--;
break;
}
/* record can only be fetched by itself */
{
yaz_log(YLOG_DEBUG, " Dropped it");
reclist->records[reclist->num_records] =
- surrogatediagrec(a, freq.basename, 16, 0);
+ surrogatediagrec(
+ a, freq.basename,
+ YAZ_BIB1_RECORD_EXCEEDS_PREFERRED_MESSAGE_SIZE, 0);
reclist->num_records++;
dumped_records += this_length;
continue;
else /* too big entirely */
{
yaz_log(log_requestdetail, "Record > maxrcdsz "
- "this=%d max=%d",
+ "this=" ODR_INT_PRINTF " max=%d",
this_length, a->maximumRecordSize);
reclist->records[reclist->num_records] =
- surrogatediagrec(a, freq.basename, 17, 0);
+ surrogatediagrec(
+ a, freq.basename,
+ YAZ_BIB1_RECORD_EXCEEDS_MAXIMUM_RECORD_SIZE, 0);
reclist->num_records++;
dumped_records += this_length;
continue;
thisrec->which = Z_NamePlusRecord_databaseRecord;
if (!freq.output_format)
- freq.output_format = freq.request_format;
+ {
+ yaz_log(YLOG_WARN, "bend_fetch output_format not set");
+ return 0;
+ }
thisrec->u.databaseRecord = z_ext_record_oid(
a->encode, freq.output_format, freq.record, freq.len);
if (!thisrec->u.databaseRecord)
return 0;
reclist->records[reclist->num_records] = thisrec;
reclist->num_records++;
+ if (freq.last_in_set)
+ break;
}
*num = reclist->num_records;
return records;
static Z_APDU *process_searchRequest(association *assoc, request *reqb)
{
Z_SearchRequest *req = reqb->apdu_request->u.searchRequest;
- bend_search_rr *bsrr =
+ bend_search_rr *bsrr =
(bend_search_rr *)nmem_malloc(reqb->request_mem, sizeof(*bsrr));
-
+
yaz_log(log_requestdetail, "Got SearchRequest.");
bsrr->association = assoc;
bsrr->referenceId = req->referenceId;
bsrr->extra_args = 0;
bsrr->extra_response_data = 0;
- yaz_log (log_requestdetail, "ResultSet '%s'", req->resultSetName);
+ yaz_log(log_requestdetail, "ResultSet '%s'", req->resultSetName);
if (req->databaseNames)
{
int i;
bsrr->errcode = 0;
bsrr->errstring = NULL;
bsrr->search_info = NULL;
+ bsrr->search_input = req->additionalSearchInfo;
+ if (!bsrr->search_input)
+ bsrr->search_input = req->otherInfo;
+ bsrr->present_number = *req->mediumSetPresentNumber;
- if (assoc->server && assoc->server->cql_transform
+ if (assoc->server && assoc->server->client_query_charset &&
+ req->query->which == Z_Query_type_1)
+ {
+ yaz_iconv_t cd =
+ yaz_iconv_open("UTF-8", assoc->server->client_query_charset);
+ if (cd)
+ {
+ yaz_query_charset_convert_rpnquery(req->query->u.type_1,
+ assoc->decode, cd);
+ yaz_iconv_close(cd);
+ }
+ }
+
+ if (assoc->server && assoc->server->cql_transform
&& req->query->which == Z_Query_type_104
&& req->query->u.type_104->which == Z_External_CQL)
{
/* have a CQL query and a CQL to PQF transform .. */
- int srw_errcode =
+ int srw_errcode =
cql2pqf(bsrr->stream, req->query->u.type_104->u.cql,
- assoc->server->cql_transform, bsrr->query);
+ assoc->server->cql_transform, bsrr->query,
+ &bsrr->srw_sortKeys);
if (srw_errcode)
bsrr->errcode = yaz_diag_srw_to_bib1(srw_errcode);
}
- if (assoc->server && assoc->server->ccl_transform
+ if (assoc->server && assoc->server->ccl_transform
&& req->query->which == Z_Query_type_2) /*CCL*/
{
/* have a CCL query and a CCL to PQF transform .. */
- int srw_errcode =
+ int srw_errcode =
ccl2pqf(bsrr->stream, req->query->u.type_2,
assoc->server->ccl_transform, bsrr);
if (srw_errcode)
(assoc->init->bend_search)(assoc->backend, bsrr);
}
else
- {
+ {
/* FIXME - make a diagnostic for it */
yaz_log(YLOG_WARN,"Search not supported ?!?!");
}
resp->resultSetStatus = 0;
if (bsrt->estimated_hit_count)
{
- resp->resultSetStatus = odr_intdup(assoc->encode,
+ resp->resultSetStatus = odr_intdup(assoc->encode,
Z_SearchResponse_estimate);
}
else if (bsrt->partial_resultset)
{
- resp->resultSetStatus = odr_intdup(assoc->encode,
+ resp->resultSetStatus = odr_intdup(assoc->encode,
Z_SearchResponse_subset);
}
}
wrbuf_puts(wr, req->databaseNames[i]);
}
wrbuf_printf(wr, " ");
-
+
if (bsrt->errcode)
wrbuf_printf(wr, "ERROR %d", bsrt->errcode);
else
wrbuf_printf(wr, " %s 1+" ODR_INT_PRINTF " ",
req->resultSetName, returnedrecs);
yaz_query_to_wrbuf(wr, req->query);
-
+
yaz_log(log_request, "Search %s", wrbuf_cstr(wr));
wrbuf_destroy(wr);
}
Odr_int *next;
Odr_int *num;
int errcode = 0;
- const char *errstring = 0;
yaz_log(log_requestdetail, "Got PresentRequest.");
bprr->errcode = 0;
bprr->errstring = NULL;
(*assoc->init->bend_present)(assoc->backend, bprr);
-
+
if (bprr->errcode)
{
resp->records = diagrec(assoc, bprr->errcode, bprr->errstring);
*resp->presentStatus = Z_PresentStatus_failure;
errcode = bprr->errcode;
- errstring = bprr->errstring;
}
}
apdu = (Z_APDU *)odr_malloc(assoc->encode, sizeof(*apdu));
next = odr_intdup(assoc->encode, 0);
num = odr_intdup(assoc->encode, 0);
-
+
apdu->which = Z_APDU_presentResponse;
apdu->u.presentResponse = resp;
resp->referenceId = req->referenceId;
resp->otherInfo = 0;
-
+
if (!resp->records)
{
*num = *req->numberOfRecordsRequested;
pack_records(assoc, req->resultSetId, *req->resultSetStartPoint,
num, req->recordComposition, next,
resp->presentStatus,
- req->referenceId, req->preferredRecordSyntax,
+ req->referenceId, req->preferredRecordSyntax,
&errcode);
}
if (log_request)
return 0;
resp->numberOfRecordsReturned = num;
resp->nextResultSetPosition = next;
-
+
return apdu;
}
if (req->stepSize)
step_size = odr_int_to_int(*req->stepSize);
+ res->stepSize = 0;
res->scanStatus = scanStatus;
res->numberOfEntriesReturned = numberOfEntriesReturned;
res->positionOfTerm = 0;
bsrr->stream = assoc->encode;
bsrr->print = assoc->print;
bsrr->step_size = &step_size;
- bsrr->setname = yaz_oi_get_string_oid(&req->otherInfo,
+ bsrr->setname = yaz_oi_get_string_oid(&req->otherInfo,
yaz_oid_userinfo_scan_set, 1, 0);
bsrr->entries = 0;
+ bsrr->extra_args = 0;
+ bsrr->extra_response_data = 0;
/* For YAZ 2.0 and earlier it was the backend handler that
initialized entries (member display_term did not exist)
YAZ 2.0 and later sets 'entries' and initialize all members
entries was modified - we assume that it is an old handler and
that 'display_term' is _not_ set.
*/
- if (bsrr->num_entries > 0)
+ if (bsrr->num_entries > 0)
{
int i;
bsrr->entries = (struct scan_entry *)
save_entries = bsrr->entries; /* save it so we can compare later */
bsrr->attributeset = req->attributeSet;
- log_scan_term_level(log_requestdetail, req->termListAndStartPoint,
+ log_scan_term_level(log_requestdetail, req->termListAndStartPoint,
bsrr->attributeset);
bsrr->term_position = req->preferredPositionInResponse ?
odr_int_to_int(*req->preferredPositionInResponse) : 1;
int i;
Z_Entry **tab = (Z_Entry **)
odr_malloc(assoc->encode, sizeof(*tab) * bsrr->num_entries);
-
+
if (bsrr->status == BEND_SCAN_PARTIAL)
*scanStatus = Z_Scan_partial_5;
else
res->stepSize = odr_intdup(assoc->encode, step_size);
ents->entries = tab;
ents->num_entries = bsrr->num_entries;
- res->numberOfEntriesReturned = odr_intdup(assoc->encode,
+ res->numberOfEntriesReturned = odr_intdup(assoc->encode,
ents->num_entries);
res->positionOfTerm = odr_intdup(assoc->encode, bsrr->term_position);
for (i = 0; i < bsrr->num_entries; i++)
{
Z_Entry *e;
Z_TermInfo *t;
- Odr_oct *o;
-
+
tab[i] = e = (Z_Entry *)odr_malloc(assoc->encode, sizeof(*e));
if (bsrr->entries[i].occurrences >= 0)
{
odr_malloc(assoc->encode, sizeof(*t));
t->suggestedAttributes = 0;
t->displayTerm = 0;
- if (save_entries == bsrr->entries &&
+ if (save_entries == bsrr->entries &&
bsrr->entries[i].display_term)
{
/* the entries was _not_ set by the handler. So it's
t->term = (Z_Term *)
odr_malloc(assoc->encode, sizeof(*t->term));
t->term->which = Z_Term_general;
- t->term->u.general = o =
- (Odr_oct *)odr_malloc(assoc->encode, sizeof(Odr_oct));
- o->buf = (unsigned char *)
- odr_malloc(assoc->encode, o->len = o->size =
- strlen(bsrr->entries[i].term));
- memcpy(o->buf, bsrr->entries[i].term, o->len);
+ t->term->u.general =
+ odr_create_Odr_oct(assoc->encode,
+ bsrr->entries[i].term,
+ strlen(bsrr->entries[i].term));
yaz_log(YLOG_DEBUG, " term #%d: '%s' (" ODR_INT_PRINTF ")", i,
bsrr->entries[i].term, bsrr->entries[i].occurrences);
}
}
wrbuf_printf(wr, " ");
-
+
if (bsrr->errcode)
wr_diag(wr, bsrr->errcode, bsrr->errstring);
else
- wrbuf_printf(wr, "OK");
+ wrbuf_printf(wr, "OK");
- wrbuf_printf(wr, " " ODR_INT_PRINTF " - " ODR_INT_PRINTF "+"
+ wrbuf_printf(wr, " " ODR_INT_PRINTF " - " ODR_INT_PRINTF "+"
ODR_INT_PRINTF "+" ODR_INT_PRINTF,
res->numberOfEntriesReturned ?
*res->numberOfEntriesReturned : 0,
*req->preferredPositionInResponse : 1),
*req->numberOfTermsRequested,
(res->stepSize ? *res->stepSize : 1));
-
+
if (bsrr->setname)
wrbuf_printf(wr, "+%s", bsrr->setname);
wrbuf_printf(wr, " ");
- yaz_scan_to_wrbuf(wr, req->termListAndStartPoint,
+ yaz_scan_to_wrbuf(wr, req->termListAndStartPoint,
bsrr->attributeset);
yaz_log(log_request, "%s", wrbuf_cstr(wr) );
wrbuf_destroy(wr);
bsrr->sort_status = Z_SortResponse_failure;
bsrr->errcode = 0;
bsrr->errstring = 0;
-
+
(*assoc->init->bend_sort)(assoc->backend, bsrr);
-
+
res->referenceId = bsrr->referenceId;
res->sortStatus = odr_intdup(assoc->encode, bsrr->sort_status);
res->resultSetStatus = 0;
bdrr->statuses = 0;
if (bdrr->num_setnames > 0)
{
- bdrr->statuses = (int*)
+ bdrr->statuses = (int*)
odr_malloc(assoc->encode, sizeof(*bdrr->statuses) *
bdrr->num_setnames);
for (i = 0; i < bdrr->num_setnames; i++)
bdrr->statuses[i] = 0;
}
(*assoc->init->bend_delete)(assoc->backend, bdrr);
-
+
res->referenceId = req->referenceId;
res->deleteOperationStatus = odr_intdup(assoc->encode,bdrr->delete_status);
res->deleteListStatuses->num = bdrr->num_setnames;
res->deleteListStatuses->elements =
(Z_ListStatus **)
- odr_malloc(assoc->encode,
+ odr_malloc(assoc->encode,
sizeof(*res->deleteListStatuses->elements) *
bdrr->num_setnames);
for (i = 0; i<bdrr->num_setnames; i++)
req.decode = assoc->decode;
req.print = assoc->print;
req.association = assoc;
-
+
(*assoc->init->bend_segment)(assoc->backend, &req);
return 0;
esrequest.association = assoc;
esrequest.taskPackage = 0;
esrequest.referenceId = req->referenceId;
-
+
if (esrequest.esr && esrequest.esr->taskSpecificParameters)
{
switch(esrequest.esr->taskSpecificParameters->which)
}
(*assoc->init->bend_esrequest)(assoc->backend, &esrequest);
-
+
resp->referenceId = req->referenceId;
if (esrequest.errcode == -1)
projects / yaz-moved-to-github.git / blobdiff