+ if (*m_parent->m_optimize == '0')
+ return apdu;
+
+ if (!m_client->m_last_resultSetId)
+ {
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentResponse);
+ new_apdu->u.presentResponse->records =
+ create_nonSurrogateDiagnostics(odr_encode(), 30,
+ pr->resultSetId);
+ send_to_client(new_apdu);
+ return 0;
+ }
+ if (!strcmp(m_client->m_last_resultSetId, pr->resultSetId))
+ {
+ if (start+toget-1 > m_client->m_last_resultCount)
+ {
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentResponse);
+ new_apdu->u.presentResponse->records =
+ create_nonSurrogateDiagnostics(odr_encode(), 13, 0);
+ send_to_client(new_apdu);
+ return 0;
+ }
+ Z_NamePlusRecordList *npr;
+ if (m_client->m_cache.lookup (odr_encode(), &npr, start, toget,
+ pr->preferredRecordSyntax,
+ pr->recordComposition))
+ {
+ yaz_log (LOG_LOG, "%sReturned cached records for present request",
+ m_session_str);
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentResponse);
+ new_apdu->u.presentResponse->referenceId = pr->referenceId;
+
+ new_apdu->u.presentResponse->numberOfRecordsReturned
+ = odr_intdup(odr_encode(), toget);
+
+ new_apdu->u.presentResponse->records = (Z_Records*)
+ odr_malloc(odr_encode(), sizeof(Z_Records));
+ new_apdu->u.presentResponse->records->which = Z_Records_DBOSD;
+ new_apdu->u.presentResponse->records->u.databaseOrSurDiagnostics = npr;
+ new_apdu->u.presentResponse->nextResultSetPosition =
+ odr_intdup(odr_encode(), start+toget);
+
+ send_to_client(new_apdu);
+ return 0;
+ }
+ }
+ }
+
+ if (apdu->which != Z_APDU_searchRequest)
+ return apdu;
+ Z_SearchRequest *sr = apdu->u.searchRequest;
+ Yaz_Z_Query *this_query = new Yaz_Z_Query;
+ Yaz_Z_Databases this_databases;
+
+ this_databases.set(sr->num_databaseNames, (const char **)
+ sr->databaseNames);
+
+ this_query->set_Z_Query(sr->query);
+
+ char query_str[120];
+ this_query->print(query_str, sizeof(query_str)-1);
+ yaz_log(LOG_LOG, "%sSearch %s", m_session_str, query_str);
+
+ if (*m_parent->m_optimize != '0' &&
+ m_client->m_last_ok && m_client->m_last_query &&
+ m_client->m_last_query->match(this_query) &&
+ !strcmp(m_client->m_last_resultSetId, sr->resultSetName) &&
+ m_client->m_last_databases.match(this_databases))
+ {
+ delete this_query;
+ if (m_client->m_last_resultCount > *sr->smallSetUpperBound &&
+ m_client->m_last_resultCount < *sr->largeSetLowerBound)
+ {
+ Z_NamePlusRecordList *npr;
+ int toget = *sr->mediumSetPresentNumber;
+ Z_RecordComposition *comp = 0;
+
+ if (toget > m_client->m_last_resultCount)
+ toget = m_client->m_last_resultCount;
+
+ if (sr->mediumSetElementSetNames)
+ {
+ comp = (Z_RecordComposition *)
+ odr_malloc(odr_encode(), sizeof(Z_RecordComposition));
+ comp->which = Z_RecordComp_simple;
+ comp->u.simple = sr->mediumSetElementSetNames;
+ }
+
+ if (m_client->m_cache.lookup (odr_encode(), &npr, 1, toget,
+ sr->preferredRecordSyntax, comp))
+ {
+ yaz_log (LOG_LOG, "%sReturned cached records for medium set",
+ m_session_str);
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
+ new_apdu->u.searchResponse->referenceId = sr->referenceId;
+ new_apdu->u.searchResponse->resultCount =
+ &m_client->m_last_resultCount;
+
+ new_apdu->u.searchResponse->numberOfRecordsReturned
+ = odr_intdup(odr_encode(), toget);
+
+ new_apdu->u.searchResponse->presentStatus =
+ odr_intdup(odr_encode(), Z_PresentStatus_success);
+ new_apdu->u.searchResponse->records = (Z_Records*)
+ odr_malloc(odr_encode(), sizeof(Z_Records));
+ new_apdu->u.searchResponse->records->which = Z_Records_DBOSD;
+ new_apdu->u.searchResponse->records->u.databaseOrSurDiagnostics = npr;
+ new_apdu->u.searchResponse->nextResultSetPosition =
+ odr_intdup(odr_encode(), toget+1);
+ send_to_client(new_apdu);
+ return 0;
+ }
+ else
+ {
+ // medium Set
+ // send present request (medium size)
+ yaz_log (LOG_LOG, "%sOptimizing search for medium set",
+ m_session_str);
+
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentRequest);
+ Z_PresentRequest *pr = new_apdu->u.presentRequest;
+ pr->referenceId = sr->referenceId;
+ pr->resultSetId = sr->resultSetName;
+ pr->preferredRecordSyntax = sr->preferredRecordSyntax;
+ *pr->numberOfRecordsRequested = toget;
+ pr->recordComposition = comp;
+ m_client->m_sr_transform = 1;
+ return new_apdu;
+ }
+ }
+ else if (m_client->m_last_resultCount >= *sr->largeSetLowerBound ||
+ m_client->m_last_resultCount <= 0)
+ {
+ // large set. Return pseudo-search response immediately
+ yaz_log (LOG_LOG, "%sOptimizing search for large set",
+ m_session_str);
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
+ new_apdu->u.searchResponse->referenceId = sr->referenceId;
+ new_apdu->u.searchResponse->resultCount =
+ &m_client->m_last_resultCount;
+ send_to_client(new_apdu);
+ return 0;
+ }
+ else
+ {
+ Z_NamePlusRecordList *npr;
+ int toget = m_client->m_last_resultCount;
+ Z_RecordComposition *comp = 0;
+ // small set
+ // send a present request (small set)
+
+ if (sr->smallSetElementSetNames)
+ {
+ comp = (Z_RecordComposition *)
+ odr_malloc(odr_encode(), sizeof(Z_RecordComposition));
+ comp->which = Z_RecordComp_simple;
+ comp->u.simple = sr->smallSetElementSetNames;
+ }
+
+ if (m_client->m_cache.lookup (odr_encode(), &npr, 1, toget,
+ sr->preferredRecordSyntax, comp))
+ {
+ yaz_log (LOG_LOG, "%sReturned cached records for small set",
+ m_session_str);
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
+ new_apdu->u.searchResponse->referenceId = sr->referenceId;
+ new_apdu->u.searchResponse->resultCount =
+ &m_client->m_last_resultCount;
+
+ new_apdu->u.searchResponse->numberOfRecordsReturned
+ = odr_intdup(odr_encode(), toget);
+
+ new_apdu->u.searchResponse->presentStatus =
+ odr_intdup(odr_encode(), Z_PresentStatus_success);
+ new_apdu->u.searchResponse->records = (Z_Records*)
+ odr_malloc(odr_encode(), sizeof(Z_Records));
+ new_apdu->u.searchResponse->records->which = Z_Records_DBOSD;
+ new_apdu->u.searchResponse->records->u.databaseOrSurDiagnostics = npr;
+ new_apdu->u.searchResponse->nextResultSetPosition =
+ odr_intdup(odr_encode(), toget+1);
+ send_to_client(new_apdu);
+ return 0;
+ }
+ else
+ {
+ yaz_log (LOG_LOG, "%sOptimizing search for small set",
+ m_session_str);
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentRequest);
+ Z_PresentRequest *pr = new_apdu->u.presentRequest;
+ pr->referenceId = sr->referenceId;
+ pr->resultSetId = sr->resultSetName;
+ pr->preferredRecordSyntax = sr->preferredRecordSyntax;
+ *pr->numberOfRecordsRequested = toget;
+ pr->recordComposition = comp;
+ m_client->m_sr_transform = 1;
+ return new_apdu;
+ }
+ }
+ }
+ else // query doesn't match
+ {
+ delete m_client->m_last_query;
+ m_client->m_last_query = this_query;
+ m_client->m_last_ok = 0;
+ m_client->m_cache.clear();
+ m_client->m_resultSetStartPoint = 0;
+
+ xfree (m_client->m_last_resultSetId);
+ m_client->m_last_resultSetId = xstrdup (sr->resultSetName);
+
+ m_client->m_last_databases.set(sr->num_databaseNames,
+ (const char **) sr->databaseNames);
+ }
+ return apdu;
+}
+
+
+void Yaz_Proxy::recv_GDU(Z_GDU *apdu, int len)
+{
+ char *cp = strchr(m_session_str, ' ');
+ m_request_no++;
+ if (cp)
+ sprintf(cp+1, "%d ", m_request_no);
+
+ m_bytes_recv += len;
+
+ if (m_log_mask & PROXY_LOG_APDU_CLIENT)
+ yaz_log (LOG_DEBUG, "%sReceiving %s from client %d bytes",
+ m_session_str, gdu_name(apdu), len);
+
+ if (m_bw_hold_PDU) // double incoming PDU. shutdown now.
+ shutdown();
+
+ m_bw_stat.add_bytes(len);
+ m_pdu_stat.add_bytes(1);
+
+ int bw_total = m_bw_stat.get_total();
+ int pdu_total = m_pdu_stat.get_total();
+
+ int reduce = 0;
+ if (m_bw_max)
+ {
+ if (bw_total > m_bw_max)
+ {
+ reduce = (bw_total/m_bw_max);
+ }
+ }
+ if (m_pdu_max)
+ {
+ if (pdu_total > m_pdu_max)
+ {
+ int nreduce = (m_pdu_max >= 60) ? 1 : 60/m_pdu_max;
+ reduce = (reduce > nreduce) ? reduce : nreduce;
+ }
+ }
+ if (reduce)
+ {
+ yaz_log(LOG_LOG, "%sdelay=%d bw=%d pdu=%d limit-bw=%d limit-pdu=%d",
+ m_session_str, reduce, bw_total, pdu_total,
+ m_bw_max, m_pdu_max);
+
+ m_bw_hold_PDU = apdu; // save PDU and signal "on hold"
+ timeout(reduce); // call us reduce seconds later
+ }
+ else if (apdu->which == Z_GDU_Z3950)
+ handle_incoming_Z_PDU(apdu->u.z3950);
+ else if (apdu->which == Z_GDU_HTTP_Request)
+ handle_incoming_HTTP(apdu->u.HTTP_Request);
+}
+
+void Yaz_Proxy::handle_max_record_retrieve(Z_APDU *apdu)
+{
+ if (m_max_record_retrieve)
+ {
+ if (apdu->which == Z_APDU_presentRequest)
+ {
+ Z_PresentRequest *pr = apdu->u.presentRequest;
+ if (pr->numberOfRecordsRequested &&
+ *pr->numberOfRecordsRequested > m_max_record_retrieve)
+ *pr->numberOfRecordsRequested = m_max_record_retrieve;
+ }
+ }
+}
+
+Z_Records *Yaz_Proxy::create_nonSurrogateDiagnostics(ODR odr,
+ int error,
+ const char *addinfo)
+{
+ Z_Records *rec = (Z_Records *)
+ odr_malloc (odr, sizeof(*rec));
+ int *err = (int *)
+ odr_malloc (odr, sizeof(*err));
+ Z_DiagRec *drec = (Z_DiagRec *)
+ odr_malloc (odr, sizeof(*drec));
+ Z_DefaultDiagFormat *dr = (Z_DefaultDiagFormat *)
+ odr_malloc (odr, sizeof(*dr));
+ *err = error;
+ rec->which = Z_Records_NSD;
+ rec->u.nonSurrogateDiagnostic = dr;
+ dr->diagnosticSetId =
+ yaz_oidval_to_z3950oid (odr, CLASS_DIAGSET, VAL_BIB1);
+ dr->condition = err;
+ dr->which = Z_DefaultDiagFormat_v2Addinfo;
+ dr->u.v2Addinfo = odr_strdup (odr, addinfo ? addinfo : "");
+ return rec;
+}
+
+Z_APDU *Yaz_Proxy::handle_query_transformation(Z_APDU *apdu)
+{
+ if (apdu->which == Z_APDU_searchRequest &&
+ apdu->u.searchRequest->query &&
+ apdu->u.searchRequest->query->which == Z_Query_type_104 &&
+ apdu->u.searchRequest->query->u.type_104->which == Z_External_CQL)
+ {
+ Z_RPNQuery *rpnquery = 0;
+ Z_SearchRequest *sr = apdu->u.searchRequest;
+
+ yaz_log(LOG_LOG, "%sCQL: %s", m_session_str,
+ sr->query->u.type_104->u.cql);
+
+ int r = m_cql2rpn.query_transform(sr->query->u.type_104->u.cql,
+ &rpnquery, odr_encode());
+ if (r == -3)
+ yaz_log(LOG_LOG, "%sNo CQL to RPN table", m_session_str);
+ else if (r)
+ yaz_log(LOG_LOG, "%sCQL Conversion error %d", m_session_str, r);
+ else
+ {
+ sr->query->which = Z_Query_type_1;
+ sr->query->u.type_1 = rpnquery;
+ }
+ return apdu;
+ }
+ return apdu;
+}
+
+Z_APDU *Yaz_Proxy::handle_query_validation(Z_APDU *apdu)
+{
+ if (apdu->which == Z_APDU_searchRequest)
+ {
+ Z_SearchRequest *sr = apdu->u.searchRequest;
+ int err = 0;
+ char *addinfo = 0;
+
+ Yaz_ProxyConfig *cfg = check_reconfigure();
+ if (cfg)
+ err = cfg->check_query(odr_encode(), m_default_target,
+ sr->query, &addinfo);
+ if (err)
+ {
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
+
+ new_apdu->u.searchResponse->referenceId = sr->referenceId;
+ new_apdu->u.searchResponse->records =
+ create_nonSurrogateDiagnostics(odr_encode(), err, addinfo);
+ *new_apdu->u.searchResponse->searchStatus = 0;
+
+ send_to_client(new_apdu);
+
+ return 0;
+ }
+ }
+ return apdu;
+}
+
+Z_APDU *Yaz_Proxy::handle_syntax_validation(Z_APDU *apdu)
+{
+ m_marcxml_flag = 0;
+ if (apdu->which == Z_APDU_searchRequest)
+ {
+ Z_SearchRequest *sr = apdu->u.searchRequest;
+ int err = 0;
+ char *addinfo = 0;
+ Yaz_ProxyConfig *cfg = check_reconfigure();
+
+ if (cfg)
+ err = cfg->check_syntax(odr_encode(),
+ m_default_target,
+ sr->preferredRecordSyntax,
+ &addinfo);
+ if (err == -1)
+ {
+ sr->preferredRecordSyntax =
+ yaz_oidval_to_z3950oid(odr_decode(), CLASS_RECSYN,
+ VAL_USMARC);
+ m_marcxml_flag = 1;
+ }
+ else if (err)
+ {
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
+
+ new_apdu->u.searchResponse->referenceId = sr->referenceId;
+ new_apdu->u.searchResponse->records =
+ create_nonSurrogateDiagnostics(odr_encode(), err, addinfo);
+ *new_apdu->u.searchResponse->searchStatus = 0;
+
+ send_to_client(new_apdu);
+
+ return 0;
+ }
+ }
+ else if (apdu->which == Z_APDU_presentRequest)
+ {
+ Z_PresentRequest *pr = apdu->u.presentRequest;
+ int err = 0;
+ char *addinfo = 0;
+ Yaz_ProxyConfig *cfg = check_reconfigure();
+
+ if (cfg)
+ err = cfg->check_syntax(odr_encode(), m_default_target,
+ pr->preferredRecordSyntax,
+ &addinfo);
+ if (err == -1)
+ {
+ pr->preferredRecordSyntax =
+ yaz_oidval_to_z3950oid(odr_decode(), CLASS_RECSYN,
+ VAL_USMARC);
+ m_marcxml_flag = 1;
+ }
+ else if (err)
+ {
+ Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentResponse);
+
+ new_apdu->u.presentResponse->referenceId = pr->referenceId;
+ new_apdu->u.presentResponse->records =
+ create_nonSurrogateDiagnostics(odr_encode(), err, addinfo);
+ *new_apdu->u.presentResponse->presentStatus =
+ Z_PresentStatus_failure;
+
+ send_to_client(new_apdu);
+
+ return 0;
+ }
+ }
+ return apdu;
+}
+
+void Yaz_Proxy::handle_incoming_HTTP(Z_HTTP_Request *hreq)
+{
+ Z_SRW_PDU *srw_pdu = 0;
+ char *soap_ns = 0;
+ if (m_s2z_odr_init)
+ {
+ odr_destroy(m_s2z_odr_init);
+ m_s2z_odr_init = 0;
+ }
+ if (m_s2z_odr_search)
+ {
+ odr_destroy(m_s2z_odr_search);
+ m_s2z_odr_search = 0;
+ }
+
+ m_http_keepalive = 0;
+ m_http_version = 0;
+ if (!strcmp(hreq->version, "1.0"))
+ {
+ const char *v = z_HTTP_header_lookup(hreq->headers, "Connection");
+ if (v && !strcmp(v, "Keep-Alive"))
+ m_http_keepalive = 1;
+ else
+ m_http_keepalive = 0;
+ m_http_version = "1.0";
+ }
+ else
+ {
+ const char *v = z_HTTP_header_lookup(hreq->headers, "Connection");
+ if (v && !strcmp(v, "close"))
+ m_http_keepalive = 0;
+ else
+ m_http_keepalive = 1;
+ m_http_version = "1.1";
+ }
+
+ if (yaz_check_for_srw(hreq, &srw_pdu, &soap_ns, odr_decode()) == 0
+ || yaz_check_for_sru(hreq, &srw_pdu, &soap_ns, odr_decode()) == 0)
+ {
+ m_s2z_odr_init = odr_createmem(ODR_ENCODE);
+ m_s2z_odr_search = odr_createmem(ODR_ENCODE);
+ m_soap_ns = odr_strdup(m_s2z_odr_search, soap_ns);
+ m_s2z_init_apdu = 0;
+ m_s2z_search_apdu = 0;
+ m_s2z_present_apdu = 0;
+ if (srw_pdu->which == Z_SRW_searchRetrieve_request)
+ {
+ Z_SRW_searchRetrieveRequest *srw_req = srw_pdu->u.request;
+
+ // set packing for response records ..
+ if (srw_req->recordPacking &&
+ !strcmp(srw_req->recordPacking, "xml"))
+ m_s2z_packing = Z_SRW_recordPacking_XML;
+ else
+ m_s2z_packing = Z_SRW_recordPacking_string;
+
+ // prepare search PDU
+ m_s2z_search_apdu = zget_APDU(m_s2z_odr_search,
+ Z_APDU_searchRequest);
+ Z_SearchRequest *z_searchRequest =
+ m_s2z_search_apdu->u.searchRequest;
+
+ z_searchRequest->num_databaseNames = 1;
+ z_searchRequest->databaseNames = (char**)
+ odr_malloc(m_s2z_odr_search, sizeof(char *));
+ z_searchRequest->databaseNames[0] = odr_strdup(m_s2z_odr_search,
+ srw_req->database);
+
+ // query transformation
+ Z_Query *query = (Z_Query *)
+ odr_malloc(m_s2z_odr_search, sizeof(Z_Query));
+ z_searchRequest->query = query;
+
+ if (srw_req->query_type == Z_SRW_query_type_cql)
+ {
+ Z_External *ext = (Z_External *)
+ odr_malloc(m_s2z_odr_search, sizeof(*ext));
+ ext->direct_reference =
+ odr_getoidbystr(m_s2z_odr_search, "1.2.840.10003.16.2");
+ ext->indirect_reference = 0;
+ ext->descriptor = 0;
+ ext->which = Z_External_CQL;
+ ext->u.cql = srw_req->query.cql;
+
+ query->which = Z_Query_type_104;
+ query->u.type_104 = ext;
+ }
+ else if (srw_req->query_type == Z_SRW_query_type_pqf)
+ {
+ Z_RPNQuery *RPNquery;
+ YAZ_PQF_Parser pqf_parser;
+
+ pqf_parser = yaz_pqf_create ();
+
+ RPNquery = yaz_pqf_parse (pqf_parser, m_s2z_odr_search,
+ srw_req->query.pqf);
+ if (!RPNquery)
+ {
+ const char *pqf_msg;
+ size_t off;
+ int code = yaz_pqf_error (pqf_parser, &pqf_msg, &off);
+ yaz_log(LOG_LOG, "%*s^\n", off+4, "");
+ yaz_log(LOG_LOG, "Bad PQF: %s (code %d)\n", pqf_msg, code);
+
+ send_to_srw_client_error(10);
+ return;
+ }
+ query->which = Z_Query_type_1;
+ query->u.type_1 = RPNquery;
+
+ yaz_pqf_destroy (pqf_parser);
+ }
+ else
+ {
+ send_to_srw_client_error(11);
+ return;
+ }
+
+ // present
+ m_s2z_present_apdu = 0;
+ int max = 0;
+ if (srw_req->maximumRecords)
+ max = *srw_req->maximumRecords;
+ int start = 1;
+ if (srw_req->startRecord)
+ start = *srw_req->startRecord;
+ if (max > 0)
+ {
+ if (start <= 1) // Z39.50 piggyback
+ {
+ *z_searchRequest->smallSetUpperBound = max;
+ *z_searchRequest->mediumSetPresentNumber = max;
+ *z_searchRequest->largeSetLowerBound = 2000000000; // 2e9
+ z_searchRequest->preferredRecordSyntax =
+ yaz_oidval_to_z3950oid(m_s2z_odr_search, CLASS_RECSYN,
+ VAL_TEXT_XML);
+ }
+ else // Z39.50 present
+ {
+ m_s2z_present_apdu = zget_APDU(m_s2z_odr_search,
+ Z_APDU_presentRequest);
+ Z_PresentRequest *z_presentRequest =
+ m_s2z_present_apdu->u.presentRequest;
+ *z_presentRequest->resultSetStartPoint = start;
+ *z_presentRequest->numberOfRecordsRequested = max;
+ z_presentRequest->preferredRecordSyntax =
+ yaz_oidval_to_z3950oid(m_s2z_odr_search, CLASS_RECSYN,
+ VAL_TEXT_XML);
+ }
+ }
+ if (!m_client)
+ {
+ yaz_log(LOG_LOG, "handle_incoming: initRequest");
+ m_s2z_init_apdu = zget_APDU(m_s2z_odr_init,
+ Z_APDU_initRequest);
+
+ // prevent m_initRequest_apdu memory from being grabbed
+ // in Yaz_Proxy::handle_incoming_Z_PDU
+ m_initRequest_apdu = m_s2z_init_apdu;
+ handle_incoming_Z_PDU(m_s2z_init_apdu);
+ return;
+ }
+ else
+ {
+ handle_incoming_Z_PDU(m_s2z_search_apdu);
+ return;
+ }
+ }
+ else if (srw_pdu->which == Z_SRW_explain_request)
+ {
+ if (!m_client)
+ {
+ yaz_log(LOG_LOG, "handle_incoming: initRequest");
+ m_s2z_init_apdu = zget_APDU(m_s2z_odr_init,
+ Z_APDU_initRequest);
+
+ // prevent m_initRequest_apdu memory from being grabbed
+ // in Yaz_Proxy::handle_incoming_Z_PDU
+ m_initRequest_apdu = m_s2z_init_apdu;
+ handle_incoming_Z_PDU(m_s2z_init_apdu);
+ }
+ else
+ send_srw_explain();
+ return;
+ }
+ }
+ int len = 0;
+ Z_GDU *p = z_get_HTTP_Response(odr_encode(), 400);
+ send_GDU(p, &len);
+ timeout(1);
+}
+
+void Yaz_Proxy::handle_incoming_Z_PDU(Z_APDU *apdu)
+{
+ if (!m_client && m_invalid_session)
+ {
+ m_apdu_invalid_session = apdu;
+ m_mem_invalid_session = odr_extract_mem(odr_decode());
+ apdu = m_initRequest_apdu;
+ }
+
+ // Determine our client.
+ Z_OtherInformation **oi;
+ get_otherInfoAPDU(apdu, &oi);
+ m_client = get_client(apdu, get_cookie(oi), get_proxy(oi));
+ if (!m_client)
+ {
+ delete this;
+ return;
+ }
+ m_client->m_server = this;
+
+ if (apdu->which == Z_APDU_initRequest)
+ {
+ if (apdu->u.initRequest->implementationId)
+ yaz_log(LOG_LOG, "%simplementationId: %s",
+ m_session_str, apdu->u.initRequest->implementationId);
+ if (apdu->u.initRequest->implementationName)
+ yaz_log(LOG_LOG, "%simplementationName: %s",
+ m_session_str, apdu->u.initRequest->implementationName);
+ if (apdu->u.initRequest->implementationVersion)
+ yaz_log(LOG_LOG, "%simplementationVersion: %s",
+ m_session_str, apdu->u.initRequest->implementationVersion);
+ if (m_initRequest_apdu == 0)
+ {
+ if (m_initRequest_mem)
+ nmem_destroy(m_initRequest_mem);
+ m_initRequest_apdu = apdu;
+ m_initRequest_mem = odr_extract_mem(odr_decode());
+ }
+ if (m_client->m_init_flag)
+ {
+ if (handle_init_response_for_invalid_session(apdu))
+ return;
+ Z_APDU *apdu2 = m_client->m_initResponse;
+ apdu2->u.initResponse->otherInfo = 0;
+ if (m_client->m_cookie && *m_client->m_cookie)
+ set_otherInformationString(apdu2, VAL_COOKIE, 1,
+ m_client->m_cookie);
+ apdu2->u.initResponse->referenceId =
+ apdu->u.initRequest->referenceId;
+ send_to_client(apdu2);
+ return;
+ }
+ m_client->m_init_flag = 1;
+ }
+ handle_max_record_retrieve(apdu);
+
+ if (apdu)
+ apdu = handle_syntax_validation(apdu);
+
+ if (apdu)
+ apdu = handle_query_transformation(apdu);
+
+ if (apdu)
+ apdu = handle_query_validation(apdu);
+
+ if (apdu)
+ apdu = result_set_optimize(apdu);
+ if (!apdu)
+ {
+ m_client->timeout(m_target_idletime); // mark it active even
+ // though we didn't use it
+ return;
+ }
+
+ // delete other info part from PDU before sending to target
+ get_otherInfoAPDU(apdu, &oi);
+ if (oi)
+ *oi = 0;
+
+ if (apdu->which == Z_APDU_presentRequest &&
+ m_client->m_resultSetStartPoint == 0)
+ {
+ Z_PresentRequest *pr = apdu->u.presentRequest;
+ m_client->m_resultSetStartPoint = *pr->resultSetStartPoint;
+ m_client->m_cache.copy_presentRequest(apdu->u.presentRequest);
+ } else {
+ m_client->m_resultSetStartPoint = 0;
+ }
+ if (m_client->send_to_target(apdu) < 0)
+ {
+ delete m_client;
+ m_client = 0;
+ delete this;
+ }
+ else
+ m_client->m_waiting = 1;
+}
+
+void Yaz_Proxy::connectNotify()
+{
+}
+
+void Yaz_Proxy::shutdown()
+{
+ m_invalid_session = 0;
+ // only keep if keep_alive flag is set...
+ if (m_client &&
+ m_client->m_pdu_recv < m_keepalive_limit_pdu &&
+ m_client->m_bytes_recv+m_client->m_bytes_sent < m_keepalive_limit_bw &&
+ m_client->m_waiting == 0)
+ {
+ yaz_log(LOG_LOG, "%sShutdown (client to proxy) keepalive %s",
+ m_session_str,
+ m_client->get_hostname());
+ yaz_log(LOG_LOG, "%sbw=%d pdu=%d limit-bw=%d limit-pdu=%d",
+ m_session_str, m_client->m_pdu_recv,
+ m_client->m_bytes_sent + m_client->m_bytes_recv,
+ m_keepalive_limit_bw, m_keepalive_limit_pdu);
+ assert (m_client->m_waiting != 2);
+ // Tell client (if any) that no server connection is there..
+ m_client->m_server = 0;
+ m_invalid_session = 0;
+ }
+ else if (m_client)
+ {
+ yaz_log (LOG_LOG, "%sShutdown (client to proxy) close %s",
+ m_session_str,
+ m_client->get_hostname());
+ assert (m_client->m_waiting != 2);
+ delete m_client;
+ }
+ else if (!m_parent)
+ {
+ yaz_log (LOG_LOG, "%sshutdown (client to proxy) bad state",
+ m_session_str);
+ assert (m_parent);
+ }
+ else
+ {
+ yaz_log (LOG_LOG, "%sShutdown (client to proxy)",
+ m_session_str);
+ }
+ if (m_parent)
+ m_parent->pre_init();
+ delete this;
+}
+
+const char *Yaz_ProxyClient::get_session_str()
+{
+ if (!m_server)
+ return "0 ";
+ return m_server->get_session_str();
+}
+
+void Yaz_ProxyClient::shutdown()