-/*
- * Copyright (C) 1995-2007, Index Data ApS
+/* This file is part of the YAZ toolkit.
+ * Copyright (C) 1995-2008 Index Data
* See the file LICENSE for details.
- *
- * $Id: zoom-c.c,v 1.130 2007-05-08 08:22:36 adam Exp $
*/
/**
* \file zoom-c.c
#include <yaz/ccl.h>
#include <yaz/query-charset.h>
#include <yaz/copy_types.h>
+#include <yaz/snprintf.h>
static int log_api = 0;
static int log_details = 0;
static zoom_ret do_write_ex(ZOOM_connection c, char *buf_out, int len_out);
static char *cql2pqf(ZOOM_connection c, const char *cql);
+ZOOM_API(const char *) ZOOM_get_event_str(int event)
+{
+ static const char *ar[] = {
+ "NONE",
+ "CONNECT",
+ "SEND_DATA",
+ "RECV_DATA",
+ "TIMEOUT",
+ "UNKNOWN",
+ "SEND_APDU",
+ "RECV_APDU",
+ "RECV_RECORD",
+ "RECV_SEARCH",
+ "END"
+ };
+ return ar[event];
+}
/*
* This wrapper is just for logging failed lookups. It would be nicer
* if it could cause failure when a lookup fails, but that's hard.
*/
static Odr_oid *zoom_yaz_str_to_z3950oid(ZOOM_connection c,
- int oid_class, const char *str) {
+ oid_class oid_class, const char *str) {
Odr_oid *res = yaz_string_to_oid_odr(yaz_oid_std(), oid_class, str,
c->odr_out);
if (res == 0)
}
}
+static int uri_to_code(const char *uri)
+{
+ int code = 0;
+ const char *cp;
+ if ((cp = strrchr(uri, '/')))
+ code = atoi(cp+1);
+ return code;
+}
+
#if YAZ_HAVE_XML2
static void set_HTTP_error(ZOOM_connection c, int error,
const char *addinfo, const char *addinfo2)
{
set_dset_error(c, error, "HTTP", addinfo, addinfo2);
}
+
+static void set_SRU_error(ZOOM_connection c, Z_SRW_diagnostic *d)
+{
+ const char *uri = d->uri;
+ if (uri)
+ set_dset_error(c, uri_to_code(uri), uri, d->details, 0);
+}
+
#endif
yaz_log(YLOG_LOG, "connect p=%p", task);
break;
case ZOOM_TASK_SCAN:
- yaz_log(YLOG_LOG, "scant p=%p", task);
+ yaz_log(YLOG_LOG, "scan p=%p", task);
break;
}
}
c->m_queue_front = 0;
c->m_queue_back = 0;
+
+ c->sru_version = 0;
return c;
}
set_ZOOM_error(c, ZOOM_ERROR_NONE, 0);
ZOOM_connection_remove_tasks(c);
+ if (ZOOM_options_get_bool(c->options, "apdulog", 0))
+ {
+ c->odr_print = odr_createmem(ODR_PRINT);
+ odr_setprint(c->odr_print, yaz_log_file());
+ }
+ else
+ c->odr_print = 0;
+
if (c->cs)
{
yaz_log(log_details, "%p ZOOM_connection_connect reconnect ok", c);
val = ZOOM_options_get(c->options, "sru");
c->sru_mode = get_sru_mode_from_string(val);
+ xfree(c->sru_version);
+ val = ZOOM_options_get(c->options, "sru_version");
+ c->sru_version = xstrdup(val ? val : "1.2");
+
ZOOM_options_set(c->options, "host", c->host_port);
xfree(c->cookie_out);
s->query_string = odr_strdup(s->odr, str);
ext = (Z_External *) odr_malloc(s->odr, sizeof(*ext));
- ext->direct_reference = odr_getoidbystr(s->odr, "1.2.840.10003.16.2");
+ ext->direct_reference = odr_oiddup(s->odr, yaz_oid_userinfo_cql);
ext->indirect_reference = 0;
ext->descriptor = 0;
ext->which = Z_External_CQL;
xfree(c->diagset);
odr_destroy(c->odr_in);
odr_destroy(c->odr_out);
+ if (c->odr_print)
+ {
+ odr_setprint(c->odr_print, 0); /* prevent destroy from fclose'ing */
+ odr_destroy(c->odr_print);
+ }
ZOOM_options_destroy(c->options);
ZOOM_connection_remove_tasks(c);
ZOOM_connection_remove_events(c);
xfree(c->user);
xfree(c->group);
xfree(c->password);
+ xfree(c->sru_version);
xfree(c);
}
r->next = 0;
r->databaseNames = 0;
r->num_databaseNames = 0;
- r->rpn_iconv = 0;
return r;
}
r->options = ZOOM_options_create_with_parent(c->options);
- {
- const char *cp = ZOOM_options_get(r->options, "rpnCharset");
- if (cp)
- r->rpn_iconv = yaz_iconv_open(cp, "UTF-8");
- }
-
-
start = ZOOM_options_get_int(r->options, "start", 0);
count = ZOOM_options_get_int(r->options, "count", 0);
{
task->u.search.resultset = r;
task->u.search.start = start;
task->u.search.count = count;
+ task->u.search.recv_search_fired = 0;
syntax = ZOOM_options_get(r->options, "preferredRecordSyntax");
task->u.search.syntax = syntax ? xstrdup(syntax) : 0;
}
ZOOM_query_destroy(r->query);
ZOOM_options_destroy(r->options);
- if (r->rpn_iconv)
- yaz_iconv_close(r->rpn_iconv);
odr_destroy(r->odr);
xfree(r->setname);
xfree(r->schema);
odr_reset(out);
return -1;
}
+ if (c->odr_print)
+ z_APDU(c->odr_print, &a, 0, 0);
yaz_log(log_details, "%p encoding_APDU encoding OK", c);
return 0;
}
Z_InitRequest *ireq = apdu->u.initRequest;
Z_IdAuthentication *auth = (Z_IdAuthentication *)
odr_malloc(c->odr_out, sizeof(*auth));
- char *version;
ODR_MASK_SET(ireq->options, Z_Options_search);
ODR_MASK_SET(ireq->options, Z_Options_present);
ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);
- /* Index Data's Z39.50 Implementor Id is 81 */
ireq->implementationId =
odr_prepend(c->odr_out,
ZOOM_options_get(c->options, "implementationId"),
- odr_prepend(c->odr_out, "81", ireq->implementationId));
+ ireq->implementationId);
ireq->implementationName =
odr_prepend(c->odr_out,
odr_prepend(c->odr_out, "ZOOM-C",
ireq->implementationName));
- version = odr_strdup(c->odr_out, "$Revision: 1.130 $");
- if (strlen(version) > 10) /* check for unexpanded CVS strings */
- version[strlen(version)-2] = '\0';
ireq->implementationVersion =
odr_prepend(c->odr_out,
ZOOM_options_get(c->options, "implementationVersion"),
- odr_prepend(c->odr_out, &version[11],
- ireq->implementationVersion));
+ ireq->implementationVersion);
*ireq->maximumRecordSize = c->maximum_record_size;
*ireq->preferredMessageSize = c->preferred_message_size;
if (c->group || c->password)
{
Z_IdPass *pass = (Z_IdPass *) odr_malloc(c->odr_out, sizeof(*pass));
- pass->groupId = 0;
- if (c->group)
- pass->groupId = odr_strdup(c->odr_out, c->group);
- pass->userId = 0;
- if (c->user)
- pass->userId = odr_strdup(c->odr_out, c->user);
- pass->password = 0;
- if (c->password)
- pass->password = odr_strdup(c->odr_out, c->password);
+ pass->groupId = odr_strdup_null(c->odr_out, c->group);
+ pass->userId = odr_strdup_null(c->odr_out, c->user);
+ pass->password = odr_strdup_null(c->odr_out, c->password);
auth->which = Z_IdAuthentication_idPass;
auth->u.idPass = pass;
ireq->idAuthentication = auth;
{
Z_GDU *gdu;
ZOOM_Event event;
-
- gdu = z_get_HTTP_Request_host_path(c->odr_out, c->host_port, c->path);
+ const char *database = ZOOM_options_get(c->options, "databaseName");
+ char *fdatabase = 0;
+
+ if (database)
+ {
+ fdatabase = (char *) odr_malloc(c->odr_out, strlen(database)+2);
+ strcpy(fdatabase, "/");
+ strcat(fdatabase, database);
+ }
+ gdu = z_get_HTTP_Request_host_path(c->odr_out, c->host_port,
+ fdatabase ? fdatabase : c->path);
if (c->sru_mode == zoom_sru_get)
{
}
if (!z_GDU(c->odr_out, &gdu, 0, 0))
return zoom_complete;
+ if (c->odr_print)
+ z_GDU(c->odr_print, &gdu, 0, 0);
c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
#endif
#if YAZ_HAVE_XML2
+static Z_SRW_PDU *ZOOM_srw_get_pdu(ZOOM_connection c, int type)
+{
+ Z_SRW_PDU *sr = yaz_srw_get_pdu(c->odr_out, type, c->sru_version);
+ sr->username = c->user;
+ sr->password = c->password;
+ return sr;
+}
+#endif
+
+#if YAZ_HAVE_XML2
static zoom_ret ZOOM_connection_srw_send_search(ZOOM_connection c)
{
int i;
{
case ZOOM_TASK_SEARCH:
resultset = c->tasks->u.search.resultset;
- resultset->setname = xstrdup("default");
+ if (!resultset->setname)
+ resultset->setname = xstrdup("default");
ZOOM_options_set(resultset->options, "setname", resultset->setname);
start = &c->tasks->u.search.start;
count = &c->tasks->u.search.count;
start = &c->tasks->u.retrieve.start;
count = &c->tasks->u.retrieve.count;
-
+
if (*start >= resultset->size)
return zoom_complete;
if (*start + *count > resultset->size)
}
assert(resultset->query);
- sr = yaz_srw_get(c->odr_out, Z_SRW_searchRetrieve_request);
-
+ sr = ZOOM_srw_get_pdu(c, Z_SRW_searchRetrieve_request);
if (resultset->query->z_query->which == Z_Query_type_104
&& resultset->query->z_query->u.type_104->which == Z_External_CQL)
{
}
sr->u.request->startRecord = odr_intdup(c->odr_out, *start + 1);
sr->u.request->maximumRecords = odr_intdup(
- c->odr_out, resultset->step>0 ? resultset->step : *count);
+ c->odr_out, (resultset->step > 0 && resultset->step < *count) ?
+ resultset->step : *count);
sr->u.request->recordSchema = resultset->schema;
option_val = ZOOM_resultset_option_get(resultset, "recordPacking");
sr->u.request->recordPacking = odr_strdup(c->odr_out, option_val);
option_val = ZOOM_resultset_option_get(resultset, "extraArgs");
- if (option_val)
- sr->extra_args = odr_strdup(c->odr_out, option_val);
+ yaz_encode_sru_extra(sr, c->odr_out, option_val);
return send_srw(c, sr);
}
#else
set_ZOOM_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
return zoom_complete;
}
- if (r->query->z_query->which == Z_Query_type_1 && r->rpn_iconv)
+ if (r->query->z_query->which == Z_Query_type_1 ||
+ r->query->z_query->which == Z_Query_type_101)
{
- search_req->query = yaz_copy_Z_Query(r->query->z_query, c->odr_out);
-
- yaz_query_charset_convert_rpnquery(search_req->query->u.type_1,
- c->odr_out, r->rpn_iconv);
+ const char *cp = ZOOM_options_get(r->options, "rpnCharset");
+ if (cp)
+ {
+ yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
+ if (cd)
+ {
+ search_req->query = yaz_copy_Z_Query(search_req->query,
+ c->odr_out);
+
+ yaz_query_charset_convert_rpnquery(search_req->query->u.type_1,
+ c->odr_out, cd);
+ yaz_iconv_close(cd);
+ }
+ }
}
search_req->databaseNames = r->databaseNames;
search_req->num_databaseNames = r->num_databaseNames;
static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
{
- oid_class oclass;
+ char oid_name_buf[OID_STR_MAX];
+ const char *oid_name;
char *addinfo = 0;
+ oid_name = yaz_oid_to_string_buf(r->diagnosticSetId, 0, oid_name_buf);
switch (r->which)
{
case Z_DefaultDiagFormat_v2Addinfo:
}
xfree(c->addinfo);
c->addinfo = 0;
- set_dset_error(c, *r->condition,
- yaz_oid_to_string(yaz_oid_std(),
- r->diagnosticSetId, &oclass),
- addinfo, 0);
+ set_dset_error(c, *r->condition, oid_name, addinfo, 0);
}
static void response_diag(ZOOM_connection c, Z_DiagRec *p)
odr_setbuf(nrec->odr, buf, size, 0);
z_NamePlusRecord(nrec->odr, &nrec->npr, 0, 0);
+ nrec->schema = odr_strdup_null(nrec->odr, srec->schema);
+ nrec->diag_uri = odr_strdup_null(nrec->odr, srec->diag_uri);
+ nrec->diag_message = odr_strdup_null(nrec->odr, srec->diag_message);
+ nrec->diag_details = odr_strdup_null(nrec->odr, srec->diag_details);
+ nrec->diag_set = odr_strdup_null(nrec->odr, srec->diag_set);
odr_destroy(odr_enc);
return nrec;
}
return buf;
}
+
ZOOM_API(int)
ZOOM_record_error(ZOOM_record rec, const char **cp,
const char **addinfo, const char **diagset)
if (!rec)
return 0;
+
npr = rec->npr;
+ if (rec->diag_uri)
+ {
+ if (cp)
+ *cp = rec->diag_message;
+ if (addinfo)
+ *addinfo = rec->diag_details;
+ if (diagset)
+ *diagset = rec->diag_set;
+ return uri_to_code(rec->diag_uri);
+ }
if (npr && npr->which == Z_NamePlusRecord_surrogateDiagnostic)
{
Z_DiagRec *diag_rec = npr->u.surrogateDiagnostic;
*len = (npr->databaseName ? strlen(npr->databaseName) : 0);
return npr->databaseName;
}
+ else if (!strcmp(type, "schema"))
+ {
+ if (len)
+ *len = rec->schema ? strlen(rec->schema) : 0;
+ return rec->schema;
+ }
else if (!strcmp(type, "syntax"))
{
const char *desc = 0;
static void record_cache_add(ZOOM_resultset r, Z_NamePlusRecord *npr,
int pos,
- const char *syntax, const char *elementSetName)
+ const char *syntax, const char *elementSetName,
+ const char *schema,
+ Z_SRW_diagnostic *diag)
{
- ZOOM_record_cache rc;
+ ZOOM_record_cache rc = 0;
ZOOM_Event event = ZOOM_Event_create(ZOOM_EVENT_RECV_RECORD);
ZOOM_connection_put_event(r->connection, event);
for (rc = r->record_hash[record_hash(pos)]; rc; rc = rc->next)
{
- if (pos == rc->pos)
+ if (pos == rc->pos
+ && strcmp_null(r->schema, rc->schema) == 0
+ && strcmp_null(elementSetName,rc->elementSetName) == 0
+ && strcmp_null(syntax, rc->syntax) == 0)
+ break;
+ }
+ if (!rc)
+ {
+ rc = (ZOOM_record_cache) odr_malloc(r->odr, sizeof(*rc));
+ rc->rec.odr = 0;
+ rc->rec.wrbuf_marc = 0;
+ rc->rec.wrbuf_iconv = 0;
+ rc->rec.wrbuf_opac = 0;
+ rc->elementSetName = odr_strdup_null(r->odr, elementSetName);
+
+ rc->syntax = odr_strdup_null(r->odr, syntax);
+
+ rc->schema = odr_strdup_null(r->odr, r->schema);
+
+ rc->pos = pos;
+ rc->next = r->record_hash[record_hash(pos)];
+ r->record_hash[record_hash(pos)] = rc;
+ }
+ rc->rec.npr = npr;
+ rc->rec.schema = odr_strdup_null(r->odr, schema);
+ rc->rec.diag_set = 0;
+ rc->rec.diag_uri = 0;
+ rc->rec.diag_message = 0;
+ rc->rec.diag_details = 0;
+ if (diag)
+ {
+ if (diag->uri)
{
- if (strcmp_null(r->schema, rc->schema))
- continue;
- if (strcmp_null(elementSetName,rc->elementSetName))
- continue;
- if (strcmp_null(syntax, rc->syntax))
- continue;
- /* not destroying rc->npr (it's handled by nmem )*/
- rc->rec.npr = npr;
- /* keeping wrbuf_marc too */
- return;
+ char *cp;
+ rc->rec.diag_set = odr_strdup(r->odr, diag->uri);
+ if ((cp = strrchr(rc->rec.diag_set, '/')))
+ *cp = '\0';
+ rc->rec.diag_uri = odr_strdup(r->odr, diag->uri);
}
+ rc->rec.diag_message = odr_strdup_null(r->odr, diag->message);
+ rc->rec.diag_details = odr_strdup_null(r->odr, diag->details);
}
- rc = (ZOOM_record_cache) odr_malloc(r->odr, sizeof(*rc));
- rc->rec.npr = npr;
- rc->rec.odr = 0;
- rc->rec.wrbuf_marc = 0;
- rc->rec.wrbuf_iconv = 0;
- rc->rec.wrbuf_opac = 0;
- if (elementSetName)
- rc->elementSetName = odr_strdup(r->odr, elementSetName);
- else
- rc->elementSetName = 0;
-
- if (syntax)
- rc->syntax = odr_strdup(r->odr, syntax);
- else
- rc->syntax = 0;
-
- if (r->schema)
- rc->schema = odr_strdup(r->odr, r->schema);
- else
- rc->schema = 0;
-
- rc->pos = pos;
- rc->next = r->record_hash[record_hash(pos)];
- r->record_hash[record_hash(pos)] = rc;
}
static ZOOM_record record_cache_lookup(ZOOM_resultset r, int pos,
for (i = 0; i<p->num_records; i++)
{
record_cache_add(resultset, p->records[i], i + *start,
- syntax, elementSetName);
+ syntax, elementSetName,
+ elementSetName, 0);
}
*count -= i;
if (*count < 0)
Z_NamePlusRecord *myrec =
zget_surrogateDiagRec(resultset->odr, 0, 14, 0);
record_cache_add(resultset, myrec, *start,
- syntax, elementSetName);
+ syntax, elementSetName, 0, 0);
}
}
else if (present_phase)
/* present response and we didn't get any records! */
Z_NamePlusRecord *myrec =
zget_surrogateDiagRec(resultset->odr, 0, 14, 0);
- record_cache_add(resultset, myrec, *start, syntax, elementSetName);
+ record_cache_add(resultset, myrec, *start, syntax, elementSetName,
+ 0, 0);
}
}
}
if (res->entries && res->entries->nonsurrogateDiagnostics)
response_diag(c, res->entries->nonsurrogateDiagnostics[0]);
scan->scan_response = res;
+ scan->srw_scan_response = 0;
nmem_transfer(odr_getmem(scan->odr), nmem);
if (res->stepSize)
ZOOM_options_set_int(scan->options, "stepSize", *res->stepSize);
yaz_log(log_details, "%p send_present skip=%d", c, i);
*req->resultSetStartPoint = *start + 1;
- *req->numberOfRecordsRequested = resultset->step>0 ?
- resultset->step : *count;
+
+ if (resultset->step > 0 && resultset->step < *count)
+ *req->numberOfRecordsRequested = resultset->step;
+ else
+ *req->numberOfRecordsRequested = *count;
+
if (*req->numberOfRecordsRequested + *start > resultset->size)
*req->numberOfRecordsRequested = resultset->size - *start;
assert(*req->numberOfRecordsRequested > 0);
ZOOM_API(ZOOM_scanset)
ZOOM_connection_scan1(ZOOM_connection c, ZOOM_query q)
{
- char *start;
- char *freeme = 0;
ZOOM_scanset scan = 0;
- /*
- * We need to check the query-type, so we can recognise CQL and
- * CCL and compile them into a form that we can use here. The
- * ZOOM_query structure has no explicit `type' member, but
- * inspection of the ZOOM_query_prefix() and ZOOM_query_cql()
- * functions shows how the structure is set up in each case.
- */
if (!q->z_query)
return 0;
- else if (q->z_query->which == Z_Query_type_1)
- {
- yaz_log(log_api, "%p ZOOM_connection_scan1 q=%p PQF '%s'",
- c, q, q->query_string);
- start = q->query_string;
- }
- else if (q->z_query->which == Z_Query_type_104)
- {
- yaz_log(log_api, "%p ZOOM_connection_scan1 q=%p CQL '%s'",
- c, q, q->query_string);
- start = freeme = cql2pqf(c, q->query_string);
- if (start == 0)
- return 0;
- }
- else
- {
- yaz_log(YLOG_FATAL, "%p ZOOM_connection_scan1 q=%p unknown type '%s'",
- c, q, q->query_string);
- abort();
- }
-
scan = (ZOOM_scanset) xmalloc(sizeof(*scan));
scan->connection = c;
scan->odr = odr_createmem(ODR_DECODE);
scan->options = ZOOM_options_create_with_parent(c->options);
scan->refcount = 1;
scan->scan_response = 0;
- scan->termListAndStartPoint =
- p_query_scan(scan->odr, PROTO_Z3950, &scan->attributeSet, start);
- xfree(freeme);
-
- {
- const char *cp = ZOOM_options_get(scan->options, "rpnCharset");
- if (cp)
- {
- yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
- if (cd)
- {
- yaz_query_charset_convert_apt(scan->termListAndStartPoint,
- scan->odr, cd);
- }
- }
- }
-
+ scan->srw_scan_response = 0;
+ scan->query = q;
+ (q->refcount)++;
scan->databaseNames = set_DatabaseNames(c, c->options,
&scan->num_databaseNames,
scan->odr);
- if (scan->termListAndStartPoint != 0)
+
+ if (1)
{
ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_SCAN);
task->u.scan.scan = scan;
(scan->refcount)--;
if (scan->refcount == 0)
{
+ ZOOM_query_destroy(scan->query);
+
odr_destroy(scan->odr);
ZOOM_options_destroy(scan->options);
return do_write(c);
}
-static zoom_ret send_scan(ZOOM_connection c)
+static zoom_ret ZOOM_connection_send_scan(ZOOM_connection c)
{
ZOOM_scanset scan;
Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
assert (c->tasks->which == ZOOM_TASK_SCAN);
scan = c->tasks->u.scan.scan;
- req->termListAndStartPoint = scan->termListAndStartPoint;
- req->attributeSet = scan->attributeSet;
+ /* Z39.50 scan can only carry RPN */
+ if (scan->query->z_query->which == Z_Query_type_1 ||
+ scan->query->z_query->which == Z_Query_type_101)
+ {
+ Z_RPNQuery *rpn = scan->query->z_query->u.type_1;
+ const char *cp = ZOOM_options_get(scan->options, "rpnCharset");
+ if (cp)
+ {
+ yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
+ if (cd)
+ {
+ rpn = yaz_copy_z_RPNQuery(rpn, c->odr_out);
+
+ yaz_query_charset_convert_rpnquery(
+ rpn, c->odr_out, cd);
+ yaz_iconv_close(cd);
+ }
+ }
+ req->attributeSet = rpn->attributeSetId;
+ if (!req->attributeSet)
+ req->attributeSet = odr_oiddup(c->odr_out, yaz_oid_attset_bib_1);
+ if (rpn->RPNStructure->which == Z_RPNStructure_simple &&
+ rpn->RPNStructure->u.simple->which == Z_Operand_APT)
+ {
+ req->termListAndStartPoint =
+ rpn->RPNStructure->u.simple->u.attributesPlusTerm;
+ }
+ else
+ {
+ set_ZOOM_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
+ return zoom_complete;
+ }
+ }
+ else
+ {
+ set_ZOOM_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
+ return zoom_complete;
+ }
*req->numberOfTermsRequested =
ZOOM_options_get_int(scan->options, "number", 10);
return send_APDU(c, apdu);
}
+#if YAZ_HAVE_XML2
+static zoom_ret ZOOM_connection_srw_send_scan(ZOOM_connection c)
+{
+ ZOOM_scanset scan;
+ Z_SRW_PDU *sr = 0;
+ const char *option_val = 0;
+
+ if (!c->tasks)
+ return zoom_complete;
+ assert (c->tasks->which == ZOOM_TASK_SCAN);
+ scan = c->tasks->u.scan.scan;
+
+ sr = ZOOM_srw_get_pdu(c, Z_SRW_scan_request);
+
+ /* SRU scan can only carry CQL and PQF */
+ if (scan->query->z_query->which == Z_Query_type_104)
+ {
+ sr->u.scan_request->query_type = Z_SRW_query_type_cql;
+ sr->u.scan_request->scanClause.cql = scan->query->query_string;
+ }
+ else if (scan->query->z_query->which == Z_Query_type_1
+ || scan->query->z_query->which == Z_Query_type_101)
+ {
+ sr->u.scan_request->query_type = Z_SRW_query_type_pqf;
+ sr->u.scan_request->scanClause.pqf = scan->query->query_string;
+ }
+ else
+ {
+ set_ZOOM_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
+ return zoom_complete;
+ }
+
+ sr->u.scan_request->maximumTerms = odr_intdup(
+ c->odr_out, ZOOM_options_get_int(scan->options, "number", 10));
+
+ sr->u.scan_request->responsePosition = odr_intdup(
+ c->odr_out, ZOOM_options_get_int(scan->options, "position", 1));
+
+ option_val = ZOOM_options_get(scan->options, "extraArgs");
+ yaz_encode_sru_extra(sr, c->odr_out, option_val);
+ return send_srw(c, sr);
+}
+#else
+static zoom_ret ZOOM_connection_srw_send_scan(ZOOM_connection c)
+{
+ return zoom_complete;
+}
+#endif
+
+
ZOOM_API(size_t)
ZOOM_scanset_size(ZOOM_scanset scan)
{
- if (!scan || !scan->scan_response || !scan->scan_response->entries)
+ if (!scan)
return 0;
- return scan->scan_response->entries->num_entries;
+
+ if (scan->scan_response && scan->scan_response->entries)
+ return scan->scan_response->entries->num_entries;
+ else if (scan->srw_scan_response)
+ return scan->srw_scan_response->num_terms;
+ return 0;
}
-ZOOM_API(const char *)
- ZOOM_scanset_term(ZOOM_scanset scan, size_t pos,
- int *occ, int *len)
+static void ZOOM_scanset_term_x(ZOOM_scanset scan, size_t pos,
+ int *occ,
+ const char **value_term, size_t *value_len,
+ const char **disp_term, size_t *disp_len)
{
- const char *term = 0;
size_t noent = ZOOM_scanset_size(scan);
- Z_ScanResponse *res = scan->scan_response;
- *len = 0;
+ *value_term = 0;
+ *value_len = 0;
+
+ *disp_term = 0;
+ *disp_len = 0;
+
*occ = 0;
- if (pos >= noent)
- return 0;
- if (res->entries->entries[pos]->which == Z_Entry_termInfo)
+ if (pos >= noent || pos < 0)
+ return;
+ if (scan->scan_response)
{
- Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
-
- if (t->term->which == Z_Term_general)
+ Z_ScanResponse *res = scan->scan_response;
+ if (res->entries->entries[pos]->which == Z_Entry_termInfo)
{
- term = (const char *) t->term->u.general->buf;
- *len = t->term->u.general->len;
+ Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
+
+ *value_term = (const char *) t->term->u.general->buf;
+ *value_len = t->term->u.general->len;
+ if (t->displayTerm)
+ {
+ *disp_term = t->displayTerm;
+ *disp_len = strlen(*disp_term);
+ }
+ else if (t->term->which == Z_Term_general)
+ {
+ *disp_term = (const char *) t->term->u.general->buf;
+ *disp_len = t->term->u.general->len;
+ }
+ *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
+ }
+ }
+ if (scan->srw_scan_response)
+ {
+ Z_SRW_scanResponse *res = scan->srw_scan_response;
+ Z_SRW_scanTerm *t = res->terms + pos;
+ if (t)
+ {
+ *value_term = t->value;
+ *value_len = strlen(*value_term);
+
+ if (t->displayTerm)
+ *disp_term = t->displayTerm;
+ else
+ *disp_term = t->value;
+ *disp_len = strlen(*disp_term);
+ *occ = t->numberOfRecords ? *t->numberOfRecords : 0;
}
- *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
}
- return term;
+}
+
+ZOOM_API(const char *)
+ ZOOM_scanset_term(ZOOM_scanset scan, size_t pos,
+ int *occ, int *len)
+{
+ const char *value_term = 0;
+ size_t value_len = 0;
+ const char *disp_term = 0;
+ size_t disp_len = 0;
+
+ ZOOM_scanset_term_x(scan, pos, occ, &value_term, &value_len,
+ &disp_term, &disp_len);
+
+ *len = value_len;
+ return value_term;
}
ZOOM_API(const char *)
ZOOM_scanset_display_term(ZOOM_scanset scan, size_t pos,
int *occ, int *len)
{
- const char *term = 0;
- size_t noent = ZOOM_scanset_size(scan);
- Z_ScanResponse *res = scan->scan_response;
-
- *len = 0;
- *occ = 0;
- if (pos >= noent)
- return 0;
- if (res->entries->entries[pos]->which == Z_Entry_termInfo)
- {
- Z_TermInfo *t = res->entries->entries[pos]->u.termInfo;
+ const char *value_term = 0;
+ size_t value_len = 0;
+ const char *disp_term = 0;
+ size_t disp_len = 0;
- if (t->displayTerm)
- {
- term = t->displayTerm;
- *len = strlen(term);
- }
- else if (t->term->which == Z_Term_general)
- {
- term = (const char *) t->term->u.general->buf;
- *len = t->term->u.general->len;
- }
- *occ = t->globalOccurrences ? *t->globalOccurrences : 0;
- }
- return term;
+ ZOOM_scanset_term_x(scan, pos, occ, &value_term, &value_len,
+ &disp_term, &disp_len);
+
+ *len = disp_len;
+ return disp_term;
}
ZOOM_API(const char *)
Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
- *req->function = Z_ExtendedServicesRequest_create;
-
str = ZOOM_options_get(p->options, "package-name");
if (str && *str)
req->packageName = odr_strdup(p->odr_out, str);
str = ZOOM_options_get(p->options, "user-id");
if (str)
- req->userId = odr_strdup(p->odr_out, str);
+ req->userId = odr_strdup_null(p->odr_out, str);
req->packageType = odr_oiddup(p->odr_out, oid);
if (str)
{
if (!strcmp (str, "create"))
- *req->function = 1;
+ *req->function = Z_ExtendedServicesRequest_create;
if (!strcmp (str, "delete"))
- *req->function = 2;
+ *req->function = Z_ExtendedServicesRequest_delete;
if (!strcmp (str, "modify"))
- *req->function = 3;
+ *req->function = Z_ExtendedServicesRequest_modify;
+ }
+
+ str = ZOOM_options_get(p->options, "waitAction");
+ if (str)
+ {
+ if (!strcmp (str, "wait"))
+ *req->waitAction = Z_ExtendedServicesRequest_wait;
+ if (!strcmp (str, "waitIfPossible"))
+ *req->waitAction = Z_ExtendedServicesRequest_waitIfPossible;
+ if (!strcmp (str, "dontWait"))
+ *req->waitAction = Z_ExtendedServicesRequest_dontWait;
+ if (!strcmp (str, "dontReturnPackage"))
+ *req->waitAction = Z_ExtendedServicesRequest_dontReturnPackage;
}
return apdu;
}
{
Z_ItemOrder *req = (Z_ItemOrder *) odr_malloc(p->odr_out, sizeof(*req));
const char *str;
+ int len;
req->which = Z_IOItemOrder_esRequest;
req->u.esRequest = (Z_IORequest *)
odr_malloc(p->odr_out, sizeof(*req->u.esRequest->toKeep->contact));
str = ZOOM_options_get(p->options, "contact-name");
- req->u.esRequest->toKeep->contact->name = str ?
- odr_strdup(p->odr_out, str) : 0;
+ req->u.esRequest->toKeep->contact->name =
+ odr_strdup_null(p->odr_out, str);
str = ZOOM_options_get(p->options, "contact-phone");
- req->u.esRequest->toKeep->contact->phone = str ?
- odr_strdup(p->odr_out, str) : 0;
+ req->u.esRequest->toKeep->contact->phone =
+ odr_strdup_null(p->odr_out, str);
str = ZOOM_options_get(p->options, "contact-email");
- req->u.esRequest->toKeep->contact->email = str ?
- odr_strdup(p->odr_out, str) : 0;
+ req->u.esRequest->toKeep->contact->email =
+ odr_strdup_null(p->odr_out, str);
req->u.esRequest->toKeep->addlBilling = 0;
(str ? atoi(str) : 1);
}
- str = ZOOM_options_get(p->options, "doc");
+ str = ZOOM_options_getl(p->options, "doc", &len);
if (str)
{
req->u.esRequest->notToKeep->itemRequest =
- z_ext_record_xml(p->odr_out, str, strlen(str));
+ z_ext_record_xml(p->odr_out, str, len);
}
else
req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);
Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_xml_es);
Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
Z_External *ext = (Z_External *) odr_malloc(p->odr_out, sizeof(*ext));
- const char *doc = ZOOM_options_get(p->options, "doc");
+ int len;
+ const char *doc = ZOOM_options_getl(p->options, "doc", &len);
if (!doc)
+ {
doc = "";
+ len = 0;
+ }
req->taskSpecificParameters = ext;
ext->direct_reference = req->packageType;
ext->which = Z_External_octet;
ext->u.single_ASN1_type =
- odr_create_Odr_oct(p->odr_out, (const unsigned char *) doc,
- strlen(doc));
+ odr_create_Odr_oct(p->odr_out, (const unsigned char *) doc, len);
return apdu;
}
int num_db;
char **db = set_DatabaseNames(p->connection, p->options, &num_db, p->odr_out);
const char *action = ZOOM_options_get(p->options, "action");
- const char *recordIdOpaque = ZOOM_options_get(p->options, "recordIdOpaque");
+ int recordIdOpaque_len;
+ const char *recordIdOpaque = ZOOM_options_getl(p->options, "recordIdOpaque",
+ &recordIdOpaque_len);
const char *recordIdNumber = ZOOM_options_get(p->options, "recordIdNumber");
- const char *record_buf = ZOOM_options_get(p->options, "record");
+ int record_len;
+ const char *record_buf = ZOOM_options_getl(p->options, "record",
+ &record_len);
+ int recordOpaque_len;
+ const char *recordOpaque_buf = ZOOM_options_getl(p->options, "recordOpaque",
+ &recordOpaque_len);
const char *syntax_str = ZOOM_options_get(p->options, "syntax");
+ const char *version = ZOOM_options_get(p->options, "updateVersion");
+
+ const char *correlationInfo_note =
+ ZOOM_options_get(p->options, "correlationInfo.note");
+ const char *correlationInfo_id =
+ ZOOM_options_get(p->options, "correlationInfo.id");
int action_no = -1;
Odr_oid *syntax_oid = 0;
+ const Odr_oid *package_oid = yaz_oid_extserv_database_update;
+ if (!version)
+ version = "3";
if (!syntax_str)
syntax_str = "xml";
- if (!record_buf)
+ if (!record_buf && !recordOpaque_buf)
{
record_buf = "void";
+ record_len = 4;
syntax_str = "SUTRS";
}
if (num_db > 0)
first_db = db[0];
- if (!action)
- action = "specialUpdate";
+ switch(*version)
+ {
+ case '1':
+ package_oid = yaz_oid_extserv_database_update_first_version;
+ /* old update does not support specialUpdate */
+ if (!action)
+ action = "recordInsert";
+ break;
+ case '2':
+ if (!action)
+ action = "specialUpdate";
+ package_oid = yaz_oid_extserv_database_update_second_version;
+ break;
+ case '3':
+ if (!action)
+ action = "specialUpdate";
+ package_oid = yaz_oid_extserv_database_update;
+ break;
+ default:
+ return 0;
+ }
if (!strcmp(action, "recordInsert"))
action_no = Z_IUOriginPartToKeep_recordInsert;
else
return 0;
- apdu = create_es_package(p, yaz_oid_extserv_database_update);
+ apdu = create_es_package(p, package_oid);
if (apdu)
{
Z_IUOriginPartToKeep *toKeep;
Z_IUSuppliedRecords *notToKeep;
Z_External *r = (Z_External *)
odr_malloc(p->odr_out, sizeof(*r));
+ const char *elementSetName =
+ ZOOM_options_get(p->options, "elementSetName");
apdu->u.extendedServicesRequest->taskSpecificParameters = r;
-
- r->direct_reference = odr_oiddup(p->odr_out,
- yaz_oid_extserv_database_update);
+ r->direct_reference = odr_oiddup(p->odr_out, package_oid);
r->descriptor = 0;
r->which = Z_External_update;
r->indirect_reference = 0;
toKeep->databaseName = odr_strdup(p->odr_out, first_db);
toKeep->schema = 0;
- toKeep->elementSetName = 0;
+
+ toKeep->elementSetName = odr_strdup_null(p->odr_out, elementSetName);
+
toKeep->actionQualifier = 0;
toKeep->action = odr_intdup(p->odr_out, action_no);
notToKeep->elements[0]->u.opaque =
odr_create_Odr_oct(p->odr_out,
(const unsigned char *) recordIdOpaque,
- strlen(recordIdOpaque));
+ recordIdOpaque_len);
}
else if (recordIdNumber)
{
else
notToKeep->elements[0]->u.opaque = 0;
notToKeep->elements[0]->supplementalId = 0;
- notToKeep->elements[0]->correlationInfo = 0;
- notToKeep->elements[0]->record =
- z_ext_record_oid(p->odr_out, syntax_oid,
- record_buf, strlen(record_buf));
+ if (correlationInfo_note || correlationInfo_id)
+ {
+ Z_IUCorrelationInfo *ci;
+ ci = notToKeep->elements[0]->correlationInfo =
+ (Z_IUCorrelationInfo *) odr_malloc(p->odr_out, sizeof(*ci));
+ ci->note = odr_strdup_null(p->odr_out, correlationInfo_note);
+ ci->id = correlationInfo_id ?
+ odr_intdup(p->odr_out, atoi(correlationInfo_id)) : 0;
+ }
+ else
+ notToKeep->elements[0]->correlationInfo = 0;
+ if (recordOpaque_buf)
+ {
+ notToKeep->elements[0]->record =
+ z_ext_record_oid_any(p->odr_out, syntax_oid,
+ recordOpaque_buf, recordOpaque_len);
+ }
+ else
+ {
+ notToKeep->elements[0]->record =
+ z_ext_record_oid(p->odr_out, syntax_oid,
+ record_buf, record_len);
+ }
}
if (0 && apdu)
{
return ZOOM_options_get(p->options, key);
}
+ZOOM_API(const char *)
+ ZOOM_package_option_getl(ZOOM_package p, const char *key, int *lenp)
+{
+ return ZOOM_options_getl(p->options, key, lenp);
+}
ZOOM_API(void)
ZOOM_package_option_set(ZOOM_package p, const char *key,
ZOOM_options_set(p->options, key, val);
}
+ZOOM_API(void)
+ ZOOM_package_option_setl(ZOOM_package p, const char *key,
+ const char *val, int len)
+{
+ ZOOM_options_setl(p->options, key, val, len);
+}
+
static int ZOOM_connection_exec_task(ZOOM_connection c)
{
ZOOM_task task = c->tasks;
ret = do_connect(c);
break;
case ZOOM_TASK_SCAN:
- ret = send_scan(c);
+ if (c->proto == PROTO_HTTP)
+ ret = ZOOM_connection_srw_send_scan(c);
+ else
+ ret = ZOOM_connection_send_scan(c);
break;
case ZOOM_TASK_PACKAGE:
ret = send_package(c);
return r;
}
+static int es_response_taskpackage_update(ZOOM_connection c,
+ Z_IUUpdateTaskPackage *utp)
+{
+ if (utp && utp->targetPart)
+ {
+ Z_IUTargetPart *targetPart = utp->targetPart;
+ switch ( *targetPart->updateStatus ) {
+ case Z_IUTargetPart_success:
+ ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "success");
+ break;
+ case Z_IUTargetPart_partial:
+ ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "partial");
+ break;
+ case Z_IUTargetPart_failure:
+ ZOOM_options_set(c->tasks->u.package->options,"updateStatus", "failure");
+ if (targetPart->globalDiagnostics && targetPart->num_globalDiagnostics > 0)
+ response_diag(c, targetPart->globalDiagnostics[0]);
+ break;
+ }
+ // NOTE: Individual record status, surrogate diagnostics, and supplemental diagnostics ARE NOT REPORTED.
+ }
+ return 1;
+}
+
+static int es_response_taskpackage(ZOOM_connection c,
+ Z_TaskPackage *taskPackage)
+{
+ // targetReference
+ Odr_oct *id = taskPackage->targetReference;
+ if (id)
+ ZOOM_options_setl(c->tasks->u.package->options,
+ "targetReference", (char*) id->buf, id->len);
+
+ // taskStatus
+ switch ( *taskPackage->taskStatus ) {
+ case Z_TaskPackage_pending:
+ ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "pending");
+ break;
+ case Z_TaskPackage_active:
+ ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "active");
+ break;
+ case Z_TaskPackage_complete:
+ ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "complete");
+ break;
+ case Z_TaskPackage_aborted:
+ ZOOM_options_set(c->tasks->u.package->options,"taskStatus", "aborted");
+ if ( taskPackage->num_packageDiagnostics && taskPackage->packageDiagnostics )
+ response_diag(c, taskPackage->packageDiagnostics[0]);
+ break;
+ }
+
+ // taskSpecificParameters
+ // NOTE: Only Update implemented, no others.
+ if ( taskPackage->taskSpecificParameters->which == Z_External_update ) {
+ Z_IUUpdateTaskPackage *utp = taskPackage->taskSpecificParameters->u.update->u.taskPackage;
+ es_response_taskpackage_update(c, utp);
+ }
+ return 1;
+}
+
+
static int es_response(ZOOM_connection c,
Z_ExtendedServicesResponse *res)
{
if (!c->tasks || c->tasks->which != ZOOM_TASK_PACKAGE)
return 0;
- if (res->diagnostics && res->num_diagnostics > 0)
- response_diag(c, res->diagnostics[0]);
+ switch (*res->operationStatus) {
+ case Z_ExtendedServicesResponse_done:
+ ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "done");
+ break;
+ case Z_ExtendedServicesResponse_accepted:
+ ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "accepted");
+ break;
+ case Z_ExtendedServicesResponse_failure:
+ ZOOM_options_set(c->tasks->u.package->options,"operationStatus", "failure");
+ if (res->diagnostics && res->num_diagnostics > 0)
+ response_diag(c, res->diagnostics[0]);
+ break;
+ }
if (res->taskPackage &&
res->taskPackage->which == Z_External_extendedService)
{
Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
- Odr_oct *id = taskPackage->targetReference;
-
- if (id)
- ZOOM_options_setl(c->tasks->u.package->options,
- "targetReference", (char*) id->buf, id->len);
+ es_response_taskpackage(c, taskPackage);
}
if (res->taskPackage &&
res->taskPackage->which == Z_External_octet)
switch(apdu->which)
{
case Z_APDU_initResponse:
- yaz_log(log_api, "%p recv_apd: Received Init response", c);
+ yaz_log(log_api, "%p recv_apdu: Received Init response", c);
initrs = apdu->u.initResponse;
ZOOM_connection_option_set(c, "serverImplementationId",
initrs->implementationId ?
}
#if YAZ_HAVE_XML2
-static void handle_srw_response(ZOOM_connection c,
- Z_SRW_searchRetrieveResponse *res)
+static zoom_ret handle_srw_response(ZOOM_connection c,
+ Z_SRW_searchRetrieveResponse *res)
{
ZOOM_resultset resultset = 0;
int i;
NMEM nmem;
ZOOM_Event event;
- int *start;
+ int *start, *count;
const char *syntax, *elementSetName;
if (!c->tasks)
- return;
+ return zoom_complete;
switch(c->tasks->which)
{
case ZOOM_TASK_SEARCH:
resultset = c->tasks->u.search.resultset;
start = &c->tasks->u.search.start;
+ count = &c->tasks->u.search.count;
syntax = c->tasks->u.search.syntax;
elementSetName = c->tasks->u.search.elementSetName;
+
+ if (!c->tasks->u.search.recv_search_fired)
+ {
+ event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
+ ZOOM_connection_put_event(c, event);
+ c->tasks->u.search.recv_search_fired = 1;
+ }
break;
case ZOOM_TASK_RETRIEVE:
resultset = c->tasks->u.retrieve.resultset;
start = &c->tasks->u.retrieve.start;
+ count = &c->tasks->u.retrieve.count;
syntax = c->tasks->u.retrieve.syntax;
elementSetName = c->tasks->u.retrieve.elementSetName;
break;
default:
- return;
+ return zoom_complete;
}
- event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
- ZOOM_connection_put_event(c, event);
resultset->size = 0;
+ if (res->resultSetId)
+ ZOOM_resultset_option_set(resultset, "resultSetId", res->resultSetId);
+
yaz_log(log_details, "%p handle_srw_response got SRW response OK", c);
-
- if (res->numberOfRecords)
- resultset->size = *res->numberOfRecords;
- for (i = 0; i<res->num_records; i++)
+ if (res->num_diagnostics > 0)
{
- int pos;
-
- Z_NamePlusRecord *npr = (Z_NamePlusRecord *)
- odr_malloc(c->odr_in, sizeof(Z_NamePlusRecord));
-
- if (res->records[i].recordPosition &&
- *res->records[i].recordPosition > 0)
- pos = *res->records[i].recordPosition - 1;
- else
- pos = *start + i;
-
- npr->databaseName = 0;
- npr->which = Z_NamePlusRecord_databaseRecord;
- npr->u.databaseRecord = (Z_External *)
- odr_malloc(c->odr_in, sizeof(Z_External));
- npr->u.databaseRecord->descriptor = 0;
- npr->u.databaseRecord->direct_reference =
- odr_oiddup(c->odr_in, yaz_oid_recsyn_xml);
- npr->u.databaseRecord->which = Z_External_octet;
-
- npr->u.databaseRecord->u.octet_aligned = (Odr_oct *)
- odr_malloc(c->odr_in, sizeof(Odr_oct));
- npr->u.databaseRecord->u.octet_aligned->buf = (unsigned char*)
- res->records[i].recordData_buf;
- npr->u.databaseRecord->u.octet_aligned->len =
- npr->u.databaseRecord->u.octet_aligned->size =
- res->records[i].recordData_len;
- record_cache_add(resultset, npr, pos, syntax, elementSetName);
+ set_SRU_error(c, &res->diagnostics[0]);
}
- if (res->num_diagnostics > 0)
+ else
{
- const char *uri = res->diagnostics[0].uri;
- if (uri)
+ if (res->numberOfRecords)
+ resultset->size = *res->numberOfRecords;
+ for (i = 0; i<res->num_records; i++)
{
- int code = 0;
- const char *cp;
- if ((cp = strrchr(uri, '/')))
- code = atoi(cp+1);
- set_dset_error(c, code, uri,
- res->diagnostics[0].details, 0);
+ int pos;
+ Z_SRW_record *sru_rec;
+ Z_SRW_diagnostic *diag = 0;
+ int num_diag;
+
+ Z_NamePlusRecord *npr = (Z_NamePlusRecord *)
+ odr_malloc(c->odr_in, sizeof(Z_NamePlusRecord));
+
+ if (res->records[i].recordPosition &&
+ *res->records[i].recordPosition > 0)
+ pos = *res->records[i].recordPosition - 1;
+ else
+ pos = *start + i;
+
+ sru_rec = &res->records[i];
+
+ npr->databaseName = 0;
+ npr->which = Z_NamePlusRecord_databaseRecord;
+ npr->u.databaseRecord = (Z_External *)
+ odr_malloc(c->odr_in, sizeof(Z_External));
+ npr->u.databaseRecord->descriptor = 0;
+ npr->u.databaseRecord->direct_reference =
+ odr_oiddup(c->odr_in, yaz_oid_recsyn_xml);
+ npr->u.databaseRecord->which = Z_External_octet;
+
+ npr->u.databaseRecord->u.octet_aligned = (Odr_oct *)
+ odr_malloc(c->odr_in, sizeof(Odr_oct));
+ npr->u.databaseRecord->u.octet_aligned->buf = (unsigned char*)
+ sru_rec->recordData_buf;
+ npr->u.databaseRecord->u.octet_aligned->len =
+ npr->u.databaseRecord->u.octet_aligned->size =
+ sru_rec->recordData_len;
+
+ if (sru_rec->recordSchema
+ && !strcmp(sru_rec->recordSchema,
+ "info:srw/schema/1/diagnostics-v1.1"))
+ {
+ sru_decode_surrogate_diagnostics(sru_rec->recordData_buf,
+ sru_rec->recordData_len,
+ &diag, &num_diag,
+ resultset->odr);
+ }
+ record_cache_add(resultset, npr, pos, syntax, elementSetName,
+ sru_rec->recordSchema, diag);
}
+ *count -= i;
+ *start += i;
+ if (*count + *start > resultset->size)
+ *count = resultset->size - *start;
+ if (*count < 0)
+ *count = 0;
+
+ nmem = odr_extract_mem(c->odr_in);
+ nmem_transfer(odr_getmem(resultset->odr), nmem);
+ nmem_destroy(nmem);
+
+ if (*count > 0)
+ return ZOOM_connection_srw_send_search(c);
}
- nmem = odr_extract_mem(c->odr_in);
- nmem_transfer(odr_getmem(resultset->odr), nmem);
+ return zoom_complete;
+}
+#endif
+
+#if YAZ_HAVE_XML2
+static void handle_srw_scan_response(ZOOM_connection c,
+ Z_SRW_scanResponse *res)
+{
+ NMEM nmem = odr_extract_mem(c->odr_in);
+ ZOOM_scanset scan;
+
+ if (!c->tasks || c->tasks->which != ZOOM_TASK_SCAN)
+ return;
+ scan = c->tasks->u.scan.scan;
+
+ if (res->num_diagnostics > 0)
+ set_SRU_error(c, &res->diagnostics[0]);
+
+ scan->scan_response = 0;
+ scan->srw_scan_response = res;
+ nmem_transfer(odr_getmem(scan->odr), nmem);
+
+ ZOOM_options_set_int(scan->options, "number", res->num_terms);
nmem_destroy(nmem);
}
#endif
#if YAZ_HAVE_XML2
static void handle_http(ZOOM_connection c, Z_HTTP_Response *hres)
{
+ zoom_ret cret = zoom_complete;
int ret = -1;
- const char *content_type = z_HTTP_header_lookup(hres->headers,
- "Content-Type");
+ const char *addinfo = 0;
const char *connection_head = z_HTTP_header_lookup(hres->headers,
"Connection");
ZOOM_connection_set_mask(c, 0);
yaz_log(log_details, "%p handle_http", c);
-
- if (content_type && !yaz_strcmp_del("text/xml", content_type, "; "))
+
+ if (!yaz_srw_check_content_type(hres))
+ addinfo = "content-type";
+ else
{
Z_SOAP *soap_package = 0;
ODR o = c->odr_in;
soap_package->u.generic->no == 0)
{
Z_SRW_PDU *sr = (Z_SRW_PDU*) soap_package->u.generic->p;
+
+ ZOOM_options_set(c->options, "sru_version", sr->srw_version);
if (sr->which == Z_SRW_searchRetrieve_response)
- handle_srw_response(c, sr->u.response);
+ cret = handle_srw_response(c, sr->u.response);
+ else if (sr->which == Z_SRW_scan_response)
+ handle_srw_scan_response(c, sr->u.scan_response);
else
ret = -1;
}
if (hres->code != 200)
set_HTTP_error(c, hres->code, 0, 0);
else
- set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
+ set_ZOOM_error(c, ZOOM_ERROR_DECODE, addinfo);
do_close(c);
}
- ZOOM_connection_remove_task(c);
+ if (cret == zoom_complete)
+ ZOOM_connection_remove_task(c);
if (!strcmp(hres->version, "1.0"))
{
/* HTTP 1.0: only if Keep-Alive we stay alive.. */
{
int x;
int err = odr_geterrorx(c->odr_in, &x);
- char msg[60];
+ char msg[100];
const char *element = odr_getelement(c->odr_in);
- sprintf(msg, "ODR code %d:%d element=%-20s",
- err, x, element ? element : "<unknown>");
+ yaz_snprintf(msg, sizeof(msg),
+ "ODR code %d:%d element=%s offset=%d",
+ err, x, element ? element : "<unknown>",
+ odr_offset(c->odr_in));
set_ZOOM_error(c, ZOOM_ERROR_DECODE, msg);
+ if (log_api)
+ {
+ FILE *ber_file = yaz_log_file();
+ if (ber_file)
+ odr_dumpBER(ber_file, c->buf_in, r);
+ }
do_close(c);
}
- else if (gdu->which == Z_GDU_Z3950)
- recv_apdu(c, gdu->u.z3950);
- else if (gdu->which == Z_GDU_HTTP_Response)
+ else
{
+ if (c->odr_print)
+ z_GDU(c->odr_print, &gdu, 0, 0);
+ if (gdu->which == Z_GDU_Z3950)
+ recv_apdu(c, gdu->u.z3950);
+ else if (gdu->which == Z_GDU_HTTP_Response)
+ {
#if YAZ_HAVE_XML2
- handle_http(c, gdu->u.HTTP_Response);
+ handle_http(c, gdu->u.HTTP_Response);
#else
- set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
- do_close(c);
+ set_ZOOM_error(c, ZOOM_ERROR_DECODE, 0);
+ do_close(c);
#endif
+ }
}
c->reconnect_ok = 0;
}
if (c->cs->io_pending & CS_WANT_READ)
mask += ZOOM_SELECT_READ;
ZOOM_connection_set_mask(c, mask);
+ event = ZOOM_Event_create(ZOOM_EVENT_NONE);
+ ZOOM_connection_put_event(c, event);
}
else if (ret == 0)
{
projects / yaz-moved-to-github.git / blobdiff