/* WIDE AREA INFORMATION SERVER SOFTWARE:
   Developed by Thinking Machines Corporation and put into the public
   domain with no guarantees or restrictions.
*/

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

#define _C_utils_Z39_50_

#include <math.h>
#include "zutil.h"
#include <string.h>
#include <pfs_threads.h>

EXTERN_CHARP_DEF(readErrorPosition); 
/* Lets hope these get initialized to NULL or that noone cares*/
#define readErrorPosition p_th_arreadErrorPosition[p__th_self_num()]

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

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

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;

{
  char* buf = buffer;
  long  length;
  
  if (diag == NULL)		
    return(buf);

  buf = writeTag(DT_DatabaseDiagnosticRecords,buf,len);
  CHECK_FOR_SPACE_LEFT(0L,len);
  
  length = 3; 
  if (diag->ADDINFO != NULL)
    length += strlen(diag->ADDINFO);
    
  if (length >= 0xFFFF )	
    { length = 0xFFFF - 1;
      diag->ADDINFO[0xFFFF - 3 - 1] = '\0';
    }
   
  buf = writeBinaryInteger(length,2L,buf,len);

  CHECK_FOR_SPACE_LEFT(1L,len);
  buf[0] = diag->DIAG[0]; 
  buf++;
  
  CHECK_FOR_SPACE_LEFT(1L,len);
  buf[0] = diag->DIAG[1];
  buf++;
  
  if (length > 3)
    { CHECK_FOR_SPACE_LEFT(3L,len);
      memcpy(buf,diag->ADDINFO,(size_t)length - 3);
      buf += length - 3;
    }
   
  CHECK_FOR_SPACE_LEFT(1L,len);
  buf[0] = diag->SURROGATE;
  buf++;
  
  CHECK_FOR_SPACE_LEFT(1L,len);
  buf[0] = END_OF_RECORD;
  buf++;

  return(buf);
}

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

char* 
readDiag(diag,buffer)	/*!!ALLOCS - diag */
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,2L,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;

{
  char aByte;
  long i;
  unsigned long size;
  
  size = writtenCompressedIntSize(num);
  CHECK_FOR_SPACE_LEFT(size,len);
  
  for (i = size - 1; i >= 0; i--)
    { aByte = num & dataMask;
      if (i != (size-1))	
	aByte = (char)(aByte | continueBit);
      buf[i] = aByte;
      num = num >> dataBits;	
    }
   
  return(buf + size);
} 

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

char*
readCompressedInteger(num,buf)
unsigned long *num;
char* buf;

{
  long i = 0;
  unsigned char aByte;

  *num = 0;
  
  do 
    { aByte = buf[i++];
      *num = *num << dataBits;
      *num += (aByte & dataMask);
    }
  while (aByte & continueBit);

  return(buf + i);
} 

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

#define pad	128 

char*
writeCompressedIntWithPadding(num,size,buffer,len)
unsigned long num;
unsigned long size;
char* buffer;
long* len;

{
  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;

{
  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;

{ 
  return(writeCompressedInteger(tag,buf,len));
} 

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

char*
readTag(tag,buf)
data_tag* tag;
char* buf;

{ 
  return(readCompressedInteger(tag,buf));
} 

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

unsigned long 
writtenTagSize(tag)
data_tag tag;
{ 
  return(writtenCompressedIntSize(tag));
}

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

data_tag
peekTag(buf)
char* buf;

{
  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;

{
  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;

{
  char* buf = buffer;

  if (a == NULL)		
    return(buf);
  
  
  buf = writeTag(tag,buf,len);
  buf = writeCompressedInteger(a->size,buf,len);

  
  CHECK_FOR_SPACE_LEFT(a->size,len);
  memcpy(buf,a->bytes,(size_t)a->size);

  return(buf+a->size);
}

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

char* 
readAny(anAny,buffer)	/*!!ALLOCS at anAny */
any** anAny;
char* buffer;

{
  char* buf = buffer;
  any* a = (any*)s_malloc((size_t)sizeof(any));
  data_tag tag;
  
  buf = readTag(&tag,buf);
  buf = readCompressedInteger(&a->size,buf);
  
  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;

{
  char* buf = buffer;
  any* data = NULL;
  if (s == NULL)
    return(buffer);		
  data = (any*)s_malloc((size_t)sizeof(any)); 
  data->size = strlen(s);
  data->bytes = s;		
  buf = writeAny(data,tag,buf,len);
  s_free(data);			
  return(buf);
}

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

char* 
readString(s ,buffer)
char** s ;
char* buffer;

{
  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;

{
  char s[40];

  sprintf(s,"%ld",num);
  
  return(stringToAny(s));
}

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

long
anyToLong(a)
any* a;

{
  long num;
  char* str = NULL;
  str = anyToString(a);
  sscanf(str,"%ld",&num);	
  s_free(str);
  return(num);
}
 
/*----------------------------------------------------------------------*/

#define bitsPerByte	8

bit_map*
makeBitMap(unsigned long numBits,...)

{
  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);
  
  
  for (i = 0; i < bm->size; i++) 
    { char aByte = 0;
      for (j = 0; j < bitsPerByte; j++) 
	{ if ((i * bitsPerByte + j) < numBits)
	    { boolean bit = false;
	      bit = (boolean)va_arg(ap,boolean); 
	      if (bit)
	        { aByte = aByte | (1 << (bitsPerByte - j - 1));
	        }
	    }
	  }
      bm->bytes[i] = aByte;
    }

  va_end(ap);
  return(bm);
}


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

void
freeBitMap(bm)
bit_map* bm;

{
  s_free(bm->bytes);
  s_free(bm);
}

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



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;

{ 
  return(writeAny((any*)bm,tag,buffer,len));
}

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

char*
readBitMap(bm,buffer)
bit_map** bm;
char* buffer;

{ 
  return(readAny((any**)bm,buffer));
}

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

char* 
writeByte(aByte,buf,len)
unsigned long aByte;
char* buf;
long* len;
{
  CHECK_FOR_SPACE_LEFT(1L,len);
  buf[0] = aByte & 0xFF; 
  return(buf + 1);
}

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

char* 
readByte(aByte,buf)
unsigned char* aByte;
char* buf;
{
  *aByte = 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 aByte;
  char* buf = readByte(&aByte,buffer);
  *flag = (aByte == true) ? true : false;
  return(buf);
}

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

char*
writePDUType(pduType,buf,len)
pdu_type pduType;
char* buf;
long* len;

{
  return(writeBinaryInteger((long)pduType,(unsigned long)1,buf,len));
} 

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

char*
readPDUType(pduType,buf)
pdu_type* pduType;
char* buf;

{
  return(readBinaryInteger((long*)pduType,(unsigned long)1,buf));
} 

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

pdu_type
peekPDUType(buf)
char* buf;

{
  pdu_type pdu;
  readPDUType(&pdu,buf + HEADER_LEN);
  return(pdu);
}

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

#define BINARY_INTEGER_BYTES	sizeof(long) 
/* Writes an integer num into the buf (which has len bytes left) in a width
   of size, returns buff, and updates len */
char*
writeBinaryInteger(num,size,buf,len)
long num;
unsigned long size;
char* buf;
long* len;

{
  long i;
  char aByte;

  if (size < 1 || size > BINARY_INTEGER_BYTES)
    return(NULL);		

  CHECK_FOR_SPACE_LEFT(size,len);

  for (i = size - 1; i >= 0; i--)
    { aByte = (char)(num & 255);
      buf[i] = aByte;
      num = num >> bitsPerByte; 
    }

  return(buf + size);
}

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

char*
readBinaryInteger(num,size,buf)
long* num;
unsigned long size;
char* buf;

{
  long i;
  unsigned char aByte;
  if (size < 1 || size > BINARY_INTEGER_BYTES)
    return(buf);		
  *num = 0;
  for (i = 0; i < size; i++)
    { aByte = buf[i];
      *num = *num << bitsPerByte;
      *num += aByte;
    }
  return(buf + size);
}

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

unsigned long 
writtenCompressedBinIntSize(num)
long num;

{
  if (num < 0L)
    return(4);
  else if (num < 256L)		
    return(1);
  else if (num < 65536L)	
    return(2);
  else if (num < 16777216L)	
    return(3);
  else
    return(4);
}
 
/*----------------------------------------------------------------------*/

char*
writeNum(num,tag,buffer,len)
long num;
data_tag tag;
char* buffer;
long* len;

{
  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;

{
  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); 
  size += writtenCompressedIntSize(dataSize); 
  size += dataSize; 
  
  return(size);
}

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

typedef void (voidfunc)();

void
doList(theList,func)
void** theList;
voidfunc *func;

{
  register long i;
  register void* ptr = NULL;
  if (theList == NULL)
    return;
  for (i = 0,ptr = theList[i]; ptr != NULL; ptr = theList[++i])
    (*func)(ptr);
}

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

char* 
writeProtocolVersion(buf,len)
char* buf;
long* len;

{
  static bit_map* version = NULL;

  if (version == NULL)
	/* While this only NEEDS doing once, dont really care if done twice
	   simultaneously by different threads*/
   { version = makeBitMap((unsigned long)1,true); 
   }
    
  return(writeBitMap(version,DT_ProtocolVersion,buf,len));
}

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

char*
defaultImplementationID()
{
  static char	ImplementationID[] = "WAIS Inc";
  return(ImplementationID);
}

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

char*
defaultImplementationName()
{
  static char ImplementationName[] = "Wide Area Information Servers Inc Z39.50";
  return(ImplementationName);
}

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

char*
defaultImplementationVersion()
{
  static char	ImplementationVersion[] = "2.0A";
  return(ImplementationVersion);
}

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