/* This file is part of the YAZ toolkit.
 * Copyright (C) Index Data
 * See the file LICENSE for details.
 */
/**
 * \file zoom-z3950.c
 * \brief Implements ZOOM Z39.50 handling
 */
#if HAVE_CONFIG_H
#include <config.h>
#endif

#include <assert.h>
#include <string.h>
#include <errno.h>
#include "zoom-p.h"

#include <yaz/yaz-util.h>
#include <yaz/xmalloc.h>
#include <yaz/otherinfo.h>
#include <yaz/log.h>
#include <yaz/pquery.h>
#include <yaz/marcdisp.h>
#include <yaz/diagbib1.h>
#include <yaz/charneg.h>
#include <yaz/ill.h>
#include <yaz/query-charset.h>
#include <yaz/copy_types.h>
#include <yaz/snprintf.h>
#include <yaz/facet.h>

#include <yaz/shptr.h>

/*
 * 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,
                                     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)
        yaz_log(YLOG_WARN, "%p OID lookup (%d, '%s') failed",
                c, (int) oid_class, str);
    return res;
}

static Z_APDU *create_es_package(ZOOM_package p, const Odr_oid *oid)
{
    const char *str;
    Z_APDU *apdu = zget_APDU(p->odr_out, Z_APDU_extendedServicesRequest);
    Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;

    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_null(p->odr_out, str);

    req->packageType = odr_oiddup(p->odr_out, oid);

    str = ZOOM_options_get(p->options, "function");
    if (str)
    {
        if (!strcmp (str, "create"))
            *req->function = Z_ExtendedServicesRequest_create;
        if (!strcmp (str, "delete"))
            *req->function = Z_ExtendedServicesRequest_delete;
        if (!strcmp (str, "modify"))
            *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;
}

static const char *ill_array_lookup(void *clientData, const char *idx)
{
    ZOOM_package p = (ZOOM_package) clientData;
    return ZOOM_options_get(p->options, idx+4);
}

static Z_External *encode_ill_request(ZOOM_package p)
{
    ODR out = p->odr_out;
    ILL_Request *req;
    Z_External *r = 0;
    struct ill_get_ctl ctl;

    ctl.odr = p->odr_out;
    ctl.clientData = p;
    ctl.f = ill_array_lookup;

    req = ill_get_ILLRequest(&ctl, "ill", 0);

    if (!ill_Request(out, &req, 0, 0))
    {
        int ill_request_size;
        char *ill_request_buf = odr_getbuf(out, &ill_request_size, 0);
        if (ill_request_buf)
            odr_setbuf(out, ill_request_buf, ill_request_size, 1);
        return 0;
    }
    else
    {
        int illRequest_size = 0;
        char *illRequest_buf = odr_getbuf(out, &illRequest_size, 0);

        r = (Z_External *) odr_malloc(out, sizeof(*r));
        r->direct_reference = odr_oiddup(out, yaz_oid_general_isoill_1);
        r->indirect_reference = 0;
        r->descriptor = 0;
        r->which = Z_External_single;

        r->u.single_ASN1_type =
            odr_create_Odr_oct(out, illRequest_buf, illRequest_size);
    }
    return r;
}

static Z_ItemOrder *encode_item_order(ZOOM_package p)
{
    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(Z_IORequest));

    /* to keep part ... */
    req->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
        odr_malloc(p->odr_out,sizeof(Z_IOOriginPartToKeep));
    req->u.esRequest->toKeep->supplDescription = 0;
    req->u.esRequest->toKeep->contact = (Z_IOContact *)
        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 =
        odr_strdup_null(p->odr_out, str);

    str = ZOOM_options_get(p->options, "contact-phone");
    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 =
        odr_strdup_null(p->odr_out, str);

    req->u.esRequest->toKeep->addlBilling = 0;

    /* not to keep part ... */
    req->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
        odr_malloc(p->odr_out,sizeof(Z_IOOriginPartNotToKeep));

    str = ZOOM_options_get(p->options, "itemorder-setname");
    if (!str)
        str = "default";

    if (!*str)
        req->u.esRequest->notToKeep->resultSetItem = 0;
    else
    {
        req->u.esRequest->notToKeep->resultSetItem = (Z_IOResultSetItem *)
            odr_malloc(p->odr_out, sizeof(Z_IOResultSetItem));

        req->u.esRequest->notToKeep->resultSetItem->resultSetId =
            odr_strdup(p->odr_out, str);
        req->u.esRequest->notToKeep->resultSetItem->item =
            odr_intdup(p->odr_out, 0);

        str = ZOOM_options_get(p->options, "itemorder-item");
        *req->u.esRequest->notToKeep->resultSetItem->item =
            (str ? atoi(str) : 1);
    }

    str = ZOOM_options_getl(p->options, "doc", &len);
    if (str)
    {
        req->u.esRequest->notToKeep->itemRequest =
            z_ext_record_xml(p->odr_out, str, len);
    }
    else
        req->u.esRequest->notToKeep->itemRequest = encode_ill_request(p);

    return req;
}

Z_APDU *create_admin_package(ZOOM_package p, int type,
                             Z_ESAdminOriginPartToKeep **toKeepP,
                             Z_ESAdminOriginPartNotToKeep **notToKeepP)
{
    Z_APDU *apdu = create_es_package(p, yaz_oid_extserv_admin);
    if (apdu)
    {
        Z_ESAdminOriginPartToKeep  *toKeep;
        Z_ESAdminOriginPartNotToKeep  *notToKeep;
        Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));
        const char *first_db = "Default";
        int num_db;
        char **db = ZOOM_connection_get_databases(p->connection,
                                                  p->options, &num_db,
                                                  p->odr_out);
        if (num_db > 0)
            first_db = db[0];

        r->direct_reference = odr_oiddup(p->odr_out, yaz_oid_extserv_admin);
        r->descriptor = 0;
        r->indirect_reference = 0;
        r->which = Z_External_ESAdmin;

        r->u.adminService = (Z_Admin *)
            odr_malloc(p->odr_out, sizeof(*r->u.adminService));
        r->u.adminService->which = Z_Admin_esRequest;
        r->u.adminService->u.esRequest = (Z_AdminEsRequest *)
            odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest));

        toKeep = r->u.adminService->u.esRequest->toKeep =
            (Z_ESAdminOriginPartToKeep *)
            odr_malloc(p->odr_out, sizeof(*r->u.adminService->u.esRequest->toKeep));
        toKeep->which = type;
        toKeep->databaseName = odr_strdup(p->odr_out, first_db);
        toKeep->u.create = odr_nullval();
        apdu->u.extendedServicesRequest->taskSpecificParameters = r;

        r->u.adminService->u.esRequest->notToKeep = notToKeep =
            (Z_ESAdminOriginPartNotToKeep *)
            odr_malloc(p->odr_out,
                       sizeof(*r->u.adminService->u.esRequest->notToKeep));
        notToKeep->which = Z_ESAdminOriginPartNotToKeep_recordsWillFollow;
        notToKeep->u.recordsWillFollow = odr_nullval();
        if (toKeepP)
            *toKeepP = toKeep;
        if (notToKeepP)
            *notToKeepP = notToKeep;
    }
    return apdu;
}

static Z_APDU *create_xmlupdate_package(ZOOM_package 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));
    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->descriptor = 0;
    ext->indirect_reference = 0;

    ext->which = Z_External_octet;
    ext->u.single_ASN1_type = odr_create_Odr_oct(p->odr_out, doc, len);
    return apdu;
}

static Z_APDU *create_update_package(ZOOM_package p)
{
    Z_APDU *apdu = 0;
    const char *first_db = "Default";
    int num_db;
    char **db = ZOOM_connection_get_databases(p->connection, p->options,
                                              &num_db, p->odr_out);
    const char *action = ZOOM_options_get(p->options, "action");
    int recordIdOpaque_len;
    const char *recordIdOpaque = ZOOM_options_getl(p->options, "recordIdOpaque",
        &recordIdOpaque_len);
    const char *recordIdNumber = ZOOM_options_get(p->options, "recordIdNumber");
    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 && !recordOpaque_buf)
    {
        record_buf = "void";
        record_len = 4;
        syntax_str = "SUTRS";
    }

    if (syntax_str)
    {
        syntax_oid = yaz_string_to_oid_odr(yaz_oid_std(),
                                           CLASS_RECSYN, syntax_str,
                                           p->odr_out);
    }
    if (!syntax_oid)
    {
        ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_SYNTAX, syntax_str);
        return 0;
    }

    if (num_db > 0)
        first_db = db[0];

    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:
        ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_VERSION, version);
        return 0;
    }

    if (!strcmp(action, "recordInsert"))
        action_no = Z_IUOriginPartToKeep_recordInsert;
    else if (!strcmp(action, "recordReplace"))
        action_no = Z_IUOriginPartToKeep_recordReplace;
    else if (!strcmp(action, "recordDelete"))
        action_no = Z_IUOriginPartToKeep_recordDelete;
    else if (!strcmp(action, "elementUpdate"))
        action_no = Z_IUOriginPartToKeep_elementUpdate;
    else if (!strcmp(action, "specialUpdate"))
        action_no = Z_IUOriginPartToKeep_specialUpdate;
    else
    {
        ZOOM_set_error(p->connection, ZOOM_ERROR_ES_INVALID_ACTION, action);
        return 0;
    }

    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, package_oid);
        r->descriptor = 0;
        r->which = Z_External_update;
        r->indirect_reference = 0;
        r->u.update = (Z_IUUpdate *)
            odr_malloc(p->odr_out, sizeof(*r->u.update));

        r->u.update->which = Z_IUUpdate_esRequest;
        r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
            odr_malloc(p->odr_out, sizeof(*r->u.update->u.esRequest));
        toKeep = r->u.update->u.esRequest->toKeep =
            (Z_IUOriginPartToKeep *)
            odr_malloc(p->odr_out, sizeof(*toKeep));

        toKeep->databaseName = odr_strdup(p->odr_out, first_db);
        toKeep->schema = 0;

        toKeep->elementSetName = odr_strdup_null(p->odr_out, elementSetName);

        toKeep->actionQualifier = 0;
        toKeep->action = odr_intdup(p->odr_out, action_no);

        notToKeep = r->u.update->u.esRequest->notToKeep =
            (Z_IUSuppliedRecords *)
            odr_malloc(p->odr_out, sizeof(*notToKeep));
        notToKeep->num = 1;
        notToKeep->elements = (Z_IUSuppliedRecords_elem **)
            odr_malloc(p->odr_out, sizeof(*notToKeep->elements));
        notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
            odr_malloc(p->odr_out, sizeof(**notToKeep->elements));
        notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
        if (recordIdOpaque)
        {
            notToKeep->elements[0]->u.opaque =
                odr_create_Odr_oct(p->odr_out, recordIdOpaque,
                                   recordIdOpaque_len);
        }
        else if (recordIdNumber)
        {
            notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_number;

            notToKeep->elements[0]->u.number =
                odr_intdup(p->odr_out, atoi(recordIdNumber));
        }
        else
            notToKeep->elements[0]->u.opaque = 0;
        notToKeep->elements[0]->supplementalId = 0;
        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)
    {
        ODR print = odr_createmem(ODR_PRINT);

        z_APDU(print, &apdu, 0, 0);
        odr_destroy(print);
    }
    return apdu;
}


static void otherInfo_attach(ZOOM_connection c, Z_APDU *a, ODR out)
{
    int i;
    for (i = 0; i < 200; i++)
    {
        size_t len;
        Odr_oid *oid;
        Z_OtherInformation **oi;
        char buf[80];
        const char *val;
        const char *cp;

        sprintf(buf, "otherInfo%d", i);
        val = ZOOM_options_get(c->options, buf);
        if (!val)
            break;
        cp = strchr(val, ':');
        if (!cp)
            continue;
        len = cp - val;
        if (len >= sizeof(buf))
            len = sizeof(buf)-1;
        memcpy(buf, val, len);
        buf[len] = '\0';

        oid = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_USERINFO,
                                    buf, out);
        if (!oid)
            continue;

        yaz_oi_APDU(a, &oi);
        yaz_oi_set_string_oid(oi, out, oid, 1, cp+1);
    }
}



static int encode_APDU(ZOOM_connection c, Z_APDU *a, ODR out)
{
    assert(a);
    if (c->cookie_out)
    {
        Z_OtherInformation **oi;
        yaz_oi_APDU(a, &oi);
        yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_cookie,
                              1, c->cookie_out);
    }
    if (c->client_IP && a->which == Z_APDU_initRequest)
    {
        Z_OtherInformation **oi;
        yaz_oi_APDU(a, &oi);
        yaz_oi_set_string_oid(oi, out, yaz_oid_userinfo_client_ip,
                              1, c->client_IP);
    }
    otherInfo_attach(c, a, out);
    if (!z_APDU(out, &a, 0, 0))
    {
        FILE *outf = fopen("/tmp/apdu.txt", "a");
        if (a && outf)
        {
            ODR odr_pr = odr_createmem(ODR_PRINT);
            fprintf(outf, "a=%p\n", a);
            odr_setprint(odr_pr, outf);
            z_APDU(odr_pr, &a, 0, 0);
            odr_destroy(odr_pr);
        }
        yaz_log(c->log_api, "%p encoding_APDU: encoding failed", c);
        ZOOM_set_error(c, ZOOM_ERROR_ENCODE, 0);
        odr_reset(out);
        return -1;
    }
    if (c->odr_print)
        z_APDU(c->odr_print, &a, 0, 0);
    if (c->odr_save)
        z_APDU(c->odr_save, &a, 0, 0);
    yaz_log(c->log_details, "%p encoding_APDU encoding OK", c);
    return 0;
}

static zoom_ret send_APDU(ZOOM_connection c, Z_APDU *a)
{
    ZOOM_Event event;
    assert(a);
    if (encode_APDU(c, a, c->odr_out))
        return zoom_complete;
    yaz_log(c->log_details, "%p send APDU type=%d", c, a->which);
    c->buf_out = odr_getbuf(c->odr_out, &c->len_out, 0);
    event = ZOOM_Event_create(ZOOM_EVENT_SEND_APDU);
    ZOOM_connection_put_event(c, event);
    odr_reset(c->odr_out);
    return ZOOM_send_buf(c);
}

zoom_ret ZOOM_connection_Z3950_send_init(ZOOM_connection c)
{
    Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_initRequest);
    Z_InitRequest *ireq = apdu->u.initRequest;
    Z_IdAuthentication *auth = (Z_IdAuthentication *)
        odr_malloc(c->odr_out, sizeof(*auth));

    ODR_MASK_SET(ireq->options, Z_Options_search);
    ODR_MASK_SET(ireq->options, Z_Options_present);
    ODR_MASK_SET(ireq->options, Z_Options_scan);
    ODR_MASK_SET(ireq->options, Z_Options_sort);
    ODR_MASK_SET(ireq->options, Z_Options_extendedServices);
    ODR_MASK_SET(ireq->options, Z_Options_namedResultSets);

    ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_1);
    ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_2);
    ODR_MASK_SET(ireq->protocolVersion, Z_ProtocolVersion_3);

    ireq->implementationId =
        odr_prepend(c->odr_out,
                    ZOOM_options_get(c->options, "implementationId"),
                    ireq->implementationId);

    ireq->implementationName =
        odr_prepend(c->odr_out,
                    ZOOM_options_get(c->options, "implementationName"),
                    odr_prepend(c->odr_out, "ZOOM-C",
                                ireq->implementationName));

    ireq->implementationVersion =
        odr_prepend(c->odr_out,
                    ZOOM_options_get(c->options, "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 = 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;
    }
    else if (c->user)
    {
        auth->which = Z_IdAuthentication_open;
        auth->u.open = odr_strdup(c->odr_out, c->user);
        ireq->idAuthentication = auth;
    }
    if (c->proxy_mode)
    {
        yaz_oi_set_string_oid(&ireq->otherInfo, c->odr_out,
                              yaz_oid_userinfo_proxy, 1, c->host_port);
    }
    if (c->charset || c->lang)
    {
        Z_OtherInformation **oi;
        Z_OtherInformationUnit *oi_unit;

        yaz_oi_APDU(apdu, &oi);

        if ((oi_unit = yaz_oi_update(oi, c->odr_out, NULL, 0, 0)))
        {
            ODR_MASK_SET(ireq->options, Z_Options_negotiationModel);
            oi_unit->which = Z_OtherInfo_externallyDefinedInfo;
            oi_unit->information.externallyDefinedInfo =
                yaz_set_proposal_charneg_list(c->odr_out, " ",
                                              c->charset, c->lang, 1);
        }
    }
    assert(apdu);
    return send_APDU(c, apdu);
}

static zoom_ret Z3950_send_search(ZOOM_connection c)
{
    ZOOM_resultset r;
    int lslb, ssub, mspn;
    const char *syntax;
    const char *schema;
    Z_APDU *apdu;
    Z_SearchRequest *search_req;
    const char *elementSetName;
    const char *smallSetElementSetName;
    const char *mediumSetElementSetName;

    assert(c->tasks);
    assert(c->tasks->which == ZOOM_TASK_SEARCH);
    r = c->tasks->u.search.resultset;

    apdu = zget_APDU(c->odr_out, Z_APDU_searchRequest);
    search_req = apdu->u.searchRequest;

    yaz_log(c->log_details, "%p Z3950_send_search set=%p", c, r);

    elementSetName = c->tasks->u.search.elementSetName;
    smallSetElementSetName  =
        ZOOM_options_get(r->options, "smallSetElementSetName");
    mediumSetElementSetName =
        ZOOM_options_get(r->options, "mediumSetElementSetName");

    if (!smallSetElementSetName)
        smallSetElementSetName = elementSetName;

    if (!mediumSetElementSetName)
        mediumSetElementSetName = elementSetName;

    if (r->req_facets)
    {
        Z_FacetList *facet_list =
            yaz_pqf_parse_facet_list(c->odr_out, r->req_facets);
        if (facet_list)
        {
            Z_OtherInformation **oi = &search_req->additionalSearchInfo;
            yaz_oi_set_facetlist(oi, c->odr_out, facet_list);
        }
        else
            yaz_log(YLOG_WARN, "Unable to parse facets: %s", r->req_facets);
    }

    assert(r);
    assert(r->query);

    /* prepare query for the search request */
    search_req->query = ZOOM_query_get_Z_Query(r->query);
    if (!search_req->query)
    {
        ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
        return zoom_complete;
    }
    if (search_req->query->which == Z_Query_type_1 ||
        search_req->query->which == Z_Query_type_101)
    {
        const char *cp = ZOOM_options_get(r->options, "rpnCharset");
        if (cp)
        {
            yaz_iconv_t cd = yaz_iconv_open(cp, "UTF-8");
            if (cd)
            {
                int r;
                search_req->query = yaz_copy_Z_Query(search_req->query,
                                                     c->odr_out);

                r = yaz_query_charset_convert_rpnquery_check(
                    search_req->query->u.type_1,
                    c->odr_out, cd);
                yaz_iconv_close(cd);
                if (r)
                {  /* query could not be char converted */
                    ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
                    return zoom_complete;
                }
            }
        }
    }
    search_req->databaseNames = r->databaseNames;
    search_req->num_databaseNames = r->num_databaseNames;

    /* get syntax (no need to provide unless piggyback is in effect) */
    syntax = c->tasks->u.search.syntax;

    schema = c->tasks->u.search.schema;

    lslb = ZOOM_options_get_int(r->options, "largeSetLowerBound", -1);
    ssub = ZOOM_options_get_int(r->options, "smallSetUpperBound", -1);
    mspn = ZOOM_options_get_int(r->options, "mediumSetPresentNumber", -1);
    if (lslb != -1 && ssub != -1 && mspn != -1)
    {
        /* So're a Z39.50 expert? Let's hope you don't do sort */
        *search_req->largeSetLowerBound = lslb;
        *search_req->smallSetUpperBound = ssub;
        *search_req->mediumSetPresentNumber = mspn;
    }
    else if (c->tasks->u.search.start == 0 && c->tasks->u.search.count > 0
             && r->piggyback && !r->r_sort_spec && !schema)
    {
        /* Regular piggyback - do it unless we're going to do sort */
        *search_req->largeSetLowerBound = 2000000000;
        *search_req->smallSetUpperBound = 1;
        *search_req->mediumSetPresentNumber =
            r->step>0 ? r->step : c->tasks->u.search.count;
    }
    else
    {
        /* non-piggyback. Need not provide elementsets or syntaxes .. */
        smallSetElementSetName = 0;
        mediumSetElementSetName = 0;
        syntax = 0;
    }
    if (smallSetElementSetName && *smallSetElementSetName)
    {
        Z_ElementSetNames *esn = (Z_ElementSetNames *)
            odr_malloc(c->odr_out, sizeof(*esn));

        esn->which = Z_ElementSetNames_generic;
        esn->u.generic = odr_strdup(c->odr_out, smallSetElementSetName);
        search_req->smallSetElementSetNames = esn;
    }
    if (mediumSetElementSetName && *mediumSetElementSetName)
    {
        Z_ElementSetNames *esn =(Z_ElementSetNames *)
            odr_malloc(c->odr_out, sizeof(*esn));

        esn->which = Z_ElementSetNames_generic;
        esn->u.generic = odr_strdup(c->odr_out, mediumSetElementSetName);
        search_req->mediumSetElementSetNames = esn;
    }
    if (syntax)
        search_req->preferredRecordSyntax =
            zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);

    if (!r->setname)
    {
        if (c->support_named_resultsets)
        {
            char setname[14];
            int ord;
            /* find the lowest unused ordinal so that we re-use
               result sets on the server. */
            for (ord = 1; ; ord++)
            {
                ZOOM_resultset rp;
                sprintf(setname, "%d", ord);
                for (rp = c->resultsets; rp; rp = rp->next)
                    if (rp->setname && !strcmp(rp->setname, setname))
                        break;
                if (!rp)
                    break;
            }
            r->setname = odr_strdup(r->odr, setname);
            yaz_log(c->log_details, "%p ZOOM_connection_send_search: "
                    "allocating set %s", c, r->setname);
        }
        else
        {
            yaz_log(c->log_details, "%p ZOOM_connection_send_search: using "
                    "default set", c);
            r->setname = odr_strdup(r->odr, "default");
        }
        ZOOM_options_set(r->options, "setname", r->setname);
    }
    search_req->resultSetName = odr_strdup(c->odr_out, r->setname);
    return send_APDU(c, apdu);
}

zoom_ret ZOOM_connection_Z3950_send_scan(ZOOM_connection c)
{
    ZOOM_scanset scan;
    Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_scanRequest);
    Z_ScanRequest *req = apdu->u.scanRequest;
    Z_Query *z_query;

    yaz_log(c->log_details, "%p send_scan", c);
    if (!c->tasks)
        return zoom_complete;
    assert (c->tasks->which == ZOOM_TASK_SCAN);
    scan = c->tasks->u.scan.scan;

    z_query = ZOOM_query_get_Z_Query(scan->query);

    /* Z39.50 scan can only carry RPN */
    if (z_query->which == Z_Query_type_1 ||
        z_query->which == Z_Query_type_101)
    {
        Z_RPNQuery *rpn = 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
        {
            ZOOM_set_error(c, ZOOM_ERROR_INVALID_QUERY, 0);
            return zoom_complete;
        }
    }
    else
    {
        ZOOM_set_error(c, ZOOM_ERROR_UNSUPPORTED_QUERY, 0);
        return zoom_complete;
    }

    *req->numberOfTermsRequested =
        ZOOM_options_get_int(scan->options, "number", 20);

    req->preferredPositionInResponse =
        odr_intdup(c->odr_out,
                   ZOOM_options_get_int(scan->options, "position", 1));

    req->stepSize =
        odr_intdup(c->odr_out,
                   ZOOM_options_get_int(scan->options, "stepSize", 0));

    req->databaseNames = scan->databaseNames;
    req->num_databaseNames = scan->num_databaseNames;

    return send_APDU(c, apdu);
}

ZOOM_API(void)
    ZOOM_package_send(ZOOM_package p, const char *type)
{
    Z_APDU *apdu = 0;
    ZOOM_connection c;
    if (!p)
        return;
    c = p->connection;
    odr_reset(p->odr_out);
    xfree(p->buf_out);
    p->buf_out = 0;
    if (!strcmp(type, "itemorder"))
    {
        apdu = create_es_package(p, yaz_oid_extserv_item_order);
        if (apdu)
        {
            Z_External *r = (Z_External *) odr_malloc(p->odr_out, sizeof(*r));

            r->direct_reference =
                odr_oiddup(p->odr_out, yaz_oid_extserv_item_order);
            r->descriptor = 0;
            r->which = Z_External_itemOrder;
            r->indirect_reference = 0;
            r->u.itemOrder = encode_item_order(p);

            apdu->u.extendedServicesRequest->taskSpecificParameters = r;
        }
    }
    else if (!strcmp(type, "create"))  /* create database */
    {
        apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_create,
                                    0, 0);
    }
    else if (!strcmp(type, "drop"))  /* drop database */
    {
        apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_drop,
                                    0, 0);
    }
    else if (!strcmp(type, "commit"))  /* commit changes */
    {
        apdu = create_admin_package(p, Z_ESAdminOriginPartToKeep_commit,
                                    0, 0);
    }
    else if (!strcmp(type, "update")) /* update record(s) */
    {
        apdu = create_update_package(p);
    }
    else if (!strcmp(type, "xmlupdate"))
    {
        apdu = create_xmlupdate_package(p);
    }
    if (apdu)
    {
        if (encode_APDU(p->connection, apdu, p->odr_out) == 0)
        {
            char *buf;

            ZOOM_task task = ZOOM_connection_add_task(c, ZOOM_TASK_PACKAGE);
            task->u.package = p;
            buf = odr_getbuf(p->odr_out, &p->len_out, 0);
            p->buf_out = (char *) xmalloc(p->len_out);
            memcpy(p->buf_out, buf, p->len_out);

            (p->refcount)++;
            if (!c->async)
            {
                while (ZOOM_event(1, &c))
                    ;
            }
        }
    }
}

static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
                                 int present_phase);

static void response_default_diag(ZOOM_connection c, Z_DefaultDiagFormat *r)
{
    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:
        addinfo = r->u.v2Addinfo;
        break;
    case Z_DefaultDiagFormat_v3Addinfo:
        addinfo = r->u.v3Addinfo;
        break;
    }
    xfree(c->addinfo);
    c->addinfo = 0;
    ZOOM_set_dset_error(c, *r->condition, oid_name, addinfo, 0);
}

static void response_diag(ZOOM_connection c, Z_DiagRec *p)
{
    if (p->which != Z_DiagRec_defaultFormat)
        ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
    else
        response_default_diag(c, p->u.defaultFormat);
}

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)
{
    Odr_oct *id = taskPackage->targetReference;
    if (id)
        ZOOM_options_setl(c->tasks->u.package->options,
                          "targetReference", (char*) id->buf, id->len);
    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;
    }
    /* 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 void handle_Z3950_es_response(ZOOM_connection c,
                                     Z_ExtendedServicesResponse *res)
{
    if (!c->tasks)
        return;
    assert(c->tasks->which == ZOOM_TASK_PACKAGE);
    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;
        es_response_taskpackage(c, taskPackage);
    }
    if (res->taskPackage &&
        res->taskPackage->which == Z_External_octet)
    {
        Odr_oct *doc = res->taskPackage->u.octet_aligned;
        ZOOM_options_setl(c->tasks->u.package->options,
                          "xmlUpdateDoc", (char*) doc->buf, doc->len);
    }
}

static char *get_term_cstr(ODR odr, Z_Term *term)
{
    switch (term->which)
    {
    case Z_Term_general:
        return odr_strdupn(odr, term->u.general->buf, term->u.general->len);
        break;
    case Z_Term_characterString:
        return odr_strdup(odr, term->u.characterString);
    }
    return 0;
}

static ZOOM_facet_field get_zoom_facet_field(ODR odr, Z_FacetField *facet)
{
    int i;
    struct yaz_facet_attr attr_values;
    ZOOM_facet_field facet_field = odr_malloc(odr, sizeof(*facet_field));
    yaz_facet_attr_init(&attr_values);
    yaz_facet_attr_get_z_attributes(facet->attributes, &attr_values);
    facet_field->facet_name = odr_strdup(odr, attr_values.useattr);
    facet_field->num_terms = facet->num_terms;
    yaz_log(YLOG_DEBUG, "ZOOM_facet_field %s %d terms %d",
            attr_values.useattr, attr_values.limit, facet->num_terms);
    facet_field->facet_terms =
        odr_malloc(odr, facet->num_terms * sizeof(*facet_field->facet_terms));
    for (i = 0 ; i < facet->num_terms; i++)
    {
        Z_FacetTerm *facetTerm = facet->terms[i];
        facet_field->facet_terms[i].frequency = *facetTerm->count;
        facet_field->facet_terms[i].term = get_term_cstr(odr, facetTerm->term);
        yaz_log(YLOG_DEBUG, "    term[%d] %s %d",
                i, facet_field->facet_terms[i].term,
                facet_field->facet_terms[i].frequency);
    }
    return facet_field;
}

/* Can be share with SOLR/SRU/SRW requests */
void ZOOM_handle_facet_list(ZOOM_resultset r, Z_FacetList *fl)
{
    int j;
    r->num_res_facets = fl->num;
    yaz_log(YLOG_DEBUG, "Facets found: %d", fl->num);
    r->res_facets =  odr_malloc(r->odr, fl->num * sizeof(*r->res_facets));
    r->facets_names =  odr_malloc(r->odr, fl->num * sizeof(*r->facets_names));
    for (j = 0; j < fl->num; j++)
    {
        r->res_facets[j] = get_zoom_facet_field(r->odr, fl->elements[j]);
        if (!r->res_facets[j])
        {
            r->facets_names[j] = 0;
            yaz_log(YLOG_DEBUG, "Facet field missing on index %d !", j);
        }
        else
            r->facets_names[j] = (char *)
                ZOOM_facet_field_name(r->res_facets[j]);
    }
}

void ZOOM_handle_facet_result(ZOOM_connection c, ZOOM_resultset r,
                              Z_OtherInformation *o)
{
    int i;
    for (i = 0; o && i < o->num_elements; i++)
    {
        if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
        {
            Z_External *ext = o->list[i]->information.externallyDefinedInfo;
            if (ext->which == Z_External_userFacets)
            {
                ZOOM_handle_facet_list(r, ext->u.facetList);
            }
        }
    }
}

static void handle_queryExpressionTerm(ZOOM_options opt, const char *name,
                                       Z_Term *term)
{
    switch (term->which)
    {
    case Z_Term_general:
        ZOOM_options_setl(opt, name,
                          term->u.general->buf, term->u.general->len);
        break;
    case Z_Term_characterString:
        ZOOM_options_set(opt, name, term->u.characterString);
        break;
    case Z_Term_numeric:
        ZOOM_options_set_int(opt, name, *term->u.numeric);
        break;
    }
}

static void handle_queryExpression(ZOOM_options opt, const char *name,
                                   Z_QueryExpression *exp)
{
    char opt_name[80];

    switch (exp->which)
    {
    case Z_QueryExpression_term:
        if (exp->u.term && exp->u.term->queryTerm)
        {
            sprintf(opt_name, "%s.term", name);
            handle_queryExpressionTerm(opt, opt_name, exp->u.term->queryTerm);
        }
        break;
    case Z_QueryExpression_query:
        break;
    }
}


void ZOOM_handle_search_result(ZOOM_connection c, ZOOM_resultset resultset,
                               Z_OtherInformation *o)
{
    int i;
    for (i = 0; o && i < o->num_elements; i++)
    {
        if (o->list[i]->which == Z_OtherInfo_externallyDefinedInfo)
        {
            Z_External *ext = o->list[i]->information.externallyDefinedInfo;

            if (ext->which == Z_External_searchResult1)
            {
                int j;
                Z_SearchInfoReport *sr = ext->u.searchResult1;

                if (sr->num)
                    ZOOM_options_set_int(
                        resultset->options, "searchresult.size", sr->num);

                for (j = 0; j < sr->num; j++)
                {
                    Z_SearchInfoReport_s *ent =
                        ext->u.searchResult1->elements[j];
                    char pref[80];

                    sprintf(pref, "searchresult.%d", j);

                    if (ent->subqueryId)
                    {
                        char opt_name[80];
                        sprintf(opt_name, "%s.id", pref);
                        ZOOM_options_set(resultset->options, opt_name,
                                         ent->subqueryId);
                    }
                    if (ent->subqueryExpression)
                    {
                        char opt_name[80];
                        sprintf(opt_name, "%s.subquery", pref);
                        handle_queryExpression(resultset->options, opt_name,
                                               ent->subqueryExpression);
                    }
                    if (ent->subqueryInterpretation)
                    {
                        char opt_name[80];
                        sprintf(opt_name, "%s.interpretation", pref);
                        handle_queryExpression(resultset->options, opt_name,
                                               ent->subqueryInterpretation);
                    }
                    if (ent->subqueryRecommendation)
                    {
                        char opt_name[80];
                        sprintf(opt_name, "%s.recommendation", pref);
                        handle_queryExpression(resultset->options, opt_name,
                                               ent->subqueryRecommendation);
                    }
                    if (ent->subqueryCount)
                    {
                        char opt_name[80];
                        sprintf(opt_name, "%s.count", pref);
                        ZOOM_options_set_int(resultset->options, opt_name,
                                             *ent->subqueryCount);
                    }
                }
            }
        }
    }
}

static void handle_Z3950_search_response(ZOOM_connection c,
                                         Z_SearchResponse *sr)
{
    ZOOM_resultset resultset;
    ZOOM_Event event;
    const char *resultCountPrecision = "exact";

    if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
        return;

    resultset = c->tasks->u.search.resultset;

    if (resultset->live_set == 0)
    {
        event = ZOOM_Event_create(ZOOM_EVENT_RECV_SEARCH);
        ZOOM_connection_put_event(c, event);
    }
    if (sr->resultSetStatus)
    {
        if (*sr->resultSetStatus == Z_SearchResponse_estimate)
            resultCountPrecision = "estimate";
        ZOOM_options_set_int(resultset->options, "resultSetStatus",
                             *sr->resultSetStatus);
    }
    if (sr->presentStatus)
    {
        ZOOM_options_set_int(resultset->options, "presentStatus",
                             *sr->presentStatus);
    }
    ZOOM_options_set(resultset->options, "resultCountPrecision",
                     resultCountPrecision);
    ZOOM_handle_search_result(c, resultset, sr->additionalSearchInfo);

    ZOOM_handle_facet_result(c, resultset, sr->additionalSearchInfo);

    resultset->size = *sr->resultCount;

    ZOOM_memcached_hitcount(c, resultset, sr->additionalSearchInfo,
                            resultCountPrecision);
    resultset->live_set = 2;
    handle_Z3950_records(c, sr->records, 0);
}

static void handle_Z3950_sort_response(ZOOM_connection c, Z_SortResponse *res)
{
    if (res->diagnostics && res->num_diagnostics > 0)
    {
        response_diag(c, res->diagnostics[0]);
        ZOOM_connection_remove_tasks(c);
    }
}

static void handle_Z3950_scan_response(ZOOM_connection c, Z_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->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);
    if (res->positionOfTerm)
        ZOOM_options_set_int(scan->options, "position", *res->positionOfTerm);
    if (res->scanStatus)
        ZOOM_options_set_int(scan->options, "scanStatus", *res->scanStatus);
    if (res->numberOfEntriesReturned)
        ZOOM_options_set_int(scan->options, "number",
                             *res->numberOfEntriesReturned);
    nmem_destroy(nmem);
}

static void handle_Z3950_records(ZOOM_connection c, Z_Records *sr,
                                 int present_phase)
{
    ZOOM_resultset resultset;
    int *start, *count;
    const char *syntax = 0, *elementSetName = 0, *schema = 0;

    if (!c->tasks || c->tasks->which != ZOOM_TASK_SEARCH)
        return ;

    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;
    schema =  c->tasks->u.search.schema;

    if (sr && sr->which == Z_Records_NSD)
    {
        response_default_diag(c, sr->u.nonSurrogateDiagnostic);
        ZOOM_connection_remove_tasks(c);
    }
    else if (sr && sr->which == Z_Records_multipleNSD)
    {
        if (sr->u.multipleNonSurDiagnostics->num_diagRecs >= 1)
            response_diag(c, sr->u.multipleNonSurDiagnostics->diagRecs[0]);
        else
            ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
        ZOOM_connection_remove_tasks(c);
    }
    else
    {
        if (*count + *start > resultset->size)
            *count = resultset->size - *start;
        if (*count < 0)
            *count = 0;
        if (sr && sr->which == Z_Records_DBOSD)
        {
            int i;
            NMEM nmem = odr_extract_mem(c->odr_in);
            Z_NamePlusRecordList *p =
                sr->u.databaseOrSurDiagnostics;
            for (i = 0; i < p->num_records; i++)
            {
                ZOOM_record_cache_add(resultset, p->records[i], i + *start,
                                      syntax, elementSetName, schema, 0);
            }
            *count -= i;
            if (*count < 0)
                *count = 0;
            *start += i;
            yaz_log(c->log_details,
                    "handle_records resultset=%p start=%d count=%d",
                    resultset, *start, *count);

            /* transfer our response to search_nmem .. we need it later */
            nmem_transfer(odr_getmem(resultset->odr), nmem);
            nmem_destroy(nmem);
            if (present_phase && p->num_records == 0)
            {
                /* present response and we didn't get any records! */
                Z_NamePlusRecord *myrec =
                    zget_surrogateDiagRec(
                        resultset->odr, 0,
                        YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
                        "ZOOM C generated. Present phase and no records");
                ZOOM_record_cache_add(resultset, myrec, *start,
                                      syntax, elementSetName, schema, 0);
                *count = 0;
            }
        }
        else if (present_phase)
        {
            /* present response and we didn't get any records! */
            Z_NamePlusRecord *myrec =
                zget_surrogateDiagRec(
                    resultset->odr, 0,
                    YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS,
                    "ZOOM C generated: Present response and no records");
            ZOOM_record_cache_add(resultset, myrec, *start,
                                  syntax, elementSetName, schema, 0);
            *count = 0;
        }
    }
}

static void handle_Z3950_present_response(ZOOM_connection c,
                                          Z_PresentResponse *pr)
{
    handle_Z3950_records(c, pr->records, 1);
}

static void set_init_option(const char *name, void *clientData)
{
    ZOOM_connection c = (ZOOM_connection) clientData;
    char buf[80];

    sprintf(buf, "init_opt_%.70s", name);
    ZOOM_connection_option_set(c, buf, "1");
}

zoom_ret send_Z3950_sort(ZOOM_connection c, ZOOM_resultset resultset)
{
    if (c->error)
        resultset->r_sort_spec = 0;
    if (resultset->r_sort_spec)
    {
        Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_sortRequest);
        Z_SortRequest *req = apdu->u.sortRequest;

        yaz_log(c->log_details, "%p send_Z3950_sort set=%p", c, resultset);

        req->num_inputResultSetNames = 1;
        req->inputResultSetNames = (Z_InternationalString **)
            odr_malloc(c->odr_out, sizeof(*req->inputResultSetNames));
        req->inputResultSetNames[0] =
            odr_strdup(c->odr_out, resultset->setname);
        req->sortedResultSetName = odr_strdup(c->odr_out, resultset->setname);
        req->sortSequence = resultset->r_sort_spec;
        resultset->r_sort_spec = 0;
        return send_APDU(c, apdu);
    }
    return zoom_complete;
}

static zoom_ret Z3950_send_present(ZOOM_connection c)
{
    Z_APDU *apdu = zget_APDU(c->odr_out, Z_APDU_presentRequest);
    Z_PresentRequest *req = apdu->u.presentRequest;
    ZOOM_resultset resultset = c->tasks->u.search.resultset;
    const char *syntax = c->tasks->u.search.syntax;
    const char *elementSetName = c->tasks->u.search.elementSetName;
    const char *schema = c->tasks->u.search.schema;

    yaz_log(c->log_details, "%p Z3950_send_present", c);

    *req->resultSetStartPoint = c->tasks->u.search.start + 1;

    if (resultset->step > 0 && resultset->step < c->tasks->u.search.count)
        *req->numberOfRecordsRequested = resultset->step;
    else
        *req->numberOfRecordsRequested = c->tasks->u.search.count;

    if (*req->numberOfRecordsRequested + c->tasks->u.search.start > resultset->size)
        *req->numberOfRecordsRequested = resultset->size - c->tasks->u.search.start;
    assert(*req->numberOfRecordsRequested > 0);

    if (syntax && *syntax)
        req->preferredRecordSyntax =
            zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, syntax);

    if (schema && *schema)
    {
        Z_RecordComposition *compo = (Z_RecordComposition *)
            odr_malloc(c->odr_out, sizeof(*compo));

        req->recordComposition = compo;
        compo->which = Z_RecordComp_complex;
        compo->u.complex = (Z_CompSpec *)
            odr_malloc(c->odr_out, sizeof(*compo->u.complex));
        compo->u.complex->selectAlternativeSyntax = (bool_t *)
            odr_malloc(c->odr_out, sizeof(bool_t));
        *compo->u.complex->selectAlternativeSyntax = 0;

        compo->u.complex->generic = (Z_Specification *)
            odr_malloc(c->odr_out, sizeof(*compo->u.complex->generic));

        compo->u.complex->generic->which = Z_Schema_oid;
        compo->u.complex->generic->schema.oid = (Odr_oid *)
            zoom_yaz_str_to_z3950oid(c, CLASS_SCHEMA, schema);

        if (!compo->u.complex->generic->schema.oid)
        {
            /* OID wasn't a schema! Try record syntax instead. */

            compo->u.complex->generic->schema.oid = (Odr_oid *)
                zoom_yaz_str_to_z3950oid(c, CLASS_RECSYN, schema);
        }
        if (elementSetName && *elementSetName)
        {
            compo->u.complex->generic->elementSpec = (Z_ElementSpec *)
                odr_malloc(c->odr_out, sizeof(Z_ElementSpec));
            compo->u.complex->generic->elementSpec->which =
                Z_ElementSpec_elementSetName;
            compo->u.complex->generic->elementSpec->u.elementSetName =
                odr_strdup(c->odr_out, elementSetName);
        }
        else
            compo->u.complex->generic->elementSpec = 0;
        compo->u.complex->num_dbSpecific = 0;
        compo->u.complex->dbSpecific = 0;
        compo->u.complex->num_recordSyntax = 0;
        compo->u.complex->recordSyntax = 0;
    }
    else if (elementSetName && *elementSetName)
    {
        Z_ElementSetNames *esn = (Z_ElementSetNames *)
            odr_malloc(c->odr_out, sizeof(*esn));
        Z_RecordComposition *compo = (Z_RecordComposition *)
            odr_malloc(c->odr_out, sizeof(*compo));

        esn->which = Z_ElementSetNames_generic;
        esn->u.generic = odr_strdup(c->odr_out, elementSetName);
        compo->which = Z_RecordComp_simple;
        compo->u.simple = esn;
        req->recordComposition = compo;
    }
    req->resultSetId = odr_strdup(c->odr_out, resultset->setname);
    return send_APDU(c, apdu);
}

zoom_ret ZOOM_connection_Z3950_search(ZOOM_connection c)
{
    int i = 0;
    const char *syntax = 0;
    const char *elementSetName = 0;
    const char *schema = 0;
    ZOOM_resultset resultset;
    int *start, *count;

    if (!c->tasks || c->tasks->which == ZOOM_TASK_SORT)
        return zoom_complete;
    assert(c->tasks->which == 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;
    schema =  c->tasks->u.search.schema;

    yaz_log(c->log_details, "%p ZOOM_connection_Z3950_search start=%d count=%d",
            c, *start, *count);

    ZOOM_memcached_search(c, resultset);

    if (*start < 0 || *count < 0)
    {
        ZOOM_set_dset_error(c, YAZ_BIB1_PRESENT_REQUEST_OUT_OF_RANGE, "Bib-1",
                       "start/count < 0", 0);
    }

    if (resultset->live_set)
    {
        if (*start >= resultset->size)
            *count = 0;
        else if (*start + *count >= resultset->size)
            *count = resultset->size - *start;
    }

    if (c->error)                  /* don't continue on error */
        return zoom_complete;

    for (i = 0; i < *count; i++)
    {
        ZOOM_record rec =
            ZOOM_record_cache_lookup(resultset, i + *start,
                                     syntax, elementSetName, schema);
        if (!rec)
            break;
    }
    *start += i;
    *count -= i;

    if (*count == 0 && resultset->live_set)
        return zoom_complete;

    if (resultset->live_set == 2)
        return Z3950_send_present(c);
    else
        return Z3950_send_search(c);
}

static zoom_ret send_Z3950_sort_present(ZOOM_connection c)
{
    zoom_ret r = zoom_complete;

    if (c->tasks && c->tasks->which == ZOOM_TASK_SEARCH)
        r = send_Z3950_sort(c, c->tasks->u.search.resultset);
    if (r == zoom_complete)
        r = ZOOM_connection_Z3950_search(c);
    return r;
}

void ZOOM_handle_Z3950_apdu(ZOOM_connection c, Z_APDU *apdu)
{
    Z_InitResponse *initrs;

    ZOOM_connection_set_mask(c, 0);
    yaz_log(c->log_details, "%p handle_Z3950_apdu apdu->which=%d",
            c, apdu->which);
    switch (apdu->which)
    {
    case Z_APDU_initResponse:
        yaz_log(c->log_api, "%p handle_Z3950_apdu: Received Init response", c);
        initrs = apdu->u.initResponse;
        ZOOM_connection_option_set(c, "serverImplementationId",
                                   initrs->implementationId ?
                                   initrs->implementationId : "");
        ZOOM_connection_option_set(c, "serverImplementationName",
                                   initrs->implementationName ?
                                   initrs->implementationName : "");
        ZOOM_connection_option_set(c, "serverImplementationVersion",
                                   initrs->implementationVersion ?
                                   initrs->implementationVersion : "");
        /* Set the three old options too, for old applications */
        ZOOM_connection_option_set(c, "targetImplementationId",
                                   initrs->implementationId ?
                                   initrs->implementationId : "");
        ZOOM_connection_option_set(c, "targetImplementationName",
                                   initrs->implementationName ?
                                   initrs->implementationName : "");
        ZOOM_connection_option_set(c, "targetImplementationVersion",
                                   initrs->implementationVersion ?
                                   initrs->implementationVersion : "");

        /* Make initrs->options available as ZOOM-level options */
        yaz_init_opt_decode(initrs->options, set_init_option, (void*) c);

        if (!*initrs->result)
        {
            Z_DefaultDiagFormat *df = yaz_decode_init_diag(0, initrs);
            if (df)
                response_default_diag(c, df);
            else
                ZOOM_set_error(c, ZOOM_ERROR_INIT, 0); /* default error */
        }
        else
        {
            char *cookie =
                yaz_oi_get_string_oid(&apdu->u.initResponse->otherInfo,
                                      yaz_oid_userinfo_cookie, 1, 0);
            xfree(c->cookie_in);
            c->cookie_in = 0;
            if (cookie)
                c->cookie_in = xstrdup(cookie);
            if (ODR_MASK_GET(initrs->options, Z_Options_namedResultSets) &&
                ODR_MASK_GET(initrs->protocolVersion, Z_ProtocolVersion_3))
                c->support_named_resultsets = 1;
            if (c->tasks)
            {
                assert(c->tasks->which == ZOOM_TASK_CONNECT);
                ZOOM_connection_remove_task(c);
            }
            ZOOM_connection_exec_task(c);
        }
        if (ODR_MASK_GET(initrs->options, Z_Options_negotiationModel))
        {
            NMEM tmpmem = nmem_create();
            Z_CharSetandLanguageNegotiation *p =
                yaz_get_charneg_record(initrs->otherInfo);

            if (p)
            {
                char *charset = NULL, *lang = NULL;
                int sel;

                yaz_get_response_charneg(tmpmem, p, &charset, &lang, &sel);
                yaz_log(c->log_details, "%p handle_Z3950_apdu target accepted: "
                        "charset %s, language %s, select %d",
                        c,
                        charset ? charset : "none", lang ? lang : "none", sel);
                if (charset)
                    ZOOM_connection_option_set(c, "negotiation-charset",
                                               charset);
                if (lang)
                    ZOOM_connection_option_set(c, "negotiation-lang",
                                               lang);

                ZOOM_connection_option_set(
                    c,  "negotiation-charset-in-effect-for-records",
                    (sel != 0) ? "1" : "0");
                nmem_destroy(tmpmem);
            }
        }
        break;
    case Z_APDU_searchResponse:
        yaz_log(c->log_api, "%p handle_Z3950_apdu Search response", c);
        handle_Z3950_search_response(c, apdu->u.searchResponse);
        if (send_Z3950_sort_present(c) == zoom_complete)
            ZOOM_connection_remove_task(c);
        break;
    case Z_APDU_presentResponse:
        yaz_log(c->log_api, "%p handle_Z3950_apdu Present response", c);
        handle_Z3950_present_response(c, apdu->u.presentResponse);
        if (ZOOM_connection_Z3950_search(c) == zoom_complete)
            ZOOM_connection_remove_task(c);
        break;
    case Z_APDU_sortResponse:
        yaz_log(c->log_api, "%p handle_Z3950_apdu Sort response", c);
        handle_Z3950_sort_response(c, apdu->u.sortResponse);
        if (ZOOM_connection_Z3950_search(c) == zoom_complete)
            ZOOM_connection_remove_task(c);
        break;
    case Z_APDU_scanResponse:
        yaz_log(c->log_api, "%p handle_Z3950_apdu Scan response", c);
        handle_Z3950_scan_response(c, apdu->u.scanResponse);
        ZOOM_connection_remove_task(c);
        break;
    case Z_APDU_extendedServicesResponse:
        yaz_log(c->log_api, "%p handle_Z3950_apdu Extended Services response", c);
        handle_Z3950_es_response(c, apdu->u.extendedServicesResponse);
        ZOOM_connection_remove_task(c);
        break;
    case Z_APDU_close:
        yaz_log(c->log_api, "%p handle_Z3950_apdu Close PDU", c);
        if (!ZOOM_test_reconnect(c))
        {
            ZOOM_set_dset_error(c, ZOOM_ERROR_CONNECTION_LOST, "ZOOM", c->host_port, apdu->u.close->diagnosticInformation);
            ZOOM_connection_close(c);
        }
        break;
    default:
        yaz_log(c->log_api, "%p Received unknown PDU", c);
        ZOOM_set_error(c, ZOOM_ERROR_DECODE, 0);
        ZOOM_connection_close(c);
    }
}

/*
 * Local variables:
 * c-basic-offset: 4
 * c-file-style: "Stroustrup"
 * indent-tabs-mode: nil
 * End:
 * vim: shiftwidth=4 tabstop=8 expandtab
 */

