home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / Programming / Source / WAIS / ir / ir.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  23.9 KB  |  804 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.  
  7. /*----------------------------------------------------------------------*/
  8. /* This code implements a simple Z39.50+WAIS server, which consults a 
  9.    local database using Brewster's search engine.  The main routine is
  10.    interpret_buffer() which reads the contents of a receive buffer, and 
  11.    writes results back to a send buffer.
  12.  
  13. The basic structure is:
  14.  
  15. interpret_buffer gets bytes and returns bytes from whatever transport 
  16.    mechanism. It calls either handleInit (which handles init requests)
  17.    or handleSearch.
  18.  
  19. handleSearch calls either handleRelevanceFeedbackSearch or 
  20.    handleElementRetrieval based on the type of question.
  21.  
  22. handleElementRetrieval calls getData or getDocumentText to answer that 
  23.    question.
  24.  
  25. handleRelevanceFeedbackSearch calls run_search and/or help_header to answer 
  26.    the question.
  27.  
  28.  
  29. A server must supply:
  30.   getData, getDocumentText, run_search, and help_header
  31. then it should work.
  32.  
  33.    To do:
  34.    - help facilities:
  35.      on a null query pass back random documents from the pool (?)
  36.    - Add dates to search responses
  37.  */
  38.  
  39. /* change log:
  40.  *  3/91 fixed db name defaulting for info server
  41.  *  5/31/91 fixed handleRelevanceFeedbackSearch to do search if
  42.  *          no seedwords but relevant document supplied - JG
  43.  *  5/31/91 fixed databaseName in handleElementRetrieval - HWM
  44.  *  7/19/91 fixed handleElementRetrieval prototype -BK
  45.  */
  46. /*----------------------------------------------------------------------*/
  47.  
  48. #include "ir.h"
  49. #include "wprot.h"
  50. #include "irsearch.h"
  51. #include "docid.h"
  52. #include "cutil.h"
  53. #include "irfiles.h" /* for pathname_name */
  54. #include "irretrvl.h"
  55. #include "sockets.h"  /* for connect_to_server */
  56.  
  57. #include <string.h>
  58. #include <ctype.h>
  59. #include <math.h>
  60.  
  61. #ifdef ANSI_LIKE
  62. #include <stdlib.h>
  63. #else
  64. #include "ustubs.h"
  65. #endif
  66.  
  67. static void handleInit _AP((char** recBuf,char** sendBuf,
  68.                 long* sendBufLen,
  69.                 long* maxBufLen));
  70.                        
  71. static void handleSearch _AP((char** recBuf,char** sendBuf,
  72.                   long* sendBufLen,
  73.                   long waisProtocolVersion,
  74.                   char *index_directory));
  75.  
  76. static void handleRelevanceFeedbackSearch _AP((SearchAPDU* search,
  77.                            char** sendBuf,long* sendBufLen,
  78.                            long waisProtocolVersion,
  79.                            char *index_directory));
  80.                                           
  81. static void handleElementRetrieval _AP((SearchAPDU* search,
  82.                     char** sendBuf,
  83.                     long* sendBufLen,
  84.                     long waisProtocolVersion,
  85.                     char *index_directory));
  86.                                    
  87.  
  88. /*----------------------------------------------------------------------*/
  89. /* Utility */
  90.   
  91. /*----------------------------------------------------------------------*/
  92. /* note - at present, it is not clear to me what the value of present-status
  93.    is, and how it is to be interpreted.  Furthermore, are our text retrieval
  94.    queries considered presents, or are they searches?
  95.  */
  96.  
  97.  
  98. /*----------------------------------------------------------------------*/
  99.  
  100. /* interpret_buffer()
  101. char* receiveBuffer - buffer containing data to interpret
  102. long receiveBufLen - how much data is there
  103. char* sendBuffer - buffer to write results to
  104. long sendBufLen - how much space there is to write to
  105. long* maxBufferSize - see below
  106. long waisProtocolVersion - what version of the wias protocol is in use
  107. char *index_directory - the directory to find the indexes on a search
  108.  
  109. maxBufferSize is a pointer to a per connection variable that contains the
  110. maximum size send/receive buffer to use.  Seems a lot like sendBufLen
  111. does't it.  Well it usually is, but not always.
  112.  
  113. Here is how it works from a server's point of view.  
  114.  
  115. When the client connection is first established, the server spawns a new
  116. process to deal with it.  The new process contains a global variable
  117. (bufferSize in server.c) which is initialized to BUFSZ (defined in server.c
  118. = 30000).  This is the physical size of the server's internal bufferes.
  119. Clearly that is the absolute maximum size of any z3950 message to or from
  120. this server.
  121.  
  122. So now *maxBufferSize = sendBufLen.  
  123.  
  124. Now, the first thing that a z3950 client is likely to do is send an init
  125. APDU.  The only useful thing (and it is useful) that the init APDU
  126. currently does is allow the client and server to negotiate the maxumum size
  127. of the messages that they will send.  This takes place somewhere down
  128. inside of the interpret_buffer() logic where the APDU's are decoded and
  129. response APDU's are recoded.  A pointer to bufferSize is passed to
  130. interpret_buffer() in the maxBufferSize argument, and if the buffer happens
  131. to contain an init message, bufferSize is changed (for the rest of the
  132. connection).
  133.  
  134. That is the only function maxBufferSize serves.  Note that I could have
  135. gotten rid of sendBufLen, and just used *maxBufferSize, but sendBufLen can
  136. be and does get modified by the z3950 APDU writting code, and we don't want
  137. the overall value being modified.
  138.  
  139. */
  140.  
  141. long
  142. interpret_buffer(receiveBuffer,
  143.             receiveBufLen,
  144.             sendBuffer,
  145.             sendBufLen,
  146.             maxBufferSize,
  147.             waisProtocolVersion,
  148.             index_directory)
  149. char* receiveBuffer;
  150. long receiveBufLen;
  151. char* sendBuffer;
  152. long sendBufLen;
  153. long* maxBufferSize;
  154. long waisProtocolVersion;
  155. char *index_directory;
  156. /* read & interpret receiveBuffer until receiveBufLen.  Write results into
  157.    send buffer.  Return number of bytes written - negative if there was an 
  158.    error 
  159.  */
  160. {
  161.   char* readPos = receiveBuffer;
  162.   char* writePos = sendBuffer;
  163.  
  164.   while (readPos - receiveBuffer < receiveBufLen && /* there is more to read */
  165.          writePos != NULL    /* no write error */
  166.      )
  167.     { pdu_type pdu = peekPDUType(readPos);
  168.       switch (pdu)
  169.     { case initAPDU:
  170.         handleInit(&readPos,&writePos,&sendBufLen,maxBufferSize);
  171.         break;
  172.       case searchAPDU:
  173.         handleSearch(&readPos,&writePos,&sendBufLen,
  174.              waisProtocolVersion, index_directory);
  175.         break;
  176.       default:
  177.         /* unknown APDU error */
  178.         writePos = NULL;
  179.         break;
  180.       }
  181.     }
  182.   
  183.   return(writePos - sendBuffer);
  184. }
  185.  
  186. /*----------------------------------------------------------------------*/
  187.  
  188. static void handleInit _AP((char** recBuf,char** sendBuf,
  189.                 long* sendBufLen,long* maxBufferSize));
  190.  
  191. static void
  192. handleInit(recBuf,sendBuf,sendBufLen,maxBufferSize)
  193. char** recBuf;
  194. char** sendBuf;
  195. long* sendBufLen;
  196. long* maxBufferSize;
  197. /* negotiate functionality and buffer sizes.  A session ususally begins
  198.    with one of these, but is not required to.  
  199.    NOTE - even if the server decides not to accept the client, it does
  200.    not shut down the connection.  It simply declies acceptatance, and 
  201.    waits for the client to shut down.
  202.  */
  203. {
  204.   InitAPDU* anInit = NULL;
  205.   
  206.   /* read the init - note there is no WAIS protocol extension here */
  207.   *recBuf = readInitAPDU(&anInit,*recBuf);
  208.   
  209.   if (recBuf == NULL || *recBuf == NULL)
  210.     { *sendBuf = NULL;        /* error in the read */
  211.       return;
  212.     }
  213.   else                /* respond to the init */
  214.     { InitResponseAPDU* reply = NULL;
  215.       WAISInitResponse* wais_response = NULL;
  216.       boolean connectionAccepted;
  217.      
  218.       /* negotiate services */
  219.       if (anInit->willPresent == false &&
  220.       anInit->willDelete == false)
  221.     connectionAccepted = true;
  222.       else
  223.     connectionAccepted = false;
  224.        
  225.       /* negotiate buffer sizes */
  226.       if (*maxBufferSize > anInit->MaximumRecordSize)
  227.     *maxBufferSize = anInit->MaximumRecordSize;
  228.      
  229.       if(anInit->IDAuthentication != NULL)
  230.     waislog(WLOG_LOW, WLOG_INFO, "Init message: %s", 
  231.         anInit->IDAuthentication);
  232.  
  233.       /* not much use huh? */
  234.       wais_response = makeWAISInitResponse(0L,0L,NULL,NULL,NULL,NULL); 
  235.      
  236.       reply = makeInitResponseAPDU(connectionAccepted,
  237.                    true,false,false,false,false,*maxBufferSize,
  238.                    *maxBufferSize,NULL,
  239.                    defaultImplementationID(),
  240.                    defaultImplementationName(),
  241.                    defaultImplementationVersion(),NULL,
  242.                    wais_response);
  243.  
  244.       /* write it */
  245.       *sendBuf = writeInitResponseAPDU(reply,*sendBuf,sendBufLen);
  246.      
  247.       /* free everything */
  248.       freeInitAPDU(anInit);
  249.       freeInitResponseAPDU(reply);
  250.       freeWAISInitResponse(wais_response);
  251.     }
  252. }
  253.  
  254.  
  255. /*----------------------------------------------------------------------*/
  256. static boolean
  257. isRemoteDB(db)
  258. char * db;
  259. {
  260.   return(strchr(db,'@') != NULL);
  261. }
  262.  
  263. /*----------------------------------------------------------------------*/
  264. #include "wmessage.h"
  265.  
  266. struct {
  267.   char host[256];
  268.   long port;
  269.   FILE *connection;
  270. } last_connection;
  271.  
  272. static void
  273. forwardSearch(aSearch,sendBuf,sendBufLen,waisProtocolVersion)
  274. SearchAPDU* aSearch;
  275. char** sendBuf;
  276. long* sendBufLen;
  277. long waisProtocolVersion;
  278. {
  279.   FILE *connection;
  280.   char hostname[1000], db[1000], *p, *p2;
  281.   long port, len, rlen;
  282.   char message[30000], response[30000];
  283.  
  284.   p = strchr(aSearch->DatabaseNames[0], '@');
  285.   strncpy(db, aSearch->DatabaseNames[0], p-aSearch->DatabaseNames[0]);
  286.   db[p-aSearch->DatabaseNames[0]] = 0;
  287.   p2 = strchr(p+1, ':');
  288.   if(p2 == NULL) {
  289.     strcpy(hostname, p+1);
  290.     port = 210;
  291.   }
  292.   else {
  293.     strncpy(hostname, p+1, p2-(p+1));
  294.     hostname[p2-(p+1)] = 0;
  295.     port = atoi(p2+1);
  296.   }
  297.  
  298.   strcpy(aSearch->DatabaseNames[0], db);
  299.   rlen = len = 30000;
  300.   writeSearchAPDU(aSearch, message+HEADER_LENGTH, &len);
  301.   len = 30000-len;
  302.   if(hostname[0] != 0) {
  303.     if(strcmp(hostname, last_connection.host) == 0 &&
  304.        port == last_connection.port)
  305.       connection = last_connection.connection;
  306.     else {
  307.       if (last_connection.connection != NULL)
  308.     close_connection(last_connection.connection);
  309.       strcpy(last_connection.host, hostname);
  310.       last_connection.port = port;
  311.       last_connection.connection = (FILE*)connect_to_server(hostname, port);
  312.       connection = last_connection.connection;
  313.       if(connection != NULL) {
  314.     char userInfo[500], hostname[80], init_message[1000];
  315.  
  316.     gethostname(hostname, 80);
  317. #ifdef TELL_USER
  318.     sprintf(userInfo, "server forwarding %s, from host: %s, user: %s",
  319.         VERSION, hostname, getenv("USER"));
  320. #else
  321.     sprintf(userInfo, "server forwarding %s, from host: %s", VERSION, hostname);
  322. #endif
  323.  
  324.     init_connection(init_message, response,
  325.             1000L,
  326.             connection,
  327.             userInfo);
  328.       }
  329.     }
  330.     if(connection != NULL)
  331.       {
  332.     len = interpret_message(message, len,
  333.                 response, rlen,
  334.                 connection, false);
  335.       }
  336.     else {
  337.       static diagnosticRecord* diags[2] = {NULL, NULL};
  338.       SearchResponseAPDU* response = NULL;
  339.       WAISSearchResponse* wais_response = NULL;
  340.       char message[255];
  341.  
  342.       sprintf(message, "Database not available: %s@%s:%d.",
  343.           db, last_connection.host, last_connection.port);
  344.       diags[0] = makeDiag(true,D_RecordNotAuthorizedToBeSent,
  345.               message);
  346.  
  347.       wais_response = makeWAISSearchResponse(NULL,NULL,NULL,
  348.                          NULL,NULL,NULL,NULL,diags);
  349.       response = makeSearchResponseAPDU(0L,0L,
  350.                     1L,
  351.                     0L,UNUSED,FAILURE,
  352.                     aSearch->ReferenceID, wais_response);
  353.       *sendBuf = writeSearchResponseAPDU(response,*sendBuf,sendBufLen);
  354.  
  355.       freeSearchResponseAPDU(response);
  356.       freeWAISSearchResponse(wais_response);
  357.       waislog(WLOG_HIGH, WLOG_ERROR, message);
  358.       return;
  359.     }
  360.   }
  361.   else
  362.     len = interpret_message(message, len,
  363.                 response, rlen,
  364.                 NULL, false);
  365.   bcopy(response+HEADER_LENGTH, *sendBuf, len);
  366.   *sendBuf+=len;
  367. }
  368.  
  369. /*----------------------------------------------------------------------*/
  370.  
  371. static void handleSearch _AP((char** recBuf,char** sendBuf,
  372.                   long* sendBufLen,long waisProtocolVersion,
  373.                   char *index_directory));
  374.  
  375. static void
  376. handleSearch(recBuf,sendBuf,sendBufLen,waisProtocolVersion,index_directory)
  377. char** recBuf;
  378. char** sendBuf;
  379. long* sendBufLen;
  380. long waisProtocolVersion;
  381. char *index_directory;
  382. /* figure out what kind of search this is, (query or retrieval) and
  383.    dispatch to the appropriate function 
  384.  */
  385. {
  386.   SearchAPDU* aSearch = NULL;
  387.  
  388.   /* read the search data */
  389.   *recBuf = readSearchAPDU(&aSearch,*recBuf);
  390.  
  391.   if (*recBuf == NULL)
  392.     { *sendBuf = NULL;        /* error in the read */
  393.       return;
  394.     }
  395.   else
  396.     {                /* dispatch on the query type */
  397.       if((aSearch->DatabaseNames != NULL) &&
  398.      (aSearch->DatabaseNames[0] != NULL) &&
  399.      isRemoteDB(aSearch->DatabaseNames[0]))
  400.     forwardSearch(aSearch,sendBuf,sendBufLen,waisProtocolVersion);
  401.       else {
  402.     if (strcmp(aSearch->QueryType,QT_TextRetrievalQuery) == 0) {
  403.       handleElementRetrieval(aSearch,sendBuf,sendBufLen,
  404.                  waisProtocolVersion, index_directory);
  405.     }
  406.     else if (strcmp(aSearch->QueryType,QT_RelevanceFeedbackQuery) == 0) {
  407.       char *seeds, *s;
  408.  
  409.       s = seeds = s_strdup(((WAISSearch *)aSearch->Query)->SeedWords);
  410.       while(*s != 0) {
  411.         if(*s == '\n' || *s == '\r') *s = ' ';
  412.         s++;
  413.       }
  414.  
  415.       if(aSearch->DatabaseNames != NULL &&
  416.          aSearch->DatabaseNames[0] != NULL)
  417.         waislog(WLOG_LOW, WLOG_SEARCH,
  418.             "Search! Database: %s, Seed Words: %s", 
  419.             aSearch->DatabaseNames[0], 
  420.             seeds);
  421.       else
  422.         waislog(WLOG_LOW, WLOG_SEARCH, 
  423.             "Search! Database: None, Seed Words: %s", 
  424.             seeds);
  425.  
  426.       handleRelevanceFeedbackSearch(aSearch,sendBuf,sendBufLen,
  427.                     waisProtocolVersion,
  428.                     index_directory);
  429.     }
  430.     else {
  431.       waislog(WLOG_HIGH, WLOG_ERROR, "Unknown search type");
  432.       *sendBuf = NULL;    /* error - unknown search type */
  433.     }
  434.     fflush(stderr);
  435.       }
  436.     }
  437. }
  438.  
  439.  
  440.      
  441.  
  442. /*----------------------------------------------------------------------*/
  443.  
  444. static boolean needs_help _AP ((char *question));
  445.  
  446. static boolean needs_help(question)
  447. char *question;
  448. /* returns true if the user wants help */
  449. {
  450.   if(question[0] == '\0')  /* null question, must need help */
  451.     return(true);
  452.   if(question[0] == '?')
  453.     return(true);
  454.   if(strlen(question) < 20){
  455.     if((NULL != strstr(question, "help")) ||
  456.        (NULL != strstr(question, "HELP")) ||
  457.        (NULL != strstr(question, "Help"))){
  458.       return(true);
  459.     }      
  460.   }
  461.   return(false);
  462. }
  463.  
  464. /* returns a help header to be returned or NULL if not possible */
  465. static WAISDocumentHeader *help_header _AP((char *database_name, 
  466.                         char *index_directory));
  467. static WAISDocumentHeader *help_header(database_name, index_directory)
  468.      char *database_name;
  469.      char *index_directory;
  470. {
  471.   /* make a help document */
  472.   hit help;
  473.   char local_id[MAX_FILENAME_LEN + 60];
  474.  
  475.   strncpy(help.filename,
  476.       merge_pathnames(database_name,index_directory), 
  477.       MAX_FILENAME_LEN);
  478.   strncat(help.filename, source_ext, MAX_FILENAME_LEN);
  479.   /* printf("help filename %s", help.filename); */
  480.  
  481.   strncpy(help.headline, "Information on database: ", MAX_FILENAME_LEN);
  482.   strncat(help.headline, pathname_name(database_name), 
  483.       MAX_FILENAME_LEN);
  484.   sprintf(local_id, "%ld %ld %s", 0L, 0L, help.filename);
  485.  
  486.   if(probe_file(help.filename))
  487.     { 
  488.       DocID* theDocID = NULL;
  489.       long length;
  490.       long lines;
  491.       char **type = NULL;
  492.  
  493.       help.start_character = 0;
  494.       help.end_character = 0;
  495.     
  496.       { FILE *stream = s_fopen(help.filename, "r");
  497.     lines = count_lines(stream);
  498.     length = file_length(stream);
  499.         s_fclose(stream);
  500.       }
  501.  
  502.       type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  503.       type[0] = s_strdup("WSRC");
  504.       type[1] = NULL;
  505.  
  506.       /* then there is a source structure to return */
  507.       theDocID = makeDocID();
  508.       theDocID->originalDatabase = stringToAny(database_name); /* XXX */
  509.       theDocID->originalLocalID = stringToAny(local_id);
  510.  
  511.       return(makeWAISDocumentHeader(anyFromDocID(theDocID),
  512.                     UNUSED,
  513.                     MAX_NORMAL_SCORE,
  514.                     UNUSED,
  515.                     length,lines,
  516.                     type,
  517.                     s_strdup(database_name), /* XXX */
  518.                     NULL, /* date */
  519.                     s_strdup(help.headline),
  520.                     NULL));
  521.     }    
  522.   else 
  523.     return(NULL);
  524. }
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531. /* picks a set of random documents from the database 
  532. static void pick_random_documents(aSearch, headers, &headerNum)
  533. {
  534.   
  535. }
  536. */
  537.  
  538.  
  539. /*----------------------------------------------------------------------*/
  540.  
  541. static void handleRelevanceFeedbackSearch 
  542.   _AP((SearchAPDU* aSearch,char** sendBuf,long* sendBufLen,
  543.        long waisProtocolVersion,
  544.        char *index_directory));
  545.  
  546. static void
  547. handleRelevanceFeedbackSearch(aSearch,sendBuf,sendBufLen,
  548.                   waisProtocolVersion,
  549.                   index_directory)
  550. SearchAPDU* aSearch;
  551. char** sendBuf;
  552. long* sendBufLen;
  553. long waisProtocolVersion;
  554. char *index_directory;
  555. { 
  556.   SearchResponseAPDU* response = NULL;
  557.   WAISSearchResponse* wais_response = NULL;
  558.  
  559.   WAISDocumentHeader** headers = NULL;
  560.   long headerNum = 0;
  561.   char* seedwords_used = NULL;
  562.   diagnosticRecord** diags = NULL;
  563.   char *seed_words_used = s_strdup(((WAISSearch *)aSearch->Query)->SeedWords);
  564.   boolean search_status;
  565.  
  566.   /* construct a response list */
  567.   headers = (WAISDocumentHeader**)
  568.     s_malloc((size_t)
  569.          (sizeof(WAISDocumentHeader*) * 
  570.           (1 + (unsigned long)
  571.            ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved)));
  572.   headers[0] = NULL;
  573.   
  574.   /* handle help queries */
  575.   if(needs_help(seed_words_used)){
  576.     char *database_name = (aSearch->DatabaseNames == NULL) ?
  577.       INFO_DATABASE_NAME : aSearch->DatabaseNames[0];
  578.  
  579.     WAISDocumentHeader *header = help_header(database_name, index_directory);
  580.     if(NULL != header){
  581.       headers[headerNum++] = header;
  582.       headers[headerNum] = NULL;    
  583.     }
  584.   }  
  585.   if(seed_words_used[0] == '\0' &&
  586.      ((WAISSearch *)aSearch->Query)->Docs == NULL){
  587.     /* pick_random_documents(aSearch, headers, &headerNum); */
  588.   }
  589.   else
  590.     /* run the search on the database.  If a new
  591.        search engine were to be used, this is where it would be hooked in */
  592.     search_status = run_search(aSearch, headers,&diags, index_directory, 
  593.                    &seed_words_used, waisProtocolVersion,
  594.                    &headerNum);
  595.  
  596.   { /* generate report on results. */
  597.     char *message;
  598.     long size, i;
  599.  
  600.     /* calculate total length needed for log report */
  601.     for(size = 0L, i = 0; i < headerNum; i++) 
  602.       size+=(headers[i]->DocumentID->size+2);
  603.     if (size > 0) {
  604.       message = s_malloc(size);
  605.       message[0] = 0;
  606.  
  607.       for (i = 0; i < headerNum; i++) {
  608.     char docname[MAX_FILE_NAME_LEN+50];
  609.     sprintf(docname, "%s", 
  610.         anyToString(GetLocalID(docIDFromAny(headers[i]->DocumentID))));
  611.     s_strncat(message, docname, headers[i]->DocumentID->size, size);
  612.     if ( i < headerNum-1)
  613.       strcat(message, ", ");
  614.       }
  615.       waislog(WLOG_LOW, WLOG_RESULTS,
  616.           "Returned %d results: %s", headerNum, message);
  617.       s_free(message);
  618.     }
  619.     else
  620.       waislog(WLOG_LOW, WLOG_RESULTS,
  621.           "Returned 0 results.  Aww.");
  622.   }    
  623.   wais_response = makeWAISSearchResponse(seedwords_used,headers,NULL,
  624.                                          NULL,NULL,NULL,NULL,diags);
  625.   response = makeSearchResponseAPDU(search_status,0L,
  626.                     headerNum + ((diags == NULL) ? 0 : 1),
  627.                     0L,UNUSED,SUCCESS,
  628.                                     aSearch->ReferenceID, wais_response);
  629.   
  630.   /* write it */
  631.   *sendBuf = writeSearchResponseAPDU(response,*sendBuf,sendBufLen);
  632.  
  633.   freeWAISSearch((WAISSearch*)aSearch->Query); 
  634.   freeSearchAPDU(aSearch);
  635.   freeSearchResponseAPDU(response);
  636.   freeWAISSearchResponse(wais_response); /* free headers & seed_words_used */
  637. }
  638.  
  639. /*----------------------------------------------------------------------*/
  640.  
  641. /* this is defined above  -brewster
  642. static void handleElementRetrieval
  643.   _AP((SearchAPDU* aSearch,char** sendBuf,long* sendBufLen,
  644.        long waisProtocolVersion));
  645. */
  646.  
  647. static void 
  648. handleElementRetrieval(aSearch,sendBuf,sendBufLen,waisProtocolVersion, index_directory)
  649. SearchAPDU* aSearch;
  650. char** sendBuf;
  651. long* sendBufLen;
  652. long waisProtocolVersion;
  653. char *index_directory;
  654. /* this is a type 1 query of the restricted form specified in the 
  655.    WAIS-protocol.  Interpret it and write out an appropriate search
  656.    response. (note the valid element sets are Document-Text,Document-Headlines,
  657.    and Document-Codes but we only support text for now).
  658.  */
  659. { 
  660.   SearchResponseAPDU* response = NULL;
  661.   WAISSearchResponse* wais_response = NULL;
  662.   DocObj** docs = NULL;
  663.   DocObj* doc = NULL;
  664.   char *databaseName;
  665.   void **elementList = NULL;
  666.   void *element = NULL;
  667.   diagnosticRecord** diags = NULL;
  668.   diagnosticRecord* diag = NULL;
  669.   long numDiags = 0L;
  670.   long numElements = 0L;
  671.   long i;
  672.   database* db;
  673.   char* new_db_name;
  674.   
  675.   /* read the query */
  676.   docs = readWAISTextQuery((any*)aSearch->Query);
  677.   databaseName = (aSearch->DatabaseNames == NULL) ?
  678.     INFO_DATABASE_NAME : aSearch->DatabaseNames[0];
  679.  
  680.   new_db_name = merge_pathnames(databaseName, index_directory);
  681.  
  682.   /* assemble the elements and construct a response */
  683.   for (i = 0L, doc = docs[i]; doc != NULL; doc = docs[++i])
  684.    { 
  685.      long errorCode;
  686.      any* bufAny;
  687.      long size;
  688.  
  689.      if (doc->Type != NULL &&
  690.      strcmp(doc->Type, "WAIS_NEXT") == 0) {
  691.        char docname[MAX_FILE_NAME_LEN+50], *buffer;
  692.  
  693.        db = openDatabase(new_db_name, false, true);
  694.        if ((size = 
  695.         next_doc(docname, 
  696.              anyToString(GetLocalID(docIDFromAny(doc->DocumentID))),
  697.              db))
  698.        > 0) {
  699.      buffer = s_malloc(strlen(docname)+50);
  700.      sprintf(buffer, "%s, %d", docname, size);
  701.      bufAny = makeAny(strlen(buffer)+1,buffer);
  702.      element = (void*)makeWAISDocumentText(duplicateAny(doc->DocumentID),0L,bufAny);
  703.        }
  704.        else element = NULL;
  705.        closeDatabase(db);
  706.      }
  707.      else if (doc->Type != NULL &&
  708.           strcmp(doc->Type, "WAIS_PREV") == 0) {
  709.        char docname[MAX_FILE_NAME_LEN+50], *buffer;
  710.        any* bufAny;
  711.        long size;
  712.  
  713.        db = openDatabase(new_db_name, false, true);
  714.        if ((size = 
  715.         previous_doc(docname, 
  716.              anyToString(GetLocalID(docIDFromAny(doc->DocumentID))),
  717.              db))
  718.        > 0) {
  719.      buffer = s_malloc(strlen(docname)+50);
  720.      sprintf(buffer, "%s, %d", docname, size);
  721.      bufAny = makeAny(strlen(buffer),buffer);
  722.      element = (void*)makeWAISDocumentText(duplicateAny(doc->DocumentID),0L,bufAny);
  723.        }
  724.        else element = NULL;
  725.        closeDatabase(db);
  726.      }
  727.      else if (doc->ChunkCode == CT_line)
  728.        element = (void*)getDocumentText(doc, databaseName, &errorCode);
  729.      else if (doc->ChunkCode == CT_byte)
  730.        element = (void*)getData(doc, databaseName, &errorCode);
  731.  
  732.      if (element == NULL)
  733.        {            /* make a diagnostic record to return */
  734.      switch (errorCode)
  735.        { case GDT_UnsupportedChunkType:
  736.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  737.                    "Bad ChunkType in Request");
  738.            break;
  739.          case GDT_BadDocID:
  740.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  741.                    "Bad DocID in request");
  742.            break;
  743.          case GDT_MissingDocID:
  744.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  745.                    "Missing DocID in request");
  746.            break;
  747.          case GDT_BadRange:
  748.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  749.                    "Request out of range");
  750.            break;
  751.          case GDT_MissingDatabase:
  752.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  753.                    "Database missing from request");
  754.            break;
  755.          case GDT_BadDatabase:
  756.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  757.                    "File not present in specified database");
  758.            break;
  759.          default:
  760.            /* should never get here */
  761.            diag = NULL;
  762.            break;
  763.          };
  764.      diags = (diagnosticRecord**)s_realloc(diags,(size_t)(sizeof(diagnosticRecord*) * 
  765.                                   (numDiags + 2)));
  766.      diags[numDiags++] = diag;
  767.      diags[numDiags] = NULL;
  768.        }
  769.      else 
  770.        { if (elementList == NULL) /* create a list */
  771.        { elementList = (void**)s_malloc((size_t)sizeof(void*) * 2);
  772.        }
  773.        else            /* grow the list */
  774.      { elementList = (void**)s_realloc((char*)elementList,
  775.                        (size_t)(sizeof(void*) * 
  776.                             (numElements + 2)));
  777.      }
  778.        elementList[numElements++] = element; /* put it in the list */
  779.        elementList[numElements] = NULL;
  780.        }
  781.    }
  782.  
  783.   wais_response = makeWAISSearchResponse(NULL,NULL,NULL,NULL,
  784.                                          (WAISDocumentText**)elementList,NULL,
  785.                                          NULL,diags);
  786.   response = makeSearchResponseAPDU(SUCCESS,0L,numElements + numDiags,0L,UNUSED,
  787.                                     SUCCESS,aSearch->ReferenceID,
  788.                     wais_response);
  789.   
  790.   /* write it */
  791.   *sendBuf = writeSearchResponseAPDU(response,*sendBuf,sendBufLen);
  792.   
  793.   /* clean up */
  794.   freeAny((any*)aSearch->Query); /* have to explicitly free the user info */
  795.   freeSearchAPDU(aSearch);
  796.   freeSearchResponseAPDU(response);
  797.   freeWAISSearchResponse(wais_response); /* frees the elements constructed */
  798.   doList((void**)docs,freeDocObj);
  799.   s_free(docs);  
  800. }
  801.  
  802. /*----------------------------------------------------------------------*/
  803.  
  804.