+ interp->result = "No parent";
+ return TCL_ERROR;
+ }
+ obj->parent = (IrTcl_Obj *) parent_info.clientData;
+
+ dst = &obj->set_inher;
+ src = &obj->parent->set_inher;
+
+ dst->num_databaseNames = src->num_databaseNames;
+ if (!(dst->databaseNames =
+ ir_malloc (interp, sizeof (*dst->databaseNames)
+ * dst->num_databaseNames)))
+ return TCL_ERROR;
+ for (i = 0; i < dst->num_databaseNames; i++)
+ {
+ if (ir_strdup (interp, &dst->databaseNames[i],
+ src->databaseNames[i]) == TCL_ERROR)
+ return TCL_ERROR;
+ }
+ if (ir_strdup (interp, &dst->queryType, src->queryType)
+ == TCL_ERROR)
+ return TCL_ERROR;
+
+ if (ir_strdup (interp, &dst->referenceId, src->referenceId)
+ == TCL_ERROR)
+ return TCL_ERROR;
+
+ dst->replaceIndicator = src->replaceIndicator;
+ dst->smallSetUpperBound = src->smallSetUpperBound;
+ dst->largeSetLowerBound = src->largeSetLowerBound;
+ dst->mediumSetPresentNumber = src->mediumSetPresentNumber;
+ }
+ else
+ obj->parent = NULL;
+
+ tabs[0].tab = ir_set_method_tab;
+ tabs[0].obj = obj;
+ tabs[1].tab = NULL;
+
+ if (ir_method (interp, 0, NULL, tabs) == TCL_ERROR)
+ return TCL_ERROR;
+
+ Tcl_CreateCommand (interp, argv[1], ir_set_obj_method,
+ (ClientData) obj, ir_set_obj_delete);
+ return TCL_OK;
+}
+
+/* ------------------------------------------------------- */
+
+/*
+ * do_scan: Perform scan
+ */
+static int do_scan (void *o, Tcl_Interp *interp, int argc, char **argv)
+{
+ Z_ScanRequest req;
+ Z_APDU apdu, *apdup = &apdu;
+ IrTcl_ScanObj *obj = o;
+ IrTcl_Obj *p = obj->parent;
+ int r;
+ oident bib1;
+#if CCL2RPN
+ struct ccl_rpn_node *rpn;
+ int pos;
+#endif
+
+ if (argc <= 0)
+ return TCL_OK;
+ p->scan_child = o;
+ if (argc != 3)
+ {
+ interp->result = "wrong # args";
+ return TCL_ERROR;
+ }
+ if (!p->set_inher.num_databaseNames)
+ {
+ interp->result = "no databaseNames";
+ return TCL_ERROR;
+ }
+ if (!p->cs_link)
+ {
+ interp->result = "not connected";
+ return TCL_ERROR;
+ }
+ odr_reset (p->odr_out);
+
+ bib1.proto = PROTO_Z3950;
+ bib1.class = CLASS_ATTSET;
+ bib1.value = VAL_BIB1;
+
+ apdu.which = Z_APDU_scanRequest;
+ apdu.u.scanRequest = &req;
+ set_referenceId (p->odr_out, &req.referenceId, p->set_inher.referenceId);
+ req.num_databaseNames = p->set_inher.num_databaseNames;
+ req.databaseNames = p->set_inher.databaseNames;
+ req.attributeSet = oid_getoidbyent (&bib1);
+
+#if !CCL2RPN
+ if (!(req.termListAndStartPoint = p_query_scan (p->odr_out, argv[2])))
+ {
+ Tcl_AppendResult (interp, "Syntax error in query", NULL);
+ return TCL_ERROR;
+ }
+#else
+ rpn = ccl_find_str(p->bibset, argv[2], &r, &pos);
+ if (r)
+ {
+ Tcl_AppendResult (interp, "CCL error: ", ccl_err_msg (r), NULL);
+ return TCL_ERROR;
+ }
+ ccl_pr_tree (rpn, stderr);
+ fprintf (stderr, "\n");
+ if (!(req.termListAndStartPoint = ccl_scan_query (rpn)))
+ return TCL_ERROR;
+#endif
+ req.stepSize = &obj->stepSize;
+ req.numberOfTermsRequested = &obj->numberOfTermsRequested;
+ req.preferredPositionInResponse = &obj->preferredPositionInResponse;
+ logf (LOG_DEBUG, "stepSize=%d", *req.stepSize);
+ logf (LOG_DEBUG, "numberOfTermsRequested=%d",
+ *req.numberOfTermsRequested);
+ logf (LOG_DEBUG, "preferredPositionInResponse=%d",
+ *req.preferredPositionInResponse);
+
+ if (!z_APDU (p->odr_out, &apdup, 0))
+ {
+ interp->result = odr_errlist [odr_geterror (p->odr_out)];
+ odr_reset (p->odr_out);
+ return TCL_ERROR;
+ }
+ p->sbuf = odr_getbuf (p->odr_out, &p->slen, NULL);
+ if ((r=cs_put (p->cs_link, p->sbuf, p->slen)) < 0)
+ {
+ interp->result = "cs_put failed in scan";
+ return TCL_ERROR;
+ }
+ else if (r == 1)
+ {
+ ir_select_add_write (cs_fileno(p->cs_link), p);
+ logf (LOG_DEBUG, "Sent part of scanRequest (%d bytes)", p->slen);
+ }
+ else
+ {
+ logf (LOG_DEBUG, "Whole scan request (%d bytes)", p->slen);
+ }
+ return TCL_OK;
+}
+
+/*
+ * do_stepSize: Set/get replace Step Size
+ */
+static int do_stepSize (void *obj, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+ if (argc <= 0)
+ {
+ p->stepSize = 0;
+ return TCL_OK;
+ }
+ return get_set_int (&p->stepSize, interp, argc, argv);
+}
+
+/*
+ * do_numberOfTermsRequested: Set/get Number of Terms requested
+ */
+static int do_numberOfTermsRequested (void *obj, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+
+ if (argc <= 0)
+ {
+ p->numberOfTermsRequested = 20;
+ return TCL_OK;
+ }
+ return get_set_int (&p->numberOfTermsRequested, interp, argc, argv);
+}
+
+
+/*
+ * do_preferredPositionInResponse: Set/get preferred Position
+ */
+static int do_preferredPositionInResponse (void *obj, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+
+ if (argc <= 0)
+ {
+ p->preferredPositionInResponse = 1;
+ return TCL_OK;
+ }
+ return get_set_int (&p->preferredPositionInResponse, interp, argc, argv);
+}
+
+/*
+ * do_scanStatus: Get scan status
+ */
+static int do_scanStatus (void *obj, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+
+ if (argc <= 0)
+ return TCL_OK;
+ return get_set_int (&p->scanStatus, interp, argc, argv);
+}
+
+/*
+ * do_numberOfEntriesReturned: Get number of Entries returned
+ */
+static int do_numberOfEntriesReturned (void *obj, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+
+ if (argc <= 0)
+ return TCL_OK;
+ return get_set_int (&p->numberOfEntriesReturned, interp, argc, argv);
+}
+
+/*
+ * do_positionOfTerm: Get position of Term
+ */
+static int do_positionOfTerm (void *obj, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+
+ if (argc <= 0)
+ return TCL_OK;
+ return get_set_int (&p->positionOfTerm, interp, argc, argv);
+}
+
+/*
+ * do_scanLine: get Scan Line (surrogate or normal) after response
+ */
+static int do_scanLine (void *obj, Tcl_Interp *interp, int argc, char **argv)
+{
+ IrTcl_ScanObj *p = obj;
+ int i;
+ char numstr[20];
+
+ if (argc == 0)
+ {
+ p->entries_flag = 0;
+ p->entries = NULL;
+ p->nonSurrogateDiagnostics = NULL;
+ return TCL_OK;
+ }
+ else if (argc == -1)
+ {
+ p->entries_flag = 0;
+ /* release entries */
+ p->entries = NULL;
+ /* release non diagnostics */
+ p->nonSurrogateDiagnostics = NULL;
+ return TCL_OK;
+ }
+ if (argc != 3)
+ {
+ interp->result = "wrong # args";
+ return TCL_ERROR;
+ }
+ if (Tcl_GetInt (interp, argv[2], &i) == TCL_ERROR)
+ return TCL_ERROR;
+ if (!p->entries_flag || p->which != Z_ListEntries_entries || !p->entries
+ || i >= p->num_entries || i < 0)
+ return TCL_OK;
+ switch (p->entries[i].which)
+ {
+ case Z_Entry_termInfo:
+ Tcl_AppendElement (interp, "T");
+ if (p->entries[i].u.term.buf)
+ Tcl_AppendElement (interp, p->entries[i].u.term.buf);
+ else
+ Tcl_AppendElement (interp, "");
+ sprintf (numstr, "%d", p->entries[i].u.term.globalOccurrences);
+ Tcl_AppendElement (interp, numstr);
+ break;
+ case Z_Entry_surrogateDiagnostic:
+ return
+ mk_nonSurrogateDiagnostics (interp, p->entries[i].u.diag.condition,
+ p->entries[i].u.diag.addinfo);
+ break;
+ }
+ return TCL_OK;
+}
+
+static IrTcl_Method ir_scan_method_tab[] = {
+ { 0, "scan", do_scan },
+ { 0, "stepSize", do_stepSize },
+ { 0, "numberOfTermsRequested", do_numberOfTermsRequested },
+ { 0, "preferredPositionInResponse", do_preferredPositionInResponse },
+ { 0, "scanStatus", do_scanStatus },
+ { 0, "numberOfEntriesReturned", do_numberOfEntriesReturned },
+ { 0, "positionOfTerm", do_positionOfTerm },
+ { 0, "scanLine", do_scanLine },
+ { 0, NULL, NULL}
+};
+
+/*
+ * ir_scan_obj_method: IR Scan Object methods
+ */
+static int ir_scan_obj_method (ClientData clientData, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ IrTcl_Methods tabs[2];
+
+ if (argc < 2)
+ {
+ interp->result = "wrong # args";
+ return TCL_ERROR;
+ }
+ tabs[0].tab = ir_scan_method_tab;
+ tabs[0].obj = clientData;
+ tabs[1].tab = NULL;
+
+ return ir_method (interp, argc, argv, tabs);
+}
+
+/*
+ * ir_scan_obj_delete: IR Scan Object disposal
+ */
+static void ir_scan_obj_delete (ClientData clientData)
+{
+ IrTcl_Methods tabs[2];
+ IrTcl_ScanObj *obj = clientData;
+
+ tabs[0].tab = ir_scan_method_tab;
+ tabs[0].obj = obj;
+ tabs[1].tab = NULL;
+
+ ir_method (NULL, -1, NULL, tabs);
+ free (obj);
+}
+
+/*
+ * ir_scan_obj_mk: IR Scan Object creation
+ */
+static int ir_scan_obj_mk (ClientData clientData, Tcl_Interp *interp,
+ int argc, char **argv)
+{
+ Tcl_CmdInfo parent_info;
+ IrTcl_ScanObj *obj;
+ IrTcl_Methods tabs[2];
+
+ if (argc != 3)
+ {
+ interp->result = "wrong # args";
+ return TCL_ERROR;
+ }
+ if (!Tcl_GetCommandInfo (interp, argv[2], &parent_info))
+ {
+ interp->result = "No parent";
+ return TCL_ERROR;
+ }
+ if (!(obj = ir_malloc (interp, sizeof(*obj))))
+ return TCL_ERROR;
+
+ obj->parent = (IrTcl_Obj *) parent_info.clientData;
+
+ tabs[0].tab = ir_scan_method_tab;
+ tabs[0].obj = obj;
+ tabs[1].tab = NULL;
+
+ if (ir_method (interp, 0, NULL, tabs) == TCL_ERROR)
+ return TCL_ERROR;
+ Tcl_CreateCommand (interp, argv[1], ir_scan_obj_method,
+ (ClientData) obj, ir_scan_obj_delete);
+ return TCL_OK;
+}
+
+/* ------------------------------------------------------- */
+
+static void ir_initResponse (void *obj, Z_InitResponse *initrs)
+{
+ IrTcl_Obj *p = obj;
+
+ p->initResult = *initrs->result ? 1 : 0;
+ if (!*initrs->result)
+ logf (LOG_DEBUG, "Connection rejected by target");
+ else
+ logf (LOG_DEBUG, "Connection accepted by target");
+
+ get_referenceId (&p->set_inher.referenceId, initrs->referenceId);
+
+ free (p->targetImplementationId);
+ ir_strdup (p->interp, &p->targetImplementationId,
+ initrs->implementationId);
+ free (p->targetImplementationName);
+ ir_strdup (p->interp, &p->targetImplementationName,
+ initrs->implementationName);
+ free (p->targetImplementationVersion);
+ ir_strdup (p->interp, &p->targetImplementationVersion,
+ initrs->implementationVersion);
+
+ p->maximumRecordSize = *initrs->maximumRecordSize;
+ p->preferredMessageSize = *initrs->preferredMessageSize;
+
+ memcpy (&p->options, initrs->options, sizeof(initrs->options));
+ memcpy (&p->protocolVersion, initrs->protocolVersion,
+ sizeof(initrs->protocolVersion));
+ free (p->userInformationField);
+ p->userInformationField = NULL;
+ if (initrs->userInformationField)
+ {
+ int len;
+
+ if (initrs->userInformationField->which == ODR_EXTERNAL_octet &&
+ (p->userInformationField =
+ malloc ((len =
+ initrs->userInformationField->u.octet_aligned->len)
+ +1)))
+ {
+ memcpy (p->userInformationField,
+ initrs->userInformationField->u.octet_aligned->buf,
+ len);
+ (p->userInformationField)[len] = '\0';
+ }
+ }
+}
+
+static void ir_handleRecords (void *o, Z_Records *zrs)
+{
+ IrTcl_Obj *p = o;
+ IrTcl_SetObj *setobj = p->set_child;
+
+ setobj->which = zrs->which;
+ setobj->recordFlag = 1;
+ if (zrs->which == Z_Records_NSD)
+ {
+ const char *addinfo;
+
+ setobj->numberOfRecordsReturned = 0;
+ setobj->condition = *zrs->u.nonSurrogateDiagnostic->condition;
+ free (setobj->addinfo);
+ setobj->addinfo = NULL;
+ addinfo = zrs->u.nonSurrogateDiagnostic->addinfo;
+ if (addinfo && (setobj->addinfo = malloc (strlen(addinfo) + 1)))
+ strcpy (setobj->addinfo, addinfo);
+ logf (LOG_DEBUG, "Diagnostic response. %s (%d): %s",
+ diagbib1_str (setobj->condition),
+ setobj->condition,
+ setobj->addinfo ? setobj->addinfo : "");
+ }
+ else
+ {
+ int offset;
+ IrTcl_RecordList *rl;
+
+ setobj->numberOfRecordsReturned =
+ zrs->u.databaseOrSurDiagnostics->num_records;
+ logf (LOG_DEBUG, "Got %d records", setobj->numberOfRecordsReturned);
+ for (offset = 0; offset<setobj->numberOfRecordsReturned; offset++)
+ {
+ rl = new_IR_record (setobj, setobj->start + offset,
+ zrs->u.databaseOrSurDiagnostics->
+ records[offset]->which);
+ if (rl->which == Z_NamePlusRecord_surrogateDiagnostic)
+ {
+ Z_DiagRec *diagrec;
+
+ diagrec = zrs->u.databaseOrSurDiagnostics->
+ records[offset]->u.surrogateDiagnostic;
+
+ rl->u.diag.condition = *diagrec->condition;
+ if (diagrec->addinfo && (rl->u.diag.addinfo =
+ malloc (strlen (diagrec->addinfo)+1)))
+ strcpy (rl->u.diag.addinfo, diagrec->addinfo);
+ }
+ else
+ {
+ Z_DatabaseRecord *zr;
+ Odr_external *oe;
+
+ zr = zrs->u.databaseOrSurDiagnostics->records[offset]
+ ->u.databaseRecord;
+ oe = (Odr_external*) zr;
+ rl->u.dbrec.size = zr->u.octet_aligned->len;
+ if (oe->which == ODR_EXTERNAL_octet && rl->u.dbrec.size > 0)
+ {
+ const char *buf = (char*) zr->u.octet_aligned->buf;
+ if ((rl->u.dbrec.buf = malloc (rl->u.dbrec.size)))
+ memcpy (rl->u.dbrec.buf, buf, rl->u.dbrec.size);
+ }
+ else
+ rl->u.dbrec.buf = NULL;
+ }
+ }
+ }
+}
+
+static void ir_searchResponse (void *o, Z_SearchResponse *searchrs)
+{
+ IrTcl_Obj *p = o;
+ IrTcl_SetObj *setobj = p->set_child;
+ Z_Records *zrs = searchrs->records;
+
+ logf (LOG_DEBUG, "Received search response");
+ if (!setobj)
+ {
+ logf (LOG_DEBUG, "Search response, no object!");
+ return;
+ }
+ setobj->searchStatus = searchrs->searchStatus ? 1 : 0;
+ get_referenceId (&setobj->set_inher.referenceId, searchrs->referenceId);
+ setobj->resultCount = *searchrs->resultCount;
+ if (searchrs->presentStatus)
+ setobj->presentStatus = *searchrs->presentStatus;
+ if (searchrs->nextResultSetPosition)
+ setobj->nextResultSetPosition = *searchrs->nextResultSetPosition;
+
+ logf (LOG_DEBUG, "Search response %d, %d hits",
+ setobj->searchStatus, setobj->resultCount);
+ if (zrs)
+ ir_handleRecords (o, zrs);
+ else
+ setobj->recordFlag = 0;
+}
+
+
+static void ir_presentResponse (void *o, Z_PresentResponse *presrs)
+{
+ IrTcl_Obj *p = o;
+ IrTcl_SetObj *setobj = p->set_child;
+ Z_Records *zrs = presrs->records;
+
+ logf (LOG_DEBUG, "Received present response");
+ if (!setobj)
+ {
+ logf (LOG_DEBUG, "Present response, no object!");
+ return;
+ }
+ setobj->presentStatus = *presrs->presentStatus;
+ get_referenceId (&setobj->set_inher.referenceId, presrs->referenceId);
+ setobj->nextResultSetPosition = *presrs->nextResultSetPosition;
+ if (zrs)
+ ir_handleRecords (o, zrs);
+ else
+ {
+ setobj->recordFlag = 0;
+ logf (LOG_DEBUG, "No records!");
+ }
+}
+
+static void ir_scanResponse (void *o, Z_ScanResponse *scanrs)
+{
+ IrTcl_Obj *p = o;
+ IrTcl_ScanObj *scanobj = p->scan_child;
+
+ logf (LOG_DEBUG, "Received scanResponse");
+
+ get_referenceId (&p->set_inher.referenceId, scanrs->referenceId);
+ scanobj->scanStatus = *scanrs->scanStatus;
+ logf (LOG_DEBUG, "scanStatus=%d", scanobj->scanStatus);
+
+ if (scanrs->stepSize)
+ scanobj->stepSize = *scanrs->stepSize;
+ logf (LOG_DEBUG, "stepSize=%d", scanobj->stepSize);
+
+ scanobj->numberOfEntriesReturned = *scanrs->numberOfEntriesReturned;
+ logf (LOG_DEBUG, "numberOfEntriesReturned=%d",
+ scanobj->numberOfEntriesReturned);
+
+ if (scanrs->positionOfTerm)
+ scanobj->positionOfTerm = *scanrs->positionOfTerm;
+ else
+ scanobj->positionOfTerm = -1;
+ logf (LOG_DEBUG, "positionOfTerm=%d", scanobj->positionOfTerm);
+
+ free (scanobj->entries);
+ scanobj->entries = NULL;
+ free (scanobj->nonSurrogateDiagnostics);
+ scanobj->nonSurrogateDiagnostics = NULL;
+
+ if (scanrs->entries)
+ {
+ int i;
+ Z_Entry *ze;
+
+ scanobj->entries_flag = 1;
+ scanobj->which = scanrs->entries->which;
+ switch (scanobj->which)
+ {
+ case Z_ListEntries_entries:
+ scanobj->num_entries = scanrs->entries->u.entries->num_entries;
+ scanobj->entries = malloc (scanobj->num_entries *
+ sizeof(*scanobj->entries));
+ for (i=0; i<scanobj->num_entries; i++)
+ {
+ ze = scanrs->entries->u.entries->entries[i];
+ scanobj->entries[i].which = ze->which;
+ switch (ze->which)
+ {
+ case Z_Entry_termInfo:
+ if (ze->u.termInfo->term->which == Z_Term_general)
+ {
+ int l = ze->u.termInfo->term->u.general->len;
+ scanobj->entries[i].u.term.buf = malloc (1+l);
+ memcpy (scanobj->entries[i].u.term.buf,
+ ze->u.termInfo->term->u.general->buf,
+ l);
+ scanobj->entries[i].u.term.buf[l] = '\0';
+ }
+ else
+ scanobj->entries[i].u.term.buf = NULL;
+ if (ze->u.termInfo->globalOccurrences)
+ scanobj->entries[i].u.term.globalOccurrences =
+ *ze->u.termInfo->globalOccurrences;
+ else
+ scanobj->entries[i].u.term.globalOccurrences = 0;
+ break;
+ case Z_Entry_surrogateDiagnostic:
+ scanobj->entries[i].u.diag.addinfo =
+ malloc (1+strlen(ze->u.surrogateDiagnostic->
+ addinfo));
+ strcpy (scanobj->entries[i].u.diag.addinfo,
+ ze->u.surrogateDiagnostic->addinfo);
+ scanobj->entries[i].u.diag.condition =
+ *ze->u.surrogateDiagnostic->condition;
+ break;
+ }
+ }
+ break;
+ case Z_ListEntries_nonSurrogateDiagnostics:
+ scanobj->num_diagRecs = scanrs->entries->
+ u.nonSurrogateDiagnostics->num_diagRecs;
+ scanobj->nonSurrogateDiagnostics = malloc (scanobj->num_diagRecs *
+ sizeof(*scanobj->nonSurrogateDiagnostics));
+ break;
+ }
+ }
+ else
+ scanobj->entries_flag = 0;
+}
+
+/*
+ * ir_select_read: handle incoming packages
+ */
+void ir_select_read (ClientData clientData)
+{
+ IrTcl_Obj *p = clientData;
+ Z_APDU *apdu;
+ int r;
+
+ if (p->connectFlag)
+ {
+ r = cs_rcvconnect (p->cs_link);
+ if (r == 1)
+ return;
+ p->connectFlag = 0;
+ ir_select_remove_write (cs_fileno (p->cs_link), p);
+ if (r < 0)
+ {
+ logf (LOG_DEBUG, "cs_rcvconnect error");
+ if (p->failback)
+ Tcl_Eval (p->interp, p->failback);
+ do_disconnect (p, NULL, 2, NULL);