+ int oid[OID_SIZE];
+ Z_DiagRecs *recs = (Z_DiagRecs *)odr_malloc (assoc->encode, sizeof(*recs));
+ int *err = (int *)odr_malloc (assoc->encode, sizeof(*err));
+ oident bib1;
+ Z_DiagRec **recp = (Z_DiagRec **)odr_malloc (assoc->encode, sizeof(*recp));
+ Z_DiagRec *drec = (Z_DiagRec *)odr_malloc (assoc->encode, sizeof(*drec));
+ Z_DefaultDiagFormat *rec = (Z_DefaultDiagFormat *)odr_malloc (assoc->encode, sizeof(*rec));
+
+ logf(LOG_DEBUG, "DiagRecs: %d -- %s", error, addinfo);
+ bib1.proto = assoc->proto;
+ bib1.oclass = CLASS_DIAGSET;
+ bib1.value = VAL_BIB1;
+
+ *err = error;
+ recs->num_diagRecs = 1;
+ recs->diagRecs = recp;
+ recp[0] = drec;
+ drec->which = Z_DiagRec_defaultFormat;
+ drec->u.defaultFormat = rec;
+
+ rec->diagnosticSetId = odr_oiddup (assoc->encode,
+ oid_ent_to_oid(&bib1, oid));
+ rec->condition = err;
+
+#ifdef ASN_COMPILED
+ rec->which = Z_DefaultDiagFormat_v2Addinfo;
+ rec->u.v2Addinfo = addinfo ? addinfo : "";
+#else
+ rec->which = Z_DiagForm_v2AddInfo;
+ rec->addinfo = addinfo ? addinfo : "";
+#endif
+ return recs;
+}
+
+static Z_Records *pack_records(association *a, char *setname, int start,
+ int *num, Z_RecordComposition *comp,
+ int *next, int *pres, oid_value format)
+{
+ int oid[OID_SIZE];
+ int recno, total_length = 0, toget = *num, dumped_records = 0;
+ Z_Records *records = (Z_Records *)odr_malloc (a->encode, sizeof(*records));
+ Z_NamePlusRecordList *reclist = (Z_NamePlusRecordList *)odr_malloc (a->encode, sizeof(*reclist));
+ Z_NamePlusRecord **list = (Z_NamePlusRecord **)odr_malloc (a->encode, sizeof(*list) * toget);
+ oident recform;
+
+ records->which = Z_Records_DBOSD;
+ records->u.databaseOrSurDiagnostics = reclist;
+ reclist->num_records = 0;
+ reclist->records = list;
+ *pres = Z_PRES_SUCCESS;
+ *num = 0;
+ *next = 0;
+
+ logf(LOG_DEBUG, "Request to pack %d+%d", start, toget);
+ logf(LOG_DEBUG, "pms=%d, mrs=%d", a->preferredMessageSize,
+ a->maximumRecordSize);
+ for (recno = start; reclist->num_records < toget; recno++)
+ {
+ bend_fetchrequest freq;
+ bend_fetchresult *fres;
+ Z_NamePlusRecord *thisrec;
+ Z_DatabaseRecord *thisext;
+ int this_length = 0;
+
+ /*
+ * we get the number of bytes allocated on the stream before any
+ * allocation done by the backend - this should give us a reasonable
+ * idea of the total size of the data so far.
+ */
+ total_length = odr_total(a->encode) - dumped_records;
+ freq.setname = setname;
+ freq.number = recno;
+ freq.comp = comp;
+ freq.format = format;
+ freq.stream = a->encode;
+ freq.surrogate_flag = 0;
+ if (!(fres = bend_fetch(a->backend, &freq, 0)))
+ {
+ *pres = Z_PRES_FAILURE;
+ return diagrec(a, 2, "Backend interface problem");
+ }
+ /* backend should be able to signal whether error is system-wide
+ or only pertaining to current record */
+ if (fres->errcode)
+ {
+ if (!freq.surrogate_flag)
+ {
+ *pres = Z_PRES_FAILURE;
+ return diagrec(a, fres->errcode, fres->errstring);
+ }
+ reclist->records[reclist->num_records] =
+ surrogatediagrec(a, fres->basename, fres->errcode,
+ fres->errstring);
+ reclist->num_records++;
+ *next = fres->last_in_set ? 0 : recno + 1;
+ continue;
+ }
+ if (fres->len >= 0)
+ this_length = fres->len;
+ else
+ this_length = odr_total(a->encode) - total_length;
+ logf(LOG_DEBUG, " fetched record, len=%d, total=%d",
+ this_length, total_length);
+ if (this_length + total_length > a->preferredMessageSize)
+ {
+ /* record is small enough, really */
+ if (this_length <= a->preferredMessageSize)
+ {
+ logf(LOG_DEBUG, " Dropped last normal-sized record");
+ *pres = Z_PRES_PARTIAL_2;
+ break;
+ }
+ /* record can only be fetched by itself */
+ if (this_length < a->maximumRecordSize)
+ {
+ logf(LOG_DEBUG, " Record > prefmsgsz");
+ if (toget > 1)
+ {
+ logf(LOG_DEBUG, " Dropped it");
+ reclist->records[reclist->num_records] =
+ surrogatediagrec(a, fres->basename, 16, 0);
+ reclist->num_records++;
+ *next = fres->last_in_set ? 0 : recno + 1;
+ dumped_records += this_length;
+ continue;
+ }
+ }
+ else /* too big entirely */
+ {
+ logf(LOG_DEBUG, "Record > maxrcdsz");
+ reclist->records[reclist->num_records] =
+ surrogatediagrec(a, fres->basename, 17, 0);
+ reclist->num_records++;
+ *next = fres->last_in_set ? 0 : recno + 1;
+ dumped_records += this_length;
+ continue;
+ }
+ }
+
+ if (!(thisrec = (Z_NamePlusRecord *)odr_malloc(a->encode, sizeof(*thisrec))))
+ return 0;
+ if (!(thisrec->databaseName = (char *)odr_malloc(a->encode,
+ strlen(fres->basename) + 1)))
+ return 0;
+ strcpy(thisrec->databaseName, fres->basename);
+ thisrec->which = Z_NamePlusRecord_databaseRecord;
+ if (!(thisrec->u.databaseRecord = thisext = (Z_External *)odr_malloc(a->encode,
+ sizeof(Z_DatabaseRecord))))
+ return 0;
+ recform.proto = a->proto;
+ recform.oclass = CLASS_RECSYN;
+ recform.value = fres->format;
+ thisext->direct_reference = odr_oiddup(a->encode,
+ oid_ent_to_oid(&recform, oid));
+ thisext->indirect_reference = 0;
+ thisext->descriptor = 0;
+ if (fres->len < 0) /* Structured data */
+ {
+ switch (fres->format)
+ {
+ case VAL_SUTRS: thisext->which = Z_External_sutrs; break;
+ case VAL_GRS1: thisext->which = Z_External_grs1; break;
+ case VAL_EXPLAIN: thisext->which = Z_External_explainRecord;
+ break;
+ case VAL_SUMMARY: thisext->which = Z_External_summary; break;
+ case VAL_OPAC: thisext->which = Z_External_OPAC; break;
+
+ default:
+ logf(LOG_FATAL, "Unknown structured format from backend.");
+ return 0;
+ }
+
+ /*
+ * We cheat on the pointers here. Obviously, the record field
+ * of the backend-fetch structure should have been a union for
+ * correctness, but we're stuck with this for backwards
+ * compatibility.
+ */
+ thisext->u.grs1 = (Z_GenericRecord*) fres->record;
+ }
+ else if (fres->format == VAL_SUTRS) /* SUTRS is a single-ASN.1-type */
+ {
+#if 0
+ Z_SUTRS *sutrs = (Z_SUTRS *)odr_malloc(a->encode, 1+fres->len);
+
+ memcpy(sutrs, fres->record, fres->len);
+ sutrs[fres->len] = '\0';
+#else
+ Odr_oct *sutrs = (Odr_oct *)odr_malloc(a->encode, sizeof(*sutrs));
+
+ thisext->which = Z_External_sutrs;
+ thisext->u.sutrs = sutrs;
+ sutrs->buf = (unsigned char *)odr_malloc(a->encode, fres->len);
+ sutrs->len = sutrs->size = fres->len;
+ memcpy(sutrs->buf, fres->record, fres->len);
+#endif
+ }
+ else /* octet-aligned record. */
+ {
+ thisext->which = Z_External_octet;
+ if (!(thisext->u.octet_aligned = (Odr_oct *)odr_malloc(a->encode,
+ sizeof(Odr_oct))))
+ return 0;
+ if (!(thisext->u.octet_aligned->buf = (unsigned char *)odr_malloc(a->encode,
+ fres->len)))
+ return 0;
+ memcpy(thisext->u.octet_aligned->buf, fres->record, fres->len);
+ thisext->u.octet_aligned->len = thisext->u.octet_aligned->size =
+ fres->len;
+ }
+ reclist->records[reclist->num_records] = thisrec;
+ reclist->num_records++;
+ *next = fres->last_in_set ? 0 : recno + 1;
+ }
+ *num = reclist->num_records;
+ return records;
+}
+
+static Z_APDU *process_searchRequest(association *assoc, request *reqb,
+ int *fd)
+{
+ Z_SearchRequest *req = reqb->request->u.searchRequest;
+ bend_search_rr *bsrr = (bend_search_rr *)nmem_malloc (reqb->request_mem, sizeof(*bsrr));
+
+ logf(LOG_LOG, "Got SearchRequest.");
+ save_referenceId (reqb, req->referenceId);
+ /* store ref id in request */
+ bsrr->fd = fd;
+ bsrr->request = reqb;
+ bsrr->association = assoc;
+ if (assoc->bend_search)
+ {
+ bsrr->setname = req->resultSetName;
+ bsrr->replace_set = *req->replaceIndicator;
+ bsrr->num_bases = req->num_databaseNames;
+ bsrr->basenames = req->databaseNames;
+ bsrr->query = req->query;
+ bsrr->stream = assoc->encode;
+ bsrr->decode = assoc->decode;
+ bsrr->errcode = 0;
+ bsrr->hits = 0;
+ bsrr->errstring = NULL;
+ ((int (*)(void *, bend_search_rr *))(assoc->bend_search))(assoc->backend, bsrr);
+ if (!bsrr->request)
+ return 0;
+ }
+ else
+ {
+ bend_searchrequest bsrq;
+ bend_searchresult *bsrt;
+
+ bsrq.setname = req->resultSetName;
+ bsrq.replace_set = *req->replaceIndicator;
+ bsrq.num_bases = req->num_databaseNames;
+ bsrq.basenames = req->databaseNames;
+ bsrq.query = req->query;
+ bsrq.stream = assoc->encode;
+ bsrq.decode = assoc->decode;
+ if (!(bsrt = bend_search(assoc->backend, &bsrq, fd)))
+ return 0;
+ bsrr->hits = bsrt->hits;
+ bsrr->errcode = bsrt->errcode;
+ bsrr->errstring = bsrt->errstring;
+ }
+ return response_searchRequest(assoc, reqb, bsrr, fd);
+}
+
+int bend_searchresponse(void *handle, bend_search_rr *bsrr) {return 0;}
+
+/*
+ * Prepare a searchresponse based on the backend results. We probably want
+ * to look at making the fetching of records nonblocking as well, but
+ * so far, we'll keep things simple.
+ * If bsrt is null, that means we're called in response to a communications
+ * event, and we'll have to get the response for ourselves.
+ */
+static Z_APDU *response_searchRequest(association *assoc, request *reqb,
+ bend_search_rr *bsrt, int *fd)
+{
+ Z_SearchRequest *req = reqb->request->u.searchRequest;
+ Z_APDU *apdu = (Z_APDU *)odr_malloc (assoc->encode, sizeof(*apdu));
+ Z_SearchResponse *resp = (Z_SearchResponse *)odr_malloc (assoc->encode, sizeof(*resp));
+ int *nulint = (int *)odr_malloc (assoc->encode, sizeof(*nulint));
+ bool_t *sr = (bool_t *)odr_malloc (assoc->encode, sizeof(*sr));
+ int *next = (int *)odr_malloc (assoc->encode, sizeof(*next));
+ int *none = (int *)odr_malloc (assoc->encode, sizeof(*none));
+
+ *nulint = 0;
+ *sr = 1;
+ *next = 0;
+ *none = Z_RES_NONE;
+
+ apdu->which = Z_APDU_searchResponse;
+ apdu->u.searchResponse = resp;
+ resp->referenceId = req->referenceId;
+ resp->additionalSearchInfo = 0;
+ resp->otherInfo = 0;
+ *fd = -1;
+ if (!bsrt && !bend_searchresponse(assoc->backend, bsrt))
+ {
+ logf(LOG_FATAL, "Bad result from backend");
+ return 0;
+ }