/*

 * $LynxId: HTVMS_WaisUI.c,v 1.19 2013/05/03 20:51:49 tom Exp $

 *								HTVMS_WAISUI.c

 *

 *	Adaptation for Lynx by F.Macrides (macrides@sci.wfeb.edu)

 *

 *	30-May-1994 FM	Initial version.

 *

 *----------------------------------------------------------------------*/

/*

 *	Routines originally from UI.c -- FM

 *

 *----------------------------------------------------------------------*/

/* WIDE AREA INFORMATION SERVER SOFTWARE:

 * No guarantees or restrictions.  See the readme file for the full standard

 * disclaimer.

 *

 * Brewster@think.com

 */

/*

 * this is a simple ui toolkit for building other ui's on top.

 * -brewster

 *

 * top level functions:

 *   generate_search_apdu

 *   generate_retrieval_apdu

 *   interpret_message

 *

 */

/* to do:

 *   generate multiple queries for long documents.

 *     this will crash if the file being retrieved is larger than 100k.

 *   do log_write()

 *

 */

#include <HTUtils.h>

#ifdef VMS

#include <HTVMS_WaisUI.h>

#include <HTVMS_WaisProt.h>

#include <HTTCP.h>

#undef MAXINT			/* we don't need it here, and www_tcp.h may conflict */

#include <math.h>

#include <LYexit.h>

#include <LYLeaks.h>

void log_write(char *s GCC_UNUSED)

{

    return;

}

/*----------------------------------------------------------------------*/

/* returns a pointer in the buffer of the first free byte.

   if it overflows, then NULL is returned

 */

char *generate_search_apdu(char *buff,	/* buffer to hold the apdu */

			   long *buff_len,	/* length of the buffer changed to reflect new data written */

			   char *seed_words,	/* string of the seed words */

			   char *database_name,

			   DocObj **docobjs,

			   long maxDocsRetrieved)

{

    /* local variables */

    SearchAPDU *search3;

    char *end_ptr;

    static char *database_names[2] =

    {"", 0};

    any refID;

    WAISSearch *query;

    refID.size = 1;

    refID.bytes = "3";

    database_names[0] = database_name;

    query = makeWAISSearch(seed_words,

			   docobjs,	/* DocObjsPtr */

			   0,

			   1,	/* DateFactor */

			   0,	/* BeginDateRange */

			   0,	/* EndDateRange */

			   maxDocsRetrieved

	);

    search3 = makeSearchAPDU(30,

			     5000,	/* should be large */

			     30,

			     1,	/* replace indicator */

			     "",	/* result set name */

			     database_names,	/* database name */

			     QT_RelevanceFeedbackQuery,		/* query_type */

			     0,	/* element name */

			     NULL,	/* reference ID */

			     query);

    end_ptr = writeSearchAPDU(search3, buff, buff_len);

    CSTFreeWAISSearch(query);

    freeSearchAPDU(search3);

    return (end_ptr);

}

/*----------------------------------------------------------------------*/

/* returns a pointer into the buffer of the next free byte.

   if it overflowed, then NULL is returned

 */

char *generate_retrieval_apdu(char *buff,

			      long *buff_len,	/* length of the buffer changed to reflect new data written */

			      any *docID,

			      long chunk_type,

			      long start,

			      long end,

			      char *type,

			      char *database_name)

{

    SearchAPDU *search;

    char *end_ptr;

    static char *database_names[2];

    static char *element_names[3];

    any refID;

    DocObj *DocObjs[2];

    any *query;			/* changed from char* by brewster */

    if (NULL == type)

	type = s_strdup("TEXT");

    database_names[0] = database_name;

    database_names[1] = NULL;

    element_names[0] = " ";

    element_names[1] = ES_DocumentText;

    element_names[2] = NULL;

    refID.size = 1;

    refID.bytes = "3";

    switch (chunk_type) {

    case CT_line:

	DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);

	break;

    case CT_byte:

	DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);

	break;

    }

    DocObjs[1] = NULL;

    query = makeWAISTextQuery(DocObjs);

    search = makeSearchAPDU(10, 16, 15,

			    1,	/* replace indicator */

			    "FOO",	/* result set name */

			    database_names,	/* database name */

			    QT_TextRetrievalQuery,	/* query_type */

			    element_names,	/* element name */

			    &refID,	/* reference ID */

			    query);

    end_ptr = writeSearchAPDU(search, buff, buff_len);

    CSTFreeWAISTextQuery(query);

    freeSearchAPDU(search);

    return (end_ptr);

}

/*----------------------------------------------------------------------*/

/* this is a safe version of unix 'read' it does all the checking

 * and looping necessary

 * to those trying to modify the transport code to use non-UNIX streams:

 *  This is the function to modify!

 */

static long read_from_stream(int d, char *buf, long nbytes)

{

    long didRead;

    long toRead = nbytes;

    long totalRead = 0;		/* paranoia */

    while (toRead > 0) {

	didRead = NETREAD(d, buf, (int) toRead);

	if (didRead == HT_INTERRUPTED)

	    return (HT_INTERRUPTED);

	if (didRead == -1)	/* error */

	    return (-1);

	if (didRead == 0)	/* eof */

	    return (-2);	/* maybe this should return 0? */

	toRead -= didRead;

	buf += didRead;

	totalRead += didRead;

    }

    if (totalRead != nbytes)	/* we overread for some reason */

	return (-totalRead);	/* bad news */

    return (totalRead);

}

/*----------------------------------------------------------------------*/

/* returns the length of the response, 0 if an error */

static long transport_message(long connection,

			      char *request_message,

			      long request_length,

			      char *response_message,

			      long response_buffer_length)

{

    WAISMessage header;

    long response_length;

    int rv;

    /* Write out message.  Read back header.  Figure out response length. */

    if (request_length + HEADER_LENGTH !=

	NETWRITE(connection, request_message,

		 (int) (request_length + HEADER_LENGTH)))

	return 0;

    /* read for the first '0' */

    while (1) {

	rv = read_from_stream(connection, response_message, 1);

	if (rv == HT_INTERRUPTED)

	    return HT_INTERRUPTED;

	if (rv < 0)

	    return 0;

	if ('0' == response_message[0])

	    break;

    }

    rv = read_from_stream(connection, response_message + 1, HEADER_LENGTH - 1);

    if (rv == HT_INTERRUPTED)

	return HT_INTERRUPTED;

    if (rv < 0)

	return 0;

    readWAISPacketHeader(response_message, &header);

    {

	char length_array[11];

	LYStrNCpy(length_array, header.msg_len, 10);

	response_length = atol(length_array);

	/*

	   if(verbose){

	   printf("WAIS header: '%s' length_array: '%s'\n",

	   response_message, length_array);

	   }

	 */

	if (response_length > response_buffer_length) {

	    /* we got a message that is too long, therefore empty the message out,

	       and return 0 */

	    long i;

	    for (i = 0; i < response_length; i++) {

		rv = read_from_stream(connection,

				      response_message + HEADER_LENGTH,

				      1);

		if (rv == HT_INTERRUPTED)

		    return HT_INTERRUPTED;

		if (rv < 0)

		    return 0;

	    }

	    return (0);

	}

    }

    rv = read_from_stream(connection,

			  response_message + HEADER_LENGTH,

			  response_length);

    if (rv == HT_INTERRUPTED)

	return HT_INTERRUPTED;

    if (rv < 0)

	return 0;

    return (response_length);

}

/*----------------------------------------------------------------------*/

/* returns the number of bytes written.  0 if an error */

long interpret_message(char *request_message,

		       long request_length,	/* length of the buffer */

		       char *response_message,

		       long response_buffer_length,

		       long connection,

		       boolean verbose GCC_UNUSED)

{

    long response_length;

    /* ?

       if(verbose){

       printf ("sending");

       if(hostname_internal && strlen(hostname_internal) > 0)

       printf(" to host %s", hostname_internal);

       if(service_name && strlen(service_name) > 0)

       printf(" for service %s", service_name);

       printf("\n");

       twais_dsply_rsp_apdu(request_message + HEADER_LENGTH,

       request_length);

       }

     */

    writeWAISPacketHeader(request_message,

			  request_length,

			  (long) 'z',	/* Z39.50 */

			  "wais      ",		/* server name */

			  (long) NO_COMPRESSION,	/* no compression */

			  (long) NO_ENCODING, (long) HEADER_VERSION);

    if (connection != 0) {

	response_length = transport_message(connection, request_message,

					    request_length,

					    response_message,

					    response_buffer_length);

	if (response_length == HT_INTERRUPTED)

	    return (HT_INTERRUPTED);

    } else

	return (0);

    return (response_length);

}

/*----------------------------------------------------------------------*/

/* modifies the string to exclude all seeker codes. sets length to

   the new length. */

static char *delete_seeker_codes(char *string, long *length)

{

    long original_count;	/* index into the original string */

    long new_count = 0;		/* index into the collapsed string */

    for (original_count = 0; original_count < *length; original_count++) {

	if (27 == string[original_count]) {

	    /* then we have an escape code */

	    /* if the next letter is '(' or ')', then ignore two letters */

	    if ('(' == string[original_count + 1] ||

		')' == string[original_count + 1])

		original_count += 1;	/* it is a term marker */

	    else

		original_count += 4;	/* it is a paragraph marker */

	} else

	    string[new_count++] = string[original_count];

    }

    *length = new_count;

    return (string);

}

/*----------------------------------------------------------------------*/

#if defined(VMS) && defined(__GNUC__)	/* 10-AUG-1995 [pr] */

/*

  Workaround for an obscure bug in gcc's 2.6.[123] and 2.7.0 vax/vms port;

  sometimes global variables will end up not being defined properly,

  causing first gas to assume they're routines, then the linker to complain

  about unresolved symbols, and finally the program to reference the wrong

  objects (provoking ACCVIO).  It's triggered by the specific ordering of

  variable usage in the source code, hence rarely appears.  This bug is

  fixed in gcc 2.7.1, and was not present in 2.6.0 and earlier.

   Make a reference to VAXCRTL's _ctype_[], and also one to this dummy

   variable itself to prevent any "defined but not used" warning.

 */

static __const void *__const ctype_dummy[] =

{&_ctype_, &ctype_dummy};

#endif /* VMS && __GNUC__ */

/* returns a pointer to a string with good stuff */

char *trim_junk(char *headline)

{

    long length = strlen(headline) + 1;		/* include the trailing null */

    size_t i;

    headline = delete_seeker_codes(headline, &length);

    /* delete leading spaces */

    for (i = 0; i < strlen(headline); i++) {

	if (isprint(headline[i])) {

	    break;

	}

    }

    headline = headline + i;

    /* delete trailing stuff */

    for (i = strlen(headline) - 1; i > 0; i--) {

	if (isprint(headline[i])) {

	    break;

	}

	headline[i] = '\0';

    }

    return (headline);

}

/*----------------------------------------------------------------------*/

/*

 *	Routines originally from ZProt.c -- FM

 *

 *----------------------------------------------------------------------*/

/* WIDE AREA INFORMATION SERVER SOFTWARE:`

 * No guarantees or restrictions.  See the readme file for the full standard

 * disclaimer.

 *

 * 3.26.90	Harry Morris, morris@think.com

 * 3.30.90  Harry Morris - Changed any->bits to any->bytes

 * 4.11.90  HWM - generalized conditional includes (see c-dialect.h)

 */

#define RESERVE_SPACE_FOR_HEADER(spaceLeft)		\

	*spaceLeft -= HEADER_LEN;

#define RELEASE_HEADER_SPACE(spaceLeft)			\

	if (*spaceLeft > 0)				\

	  *spaceLeft += HEADER_LEN;

/*----------------------------------------------------------------------*/

InitResponseAPDU *makeInitResponseAPDU(boolean result,

				       boolean search,

				       boolean present,

				       boolean deleteIt,

				       boolean accessControl,

				       boolean resourceControl,

				       long prefSize,

				       long maxMsgSize,

				       char *auth,

				       char *id,

				       char *name,

				       char *version,

				       any *refID,

				       void *userInfo)

/* build an initResponse APDU with user specified information */

{

    InitResponseAPDU *init = (InitResponseAPDU *) s_malloc((size_t) sizeof(InitResponseAPDU));

    init->PDUType = initResponseAPDU;

    init->Result = result;

    init->willSearch = search;

    init->willPresent = present;

    init->willDelete = deleteIt;

    init->supportAccessControl = accessControl;

    init->supportResourceControl = resourceControl;

    init->PreferredMessageSize = prefSize;

    init->MaximumRecordSize = maxMsgSize;

    init->IDAuthentication = s_strdup(auth);

    init->ImplementationID = s_strdup(id);

    init->ImplementationName = s_strdup(name);

    init->ImplementationVersion = s_strdup(version);

    init->ReferenceID = duplicateAny(refID);

    init->UserInformationField = userInfo;	/* not copied! */

    return (init);

}

/*----------------------------------------------------------------------*/

void freeInitResponseAPDU(InitResponseAPDU *init)

/* free an initAPDU */

{

    s_free(init->IDAuthentication);

    s_free(init->ImplementationID);

    s_free(init->ImplementationName);

    s_free(init->ImplementationVersion);

    freeAny(init->ReferenceID);

    s_free(init);

}

/*----------------------------------------------------------------------*/

char *writeInitResponseAPDU(InitResponseAPDU *init, char *buffer, long *len)

/* write the initResponse to a buffer, adding system information */

{

    char *buf = buffer + HEADER_LEN;	/* leave room for the header-length-indicator */

    long size;

    bit_map *optionsBM = NULL;

    RESERVE_SPACE_FOR_HEADER(len);

    buf = writePDUType(init->PDUType, buf, len);

    buf = writeBoolean(init->Result, buf, len);

    buf = writeProtocolVersion(buf, len);

    optionsBM = makeBitMap((unsigned long) 5, init->willSearch, init->willPresent,

			   init->willDelete, init->supportAccessControl,

			   init->supportResourceControl);

    buf = writeBitMap(optionsBM, DT_Options, buf, len);

    freeBitMap(optionsBM);

    buf = writeNum(init->PreferredMessageSize,

		   DT_PreferredMessageSize,

		   buf,

		   len);

    buf = writeNum(init->MaximumRecordSize,

		   DT_MaximumRecordSize,

		   buf,

		   len);

    buf = writeString(init->IDAuthentication,

		      DT_IDAuthentication,

		      buf,

		      len);

    buf = writeString(init->ImplementationID,

		      DT_ImplementationID,

		      buf,

		      len);

    buf = writeString(init->ImplementationName,

		      DT_ImplementationName,

		      buf,

		      len);

    buf = writeString(init->ImplementationVersion,

		      DT_ImplementationVersion,

		      buf,

		      len);

    buf = writeAny(init->ReferenceID,

		   DT_ReferenceID,

		   buf,

		   len);

    /* go back and write the header-length-indicator */

    RELEASE_HEADER_SPACE(len);

    size = buf - buffer - HEADER_LEN;

    writeBinaryInteger(size, HEADER_LEN, buffer, len);

    if (init->UserInformationField != NULL)

	buf = writeInitResponseInfo(init, buf, len);

    return (buf);

}

/*----------------------------------------------------------------------*/

char *readInitResponseAPDU(InitResponseAPDU **init, char *buffer)

{

    char *buf = buffer;

    boolean search, present, delete, accessControl, resourceControl;

    long prefSize, maxMsgSize;

    char *auth, *id, *name, *version;

    long size;

    pdu_type pduType;

    bit_map *versionBM = NULL;

    bit_map *optionsBM = NULL;

    boolean result;

    any *refID = NULL;

    void *userInfo = NULL;

    auth = id = name = version = NULL;

    refID = NULL;

    /* read required part */

    buf = readBinaryInteger(&size, HEADER_LEN, buf);

    buf = readPDUType(&pduType, buf);

    buf = readBoolean(&result, buf);

    buf = readBitMap(&versionBM, buf);

    buf = readBitMap(&optionsBM, buf);

    buf = readNum(&prefSize, buf);

    buf = readNum(&maxMsgSize, buf);

    /* decode optionsBM */

    search = bitAtPos(0, optionsBM);

    present = bitAtPos(1, optionsBM);

    delete = bitAtPos(2, optionsBM);

    accessControl = bitAtPos(3, optionsBM);

    resourceControl = bitAtPos(4, optionsBM);

    /* read optional part */

    while (buf < (buffer + size + HEADER_LEN)) {

	data_tag tag = peekTag(buf);

	switch (tag) {

	case DT_IDAuthentication:

	    buf = readString(&auth, buf);

	    break;

	case DT_ImplementationID:

	    buf = readString(&id, buf);

	    break;

	case DT_ImplementationName:

	    buf = readString(&name, buf);

	    break;

	case DT_ImplementationVersion:

	    buf = readString(&version, buf);

	    break;

	case DT_ReferenceID:

	    buf = readAny(&refID, buf);

	    break;

	default:

	    freeBitMap(versionBM);

	    freeBitMap(optionsBM);

	    s_free(auth);

	    s_free(id);

	    s_free(name);

	    s_free(version);

	    freeAny(refID);

	    REPORT_READ_ERROR(buf);

	    break;

	}

    }

    buf = readInitResponseInfo(&userInfo, buf);

    if (buf == NULL) {

	freeBitMap(versionBM);

	freeBitMap(optionsBM);

	s_free(auth);

	s_free(id);

	s_free(name);

	s_free(version);

	freeAny(refID);

    }

    RETURN_ON_NULL(buf);

    /* construct the basic init object */

    *init = makeInitResponseAPDU(result,

				 search,

				 present,

				 delete,

				 accessControl,

				 resourceControl,

				 prefSize,

				 maxMsgSize,

				 auth,

				 id,

				 name,

				 version,

				 refID,

				 userInfo);

    freeBitMap(versionBM);

    freeBitMap(optionsBM);

    s_free(auth);

    s_free(id);

    s_free(name);

    s_free(version);

    freeAny(refID);

    return (buf);

}

/*----------------------------------------------------------------------*/

InitResponseAPDU *replyToInitAPDU(InitAPDU * init, boolean result, void *userInfo)

/* respond to an init message in the default way - echoing back

   the init info

 */

{

    InitResponseAPDU *initResp;

    initResp = makeInitResponseAPDU(result,

				    init->willSearch,

				    init->willPresent,

				    init->willDelete,

				    init->supportAccessControl,

				    init->supportResourceControl,

				    init->PreferredMessageSize,

				    init->MaximumRecordSize,

				    init->IDAuthentication,

				    defaultImplementationID(),

				    defaultImplementationName(),

				    defaultImplementationVersion(),

				    init->ReferenceID,

				    userInfo);

    return (initResp);

}

/*----------------------------------------------------------------------*/

SearchAPDU *makeSearchAPDU(long small,

			   long large,

			   long medium,

			   boolean replace,

			   char *name,

			   char **databases,

			   char *type,

			   char **elements,

			   any *refID,

			   void *queryInfo)

{

    char *ptr = NULL;

    long i;

    SearchAPDU *query = (SearchAPDU *) s_malloc((size_t) sizeof(SearchAPDU));

    query->PDUType = searchAPDU;

    query->SmallSetUpperBound = small;

    query->LargeSetLowerBound = large;

    query->MediumSetPresentNumber = medium;

    query->ReplaceIndicator = replace;

    query->ResultSetName = s_strdup(name);

    query->DatabaseNames = NULL;

    if (databases != NULL) {

	for (i = 0, ptr = databases[i]; ptr != NULL; ptr = databases[++i]) {

	    if (query->DatabaseNames == NULL)

		query->DatabaseNames = (char **) s_malloc((size_t) (sizeof(char

									   *)

								    * 2));

	    else

		query->DatabaseNames = (char **) s_realloc((char *) query->DatabaseNames,

							   (size_t) (sizeof(char

									    *) *

								     (i + 2)));

	    query->DatabaseNames[i] = s_strdup(ptr);

	    query->DatabaseNames[i + 1] = NULL;

	}

    }

    query->QueryType = s_strdup(type);

    query->ElementSetNames = NULL;

    if (elements != NULL) {

	for (i = 0, ptr = elements[i]; ptr != NULL; ptr = elements[++i]) {

	    if (query->ElementSetNames == NULL)

		query->ElementSetNames =

		    (char **) s_malloc((size_t) (sizeof(char *) * 2));

	    else

		query->ElementSetNames = (char **) s_realloc((char *) query->ElementSetNames,

							     (size_t) (sizeof(char

									      *) *

								       (i + 2)));

	    query->ElementSetNames[i] = s_strdup(ptr);

	    query->ElementSetNames[i + 1] = NULL;

	}

    }

    query->ReferenceID = duplicateAny(refID);

    query->Query = queryInfo;	/* not copied! */

    return (query);

}

/*----------------------------------------------------------------------*/

void freeSearchAPDU(SearchAPDU *query)

{

    s_free(query->ResultSetName);

    s_free(query->QueryType);

    doList((void **) query->DatabaseNames, fs_free);	/* can't use the macro here ! */

    s_free(query->DatabaseNames);

    doList((void **) query->ElementSetNames, fs_free);	/* can't use the macro here ! */

    s_free(query->ElementSetNames);

    freeAny(query->ReferenceID);

    s_free(query);

}

/*----------------------------------------------------------------------*/

#define DB_DELIMITER	"\037"	/* hex 1F occurs between each database name */

#define ES_DELIMITER_1	"\037"	/* separates database name from element name */

#define ES_DELIMITER_2	"\036"	/* hex 1E separates <db,es> groups from one another */

char *writeSearchAPDU(SearchAPDU *query, char *buffer, long *len)

{

    char *buf = buffer + HEADER_LEN;	/* leave room for the header-length-indicator */

    long size, i;

    char *ptr = NULL;

    char *scratch = NULL;

    RESERVE_SPACE_FOR_HEADER(len);

    buf = writePDUType(query->PDUType, buf, len);

    buf = writeBinaryInteger(query->SmallSetUpperBound, (size_t) 3, buf, len);

    buf = writeBinaryInteger(query->LargeSetLowerBound, (size_t) 3, buf, len);

    buf = writeBinaryInteger(query->MediumSetPresentNumber, (size_t) 3, buf, len);

    buf = writeBoolean(query->ReplaceIndicator, buf, len);

    buf = writeString(query->ResultSetName, DT_ResultSetName, buf, len);

    /* write database names */

    if (query->DatabaseNames != NULL) {

	for (i = 0, scratch = NULL, ptr = query->DatabaseNames[i]; ptr != NULL;

	     ptr = query->DatabaseNames[++i]) {

	    if (scratch == NULL)

		scratch = s_strdup(ptr);

	    else {

		size_t newScratchSize = (size_t) (strlen(scratch) +

						  strlen(ptr) + 2);

		scratch = (char *) s_realloc(scratch, newScratchSize);

		s_strncat(scratch, DB_DELIMITER, 2, newScratchSize);

		s_strncat(scratch, ptr, strlen(ptr) + 1, newScratchSize);

	    }

	}

	buf = writeString(scratch, DT_DatabaseNames, buf, len);

	s_free(scratch);

    }

    buf = writeString(query->QueryType, DT_QueryType, buf, len);

    /* write element set names */

    if (query->ElementSetNames != NULL) {

	for (i = 0, scratch = NULL, ptr = query->ElementSetNames[i];

	     ptr != NULL;

	     ptr = query->ElementSetNames[++i]) {

	    if (scratch == NULL) {

		if (query->ElementSetNames[i + 1] == NULL)	/* there is a single element set name */

		{

		    scratch = (char *) s_malloc((size_t) strlen(ptr) + 2);

		    StrNCpy(scratch, ES_DELIMITER_1, 2);

		    s_strncat(scratch, ptr, strlen(ptr) + 1, strlen(ptr) + 2);

		} else {	/* this is the first of a series of element set names */

		    size_t newScratchSize = (size_t) (strlen(ptr) +

						      strlen(query->ElementSetNames[i

										    + 1])

						      + 2);

		    scratch = s_strdup(ptr);	/* the database name */

		    ptr = query->ElementSetNames[++i];	/* the element set name */

		    scratch = (char *) s_realloc(scratch, newScratchSize);

		    s_strncat(scratch, ES_DELIMITER_1, 2, newScratchSize);

		    s_strncat(scratch, ptr, strlen(ptr) + 1, newScratchSize);

		}

	    } else {

		char *esPtr = query->ElementSetNames[++i];	/* the element set name */

		size_t newScratchSize = (size_t) (strlen(scratch) +

						  strlen(ptr) +

						  strlen(esPtr) +

						  3);

		scratch = (char *) s_realloc(scratch, newScratchSize);

		s_strncat(scratch, ES_DELIMITER_2, 2, newScratchSize);

		s_strncat(scratch, ptr, strlen(ptr) + 1, newScratchSize);

		s_strncat(scratch, ES_DELIMITER_1, 2, newScratchSize);

		s_strncat(scratch, esPtr, strlen(esPtr) + 1, newScratchSize);

	    }

	}

	buf = writeString(scratch, DT_ElementSetNames, buf, len);

	s_free(scratch);

    }

    buf = writeAny(query->ReferenceID, DT_ReferenceID, buf, len);

    /* go back and write the header-length-indicator */

    RELEASE_HEADER_SPACE(len);

    size = buf - buffer - HEADER_LEN;

    writeBinaryInteger(size, HEADER_LEN, buffer, len);

    if (query->Query != NULL)

	buf = writeSearchInfo(query, buf, len);

    return (buf);

}

/*----------------------------------------------------------------------*/

SearchResponseAPDU *makeSearchResponseAPDU(long result,

					   long count,

					   long recordsReturned,

					   long nextPos,

					   long resultStatus,

					   long presentStatus,

					   any *refID,

					   void *records)

{

    SearchResponseAPDU *query =

    (SearchResponseAPDU *) s_malloc((size_t) sizeof(SearchResponseAPDU));

    query->PDUType = searchResponseAPDU;

    query->SearchStatus = result;

    query->ResultCount = count;

    query->NumberOfRecordsReturned = recordsReturned;

    query->NextResultSetPosition = nextPos;

    query->ResultSetStatus = resultStatus;

    query->PresentStatus = presentStatus;

    query->ReferenceID = duplicateAny(refID);

    query->DatabaseDiagnosticRecords = records;

    return (query);

}

/*----------------------------------------------------------------------*/

void freeSearchResponseAPDU(SearchResponseAPDU *queryResponse)

{

    freeAny(queryResponse->ReferenceID);

    s_free(queryResponse);

}

/*----------------------------------------------------------------------*/

char *writeSearchResponseAPDU(SearchResponseAPDU *queryResponse, char *buffer,

			      long *len)

{

    char *buf = buffer + HEADER_LEN;	/* leave room for the header-length-indicator */

    long size;

    RESERVE_SPACE_FOR_HEADER(len);

    buf = writePDUType(queryResponse->PDUType,

		       buf,

		       len);