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