diff options
Diffstat (limited to 'gnu/usr.bin/lynx/WWW/Library/Implementation/HTVMS_WaisUI.c')
| -rw-r--r-- | gnu/usr.bin/lynx/WWW/Library/Implementation/HTVMS_WaisUI.c | 2448 |
1 files changed, 2448 insertions, 0 deletions
diff --git a/gnu/usr.bin/lynx/WWW/Library/Implementation/HTVMS_WaisUI.c b/gnu/usr.bin/lynx/WWW/Library/Implementation/HTVMS_WaisUI.c new file mode 100644 index 00000000000..81c097070c9 --- /dev/null +++ b/gnu/usr.bin/lynx/WWW/Library/Implementation/HTVMS_WaisUI.c @@ -0,0 +1,2448 @@ +/* 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" +#include "tcp.h" +#include "HTVMS_WaisUI.h" +#include "HTVMS_WaisProt.h" +#include "HTTCP.h" +/*#include <stdio> included by HTUtils.h -- FM */ +#include <string.h> +#include <ctype.h> +#include <math.h> +#include <stdarg.h> + +#include "LYexit.h" +#include "LYLeaks.h" + +void +log_write(s) +char *s; +{ + return; +} + +/*----------------------------------------------------------------------*/ + +/* returns a pointer in the buffer of the first free byte. + if it overflows, then NULL is returned + */ +char * +generate_search_apdu(buff, + buff_len, + seed_words, + database_name, + docobjs, + maxDocsRetrieved) +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(buff, + buff_len, + docID, + chunk_type, + start, + end, + type, + database_name) +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! + */ +long read_from_stream(d,buf,nbytes) +int d; /* this is the stream */ +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 */ + +long +transport_message(connection, + request_message, + request_length, + response_message, + response_buffer_length) +int 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]; + strncpy(length_array, header.msg_len, 10); + length_array[10] = '\0'; + 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 writen. 0 if an error */ +long +interpret_message(request_message,request_length, + response_message, + response_buffer_length, + connection, + verbose) +char *request_message; +long request_length; /* length of the buffer */ +char *response_message; +long response_buffer_length; +int connection; +boolean verbose; +{ + 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. */ +char *delete_seeker_codes(string,length) +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(headline) +char *headline; +{ + long length = strlen(headline) + 1; /* include the trailing null */ + long 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(result, + search, + present, + deleteIt, + accessControl, + resourceControl, + prefSize, + maxMsgSize, + auth, + id, + name, + version, + refID, + userInfo) +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(init) +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(init,buffer,len) +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(init,buffer) +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(init,result,userInfo) +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(small, + large, + medium, + replace, + name, + databases, + type, + elements, + refID, + queryInfo) +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(query) +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(query,buffer,len) +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(result,count,recordsReturned,nextPos,resultStatus, + presentStatus,refID,records) +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(queryResponse) +SearchResponseAPDU* queryResponse; +{ + freeAny(queryResponse->ReferenceID); + s_free(queryResponse); +} + +/*----------------------------------------------------------------------*/ + +char* +writeSearchResponseAPDU(queryResponse,buffer,len) +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); + buf = writeBinaryInteger(queryResponse->SearchStatus,(size_t)1,buf,len); + buf = writeBinaryInteger(queryResponse->ResultCount,(size_t)3,buf,len); + buf = writeBinaryInteger(queryResponse->NumberOfRecordsReturned,(size_t)3,buf,len); + buf = writeBinaryInteger(queryResponse->NextResultSetPosition,(size_t)3,buf,len); + buf = writeNum(queryResponse->ResultSetStatus,DT_ResultSetStatus,buf,len); + buf = writeNum(queryResponse->PresentStatus,DT_PresentStatus,buf,len); + buf = writeAny(queryResponse->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 (queryResponse->DatabaseDiagnosticRecords != NULL) + buf = writeSearchResponseInfo(queryResponse,buf,len); + + return(buf); +} + +/*----------------------------------------------------------------------*/ + +char* +readSearchResponseAPDU(queryResponse,buffer) +SearchResponseAPDU** queryResponse; +char* buffer; +{ + char* buf = buffer; + long size; + pdu_type pduType; + long result,count,recordsReturned,nextPos; + long resultStatus,presentStatus; + any *refID = NULL; + void* userInfo = NULL; + + /* read required part */ + buf = readBinaryInteger(&size,HEADER_LEN,buf); + buf = readPDUType(&pduType,buf); + buf = readBinaryInteger(&result,(size_t)1,buf); + buf = readBinaryInteger(&count,(size_t)3,buf); + buf = readBinaryInteger(&recordsReturned,(size_t)3,buf); + buf = readBinaryInteger(&nextPos,(size_t)3,buf); + + resultStatus = presentStatus = UNUSED; + refID = NULL; + + /* read optional part */ + while (buf < (buffer + size + HEADER_LEN)) + { data_tag tag = peekTag(buf); + switch (tag) + { case DT_ResultSetStatus: + buf = readNum(&resultStatus,buf); + break; + case DT_PresentStatus: + buf = readNum(&presentStatus,buf); + break; + case DT_ReferenceID: + buf = readAny(&refID,buf); + break; + default: + freeAny(refID); + REPORT_READ_ERROR(buf); + break; + } + } + + buf = readSearchResponseInfo(&userInfo,buf); + if (buf == NULL) + freeAny(refID); + RETURN_ON_NULL(buf); + + /* construct the search object */ + *queryResponse = makeSearchResponseAPDU(result,count,recordsReturned,nextPos, + (long)resultStatus,(long)presentStatus,refID,userInfo); + + freeAny(refID); + + return(buf); +} + + +/* +** Routines originally from ZUtil.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 - fixed include file names, changed + - writeCompressedIntegerWithPadding() to + writeCompressedIntWithPadding() + - generalized conditional includes (see c-dialect.h) + 3.7.91 Jonny Goldman. Replaced "short" in makeBitMap with "int" line 632. +*/ + +char* readErrorPosition = NULL; /* pos where buf stoped making sense */ + +/*----------------------------------------------------------------------*/ +/* A note on error handling + read - these are low level routines, they do not check the type tags + which (sometimes) preceed the data (this is done by the higher + level functions which call these functions). There is no + attempt made to check that the reading does not exceed the read + buffer. Such cases should be very rare and usually will be + caught by the calling functions. (note - it is unlikely that + a series of low level reads will go far off the edge without + triggering a type error. However, it is possible for a single + bad read in an array function (eg. readAny) to attempt to read a + large ammount, possibly causing a segmentation violation or out + of memory condition. + */ +/*----------------------------------------------------------------------*/ + +diagnosticRecord* +makeDiag(surrogate,code,addInfo) +boolean surrogate; +char* code; +char* addInfo; +{ + diagnosticRecord* diag = + (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord)); + + diag->SURROGATE = surrogate; + memcpy(diag->DIAG,code,DIAGNOSTIC_CODE_SIZE); + diag->ADDINFO = s_strdup(addInfo); + + return(diag); +} + +/*----------------------------------------------------------------------*/ + +void +freeDiag(diag) +diagnosticRecord* diag; +{ + if (diag != NULL) + { if (diag->ADDINFO != NULL) + s_free(diag->ADDINFO); + s_free(diag); + } +} + +/*----------------------------------------------------------------------*/ + +#define END_OF_RECORD 0x1D + +char* +writeDiag(diag,buffer,len) +diagnosticRecord* diag; +char* buffer; +long* len; +/* diagnostics (as per Appendix D) have a very weird format - this changes + in SR-1 + */ +{ + char* buf = buffer; + long length; + + if (diag == NULL) /* handle unspecified optional args */ + return(buf); + + buf = writeTag(DT_DatabaseDiagnosticRecords,buf,len); + CHECK_FOR_SPACE_LEFT(0,len); + + length = 3; + if (diag->ADDINFO != NULL) + length += strlen(diag->ADDINFO); + + if (length >= 0xFFFF ) /* make sure the length is reasonable */ + { length = 0xFFFF - 1; + diag->ADDINFO[0xFFFF - 3 - 1] = '\0'; + } + + buf = writeBinaryInteger(length,2,buf,len); + + CHECK_FOR_SPACE_LEFT(1,len); + buf[0] = diag->DIAG[0]; + buf++; + + CHECK_FOR_SPACE_LEFT(1,len); + buf[0] = diag->DIAG[1]; + buf++; + + if (length > 3) + { CHECK_FOR_SPACE_LEFT(3,len); + memcpy(buf,diag->ADDINFO,(size_t)length - 3); + buf += length - 3; + } + + CHECK_FOR_SPACE_LEFT(1,len); + buf[0] = diag->SURROGATE; + buf++; + + CHECK_FOR_SPACE_LEFT(1,len); + buf[0] = END_OF_RECORD; + buf++; + + return(buf); +} + +/*----------------------------------------------------------------------*/ + +char* +readDiag(diag,buffer) +diagnosticRecord** diag; +char* buffer; +{ + char* buf = buffer; + diagnosticRecord* d + = (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord)); + data_tag tag; + long len; + + buf = readTag(&tag,buf); + + buf = readBinaryInteger(&len,2,buf); + + d->DIAG[0] = buf[0]; + d->DIAG[1] = buf[1]; + d->DIAG[2] = '\0'; + + if (len > 3) + { d->ADDINFO = (char*)s_malloc((size_t)(len - 3 + 1)); + memcpy(d->ADDINFO,(char*)(buf + 2),(size_t)(len - 3)); + d->ADDINFO[len - 3] = '\0'; + } + else + d->ADDINFO = NULL; + + d->SURROGATE = buf[len - 1]; + + *diag = d; + + return(buf + len + 1); +} + +/*----------------------------------------------------------------------*/ + +#define continueBit 0x80 +#define dataMask 0x7F +#define dataBits 7 + +char* +writeCompressedInteger(num,buf,len) +unsigned long num; +char* buf; +long* len; +/* write a binary integer in the format described on p. 40. + this might be sped up +*/ +{ + char byte; + long i; + unsigned long size; + + size = writtenCompressedIntSize(num); + CHECK_FOR_SPACE_LEFT(size,len); + + for (i = size - 1; i >= 0; i--) + { byte = num & dataMask; + if (i != (size-1)) /* turn on continue bit */ + byte = (char)(byte | continueBit); + buf[i] = byte; + num = num >> dataBits; /* don't and here */ + } + + return(buf + size); +} + +/*----------------------------------------------------------------------*/ + +char* +readCompressedInteger(num,buf) +unsigned long *num; +char* buf; +/* read a binary integer in the format described on p. 40. + this might be sped up +*/ +{ + long i = 0; + unsigned char byte; + + *num = 0; + + do + { byte = buf[i++]; + *num = *num << dataBits; + *num += (byte & dataMask); + } + while (byte & continueBit); + + return(buf + i); +} + +/*----------------------------------------------------------------------*/ + +#define pad 128 /* high bit is set */ + +char* +writeCompressedIntWithPadding(num,size,buffer,len) +unsigned long num; +unsigned long size; +char* buffer; +long* len; +/* Like writeCompressedInteger, except writes padding (128) to make + sure that size bytes are used. This can be read correctly by + readCompressedInteger() +*/ +{ + char* buf = buffer; + unsigned long needed,padding; + long i; + + CHECK_FOR_SPACE_LEFT(size,len); + + needed = writtenCompressedIntSize(num); + padding = size - needed; + i = padding - 1; + + for (i = padding - 1;i >= 0;i--) + { buf[i] = pad; + } + + buf = writeCompressedInteger(num,buf + padding,len); + + return(buf); +} + +/*----------------------------------------------------------------------*/ + +unsigned long +writtenCompressedIntSize(num) +unsigned long num; +/* return the number of bytes needed to represnet the value num in + compressed format. curently limited to 4 bytes + */ +{ + if (num < CompressedInt1Byte) + return(1); + else if (num < CompressedInt2Byte) + return(2); + else if (num < CompressedInt3Byte) + return(3); + else + return(4); +} + +/*----------------------------------------------------------------------*/ + +char* +writeTag(tag,buf,len) +data_tag tag; +char* buf; +long* len; +/* write out a data tag */ +{ + return(writeCompressedInteger(tag,buf,len)); +} + +/*----------------------------------------------------------------------*/ + +char* +readTag(tag,buf) +data_tag* tag; +char* buf; +/* read a data tag */ +{ + return(readCompressedInteger(tag,buf)); +} + +/*----------------------------------------------------------------------*/ + +unsigned long +writtenTagSize(tag) +data_tag tag; +{ + return(writtenCompressedIntSize(tag)); +} + +/*----------------------------------------------------------------------*/ + +data_tag +peekTag(buf) +char* buf; +/* read a data tag without advancing the buffer */ +{ + data_tag tag; + readTag(&tag,buf); + return(tag); +} + +/*----------------------------------------------------------------------*/ + +any* +makeAny(size,data) +unsigned long size; +char* data; +{ + any* a = (any*)s_malloc((size_t)sizeof(any)); + a->size = size; + a->bytes = data; + return(a); +} + +/*----------------------------------------------------------------------*/ + +void +freeAny(a) +any* a; +/* destroy an any and its associated data. Assumes a->bytes was + allocated using the s_malloc family of libraries + */ +{ + if (a != NULL) + { if (a->bytes != NULL) + s_free(a->bytes); + s_free(a); + } +} + +/*----------------------------------------------------------------------*/ + +any* +duplicateAny(a) +any* a; +{ + any* copy = NULL; + + if (a == NULL) + return(NULL); + + copy = (any*)s_malloc((size_t)sizeof(any)); + copy->size = a->size; + if (a->bytes == NULL) + copy->bytes = NULL; + else + { copy->bytes = (char*)s_malloc((size_t)copy->size); + memcpy(copy->bytes,a->bytes,(size_t)copy->size); + } + return(copy); +} + +/*----------------------------------------------------------------------*/ + +char* +writeAny(a,tag,buffer,len) +any* a; +data_tag tag; +char* buffer; +long* len; +/* write an any + tag and size info */ +{ + char* buf = buffer; + + if (a == NULL) /* handle unspecified optional args */ + return(buf); + + /* write the tags */ + buf = writeTag(tag,buf,len); + buf = writeCompressedInteger(a->size,buf,len); + + /* write the bytes */ + CHECK_FOR_SPACE_LEFT(a->size,len); + memcpy(buf,a->bytes,(size_t)a->size); + + return(buf+a->size); +} + +/*----------------------------------------------------------------------*/ + + +char *readAny(anAny,buffer) +any** anAny; +char* buffer; +/* read an any + tag and size info */ +{ + char *buf; + any* a; + data_tag tag; + + + +a=(any*)s_malloc((size_t)sizeof(any)); + + buf=buffer; + + buf = readTag(&tag,buf); + + buf = readCompressedInteger(&a->size,buf); + + /* now simply copy the bytes */ + a->bytes = (char*)s_malloc((size_t)a->size); + memcpy(a->bytes,buf,(size_t)a->size); + *anAny = a; + + return(buf+a->size); +} + +/*----------------------------------------------------------------------*/ + +unsigned long +writtenAnySize(tag,a) +data_tag tag; +any* a; +{ + unsigned long size; + + if (a == NULL) + return(0); + + size = writtenTagSize(tag); + size += writtenCompressedIntSize(a->size); + size += a->size; + return(size); +} + +/*----------------------------------------------------------------------*/ + +any* +stringToAny(s) +char* s; +{ + any* a = NULL; + + if (s == NULL) + return(NULL); + + a = (any*)s_malloc((size_t)sizeof(any)); + a->size = strlen(s); + a->bytes = (char*)s_malloc((size_t)a->size); + memcpy(a->bytes,s,(size_t)a->size); + return(a); +} + +/*----------------------------------------------------------------------*/ + +char* +anyToString(a) +any* a; +{ + char* s = NULL; + + if (a == NULL) + return(NULL); + + s = s_malloc((size_t)(a->size + 1)); + memcpy(s,a->bytes,(size_t)a->size); + s[a->size] = '\0'; + return(s); +} + +/*----------------------------------------------------------------------*/ + +char* +writeString(s,tag,buffer,len) +char* s; +data_tag tag; +char* buffer; +long* len; +/* Write a C style string. The terminating null is not written. + This function is not part of the Z39.50 spec. It is provided + for the convienience of those wishing to pass C strings in + the place of an any. + */ +{ + char* buf = buffer; + any* data = NULL; + if (s == NULL) + return(buffer); /* handle unused optional item before making an any */ + data = (any*)s_malloc((size_t)sizeof(any)); + data->size = strlen(s); + data->bytes = s; /* save a copy here by not using stringToAny() */ + buf = writeAny(data,tag,buf,len); + s_free(data); /* don't use freeAny() since it will free s too */ + return(buf); +} + +/*----------------------------------------------------------------------*/ + +char* +readString(s ,buffer) +char** s ; +char* buffer; +/* Read an any and convert it into a C style string. + This function is not part of the Z39.50 spec. It is provided + for the convienience of those wishing to pass C strings in + the place of an any. + */ +{ + any* data = NULL; + char* buf = readAny(&data,buffer); + *s = anyToString(data); + freeAny(data); + return(buf); +} + +/*----------------------------------------------------------------------*/ + +unsigned long +writtenStringSize(tag,s) +data_tag tag; +char* s; +{ + unsigned long size; + + if (s == NULL) + return(0); + + size = writtenTagSize(tag); + size += writtenCompressedIntSize(size); + size += strlen(s); + return(size); +} + +/*----------------------------------------------------------------------*/ + +any* +longToAny(num) +long num; +/* a convienience function */ +{ + char s[40]; + + sprintf(s,"%ld",num); + + return(stringToAny(s)); +} + +/*----------------------------------------------------------------------*/ + +long +anyToLong(a) +any* a; +/* a convienience function */ +{ + long num; + char* str = NULL; + str = anyToString(a); + sscanf(str,"%ld",&num); /* could check the result and return + an error */ + s_free(str); + return(num); +} + +/*----------------------------------------------------------------------*/ + +#define bitsPerByte 8 + +bit_map* +makeBitMap(unsigned long numBits, ...) +/* construct and return a bitmap with numBits elements */ +{ + va_list ap; + long i,j; + bit_map* bm = NULL; + + va_start(ap,numBits); + + bm = (bit_map*)s_malloc((size_t)sizeof(bit_map)); + bm->size = (unsigned long)ceil((double)numBits / bitsPerByte); + bm->bytes = (char*)s_malloc((size_t)bm->size); + + /* fill up the bits */ + for (i = 0; i < bm->size; i++) /* iterate over bytes */ + { char byte = 0; + for (j = 0; j < bitsPerByte; j++) /* iterate over bits */ + { if ((i * bitsPerByte + j) < numBits) + { boolean bit = false; + bit = (boolean)va_arg(ap,boolean); + if (bit) + { byte = byte | (1 << (bitsPerByte - j - 1)); + } + } + } + bm->bytes[i] = byte; + } + + va_end(ap); + return(bm); +} + + +/*----------------------------------------------------------------------*/ + +void +freeBitMap(bm) +bit_map* bm; +/* destroy a bit map created by makeBitMap() */ +{ + s_free(bm->bytes); + s_free(bm); +} + +/*----------------------------------------------------------------------*/ + +/* use this routine to interpret a bit map. pos specifies the bit + number. bit 0 is the Leftmost bit of the first byte. + Could do bounds checking. + */ + +boolean +bitAtPos(pos,bm) +long pos; +bit_map* bm; +{ + if (pos > bm->size*bitsPerByte) + return false; + else + return((bm->bytes[(pos / bitsPerByte)] & + (0x80>>(pos % bitsPerByte))) ? + true : false); +} + +/*----------------------------------------------------------------------*/ + +char* +writeBitMap(bm,tag,buffer,len) +bit_map* bm; +data_tag tag; +char* buffer; +long* len; +/* write a bitmap + type and size info */ +{ + return(writeAny((any*)bm,tag,buffer,len)); +} + +/*----------------------------------------------------------------------*/ + +char* +readBitMap(bm,buffer) +bit_map** bm; +char* buffer; +/* read a bitmap + type and size info */ +{ + char *c; + + + +c=readAny((any**)bm,buffer); + + return(c); +} + +/*----------------------------------------------------------------------*/ + +char* +writeByte(byte,buf,len) +unsigned long byte; +char* buf; +long* len; +{ + CHECK_FOR_SPACE_LEFT(1,len); + buf[0] = byte & 0xFF; /* we really only want the first byte */ + return(buf + 1); +} + +/*----------------------------------------------------------------------*/ + +char* +readByte(byte,buf) +unsigned char* byte; +char* buf; +{ + *byte = buf[0]; + return(buf + 1); +} + +/*----------------------------------------------------------------------*/ + +char* +writeBoolean(flag,buf,len) +boolean flag; +char* buf; +long* len; +{ + return(writeByte(flag,buf,len)); +} + +/*----------------------------------------------------------------------*/ + +char* +readBoolean(flag,buffer) +boolean* flag; +char* buffer; +{ + unsigned char byte; + char* buf = readByte(&byte,buffer); + *flag = (byte == true) ? true : false; + return(buf); +} + +/*----------------------------------------------------------------------*/ + +char* +writePDUType(pduType,buf,len) +pdu_type pduType; +char* buf; +long* len; +/* PDUType is a single byte */ +{ + return(writeBinaryInteger((long)pduType,(unsigned long)1,buf,len)); +} + +/*----------------------------------------------------------------------*/ + +char* +readPDUType(pduType,buf) +pdu_type* pduType; +char* buf; +/* PDUType is a single byte */ +{ + return(readBinaryInteger((long*)pduType,(unsigned long)1,buf)); +} + +/*----------------------------------------------------------------------*/ + +pdu_type +peekPDUType(buf) +char* buf; +/* read the next pdu without advancing the buffer, Note that this + function is to be used on a buffer that is known to contain an + APDU. The pdu_type is written HEADER_LEN bytes into the buffer + */ +{ + pdu_type pdu; + readPDUType(&pdu,buf + HEADER_LEN); + return(pdu); +} + +/*----------------------------------------------------------------------*/ + +#define BINARY_INTEGER_BYTES sizeof(long) /* the number of bytes used by + a "binary integer" */ +char* +writeBinaryInteger(num,size,buf,len) +long num; +unsigned long size; +char* buf; +long* len; +/* write out first size bytes of num - no type info + XXX should this take unsigned longs instead ??? */ +{ + long i; + char byte; + + if (size < 1 || size > BINARY_INTEGER_BYTES) + return(NULL); /* error */ + + CHECK_FOR_SPACE_LEFT(size,len); + + for (i = size - 1; i >= 0; i--) + { byte = (char)(num & 255); + buf[i] = byte; + num = num >> bitsPerByte; /* don't and here */ + } + + return(buf + size); +} + +/*----------------------------------------------------------------------*/ + +char* +readBinaryInteger(num,size,buf) +long* num; +unsigned long size; +char* buf; +/* read in first size bytes of num - no type info + XXX this should take unsigned longs instead !!! */ +{ + long i; + unsigned char byte; + + if (size < 1 || size > BINARY_INTEGER_BYTES) + return(buf); /* error */ + *num = 0; + + for (i = 0; i < size; i++) + { byte = buf[i]; + *num = *num << bitsPerByte; + *num += byte; + } + + return(buf + size); +} + +/*----------------------------------------------------------------------*/ + +unsigned long +writtenCompressedBinIntSize(num) +long num; +/* return the number of bytes needed to represent the value num. + currently limited to max of 4 bytes + Only compresses for positive nums - negatives get whole 4 bytes + */ +{ + if (num < 0L) + return(4); + else if (num < 256L) /* 2**8 */ + return(1); + else if (num < 65536L) /* 2**16 */ + return(2); + else if (num < 16777216L) /* 2**24 */ + return(3); + else + return(4); +} + +/*----------------------------------------------------------------------*/ + +char* +writeNum(num,tag,buffer,len) +long num; +data_tag tag; +char* buffer; +long* len; +/* write a binary integer + size and tag info */ +{ + char* buf = buffer; + long size = writtenCompressedBinIntSize(num); + + if (num == UNUSED) + return(buffer); + + buf = writeTag(tag,buf,len); + buf = writeCompressedInteger(size,buf,len); + buf = writeBinaryInteger(num,(unsigned long)size,buf,len); + return(buf); +} + +/*----------------------------------------------------------------------*/ + +char* +readNum(num,buffer) +long* num; +char* buffer; +/* read a binary integer + size and tag info */ +{ + char* buf = buffer; + data_tag tag; + unsigned long size; + unsigned long val; + + buf = readTag(&tag,buf); + buf = readCompressedInteger(&val,buf); + size = (unsigned long)val; + buf = readBinaryInteger(num,size,buf); + return(buf); +} + +/*----------------------------------------------------------------------*/ + +unsigned long +writtenNumSize(tag,num) +data_tag tag; +long num; +{ + long dataSize = writtenCompressedBinIntSize(num); + long size; + + size = writtenTagSize(tag); /* space for the tag */ + size += writtenCompressedIntSize(dataSize); /* space for the size */ + size += dataSize; /* space for the data */ + + return(size); +} + +/*----------------------------------------------------------------------*/ + +typedef void (voidfunc)(); + +void +doList(list,func) +void** list; +voidfunc *func; +/* call func on each element of the NULL terminated list of pointers */ +{ + register long i; + register void* ptr = NULL; + if (list == NULL) + return; + for (i = 0,ptr = list[i]; ptr != NULL; ptr = list[++i]) + (*func)(ptr); +} + +/*----------------------------------------------------------------------*/ + +char* +writeProtocolVersion(buf,len) +char* buf; +long* len; +/* write a bitmap describing the protocols available */ +{ + static bit_map* version = NULL; + + if (version == NULL) + { version = makeBitMap((unsigned long)1,true); /* version 1! */ + } + + return(writeBitMap(version,DT_ProtocolVersion,buf,len)); +} + +/*----------------------------------------------------------------------*/ + +char* +defaultImplementationID() +{ + static char ImplementationID[] = "TMC"; + return(ImplementationID); +} + +/*----------------------------------------------------------------------*/ + +char* +defaultImplementationName() +{ + static char ImplementationName[] = "Thinking Machines Corporation Z39.50"; + return(ImplementationName); +} + +/*----------------------------------------------------------------------*/ + +char* +defaultImplementationVersion() +{ + static char ImplementationVersion[] = "2.0A"; + return(ImplementationVersion); +} + +/*----------------------------------------------------------------------*/ + + +/* +** Routines originally from ZType1.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 + 4.11.90 HWM - generalized conditional includes (see c-dialect.h) +*/ +/*----------------------------------------------------------------------*/ + +query_term* +makeAttributeTerm(use, + relation, + position, + structure, + truncation, + completeness, + term) +char* use; +char* relation; +char* position; +char* structure; +char* truncation; +char* completeness; +any* term; +{ + query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term)); + + qt->TermType = TT_Attribute; + + /* copy in the attributes */ + strncpy(qt->Use,use,ATTRIBUTE_SIZE); + strncpy(qt->Relation,relation,ATTRIBUTE_SIZE); + strncpy(qt->Position,position,ATTRIBUTE_SIZE); + strncpy(qt->Structure,structure,ATTRIBUTE_SIZE); + strncpy(qt->Truncation,truncation,ATTRIBUTE_SIZE); + strncpy(qt->Completeness,completeness,ATTRIBUTE_SIZE); + + qt->Term = duplicateAny(term); + + qt->ResultSetID = NULL; + + return(qt); +} + +/*----------------------------------------------------------------------*/ + +query_term* +makeResultSetTerm(resultSet) +any* resultSet; +{ + query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term)); + + qt->TermType = TT_ResultSetID; + + qt->ResultSetID = duplicateAny(resultSet); + + qt->Term = NULL; + + return(qt); +} + +/*----------------------------------------------------------------------*/ + +query_term* +makeOperatorTerm(operatorCode) +char* operatorCode; +{ + query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term)); + + qt->TermType = TT_Operator; + + strncpy(qt->Operator,operatorCode,OPERATOR_SIZE); + + qt->Term = NULL; + qt->ResultSetID = NULL; + + return(qt); +} + +/*----------------------------------------------------------------------*/ + +void +freeTerm(qt) +query_term* qt; +{ + switch (qt->TermType) + { case TT_Attribute: + freeAny(qt->Term); + break; + case TT_ResultSetID: + freeAny(qt->ResultSetID); + break; + case TT_Operator: + /* do nothing */ + break; + default: + panic("Implementation error: Unknown term type %ld", + qt->TermType); + break; + } + s_free(qt); +} + +/*----------------------------------------------------------------------*/ + +#define ATTRIBUTE_LIST_SIZE ATTRIBUTE_SIZE * 6 +#define AT_DELIMITER " " + +char* +writeQueryTerm(qt,buffer,len) +query_term* qt; +char* buffer; +long* len; +{ + char* buf = buffer; + char attributes[ATTRIBUTE_LIST_SIZE]; + + switch (qt->TermType) + { case TT_Attribute: + strncpy(attributes,qt->Use,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,qt->Relation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,qt->Position,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,qt->Structure,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,qt->Truncation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE); + s_strncat(attributes,qt->Completeness,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); + buf = writeString(attributes,DT_AttributeList,buf,len); + buf = writeAny(qt->Term,DT_Term,buf,len); + break; + case TT_ResultSetID: + buf = writeAny(qt->ResultSetID,DT_ResultSetID,buf,len); + break; + case TT_Operator: + buf = writeString(qt->Operator,DT_Operator,buf,len); + break; + default: + panic("Implementation error: Unknown term type %ld", + qt->TermType); + break; + } + + return(buf); +} + +/*----------------------------------------------------------------------*/ + +char* +readQueryTerm(qt,buffer) +query_term** qt; +char* buffer; +{ + char* buf = buffer; + char *attributeList = NULL; + char* operator = NULL; + any* term; + char* use = NULL; + char* relation = NULL; + char* position = NULL; + char* structure = NULL; + char* truncation = NULL; + char* completeness; + any* resultSetID = NULL; + data_tag tag; + + + tag = peekTag(buffer); + + switch(tag) + { case DT_AttributeList: + buf = readString(&attributeList,buf); + buf = readAny(&term,buf); + use = strtok(attributeList,AT_DELIMITER); + relation = strtok(NULL,AT_DELIMITER); + position = strtok(NULL,AT_DELIMITER); + structure = strtok(NULL,AT_DELIMITER); + truncation = strtok(NULL,AT_DELIMITER); + completeness = strtok(NULL,AT_DELIMITER); + *qt = makeAttributeTerm(use,relation,position,structure, + truncation,completeness,term); + s_free(attributeList); + freeAny(term); + break; + case DT_ResultSetID: + buf = readAny(&resultSetID,buf); + *qt = makeResultSetTerm(resultSetID); + freeAny(resultSetID); + break; + case DT_Operator: + buf = readString(&operator,buf); + *qt = makeOperatorTerm(operator); + s_free(operator); + break; + default: + REPORT_READ_ERROR(buf); + break; + } + + return(buf); +} + +/*----------------------------------------------------------------------*/ + +static unsigned long getQueryTermSize _AP((query_term* qt)); + +static unsigned long +getQueryTermSize(qt) +query_term* qt; +/* figure out how many bytes it will take to write this query */ +{ + unsigned long size; + static char attributes[] = "11 22 33 44 55 66"; /* we just need this to + calculate its written + size */ + + switch (qt->TermType) + { case TT_Attribute: + size = writtenStringSize(DT_AttributeList,attributes); + size += writtenAnySize(DT_Term,qt->Term); + break; + case TT_ResultSetID: + size = writtenAnySize(DT_ResultSetID,qt->ResultSetID); + break; + case TT_Operator: + size = writtenStringSize(DT_Operator,qt->Operator); + break; + default: + panic("Implementation error: Unknown term type %ld", + qt->TermType); + break; + } + + return(size); +} + +/*----------------------------------------------------------------------*/ + +/* A query is simply a null terminated list of query terms. For + transmission, a query is written into an any which is sent as + the user information field. */ + +any* +writeQuery(terms) +query_term** terms; +{ + any* info = NULL; + char* writePos = NULL; + char* data = NULL; + unsigned long size = 0; + long remaining = 0; + long i; + query_term* qt = NULL; + + if (terms == NULL) + return(NULL); + + /* calculate the size of write buffer */ + for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i]) + size += getQueryTermSize(qt); + + data = (char*)s_malloc((size_t)size); + + /* write the terms */ + writePos = data; + remaining = size; + for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i]) + writePos = writeQueryTerm(qt,writePos,&remaining); + + info = makeAny(size,data); + + return(info); +} + +/*----------------------------------------------------------------------*/ + +query_term** +readQuery(info) +any *info; +{ + char* readPos = info->bytes; + query_term** terms = NULL; + query_term* qt = NULL; + long numTerms = 0L; +char tmp[100]; + +sprintf(tmp,"readquery: bytes: %ld",info->size); +log_write(tmp); + + while (readPos < info->bytes + info->size) + { readPos = readQueryTerm(&qt,readPos); + + if (terms == NULL) + { terms = (query_term**)s_malloc((size_t)(sizeof(query_term*)*2)); + } + else + { terms = + (query_term**)s_realloc((char*)terms, + (size_t)(sizeof(query_term*)*(numTerms+2))); + } +if(qt==NULL) + log_write("qt = null"); + terms[numTerms++] = qt; + terms[numTerms] = NULL; + } + + return(terms); +} + +/*----------------------------------------------------------------------*/ + + +/* +** Routines originally from panic.c -- FM +** +**----------------------------------------------------------------------*/ +/* WIDE AREA INFORMATION SERVER SOFTWARE: + No guarantees or restrictions. See the readme file for the full standard + disclaimer. + + Morris@think.com +*/ + +/* panic is an error system interface. On the Mac, it will pop + * up a little window to explain the problem. + * On a unix box, it will print out the error and call perror() + */ + +/*----------------------------------------------------------------------*/ + +static void exitAction _AP((long error)); + +static void +exitAction(error) +long error; +{ + long i; + for (i = 0; i < 100000; i++) + ; + exit(0); +} + +/*----------------------------------------------------------------------*/ + +#define PANIC_HEADER "Fatal Error: " + +void +panic(char *format, ...) +{ + va_list ap; /* the variable arguments */ + + fprintf(stderr,PANIC_HEADER); + va_start(ap, format); /* init ap */ + vfprintf(stderr,format,ap); /* print the contents */ + va_end(ap); /* free ap */ + fflush(stderr); + + exitAction(0); +} + +/*----------------------------------------------------------------------*/ + + +/* +** Routines originally from cutil.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 + 4.11.90 HWM - generalized conditional includes (see c-dialect.h) +*/ + +#include <varargs.h> + + +/*----------------------------------------------------------------------*/ + +void +fs_checkPtr(ptr) +void* ptr; +/* If the ptr is NULL, give an error */ +{ + if (ptr == NULL) + panic("checkPtr found a NULL pointer"); +} + +/*----------------------------------------------------------------------*/ + +void* +fs_malloc(size) +size_t size; +/* does safety checks and optional accounting */ +{ + register void* ptr = NULL; + + ptr = (void*)calloc((size_t)size,(size_t)1); + s_checkPtr(ptr); + + return(ptr); +} + +/*----------------------------------------------------------------------*/ + +void* +fs_realloc(ptr,size) +void* ptr; +size_t size; +/* does safety checks and optional accounting + note - we don't know how big ptr's memory is, so we can't ensure + that any new memory allocated is NULLed! + */ +{ + register void* nptr = NULL; + + if (ptr == NULL) /* this is really a malloc */ + return(s_malloc(size)); + + nptr = (void*)realloc(ptr,size); + s_checkPtr(ptr); + + return(nptr); +} + +/*----------------------------------------------------------------------*/ + +void +fs_free(ptr) +void* ptr; +/* does safety checks and optional accounting */ +{ + if (ptr != NULL) /* some non-ansi compilers/os's cant handle freeing null */ + { /* if we knew the size of this block of memory, we could clear it - oh well */ + free(ptr); + ptr = NULL; + } +} + +/*----------------------------------------------------------------------*/ + +char* +s_strdup(s) +char* s; + +/* return a copy of s. This is identical to the standard library routine + strdup(), except that it is safe. If s == NULL or malloc fails, + appropriate action is taken. + */ +{ + unsigned long len; + char* copy = NULL; + + if (s == NULL) /* saftey check to postpone stupid errors */ + return(NULL); + + len = strlen(s); /* length of string - terminator */ + copy = (char*)s_malloc((size_t)(sizeof(char)*(len + 1))); + strncpy(copy,s,len + 1); + return(copy); +} + +/*----------------------------------------------------------------------*/ + +char* +fs_strncat(dst,src,maxToAdd,maxTotal) +char* dst; + char* src; + size_t maxToAdd; + size_t maxTotal; + +/* like strncat, except the fourth argument limits the maximum total + length of the resulting string + */ +{ + size_t dstSize = strlen(dst); + size_t srcSize = strlen(src); + + if (dstSize + srcSize < maxTotal) /* use regular old strncat */ + return(strncat(dst,src,maxToAdd)); + else + { size_t truncateTo = maxTotal - dstSize - 1; + char saveChar = src[truncateTo]; + char* result = NULL; + src[truncateTo] = '\0'; + result = strncat(dst,src,maxToAdd); + src[truncateTo] = saveChar; + return(result); + } +} + +/*----------------------------------------------------------------------*/ + +char char_downcase(long_ch) +unsigned long long_ch; +{ + unsigned char ch = long_ch & 0xFF; /* just want one byte */ + /* when ansi is the way of the world, this can be tolower */ + return (((ch >= 'A') && (ch <= 'Z')) ? (ch + 'a' -'A') : ch); +} + +char *string_downcase(word) +char *word; +{ + long i = 0; + while(word[i] != '\0'){ + word[i] = char_downcase((unsigned long)word[i]); + i++; + } + return(word); +} + +/*----------------------------------------------------------------------*/ + |