+ init_req->idAuthentication = auth;
+
+ *init_req->preferredMessageSize = 10*1024*1024;
+ *init_req->maximumRecordSize = 10*1024*1024;
+
+ ODR_MASK_SET(init_req->options, Z_Options_search);
+ ODR_MASK_SET(init_req->options, Z_Options_present);
+ ODR_MASK_SET(init_req->options, Z_Options_namedResultSets);
+ ODR_MASK_SET(init_req->options, Z_Options_scan);
+
+ ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_1);
+ ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_2);
+ ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_3);
+
+ if (zurl.length())
+ {
+ std::string host;
+ std::list<std::string> dblist;
+ mp_util::split_zurl(zurl, host, dblist);
+ mp_util::set_vhost_otherinfo(&init_req->otherInfo, odr_en, host, 1);
+ }
+
+ z3950_package.request() = apdu;
+
+ // send Z3950 package
+ z3950_package.move();
+
+ // dead Z3950 backend detection
+ if (z3950_package.session().is_closed())
+ {
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE, 0);
+ return false;
+ }
+
+ // check successful initResponse
+ Z_GDU *z3950_gdu = z3950_package.response().get();
+
+ if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
+ && z3950_gdu->u.z3950->which == Z_APDU_initResponse
+ && *z3950_gdu->u.z3950->u.initResponse->result)
+ return true;
+
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE, 0);
+ return false;
+}
+
+bool yf::SRUtoZ3950::Impl::z3950_close_request(mp::Package &package) const
+{
+ Package z3950_package(package.session(), package.origin());
+ z3950_package.copy_filter(package);
+ z3950_package.session().close();
+
+ z3950_package.move();
+
+ if (z3950_package.session().is_closed())
+ {
+ return true;
+ }
+ return false;
+}
+
+bool yf::SRUtoZ3950::Impl::z3950_search_request(mp::Package &package,
+ mp::odr &odr_en,
+ Z_SRW_PDU *sru_pdu_res,
+ Z_SRW_searchRetrieveRequest
+ const *sr_req,
+ std::string zurl) const
+{
+
+ assert(sru_pdu_res->u.response);
+
+ Package z3950_package(package.session(), package.origin());
+ z3950_package.copy_filter(package);
+
+ Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_searchRequest);
+ Z_SearchRequest *z_searchRequest = apdu->u.searchRequest;
+
+ // RecordSyntax will always be XML
+ z_searchRequest->preferredRecordSyntax
+ = odr_oiddup(odr_en, yaz_oid_recsyn_xml);
+
+ if (!mp_util::set_databases_from_zurl(odr_en, zurl,
+ &z_searchRequest->num_databaseNames,
+ &z_searchRequest->databaseNames))
+ {
+ z_searchRequest->num_databaseNames = 1;
+ z_searchRequest->databaseNames = (char**)
+ odr_malloc(odr_en, sizeof(char *));
+
+ if (sr_req->database)
+ z_searchRequest->databaseNames[0]
+ = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
+ else
+ z_searchRequest->databaseNames[0]
+ = odr_strdup(odr_en, "Default");
+ }
+
+ Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
+ z_searchRequest->query = z_query;
+
+ int sru_diagnostic = z3950_build_query(odr_en, z_query, sr_req);
+ if (sru_diagnostic)
+ {
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ sru_diagnostic,
+ "query");
+ return false;
+ }
+
+ z3950_package.request() = apdu;
+
+ z3950_package.move();
+
+ Z_GDU *z3950_gdu = z3950_package.response().get();
+
+ if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
+ || z3950_gdu->u.z3950->which != Z_APDU_searchResponse
+ || !z3950_gdu->u.z3950->u.searchResponse
+ || !z3950_gdu->u.z3950->u.searchResponse->searchStatus)
+ {
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE, 0);
+ return false;
+ }
+
+ Z_SearchResponse *sr = z3950_gdu->u.z3950->u.searchResponse;
+
+ if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
+ sr->records))
+ {
+ return false;
+ }
+
+ sru_pdu_res->u.response->numberOfRecords
+ = odr_intdup(odr_en, *sr->resultCount);
+ return true;
+}
+
+bool yf::SRUtoZ3950::Impl::z3950_present_request(
+ mp::Package &package,
+ mp::odr &odr_en,
+ Z_SRW_PDU *sru_pdu_res,
+ const Z_SRW_searchRetrieveRequest *sr_req)
+ const
+{
+ assert(sru_pdu_res->u.response);
+ int start = 1;
+ int max_recs = 0;
+
+ if (!sr_req)
+ return false;
+
+ if (sr_req->maximumRecords)
+ max_recs = *sr_req->maximumRecords;
+ if (sr_req->startRecord)
+ start = *sr_req->startRecord;
+
+ // no need to work if nobody wants record ..
+ if (max_recs == 0)
+ return true;
+
+ bool send_z3950_present = true;
+
+ // recordXPath unsupported.
+ if (sr_req->recordXPath)
+ {
+ send_z3950_present = false;
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_XPATH_RETRIEVAL_UNSUPP, 0);
+ }
+
+ // resultSetTTL unsupported.
+ // resultSetIdleTime in response
+ if (sr_req->resultSetTTL)
+ {
+ send_z3950_present = false;
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_RESULT_SETS_UNSUPP, 0);
+ }
+
+ // sort unsupported
+ if (sr_req->sort_type != Z_SRW_sort_type_none)
+ {
+ send_z3950_present = false;
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_SORT_UNSUPP, 0);
+ }
+
+ // start record requested negative, or larger than number of records
+ if (start < 0 || start > *sru_pdu_res->u.response->numberOfRecords)
+ {
+ send_z3950_present = false;
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_FIRST_RECORD_POSITION_OUT_OF_RANGE, 0);
+ }
+
+ // maximumRecords requested negative
+ if (max_recs < 0)
+ {
+ send_z3950_present = false;
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_UNSUPP_PARAMETER_VALUE,
+ "maximumRecords");
+ }
+
+ // exit on all these above diagnostics
+ if (!send_z3950_present)
+ return false;
+
+ if (max_recs > *sru_pdu_res->u.response->numberOfRecords - start)
+ max_recs = *sru_pdu_res->u.response->numberOfRecords - start + 1;
+
+ Z_SRW_searchRetrieveResponse *sru_res = sru_pdu_res->u.response;
+ sru_res->records = (Z_SRW_record *)
+ odr_malloc(odr_en, max_recs * sizeof(Z_SRW_record));
+ int num = 0;
+ while (num < max_recs)
+ {
+ // now packaging the z3950 present request
+ Package z3950_package(package.session(), package.origin());
+ z3950_package.copy_filter(package);
+ Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_presentRequest);
+
+ assert(apdu->u.presentRequest);
+
+ *apdu->u.presentRequest->resultSetStartPoint = start + num;
+ *apdu->u.presentRequest->numberOfRecordsRequested = max_recs - num;
+
+ // set response packing to be same as "request" packing..
+ int record_packing = Z_SRW_recordPacking_XML;
+ if (sr_req->recordPacking && 's' == *(sr_req->recordPacking))
+ record_packing = Z_SRW_recordPacking_string;
+
+ // RecordSyntax will always be XML
+ apdu->u.presentRequest->preferredRecordSyntax
+ = odr_oiddup(odr_en, yaz_oid_recsyn_xml);
+
+ // z3950'fy record schema
+ if (sr_req->recordSchema)
+ {
+ apdu->u.presentRequest->recordComposition
+ = (Z_RecordComposition *)
+ odr_malloc(odr_en, sizeof(Z_RecordComposition));
+ apdu->u.presentRequest->recordComposition->which
+ = Z_RecordComp_simple;
+ apdu->u.presentRequest->recordComposition->u.simple
+ = mp_util::build_esn_from_schema(odr_en,
+ (const char *)
+ sr_req->recordSchema);
+ }
+
+ // attaching Z3950 package to filter chain
+ z3950_package.request() = apdu;
+
+ // sending Z30.50 present request
+ z3950_package.move();
+
+ //check successful Z3950 present response
+ Z_GDU *z3950_gdu = z3950_package.response().get();
+ if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
+ || z3950_gdu->u.z3950->which != Z_APDU_presentResponse
+ || !z3950_gdu->u.z3950->u.presentResponse)
+
+ {
+ yaz_add_srw_diagnostic(odr_en,
+ &(sru_pdu_res->u.response->diagnostics),
+ &(sru_pdu_res->u.response->num_diagnostics),
+ YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE, 0);
+ return false;
+ }
+ // everything fine, continuing
+
+ Z_PresentResponse *pr = z3950_gdu->u.z3950->u.presentResponse;
+
+ // checking non surrogate diagnostics in Z3950 present response package
+ if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
+ pr->records))
+ return false;
+
+ // if anything but database or surrogate diagnostics, stop
+ if (!pr->records || pr->records->which != Z_Records_DBOSD)
+ break;
+ else
+ {
+ // inserting all records
+ int returned_recs =
+ pr->records->u.databaseOrSurDiagnostics->num_records;
+ for (int i = 0; i < returned_recs; i++)
+ {
+ int position = i + *apdu->u.presentRequest->resultSetStartPoint;
+ Z_NamePlusRecord *npr
+ = pr->records->u.databaseOrSurDiagnostics->records[i];
+
+ sru_res->records[i + num].recordPacking = record_packing;
+
+ if (npr->which == Z_NamePlusRecord_surrogateDiagnostic)
+ {
+ Z_DiagRec *p = npr->u.surrogateDiagnostic;
+ if (p->which == Z_DiagRec_defaultFormat)
+ {
+ Z_DefaultDiagFormat *df = p->u.defaultFormat;
+ int c = yaz_diag_bib1_to_srw(*df->condition);
+
+ yaz_mk_sru_surrogate(
+ odr_en, sru_res->records + i + num, position,
+ c, df->u.v2Addinfo);
+ }
+ else
+ {
+ yaz_mk_sru_surrogate(
+ odr_en, sru_res->records + i + num, position,
+ YAZ_SRW_RECORD_TEMPORARILY_UNAVAILABLE, 0);
+ }
+ }
+ else if (npr->which == Z_NamePlusRecord_databaseRecord &&
+ npr->u.databaseRecord->direct_reference
+ && !oid_oidcmp(npr->u.databaseRecord->direct_reference,
+ yaz_oid_recsyn_xml))
+ {
+ // got XML record back
+ Z_External *r = npr->u.databaseRecord;
+ sru_res->records[i + num].recordPosition =
+ odr_intdup(odr_en, position);
+ sru_res->records[i + num].recordSchema = sr_req->recordSchema;
+ sru_res->records[i + num].recordData_buf
+ = odr_strdupn(odr_en,
+ (const char *)r->u.octet_aligned->buf,
+ r->u.octet_aligned->len);
+ sru_res->records[i + num].recordData_len
+ = r->u.octet_aligned->len;
+ }
+ else
+ {
+ // not XML or no database record at all
+ yaz_mk_sru_surrogate(
+ odr_en, sru_res->records + i + num, position,
+ YAZ_SRW_RECORD_NOT_AVAILABLE_IN_THIS_SCHEMA, 0);
+ }
+ }
+ num += returned_recs;
+ }
+ }
+ sru_res->num_records = num;
+ if (start - 1 + num < *sru_pdu_res->u.response->numberOfRecords)
+ sru_res->nextRecordPosition =
+ odr_intdup(odr_en, start + num);
+ return true;