home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / Programming / Source / WAIS / ir / zutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  21.0 KB  |  990 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4.   
  5.    3.26.90    Harry Morris, morris@think.com
  6.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  7.    4.11.90  HWM - fixed include file names, changed 
  8.                    - writeCompressedIntegerWithPadding() to
  9.                   writeCompressedIntWithPadding()
  10.                 - generalized conditional includes (see c-dialect.h)
  11.    3.7.91   Jonny Goldman.  Replaced "short" in makeBitMap with "int" line 632.
  12. */
  13.  
  14. #define _C_utils_Z39_50_
  15.  
  16. #include "zutil.h"
  17.  
  18. #include <math.h>
  19. #include <string.h>
  20.  
  21. #ifdef ANSI_LIKE
  22. #include <stdarg.h>
  23. #else
  24. #include "ustubs.h"
  25. #include <varargs.h>
  26. #endif
  27.  
  28. char* readErrorPosition = NULL; /* pos where buf stoped making sense */
  29.  
  30. /*----------------------------------------------------------------------*/
  31. /* A note on error handling 
  32.    read - these are low level routines, they do not check the type tags
  33.    which (sometimes) preceed the data (this is done by the higher
  34.    level functions which call these functions).  There is no 
  35.    attempt made to check that the reading does not exceed the read
  36.    buffer.  Such cases should be very rare and usually will be 
  37.    caught by the calling functions. (note - it is unlikely that 
  38.    a series of low level reads will go far off the edge without
  39.    triggering a type error.  However, it is possible for a single
  40.    bad read in an array function (eg. readAny) to attempt to read a 
  41.    large ammount, possibly causing a segmentation violation or out
  42.    of memory condition.
  43.  */
  44. /*----------------------------------------------------------------------*/
  45.  
  46. diagnosticRecord* 
  47. makeDiag(surrogate,code,addInfo)
  48. boolean surrogate;
  49. char* code;
  50. char* addInfo;
  51. {
  52.   diagnosticRecord* diag = 
  53.     (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  54.   
  55.   diag->SURROGATE = surrogate;
  56.   memcpy(diag->DIAG,code,DIAGNOSTIC_CODE_SIZE);
  57.   diag->ADDINFO = s_strdup(addInfo); 
  58.  
  59.   return(diag);
  60. }
  61.  
  62. /*----------------------------------------------------------------------*/
  63.  
  64. void 
  65. freeDiag(diag)
  66. diagnosticRecord* diag;
  67. { 
  68.   if (diag != NULL)
  69.     { if (diag->ADDINFO != NULL)
  70.     s_free(diag->ADDINFO);
  71.     s_free(diag);
  72.       }
  73. }
  74.  
  75. /*----------------------------------------------------------------------*/
  76.  
  77. #define END_OF_RECORD    0x1D
  78.  
  79. char* 
  80. writeDiag(diag,buffer,len)
  81. diagnosticRecord* diag;
  82. char* buffer;
  83. long* len;
  84. /* diagnostics (as per Appendix D) have a very weird format - this changes
  85.    in SR-1
  86.  */
  87. {
  88.   char* buf = buffer;
  89.   long  length;
  90.   
  91.   if (diag == NULL)        /* handle unspecified optional args */
  92.     return(buf);
  93.  
  94.   buf = writeTag(DT_DatabaseDiagnosticRecords,buf,len);
  95.   CHECK_FOR_SPACE_LEFT(0L,len);
  96.   
  97.   length = 3; 
  98.   if (diag->ADDINFO != NULL)
  99.     length += strlen(diag->ADDINFO);
  100.     
  101.   if (length >= 0xFFFF )    /* make sure the length is reasonable */
  102.     { length = 0xFFFF - 1;
  103.       diag->ADDINFO[0xFFFF - 3 - 1] = '\0';
  104.     }
  105.    
  106.   buf = writeBinaryInteger(length,2L,buf,len);
  107.  
  108.   CHECK_FOR_SPACE_LEFT(1L,len);
  109.   buf[0] = diag->DIAG[0]; 
  110.   buf++;
  111.   
  112.   CHECK_FOR_SPACE_LEFT(1L,len);
  113.   buf[0] = diag->DIAG[1];
  114.   buf++;
  115.   
  116.   if (length > 3)
  117.     { CHECK_FOR_SPACE_LEFT(3L,len);
  118.       memcpy(buf,diag->ADDINFO,(size_t)length - 3);
  119.       buf += length - 3;
  120.     }
  121.    
  122.   CHECK_FOR_SPACE_LEFT(1L,len);
  123.   buf[0] = diag->SURROGATE;
  124.   buf++;
  125.   
  126.   CHECK_FOR_SPACE_LEFT(1L,len);
  127.   buf[0] = END_OF_RECORD;
  128.   buf++;
  129.  
  130.   return(buf);
  131. }
  132.  
  133. /*----------------------------------------------------------------------*/
  134.  
  135. char* 
  136. readDiag(diag,buffer)
  137. diagnosticRecord** diag;
  138. char* buffer;
  139. {
  140.   char* buf = buffer;
  141.   diagnosticRecord* d 
  142.     = (diagnosticRecord*)s_malloc((size_t)sizeof(diagnosticRecord));
  143.   data_tag tag;
  144.   long len;
  145.   
  146.   buf = readTag(&tag,buf);
  147.   
  148.   buf = readBinaryInteger(&len,2L,buf);
  149.   
  150.   d->DIAG[0] = buf[0];
  151.   d->DIAG[1] = buf[1];
  152.   d->DIAG[2] = '\0';
  153.     
  154.   if (len > 3)
  155.     { d->ADDINFO = (char*)s_malloc((size_t)(len - 3 + 1));
  156.       memcpy(d->ADDINFO,(char*)(buf + 2),(size_t)(len - 3));
  157.       d->ADDINFO[len - 3] = '\0';
  158.     }
  159.   else
  160.     d->ADDINFO = NULL;
  161.     
  162.   d->SURROGATE = buf[len - 1];
  163.   
  164.   *diag = d;
  165.  
  166.   return(buf + len + 1);
  167. }
  168.  
  169. /*----------------------------------------------------------------------*/
  170.  
  171. #define continueBit    0x80
  172. #define dataMask    0x7F
  173. #define dataBits    7
  174.  
  175. char*
  176. writeCompressedInteger(num,buf,len)
  177. unsigned long num;
  178. char* buf;
  179. long* len;
  180. /* write a binary integer in the format described on p. 40.
  181.    this might be sped up 
  182. */
  183. {
  184.   char byte;
  185.   long i;
  186.   unsigned long size;
  187.   
  188.   size = writtenCompressedIntSize(num);
  189.   CHECK_FOR_SPACE_LEFT(size,len);
  190.   
  191.   for (i = size - 1; i >= 0; i--)
  192.     { byte = num & dataMask;
  193.       if (i != (size-1))    /* turn on continue bit */
  194.     byte = (char)(byte | continueBit);
  195.       buf[i] = byte;
  196.       num = num >> dataBits;    /* don't and here */
  197.     }
  198.    
  199.   return(buf + size);
  200. } 
  201.  
  202. /*----------------------------------------------------------------------*/
  203.  
  204. char*
  205. readCompressedInteger(num,buf)
  206. unsigned long *num;
  207. char* buf;
  208. /* read a binary integer in the format described on p. 40.
  209.    this might be sped up 
  210. */
  211. {
  212.   long i = 0;
  213.   unsigned char byte;
  214.  
  215.   *num = 0;
  216.   
  217.   do 
  218.     { byte = buf[i++];
  219.       *num = *num << dataBits;
  220.       *num += (byte & dataMask);
  221.     }
  222.   while (byte & continueBit);
  223.  
  224.   return(buf + i);
  225. } 
  226.  
  227. /*----------------------------------------------------------------------*/
  228.  
  229. #define pad    128 /* high bit is set */
  230.  
  231. char*
  232. writeCompressedIntWithPadding(num,size,buffer,len)
  233. unsigned long num;
  234. unsigned long size;
  235. char* buffer;
  236. long* len;
  237. /* Like writeCompressedInteger, except writes padding (128) to make
  238.    sure that size bytes are used.  This can be read correctly by 
  239.    readCompressedInteger()
  240. */
  241. {
  242.   char* buf = buffer;
  243.   unsigned long needed,padding;
  244.   long i;
  245.     
  246.   CHECK_FOR_SPACE_LEFT(size,len);
  247.   
  248.   needed = writtenCompressedIntSize(num);
  249.   padding = size - needed;
  250.   i = padding - 1;
  251.  
  252.   for (i = padding - 1;i >= 0;i--)
  253.     { buf[i] = pad;
  254.     }
  255.   
  256.   buf = writeCompressedInteger(num,buf + padding,len);
  257.   
  258.   return(buf);
  259. } 
  260.  
  261. /*----------------------------------------------------------------------*/
  262.  
  263. unsigned long
  264. writtenCompressedIntSize(num)
  265. unsigned long num;
  266. /* return the number of bytes needed to represnet the value num in
  267.    compressed format.  curently limited to 4 bytes
  268.  */
  269. {
  270.   if (num < CompressedInt1Byte) 
  271.     return(1);
  272.   else if (num < CompressedInt2Byte) 
  273.     return(2);
  274.   else if (num < CompressedInt3Byte)
  275.     return(3);
  276.   else
  277.     return(4);    
  278. }
  279.  
  280. /*----------------------------------------------------------------------*/
  281.  
  282. char*
  283. writeTag(tag,buf,len)
  284. data_tag tag;
  285. char* buf;
  286. long* len;
  287. /* write out a data tag */
  288. { 
  289.   return(writeCompressedInteger(tag,buf,len));
  290. } 
  291.  
  292. /*----------------------------------------------------------------------*/
  293.  
  294. char*
  295. readTag(tag,buf)
  296. data_tag* tag;
  297. char* buf;
  298. /* read a data tag */
  299. { 
  300.   return(readCompressedInteger(tag,buf));
  301. } 
  302.  
  303. /*----------------------------------------------------------------------*/
  304.  
  305. unsigned long 
  306. writtenTagSize(tag)
  307. data_tag tag;
  308. { 
  309.   return(writtenCompressedIntSize(tag));
  310. }
  311.  
  312. /*----------------------------------------------------------------------*/
  313.  
  314. data_tag
  315. peekTag(buf)
  316. char* buf;
  317. /* read a data tag without advancing the buffer */
  318. {
  319.   data_tag tag;
  320.   readTag(&tag,buf);
  321.   return(tag);
  322. } 
  323.  
  324. /*----------------------------------------------------------------------*/
  325.  
  326. any* 
  327. makeAny(size,data)
  328. unsigned long size;
  329. char* data;
  330. {
  331.   any* a = (any*)s_malloc((size_t)sizeof(any));
  332.   a->size = size;
  333.   a->bytes = data;
  334.   return(a);
  335. }
  336.  
  337. /*----------------------------------------------------------------------*/
  338.  
  339. void
  340. freeAny(a)
  341. any* a;
  342. /* destroy an any and its associated data. Assumes a->bytes was
  343.    allocated using the s_malloc family of libraries 
  344.  */
  345. {
  346.   if (a != NULL)
  347.     { if (a->bytes != NULL)
  348.     s_free(a->bytes);
  349.       s_free(a);
  350.     }
  351. }
  352.  
  353. /*----------------------------------------------------------------------*/
  354.  
  355. any* 
  356. duplicateAny(a)
  357. any* a;
  358. {
  359.   any* copy = NULL;
  360.  
  361.   if (a == NULL)
  362.     return(NULL);
  363.  
  364.   copy = (any*)s_malloc((size_t)sizeof(any));
  365.   copy->size = a->size;
  366.   if (a->bytes == NULL)
  367.     copy->bytes = NULL;
  368.   else
  369.     { copy->bytes = (char*)s_malloc((size_t)copy->size);
  370.       memcpy(copy->bytes,a->bytes,(size_t)copy->size);
  371.     }
  372.   return(copy);
  373. }
  374.  
  375. /*----------------------------------------------------------------------*/
  376.  
  377. char* 
  378. writeAny(a,tag,buffer,len)
  379. any* a;
  380. data_tag tag;
  381. char* buffer;
  382. long* len;
  383. /* write an any + tag and size info */
  384. {
  385.   char* buf = buffer;
  386.  
  387.   if (a == NULL)        /* handle unspecified optional args */
  388.     return(buf);
  389.   
  390.   /* write the tags */
  391.   buf = writeTag(tag,buf,len);
  392.   buf = writeCompressedInteger(a->size,buf,len);
  393.  
  394.   /* write the bytes */
  395.   CHECK_FOR_SPACE_LEFT(a->size,len);
  396.   memcpy(buf,a->bytes,(size_t)a->size);
  397.  
  398.   return(buf+a->size);
  399. }
  400.  
  401. /*----------------------------------------------------------------------*/
  402.  
  403. char* 
  404. readAny(anAny,buffer)
  405. any** anAny;
  406. char* buffer;
  407. /* read an any + tag and size info */
  408. {
  409.   char* buf = buffer;
  410.   any* a = (any*)s_malloc((size_t)sizeof(any));
  411.   data_tag tag;
  412.   
  413.   buf = readTag(&tag,buf);
  414.   buf = readCompressedInteger(&a->size,buf);
  415.   /* now simply copy the bytes */
  416.   a->bytes = (char*)s_malloc((size_t)a->size);
  417.   memcpy(a->bytes,buf,(size_t)a->size);
  418.   *anAny = a;
  419.   return(buf+a->size);
  420. }
  421.  
  422. /*----------------------------------------------------------------------*/
  423.  
  424. unsigned long 
  425. writtenAnySize(tag,a)
  426. data_tag tag;
  427. any* a;
  428. {
  429.   unsigned long size;
  430.  
  431.   if (a == NULL)
  432.     return(0);
  433.  
  434.   size = writtenTagSize(tag);
  435.   size += writtenCompressedIntSize(a->size);
  436.   size += a->size;
  437.   return(size);
  438. }
  439.  
  440. /*----------------------------------------------------------------------*/
  441.  
  442. any*
  443. stringToAny(s)
  444. char* s;
  445. {
  446.   any* a = NULL;
  447.   
  448.   if (s == NULL)
  449.     return(NULL);
  450.     
  451.   a = (any*)s_malloc((size_t)sizeof(any));
  452.   a->size = strlen(s);
  453.   a->bytes = (char*)s_malloc((size_t)a->size);
  454.   memcpy(a->bytes,s,(size_t)a->size);
  455.   return(a);
  456. }
  457.  
  458. /*----------------------------------------------------------------------*/
  459.  
  460. char*
  461. anyToString(a)
  462. any* a;
  463. {
  464.   char* s = NULL;
  465.   
  466.   if (a == NULL)
  467.     return(NULL);
  468.     
  469.   s = s_malloc((size_t)(a->size + 1));
  470.   memcpy(s,a->bytes,(size_t)a->size);
  471.   s[a->size] = '\0';
  472.   return(s);
  473. }
  474.  
  475. /*----------------------------------------------------------------------*/
  476.  
  477. char* 
  478. writeString(s,tag,buffer,len)
  479. char* s;
  480. data_tag tag;
  481. char* buffer;
  482. long* len;
  483. /* Write a C style string.  The terminating null is not written. 
  484.    This function is not part of the Z39.50 spec.  It is provided
  485.    for the convienience of those wishing to pass C strings in 
  486.    the place of an any.
  487.  */
  488. {
  489.   char* buf = buffer;
  490.   any* data = NULL;
  491.   if (s == NULL)
  492.     return(buffer);        /* handle unused optional item before making an any */
  493.   data = (any*)s_malloc((size_t)sizeof(any)); 
  494.   data->size = strlen(s);
  495.   data->bytes = s;        /* save a copy here by not using stringToAny() */
  496.   buf = writeAny(data,tag,buf,len);
  497.   s_free(data);            /* don't use freeAny() since it will free s too */
  498.   return(buf);
  499. }
  500.  
  501. /*----------------------------------------------------------------------*/
  502.  
  503. char* 
  504. readString(s ,buffer)
  505. char** s ;
  506. char* buffer;
  507. /* Read an any and convert it into a C style string.
  508.    This function is not part of the Z39.50 spec.  It is provided
  509.    for the convienience of those wishing to pass C strings in 
  510.    the place of an any. 
  511.  */
  512. {
  513.   any* data = NULL;
  514.   char* buf = readAny(&data,buffer);
  515.   *s = anyToString(data);
  516.   freeAny(data);
  517.   return(buf);
  518. }
  519.  
  520. /*----------------------------------------------------------------------*/
  521.  
  522. unsigned long 
  523. writtenStringSize(tag,s)
  524. data_tag tag;
  525. char* s;
  526. {
  527.   unsigned long size;
  528.  
  529.   if (s == NULL)
  530.    return(0);
  531.  
  532.   size = writtenTagSize(tag);
  533.   size += writtenCompressedIntSize(size);
  534.   size += strlen(s);
  535.   return(size);
  536. }
  537.  
  538. /*----------------------------------------------------------------------*/
  539.  
  540. any* 
  541. longToAny(num)
  542. long num;
  543. /* a convienience function */
  544. {
  545.   char s[40];
  546.  
  547.   sprintf(s,"%ld",num);
  548.   
  549.   return(stringToAny(s));
  550. }
  551.  
  552. /*----------------------------------------------------------------------*/
  553.  
  554. long
  555. anyToLong(a)
  556. any* a;
  557. /* a convienience function */
  558. {
  559.   long num;
  560.   char* str = NULL;
  561.   str = anyToString(a);
  562.   sscanf(str,"%ld",&num);    /* could check the result and return
  563.                    an error */
  564.   s_free(str);
  565.   return(num);
  566. }
  567.  
  568. /*----------------------------------------------------------------------*/
  569.  
  570. #define bitsPerByte    8
  571.  
  572. #ifdef ANSI_LIKE /* use ansi */
  573.  
  574. bit_map*
  575. makeBitMap(numBits)
  576. unsigned long numBits;
  577. /* construct and return a bitmap with numBits elements */
  578. {
  579.   va_list ap;
  580.   long i,j;
  581.   bit_map* bm = NULL;
  582.  
  583.   va_start(ap,numBits);
  584.   
  585.   bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  586.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte); 
  587.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  588.   
  589.   /* fill up the bits */
  590.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  591.     { char byte = 0;
  592.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  593.     { if ((i * bitsPerByte + j) < numBits)
  594.         { boolean bit = false;
  595.           bit = (boolean)va_arg(ap,boolean); 
  596.           if (bit)
  597.             { byte = byte | (1 << (bitsPerByte - j - 1));
  598.             }
  599.         }
  600.       }
  601.       bm->bytes[i] = byte;
  602.     }
  603.  
  604.   va_end(ap);
  605.   return(bm);
  606. }
  607.  
  608. #else /* use K & R */
  609.  
  610. bit_map*
  611. makeBitMap(va_alist)
  612. va_dcl
  613. /* construct and return a bitmap with numBits elements */
  614. {
  615.   va_list ap;
  616.   long i,j;
  617.   unsigned long numBits;
  618.   bit_map* bm = (bit_map*)s_malloc((size_t)sizeof(bit_map));
  619.  
  620.   va_start(ap);
  621.   
  622.   numBits = va_arg(ap,unsigned long);
  623.  
  624.   bm->size = (unsigned long)ceil((double)numBits / bitsPerByte);
  625.   
  626.   bm->bytes = (char*)s_malloc((size_t)bm->size);
  627.   
  628.   /* fill up the bits */
  629.   for (i = 0; i < bm->size; i++) /* iterate over bytes */
  630.     { char byte = 0;
  631.       for (j = 0; j < bitsPerByte; j++) /* iterate over bits */
  632.     { if ((i * bitsPerByte + j) < numBits)
  633.         { boolean bit;
  634.           bit = (boolean)va_arg(ap,int); /* really boolean, but this 
  635.                         is how it is passed on stack */
  636.           if (bit)
  637.             { byte = byte | (1 << (bitsPerByte - j - 1));
  638.             }
  639.         }
  640.       }
  641.       bm->bytes[i] = byte;
  642.     }
  643.  
  644.   va_end(ap);
  645.  
  646.   return(bm);
  647. }
  648.  
  649. #endif 
  650.  
  651. /*----------------------------------------------------------------------*/
  652.  
  653. void
  654. freeBitMap(bm)
  655. bit_map* bm;
  656. /* destroy a bit map created by makeBitMap() */
  657. {
  658.   s_free(bm->bytes);
  659.   s_free(bm);
  660. }
  661.  
  662. /*----------------------------------------------------------------------*/
  663.  
  664. /* use this routine to interpret a bit map.  pos specifies the bit 
  665.    number.  bit 0 is the Leftmost bit of the first byte.  
  666.    Could do bounds checking.
  667.  */
  668.  
  669. boolean
  670. bitAtPos(pos,bm)
  671. long pos;
  672. bit_map* bm;
  673. {
  674.   if (pos > bm->size*bitsPerByte)
  675.     return false;
  676.   else
  677.     return((bm->bytes[(pos / bitsPerByte)] & 
  678.         (0x80>>(pos % bitsPerByte))) ?
  679.        true : false);
  680. }
  681.  
  682. /*----------------------------------------------------------------------*/
  683.  
  684. char*
  685. writeBitMap(bm,tag,buffer,len)
  686. bit_map* bm;
  687. data_tag tag;
  688. char* buffer;
  689. long* len;
  690. /* write a bitmap + type and size info */
  691. { 
  692.   return(writeAny((any*)bm,tag,buffer,len));
  693. }
  694.  
  695. /*----------------------------------------------------------------------*/
  696.  
  697. char*
  698. readBitMap(bm,buffer)
  699. bit_map** bm;
  700. char* buffer;
  701. /* read a bitmap + type and size info */
  702. { 
  703.   return(readAny((any**)bm,buffer));
  704. }
  705.  
  706. /*----------------------------------------------------------------------*/
  707.  
  708. char* 
  709. writeByte(byte,buf,len)
  710. unsigned long byte;
  711. char* buf;
  712. long* len;
  713. {
  714.   CHECK_FOR_SPACE_LEFT(1L,len);
  715.   buf[0] = byte & 0xFF; /* we really only want the first byte */
  716.   return(buf + 1);
  717. }
  718.  
  719. /*----------------------------------------------------------------------*/
  720.  
  721. char* 
  722. readByte(byte,buf)
  723. unsigned char* byte;
  724. char* buf;
  725. {
  726.   *byte = buf[0];
  727.   return(buf + 1);
  728. }
  729.  
  730. /*----------------------------------------------------------------------*/
  731.  
  732. char* 
  733. writeBoolean(flag,buf,len)
  734. boolean flag;
  735. char* buf;
  736. long* len;
  737. {
  738.   return(writeByte(flag,buf,len));
  739. }
  740.  
  741. /*----------------------------------------------------------------------*/
  742.  
  743. char* 
  744. readBoolean(flag,buffer)
  745. boolean* flag;
  746. char* buffer;
  747. {
  748.   unsigned char byte;
  749.   char* buf = readByte(&byte,buffer);
  750.   *flag = (byte == true) ? true : false;
  751.   return(buf);
  752. }
  753.  
  754. /*----------------------------------------------------------------------*/
  755.  
  756. char*
  757. writePDUType(pduType,buf,len)
  758. pdu_type pduType;
  759. char* buf;
  760. long* len;
  761. /* PDUType is a single byte */
  762. {
  763.   return(writeBinaryInteger((long)pduType,(unsigned long)1,buf,len));
  764. } 
  765.  
  766. /*----------------------------------------------------------------------*/
  767.  
  768. char*
  769. readPDUType(pduType,buf)
  770. pdu_type* pduType;
  771. char* buf;
  772. /* PDUType is a single byte */
  773. {
  774.   return(readBinaryInteger((long*)pduType,(unsigned long)1,buf));
  775. } 
  776.  
  777. /*----------------------------------------------------------------------*/
  778.  
  779. pdu_type
  780. peekPDUType(buf)
  781. char* buf;
  782. /* read the next pdu without advancing the buffer, Note that this 
  783.    function is to be used on a buffer that is known to contain an
  784.    APDU.  The pdu_type is written HEADER_LEN bytes into the buffer
  785.  */
  786. {
  787.   pdu_type pdu;
  788.   readPDUType(&pdu,buf + HEADER_LEN);
  789.   return(pdu);
  790. }
  791.  
  792. /*----------------------------------------------------------------------*/
  793.  
  794. #define BINARY_INTEGER_BYTES    sizeof(long) /* the number of bytes used by
  795.                         a "binary integer" */
  796. char*
  797. writeBinaryInteger(num,size,buf,len)
  798. long num;
  799. unsigned long size;
  800. char* buf;
  801. long* len;
  802. /* write out first size bytes of num - no type info
  803.   XXX should this take unsigned longs instead ???  */
  804. {
  805.   long i;
  806.   char byte;
  807.  
  808.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  809.     return(NULL);        /* error */
  810.  
  811.   CHECK_FOR_SPACE_LEFT(size,len);
  812.  
  813.   for (i = size - 1; i >= 0; i--)
  814.     { byte = (char)(num & 255);
  815.       buf[i] = byte;
  816.       num = num >> bitsPerByte; /* don't and here */
  817.     }
  818.  
  819.   return(buf + size);
  820. }
  821.  
  822. /*----------------------------------------------------------------------*/
  823.  
  824. char*
  825. readBinaryInteger(num,size,buf)
  826. long* num;
  827. unsigned long size;
  828. char* buf;
  829. /* read in first size bytes of num - no type info
  830.   XXX this should take unsigned longs instead !!! */
  831. {
  832.   long i;
  833.   unsigned char byte;
  834.   if (size < 1 || size > BINARY_INTEGER_BYTES)
  835.     return(buf);        /* error */
  836.   *num = 0;
  837.   for (i = 0; i < size; i++)
  838.     { byte = buf[i];
  839.       *num = *num << bitsPerByte;
  840.       *num += byte;
  841.     }
  842.   return(buf + size);
  843. }
  844.  
  845. /*----------------------------------------------------------------------*/
  846.  
  847. unsigned long 
  848. writtenCompressedBinIntSize(num)
  849. long num;
  850. /* return the number of bytes needed to represent the value num.
  851.    currently limited to max of 4 bytes 
  852.    Only compresses for positive nums - negatives get whole 4 bytes
  853.  */
  854. {
  855.   if (num < 0L)
  856.     return(4);
  857.   else if (num < 256L)        /* 2**8 */
  858.     return(1);
  859.   else if (num < 65536L)    /* 2**16 */
  860.     return(2);
  861.   else if (num < 16777216L)    /* 2**24 */
  862.     return(3);
  863.   else
  864.     return(4);
  865. }
  866.  
  867. /*----------------------------------------------------------------------*/
  868.  
  869. char*
  870. writeNum(num,tag,buffer,len)
  871. long num;
  872. data_tag tag;
  873. char* buffer;
  874. long* len;
  875. /* write a binary integer + size and tag info */
  876. {
  877.   char* buf = buffer;
  878.   long size = writtenCompressedBinIntSize(num);
  879.   
  880.   if (num == UNUSED)
  881.     return(buffer);
  882.     
  883.   buf = writeTag(tag,buf,len);
  884.   buf = writeCompressedInteger(size,buf,len); 
  885.   buf = writeBinaryInteger(num,(unsigned long)size,buf,len); 
  886.   return(buf);
  887. }
  888.  
  889. /*----------------------------------------------------------------------*/
  890.  
  891. char*
  892. readNum(num,buffer)
  893. long* num;
  894. char* buffer;
  895. /* read a binary integer + size and tag info */
  896. {
  897.   char* buf = buffer;
  898.   data_tag tag;
  899.   unsigned long size;
  900.   unsigned long val;
  901.   
  902.   buf = readTag(&tag,buf);
  903.   buf = readCompressedInteger(&val,buf);
  904.   size = (unsigned long)val;
  905.   buf = readBinaryInteger(num,size,buf);
  906.   return(buf);
  907. }
  908.  
  909. /*----------------------------------------------------------------------*/
  910.  
  911. unsigned long 
  912. writtenNumSize(tag,num)
  913. data_tag tag;
  914. long num;
  915. {
  916.   long dataSize = writtenCompressedBinIntSize(num);
  917.   long size;
  918.   
  919.   size = writtenTagSize(tag); /* space for the tag */
  920.   size += writtenCompressedIntSize(dataSize); /* space for the size */
  921.   size += dataSize; /* space for the data */
  922.   
  923.   return(size);
  924. }
  925.  
  926. /*----------------------------------------------------------------------*/
  927.  
  928. typedef void (voidfunc)();
  929.  
  930. void
  931. doList(list,func)
  932. void** list;
  933. voidfunc *func;
  934. /* call func on each element of the NULL terminated list of pointers */
  935. {
  936.   register long i;
  937.   register void* ptr = NULL;
  938.   if (list == NULL)
  939.     return;
  940.   for (i = 0,ptr = list[i]; ptr != NULL; ptr = list[++i])
  941.     (*func)(ptr);
  942. }
  943.  
  944. /*----------------------------------------------------------------------*/
  945.  
  946. char* 
  947. writeProtocolVersion(buf,len)
  948. char* buf;
  949. long* len;
  950. /* write a bitmap describing the protocols available */
  951. {
  952.   static bit_map* version = NULL;
  953.  
  954.   if (version == NULL)
  955.    { version = makeBitMap((unsigned long)1,true); /* version 1! */
  956.    }
  957.     
  958.   return(writeBitMap(version,DT_ProtocolVersion,buf,len));
  959. }
  960.  
  961. /*----------------------------------------------------------------------*/
  962.  
  963. char*
  964. defaultImplementationID()
  965. {
  966.   static char    ImplementationID[] = "TMC";
  967.   return(ImplementationID);
  968. }
  969.  
  970. /*----------------------------------------------------------------------*/
  971.  
  972. char*
  973. defaultImplementationName()
  974. {
  975.   static char ImplementationName[] = "Thinking Machines Corporation Z39.50";
  976.   return(ImplementationName);
  977. }
  978.  
  979. /*----------------------------------------------------------------------*/
  980.  
  981. char*
  982. defaultImplementationVersion()
  983. {
  984.   static char    ImplementationVersion[] = "2.0A";
  985.   return(ImplementationVersion);
  986. }
  987.  
  988. /*----------------------------------------------------------------------*/
  989.  
  990.