home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / zprot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-16  |  32.5 KB  |  1,144 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:`
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4. /*
  5.  
  6. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  7.  
  8.  
  9. #ifndef lint
  10. static char *RCSid = "$Header: /usr/users/freewais/FreeWAIS-0.1/ir/zprot.c,v 1.1 1993/02/16 15:05:35 freewais Exp $";
  11. #endif
  12.  
  13. /* Change log:
  14.  * $Log: zprot.c,v $
  15.  * Revision 1.1  1993/02/16  15:05:35  freewais
  16.  * Initial revision
  17.  *
  18.  * Revision 1.4  92/02/12  13:59:51  jonathan
  19.  * Added "$Log" so RCS will put the log message in the header
  20.  * 
  21.  * 
  22.   
  23.    3.26.90    Harry Morris, morris@think.com
  24.    3.30.90  Harry Morris - Changed any->bits to any->bytes
  25.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  26. */
  27.  
  28. #define _C_Z39_50_
  29.  
  30. #include "zprot.h"
  31.  
  32. #include "zutil.h"
  33. #include "cutil.h"
  34. #include <string.h>
  35.  
  36. #ifndef ANSI_LIKE
  37. #include "ustubs.h"
  38. #endif
  39.  
  40. #define RESERVE_SPACE_FOR_HEADER(spaceLeft)        \
  41.     *spaceLeft -= HEADER_LEN;
  42.     
  43. #define RELEASE_HEADER_SPACE(spaceLeft)            \
  44.     if (*spaceLeft > 0)                            \
  45.       *spaceLeft += HEADER_LEN;
  46.     
  47. /*----------------------------------------------------------------------*/
  48.  
  49. InitAPDU* 
  50. makeInitAPDU(search,
  51.          present,
  52.          deleteIt,
  53.          accessControl,
  54.          resourceControl,
  55.          prefSize,
  56.          maxMsgSize,
  57.          auth,
  58.          id,
  59.          name,
  60.          version,
  61.          refID,
  62.          userInfo)
  63. boolean search;
  64. boolean present;
  65. boolean deleteIt;
  66. boolean accessControl;
  67. boolean resourceControl;
  68. long prefSize;
  69. long maxMsgSize;
  70. char* auth;
  71. char* id;
  72. char* name;
  73. char* version;
  74. any* refID;
  75. void* userInfo;
  76.  
  77. /* build an init APDU with user specified information */
  78. { 
  79.   InitAPDU* init = (InitAPDU*)s_malloc((size_t)sizeof(InitAPDU));
  80.  
  81.   init->PDUType = initAPDU;
  82.   init->willSearch = search;
  83.   init->willPresent = present;
  84.   init->willDelete = deleteIt;
  85.   init->supportAccessControl = accessControl;
  86.   init->supportResourceControl = resourceControl;
  87.   init->PreferredMessageSize = prefSize;
  88.   init->MaximumRecordSize = maxMsgSize;
  89.   init->IDAuthentication = s_strdup(auth);
  90.   init->ImplementationID = s_strdup(id);
  91.   init->ImplementationName = s_strdup(name);
  92.   init->ImplementationVersion = s_strdup(version);
  93.   init->ReferenceID = duplicateAny(refID);
  94.   init->UserInformationField = userInfo; /* not copied */
  95.   
  96.   return(init);
  97. }
  98.  
  99. /*----------------------------------------------------------------------*/
  100.  
  101. void 
  102. freeInitAPDU(init)
  103. InitAPDU* init;
  104. /* free an initAPDU */
  105. {
  106.   s_free(init->IDAuthentication);
  107.   s_free(init->ImplementationID);
  108.   s_free(init->ImplementationName);
  109.   s_free(init->ImplementationVersion);
  110.   freeAny(init->ReferenceID);
  111.   s_free(init);
  112. }
  113.  
  114. /*----------------------------------------------------------------------*/
  115.  
  116. char* 
  117. writeInitAPDU(init,buffer,len)
  118. InitAPDU* init;
  119. char* buffer;
  120. long* len;
  121. /* write the init to a buffer, adding system information */
  122. {
  123.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  124.   long size;
  125.   bit_map* optionsBM = NULL;
  126.  
  127.   RESERVE_SPACE_FOR_HEADER(len);
  128.   
  129.   buf = writePDUType(init->PDUType,buf,len);
  130.   
  131.   buf = writeProtocolVersion(buf,len);
  132.   
  133.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  134.                          init->willDelete,init->supportAccessControl,
  135.                          init->supportResourceControl);
  136.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  137.   freeBitMap(optionsBM);
  138.  
  139.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  140.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  141.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  142.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  143.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  144.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  145.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  146.   
  147.   /* go back and write the header-length-indicator */
  148.   RELEASE_HEADER_SPACE(len);
  149.   size = buf - buffer - HEADER_LEN; 
  150.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  151.  
  152.   if (init->UserInformationField != NULL)
  153.     buf = writeInitInfo(init,buf,len);   
  154.     
  155.   return(buf); 
  156. }
  157.  
  158. /*----------------------------------------------------------------------*/
  159.  
  160. char* 
  161. readInitAPDU(init,buffer)
  162. InitAPDU** init;
  163. char* buffer;
  164. {
  165.   char* buf = buffer;
  166.   boolean search,present,delete,accessControl,resourceControl;
  167.   long prefSize,maxMsgSize;
  168.   char *auth,*id,*name,*version;
  169.   long size; 
  170.   pdu_type pduType;
  171.   bit_map* versionBM = NULL;
  172.   bit_map* optionsBM = NULL;
  173.   any *refID = NULL;
  174.   void* userInfo = NULL;
  175.   
  176.   auth = id = name = version = NULL;
  177.   
  178.   /* read required part */
  179.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  180.   buf = readPDUType(&pduType,buf);
  181.   buf = readBitMap(&versionBM,buf); 
  182.   buf = readBitMap(&optionsBM,buf);
  183.   buf = readNum(&prefSize,buf);
  184.   buf = readNum(&maxMsgSize,buf);
  185.   
  186.   /* decode optionsBM */
  187.   search = bitAtPos(0L,optionsBM);
  188.   present = bitAtPos(1L,optionsBM);
  189.   delete = bitAtPos(2L,optionsBM);
  190.   accessControl = bitAtPos(3L,optionsBM);
  191.   resourceControl = bitAtPos(4L,optionsBM);
  192.   
  193.   /* read optional part */
  194.   while (buf < (buffer + size + HEADER_LEN)) 
  195.     { data_tag tag = peekTag(buf);
  196.       switch (tag)
  197.     { case DT_IDAuthentication:
  198.         buf = readString(&auth,buf);
  199.         break;
  200.       case DT_ImplementationID:
  201.         buf = readString(&id,buf);
  202.         break;
  203.       case DT_ImplementationName:
  204.         buf = readString(&name,buf);
  205.         break;
  206.       case DT_ImplementationVersion:
  207.         buf = readString(&version,buf);
  208.         break;
  209.       case DT_ReferenceID:
  210.         buf = readAny(&refID,buf);
  211.         break;
  212.       default:
  213.         freeBitMap(versionBM);
  214.         freeBitMap(optionsBM);
  215.         s_free(auth);
  216.         s_free(id);
  217.         s_free(name);
  218.         s_free(version);
  219.         freeAny(refID);
  220.         REPORT_READ_ERROR(buf);
  221.         break;
  222.       }
  223.     }
  224.  
  225.   buf = readInitInfo(&userInfo,buf);
  226.   if (buf == NULL)
  227.     { freeBitMap(versionBM);
  228.       freeBitMap(optionsBM);
  229.       s_free(auth);
  230.       s_free(id);
  231.       s_free(name);
  232.       s_free(version);
  233.       freeAny(refID);
  234.     }
  235.   RETURN_ON_NULL(buf);
  236.  
  237.   /* construct the basic init object */
  238.   *init = makeInitAPDU(search,present,delete,accessControl,resourceControl,
  239.                        prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  240.                           
  241.   freeBitMap(versionBM);
  242.   freeBitMap(optionsBM);
  243.   s_free(auth);
  244.   s_free(id);
  245.   s_free(name);
  246.   s_free(version);
  247.   freeAny(refID);
  248.   
  249.   return(buf);
  250. }
  251.  
  252. /*----------------------------------------------------------------------*/
  253.  
  254. InitResponseAPDU* 
  255. makeInitResponseAPDU(result,
  256.              search,
  257.              present,
  258.              deleteIt,
  259.              accessControl,
  260.              resourceControl,
  261.              prefSize,
  262.              maxMsgSize,
  263.              auth,
  264.              id,
  265.              name,
  266.              version,
  267.              refID,
  268.              userInfo)
  269. boolean result;
  270. boolean search;
  271. boolean present;
  272. boolean deleteIt;
  273. boolean accessControl;
  274. boolean resourceControl;
  275. long prefSize;
  276. long maxMsgSize;
  277. char* auth;
  278. char* id;
  279. char* name;
  280. char* version;
  281. any* refID;
  282. void* userInfo;
  283. /* build an initResponse APDU with user specified information */
  284. { 
  285.   InitResponseAPDU* init = (InitResponseAPDU*)s_malloc((size_t)sizeof(InitResponseAPDU));
  286.  
  287.   init->PDUType = initResponseAPDU;
  288.   init->Result = result;
  289.   init->willSearch = search;
  290.   init->willPresent = present;
  291.   init->willDelete = deleteIt;
  292.   init->supportAccessControl = accessControl;
  293.   init->supportResourceControl = resourceControl;
  294.   init->PreferredMessageSize = prefSize;
  295.   init->MaximumRecordSize = maxMsgSize;
  296.   init->IDAuthentication = s_strdup(auth);
  297.   init->ImplementationID = s_strdup(id);
  298.   init->ImplementationName = s_strdup(name);
  299.   init->ImplementationVersion = s_strdup(version);
  300.   init->ReferenceID = duplicateAny(refID);
  301.   init->UserInformationField = userInfo; /* not copied! */
  302.   
  303.   return(init);
  304. }
  305.  
  306. /*----------------------------------------------------------------------*/
  307.  
  308. void 
  309. freeInitResponseAPDU(init)
  310. InitResponseAPDU* init;
  311. /* free an initAPDU */
  312. {
  313.   s_free(init->IDAuthentication);
  314.   s_free(init->ImplementationID);
  315.   s_free(init->ImplementationName);
  316.   s_free(init->ImplementationVersion);
  317.   freeAny(init->ReferenceID);
  318.   s_free(init);
  319. }
  320.  
  321. /*----------------------------------------------------------------------*/
  322.  
  323. char* 
  324. writeInitResponseAPDU(init,buffer,len)
  325. InitResponseAPDU* init;
  326. char* buffer;
  327. long* len;
  328. /* write the initResponse to a buffer, adding system information */
  329. { 
  330.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  331.   long size;
  332.   bit_map* optionsBM = NULL;
  333.  
  334.   RESERVE_SPACE_FOR_HEADER(len);
  335.   
  336.   buf = writePDUType(init->PDUType,buf,len);
  337.   buf = writeBoolean(init->Result,buf,len);
  338.   buf = writeProtocolVersion(buf,len);
  339.   
  340.   optionsBM = makeBitMap((unsigned long)5,init->willSearch,init->willPresent,
  341.                          init->willDelete,init->supportAccessControl,
  342.                          init->supportResourceControl);
  343.   buf = writeBitMap(optionsBM,DT_Options,buf,len);
  344.   freeBitMap(optionsBM);
  345.  
  346.   buf = writeNum(init->PreferredMessageSize,DT_PreferredMessageSize,buf,len);
  347.   buf = writeNum(init->MaximumRecordSize,DT_MaximumRecordSize,buf,len);
  348.   buf = writeString(init->IDAuthentication,DT_IDAuthentication,buf,len);
  349.   buf = writeString(init->ImplementationID,DT_ImplementationID,buf,len);
  350.   buf = writeString(init->ImplementationName,DT_ImplementationName,buf,len);
  351.   buf = writeString(init->ImplementationVersion,DT_ImplementationVersion,buf,len);
  352.   buf = writeAny(init->ReferenceID,DT_ReferenceID,buf,len);
  353.   
  354.   /* go back and write the header-length-indicator */
  355.   RELEASE_HEADER_SPACE(len);
  356.   size = buf - buffer - HEADER_LEN; 
  357.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  358.  
  359.   if (init->UserInformationField != NULL)
  360.     buf = writeInitResponseInfo(init,buf,len);   
  361.     
  362.   return(buf);
  363. }
  364.  
  365. /*----------------------------------------------------------------------*/
  366.  
  367. char* 
  368. readInitResponseAPDU(init,buffer)
  369. InitResponseAPDU** init;
  370. char* buffer;
  371. {
  372.   char* buf = buffer;
  373.   boolean search,present,delete,accessControl,resourceControl;
  374.   long prefSize,maxMsgSize;
  375.   char *auth,*id,*name,*version;
  376.   long size; 
  377.   pdu_type pduType;
  378.   bit_map* versionBM = NULL;
  379.   bit_map* optionsBM = NULL;
  380.   boolean result;
  381.   any *refID = NULL;
  382.   void* userInfo = NULL;
  383.   
  384.   auth = id = name = version = NULL;
  385.   refID = NULL;
  386.   
  387.   /* read required part */
  388.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  389.   buf = readPDUType(&pduType,buf);
  390.   buf = readBoolean(&result,buf);
  391.   buf = readBitMap(&versionBM,buf); 
  392.   buf = readBitMap(&optionsBM,buf);
  393.   buf = readNum(&prefSize,buf);
  394.   buf = readNum(&maxMsgSize,buf);
  395.   
  396.   /* decode optionsBM */
  397.   search = bitAtPos(0L,optionsBM);
  398.   present = bitAtPos(1L,optionsBM);
  399.   delete = bitAtPos(2L,optionsBM);
  400.   accessControl = bitAtPos(3L,optionsBM);
  401.   resourceControl = bitAtPos(4L,optionsBM);
  402.   
  403.   /* read optional part */
  404.   while (buf < (buffer + size + HEADER_LEN)) 
  405.     { data_tag tag = peekTag(buf);
  406.       switch (tag)
  407.     { case DT_IDAuthentication:
  408.         buf = readString(&auth,buf);
  409.         break;
  410.       case DT_ImplementationID:
  411.         buf = readString(&id,buf);
  412.         break;
  413.       case DT_ImplementationName:
  414.         buf = readString(&name,buf);
  415.         break;
  416.       case DT_ImplementationVersion:
  417.         buf = readString(&version,buf);
  418.         break;
  419.       case DT_ReferenceID:
  420.         buf = readAny(&refID,buf);
  421.         break;
  422.       default:
  423.         freeBitMap(versionBM);
  424.         freeBitMap(optionsBM);
  425.         s_free(auth);
  426.         s_free(id);
  427.         s_free(name);
  428.         s_free(version);
  429.         freeAny(refID);
  430.         REPORT_READ_ERROR(buf);
  431.         break;
  432.       }
  433.     }
  434.  
  435.   buf = readInitResponseInfo(&userInfo,buf);
  436.   if (buf == NULL)
  437.     { freeBitMap(versionBM);
  438.       freeBitMap(optionsBM);
  439.       s_free(auth);
  440.       s_free(id);
  441.       s_free(name);
  442.       s_free(version);
  443.       freeAny(refID);
  444.     }
  445.   RETURN_ON_NULL(buf);
  446.   
  447.   /* construct the basic init object */
  448.   *init = makeInitResponseAPDU(result,
  449.                    search,present,delete,accessControl,resourceControl,
  450.                    prefSize,maxMsgSize,auth,id,name,version,refID,userInfo);
  451.                                           
  452.   freeBitMap(versionBM);
  453.   freeBitMap(optionsBM);
  454.   s_free(auth);
  455.   s_free(id);
  456.   s_free(name);
  457.   s_free(version);
  458.   freeAny(refID);
  459.   
  460.   return(buf);
  461. }
  462.  
  463. /*----------------------------------------------------------------------*/
  464.  
  465. InitResponseAPDU* 
  466. replyToInitAPDU(init,result,userInfo)
  467. InitAPDU* init;
  468. boolean result;
  469. void* userInfo;
  470. /* respond to an init message in the default way - echoing back
  471.    the init info 
  472.  */
  473. {
  474.   InitResponseAPDU* initResp;
  475.   initResp = makeInitResponseAPDU(result,
  476.                   init->willSearch,init->willPresent,init->willDelete,
  477.                   init->supportAccessControl,init->supportResourceControl,
  478.                   init->PreferredMessageSize,init->MaximumRecordSize,
  479.                   init->IDAuthentication,defaultImplementationID(),defaultImplementationName(),
  480.                   defaultImplementationVersion(),
  481.                   init->ReferenceID,userInfo);
  482.   return(initResp);
  483. }
  484.  
  485. /*----------------------------------------------------------------------*/
  486.  
  487. SearchAPDU* 
  488. makeSearchAPDU(small,
  489.            large,
  490.            medium,
  491.            replace,
  492.            name,
  493.            databases,
  494.            type,
  495.            elements,
  496.            refID,
  497.            queryInfo)
  498. long small;
  499. long large;
  500. long medium;
  501. boolean replace;
  502. char* name;
  503. char** databases;
  504. char* type;
  505. char** elements;
  506. any* refID;
  507. void* queryInfo;
  508. {
  509.   char* ptr = NULL;
  510.   long i;
  511.   SearchAPDU* query = (SearchAPDU*)s_malloc((size_t)sizeof(SearchAPDU));
  512.   query->PDUType = searchAPDU;
  513.   query->SmallSetUpperBound = small;
  514.   query->LargeSetLowerBound = large;
  515.   query->MediumSetPresentNumber = medium;
  516.   query->ReplaceIndicator = replace;
  517.   query->ResultSetName = s_strdup(name);
  518.   query->DatabaseNames = NULL; 
  519.   if (databases != NULL)
  520.     { for (i = 0, ptr = databases[i]; ptr != NULL; ptr = databases[++i])
  521.     { if (query->DatabaseNames == NULL)
  522.         query->DatabaseNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  523.         else
  524.           query->DatabaseNames = (char**)s_realloc((char*)query->DatabaseNames,
  525.                            (size_t)(sizeof(char*) * (i + 2)));
  526.         query->DatabaseNames[i] = s_strdup(ptr);
  527.         query->DatabaseNames[i+1] = NULL;
  528.       }
  529.       }
  530.   query->QueryType = s_strdup(type);
  531.   query->ElementSetNames = NULL; 
  532.   if (elements != NULL)
  533.     { for (i = 0, ptr = elements[i]; ptr != NULL; ptr = elements[++i])
  534.     { if (query->ElementSetNames == NULL)
  535.         query->ElementSetNames = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  536.         else
  537.           query->ElementSetNames = (char**)s_realloc((char*)query->ElementSetNames,
  538.                              (size_t)(sizeof(char*) * (i + 2)));
  539.         query->ElementSetNames[i] = s_strdup(ptr);
  540.         query->ElementSetNames[i+1] = NULL;
  541.       }
  542.       }
  543.   query->ReferenceID = duplicateAny(refID);
  544.   query->Query = queryInfo;    /* not copied! */
  545.   return(query);
  546. }
  547.  
  548. /*----------------------------------------------------------------------*/
  549.  
  550. void 
  551. freeSearchAPDU(query)
  552. SearchAPDU* query;
  553. {
  554.   s_free(query->ResultSetName);
  555.   s_free(query->QueryType);
  556.   doList((void**)query->DatabaseNames,fs_free); /* can't use the macro here ! */
  557.   s_free(query->DatabaseNames);
  558.   doList((void**)query->ElementSetNames,fs_free); /* can't use the macro here ! */
  559.   s_free(query->ElementSetNames);
  560.   freeAny(query->ReferenceID);
  561.   s_free(query);
  562. }
  563.  
  564. /*----------------------------------------------------------------------*/
  565.  
  566. #define DB_DELIMITER     "\037"     /* hex 1F occurs between each database name */
  567. #define ES_DELIMITER_1     "\037"     /* separates database name from element name */
  568. #define ES_DELIMITER_2     "\036"     /* hex 1E separates <db,es> groups from one another */
  569.  
  570. char* 
  571. writeSearchAPDU(query,buffer,len)
  572. SearchAPDU* query;
  573. char* buffer;
  574. long* len;
  575. { 
  576.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  577.   long size,i;
  578.   char* ptr = NULL;
  579.   char* scratch = NULL;
  580.  
  581.   RESERVE_SPACE_FOR_HEADER(len);
  582.   
  583.   buf = writePDUType(query->PDUType,buf,len);
  584.   buf = writeBinaryInteger(query->SmallSetUpperBound,(size_t)3,buf,len);
  585.   buf = writeBinaryInteger(query->LargeSetLowerBound,(size_t)3,buf,len);
  586.   buf = writeBinaryInteger(query->MediumSetPresentNumber,(size_t)3,buf,len);
  587.   buf = writeBoolean(query->ReplaceIndicator,buf,len);
  588.   buf = writeString(query->ResultSetName,DT_ResultSetName,buf,len);
  589.   /* write database names */
  590.   if (query->DatabaseNames != NULL)
  591.     { for (i = 0,scratch = NULL, ptr = query->DatabaseNames[i]; ptr != NULL; ptr = query->DatabaseNames[++i])
  592.     { if (scratch == NULL)
  593.         scratch = s_strdup(ptr);
  594.         else
  595.       { size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + 3);
  596.         scratch = (char*)s_realloc(scratch,newScratchSize);
  597.         s_strncat(scratch,DB_DELIMITER,2L,newScratchSize);
  598.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  599.       }
  600.       }
  601.     buf = writeString(scratch,DT_DatabaseNames,buf,len);
  602.     s_free(scratch);
  603.       }
  604.   buf = writeString(query->QueryType,DT_QueryType,buf,len);
  605.   /* write element set names */
  606.   if (query->ElementSetNames != NULL)
  607.     { for (i = 0,scratch = NULL, ptr = query->ElementSetNames[i]; ptr != NULL; ptr = query->ElementSetNames[++i])
  608.     { if (scratch == NULL)
  609.         { if (query->ElementSetNames[i+1] == NULL) /* there is a single element set name */
  610.         { scratch = (char*)s_malloc((size_t)strlen(ptr) + 3);
  611.           strncpy(scratch,ES_DELIMITER_1,2);
  612.           s_strncat(scratch,ptr,strlen(ptr) + 1,strlen(ptr) + 2);
  613.         }
  614.         else        /* this is the first of a series of element set names */
  615.           { size_t newScratchSize = (size_t)(strlen(ptr) + strlen(query->ElementSetNames[i + 1]) + 3);
  616.         scratch = s_strdup(ptr); /* the database name */
  617.         ptr = query->ElementSetNames[++i]; /* the element set name */
  618.         scratch = (char*)s_realloc(scratch,newScratchSize);
  619.         s_strncat(scratch,ES_DELIMITER_1,2L,newScratchSize);
  620.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize); 
  621.           }
  622.           }
  623.         else
  624.       { char* esPtr = query->ElementSetNames[++i]; /* the element set name */
  625.         size_t newScratchSize = (size_t)(strlen(scratch) + strlen(ptr) + strlen(esPtr) + 3);
  626.         scratch = (char*)s_realloc(scratch,newScratchSize);
  627.         s_strncat(scratch,ES_DELIMITER_2,2L,newScratchSize);
  628.         s_strncat(scratch,ptr,strlen(ptr) + 1,newScratchSize);
  629.         s_strncat(scratch,ES_DELIMITER_1,2L,newScratchSize);
  630.         s_strncat(scratch,esPtr,strlen(esPtr) + 1,newScratchSize); 
  631.       }
  632.       }
  633.     buf = writeString(scratch,DT_ElementSetNames,buf,len);
  634.     s_free(scratch);
  635.       }                        
  636.   buf = writeAny(query->ReferenceID,DT_ReferenceID,buf,len);
  637.     
  638.   /* go back and write the header-length-indicator */
  639.   RELEASE_HEADER_SPACE(len);
  640.   size = buf - buffer - HEADER_LEN; 
  641.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  642.  
  643.   if (query->Query != NULL)
  644.     buf = writeSearchInfo(query,buf,len);    
  645.     
  646.   return(buf);
  647. }
  648.  
  649. /*----------------------------------------------------------------------*/
  650.  
  651. char*
  652. readSearchAPDU(query,buffer)
  653. SearchAPDU** query;
  654. char* buffer;
  655. {
  656.   char* buf = buffer;
  657.   long size;
  658.   pdu_type pduType;
  659.   long small,large,medium,numItems;
  660.   boolean replace;
  661.   char *name,*databaseNames,*type,*elements;
  662.   char **dbList,**elemList;
  663.   any *refID;
  664.   void* userInfo = NULL;
  665.   
  666.   name = databaseNames = type = elements = NULL;
  667.   dbList = elemList = NULL;
  668.   refID = NULL;
  669.  
  670.   /* read required part */
  671.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  672.   buf = readPDUType(&pduType,buf);
  673.   buf = readBinaryInteger(&small,(size_t)3,buf);
  674.   buf = readBinaryInteger(&large,(size_t)3,buf);
  675.   buf = readBinaryInteger(&medium,(size_t)3,buf);
  676.   buf = readBoolean(&replace,buf);
  677.   
  678.   /* read optional part */
  679.   while (buf < (buffer + size + HEADER_LEN)) 
  680.     { data_tag tag = peekTag(buf);
  681.       switch (tag)
  682.     { case DT_ResultSetName:
  683.         buf = readString(&name,buf);
  684.         break;
  685.       case DT_DatabaseNames:
  686.         {            /* parse the database names */
  687.           char *tok;
  688.           buf = readString(&databaseNames,buf);
  689.           tok = strtok(databaseNames,DB_DELIMITER);
  690.           numItems = 0;
  691.           while (tok != NULL)
  692.         { if (dbList == NULL)
  693.             dbList = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  694.         else
  695.           dbList = (char**)s_realloc((char*)dbList,(size_t)(sizeof(char*) * (numItems+2)));
  696.             dbList[numItems++] = s_strdup(tok);
  697.             dbList[numItems] = NULL;
  698.             tok = strtok(NULL,DB_DELIMITER);
  699.           }
  700.         }
  701.         break;
  702.       case DT_QueryType:
  703.         buf = readString(&type,buf);
  704.         break;
  705.       case DT_ElementSetNames:
  706.         {            /* parse the element set names */
  707.           char *tok;
  708.           buf = readString(&elements,buf);
  709.           if (elements[0] == ES_DELIMITER_1[0]) /* this is a single element w/ no db */
  710.         { elemList = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  711.           elemList[0] = s_strdup(elements);
  712.           elemList[1] = NULL;
  713.         }
  714.           else        /* its a group of <DB/ES> pairs */
  715.         { char* esTok = NULL;
  716.           tok = strtok(elements,ES_DELIMITER_1); /* db name */
  717.           esTok = strtok(NULL,ES_DELIMITER_2); /* es name */
  718.           numItems = 0;
  719.           while (tok != NULL)
  720.             { if (elemList == NULL)
  721.             elemList = (char**)s_malloc((size_t)(sizeof(char*) * 3));
  722.             else
  723.               elemList = (char**)s_realloc((char*)elemList,(size_t)(sizeof(char*) * (numItems * 2 + 1)));
  724.             elemList[numItems++] = s_strdup(tok);
  725.             elemList[numItems++] = s_strdup(esTok);
  726.             elemList[numItems] = NULL;
  727.             tok = strtok(NULL,ES_DELIMITER_1);
  728.             esTok = strtok(NULL,ES_DELIMITER_2);
  729.               } 
  730.         }
  731.         }
  732.         break;
  733.       case DT_ReferenceID:
  734.         buf = readAny(&refID,buf);
  735.         break;
  736.       default:
  737.         s_free(name);
  738.         s_free(type);
  739.         s_free(databaseNames);
  740.         doList((void**)dbList,fs_free);
  741.         s_free(dbList);
  742.         s_free(elements);
  743.         doList((void**)elemList,fs_free);
  744.         s_free(elemList);
  745.         freeAny(refID);
  746.         REPORT_READ_ERROR(buf);
  747.         break;
  748.       }
  749.     }
  750.   
  751.   buf = readSearchInfo(&userInfo,buf);
  752.   if (buf == NULL)
  753.     { s_free(name);
  754.       s_free(type);
  755.       s_free(databaseNames);
  756.       doList((void**)dbList,fs_free);
  757.       s_free(dbList);
  758.       s_free(elements);
  759.       doList((void**)elemList,fs_free);
  760.       s_free(elemList);
  761.       freeAny(refID);
  762.     }
  763.   RETURN_ON_NULL(buf);
  764.     
  765.   /* construct the search object */
  766.   *query = makeSearchAPDU(small,large,medium,replace,name,dbList,type,elemList,refID,userInfo);
  767.  
  768.   s_free(name);
  769.   s_free(type);
  770.   s_free(databaseNames);
  771.   doList((void**)dbList,fs_free);
  772.   s_free(dbList);
  773.   s_free(elements);
  774.   doList((void**)elemList,fs_free);
  775.   s_free(elemList);
  776.   freeAny(refID);
  777.   
  778.   return(buf);
  779. }
  780.  
  781. /*----------------------------------------------------------------------*/
  782.  
  783. SearchResponseAPDU* 
  784. makeSearchResponseAPDU(result,count,recordsReturned,nextPos,resultStatus,
  785.                presentStatus,refID,records)
  786. long result;
  787. long count;
  788. long recordsReturned;
  789. long nextPos;
  790. long resultStatus;
  791. long presentStatus;
  792. any* refID;
  793. void* records;
  794. {
  795.   SearchResponseAPDU* query = (SearchResponseAPDU*)s_malloc((size_t)sizeof(SearchResponseAPDU));
  796.   query->PDUType = searchResponseAPDU;
  797.   query->SearchStatus = result;
  798.   query->ResultCount = count;
  799.   query->NumberOfRecordsReturned = recordsReturned;
  800.   query->NextResultSetPosition = nextPos;
  801.   query->ResultSetStatus = resultStatus;
  802.   query->PresentStatus = presentStatus;
  803.   query->ReferenceID = duplicateAny(refID);
  804.   query->DatabaseDiagnosticRecords = records;
  805.   return(query);  
  806. }
  807.  
  808. /*----------------------------------------------------------------------*/
  809.  
  810. void 
  811. freeSearchResponseAPDU(queryResponse)
  812. SearchResponseAPDU* queryResponse;
  813. {
  814.   freeAny(queryResponse->ReferenceID);
  815.   s_free(queryResponse);
  816. }
  817.  
  818. /*----------------------------------------------------------------------*/
  819.  
  820. char* 
  821. writeSearchResponseAPDU(queryResponse,buffer,len)
  822. SearchResponseAPDU* queryResponse;
  823. char* buffer;
  824. long* len;
  825. {
  826.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  827.   long size;
  828.  
  829.   RESERVE_SPACE_FOR_HEADER(len);
  830.   
  831.   buf = writePDUType(queryResponse->PDUType,buf,len);
  832.   buf = writeBinaryInteger(queryResponse->SearchStatus,(size_t)1,buf,len);
  833.   buf = writeBinaryInteger(queryResponse->ResultCount,(size_t)3,buf,len);
  834.   buf = writeBinaryInteger(queryResponse->NumberOfRecordsReturned,(size_t)3,buf,len);
  835.   buf = writeBinaryInteger(queryResponse->NextResultSetPosition,(size_t)3,buf,len);
  836.   buf = writeNum(queryResponse->ResultSetStatus,DT_ResultSetStatus,buf,len);
  837.   buf = writeNum(queryResponse->PresentStatus,DT_PresentStatus,buf,len);
  838.   buf = writeAny(queryResponse->ReferenceID,DT_ReferenceID,buf,len);
  839.     
  840.   /* go back and write the header-length-indicator */
  841.   RELEASE_HEADER_SPACE(len);
  842.   size = buf - buffer - HEADER_LEN; 
  843.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  844.  
  845.   if (queryResponse->DatabaseDiagnosticRecords != NULL)
  846.     buf = writeSearchResponseInfo(queryResponse,buf,len);    
  847.     
  848.   return(buf);
  849. }
  850.  
  851. /*----------------------------------------------------------------------*/
  852.  
  853. char* 
  854. readSearchResponseAPDU(queryResponse,buffer)
  855. SearchResponseAPDU** queryResponse;
  856. char* buffer;
  857. {
  858.   char* buf = buffer;
  859.   long size;
  860.   pdu_type pduType;
  861.   long result,count,recordsReturned,nextPos;
  862.   long resultStatus,presentStatus;
  863.   any *refID = NULL;
  864.   void* userInfo = NULL;
  865.   
  866.   /* read required part */
  867.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  868.   buf = readPDUType(&pduType,buf);
  869.   buf = readBinaryInteger(&result,(size_t)1,buf);
  870.   buf = readBinaryInteger(&count,(size_t)3,buf);
  871.   buf = readBinaryInteger(&recordsReturned,(size_t)3,buf);
  872.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  873.   
  874.   resultStatus = presentStatus = UNUSED;
  875.   refID = NULL;
  876.  
  877.   /* read optional part */
  878.   while (buf < (buffer + size + HEADER_LEN)) 
  879.     { data_tag tag = peekTag(buf);
  880.       switch (tag)
  881.     { case DT_ResultSetStatus:
  882.         buf = readNum(&resultStatus,buf);
  883.         break;
  884.       case DT_PresentStatus:
  885.         buf = readNum(&presentStatus,buf);
  886.         break;
  887.       case DT_ReferenceID:
  888.         buf = readAny(&refID,buf);
  889.         break;
  890.       default:
  891.         freeAny(refID);
  892.         REPORT_READ_ERROR(buf);
  893.         break;
  894.       }
  895.     }
  896.   
  897.   buf = readSearchResponseInfo(&userInfo,buf);
  898.   if (buf == NULL)
  899.     freeAny(refID);
  900.   RETURN_ON_NULL(buf);
  901.   
  902.   /* construct the search object */
  903.   *queryResponse = makeSearchResponseAPDU(result,count,recordsReturned,nextPos,
  904.                       (long)resultStatus,(long)presentStatus,refID,userInfo);
  905.  
  906.   freeAny(refID);
  907.   
  908.   return(buf);
  909. }
  910.  
  911. #ifdef NOTUSED
  912. /*----------------------------------------------------------------------*/
  913.  
  914.  
  915. PresentAPDU* 
  916. makePresentAPDU(recsReq,startPos,resultID,refID,info)
  917. long recsReq;
  918. long startPos;
  919. char* resultID;
  920. any* refID;
  921. void* info;
  922. {
  923.   PresentAPDU* present = (PresentAPDU*)s_malloc((size_t)sizeof(PresentAPDU));
  924.   present->PDUType = presentAPDU;
  925.   present->NumberOfRecordsRequested = recsReq;
  926.   present->ResultSetStartPosition = startPos;
  927.   present->ResultSetID = s_strdup(resultID);
  928.   present->ElementSetNames = NULL; /* XXX for now */
  929.   present->ReferenceID = duplicateAny(refID);
  930.   present->PresentInfo = info;
  931.   return(present);  
  932. }
  933.  
  934. /*----------------------------------------------------------------------*/
  935.  
  936. void 
  937. freePresentAPDU(present)
  938. PresentAPDU* present;
  939. {
  940.   /* handle element set names */ 
  941.   s_free(present->ResultSetID);
  942.   freeAny(present->ReferenceID);
  943.   s_free(present);
  944. }
  945.  
  946. /*----------------------------------------------------------------------*/
  947.  
  948. char* 
  949. writePresentAPDU(present,buffer,len)
  950. PresentAPDU* present;
  951. char* buffer;
  952. long* len;
  953. {
  954.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  955.   long size;
  956.  
  957.   RESERVE_SPACE_FOR_HEADER(len);
  958.   
  959.   buf = writePDUType(present->PDUType,buf,len);
  960.   buf = writeBinaryInteger(present->NumberOfRecordsRequested,(size_t)3,buf,len);
  961.   buf = writeBinaryInteger(present->ResultSetStartPosition,(size_t)3,buf,len);
  962.   buf = writeString(present->ResultSetID,DT_ResultSetID,buf,len); 
  963.   /* handle element set names */
  964.   buf = writeAny(present->ReferenceID,DT_ReferenceID,buf,len);
  965.     
  966.   /* go back and write the header-length-indicator */
  967.   RELEASE_HEADER_SPACE(len);
  968.   size = buf - buffer - HEADER_LEN; 
  969.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  970.  
  971.   if (present->PresentInfo != NULL)
  972.     buf = writePresentInfo(present,buf,len);   
  973.     
  974.   return(buf); 
  975. }
  976.  
  977. /*----------------------------------------------------------------------*/
  978.  
  979. char* 
  980. readPresentAPDU(present,buffer)
  981. PresentAPDU** present;
  982. char* buffer;
  983. {
  984.   char* buf = buffer;
  985.   long size;
  986.   pdu_type pduType;
  987.   long recsReq,startPos;
  988.   char* resultID = NULL;
  989.   any *refID = NULL;
  990.   void* userInfo = NULL;
  991.   
  992.   /* read required part */
  993.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  994.   buf = readPDUType(&pduType,buf);
  995.   buf = readBinaryInteger(&recsReq,(size_t)3,buf);
  996.   buf = readBinaryInteger(&startPos,(size_t)3,buf);
  997.   buf = readString(&resultID,buf);
  998.   
  999.   /* read optional part */
  1000.   while (buf < (buffer + size + HEADER_LEN)) 
  1001.    { data_tag tag = peekTag(buf);
  1002.      switch (tag)
  1003.       { case DT_ReferenceID:
  1004.           buf = readAny(&refID,buf);
  1005.           break;
  1006.         default:
  1007.           s_free(resultID);
  1008.           freeAny(refID);
  1009.           REPORT_READ_ERROR(buf);
  1010.           break;
  1011.       }
  1012.    }
  1013.   
  1014.   buf = readPresentInfo(&userInfo,buf);
  1015.   if (buf == NULL)
  1016.    { s_free(resultID);
  1017.      freeAny(refID);
  1018.    }
  1019.   RETURN_ON_NULL(buf);
  1020.  
  1021.   /* construct the present object */
  1022.   *present = makePresentAPDU(recsReq,startPos,resultID,refID,userInfo);
  1023.  
  1024.   s_free(resultID);
  1025.   freeAny(refID);
  1026.   
  1027.   return(buf);
  1028. }
  1029.  
  1030. /*----------------------------------------------------------------------*/
  1031.  
  1032.  
  1033. PresentResponseAPDU* 
  1034. makePresentResponseAPDU(status,recsRet,nextPos,refID,records)
  1035. boolean status;
  1036. long recsRet;
  1037. long nextPos;
  1038. any* refID;
  1039. void* records;
  1040. {
  1041.   PresentResponseAPDU* present = (PresentResponseAPDU*)s_malloc((size_t)sizeof(PresentResponseAPDU));
  1042.   present->PDUType = presentResponseAPDU;
  1043.   present->PresentStatus = status;
  1044.   present->NumberOfRecordsReturned = recsRet;
  1045.   present->NextResultSetPosition = nextPos;
  1046.   present->ReferenceID = duplicateAny(refID);
  1047.   present->DatabaseDiagnosticRecords = records;
  1048.   return(present);  
  1049. }
  1050.  
  1051. /*----------------------------------------------------------------------*/
  1052.  
  1053. void 
  1054. freePresentResponseAPDU(present)
  1055. PresentResponseAPDU* present;
  1056. { 
  1057.   freeAny(present->ReferenceID);
  1058.   s_free(present);
  1059. }
  1060.  
  1061. /*----------------------------------------------------------------------*/
  1062.  
  1063. char* 
  1064. writePresentResponseAPDU(present,buffer,len)
  1065. PresentResponseAPDU* present;
  1066. char* buffer;
  1067. long* len;
  1068. {
  1069.   char* buf = buffer + HEADER_LEN; /* leave room for the header-length-indicator */
  1070.   long size;
  1071.  
  1072.   RESERVE_SPACE_FOR_HEADER(len);
  1073.   
  1074.   buf = writePDUType(present->PDUType,buf,len);
  1075.   buf = writeBoolean(present->PresentStatus,buf,len);
  1076.   buf = writeBinaryInteger(present->NumberOfRecordsReturned,(size_t)3,buf,len);
  1077.   buf = writeBinaryInteger(present->NextResultSetPosition,(size_t)3,buf,len);
  1078.   buf = writeAny(present->ReferenceID,DT_ReferenceID,buf,len);
  1079.     
  1080.   /* go back and write the header-length-indicator */
  1081.   RELEASE_HEADER_SPACE(len);
  1082.   size = buf - buffer - HEADER_LEN; 
  1083.   writeBinaryInteger(size,HEADER_LEN,buffer,len);
  1084.  
  1085.   if (present->DatabaseDiagnosticRecords != NULL)
  1086.     buf = writePresentResponseInfo(present,buf,len);
  1087.     
  1088.   return(buf);
  1089. }
  1090.  
  1091. /*----------------------------------------------------------------------*/
  1092.  
  1093. char* 
  1094. readPresentResponseAPDU(present,buffer)
  1095. PresentResponseAPDU** present;
  1096. char* buffer;
  1097. {
  1098.   char* buf = buffer;
  1099.   long size;
  1100.   pdu_type pduType;
  1101.   boolean status;
  1102.   long recsRet,nextPos;
  1103.   any *refID = NULL;
  1104.   void* userInfo = NULL;
  1105.  
  1106.   /* read required part */
  1107.   buf = readBinaryInteger(&size,HEADER_LEN,buf); 
  1108.   buf = readPDUType(&pduType,buf);
  1109.   buf = readBoolean(&status,buf);
  1110.   buf = readBinaryInteger(&recsRet,(size_t)3,buf);
  1111.   buf = readBinaryInteger(&nextPos,(size_t)3,buf);
  1112.  
  1113.   /* read optional part */
  1114.   while (buf < (buffer + size + HEADER_LEN)) 
  1115.    { data_tag tag = peekTag(buf);
  1116.      switch (tag)
  1117.       { case DT_ReferenceID:
  1118.           buf = readAny(&refID,buf);
  1119.           break;
  1120.         default:
  1121.           freeAny(refID);
  1122.           REPORT_READ_ERROR(buf);
  1123.           break;
  1124.       }
  1125.    }
  1126.   
  1127.   buf = readPresentResponseInfo(&userInfo,buf);
  1128.   if (buf == NULL)
  1129.     freeAny(refID);
  1130.   RETURN_ON_NULL(buf);
  1131.  
  1132.   /* construct the presentResponse object */
  1133.   *present = makePresentResponseAPDU(status,recsRet,nextPos,refID,userInfo);
  1134.  
  1135.   freeAny(refID);
  1136.   
  1137.   return(buf);
  1138. }
  1139.  
  1140. /*----------------------------------------------------------------------*/
  1141.  
  1142.  
  1143. #endif /* def NOTUSED */
  1144.