/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2008 Index Data
+ * Copyright (C) 1995-2010 Index Data
* See the file LICENSE for details.
*/
/**
*
*/
+#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
static void process_gdu_request(association *assoc, request *req);
static int process_z_request(association *assoc, request *req, char **msg);
-void backend_response(IOCHAN i, int event);
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,
const char *errstring);
-static Z_APDU *process_searchRequest(association *assoc, request *reqb,
- int *fd);
+static Z_APDU *process_searchRequest(association *assoc, request *reqb);
static Z_APDU *response_searchRequest(association *assoc, request *reqb,
- bend_search_rr *bsrr, int *fd);
-static Z_APDU *process_presentRequest(association *assoc, request *reqb,
- int *fd);
-static Z_APDU *process_scanRequest(association *assoc, request *reqb, int *fd);
-static Z_APDU *process_sortRequest(association *assoc, request *reqb, int *fd);
+ bend_search_rr *bsrr);
+static Z_APDU *process_presentRequest(association *assoc, request *reqb);
+static Z_APDU *process_scanRequest(association *assoc, request *reqb);
+static Z_APDU *process_sortRequest(association *assoc, request *reqb);
static void process_close(association *assoc, request *reqb);
-void save_referenceId(request *reqb, Z_ReferenceId *refid);
-static Z_APDU *process_deleteRequest(association *assoc, request *reqb,
- int *fd);
+static Z_APDU *process_deleteRequest(association *assoc, request *reqb);
static Z_APDU *process_segmentRequest(association *assoc, request *reqb);
-
-static Z_APDU *process_ESRequest(association *assoc, request *reqb, int *fd);
+static Z_APDU *process_ESRequest(association *assoc, request *reqb);
/* dynamic logging levels */
static int logbits_set = 0;
}
}
-
-
static void wr_diag(WRBUF w, int error, const char *addinfo)
{
wrbuf_printf(w, "ERROR %d+", error);
wrbuf_puts_replace_char(w, diagbib1_str(error), ' ', '_');
- if (addinfo){
+ if (addinfo)
+ {
wrbuf_puts(w, "+");
wrbuf_puts_replace_char(w, addinfo, ' ', '_');
}
-
wrbuf_puts(w, " ");
}
+static int odr_int_to_int(Odr_int v)
+{
+ if (v >= INT_MAX)
+ return INT_MAX;
+ else if (v <= INT_MIN)
+ return INT_MIN;
+ else
+ return (int) v;
+}
/*
* Create and initialize a new association-handle.
static void do_close_req(association *a, int reason, char *message,
request *req)
{
- Z_APDU apdu;
- Z_Close *cls = zget_Close(a->encode);
+ Z_APDU *apdu = zget_APDU(a->encode, Z_APDU_close);
+ Z_Close *cls = apdu->u.close;
/* Purge request queue */
while (request_deq(&a->incoming));
{
yaz_log(log_requestdetail, "Sending Close PDU, reason=%d, message=%s",
reason, message ? message : "none");
- apdu.which = Z_APDU_close;
- apdu.u.close = cls;
*cls->closeReason = reason;
cls->diagnosticInformation = message;
- process_z_response(a, req, &apdu);
+ process_z_response(a, req, apdu);
iochan_settimeout(a->client_chan, 20);
}
else
static void do_close(association *a, int reason, char *message)
{
request *req = request_get(&a->outgoing);
- do_close_req (a, reason, message, req);
+ do_close_req(a, reason, message, req);
}
{
if (assoc->state != ASSOC_UP)
{
- yaz_log(YLOG_DEBUG, "Final timeout - closing connection.");
+ yaz_log(log_session, "Timeout. Closing connection");
/* do we need to lod this at all */
cs_close(conn);
destroy_association(assoc);
}
else
{
- yaz_log(log_sessiondetail,
- "Session idle too long. Sending close.");
+ yaz_log(log_sessiondetail, "Timeout. Sending Z39.50 Close");
do_close(assoc, Z_Close_lackOfActivity, 0);
}
return;
static void assoc_init_reset(association *assoc)
{
- xfree (assoc->init);
+ xfree(assoc->init);
assoc->init = (bend_initrequest *) xmalloc(sizeof(*assoc->init));
assoc->init->stream = assoc->encode;
assoc->init->bend_explain = NULL;
assoc->init->bend_srw_scan = NULL;
assoc->init->bend_srw_update = NULL;
+ assoc->init->named_result_sets = 0;
assoc->init->charneg_request = NULL;
assoc->init->charneg_response = NULL;
{
Z_IdAuthentication *auth = (Z_IdAuthentication *)
odr_malloc(assoc->decode, sizeof(*auth));
- int len;
+ size_t len;
len = strlen(sr->username) + 1;
if (sr->password)
rr->output_format = match_syntax;
if (match_schema)
rr->schema = odr_strdup(rr->stream, match_schema);
- return 0;
#else
(*assoc->init->bend_fetch)(assoc->backend, rr);
#endif
static int ccl2pqf(ODR odr, const Odr_oct *ccl, CCL_bibset bibset,
- bend_search_rr *bsrr) {
+ bend_search_rr *bsrr)
+{
char *ccl0;
struct ccl_rpn_node *node;
int errcode, pos;
ccl0 = odr_strdupn(odr, (char*) ccl->buf, ccl->len);
- if ((node = ccl_find_str(bibset, ccl0, &errcode, &pos)) == 0) {
+ if ((node = ccl_find_str(bibset, ccl0, &errcode, &pos)) == 0)
+ {
bsrr->errstring = (char*) ccl_err_msg(errcode);
return YAZ_SRW_QUERY_SYNTAX_ERROR; /* Query syntax error */
}
return 0;
}
-
-static void srw_bend_search(association *assoc, request *req,
+static void srw_bend_search(association *assoc,
Z_SRW_PDU *sr,
- Z_SRW_searchRetrieveResponse *srw_res,
+ Z_SRW_PDU *res,
int *http_code)
{
+ Z_SRW_searchRetrieveResponse *srw_res = res->u.response;
int srw_error = 0;
Z_External *ext;
Z_SRW_searchRetrieveRequest *srw_req = sr->u.request;
rr.partial_resultset = 0;
rr.query = (Z_Query *) odr_malloc(assoc->decode, sizeof(*rr.query));
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.stream = assoc->encode;
rr.decode = assoc->decode;
rr.print = assoc->print;
- rr.request = req;
if ( srw_req->sort.sortKeys )
rr.srw_sortKeys = odr_strdup(assoc->encode,
srw_req->sort.sortKeys );
rr.association = assoc;
- rr.fd = 0;
rr.hits = 0;
rr.errcode = 0;
rr.errstring = 0;
}
else
{
- int number = srw_req->maximumRecords ? *srw_req->maximumRecords : 0;
- int start = srw_req->startRecord ? *srw_req->startRecord : 1;
+ int number = srw_req->maximumRecords ?
+ 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 %d",
+ 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);
int i;
int ok = 1;
if (start + number > rr.hits)
- number = rr.hits - start + 1;
+ number = odr_int_to_int(rr.hits) - start + 1;
/* Call bend_present if defined */
if (assoc->init->bend_present)
bprr->stream = assoc->encode;
bprr->referenceId = 0;
bprr->print = assoc->print;
- bprr->request = req;
bprr->association = assoc;
bprr->errcode = 0;
bprr->errstring = NULL;
(*assoc->init->bend_present)(assoc->backend, bprr);
- if (!bprr->request)
- return;
if (bprr->errcode)
{
srw_error = yaz_diag_bib1_to_srw(bprr->errcode);
srw_res->records = 0;
}
}
+ if (rr.extra_response_data)
+ {
+ res->extraResponseData_buf = rr.extra_response_data;
+ res->extraResponseData_len = strlen(rr.extra_response_data);
+ }
if (rr.estimated_hit_count || rr.partial_resultset)
{
yaz_add_srw_diagnostic(
wrbuf_printf(wr, "ERROR info:http/%d", *http_code);
else if (srw_res->numberOfRecords)
{
- wrbuf_printf(wr, "OK %d",
+ wrbuf_printf(wr, "OK " ODR_INT_PRINTF,
(srw_res->numberOfRecords ?
*srw_res->numberOfRecords : 0));
}
- wrbuf_printf(wr, " %s %d+%d",
+ wrbuf_printf(wr, " %s " ODR_INT_PRINTF "+%d",
(srw_res->resultSetId ?
srw_res->resultSetId : "-"),
(srw_req->startRecord ? *srw_req->startRecord : 1),
}
}
-static char *srw_bend_explain_default(void *handle, bend_explain_rr *rr)
+static char *srw_bend_explain_default(bend_explain_rr *rr)
{
#if YAZ_HAVE_XML2
xmlNodePtr ptr = (xmlNode *) rr->server_node_ptr;
return 0;
}
-static void srw_bend_explain(association *assoc, request *req,
+static void srw_bend_explain(association *assoc,
Z_SRW_PDU *sr,
Z_SRW_explainResponse *srw_res,
int *http_code)
if (assoc->init->bend_explain)
(*assoc->init->bend_explain)(assoc->backend, &rr);
else
- srw_bend_explain_default(assoc->backend, &rr);
+ srw_bend_explain_default(&rr);
if (rr.explain_buf)
{
}
}
-static void srw_bend_scan(association *assoc, request *req,
+static void srw_bend_scan(association *assoc,
Z_SRW_PDU *sr,
Z_SRW_scanResponse *srw_res,
int *http_code)
srw_bend_init(assoc, &srw_res->diagnostics, &srw_res->num_diagnostics, sr);
if (srw_res->num_diagnostics == 0 && assoc->init)
{
+ int step_size = 0;
struct scan_entry *save_entries;
bend_scan_rr *bsrr = (bend_scan_rr *)
bsrr->basenames = &srw_req->database;
bsrr->num_entries = srw_req->maximumTerms ?
- *srw_req->maximumTerms : 10;
+ odr_int_to_int(*srw_req->maximumTerms) : 10;
bsrr->term_position = srw_req->responsePosition ?
- *srw_req->responsePosition : 1;
+ odr_int_to_int(*srw_req->responsePosition) : 1;
bsrr->errcode = 0;
bsrr->errstring = 0;
bsrr->referenceId = 0;
bsrr->stream = assoc->encode;
bsrr->print = assoc->print;
- bsrr->step_size = odr_intdup(assoc->decode, 0);
+ bsrr->step_size = &step_size;
bsrr->entries = 0;
bsrr->setname = 0;
else
wrbuf_printf(wr, "OK - - ");
- wrbuf_printf(wr, "%d+%d+0 ",
+ wrbuf_printf(wr, ODR_INT_PRINTF "+" ODR_INT_PRINTF " ",
(srw_req->responsePosition ?
*srw_req->responsePosition : 1),
(srw_req->maximumTerms ?
}
-static void srw_bend_update(association *assoc, request *req,
+static void srw_bend_update(association *assoc,
Z_SRW_PDU *sr,
Z_SRW_updateResponse *srw_res,
int *http_code)
int num_diagnostic = 0;
const char *host = z_HTTP_header_lookup(hreq->headers, "Host");
+ yaz_log(log_request, "%s %s HTTP/%s", hreq->method, hreq->path, hreq->version);
if (!control_association(assoc, host, 0))
{
p = z_get_HTTP_Response(o, 404);
}
else
{
- int content_size = 0;
+ size_t content_size = 0;
char *content_buf = read_file(hreq->path+1, o, &content_size);
if (!content_buf)
{
}
else
{
- srw_bend_search(assoc, req, sr, res->u.response,
- &http_code);
+ srw_bend_search(assoc, sr, res, &http_code);
}
if (http_code == 200)
soap_package->u.generic->p = res;
res->u.explain_response->diagnostics = diagnostic;
res->u.explain_response->num_diagnostics = num_diagnostic;
}
- srw_bend_explain(assoc, req, sr,
- res->u.explain_response, &http_code);
+ srw_bend_explain(assoc, sr, res->u.explain_response, &http_code);
if (http_code == 200)
soap_package->u.generic->p = res;
}
res->u.scan_response->diagnostics = diagnostic;
res->u.scan_response->num_diagnostics = num_diagnostic;
}
- srw_bend_scan(assoc, req, sr,
- res->u.scan_response, &http_code);
+ srw_bend_scan(assoc, sr, res->u.scan_response, &http_code);
if (http_code == 200)
soap_package->u.generic->p = res;
}
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, req, sr,
- res->u.update_response, &http_code);
+ srw_bend_update(assoc, sr, res->u.update_response, &http_code);
if (http_code == 200)
soap_package->u.generic->p = res;
}
*/
static int process_z_request(association *assoc, request *req, char **msg)
{
- int fd = -1;
Z_APDU *res;
int retval;
case Z_APDU_initRequest:
res = process_initRequest(assoc, req); break;
case Z_APDU_searchRequest:
- res = process_searchRequest(assoc, req, &fd); break;
+ res = process_searchRequest(assoc, req); break;
case Z_APDU_presentRequest:
- res = process_presentRequest(assoc, req, &fd); break;
+ res = process_presentRequest(assoc, req); break;
case Z_APDU_scanRequest:
if (assoc->init->bend_scan)
- res = process_scanRequest(assoc, req, &fd);
+ res = process_scanRequest(assoc, req);
else
{
*msg = "Cannot handle Scan APDU";
break;
case Z_APDU_extendedServicesRequest:
if (assoc->init->bend_esrequest)
- res = process_ESRequest(assoc, req, &fd);
+ res = process_ESRequest(assoc, req);
else
{
*msg = "Cannot handle Extended Services APDU";
break;
case Z_APDU_sortRequest:
if (assoc->init->bend_sort)
- res = process_sortRequest(assoc, req, &fd);
+ res = process_sortRequest(assoc, req);
else
{
*msg = "Cannot handle Sort APDU";
return 0;
case Z_APDU_deleteResultSetRequest:
if (assoc->init->bend_delete)
- res = process_deleteRequest(assoc, req, &fd);
+ res = process_deleteRequest(assoc, req);
else
{
*msg = "Cannot handle Delete APDU";
yaz_log(YLOG_DEBUG, " result immediately available");
retval = process_z_response(assoc, req, res);
}
- else if (fd < 0)
- {
- yaz_log(YLOG_DEBUG, " result unavailble");
- retval = 0;
- }
- else /* no result yet - one will be provided later */
+ else
{
- IOCHAN chan;
-
- /* Set up an I/O handler for the fd supplied by the backend */
-
- yaz_log(YLOG_DEBUG, " establishing handler for result");
- req->state = REQUEST_PENDING;
- if (!(chan = iochan_create(fd, backend_response, EVENT_INPUT, 0)))
- abort();
- iochan_setdata(chan, assoc);
- retval = 0;
+ yaz_log(YLOG_DEBUG, " result unavailable");
+ retval = -1;
}
return retval;
}
/*
- * Handle message from the backend.
- */
-void backend_response(IOCHAN i, int event)
-{
- association *assoc = (association *)iochan_getdata(i);
- request *req = request_head(&assoc->incoming);
- Z_APDU *res;
- int fd;
-
- yaz_log(YLOG_DEBUG, "backend_response");
- assert(assoc && req && req->state != REQUEST_IDLE);
- /* determine what it is we're waiting for */
- switch (req->apdu_request->which)
- {
- case Z_APDU_searchRequest:
- res = response_searchRequest(assoc, req, 0, &fd); break;
-#if 0
- case Z_APDU_presentRequest:
- res = response_presentRequest(assoc, req, 0, &fd); break;
- case Z_APDU_scanRequest:
- res = response_scanRequest(assoc, req, 0, &fd); break;
-#endif
- default:
- yaz_log(YLOG_FATAL, "Serious programmer's lapse or bug");
- abort();
- }
- if ((res && process_z_response(assoc, req, res) < 0) || fd < 0)
- {
- yaz_log(YLOG_WARN, "Fatal error when talking to backend");
- do_close(assoc, Z_Close_systemProblem, 0);
- iochan_destroy(i);
- return;
- }
- else if (!res) /* no result yet - try again later */
- {
- yaz_log(YLOG_DEBUG, " no result yet");
- iochan_setfd(i, fd); /* in case fd has changed */
- }
-}
-
-/*
* Encode response, and transfer the request structure to the outgoing queue.
*/
static int process_gdu_response(association *assoc, request *req, Z_GDU *res)
*/
static int process_z_response(association *assoc, request *req, Z_APDU *res)
{
- Z_GDU *gres = (Z_GDU *) odr_malloc(assoc->encode, sizeof(*res));
+ Z_GDU *gres = (Z_GDU *) odr_malloc(assoc->encode, sizeof(*gres));
gres->which = Z_GDU_Z3950;
gres->u.z3950 = res;
assoc->init->charneg_request = negotiation;
}
+ /* by default named_result_sets is 0 .. Enable it if client asks for it. */
+ if (ODR_MASK_GET(req->options, Z_Options_namedResultSets))
+ assoc->init->named_result_sets = 1;
+
assoc->backend = 0;
if (cb)
{
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)))
ODR_MASK_SET(resp->options, Z_Options_extendedServices);
strcat(options, " extendedServices");
}
- if (ODR_MASK_GET(req->options, Z_Options_namedResultSets))
+ if (ODR_MASK_GET(req->options, Z_Options_namedResultSets)
+ && assoc->init->named_result_sets)
{
ODR_MASK_SET(resp->options, Z_Options_namedResultSets);
strcat(options, " namedresults");
yaz_log(log_requestdetail, "Negotiated to v%d: %s", assoc->version, options);
if (*req->maximumRecordSize < assoc->maximumRecordSize)
- assoc->maximumRecordSize = *req->maximumRecordSize;
+ assoc->maximumRecordSize = odr_int_to_int(*req->maximumRecordSize);
if (*req->preferredMessageSize < assoc->preferredMessageSize)
- assoc->preferredMessageSize = *req->preferredMessageSize;
+ assoc->preferredMessageSize = odr_int_to_int(*req->preferredMessageSize);
- resp->preferredMessageSize = &assoc->preferredMessageSize;
- resp->maximumRecordSize = &assoc->maximumRecordSize;
+ resp->preferredMessageSize =
+ odr_intdup(assoc->encode, assoc->preferredMessageSize);
+ resp->maximumRecordSize =
+ odr_intdup(assoc->encode, assoc->maximumRecordSize);
resp->implementationId = odr_prepend(assoc->encode,
assoc->init->implementation_id,
binitres->errstring);
*resp->result = 0;
}
+ else
+ assoc->state = ASSOC_UP;
+
if (log_request)
{
if (!req->idAuthentication)
return zget_surrogateDiagRec(assoc->encode, dbname, error, addinfo);
}
-static Z_Records *pack_records(association *a, char *setname, int start,
- int *num, Z_RecordComposition *comp,
- int *next, int *pres,
+static Z_Records *pack_records(association *a, char *setname, Odr_int start,
+ Odr_int *num, Z_RecordComposition *comp,
+ Odr_int *next, Odr_int *pres,
Z_ReferenceId *referenceId,
Odr_oid *oid, int *errcode)
{
- int recno, total_length = 0, toget = *num, dumped_records = 0;
+ int recno, total_length = 0, dumped_records = 0;
+ int toget = odr_int_to_int(*num);
Z_Records *records =
(Z_Records *) odr_malloc(a->encode, sizeof(*records));
Z_NamePlusRecordList *reclist =
(Z_NamePlusRecordList *) odr_malloc(a->encode, sizeof(*reclist));
- Z_NamePlusRecord **list =
- (Z_NamePlusRecord **) odr_malloc(a->encode, sizeof(*list) * toget);
records->which = Z_Records_DBOSD;
records->u.databaseOrSurDiagnostics = reclist;
reclist->num_records = 0;
- reclist->records = list;
+
+ if (toget < 0)
+ return diagrec(a, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, 0);
+ else if (toget == 0)
+ reclist->records = odr_nullval();
+ else
+ reclist->records = (Z_NamePlusRecord **)
+ odr_malloc(a->encode, sizeof(*reclist->records) * toget);
+
*pres = Z_PresentStatus_success;
*num = 0;
*next = 0;
- yaz_log(log_requestdetail, "Request to pack %d+%d %s", start, toget, setname);
+ yaz_log(log_requestdetail, "Request to pack " ODR_INT_PRINTF "+%d %s", start, toget, setname);
yaz_log(log_requestdetail, "pms=%d, mrs=%d", a->preferredMessageSize,
a->maximumRecordSize);
- for (recno = start; reclist->num_records < toget; recno++)
+ for (recno = odr_int_to_int(start); reclist->num_records < toget; recno++)
{
bend_fetch_rr freq;
Z_NamePlusRecord *thisrec;
if (freq.errcode == YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE &&
freq.errstring == 0)
{
- sprintf (s, "%d", recno);
+ sprintf(s, "%d", recno);
freq.errstring = s;
}
if (errcode)
{
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",
+ yaz_log(log_requestdetail, "Record > maxrcdsz "
+ "this=%d 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 records;
}
-static Z_APDU *process_searchRequest(association *assoc, request *reqb,
- int *fd)
+static Z_APDU *process_searchRequest(association *assoc, request *reqb)
{
Z_SearchRequest *req = reqb->apdu_request->u.searchRequest;
bend_search_rr *bsrr =
(bend_search_rr *)nmem_malloc(reqb->request_mem, sizeof(*bsrr));
yaz_log(log_requestdetail, "Got SearchRequest.");
- bsrr->fd = fd;
- bsrr->request = reqb;
bsrr->association = assoc;
bsrr->referenceId = req->referenceId;
- save_referenceId (reqb, bsrr->referenceId);
bsrr->srw_sortKeys = 0;
bsrr->srw_setname = 0;
bsrr->srw_setnameIdleTime = 0;
bsrr->estimated_hit_count = 0;
bsrr->partial_resultset = 0;
+ bsrr->extra_args = 0;
+ bsrr->extra_response_data = 0;
yaz_log (log_requestdetail, "ResultSet '%s'", req->resultSetName);
if (req->databaseNames)
if (!bsrr->errcode)
(assoc->init->bend_search)(assoc->backend, bsrr);
- if (!bsrr->request) /* backend not ready with the search response */
- return 0; /* should not be used any more */
}
else
{
/* FIXME - make a diagnostic for it */
yaz_log(YLOG_WARN,"Search not supported ?!?!");
}
- return response_searchRequest(assoc, reqb, bsrr, fd);
+ return response_searchRequest(assoc, reqb, bsrr);
}
-int bend_searchresponse(void *handle, bend_search_rr *bsrr) {return 0;}
-
/*
* Prepare a searchresponse based on the backend results. We probably want
* to look at making the fetching of records nonblocking as well, but
* event, and we'll have to get the response for ourselves.
*/
static Z_APDU *response_searchRequest(association *assoc, request *reqb,
- bend_search_rr *bsrt, int *fd)
+ bend_search_rr *bsrt)
{
Z_SearchRequest *req = reqb->apdu_request->u.searchRequest;
Z_APDU *apdu = (Z_APDU *)odr_malloc(assoc->encode, sizeof(*apdu));
Z_SearchResponse *resp = (Z_SearchResponse *)
odr_malloc(assoc->encode, sizeof(*resp));
- int *nulint = odr_intdup(assoc->encode, 0);
- int *next = odr_intdup(assoc->encode, 0);
- int *none = odr_intdup(assoc->encode, Z_SearchResponse_none);
- int returnedrecs = 0;
+ Odr_int *nulint = odr_intdup(assoc->encode, 0);
+ Odr_int *next = odr_intdup(assoc->encode, 0);
+ Odr_int *none = odr_intdup(assoc->encode, Z_SearchResponse_none);
+ Odr_int returnedrecs = 0;
apdu->which = Z_APDU_searchResponse;
apdu->u.searchResponse = resp;
resp->referenceId = req->referenceId;
resp->additionalSearchInfo = 0;
resp->otherInfo = 0;
- *fd = -1;
- if (!bsrt && !bend_searchresponse(assoc->backend, bsrt))
+ if (!bsrt)
{
yaz_log(YLOG_FATAL, "Bad result from backend");
return 0;
resp->resultCount = nulint;
resp->numberOfRecordsReturned = nulint;
resp->nextResultSetPosition = nulint;
- resp->searchStatus = nulint;
+ resp->searchStatus = odr_booldup(assoc->encode, 0);
resp->resultSetStatus = none;
resp->presentStatus = 0;
}
else
{
- bool_t *sr = odr_intdup(assoc->encode, 1);
- int *toget = odr_intdup(assoc->encode, 0);
+ bool_t *sr = odr_booldup(assoc->encode, 1);
+ Odr_int *toget = odr_intdup(assoc->encode, 0);
Z_RecordComposition comp, *compp = 0;
- yaz_log(log_requestdetail, "resultCount: %d", bsrt->hits);
+ yaz_log(log_requestdetail, "resultCount: " ODR_INT_PRINTF, bsrt->hits);
resp->records = 0;
resp->resultCount = &bsrt->hits;
comp.which = Z_RecordComp_simple;
/* how many records does the user agent want, then? */
- if (bsrt->hits <= *req->smallSetUpperBound)
+ if (bsrt->hits < 0)
+ *toget = 0;
+ else if (bsrt->hits <= *req->smallSetUpperBound)
{
*toget = bsrt->hits;
if ((comp.u.simple = req->smallSetElementSetNames))
if (*toget && !resp->records)
{
- int *presst = odr_intdup(assoc->encode, 0);
+ Odr_int *presst = odr_intdup(assoc->encode, 0);
/* Call bend_present if defined */
if (assoc->init->bend_present)
{
nmem_malloc(reqb->request_mem, sizeof(*bprr));
bprr->setname = req->resultSetName;
bprr->start = 1;
- bprr->number = *toget;
+ bprr->number = odr_int_to_int(*toget);
bprr->format = req->preferredRecordSyntax;
bprr->comp = compp;
bprr->referenceId = req->referenceId;
bprr->stream = assoc->encode;
bprr->print = assoc->print;
- bprr->request = reqb;
bprr->association = assoc;
bprr->errcode = 0;
bprr->errstring = NULL;
(*assoc->init->bend_present)(assoc->backend, bprr);
- if (!bprr->request)
- return 0;
if (bprr->errcode)
{
resp->records = diagrec(assoc, bprr->errcode, bprr->errstring);
int i;
WRBUF wr = wrbuf_alloc();
- for (i = 0 ; i < req->num_databaseNames; i++){
+ for (i = 0 ; i < req->num_databaseNames; i++)
+ {
if (i)
wrbuf_printf(wr, "+");
wrbuf_puts(wr, req->databaseNames[i]);
if (bsrt->errcode)
wrbuf_printf(wr, "ERROR %d", bsrt->errcode);
else
- wrbuf_printf(wr, "OK %d", bsrt->hits);
- wrbuf_printf(wr, " %s 1+%d ",
+ wrbuf_printf(wr, "OK " ODR_INT_PRINTF, bsrt->hits);
+ wrbuf_printf(wr, " %s 1+" ODR_INT_PRINTF " ",
req->resultSetName, returnedrecs);
yaz_query_to_wrbuf(wr, req->query);
* operation is more fun in operations that have an unpredictable execution
* speed - which is normally more true for search than for present.
*/
-static Z_APDU *process_presentRequest(association *assoc, request *reqb,
- int *fd)
+static Z_APDU *process_presentRequest(association *assoc, request *reqb)
{
Z_PresentRequest *req = reqb->apdu_request->u.presentRequest;
Z_APDU *apdu;
Z_PresentResponse *resp;
- int *next;
- int *num;
+ Odr_int *next;
+ Odr_int *num;
int errcode = 0;
const char *errstring = 0;
bend_present_rr *bprr = (bend_present_rr *)
nmem_malloc(reqb->request_mem, sizeof(*bprr));
bprr->setname = req->resultSetId;
- bprr->start = *req->resultSetStartPoint;
- bprr->number = *req->numberOfRecordsRequested;
+ bprr->start = odr_int_to_int(*req->resultSetStartPoint);
+ bprr->number = odr_int_to_int(*req->numberOfRecordsRequested);
bprr->format = req->preferredRecordSyntax;
bprr->comp = req->recordComposition;
bprr->referenceId = req->referenceId;
bprr->stream = assoc->encode;
bprr->print = assoc->print;
- bprr->request = reqb;
bprr->association = assoc;
bprr->errcode = 0;
bprr->errstring = NULL;
(*assoc->init->bend_present)(assoc->backend, bprr);
- if (!bprr->request)
- return 0; /* should not happen */
if (bprr->errcode)
{
resp->records = diagrec(assoc, bprr->errcode, bprr->errstring);
else if (*resp->presentStatus == Z_PresentStatus_success)
wrbuf_printf(wr, "OK - ");
else
- wrbuf_printf(wr, "Partial %d - ", *resp->presentStatus);
+ wrbuf_printf(wr, "Partial " ODR_INT_PRINTF " - ",
+ *resp->presentStatus);
- wrbuf_printf(wr, " %s %d+%d ",
+ wrbuf_printf(wr, " %s " ODR_INT_PRINTF "+" ODR_INT_PRINTF " ",
req->resultSetId, *req->resultSetStartPoint,
*req->numberOfRecordsRequested);
yaz_log(log_request, "%s", wrbuf_cstr(wr) );
* Scan was implemented rather in a hurry, and with support for only the basic
* elements of the service in the backend API. Suggestions are welcome.
*/
-static Z_APDU *process_scanRequest(association *assoc, request *reqb, int *fd)
+static Z_APDU *process_scanRequest(association *assoc, request *reqb)
{
Z_ScanRequest *req = reqb->apdu_request->u.scanRequest;
Z_APDU *apdu = (Z_APDU *)odr_malloc(assoc->encode, sizeof(*apdu));
Z_ScanResponse *res = (Z_ScanResponse *)
odr_malloc(assoc->encode, sizeof(*res));
- int *scanStatus = odr_intdup(assoc->encode, Z_Scan_failure);
- int *numberOfEntriesReturned = odr_intdup(assoc->encode, 0);
+ Odr_int *scanStatus = odr_intdup(assoc->encode, Z_Scan_failure);
+ Odr_int *numberOfEntriesReturned = odr_intdup(assoc->encode, 0);
Z_ListEntries *ents = (Z_ListEntries *)
odr_malloc(assoc->encode, sizeof(*ents));
Z_DiagRecs *diagrecs_p = NULL;
bend_scan_rr *bsrr = (bend_scan_rr *)
odr_malloc(assoc->encode, sizeof(*bsrr));
struct scan_entry *save_entries;
+ int step_size = 0;
yaz_log(log_requestdetail, "Got ScanRequest");
res->referenceId = req->referenceId;
/* if step is absent, set it to 0 */
- res->stepSize = odr_intdup(assoc->encode, 0);
if (req->stepSize)
- *res->stepSize = *req->stepSize;
+ step_size = odr_int_to_int(*req->stepSize);
res->scanStatus = scanStatus;
res->numberOfEntriesReturned = numberOfEntriesReturned;
bsrr->errstring = 0;
bsrr->num_bases = req->num_databaseNames;
bsrr->basenames = req->databaseNames;
- bsrr->num_entries = *req->numberOfTermsRequested;
+ bsrr->num_entries = odr_int_to_int(*req->numberOfTermsRequested);
bsrr->term = req->termListAndStartPoint;
bsrr->referenceId = req->referenceId;
bsrr->stream = assoc->encode;
bsrr->print = assoc->print;
- bsrr->step_size = res->stepSize;
+ bsrr->step_size = &step_size;
bsrr->setname = yaz_oi_get_string_oid(&req->otherInfo,
yaz_oid_userinfo_scan_set, 1, 0);
bsrr->entries = 0;
log_scan_term_level(log_requestdetail, req->termListAndStartPoint,
bsrr->attributeset);
bsrr->term_position = req->preferredPositionInResponse ?
- *req->preferredPositionInResponse : 1;
+ odr_int_to_int(*req->preferredPositionInResponse) : 1;
((int (*)(void *, bend_scan_rr *))
(*assoc->init->bend_scan))(assoc->backend, bsrr);
*scanStatus = Z_Scan_partial_5;
else
*scanStatus = Z_Scan_success;
+ res->stepSize = odr_intdup(assoc->encode, step_size);
ents->entries = tab;
ents->num_entries = bsrr->num_entries;
- res->numberOfEntriesReturned = &ents->num_entries;
- res->positionOfTerm = &bsrr->term_position;
+ 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;
odr_malloc(assoc->encode, o->len = o->size =
strlen(bsrr->entries[i].term));
memcpy(o->buf, bsrr->entries[i].term, o->len);
- yaz_log(YLOG_DEBUG, " term #%d: '%s' (%d)", i,
+ yaz_log(YLOG_DEBUG, " term #%d: '%s' (" ODR_INT_PRINTF ")", i,
bsrr->entries[i].term, bsrr->entries[i].occurrences);
}
else
else
wrbuf_printf(wr, "OK");
- wrbuf_printf(wr, " %d - %d+%d+%d",
+ wrbuf_printf(wr, " " ODR_INT_PRINTF " - " ODR_INT_PRINTF "+"
+ ODR_INT_PRINTF "+" ODR_INT_PRINTF,
res->numberOfEntriesReturned ?
*res->numberOfEntriesReturned : 0,
(req->preferredPositionInResponse ?
return apdu;
}
-static Z_APDU *process_sortRequest(association *assoc, request *reqb,
- int *fd)
+static Z_APDU *process_sortRequest(association *assoc, request *reqb)
{
int i;
Z_SortRequest *req = reqb->apdu_request->u.sortRequest;
return apdu;
}
-static Z_APDU *process_deleteRequest(association *assoc, request *reqb,
- int *fd)
+static Z_APDU *process_deleteRequest(association *assoc, request *reqb)
{
int i;
Z_DeleteResultSetRequest *req =
req->resultSetList[i]);
bdrr->stream = assoc->encode;
bdrr->print = assoc->print;
- bdrr->function = *req->deleteFunction;
+ bdrr->function = odr_int_to_int(*req->deleteFunction);
bdrr->referenceId = req->referenceId;
bdrr->statuses = 0;
if (bdrr->num_setnames > 0)
(Z_ListStatus *)
odr_malloc(assoc->encode,
sizeof(**res->deleteListStatuses->elements));
- res->deleteListStatuses->elements[i]->status = bdrr->statuses+i;
+ res->deleteListStatuses->elements[i]->status =
+ odr_intdup(assoc->encode, bdrr->statuses[i]);
res->deleteListStatuses->elements[i]->id =
odr_strdup(assoc->encode, bdrr->setnames[i]);
}
yaz_log(log_request,"Close OK");
}
-void save_referenceId(request *reqb, Z_ReferenceId *refid)
-{
- if (refid)
- {
- reqb->len_refid = refid->len;
- reqb->refid = (char *)nmem_malloc(reqb->request_mem, refid->len);
- memcpy(reqb->refid, refid->buf, refid->len);
- }
- else
- {
- reqb->len_refid = 0;
- reqb->refid = NULL;
- }
-}
-
-void bend_request_send(bend_association a, bend_request req, Z_APDU *res)
-{
- process_z_response(a, req, res);
-}
-
-bend_request bend_request_mk(bend_association a)
-{
- request *nreq = request_get(&a->outgoing);
- nreq->request_mem = nmem_create();
- return nreq;
-}
-
-Z_ReferenceId *bend_request_getid(ODR odr, bend_request req)
-{
- Z_ReferenceId *id;
- if (!req->refid)
- return 0;
- id = (Odr_oct *)odr_malloc(odr, sizeof(*odr));
- id->buf = (unsigned char *)odr_malloc(odr, req->len_refid);
- id->len = id->size = req->len_refid;
- memcpy(id->buf, req->refid, req->len_refid);
- return id;
-}
-
-void bend_request_destroy(bend_request *req)
-{
- nmem_destroy((*req)->request_mem);
- request_release(*req);
- *req = NULL;
-}
-
-int bend_backend_respond(bend_association a, bend_request req)
-{
- char *msg;
- int r;
- r = process_z_request(a, req, &msg);
- if (r < 0)
- yaz_log(YLOG_WARN, "%s", msg);
- return r;
-}
-
-void bend_request_setdata(bend_request r, void *p)
-{
- r->clientData = p;
-}
-
-void *bend_request_getdata(bend_request r)
-{
- return r->clientData;
-}
-
static Z_APDU *process_segmentRequest(association *assoc, request *reqb)
{
bend_segment_rr req;
return 0;
}
-static Z_APDU *process_ESRequest(association *assoc, request *reqb, int *fd)
+static Z_APDU *process_ESRequest(association *assoc, request *reqb)
{
bend_esrequest_rr esrequest;
const char *ext_name = "unknown";
esrequest.print = assoc->print;
esrequest.errcode = 0;
esrequest.errstring = NULL;
- esrequest.request = reqb;
esrequest.association = assoc;
esrequest.taskPackage = 0;
esrequest.referenceId = req->referenceId;
-
if (esrequest.esr && esrequest.esr->taskSpecificParameters)
{
(*assoc->init->bend_esrequest)(assoc->backend, &esrequest);
- /* If the response is being delayed, return NULL */
- if (esrequest.request == NULL)
- return(NULL);
-
resp->referenceId = req->referenceId;
if (esrequest.errcode == -1)
/*
* Local variables:
* c-basic-offset: 4
+ * c-file-style: "Stroustrup"
* indent-tabs-mode: nil
* End:
* vim: shiftwidth=4 tabstop=8 expandtab
projects / yaz-moved-to-github.git / blobdiff