+ const char *charset = negotiationCharset;
+ const char *host_port = cur_host;
+ char *path = 0;
+ char ctype[50];
+ Z_SOAP_Handler h[2] = {
+ {"http://www.loc.gov/zing/srw/", 0, (Z_SOAP_fun) yaz_srw_codec},
+ {0, 0, 0}
+ };
+ ODR o = odr_createmem(ODR_ENCODE);
+ int ret;
+ Z_SOAP *p = odr_malloc(o, sizeof(*p));
+ Z_GDU *gdu;
+
+ path = odr_malloc(out, strlen(databaseNames[0])+2);
+ *path = '/';
+ strcpy(path+1, databaseNames[0]);
+
+ gdu = z_get_HTTP_Request(out);
+ gdu->u.HTTP_Request->path = odr_strdup(out, path);
+
+ if (host_port)
+ {
+ const char *cp0 = strstr(host_port, "://");
+ const char *cp1 = 0;
+ if (cp0)
+ cp0 = cp0+3;
+ else
+ cp0 = host_port;
+
+ cp1 = strchr(cp0, '/');
+ if (!cp1)
+ cp1 = cp0+strlen(cp0);
+
+ if (cp0 && cp1)
+ {
+ char *h = odr_malloc(out, cp1 - cp0 + 1);
+ memcpy (h, cp0, cp1 - cp0);
+ h[cp1-cp0] = '\0';
+ z_HTTP_header_add(out, &gdu->u.HTTP_Request->headers,
+ "Host", h);
+ }
+ }
+
+ strcpy(ctype, "text/xml");
+ if (charset && strlen(charset) < 20)
+ {
+ strcat(ctype, "; charset=");
+ strcat(ctype, charset);
+ }
+ z_HTTP_header_add(out, &gdu->u.HTTP_Request->headers,
+ "Content-Type", ctype);
+ z_HTTP_header_add(out, &gdu->u.HTTP_Request->headers,
+ "SOAPAction", "\"\"");
+ p->which = Z_SOAP_generic;
+ p->u.generic = odr_malloc(o, sizeof(*p->u.generic));
+ p->u.generic->no = 0;
+ p->u.generic->ns = 0;
+ p->u.generic->p = sr;
+ p->ns = "http://schemas.xmlsoap.org/soap/envelope/";
+
+ ret = z_soap_codec_enc(o, &p,
+ &gdu->u.HTTP_Request->content_buf,
+ &gdu->u.HTTP_Request->content_len, h,
+ charset);
+
+ if (z_GDU(out, &gdu, 0, 0))
+ {
+ /* encode OK */
+ char *buf_out;
+ int len_out;
+ int r;
+ if (apdu_file)
+ {
+ if (!z_GDU(print, &gdu, 0, 0))
+ printf ("Failed to print outgoing APDU\n");
+ odr_reset(print);
+ }
+ buf_out = odr_getbuf(out, &len_out, 0);
+
+ /* we don't odr_reset(out), since we may need the buffer again */
+
+ do_hex_dump(buf_out, len_out);
+
+ r = cs_put(conn, buf_out, len_out);
+
+ odr_destroy(o);
+
+ if (r >= 0)
+ return 2;
+ }
+ return 0;
+}
+#endif
+
+#if HAVE_XML2
+static int send_SRW_searchRequest(const char *arg)
+{
+ Z_SRW_PDU *sr = 0;
+
+ if (!srw_sr)
+ {
+ assert(srw_sr_odr_out == 0);
+ srw_sr_odr_out = odr_createmem(ODR_ENCODE);
+ }
+ odr_reset(srw_sr_odr_out);
+
+ setno = 1;
+
+ /* save this for later .. when fetching individual records */
+ srw_sr = sr = yaz_srw_get(srw_sr_odr_out, Z_SRW_searchRetrieve_request);
+ sr->u.request->query_type = Z_SRW_query_type_cql;
+ sr->u.request->query.cql = odr_strdup(srw_sr_odr_out, arg);
+
+ sr = yaz_srw_get(out, Z_SRW_searchRetrieve_request);
+ sr->u.request->query_type = Z_SRW_query_type_cql;
+ sr->u.request->query.cql = odr_strdup(out, arg);
+
+ sr->u.request->maximumRecords = odr_intdup(out, 0);
+
+ if (record_schema)
+ sr->u.request->recordSchema = record_schema;
+ return send_srw(sr);
+}
+#endif
+
+static int send_searchRequest(const char *arg)
+{
+ Z_APDU *apdu = zget_APDU(out, Z_APDU_searchRequest);
+ Z_SearchRequest *req = apdu->u.searchRequest;
+ Z_Query query;
+ int oid[OID_SIZE];
+ struct ccl_rpn_node *rpn = NULL;
+ int error, pos;
+ char setstring[100];
+ Z_RPNQuery *RPNquery;
+ Odr_oct ccl_query;
+ YAZ_PQF_Parser pqf_parser;
+ Z_External *ext;
+ QueryType myQueryType = queryType;
+ char pqfbuf[512];
+
+ if (myQueryType == QueryType_CCL2RPN)
+ {
+ rpn = ccl_find_str(bibset, arg, &error, &pos);
+ if (error)
+ {
+ printf("CCL ERROR: %s\n", ccl_err_msg(error));
+ return 0;
+ }
+ } else if (myQueryType == QueryType_CQL2RPN) {
+ /* ### All this code should be wrapped in a utility function */
+ CQL_parser parser;
+ struct cql_node *node;
+ const char *addinfo;
+ if (cqltrans == 0) {
+ printf("Can't use CQL: no translation file. Try set_cqlfile\n");
+ return 0;
+ }
+ parser = cql_parser_create();
+ if ((error = cql_parser_string(parser, arg)) != 0) {
+ printf("Can't parse CQL: must be a syntax error\n");
+ return 0;
+ }
+ node = cql_parser_result(parser);
+ if ((error = cql_transform_buf(cqltrans, node, pqfbuf,
+ sizeof pqfbuf)) != 0) {
+ error = cql_transform_error(cqltrans, &addinfo);
+ printf ("Can't convert CQL to PQF: %s (addinfo=%s)\n",
+ cql_strerror(error), addinfo);
+ return 0;
+ }
+ arg = pqfbuf;
+ myQueryType = QueryType_Prefix;
+ }
+
+ req->referenceId = set_refid (out);
+ if (!strcmp(arg, "@big")) /* strictly for troublemaking */
+ {
+ static unsigned char big[2100];
+ static Odr_oct bigo;
+
+ /* send a very big referenceid to test transport stack etc. */
+ memset(big, 'A', 2100);
+ bigo.len = bigo.size = 2100;
+ bigo.buf = big;
+ req->referenceId = &bigo;
+ }
+
+ if (setnumber >= 0)
+ {
+ sprintf(setstring, "%d", ++setnumber);
+ req->resultSetName = setstring;
+ }
+ *req->smallSetUpperBound = smallSetUpperBound;
+ *req->largeSetLowerBound = largeSetLowerBound;
+ *req->mediumSetPresentNumber = mediumSetPresentNumber;
+ if (smallSetUpperBound > 0 || (largeSetLowerBound > 1 &&
+ mediumSetPresentNumber > 0))
+ {
+ oident prefsyn;
+
+ prefsyn.proto = protocol;
+ prefsyn.oclass = CLASS_RECSYN;
+ prefsyn.value = recordsyntax;
+ req->preferredRecordSyntax =
+ odr_oiddup(out, oid_ent_to_oid(&prefsyn, oid));
+ req->smallSetElementSetNames =
+ req->mediumSetElementSetNames = elementSetNames;
+ }
+ req->num_databaseNames = num_databaseNames;
+ req->databaseNames = databaseNames;
+
+ req->query = &query;
+
+ switch (myQueryType)
+ {
+ case QueryType_Prefix:
+ query.which = Z_Query_type_1;
+ pqf_parser = yaz_pqf_create ();
+ RPNquery = yaz_pqf_parse (pqf_parser, out, arg);
+ if (!RPNquery)
+ {
+ const char *pqf_msg;
+ size_t off;
+ int code = yaz_pqf_error (pqf_parser, &pqf_msg, &off);
+ printf("%*s^\n", off+4, "");
+ printf("Prefix query error: %s (code %d)\n", pqf_msg, code);
+
+ yaz_pqf_destroy (pqf_parser);
+ return 0;
+ }
+ yaz_pqf_destroy (pqf_parser);
+ query.u.type_1 = RPNquery;
+ break;
+ case QueryType_CCL:
+ query.which = Z_Query_type_2;
+ query.u.type_2 = &ccl_query;
+ ccl_query.buf = (unsigned char*) arg;
+ ccl_query.len = strlen(arg);
+ break;
+ case QueryType_CCL2RPN:
+ query.which = Z_Query_type_1;
+ RPNquery = ccl_rpn_query(out, rpn);
+ if (!RPNquery)
+ {
+ printf ("Couldn't convert from CCL to RPN\n");
+ return 0;
+ }
+ query.u.type_1 = RPNquery;
+ ccl_rpn_delete (rpn);
+ break;
+ case QueryType_CQL:
+ query.which = Z_Query_type_104;
+ ext = (Z_External *) odr_malloc(out, sizeof(*ext));
+ ext->direct_reference = odr_getoidbystr(out, "1.2.840.10003.16.2");
+ ext->indirect_reference = 0;
+ ext->descriptor = 0;
+ ext->which = Z_External_CQL;
+ ext->u.cql = odr_strdup(out, arg);
+ query.u.type_104 = ext;
+ break;
+ default:
+ printf ("Unsupported query type\n");
+ return 0;
+ }
+ if (send_apdu(apdu))
+ printf("Sent searchRequest.\n");
+ setno = 1;
+ return 2;
+}
+
+/* display Query Expression as part of searchResult-1 */
+static void display_queryExpression (Z_QueryExpression *qe)
+{
+ if (!qe)
+ return;
+ if (qe->which == Z_QueryExpression_term)
+ {
+ if (qe->u.term->queryTerm)
+ {
+ Z_Term *term = qe->u.term->queryTerm;
+ switch (term->which)
+ {
+ case Z_Term_general:
+ printf (" %.*s", term->u.general->len, term->u.general->buf);
+ break;
+ case Z_Term_characterString:
+ printf (" %s", term->u.characterString);
+ break;
+ case Z_Term_numeric:
+ printf (" %d", *term->u.numeric);
+ break;
+ case Z_Term_null:
+ printf (" null");
+ break;
+ }
+ }
+ }
+}
+
+/* see if we can find USR:SearchResult-1 */
+static void display_searchResult (Z_OtherInformation *o)
+{
+ int i;
+ if (!o)
+ return ;
+ for (i = 0; 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;
+ printf ("SearchResult-1:");
+ for (j = 0; j < sr->num; j++)
+ {
+ if (!sr->elements[j]->subqueryExpression)
+ printf (" %d", j);
+ display_queryExpression (
+ sr->elements[j]->subqueryExpression);
+ display_queryExpression (
+ sr->elements[j]->subqueryInterpretation);
+ display_queryExpression (
+ sr->elements[j]->subqueryRecommendation);
+ if (sr->elements[j]->subqueryCount)
+ printf ("(%d)", *sr->elements[j]->subqueryCount);
+ }
+ printf ("\n");
+ }
+ }
+ }
+}
+
+static int process_searchResponse(Z_SearchResponse *res)
+{
+ printf ("Received SearchResponse.\n");
+ print_refid (res->referenceId);
+ if (*res->searchStatus)
+ printf("Search was a success.\n");
+ else
+ printf("Search was a bloomin' failure.\n");
+ printf("Number of hits: %d", *res->resultCount);
+ if (setnumber >= 0)
+ printf (", setno %d", setnumber);
+ printf ("\n");
+ display_searchResult (res->additionalSearchInfo);
+ printf("records returned: %d\n",
+ *res->numberOfRecordsReturned);
+ setno += *res->numberOfRecordsReturned;
+ if (res->records)
+ display_records(res->records);
+ return 0;
+}
+
+static void print_level(int iLevel)
+{
+ int i;
+ for (i = 0; i < iLevel * 4; i++)
+ printf(" ");
+}
+
+static void print_int(int iLevel, const char *pTag, int *pInt)
+{
+ if (pInt != NULL)
+ {
+ print_level(iLevel);
+ printf("%s: %d\n", pTag, *pInt);
+ }
+}
+
+static void print_string(int iLevel, const char *pTag, const char *pString)
+{
+ if (pString != NULL)
+ {
+ print_level(iLevel);
+ printf("%s: %s\n", pTag, pString);
+ }
+}
+
+static void print_oid(int iLevel, const char *pTag, Odr_oid *pOid)
+{
+ if (pOid != NULL)
+ {
+ int *pInt = pOid;
+
+ print_level(iLevel);
+ printf("%s:", pTag);
+ for (; *pInt != -1; pInt++)
+ printf(" %d", *pInt);
+ printf("\n");
+ }
+}
+
+static void print_referenceId(int iLevel, Z_ReferenceId *referenceId)
+{
+ if (referenceId != NULL)
+ {
+ int i;
+
+ print_level(iLevel);
+ printf("Ref Id (%d, %d): ", referenceId->len, referenceId->size);
+ for (i = 0; i < referenceId->len; i++)
+ printf("%c", referenceId->buf[i]);
+ printf("\n");
+ }
+}
+
+static void print_string_or_numeric(int iLevel, const char *pTag, Z_StringOrNumeric *pStringNumeric)
+{
+ if (pStringNumeric != NULL)
+ {
+ switch (pStringNumeric->which)
+ {
+ case Z_StringOrNumeric_string:
+ print_string(iLevel, pTag, pStringNumeric->u.string);
+ break;
+
+ case Z_StringOrNumeric_numeric:
+ print_int(iLevel, pTag, pStringNumeric->u.numeric);
+ break;
+
+ default:
+ print_level(iLevel);
+ printf("%s: valid type for Z_StringOrNumeric\n", pTag);
+ break;
+ }
+ }
+}
+
+static void print_universe_report_duplicate(
+ int iLevel,
+ Z_UniverseReportDuplicate *pUniverseReportDuplicate)
+{
+ if (pUniverseReportDuplicate != NULL)
+ {
+ print_level(iLevel);
+ printf("Universe Report Duplicate: \n");
+ iLevel++;
+ print_string_or_numeric(iLevel, "Hit No",
+ pUniverseReportDuplicate->hitno);
+ }
+}
+
+static void print_universe_report_hits(
+ int iLevel,
+ Z_UniverseReportHits *pUniverseReportHits)
+{
+ if (pUniverseReportHits != NULL)
+ {
+ print_level(iLevel);
+ printf("Universe Report Hits: \n");
+ iLevel++;
+ print_string_or_numeric(iLevel, "Database",
+ pUniverseReportHits->database);
+ print_string_or_numeric(iLevel, "Hits", pUniverseReportHits->hits);
+ }
+}
+
+static void print_universe_report(int iLevel, Z_UniverseReport *pUniverseReport)
+{
+ if (pUniverseReport != NULL)
+ {
+ print_level(iLevel);
+ printf("Universe Report: \n");
+ iLevel++;
+ print_int(iLevel, "Total Hits", pUniverseReport->totalHits);
+ switch (pUniverseReport->which)
+ {
+ case Z_UniverseReport_databaseHits:
+ print_universe_report_hits(iLevel,
+ pUniverseReport->u.databaseHits);
+ break;
+
+ case Z_UniverseReport_duplicate:
+ print_universe_report_duplicate(iLevel,
+ pUniverseReport->u.duplicate);
+ break;
+
+ default:
+ print_level(iLevel);
+ printf("Type: %d\n", pUniverseReport->which);
+ break;
+ }
+ }
+}
+
+static void print_external(int iLevel, Z_External *pExternal)
+{
+ if (pExternal != NULL)
+ {
+ print_level(iLevel);
+ printf("External: \n");
+ iLevel++;
+ print_oid(iLevel, "Direct Reference", pExternal->direct_reference);
+ print_int(iLevel, "InDirect Reference", pExternal->indirect_reference);
+ print_string(iLevel, "Descriptor", pExternal->descriptor);
+ switch (pExternal->which)
+ {
+ case Z_External_universeReport:
+ print_universe_report(iLevel, pExternal->u.universeReport);
+ break;
+
+ default:
+ print_level(iLevel);
+ printf("Type: %d\n", pExternal->which);
+ break;
+ }
+ }
+}
+
+static int process_resourceControlRequest (Z_ResourceControlRequest *req)
+{
+ printf ("Received ResourceControlRequest.\n");
+ print_referenceId(1, req->referenceId);
+ print_int(1, "Suspended Flag", req->suspendedFlag);
+ print_int(1, "Partial Results Available", req->partialResultsAvailable);
+ print_int(1, "Response Required", req->responseRequired);
+ print_int(1, "Triggered Request Flag", req->triggeredRequestFlag);
+ print_external(1, req->resourceReport);
+ return 0;
+}
+
+void process_ESResponse(Z_ExtendedServicesResponse *res)
+{
+ printf("Status: ");
+ switch (*res->operationStatus)
+ {
+ case Z_ExtendedServicesResponse_done:
+ printf ("done\n");
+ break;
+ case Z_ExtendedServicesResponse_accepted:
+ printf ("accepted\n");
+ break;
+ case Z_ExtendedServicesResponse_failure:
+ printf ("failure\n");
+ display_diagrecs(res->diagnostics, res->num_diagnostics);
+ break;
+ default:
+ printf ("unknown\n");
+ }
+ if ( (*res->operationStatus != Z_ExtendedServicesResponse_failure) &&
+ (res->num_diagnostics != 0) ) {
+ display_diagrecs(res->diagnostics, res->num_diagnostics);
+ }
+ print_refid (res->referenceId);
+ if (res->taskPackage &&
+ res->taskPackage->which == Z_External_extendedService)
+ {
+ Z_TaskPackage *taskPackage = res->taskPackage->u.extendedService;
+ Odr_oct *id = taskPackage->targetReference;
+ Z_External *ext = taskPackage->taskSpecificParameters;
+
+ if (id)
+ {
+ printf ("Target Reference: ");
+ print_stringn (id->buf, id->len);
+ printf ("\n");
+ }
+ if (ext->which == Z_External_update)
+ {
+ Z_IUUpdateTaskPackage *utp = ext->u.update->u.taskPackage;
+ if (utp && utp->targetPart)
+ {
+ Z_IUTargetPart *targetPart = utp->targetPart;
+ int i;
+
+ for (i = 0; i<targetPart->num_taskPackageRecords; i++)
+ {
+
+ Z_IUTaskPackageRecordStructure *tpr =
+ targetPart->taskPackageRecords[i];
+ printf ("task package record %d\n", i+1);
+ if (tpr->which == Z_IUTaskPackageRecordStructure_record)
+ {
+ display_record (tpr->u.record);
+ }
+ else
+ {
+ printf ("other type\n");
+ }
+ }
+ }
+ }
+ }
+}
+
+const char *get_ill_element (void *clientData, const char *element)
+{
+ return 0;
+}
+
+static Z_External *create_external_itemRequest()
+{
+ struct ill_get_ctl ctl;
+ ILL_ItemRequest *req;
+ Z_External *r = 0;
+ int item_request_size = 0;
+ char *item_request_buf = 0;
+
+ ctl.odr = out;
+ ctl.clientData = 0;
+ ctl.f = get_ill_element;
+
+ req = ill_get_ItemRequest(&ctl, "ill", 0);
+ if (!req)
+ printf ("ill_get_ItemRequest failed\n");
+
+ if (!ill_ItemRequest (out, &req, 0, 0))
+ {
+ if (apdu_file)
+ {
+ ill_ItemRequest(print, &req, 0, 0);
+ odr_reset(print);
+ }
+ item_request_buf = odr_getbuf (out, &item_request_size, 0);
+ if (item_request_buf)
+ odr_setbuf (out, item_request_buf, item_request_size, 1);
+ printf ("Couldn't encode ItemRequest, size %d\n", item_request_size);
+ return 0;
+ }
+ else
+ {
+ oident oid;
+
+ item_request_buf = odr_getbuf (out, &item_request_size, 0);
+ oid.proto = PROTO_GENERAL;
+ oid.oclass = CLASS_GENERAL;
+ oid.value = VAL_ISO_ILL_1;
+
+ r = (Z_External *) odr_malloc (out, sizeof(*r));
+ r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid));
+ r->indirect_reference = 0;
+ r->descriptor = 0;
+ r->which = Z_External_single;
+
+ r->u.single_ASN1_type = (Odr_oct *)
+ odr_malloc (out, sizeof(*r->u.single_ASN1_type));
+ r->u.single_ASN1_type->buf = (unsigned char *)
+ odr_malloc (out, item_request_size);
+ r->u.single_ASN1_type->len = item_request_size;
+ r->u.single_ASN1_type->size = item_request_size;
+ memcpy (r->u.single_ASN1_type->buf, item_request_buf,
+ item_request_size);
+
+ do_hex_dump(item_request_buf,item_request_size);
+ }
+ return r;
+}
+
+static Z_External *create_external_ILL_APDU(int which)
+{
+ struct ill_get_ctl ctl;
+ ILL_APDU *ill_apdu;
+ Z_External *r = 0;
+ int ill_request_size = 0;
+ char *ill_request_buf = 0;
+
+ ctl.odr = out;
+ ctl.clientData = 0;
+ ctl.f = get_ill_element;
+
+ ill_apdu = ill_get_APDU(&ctl, "ill", 0);
+
+ if (!ill_APDU (out, &ill_apdu, 0, 0))
+ {
+ if (apdu_file)
+ {
+ printf ("-------------------\n");
+ ill_APDU(print, &ill_apdu, 0, 0);
+ odr_reset(print);
+ printf ("-------------------\n");
+ }
+ ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
+ if (ill_request_buf)
+ odr_setbuf (out, ill_request_buf, ill_request_size, 1);
+ printf ("Couldn't encode ILL-Request, size %d\n", ill_request_size);
+ return 0;
+ }
+ else
+ {
+ oident oid;
+ ill_request_buf = odr_getbuf (out, &ill_request_size, 0);
+
+ oid.proto = PROTO_GENERAL;
+ oid.oclass = CLASS_GENERAL;
+ oid.value = VAL_ISO_ILL_1;
+
+ r = (Z_External *) odr_malloc (out, sizeof(*r));
+ r->direct_reference = odr_oiddup(out,oid_getoidbyent(&oid));
+ r->indirect_reference = 0;
+ r->descriptor = 0;
+ r->which = Z_External_single;
+
+ r->u.single_ASN1_type = (Odr_oct *)
+ odr_malloc (out, sizeof(*r->u.single_ASN1_type));
+ r->u.single_ASN1_type->buf = (unsigned char *)
+ odr_malloc (out, ill_request_size);
+ r->u.single_ASN1_type->len = ill_request_size;
+ r->u.single_ASN1_type->size = ill_request_size;
+ memcpy (r->u.single_ASN1_type->buf, ill_request_buf, ill_request_size);
+/* printf ("len = %d\n", ill_request_size); */
+/* do_hex_dump(ill_request_buf,ill_request_size); */
+/* printf("--- end of extenal\n"); */
+
+ }
+ return r;
+}
+
+
+static Z_External *create_ItemOrderExternal(const char *type, int itemno)
+{
+ Z_External *r = (Z_External *) odr_malloc(out, sizeof(Z_External));
+ oident ItemOrderRequest;
+
+ ItemOrderRequest.proto = PROTO_Z3950;
+ ItemOrderRequest.oclass = CLASS_EXTSERV;
+ ItemOrderRequest.value = VAL_ITEMORDER;
+
+ r->direct_reference = odr_oiddup(out,oid_getoidbyent(&ItemOrderRequest));
+ r->indirect_reference = 0;
+ r->descriptor = 0;
+
+ r->which = Z_External_itemOrder;
+
+ r->u.itemOrder = (Z_ItemOrder *) odr_malloc(out,sizeof(Z_ItemOrder));
+ memset(r->u.itemOrder, 0, sizeof(Z_ItemOrder));
+ r->u.itemOrder->which=Z_IOItemOrder_esRequest;
+
+ r->u.itemOrder->u.esRequest = (Z_IORequest *)
+ odr_malloc(out,sizeof(Z_IORequest));
+ memset(r->u.itemOrder->u.esRequest, 0, sizeof(Z_IORequest));
+
+ r->u.itemOrder->u.esRequest->toKeep = (Z_IOOriginPartToKeep *)
+ odr_malloc(out,sizeof(Z_IOOriginPartToKeep));
+ memset(r->u.itemOrder->u.esRequest->toKeep, 0, sizeof(Z_IOOriginPartToKeep));
+ r->u.itemOrder->u.esRequest->notToKeep = (Z_IOOriginPartNotToKeep *)
+ odr_malloc(out,sizeof(Z_IOOriginPartNotToKeep));
+ memset(r->u.itemOrder->u.esRequest->notToKeep, 0, sizeof(Z_IOOriginPartNotToKeep));
+
+ r->u.itemOrder->u.esRequest->toKeep->supplDescription = NULL;
+ r->u.itemOrder->u.esRequest->toKeep->contact = NULL;
+ r->u.itemOrder->u.esRequest->toKeep->addlBilling = NULL;
+
+ r->u.itemOrder->u.esRequest->notToKeep->resultSetItem =
+ (Z_IOResultSetItem *) odr_malloc(out, sizeof(Z_IOResultSetItem));
+ memset(r->u.itemOrder->u.esRequest->notToKeep->resultSetItem, 0, sizeof(Z_IOResultSetItem));
+ r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->resultSetId = "1";
+
+ r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->item =
+ (int *) odr_malloc(out, sizeof(int));
+ *r->u.itemOrder->u.esRequest->notToKeep->resultSetItem->item = itemno;
+
+ if (!strcmp (type, "item") || !strcmp(type, "2"))
+ {
+ printf ("using item-request\n");
+ r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
+ create_external_itemRequest();
+ }
+ else if (!strcmp(type, "ill") || !strcmp(type, "1"))
+ {
+ printf ("using ILL-request\n");
+ r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
+ create_external_ILL_APDU(ILL_APDU_ILL_Request);
+ }
+ else if (!strcmp(type, "xml") || !strcmp(type, "3"))
+ {
+ const char *xml_buf =
+ "<itemorder>\n"
+ " <type>request</type>\n"
+ " <libraryNo>000200</libraryNo>\n"
+ " <borrowerTicketNo> 1212 </borrowerTicketNo>\n"
+ "</itemorder>";
+ r->u.itemOrder->u.esRequest->notToKeep->itemRequest =
+ z_ext_record (out, VAL_TEXT_XML, xml_buf, strlen(xml_buf));
+ }
+ else
+ r->u.itemOrder->u.esRequest->notToKeep->itemRequest = 0;
+
+ return r;
+}
+
+static int send_itemorder(const char *type, int itemno)
+{
+ Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest);
+ Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
+ oident ItemOrderRequest;
+
+ ItemOrderRequest.proto = PROTO_Z3950;
+ ItemOrderRequest.oclass = CLASS_EXTSERV;
+ ItemOrderRequest.value = VAL_ITEMORDER;
+ req->packageType = odr_oiddup(out,oid_getoidbyent(&ItemOrderRequest));
+ req->packageName = esPackageName;
+
+ req->taskSpecificParameters = create_ItemOrderExternal(type, itemno);
+
+ send_apdu(apdu);
+ return 0;
+}
+
+static int only_z3950()
+{
+ if (protocol == PROTO_HTTP)
+ {
+ printf ("Not supported by SRW\n");
+ return 1;
+ }
+ return 0;
+}
+
+static int cmd_update_common(const char *arg, int version);
+
+static int cmd_update(const char *arg)
+{
+ return cmd_update_common(arg, 1);
+}
+
+static int cmd_update0(const char *arg)
+{
+ return cmd_update_common(arg, 0);
+}
+
+static int cmd_update_common(const char *arg, int version)
+{
+ Z_APDU *apdu = zget_APDU(out, Z_APDU_extendedServicesRequest );
+ Z_ExtendedServicesRequest *req = apdu->u.extendedServicesRequest;
+ Z_External *r;
+ int oid[OID_SIZE];
+ oident update_oid;
+ char action[20], recid[20], fname[80];
+ int action_no;
+ Z_External *record_this = 0;
+
+ if (only_z3950())
+ return 0;
+ *action = 0;
+ *recid = 0;
+ *fname = 0;
+ sscanf (arg, "%19s %19s %79s", action, recid, fname);
+
+ if (!strcmp (action, "insert"))
+ action_no = Z_IUOriginPartToKeep_recordInsert;
+ else if (!strcmp (action, "replace"))
+ action_no = Z_IUOriginPartToKeep_recordReplace;
+ else if (!strcmp (action, "delete"))
+ action_no = Z_IUOriginPartToKeep_recordDelete;
+ else if (!strcmp (action, "update"))
+ action_no = Z_IUOriginPartToKeep_specialUpdate;
+ else
+ {
+ printf ("Bad action: %s\n", action);
+ printf ("Possible values: insert, replace, delete, update\n");
+ return 0;
+ }
+
+ if (*fname)
+ {
+ FILE *inf;
+ struct stat status;
+ stat (fname, &status);
+ if (S_ISREG(status.st_mode) && (inf = fopen(fname, "r")))
+ {
+ size_t len = status.st_size;
+ char *buf = (char *) xmalloc (len);
+
+ fread (buf, 1, len, inf);
+
+ fclose (inf);
+
+ record_this = z_ext_record (out, VAL_TEXT_XML, buf, len);
+
+ xfree (buf);
+ }
+ else
+ {
+ printf ("File %s doesn't exist\n", fname);
+ return 0;
+ }
+ }
+ else
+ {
+ if (!record_last)
+ {
+ printf ("No last record (update ignored)\n");
+ return 0;
+ }
+ record_this = record_last;
+ }
+
+ update_oid.proto = PROTO_Z3950;
+ update_oid.oclass = CLASS_EXTSERV;
+ if (version == 0)
+ update_oid.value = VAL_DBUPDATE0;
+ else
+ update_oid.value = VAL_DBUPDATE;
+ oid_ent_to_oid (&update_oid, oid);
+ req->packageType = odr_oiddup(out,oid);
+ req->packageName = esPackageName;
+
+ req->referenceId = set_refid (out);
+
+ r = req->taskSpecificParameters = (Z_External *)
+ odr_malloc (out, sizeof(*r));
+ r->direct_reference = odr_oiddup(out,oid);
+ r->indirect_reference = 0;
+ r->descriptor = 0;
+ if (version == 0)
+ {
+ Z_IU0OriginPartToKeep *toKeep;
+ Z_IU0SuppliedRecords *notToKeep;
+
+ r->which = Z_External_update0;
+ r->u.update0 = (Z_IU0Update *) odr_malloc(out, sizeof(*r->u.update0));
+ r->u.update0->which = Z_IUUpdate_esRequest;
+ r->u.update0->u.esRequest = (Z_IU0UpdateEsRequest *)
+ odr_malloc(out, sizeof(*r->u.update0->u.esRequest));
+ toKeep = r->u.update0->u.esRequest->toKeep = (Z_IU0OriginPartToKeep *)
+ odr_malloc(out, sizeof(*r->u.update0->u.esRequest->toKeep));
+
+ toKeep->databaseName = databaseNames[0];
+ toKeep->schema = 0;
+ toKeep->elementSetName = 0;
+
+ toKeep->action = (int *) odr_malloc(out, sizeof(*toKeep->action));
+ *toKeep->action = action_no;
+
+ notToKeep = r->u.update0->u.esRequest->notToKeep = (Z_IU0SuppliedRecords *)
+ odr_malloc(out, sizeof(*r->u.update0->u.esRequest->notToKeep));
+ notToKeep->num = 1;
+ notToKeep->elements = (Z_IU0SuppliedRecords_elem **)
+ odr_malloc(out, sizeof(*notToKeep->elements));
+ notToKeep->elements[0] = (Z_IU0SuppliedRecords_elem *)
+ odr_malloc(out, sizeof(**notToKeep->elements));
+ notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
+ if (*recid)
+ {
+ notToKeep->elements[0]->u.opaque = (Odr_oct *)
+ odr_malloc (out, sizeof(Odr_oct));
+ notToKeep->elements[0]->u.opaque->buf = (unsigned char *) recid;
+ notToKeep->elements[0]->u.opaque->size = strlen(recid);
+ notToKeep->elements[0]->u.opaque->len = strlen(recid);
+ }
+ else
+ notToKeep->elements[0]->u.opaque = 0;
+ notToKeep->elements[0]->supplementalId = 0;
+ notToKeep->elements[0]->correlationInfo = 0;
+ notToKeep->elements[0]->record = record_this;
+ }
+ else
+ {
+ Z_IUOriginPartToKeep *toKeep;
+ Z_IUSuppliedRecords *notToKeep;
+
+ r->which = Z_External_update;
+ r->u.update = (Z_IUUpdate *) odr_malloc(out, sizeof(*r->u.update));
+ r->u.update->which = Z_IUUpdate_esRequest;
+ r->u.update->u.esRequest = (Z_IUUpdateEsRequest *)
+ odr_malloc(out, sizeof(*r->u.update->u.esRequest));
+ toKeep = r->u.update->u.esRequest->toKeep = (Z_IUOriginPartToKeep *)
+ odr_malloc(out, sizeof(*r->u.update->u.esRequest->toKeep));
+
+ toKeep->databaseName = databaseNames[0];
+ toKeep->schema = 0;
+ toKeep->elementSetName = 0;
+ toKeep->actionQualifier = 0;
+ toKeep->action = (int *) odr_malloc(out, sizeof(*toKeep->action));
+ *toKeep->action = action_no;
+
+ notToKeep = r->u.update->u.esRequest->notToKeep = (Z_IUSuppliedRecords *)
+ odr_malloc(out, sizeof(*r->u.update->u.esRequest->notToKeep));
+ notToKeep->num = 1;
+ notToKeep->elements = (Z_IUSuppliedRecords_elem **)
+ odr_malloc(out, sizeof(*notToKeep->elements));
+ notToKeep->elements[0] = (Z_IUSuppliedRecords_elem *)
+ odr_malloc(out, sizeof(**notToKeep->elements));
+ notToKeep->elements[0]->which = Z_IUSuppliedRecords_elem_opaque;
+ if (*recid)
+ {
+ notToKeep->elements[0]->u.opaque = (Odr_oct *)
+ odr_malloc (out, sizeof(Odr_oct));
+ notToKeep->elements[0]->u.opaque->buf = (unsigned char *) recid;
+ notToKeep->elements[0]->u.opaque->size = strlen(recid);
+ notToKeep->elements[0]->u.opaque->len = strlen(recid);
+ }
+ else
+ notToKeep->elements[0]->u.opaque = 0;
+ notToKeep->elements[0]->supplementalId = 0;
+ notToKeep->elements[0]->correlationInfo = 0;
+ notToKeep->elements[0]->record = record_this;
+ }
+
+ send_apdu(apdu);
+
+ return 2;
+}
+
+static int cmd_itemorder(const char *arg)
+{
+ char type[12];
+ int itemno;
+
+ if (only_z3950())
+ return 0;
+ if (sscanf (arg, "%10s %d", type, &itemno) != 2)
+ return 0;
+
+ printf("Item order request\n");
+ fflush(stdout);
+ send_itemorder(type, itemno);
+ return 2;
+}
+
+static void show_opt(const char *arg, void *clientData)
+{
+ printf ("%s ", arg);
+}
+
+static int cmd_zversion(const char *arg)
+{
+ if (*arg && arg)
+ z3950_version = atoi(arg);
+ else
+ printf ("version is %d\n", z3950_version);
+ return 0;
+}
+
+static int cmd_options(const char *arg)
+{
+ if (*arg)
+ {
+ int r;
+ int pos;
+ r = yaz_init_opt_encode(&z3950_options, arg, &pos);
+ }
+ else
+ {
+ yaz_init_opt_decode(&z3950_options, show_opt, 0);
+ printf ("\n");
+ }
+ return 0;
+}
+
+static int cmd_explain(const char *arg)
+{
+ if (protocol != PROTO_HTTP)
+ return 0;
+#if HAVE_XML2
+ if (!conn)
+ cmd_open(0);
+ if (conn)
+ {
+ Z_SRW_PDU *sr = 0;
+
+ setno = 1;
+
+ /* save this for later .. when fetching individual records */
+ sr = yaz_srw_get(out, Z_SRW_explain_request);
+ send_srw(sr);
+ return 2;
+ }
+#endif
+ return 0;
+}
+
+static int cmd_init(const char *arg)
+{
+ if (!conn || protocol != PROTO_Z3950)
+ return 0;
+ send_initRequest(0);
+ return 2;
+}
+
+static int cmd_find(const char *arg)
+{
+ if (!*arg)
+ {
+ printf("Find what?\n");
+ return 0;
+ }
+ if (protocol == PROTO_HTTP)
+ {
+#if HAVE_XML2
+ if (!conn)
+ cmd_open(0);
+ if (!conn)
+ return 0;
+ if (!send_SRW_searchRequest(arg))
+ return 0;
+#else
+ return 0;
+#endif
+ }
+ else
+ {
+ if (!conn)
+ {
+ try_reconnect();
+
+ if (!conn) {
+ printf("Not connected yet\n");
+ return 0;
+ }
+ }
+ if (!send_searchRequest(arg))
+ return 0;
+ }
+ return 2;
+}
+
+static int cmd_delete(const char *arg)
+{
+ if (!conn)
+ {
+ printf("Not connected yet\n");
+ return 0;
+ }
+ if (only_z3950())
+ return 0;
+ if (!send_deleteResultSetRequest(arg))
+ return 0;
+ return 2;
+}
+
+static int cmd_ssub(const char *arg)
+{
+ if (!(smallSetUpperBound = atoi(arg)))
+ return 0;
+ return 1;
+}
+
+static int cmd_lslb(const char *arg)
+{
+ if (only_z3950())
+ return 0;
+ if (!(largeSetLowerBound = atoi(arg)))
+ return 0;
+ return 1;
+}
+
+static int cmd_mspn(const char *arg)
+{
+ if (only_z3950())
+ return 0;
+ if (!(mediumSetPresentNumber = atoi(arg)))
+ return 0;
+ return 1;
+}
+
+static int cmd_status(const char *arg)
+{
+ printf("smallSetUpperBound: %d\n", smallSetUpperBound);
+ printf("largeSetLowerBound: %d\n", largeSetLowerBound);
+ printf("mediumSetPresentNumber: %d\n", mediumSetPresentNumber);
+ return 1;
+}
+
+static int cmd_setnames(const char *arg)
+{
+ if (*arg == '1') /* enable ? */
+ setnumber = 0;
+ else if (*arg == '0') /* disable ? */
+ setnumber = -1;
+ else if (setnumber < 0) /* no args, toggle .. */
+ setnumber = 0;
+ else
+ setnumber = -1;
+
+ if (setnumber >= 0)
+ printf("Set numbering enabled.\n");
+ else
+ printf("Set numbering disabled.\n");
+ return 1;
+}
+
+/* PRESENT SERVICE ----------------------------- */
+
+static void parse_show_args(const char *arg_c, char *setstring,
+ int *start, int *number)
+{
+ char arg[40];
+ char *p;
+
+ strncpy(arg, arg_c, sizeof(arg)-1);
+ arg[sizeof(arg)-1] = '\0';
+
+ if ((p = strchr(arg, '+')))
+ {
+ *number = atoi(p + 1);
+ *p = '\0';
+ }
+ if (*arg)
+ *start = atoi(arg);
+ if (p && (p=strchr(p+1, '+')))
+ strcpy (setstring, p+1);
+ else if (setnumber >= 0)
+ sprintf(setstring, "%d", setnumber);
+ else
+ *setstring = '\0';
+}
+
+static int send_presentRequest(const char *arg)
+{
+ Z_APDU *apdu = zget_APDU(out, Z_APDU_presentRequest);
+ Z_PresentRequest *req = apdu->u.presentRequest;
+ Z_RecordComposition compo;
+ oident prefsyn;
+ int nos = 1;
+ int oid[OID_SIZE];
+ char setstring[100];
+
+ req->referenceId = set_refid (out);
+
+ parse_show_args(arg, setstring, &setno, &nos);
+ if (*setstring)
+ req->resultSetId = setstring;
+
+ req->resultSetStartPoint = &setno;
+ req->numberOfRecordsRequested = &nos;
+ prefsyn.proto = protocol;
+ prefsyn.oclass = CLASS_RECSYN;
+ prefsyn.value = recordsyntax;
+ req->preferredRecordSyntax =
+ odr_oiddup (out, oid_ent_to_oid(&prefsyn, oid));
+
+ if (record_schema)
+ {
+ oident prefschema;
+
+ prefschema.proto = protocol;
+ prefschema.oclass = CLASS_SCHEMA;
+ prefschema.value = oid_getvalbyname(record_schema);
+
+ req->recordComposition = &compo;
+ compo.which = Z_RecordComp_complex;
+ compo.u.complex = (Z_CompSpec *)
+ odr_malloc(out, sizeof(*compo.u.complex));
+ compo.u.complex->selectAlternativeSyntax = (bool_t *)
+ odr_malloc(out, sizeof(bool_t));
+ *compo.u.complex->selectAlternativeSyntax = 0;
+
+ compo.u.complex->generic = (Z_Specification *)
+ odr_malloc(out, sizeof(*compo.u.complex->generic));
+ compo.u.complex->generic->which = Z_Schema_oid;
+ compo.u.complex->generic->schema.oid = (Odr_oid *)
+ odr_oiddup(out, oid_ent_to_oid(&prefschema, oid));
+ if (!compo.u.complex->generic->schema.oid)
+ {
+ /* OID wasn't a schema! Try record syntax instead. */
+ prefschema.oclass = CLASS_RECSYN;
+ compo.u.complex->generic->schema.oid = (Odr_oid *)
+ odr_oiddup(out, oid_ent_to_oid(&prefschema, oid));
+ }
+ if (!elementSetNames)
+ compo.u.complex->generic->elementSpec = 0;
+ else
+ {
+ compo.u.complex->generic->elementSpec = (Z_ElementSpec *)
+ odr_malloc(out, sizeof(Z_ElementSpec));
+ compo.u.complex->generic->elementSpec->which =
+ Z_ElementSpec_elementSetName;
+ compo.u.complex->generic->elementSpec->u.elementSetName =
+ elementSetNames->u.generic;
+ }
+ compo.u.complex->num_dbSpecific = 0;
+ compo.u.complex->dbSpecific = 0;
+ compo.u.complex->num_recordSyntax = 0;
+ compo.u.complex->recordSyntax = 0;
+ }
+ else if (elementSetNames)
+ {
+ req->recordComposition = &compo;
+ compo.which = Z_RecordComp_simple;
+ compo.u.simple = elementSetNames;
+ }
+ send_apdu(apdu);
+ printf("Sent presentRequest (%d+%d).\n", setno, nos);
+ return 2;
+}
+
+#if HAVE_XML2
+static int send_SRW_presentRequest(const char *arg)
+{
+ char setstring[100];
+ int nos = 1;
+ Z_SRW_PDU *sr = srw_sr;
+
+ if (!sr)
+ return 0;
+ parse_show_args(arg, setstring, &setno, &nos);
+ sr->u.request->startRecord = odr_intdup(out, setno);
+ sr->u.request->maximumRecords = odr_intdup(out, nos);
+ if (record_schema)
+ sr->u.request->recordSchema = record_schema;
+ return send_srw(sr);
+}
+#endif
+
+static void close_session (void)
+{
+ if (conn)
+ cs_close (conn);
+ conn = 0;
+ if (session_mem)
+ {
+ nmem_destroy (session_mem);
+ session_mem = NULL;
+ }
+ sent_close = 0;
+ odr_reset(out);
+ odr_reset(in);
+ odr_reset(print);
+}
+
+void process_close(Z_Close *req)
+{
+ Z_APDU *apdu = zget_APDU(out, Z_APDU_close);
+ Z_Close *res = apdu->u.close;
+
+ static char *reasons[] =
+ {
+ "finished",
+ "shutdown",
+ "system problem",
+ "cost limit reached",
+ "resources",
+ "security violation",
+ "protocolError",
+ "lack of activity",
+ "peer abort",
+ "unspecified"
+ };
+
+ printf("Reason: %s, message: %s\n", reasons[*req->closeReason],
+ req->diagnosticInformation ? req->diagnosticInformation : "NULL");
+ if (sent_close)
+ close_session ();
+ else
+ {
+ *res->closeReason = Z_Close_finished;
+ send_apdu(apdu);
+ printf("Sent response.\n");
+ sent_close = 1;
+ }
+}
+
+static int cmd_show(const char *arg)
+{
+ if (protocol == PROTO_HTTP)
+ {
+#if HAVE_XML2
+ if (!conn)
+ cmd_open(0);
+ if (!conn)
+ return 0;
+ if (!send_SRW_presentRequest(arg))
+ return 0;
+#else
+ return 0;
+#endif
+ }
+ else
+ {
+ if (!conn)
+ {
+ printf("Not connected yet\n");
+ return 0;
+ }
+ if (!send_presentRequest(arg))
+ return 0;
+ }
+ return 2;
+}
+
+int cmd_quit(const char *arg)
+{
+ printf("See you later, alligator.\n");
+ xmalloc_trav ("");
+ exit(0);