home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / ir.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-13  |  49.3 KB  |  1,697 lines
  1.  
  2. /* Copyright (c) CNIDR (Work in progress) */
  3.  
  4. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  5.    No guarantees or restrictions.  See the readme file for the full standard
  6.    disclaimer.    
  7.   
  8. */
  9.  
  10. /* Change log:
  11.  * $Log: ir.c,v $
  12.  * Revision 1.13  1994/12/13  18:52:45  pfeifer
  13.  * chip@chinacat.unicom.com (Chip Rosenthal) patches.
  14.  * Excluding the merge of libinv and libwais
  15.  *
  16.  * Revision 1.12  1994/08/15  16:17:50  pfeifer
  17.  * fixed unchecked usage of getenv("USER") in printf
  18.  *
  19.  * Revision 1.11  1994/08/05  07:12:05  pfeifer
  20.  * Release beta 04
  21.  *
  22.  * Revision 1.10  1994/04/29  23:23:23  pfeifer
  23.  * Fixed getwd insted of getcwd
  24.  * ifdef'ed alphasort for gcc 2.4.3
  25.  *
  26.  * Revision 1.9  1994/04/06  23:50:22  pfeifer
  27.  * 08
  28.  *
  29.  * Revision 1.8  1994/03/21  17:29:49  huynh1
  30.  * openDatabase modified.
  31.  * Patchlevel 07.
  32.  *
  33.  * Revision 1.7  1994/03/08  20:55:03  pfeifer
  34.  * Patchlevel 04
  35.  *
  36.  * Revision 1.6  93/07/23  02:18:37  warnock
  37.  * eliminated extra argument in call to probe_file in server_security
  38.  * 
  39.  * Revision 1.5  93/07/02  17:49:54  warnock
  40.  * drop-in replacement for handleElementRetrieval from francois
  41.  * 
  42.  * Revision 1.4  93/07/01  20:33:57  warnock
  43.  * Drop-in replacement for server_security routine
  44.  * 
  45.  * Revision 1.3  93/07/01  19:16:39  warnock
  46.  * gethostname -> mygethostname
  47.  * 
  48.  * Revision 1.2  93/07/01  19:01:13  warnock
  49.  * Fix from tovio@sage.ucs.uwa.edu.au when database name array was empty
  50.  * This is Francois' drop-in replacement for ir.c
  51.  * 
  52.  * Revision 1.1  1993/02/16  15:05:35  freewais
  53.  * Initial revision
  54.  *
  55.  * Revision 1.49  92/05/10  14:43:35  jonathan
  56.  * Made a little safer on NULL docid's when parsing.
  57.  * 
  58.  * Revision 1.48  92/05/05  14:56:33  jonathan
  59.  * Added definition of S_ISDIR for Mach and NeXT.  Fixed isdoctype macro to
  60.  * check for NULLs.
  61.  * 
  62.  * Revision 1.47  92/05/04  11:28:26  jonathan
  63.  * Changed logging result list to use log_level a little better.
  64.  * 
  65.  * Revision 1.46  92/04/30  12:24:45  jonathan
  66.  * split =* for ULTRIX CC.
  67.  * changed a couple of s_free's to free's for ULTRIX CC too.
  68.  * 
  69.  * Revision 1.45  92/04/01  17:08:14  jonathan
  70.  * Added code to handle FTP-like searches.
  71.  * 
  72.  * Revision 1.44  92/03/23  13:25:22  shen
  73.  * only print out the number of the results but not the message in the log
  74.  * 
  75.  * Revision 1.43  92/03/18  08:55:45  jonathan
  76.  * Removed databaseName argument to getDocumentText and getData.
  77.  * 
  78.  * Revision 1.42  92/03/05  07:07:20  shen
  79.  * add two more dummy arguments to call to init_search_engine
  80.  * 
  81.  * Revision 1.41  92/02/23  10:37:53  jonathan
  82.  * enforced limit on results in handleRelevanceFeedbackSearch (particularly
  83.  * for handline help queries).
  84.  * 
  85.  * Revision 1.40  92/02/23  09:57:57  jonathan
  86.  * Prevent return of help messages if query is empty but there are relevant
  87.  * documents.
  88.  * 
  89.  * Revision 1.39  92/02/21  11:07:25  jonathan
  90.  * Added RCSIdent.
  91.  * 
  92.  * Revision 1.38  92/02/21  11:00:10  jonathan
  93.  * Changed logging of init message to WLOG_MEDIUM.
  94.  * 
  95.  * Revision 1.37  92/02/19  16:56:48  jonathan
  96.  * mucked a bit with the no-results case.
  97.  * 
  98.  * Revision 1.36  92/02/19  13:55:22  jonathan
  99.  * Return catalog as result if no hits to search.
  100.  * Plug some more memory leaks.
  101.  * 
  102.  * Revision 1.35  92/02/19  10:39:27  jonathan
  103.  * Off by one in last fix (headerNum>=0).  Fixed it.
  104.  * 
  105.  * Revision 1.34  92/02/19  10:16:04  jonathan
  106.  * Added code to handle too many headers for buffer.  Reduces the number of
  107.  * headers until they fit, and marks the log with a warning.
  108.  * 
  109.  * Revision 1.33  92/02/17  12:40:04  jonathan
  110.  * Return catalog as well as source description for help queries.
  111.  * 
  112.  * 
  113.  * Revision 1.32  92/02/12  13:20:49  jonathan
  114.  * Added "$Log" so RCS will put the log message in the header
  115.  * 
  116. */
  117.  
  118. #ifndef lint
  119. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-sf/ir/RCS/ir.c,v 1.13 1994/12/13 18:52:45 pfeifer Exp $";
  120. #endif
  121.  
  122. /*----------------------------------------------------------------------*/
  123. /* This code implements a simple Z39.50+WAIS server, which consults a 
  124.    local database using Brewster's search engine.  The main routine is
  125.    interpret_buffer() which reads the contents of a receive buffer, and 
  126.    writes results back to a send buffer.
  127.  
  128. The basic structure is:
  129.  
  130. interpret_buffer gets bytes and returns bytes from whatever transport 
  131.    mechanism. It calls either handleInit (which handles init requests)
  132.    or handleSearch.
  133.  
  134. handleSearch calls either handleRelevanceFeedbackSearch or 
  135.    handleElementRetrieval based on the type of question.
  136.  
  137. handleElementRetrieval calls getData or getDocumentText to answer that 
  138.    question.
  139.  
  140. handleRelevanceFeedbackSearch calls run_search and/or help_header to answer 
  141.    the question.
  142.  
  143.  
  144. A server must supply:
  145.   getData, getDocumentText, run_search, and help_header
  146. then it should work.
  147.  
  148.    To do:
  149.    - help facilities:
  150.      on a null query pass back random documents from the pool (?)
  151.    - Add dates to search responses
  152.  */
  153.  
  154. /* change log:
  155.  *  3/91 fixed db name defaulting for info server
  156.  *  5/31/91 fixed handleRelevanceFeedbackSearch to do search if
  157.  *          no seedwords but relevant document supplied - JG
  158.  *  5/31/91 fixed databaseName in handleElementRetrieval - HWM
  159.  *  7/19/91 fixed handleElementRetrieval prototype -BK
  160.  */
  161. /*----------------------------------------------------------------------*/
  162.  
  163. #include "server.h"
  164. #include "ir.h"
  165. #include "wprot.h"
  166. #include "irsearch.h"
  167. #include "docid.h"
  168. #include "cutil.h"
  169. #include "irfiles.h" /* for pathname_name */
  170. #include "irretrvl.h"
  171. #include "sockets.h"  /* for connect_to_server */
  172. #include "panic.h"
  173.  
  174. #include <ctype.h>
  175. /*
  176. #include <string.h>
  177. #include <math.h>
  178.  
  179. #ifdef ANSI_LIKE
  180. #include <stdlib.h>
  181. #else
  182. #include "ustubs.h"
  183. #endif
  184. */
  185. #include <sys/stat.h>
  186. #include "irdirent.h"
  187.  
  188. /* forward declarations */
  189.  
  190. static boolean needs_help _AP ((char *question));
  191.  
  192. static WAISDocumentHeader *help_header _AP((char *database_name, 
  193.                         char *index_directory));
  194.  
  195. static WAISDocumentHeader *catalog_header _AP((char *database_name, 
  196.                            char *index_directory,
  197.                            boolean results));
  198.  
  199. static void handleInit _AP((char** recBuf,char** sendBuf,
  200.                 long* sendBufLen,
  201.                 long* maxBufLen));
  202.                        
  203. static void handleSearch _AP((char** recBuf,char** sendBuf,
  204.                   long* sendBufLen,
  205.                   long waisProtocolVersion,
  206.                   char *index_directory));
  207.  
  208. static void handleRelevanceFeedbackSearch _AP((SearchAPDU* search,
  209.                            char** sendBuf,long* sendBufLen,
  210.                            long waisProtocolVersion,
  211.                            char *index_directory));
  212.                                           
  213. static void handleElementRetrieval _AP((SearchAPDU* search,
  214.                     char** sendBuf,
  215.                     long* sendBufLen,
  216.                     long waisProtocolVersion,
  217.                     char *index_directory));
  218.                                    
  219. static void handleFTPSearch _AP((SearchAPDU* search,
  220.                  char** sendBuf,long* sendBufLen,
  221.                  long waisProtocolVersion,
  222.                  char *index_directory));
  223.  
  224. boolean server_security _AP((char *index_directory, char *database_name));
  225.  
  226. #define isdoctype(doc, doctype) \
  227.  (((doc) != NULL) && \
  228.  ((doc)->Type != NULL) && \
  229.  !strcmp((doc)->Type, doctype))
  230.  
  231. #ifdef Mach
  232. #include <sys/inode.h>
  233. #endif /* Mach */
  234.  
  235. /* francois */
  236. #ifndef S_ISDIR
  237. #define S_ISDIR(f_mode) ((f_mode & S_IFMT) == S_IFDIR)
  238. #endif
  239.  
  240. /*----------------------------------------------------------------------*/
  241. /* Utility */
  242.   
  243. /*----------------------------------------------------------------------*/
  244. /* note - at present, it is not clear to me what the value of present-status
  245.    is, and how it is to be interpreted.  Furthermore, are our text retrieval
  246.    queries considered presents, or are they searches?
  247.  */
  248.  
  249.  
  250. /*----------------------------------------------------------------------*/
  251.  
  252. /* interpret_buffer()
  253. char* receiveBuffer - buffer containing data to interpret
  254. long receiveBufLen - how much data is there
  255. char* sendBuffer - buffer to write results to
  256. long sendBufLen - how much space there is to write to
  257. long* maxBufferSize - see below
  258. long waisProtocolVersion - what version of the wias protocol is in use
  259. char *index_directory - the directory to find the indexes on a search
  260.  
  261. maxBufferSize is a pointer to a per connection variable that contains the
  262. maximum size send/receive buffer to use.  Seems a lot like sendBufLen
  263. does't it.  Well it usually is, but not always.
  264.  
  265. Here is how it works from a server's point of view.  
  266.  
  267. When the client connection is first established, the server spawns a new
  268. process to deal with it.  The new process contains a global variable
  269. (bufferSize in server.c) which is initialized to BUFSZ (defined in server.h).
  270. This is the physical size of the server's internal bufferes.
  271. Clearly that is the absolute maximum size of any z3950 message to or from
  272. this server.
  273.  
  274. So now *maxBufferSize = sendBufLen.  
  275.  
  276. Now, the first thing that a z3950 client is likely to do is send an init
  277. APDU.  The only useful thing (and it is useful) that the init APDU
  278. currently does is allow the client and server to negotiate the maxumum size
  279. of the messages that they will send.  This takes place somewhere down
  280. inside of the interpret_buffer() logic where the APDU's are decoded and
  281. response APDU's are recoded.  A pointer to bufferSize is passed to
  282. interpret_buffer() in the maxBufferSize argument, and if the buffer happens
  283. to contain an init message, bufferSize is changed (for the rest of the
  284. connection).
  285.  
  286. That is the only function maxBufferSize serves.  Note that I could have
  287. gotten rid of sendBufLen, and just used *maxBufferSize, but sendBufLen can
  288. be and does get modified by the z3950 APDU writting code, and we don't want
  289. the overall value being modified.
  290.  
  291. */
  292.  
  293. long
  294. interpret_buffer(receiveBuffer,
  295.             receiveBufLen,
  296.             sendBuffer,
  297.             sendBufLen,
  298.             maxBufferSize,
  299.             waisProtocolVersion,
  300.             index_directory)
  301. char* receiveBuffer;
  302. long receiveBufLen;
  303. char* sendBuffer;
  304. long sendBufLen;
  305. long* maxBufferSize;
  306. long waisProtocolVersion;
  307. char *index_directory;
  308. /* read & interpret receiveBuffer until receiveBufLen.  Write results into
  309.    send buffer.  Return number of bytes written - negative if there was an 
  310.    error 
  311.  */
  312. {
  313.   char* readPos = receiveBuffer;
  314.   char* writePos = sendBuffer;
  315.  
  316.   while (readPos - receiveBuffer < receiveBufLen && /* there is more to read */
  317.          writePos != NULL    /* no write error */
  318.      )
  319.     { pdu_type pdu = peekPDUType(readPos);
  320.       switch (pdu)
  321.     { case initAPDU:
  322.         handleInit(&readPos,&writePos,&sendBufLen,maxBufferSize);
  323.         break;
  324.       case searchAPDU:
  325.         handleSearch(&readPos,&writePos,&sendBufLen,
  326.              waisProtocolVersion, index_directory);
  327.         break;
  328.       default:
  329.         /* unknown APDU error */
  330.         writePos = NULL;
  331.         waislog(WLOG_HIGH, WLOG_ERROR,
  332.             "Error in interpret_message: unknown APDU type.");
  333.         break;
  334.       }
  335.     }
  336.   
  337.   if(writePos == NULL) {
  338.     waislog(WLOG_HIGH, WLOG_ERROR,
  339.         "Error in interpret_message: NULL writePos.");
  340.     return (0);
  341.   }
  342.   else return(writePos - sendBuffer);
  343. }
  344.  
  345. /*----------------------------------------------------------------------*/
  346.  
  347. static void handleInit _AP((char** recBuf,char** sendBuf,
  348.                 long* sendBufLen,long* maxBufferSize));
  349.  
  350. static void
  351. handleInit(recBuf,sendBuf,sendBufLen,maxBufferSize)
  352. char** recBuf;
  353. char** sendBuf;
  354. long* sendBufLen;
  355. long* maxBufferSize;
  356. /* negotiate functionality and buffer sizes.  A session ususally begins
  357.    with one of these, but is not required to.  
  358.    NOTE - even if the server decides not to accept the client, it does
  359.    not shut down the connection.  It simply declies acceptatance, and 
  360.    waits for the client to shut down.
  361.  */
  362. {
  363.   InitAPDU* anInit = NULL;
  364.   
  365.   /* read the init - note there is no WAIS protocol extension here */
  366.   *recBuf = readInitAPDU(&anInit,*recBuf);
  367.   
  368.   if (recBuf == NULL || *recBuf == NULL)
  369.     { *sendBuf = NULL;        /* error in the read */
  370.       return;
  371.     }
  372.   else                /* respond to the init */
  373.     { InitResponseAPDU* reply = NULL;
  374.       WAISInitResponse* wais_response = NULL;
  375.       boolean connectionAccepted;
  376.      
  377.       /* negotiate services */
  378.       if (anInit->willPresent == false &&
  379.       anInit->willDelete == false)
  380.     connectionAccepted = true;
  381.       else
  382.     connectionAccepted = false;
  383.        
  384.       /* negotiate buffer sizes */
  385.       if (*maxBufferSize > anInit->MaximumRecordSize)
  386.     *maxBufferSize = anInit->MaximumRecordSize;
  387.      
  388.       if(anInit->IDAuthentication != NULL)
  389.     waislog(WLOG_MEDIUM, WLOG_INFO, "Init message: %s", 
  390.         anInit->IDAuthentication);
  391.  
  392.       /* not much use huh? */
  393.       wais_response = makeWAISInitResponse(0L,0L,NULL,NULL,NULL,NULL); 
  394.      
  395.       reply = makeInitResponseAPDU(connectionAccepted,
  396.                    true,false,false,false,false,*maxBufferSize,
  397.                    *maxBufferSize,NULL,
  398.                    defaultImplementationID(),
  399.                    defaultImplementationName(),
  400.                    defaultImplementationVersion(),NULL,
  401.                    wais_response);
  402.  
  403.       /* write it */
  404.       *sendBuf = writeInitResponseAPDU(reply,*sendBuf,sendBufLen);
  405.      
  406.       /* free everything */
  407.       freeInitAPDU(anInit);
  408.       freeInitResponseAPDU(reply);
  409.       freeWAISInitResponse(wais_response);
  410.     }
  411. }
  412.  
  413.  
  414. /*----------------------------------------------------------------------*/
  415. static boolean
  416. isRemoteDB(db)
  417. char * db;
  418. {
  419.   return(strchr(db,'@') != NULL);
  420. }
  421.  
  422. /*----------------------------------------------------------------------*/
  423. #include "wmessage.h"
  424.  
  425. struct {
  426.   char host[256];
  427.   long port;
  428.   FILE *connection;
  429.   long buffer_size;
  430. } last_connection;
  431.  
  432. static void
  433. forwardSearch(aSearch,sendBuf,sendBufLen,waisProtocolVersion)
  434. SearchAPDU* aSearch;
  435. char** sendBuf;
  436. long* sendBufLen;
  437. long waisProtocolVersion;
  438. {
  439.   FILE *connection;
  440.   char hostname[1000], db[1000], *p, *p2;
  441.   long port, len, rlen;
  442.   char message[BUFSZ], response[BUFSZ];
  443.  
  444.   p = strchr(aSearch->DatabaseNames[0], '@');
  445.   strncpy(db, aSearch->DatabaseNames[0], p-aSearch->DatabaseNames[0]);
  446.   db[p-aSearch->DatabaseNames[0]] = 0;
  447.   p2 = strchr(p+1, ':');
  448.   if(p2 == NULL) {
  449.     strcpy(hostname, p+1);
  450.     port = 210;
  451.   }
  452.   else {
  453.     strncpy(hostname, p+1, p2-(p+1));
  454.     hostname[p2-(p+1)] = 0;
  455.     port = atoi(p2+1);
  456.   }
  457.  
  458.   strcpy(aSearch->DatabaseNames[0], db);
  459.   rlen = len = BUFSZ;
  460.   writeSearchAPDU(aSearch, message+HEADER_LENGTH, &len);
  461.   len = BUFSZ-len;
  462.   if(hostname[0] != 0) {
  463.     if(strcmp(hostname, last_connection.host) == 0 &&
  464.        port == last_connection.port)
  465.       connection = last_connection.connection;
  466.     else {
  467.       if (last_connection.connection != NULL)
  468.     close_connection(last_connection.connection);
  469.       strcpy(last_connection.host, hostname);
  470.       last_connection.port = port;
  471.       last_connection.connection = (FILE*)connect_to_server(hostname, port);
  472.       connection = last_connection.connection;
  473.       if(connection != NULL) {
  474.     char userInfo[500], hostname[80], init_message[1000];
  475.  
  476.     mygethostname(hostname, 80);
  477. #ifdef TELL_USER
  478.     sprintf(userInfo, "server forwarding %s, from host: %s, user: %s",
  479.         VERSION, hostname, getenv("USER")?getenv("USER"):"nobody");
  480. #else
  481.     sprintf(userInfo, "server forwarding %s, from host: %s", VERSION, hostname);
  482. #endif
  483.  
  484.     last_connection.buffer_size =
  485.       init_connection(init_message, response,
  486.               BUFSZ,
  487.               connection,
  488.               userInfo);
  489.       }
  490.     }
  491.     if(connection != NULL)
  492.       {
  493.     len = interpret_message(message, len,
  494.                 response, last_connection.buffer_size,
  495.                 connection, false);
  496.       }
  497.     else {
  498.       static diagnosticRecord* diags[2] = {NULL, NULL};
  499.       SearchResponseAPDU* response = NULL;
  500.       WAISSearchResponse* wais_response = NULL;
  501.       char message[255];
  502.  
  503.       sprintf(message, "Database not available: %s@%s:%d.",
  504.           db, last_connection.host, last_connection.port);
  505.       diags[0] = makeDiag(true,D_RecordNotAuthorizedToBeSent,
  506.               message);
  507.  
  508.       wais_response = makeWAISSearchResponse(NULL,NULL,NULL,
  509.                          NULL,NULL,NULL,NULL,diags);
  510.       response = makeSearchResponseAPDU(0L,0L,
  511.                     1L,
  512.                     0L,UNUSED,FAILURE,
  513.                     aSearch->ReferenceID, wais_response);
  514.       *sendBuf = writeSearchResponseAPDU(response,*sendBuf,sendBufLen);
  515.  
  516.       freeSearchResponseAPDU(response);
  517.       freeWAISSearchResponse(wais_response);
  518.       waislog(WLOG_HIGH, WLOG_ERROR, message);
  519.       return;
  520.     }
  521.   }
  522.   else
  523.     len = interpret_message(message, len,
  524.                 response, last_connection.buffer_size,
  525.                 NULL, false);
  526.   bcopy(response+HEADER_LENGTH, *sendBuf, len);
  527.   *sendBuf+=len;
  528. }
  529.  
  530. /*----------------------------------------------------------------------*/
  531.  
  532. static void
  533. handleSearch(recBuf,sendBuf,sendBufLen,waisProtocolVersion,index_directory)
  534. char** recBuf;
  535. char** sendBuf;
  536. long* sendBufLen;
  537. long waisProtocolVersion;
  538. char *index_directory;
  539. /* figure out what kind of search this is, (query or retrieval) and
  540.    dispatch to the appropriate function 
  541.  */
  542. {
  543.   SearchAPDU* aSearch = NULL;
  544.  
  545.   /* read the search data */
  546.   *recBuf = readSearchAPDU(&aSearch,*recBuf);
  547.  
  548.   if (*recBuf == NULL)
  549.     { *sendBuf = NULL;        /* error in the read */
  550.       return;
  551.     }
  552.   else
  553.     {                /* dispatch on the query type */
  554.       if((aSearch->DatabaseNames != NULL) &&
  555.      (aSearch->DatabaseNames[0] != NULL) &&
  556.      isRemoteDB(aSearch->DatabaseNames[0]))
  557.     forwardSearch(aSearch,sendBuf,sendBufLen,waisProtocolVersion);
  558.       else {
  559. /* francois - security */
  560.     /* patch from tovio@sage.ucs.uwa.edu.au to fix crash if aSearch->DatabaseNames 
  561.        is null
  562.     */
  563.         if ( (aSearch->DatabaseNames != NULL) &&
  564.         (aSearch->DatabaseNames[0] != NULL) &&
  565.         (server_security(index_directory,aSearch->DatabaseNames[0]) != true ) ) {
  566.                 
  567.                 SearchResponseAPDU* response = NULL;
  568.                 WAISSearchResponse* wais_response = NULL;
  569.  
  570.                 WAISDocumentHeader** headers = NULL;            
  571.                 diagnosticRecord** diags = NULL;
  572.                 diagnosticRecord* diag = NULL;
  573.                 DocObj** docs = NULL;
  574.                 
  575.                 
  576.                 char msg[MAX_FILENAME_LEN * 2];
  577.                     
  578.                 sprintf(msg,"Unautorized access to database: ", aSearch->DatabaseNames[0]);
  579.                 diag = makeDiag(false,D_AccessControlFailure,msg);
  580.                 diags = (diagnosticRecord **)s_malloc((size_t)(sizeof(diagnosticRecord*) * 2));
  581.                 (diags)[0] = diag;
  582.                 (diags)[1] = NULL;
  583.                   
  584.                 wais_response = makeWAISSearchResponse(NULL,NULL,NULL,NULL,
  585.                                          NULL,NULL,NULL,diags);
  586.                 response = makeSearchResponseAPDU(SUCCESS,0L,((diags == NULL) ? 0 : 1),
  587.                                     0L,UNUSED,SUCCESS,aSearch->ReferenceID, wais_response);
  588.  
  589.                 *sendBuf = writeSearchResponseAPDU(response,*sendBuf,sendBufLen);
  590.  
  591.                 if ( strcmp(aSearch->QueryType,QT_RelevanceFeedbackQuery) == 0) {
  592.                         freeWAISSearch((WAISSearch*)aSearch->Query);
  593.                         freeSearchAPDU(aSearch);
  594.                         freeSearchResponseAPDU(response);
  595.                         freeWAISSearchResponse(wais_response); 
  596.                 } 
  597.                 else if ( strcmp(aSearch->QueryType,QT_TextRetrievalQuery) == 0) {
  598.                         docs = readWAISTextQuery((any*)aSearch->Query);
  599.                         freeAny((any*)aSearch->Query);
  600.                         freeSearchAPDU(aSearch);
  601.                         freeSearchResponseAPDU(response);
  602.                         freeWAISSearchResponse(wais_response); 
  603.                         doList((void**)docs,freeDocObj);
  604.                         s_free(docs);  
  605.                 } 
  606.  
  607.                 return;
  608.         }
  609.  
  610.     if (strcmp(aSearch->QueryType,QT_TextRetrievalQuery) == 0) {
  611.       handleElementRetrieval(aSearch,sendBuf,sendBufLen,
  612.                  waisProtocolVersion, index_directory);
  613.     }
  614.     else if (strcmp(aSearch->QueryType,QT_RelevanceFeedbackQuery) == 0) {
  615.       char *seeds, *s;
  616.  
  617.       s = seeds = s_strdup(((WAISSearch *)aSearch->Query)->SeedWords);
  618.       while(*s != 0) {
  619.         if(*s == '\n' || *s == '\r') *s = ' ';
  620.         s++;
  621.       }
  622.  
  623.       if(aSearch->DatabaseNames != NULL &&
  624.          aSearch->DatabaseNames[0] != NULL)
  625.         waislog(WLOG_LOW, WLOG_SEARCH,
  626.             "Search! Database: %s, Seed Words: %s", 
  627.             aSearch->DatabaseNames[0], 
  628.             seeds);
  629.       else
  630.         waislog(WLOG_LOW, WLOG_SEARCH, 
  631.             "Search! Database: None, Seed Words: %s", 
  632.             seeds);
  633.  
  634.       handleRelevanceFeedbackSearch(aSearch,sendBuf,sendBufLen,
  635.                     waisProtocolVersion,
  636.                     index_directory);
  637.           s_free(seeds);        /* (up) */
  638.     }
  639.     else {
  640.       waislog(WLOG_HIGH, WLOG_ERROR, "Unknown search type");
  641.       *sendBuf = NULL;    /* error - unknown search type */
  642.     }
  643.     fflush(stderr);
  644.       }
  645.     }
  646. }
  647.  
  648.  
  649.      
  650.  
  651. /*----------------------------------------------------------------------*/
  652.  
  653. static boolean needs_help(question)
  654. char *question;
  655. /* returns true if the user wants help */
  656. {
  657.   if(question[0] == '\0')  /* null question, must need help */
  658.     return(true);
  659.   if(question[0] == '?')
  660.     return(true);
  661.   if(question[0] == '*')
  662.     return(true);
  663.   if(strlen(question) < 20){
  664.     if((NULL != strstr(question, "help")) ||
  665.        (NULL != strstr(question, "HELP")) ||
  666.        (NULL != strstr(question, "Help")) ||
  667.        (NULL != strstr(question, "all"))){
  668.       return(true);
  669.     }      
  670.   }
  671.   return(false);
  672. }
  673.  
  674. /* returns a help header to be returned or NULL if not possible */
  675. static WAISDocumentHeader *help_header(database_name, index_directory)
  676.      char *database_name;
  677.      char *index_directory;
  678. {
  679.   /* make a help document */
  680.   hit help;
  681.   char local_id[MAX_FILENAME_LEN + 60];
  682.  
  683.   strncpy(help.filename,
  684.       merge_pathnames(database_name,index_directory), 
  685.       MAX_FILENAME_LEN);
  686.   strncat(help.filename, source_ext, MAX_FILENAME_LEN);
  687.   /* printf("help filename %s", help.filename); */
  688.  
  689.   strncpy(help.headline, "Information on database: ", MAX_FILENAME_LEN);
  690.   strncat(help.headline, pathname_name(database_name), 
  691.       MAX_FILENAME_LEN);
  692.   sprintf(local_id, "%ld %ld %s", 0L, 0L, help.filename);
  693.  
  694.   if(probe_file(help.filename))
  695.     { 
  696.       DocID* theDocID = NULL;
  697.       long length;
  698.       long lines;
  699.       char **type = NULL;
  700.  
  701.       help.start_character = 0;
  702.       help.end_character = 0;
  703.     
  704.       { FILE *stream = s_fopen(help.filename, "r");
  705.     lines = count_lines(stream);
  706.     length = file_length(stream);
  707.         s_fclose(stream);
  708.       }
  709.  
  710.       type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  711.       type[0] = s_strdup("WSRC");
  712.       type[1] = NULL;
  713.  
  714.       /* then there is a source structure to return */
  715.       theDocID = makeDocID();
  716.       theDocID->originalDatabase = stringToAny(database_name); /* XXX */
  717.       theDocID->originalLocalID = stringToAny(local_id);
  718.  
  719.       return(makeWAISDocumentHeader(anyFromDocID(theDocID),
  720.                     UNUSED,
  721.                     MAX_NORMAL_SCORE,
  722.                     UNUSED,
  723.                     length,lines,
  724.                     type,
  725.                     s_strdup(database_name), /* XXX */
  726.                     NULL, /* date */
  727.                     s_strdup(help.headline),
  728.                     NULL));
  729.     }    
  730.   else 
  731.     return(NULL);
  732. }
  733.  
  734. /* returns the catalog document to be returned or NULL if not possible */
  735.  
  736. static WAISDocumentHeader *catalog_header(database_name, index_directory, results)
  737.      char *database_name;
  738.      char *index_directory;
  739.      boolean results;
  740. {
  741.   /* make a help document */
  742.   hit catalog;
  743.   char local_id[MAX_FILENAME_LEN + 60];
  744.  
  745.   strncpy(catalog.filename,
  746.       merge_pathnames(database_name,index_directory), 
  747.       MAX_FILENAME_LEN);
  748.   strncat(catalog.filename, catalog_ext, MAX_FILENAME_LEN);
  749.   /* printf("catalog filename %s", catalog.filename); */
  750.  
  751.   if(results)
  752.     strncpy(catalog.headline,
  753.         "Catalog for database: ",
  754.         MAX_FILENAME_LEN);
  755.   else
  756.     strncpy(catalog.headline,
  757.         "Search produced no result. Here's the Catalog for database: ",
  758.         MAX_FILENAME_LEN);
  759.  
  760.   strncat(catalog.headline, pathname_name(database_name), 
  761.       MAX_FILENAME_LEN);
  762.   sprintf(local_id, "%ld %ld %s", 0L, 0L, catalog.filename);
  763.  
  764.   if(probe_file(catalog.filename))
  765.     { 
  766.       DocID* theDocID = NULL;
  767.       long length;
  768.       long lines;
  769.       char **type = NULL;
  770.  
  771.       catalog.start_character = 0;
  772.       catalog.end_character = 0;
  773.     
  774.       { FILE *stream = s_fopen(catalog.filename, "r");
  775.     lines = count_lines(stream);
  776.     length = file_length(stream);
  777.         s_fclose(stream);
  778.       }
  779.  
  780.       type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  781.       type[0] = s_strdup("TEXT");
  782.       type[1] = NULL;
  783.  
  784.       /* then there is a catalog structure to return */
  785.       theDocID = makeDocID();
  786.       theDocID->originalDatabase = stringToAny(database_name); /* XXX */
  787.       theDocID->originalLocalID = stringToAny(local_id);
  788.  
  789.       return(makeWAISDocumentHeader(anyFromDocID(theDocID),
  790.                     UNUSED,
  791.                     (results ? MAX_NORMAL_SCORE:0),
  792.                     UNUSED,
  793.                     length,lines,
  794.                     type,
  795.                     s_strdup(database_name), /* XXX */
  796.                     NULL, /* date */
  797.                     s_strdup(catalog.headline),
  798.                     NULL));
  799.     }    
  800.   else 
  801.     return(NULL);
  802. }
  803.  
  804. /* picks a set of random documents from the database 
  805. static void pick_random_documents(aSearch, headers, &headerNum)
  806. {
  807.   
  808. }
  809. */
  810.  
  811.  
  812. /*----------------------------------------------------------------------*/
  813.  
  814. static void
  815. handleRelevanceFeedbackSearch(aSearch,sendBuf,sendBufLen,
  816.                   waisProtocolVersion,
  817.                   index_directory)
  818. SearchAPDU* aSearch;
  819. char** sendBuf;
  820. long* sendBufLen;
  821. long waisProtocolVersion;
  822. char *index_directory;
  823. { 
  824.   DocObj *doc = NULL;
  825.   SearchResponseAPDU* response = NULL;
  826.   WAISSearchResponse* wais_response = NULL;
  827.  
  828.   WAISDocumentHeader** headers = NULL;
  829.   long headerNum = 0;
  830.   long max_headers = ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved;
  831.   char* seedwords_used = NULL;
  832.   diagnosticRecord** diags = NULL;
  833.   char *seed_words_used = s_strdup(((WAISSearch *)aSearch->Query)->SeedWords);
  834.   boolean search_status;
  835.  
  836.   if(((WAISSearch *)aSearch->Query)->Docs!=NULL &&
  837.      (doc=((WAISSearch *)aSearch->Query)->Docs[0]) != NULL &&
  838.      (isdoctype(doc, "TEXT-FTP") || isdoctype(doc, "FTP-DIR"))) {
  839.     handleFTPSearch(aSearch,sendBuf,sendBufLen, waisProtocolVersion, index_directory);
  840.     return;
  841.   }
  842.  
  843.   /* construct a response list */
  844.   headers = (WAISDocumentHeader**)
  845.     s_malloc((size_t)
  846.          (sizeof(WAISDocumentHeader*) * 
  847.           (1 + max_headers)));
  848.   headers[0] = NULL;
  849.  
  850.   if(0 != init_search_engine(index_directory, false, true, 0, 0, 0))
  851.     panic("unable to initialize search engine");
  852.   
  853.   /* handle help queries */
  854.   if(seed_words_used[0] == '\0' &&
  855.      ((WAISSearch *)aSearch->Query)->Docs != NULL) {
  856.     1;
  857.   }
  858.   else if(needs_help(seed_words_used)) {
  859.       WAISDocumentHeader *header;
  860.       char *database_name = (aSearch->DatabaseNames == NULL) ?
  861.       INFO_DATABASE_NAME : aSearch->DatabaseNames[0];
  862.  
  863.     if(headerNum < max_headers) {
  864.       header = help_header(database_name, index_directory);
  865.       if(NULL != header) {
  866.     headers[headerNum++] = header;
  867.     headers[headerNum] = NULL;    
  868.     ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved--;
  869.       }
  870.     }
  871.     if(headerNum < max_headers) {
  872.       header = catalog_header(database_name, index_directory, true);
  873.       if(NULL != header){
  874.     headers[headerNum++] = header;
  875.     headers[headerNum] = NULL;    
  876.     ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved--;
  877.       }
  878.     }
  879.   }
  880.  
  881.   if(seed_words_used[0] == '\0' &&
  882.      ((WAISSearch *)aSearch->Query)->Docs == NULL)
  883.    {
  884.      /* pick_random_documents(aSearch, headers, &headerNum); */
  885.      search_status = true;
  886.    }
  887.   else
  888.    { /* run the search on the database.  If a new
  889.     search engine were to be used, this is where it would be hooked in */
  890.      search_status = run_search(aSearch, headers,&diags, index_directory, 
  891.                 &seed_words_used, waisProtocolVersion,
  892.                 &headerNum);
  893.    }
  894.  
  895. #define CATALOG_FOR_NO_RESULTS
  896. #ifdef CATALOG_FOR_NO_RESULTS
  897.   if(headerNum == 0 && headerNum < max_headers) {
  898.     char *database_name = (aSearch->DatabaseNames == NULL) ?
  899.       INFO_DATABASE_NAME : aSearch->DatabaseNames[0];
  900.     WAISDocumentHeader *header = catalog_header(database_name, index_directory, false);
  901.  
  902.     if(NULL != header){
  903.       waislog(WLOG_MEDIUM, WLOG_INFO,
  904.           "Search had no hits, returning catalog");
  905.       headers[headerNum++] = header;
  906.       headers[headerNum] = NULL;    
  907.     }
  908.   }
  909. #endif /* CATALOG_FOR_NO_RESULTS */
  910.  
  911.   wais_response = makeWAISSearchResponse(seedwords_used,headers,NULL,
  912.                                          NULL,NULL,NULL,NULL,diags);
  913.   response = makeSearchResponseAPDU(search_status,0L,
  914.                     headerNum + ((diags == NULL) ? 0 : 1),
  915.                     0L,UNUSED,SUCCESS,
  916.                                     aSearch->ReferenceID, wais_response);
  917.   /* write it */
  918.   {
  919.     char *buff;
  920.     long len;
  921.     boolean it_fit = true;
  922.  
  923.     while(headerNum >= 0) {
  924.       buff = *sendBuf;
  925.       len = *sendBufLen;
  926.       if ((buff = writeSearchResponseAPDU(response,buff,&len)) == NULL) {
  927.  
  928.     it_fit = false; /* didn't make it in the buffer. */
  929.     headerNum--; 
  930.     s_free(headers[headerNum]);
  931.     headers[headerNum] = NULL;
  932.  
  933.     s_free(wais_response);
  934.     wais_response = makeWAISSearchResponse(seedwords_used,headers,NULL,
  935.                            NULL,NULL,NULL,NULL,diags);
  936.     
  937.     freeSearchResponseAPDU(response);
  938.     response = makeSearchResponseAPDU(search_status,0L,
  939.                       headerNum + ((diags == NULL) ? 0:1),
  940.                       0L,UNUSED,SUCCESS,
  941.                       aSearch->ReferenceID, wais_response);
  942.       }
  943.       else {
  944.     break;
  945.       }
  946.     }
  947.     *sendBuf = buff;
  948.     *sendBufLen = len;
  949.     if (!it_fit) {
  950.       waislog(WLOG_HIGH, WLOG_WARNING, 
  951.           "Buffer overflow, adjusted results from %ld", 
  952.           ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved);
  953.     }
  954.   }
  955.  
  956.   { /* generate report on results. */
  957.      long i;
  958.   
  959.      waislog(WLOG_MEDIUM, WLOG_RESULTS, "Returned %d result%s.", headerNum,
  960.          headerNum == 1 ? "" : "s");
  961.      if (headerNum > 0) {
  962.        waislog(WLOG_LOW, WLOG_RESULTS, "Results:");
  963.  
  964.         for (i = 0; i < headerNum; i++) {
  965.       char docname[MAX_FILE_NAME_LEN+50];
  966.       DocID *docid = docIDFromAny(headers[i]->DocumentID);
  967.       char *docidstring = anyToString(GetLocalID(docid));
  968.      waislog(WLOG_LOW, WLOG_RESULTS, " %s", docidstring);
  969.         s_free(docidstring);    /* (up) */
  970.         freeDocID(docid);       /* (up) */
  971.         }
  972.  
  973.       }
  974.       else
  975.         waislog(WLOG_LOW, WLOG_RESULTS,
  976.           "Returned 0 results.  Aww.");
  977.   }
  978.   freeWAISSearch((WAISSearch*)aSearch->Query); 
  979.   freeSearchAPDU(aSearch);
  980.   freeSearchResponseAPDU(response);
  981.   freeWAISSearchResponse(wais_response); /* free headers & seed_words_used */
  982.   s_free(seed_words_used);    /* (up) */
  983. }
  984.  
  985.  
  986. /*----------------------------------------------------------------------*/
  987. static void 
  988. handleElementRetrieval(aSearch,sendBuf,sendBufLen,waisProtocolVersion, index_directory)
  989. SearchAPDU* aSearch;
  990. char** sendBuf;
  991. long* sendBufLen;
  992. long waisProtocolVersion;
  993. char *index_directory;
  994. /* this is a type 1 query of the restricted form specified in the 
  995.    WAIS-protocol.  Interpret it and write out an appropriate search
  996.    response. (note the valid element sets are Document-Text,Document-Headlines,
  997.    and Document-Codes but we only support text for now).
  998.  */
  999. { 
  1000.   SearchResponseAPDU* response = NULL;
  1001.   WAISSearchResponse* wais_response = NULL;
  1002.   DocObj** docs = NULL;
  1003.   DocObj* doc = NULL;
  1004.   char *databaseName;
  1005.   void **elementList = NULL;
  1006.   void *element = NULL;
  1007.   diagnosticRecord** diags = NULL;
  1008.   diagnosticRecord* diag = NULL;
  1009.   long numDiags = 0L;
  1010.   long numElements = 0L;
  1011.   long i;
  1012.   database* db;
  1013.   
  1014.   /* francois */
  1015.   char new_db_name[MAX_FILENAME_LEN * 2];
  1016.  
  1017.   
  1018.   /* read the query */
  1019.   docs = readWAISTextQuery((any*)aSearch->Query);
  1020.  
  1021.   /* francois */
  1022.  if (aSearch->DatabaseNames == NULL)
  1023.     strcpy(new_db_name,merge_pathnames(INFO_DATABASE_NAME, index_directory));
  1024.   else
  1025.     strcpy(new_db_name,merge_pathnames(aSearch->DatabaseNames[0], index_directory));
  1026.  
  1027.  
  1028.  
  1029.    /* francois - locks */
  1030.   db = openDatabase(new_db_name, false, 
  1031. #ifdef FIELDS /* tung, 3/94 */
  1032.                     true, true);
  1033. #else
  1034.   true);
  1035. #endif
  1036.  
  1037.   if (db == NULL){
  1038.     char msg[MAX_FILENAME_LEN * 2];
  1039.     strncpy(msg,"The following database is not available: ",
  1040.         MAX_FILENAME_LEN);
  1041.     s_strncat(msg,aSearch->DatabaseNames[0],MAX_FILENAME_LEN,MAX_FILENAME_LEN);
  1042.     diag = makeDiag(false,D_PermanentSystemError,msg);
  1043.     diags = (diagnosticRecord **)s_malloc((size_t)(sizeof(diagnosticRecord*) * 2));
  1044.     diags[0] = diag;
  1045.     diags[1] = NULL;
  1046.     
  1047.   }
  1048.   else {
  1049.   
  1050.  
  1051.        /* assemble the elements and construct a response */
  1052.        for (i = 0L, doc = docs[i]; doc != NULL; doc = docs[++i])
  1053.        { 
  1054.      long errorCode;
  1055.      any* bufAny;
  1056.      long size;
  1057.     
  1058.     
  1059.      if (doc->Type != NULL &&
  1060.          strcmp(doc->Type, "WAIS_NEXT") == 0) {
  1061.        char docname[MAX_FILE_NAME_LEN+50], *buffer;
  1062.       
  1063.       if ((size = 
  1064.         next_doc(docname, 
  1065.              anyToString(GetLocalID(docIDFromAny(doc->DocumentID))),
  1066.              db))
  1067.            > 0) {
  1068.          buffer = s_malloc(strlen(docname)+50);
  1069.          sprintf(buffer, "%s, %d", docname, size);
  1070.          bufAny = makeAny(strlen(buffer)+1,buffer);
  1071.          element = (void*)makeWAISDocumentText(duplicateAny(doc->DocumentID),0L,bufAny);
  1072.        }
  1073.        else element = NULL;
  1074.        closeDatabase(db);
  1075.      }
  1076.      else if (doc->Type != NULL &&
  1077.           strcmp(doc->Type, "WAIS_PREV") == 0) {
  1078.        char docname[MAX_FILE_NAME_LEN+50], *buffer;
  1079.        any* bufAny;
  1080.        long size;
  1081.     
  1082.        if ((size = 
  1083.         previous_doc(docname, 
  1084.                  anyToString(GetLocalID(docIDFromAny(doc->DocumentID))),
  1085.                  db))
  1086.            > 0) {
  1087.          buffer = s_malloc(strlen(docname)+50);
  1088.          sprintf(buffer, "%s, %d", docname, size);
  1089.          bufAny = makeAny(strlen(buffer),buffer);
  1090.          element = (void*)makeWAISDocumentText(duplicateAny(doc->DocumentID),0L,bufAny);
  1091.        }
  1092.        else element = NULL;
  1093.        closeDatabase(db);
  1094.      }
  1095.      else if (doc->ChunkCode == CT_line) {
  1096.        element = (void*)getDocumentText(doc, &errorCode, index_directory);
  1097.      }
  1098.      else if (doc->ChunkCode == CT_byte) {
  1099.        element = (void*)getData(doc, &errorCode, index_directory);
  1100.      }
  1101.     
  1102.      if (errorCode != GDT_NoError)
  1103.        {            /* make a diagnostic record to return */
  1104.          switch (errorCode)
  1105.            { case GDT_UnsupportedChunkType:
  1106.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  1107.                    "Bad ChunkType in Request");
  1108.            break;
  1109.          case GDT_BadDocID:
  1110.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  1111.                    "Bad DocID in request");
  1112.            break;
  1113.          case GDT_MissingDocID:
  1114.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  1115.                    "Missing DocID in request");
  1116.            break;
  1117.          case GDT_BadRange:
  1118.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  1119.                    "Request out of range");
  1120.            break;
  1121.          case GDT_MissingDatabase:
  1122.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  1123.                    "Database missing from request");
  1124.            break;
  1125.          case GDT_BadDatabase:
  1126.            diag = makeDiag(true,D_PresentRequestOutOfRange,
  1127.                    "File not present in specified database");
  1128.            break;
  1129.          default:
  1130.            /* should never get here */
  1131.            diag = NULL;
  1132.            break;
  1133.          };
  1134.          diags = (diagnosticRecord**)s_realloc(diags,(size_t)(sizeof(diagnosticRecord*) * 
  1135.                                   (numDiags + 2)));
  1136.          diags[numDiags++] = diag;
  1137.          diags[numDiags] = NULL;
  1138.        }
  1139.      if (element != NULL)
  1140.        { if (elementList == NULL) /* create a list */
  1141.            { elementList = (void**)s_malloc((size_t)sizeof(void*) * 2);
  1142.            }
  1143.        else            /* grow the list */
  1144.          { elementList = (void**)s_realloc((char*)elementList,
  1145.                            (size_t)(sizeof(void*) * 
  1146.                             (numElements + 2)));
  1147.          }
  1148.            elementList[numElements++] = element; /* put it in the list */
  1149.            elementList[numElements] = NULL;
  1150.            }
  1151.     }
  1152.    }
  1153.  
  1154.   wais_response = makeWAISSearchResponse(NULL,NULL,NULL,NULL,
  1155.                                          (WAISDocumentText**)elementList,NULL,
  1156.                                          NULL,diags);
  1157.   response = makeSearchResponseAPDU(SUCCESS,0L,numElements + numDiags,0L,UNUSED,
  1158.                                     SUCCESS,aSearch->ReferenceID,
  1159.                     wais_response);
  1160.   
  1161.   /* write it */
  1162.   *sendBuf = writeSearchResponseAPDU(response,*sendBuf,sendBufLen);
  1163.   
  1164.  
  1165.   /* clean up */
  1166.   freeAny((any*)aSearch->Query);/* have to explicitly free the user info */
  1167.   freeSearchAPDU(aSearch);
  1168.   freeSearchResponseAPDU(response);
  1169.   freeWAISSearchResponse(wais_response); /* frees the elements constructed */
  1170.   doList((void**)docs,freeDocObj);
  1171.   s_free(docs);  
  1172.  
  1173.   /* francois - locks */
  1174.   closeDatabase(db);
  1175. }
  1176.  
  1177.  
  1178.  
  1179. /*----------------------------------------------------------------------*/
  1180.  
  1181. static void
  1182. handleFTPSearch(aSearch,sendBuf,sendBufLen,
  1183.         waisProtocolVersion,
  1184.         index_directory)
  1185. SearchAPDU* aSearch;
  1186. char** sendBuf;
  1187. long* sendBufLen;
  1188. long waisProtocolVersion;
  1189. char *index_directory;
  1190. {
  1191.   SearchResponseAPDU* response = NULL;
  1192.   WAISSearchResponse* wais_response = NULL;
  1193.  
  1194.   DocID *t;
  1195.   WAISDocumentHeader** headers = NULL;
  1196.   long headerNum = 0;
  1197.   long max_headers = ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved;
  1198.   DocObj *doc;
  1199.   char* seedwords_used = NULL;
  1200.   diagnosticRecord** diags = NULL;
  1201.   char *seed_words_used = s_strdup(((WAISSearch *)aSearch->Query)->SeedWords);
  1202.   char *database_name = (aSearch->DatabaseNames == NULL) ?
  1203.     INFO_DATABASE_NAME : aSearch->DatabaseNames[0];
  1204.   boolean search_status;
  1205.   int i=0;
  1206.   char *local_id,*p;
  1207.   long start,end;
  1208.   char path[200];
  1209.   char mpath[200];
  1210.   int count;
  1211.  
  1212.   /* construct a response list */
  1213.   headers = (WAISDocumentHeader**)
  1214.     s_malloc((size_t)
  1215.          (sizeof(WAISDocumentHeader*) *
  1216.           (1 + max_headers)));
  1217.   headers[0] = NULL;
  1218.   for(doc=((WAISSearch *)aSearch->Query)->Docs[i]; ((WAISSearch *)aSearch->Query)->Docs[i]!=NULL;
  1219.       doc=((WAISSearch *)aSearch->Query)->Docs[++i]){
  1220.  
  1221.     t=docIDFromAny(doc->DocumentID);
  1222.     local_id = anyToString(GetLocalID(t));
  1223.     freeDocID(t);
  1224.     sscanf(local_id,"%ld %ld %s",&start,&end,path);
  1225.     if(strcmp(path, "/")) {
  1226.       p=strrchr(path,'/');
  1227.       if(p)
  1228.     *p='\0';
  1229.     }
  1230.  
  1231.     getcwd(mpath,198);           /* up: was getwd ?? */
  1232.  
  1233.     if(index_directory && !substrcmp(path, index_directory))
  1234.       strcpy(path, index_directory);
  1235.  
  1236.     chdir(path);
  1237.  
  1238.     loadFileHeaders(path,headers,&headerNum,database_name, 
  1239.             ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved,
  1240.             index_directory); 
  1241.     chdir(mpath);
  1242.   }
  1243.   /**** jim jim jim */
  1244.   wais_response = makeWAISSearchResponse(seedwords_used,headers,NULL,
  1245.                      NULL,NULL,NULL,NULL,diags);
  1246.   response = makeSearchResponseAPDU(search_status,0L,
  1247.                     headerNum + ((diags == NULL) ? 0 : 1),
  1248.                     0L,UNUSED,SUCCESS,
  1249.                     aSearch->ReferenceID, wais_response);
  1250.   /* write it */
  1251.   {
  1252.     char *buff;
  1253.     long len;
  1254.     boolean it_fit = true;
  1255.  
  1256.     while(headerNum >= 0) {
  1257.       buff = *sendBuf;
  1258.       len = *sendBufLen;
  1259.       if (headerNum*(sizeof(WAISDocumentHeader)+100) > len || (buff = writeSearchResponseAPDU(response,buff,&len)) == NULL) {
  1260.  
  1261.     it_fit = false;        /* didn't make it in the buffer. */
  1262.     headerNum--;
  1263.     s_free(headers[headerNum]);
  1264.     headers[headerNum] = NULL;
  1265.  
  1266.     s_free(wais_response);
  1267.     wais_response = makeWAISSearchResponse(seedwords_used,headers,NULL,
  1268.                            NULL,NULL,NULL,NULL,diags);
  1269.  
  1270.     freeSearchResponseAPDU(response);
  1271.     response = makeSearchResponseAPDU(search_status,0L,
  1272.                       headerNum + ((diags == NULL) ? 0:1),
  1273.                       0L,UNUSED,SUCCESS,
  1274.                       aSearch->ReferenceID, wais_response);
  1275.       }
  1276.       else {
  1277.     break;
  1278.       }
  1279.     }
  1280.     *sendBuf = buff;
  1281.     *sendBufLen = len;
  1282.     if (!it_fit) {
  1283.       waislog(WLOG_HIGH, WLOG_WARNING,
  1284.  
  1285.           "Buffer overflow, adjusted results from %ld",
  1286.           ((WAISSearch *)aSearch->Query)->MaxDocumentsRetrieved);
  1287.     }
  1288.   }
  1289.   {                /* generate report on results. */
  1290.     char *message;
  1291.     long size, i;
  1292.  
  1293.     /* calculate total length needed for log report */
  1294.     for(size = 0L, i = 0; i < headerNum; i++)
  1295.       size+=(headers[i]->DocumentID->size+2);
  1296.     if (size > 0) {
  1297.       message = s_malloc(size);
  1298.       message[0] = 0;
  1299.  
  1300.       for (i = 0; i < headerNum; i++) {
  1301.     char docname[MAX_FILE_NAME_LEN+50];
  1302.     DocID *docid = docIDFromAny(headers[i]->DocumentID);
  1303.     char *docidstring = anyToString(GetLocalID(docid));
  1304.  
  1305.     sprintf(docname, "%s", docidstring);
  1306.     s_strncat(message, docname, headers[i]->DocumentID->size, size);
  1307.  
  1308.     s_free(docid); 
  1309.     s_free(docidstring);
  1310.  
  1311.     if ( i < headerNum-1)
  1312.       strcat(message, ", ");
  1313.       }
  1314.       waislog(WLOG_LOW, WLOG_RESULTS,
  1315.           "Returned %d results: %s", headerNum, message);
  1316.       s_free(message);
  1317.     }
  1318.     else
  1319.       waislog(WLOG_LOW, WLOG_RESULTS,
  1320.           "Returned 0 results.  Aww.");
  1321.   }
  1322.   freeWAISSearch((WAISSearch*)aSearch->Query);
  1323.   freeSearchAPDU(aSearch);
  1324.   freeSearchResponseAPDU(response);
  1325.   freeWAISSearchResponse(wais_response); /* free headers & seed_words_used */
  1326. }
  1327.  
  1328. #ifndef HAVE_ALPHASORT
  1329. static int
  1330.   alphasort(d1, d2)
  1331. struct dirent **d1;
  1332. struct dirent **d2;
  1333. {
  1334.   return strcmp((*d1)->d_name, (*d2)->d_name);
  1335. }
  1336. #endif /* HAVE_ALPHASORT */
  1337. static int
  1338. filesonly(e)
  1339. struct dirent *e;
  1340. {
  1341.   struct stat sb;
  1342.   int val;
  1343.   val = (stat(e->d_name, &sb) >= 0 &&( (sb.st_mode & S_IFMT) == S_IFREG || (sb.st_mode & S_IFMT)==S_IFDIR));
  1344.   if((sb.st_mode & S_IFMT)==S_IFDIR){
  1345.     if(e->d_name[strlen(e->d_name)-1]=='.')
  1346.       return(0);
  1347.     strcat(e->d_name,"/");
  1348.   }
  1349.   return(val);
  1350. }
  1351.  
  1352. loadFileHeaders(path,headers, headerNum,database_name,maxf,index_directory)
  1353. char *path;
  1354. WAISDocumentHeader **headers;
  1355. long *headerNum;
  1356. char *database_name;
  1357. long maxf;
  1358. char *index_directory;
  1359. {
  1360.   register int i;
  1361.   register int j;
  1362.   int k;
  1363.   struct dirent **list;
  1364.   hit help;
  1365.   char local_id[MAX_FILENAME_LEN + 60];
  1366.   DocID* theDocID = NULL;
  1367.   struct stat sbuf;
  1368.   long length,flen;
  1369.   long lines;
  1370.   char **type = NULL;
  1371.   char *p,tmpb[200];
  1372.   int loop;
  1373.   int ch,text=1;
  1374.   FILE *fp;
  1375.  
  1376.   k = *headerNum;
  1377.   if ((i = scandir(".", &list, filesonly, alphasort)) < 0) {
  1378.     return;
  1379.   }
  1380.   if(strcmp(path, "/") &&
  1381.      (index_directory == NULL || 
  1382.       strcmp(path, index_directory))) {
  1383.     pathname_directory(path, help.filename);
  1384.     stat(help.filename,&sbuf);
  1385.     length=lines=sbuf.st_size;
  1386.     strncpy(help.headline, help.filename, MAX_FILENAME_LEN);
  1387.     sprintf(local_id, "%ld %ld %s", 0L, length, help.filename);
  1388.     theDocID = makeDocID();
  1389.     theDocID->originalDatabase = stringToAny(database_name); /* XXX */
  1390.     theDocID->originalLocalID = stringToAny(local_id);
  1391.     type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  1392.     strcpy(tmpb,help.filename);
  1393.     type[0] = s_strdup("FTP-DIR");
  1394.     type[1] = NULL;
  1395.  
  1396.     headers[k++]=makeWAISDocumentHeader(anyFromDocID(theDocID),
  1397.                     UNUSED, MAX_NORMAL_SCORE, UNUSED, length,lines, type,
  1398.                     s_strdup(database_name), /* XXX */
  1399.                     NULL, /* date */
  1400.                     s_strdup(help.headline),
  1401.                     NULL);
  1402.   }
  1403.  
  1404.   if(!strcmp(path, "/")) {
  1405.     *path = '\0';
  1406.   }
  1407.   for (j = 0; j < i; j++){
  1408.     if(k>=maxf)
  1409.       break;
  1410.     sprintf(help.filename,"%s/%s",path,list[j]->d_name);
  1411.     stat(list[j]->d_name,&sbuf);
  1412.     length=lines=sbuf.st_size;
  1413.     strncpy(help.headline, help.filename, MAX_FILENAME_LEN);
  1414.     sprintf(local_id, "%ld %ld %s", 0L, length, help.filename);
  1415.     theDocID = makeDocID();
  1416.     theDocID->originalDatabase = stringToAny(database_name); /* XXX */
  1417.     theDocID->originalLocalID = stringToAny(local_id);
  1418.     type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  1419.     strcpy(tmpb,help.filename);
  1420.     p=strrchr(tmpb,'.');
  1421.     if(p){
  1422.       ++p;
  1423.       if(!strcasecmp(p,"tar") || !strcasecmp(p,"shar"))
  1424.     text=0;
  1425.       else
  1426.     text=1;
  1427.     }
  1428.     if(text==1){
  1429.       fp=fopen(help.filename,"r");
  1430.       if(fp==NULL)
  1431.     text=0;
  1432.       else{
  1433.     fseek(fp,0L,2);
  1434.     flen=ftell(fp);
  1435.     for(loop=2; loop<100; loop++){
  1436.       fseek(fp,flen/loop,0);
  1437.       ch=fgetc(fp);
  1438.       if(ch==EOF || (!isprint(ch) && !isspace(ch)))
  1439.         text=0;
  1440.     }
  1441.     fclose(fp);
  1442.       }
  1443.     }
  1444.  
  1445.     if(S_ISDIR(sbuf.st_mode))
  1446.       type[0] = s_strdup("FTP-DIR");
  1447.     else if(text==0)
  1448.       type[0] = s_strdup("FTP");
  1449.     else
  1450.       type[0]=s_strdup("TEXT");
  1451.  
  1452.     type[1] = NULL;
  1453.  
  1454.     headers[k++]=makeWAISDocumentHeader(anyFromDocID(theDocID),
  1455.                     UNUSED, MAX_NORMAL_SCORE, 
  1456.                     UNUSED, length,lines, type,
  1457.                     s_strdup(database_name), /* XXX */
  1458.                     NULL, /* date */
  1459.                     s_strdup(help.headline),
  1460.                     NULL);
  1461.   }
  1462.   if(list != NULL) {
  1463.     for (j = 0; j < i; j++)
  1464.       if(list[j] != NULL) free((char *)list[j]);
  1465.     free((char *)list);
  1466.   }
  1467.   *headerNum = k;
  1468. }
  1469.  
  1470.  
  1471. /*---------------------------------------------------------------------------*/
  1472.  
  1473. boolean
  1474. server_security(index_directory,database_name)
  1475. char *index_directory;
  1476. char *database_name;
  1477. {
  1478.  
  1479.  
  1480. /* francois - security */
  1481.  
  1482. /* This little piece of code implements a very simple security
  1483.    scheme for wais.
  1484.  
  1485.    Every user connection is validated against a file which 
  1486.    contains a list of hosts/domains that can connect to this 
  1487.    server. If the file does not exist, then the server is 
  1488.    open to everybody.
  1489.    
  1490.    The names of the security files can be found in server.h
  1491.  
  1492.    The format of the SERVER SECURITY file ("SERV_SEC")
  1493.    is as follows:
  1494.  
  1495.    host_name    host_address
  1496.  
  1497.    or 
  1498.    
  1499.    welchlab.welch.jhu.edu    128.220.59.10
  1500.    welchlgate.welch.jhu.edu    128.220.59.13
  1501.    
  1502.    
  1503.    Access can be given to specific domains, so if one 
  1504.    wanted to give access to everyone in the 
  1505.    welch.jhu.edu domain, the file would look like this:
  1506.    
  1507.    welch.jhu.edu    128.220.59
  1508.    
  1509.    Note that the host address is optional, but that the 
  1510.    host name is not.
  1511.   
  1512.  
  1513.   
  1514.    The format of the DATABASE SECURITY file ("DATA_SEC")
  1515.    is as follows:
  1516.  
  1517.    database_name    host_name    host_address
  1518.  
  1519.    or 
  1520.    
  1521.    foo    welchlab.welch.jhu.edu        128.220.59.10
  1522.    foo    welchlgate.welch.jhu.edu    128.220.59.13
  1523.    
  1524.    
  1525.    Access can be given to specific domains, so if one 
  1526.    wanted to give access to everyone in the 
  1527.    welch.jhu.edu domain, the file would look like this:
  1528.    
  1529.    foo    welch.jhu.edu    128.220.59
  1530.    
  1531.    Note that the host address is optional, but that the 
  1532.    host name is not.
  1533.    
  1534.    Using a star in this case would allow access to everyone 
  1535.    for a particular database, for example:
  1536.  
  1537.    foo    welch.jhu.edu    128.220.59
  1538.    bar    *    *
  1539.    
  1540.    This would be useful if you wanted to give public access
  1541.    to certain databases on a particular server and restricted 
  1542.    access to others.
  1543.    
  1544. */
  1545.    
  1546.  
  1547.  
  1548.     FILE *   security_stream = NULL;
  1549.     char     security_filename[MAX_FILE_NAME_LEN+50];
  1550.     char     security_line[100];
  1551.     char     security_database_name[100];
  1552.     char     security_host_name[100];
  1553.     char     security_host_address[100];
  1554.     boolean  security_flag = false;
  1555.     
  1556.  
  1557.  
  1558.     if ( database_name != NULL ) {
  1559.        sprintf(security_filename,"%s/%s",index_directory,DATASECURITYFILE);
  1560.     }
  1561.     else {
  1562.        sprintf(security_filename,"%s/%s",index_directory,SERVSECURITYFILE);
  1563.     }
  1564.  
  1565.  
  1566.    
  1567.     /* see if we can open the security file - if not then we dont use it */
  1568. /*    if ( probe_file(security_filename,"r") ) { */
  1569.     if ( probe_file(security_filename) ) {
  1570.         waislog(WLOG_HIGH, WLOG_INFO,"Using security file : %s", security_filename);
  1571.     security_stream = s_fopen(security_filename,"r");
  1572.     if ( security_stream  == NULL ) {
  1573.            waislog(WLOG_HIGH, WLOG_ERROR,"Could not open security file : %s", security_filename);
  1574.            return (false);
  1575.     }
  1576.      }
  1577.      else {
  1578.         return (true);
  1579.      }
  1580.        
  1581.     /* loop getting each line from the security file */
  1582.     do {
  1583.       security_line[0] = '\0';
  1584.       security_database_name[0] = '\0';
  1585.       security_host_name[0] = '\0';
  1586.       security_host_address[0] = '\0';
  1587.       
  1588.     /* read the line, skip '#' lines */
  1589.     if ( (fgets(security_line,100,security_stream) != NULL) && (security_line[0] != '#') ) {
  1590.         
  1591.         /* do we have a database name to check against? */
  1592.         if ( database_name != NULL ) {
  1593.             sscanf(security_line,"%s %s %s",security_database_name,security_host_name, security_host_address);
  1594.             
  1595.             /* check the host address if it exists */
  1596.             if ( host_address[0] != 0 && security_host_address[0] != 0 &&
  1597.                 (( strncmp(host_address,security_host_address,strlen(security_host_address)) == 0 &&
  1598.                 strcmp(security_database_name,database_name) == 0) ||  
  1599.                 ( strcmp(security_host_address,"*") == 0 && 
  1600.                 strcmp(security_database_name,database_name) == 0 )) ) {
  1601.                 security_flag = true;
  1602.                 break;
  1603.             }
  1604.         
  1605.             /* check the host name if it exists*/
  1606.             if ( host_name[0] != 0 && security_host_name[0] != 0 &&
  1607.                    (( strncmp(host_name + ( strlen(host_name) - strlen(security_host_name) ),
  1608.                    security_host_name,strlen(security_host_name)) == 0 &&
  1609.                    strcmp(security_database_name,database_name) == 0) ||
  1610.                    ( strcmp(security_host_name,"*") == 0  &&
  1611.                    strcmp(security_database_name,database_name) == 0 )) ) {
  1612.                 security_flag = true;
  1613.                 break;
  1614.             }
  1615.  
  1616.             /* the host name/address could not be resolved, see if we have public access */
  1617.             if ( host_address[0] == 0 && host_name[0] == 0 &&
  1618.                    strcmp(security_host_name,"*") == 0  &&
  1619.                    strcmp(security_host_address,"*") == 0  &&
  1620.                    strcmp(security_database_name,database_name) == 0 ) {
  1621.                 security_flag = true;
  1622.                 break;
  1623.             }
  1624.  
  1625.  
  1626.         }
  1627.         else {
  1628.             sscanf(security_line,"%s %s",security_host_name, security_host_address);
  1629.             
  1630.             /* check the host address */
  1631.             if ( host_address[0] != 0 && security_host_address[0] != 0 &&
  1632.                 ((strncmp(host_address,security_host_address,strlen(security_host_address)) == 0) ||
  1633.                 (strcmp(security_host_address,"*") == 0)) ) {
  1634.                 security_flag = true;
  1635.                 break;
  1636.             }
  1637.         
  1638.             /* check the host name */
  1639.             if ( host_name[0] != 0 && security_host_name[0] != 0 &&
  1640.                    ((strncmp(host_name + ( strlen(host_name) - strlen(security_host_name) ),
  1641.                    security_host_name,strlen(security_host_name)) == 0) ||
  1642. /*                   ((security_host_name,strlen(security_host_name)) == 0) || */
  1643.                    (strcmp(security_host_name,"*") == 0)) ) {
  1644.                 security_flag = true;
  1645.                 break;
  1646.             }
  1647.             
  1648.             /* the host name/address could not be resolved, see if we have public access */
  1649.             if ( host_address[0] == 0 && host_name[0] == 0 &&
  1650.                    strcmp(security_host_name,"*") == 0  &&
  1651.                    strcmp(security_host_address,"*") == 0  ) {
  1652.                 security_flag = true;
  1653.                 break;
  1654.             }
  1655.  
  1656.         }
  1657.             
  1658.      }
  1659.                 
  1660.     } while ( strlen(security_line) != 0 );
  1661.   
  1662.  
  1663.     /* close the security file */
  1664.     s_fclose(security_stream);
  1665.  
  1666.  
  1667.     /* tell the user of an attempted break-in */
  1668.     if ( security_flag == false ) {
  1669.     if ( database_name != NULL ) {
  1670.         if(host_address[0] != 0){
  1671.           waislog(WLOG_MEDIUM, WLOG_ERROR,"Unauthorised access of database '%s' by: %s [%s], %s ",
  1672.           database_name, host_name, host_address, VERSION);
  1673.         }
  1674.         else if(host_name[0] != 0){
  1675.           waislog(WLOG_MEDIUM, WLOG_ERROR,"Unauthorised access of database '%s' by: %s, %s",
  1676.           database_name, host_name,  VERSION);
  1677.         }
  1678.     }
  1679.     else {
  1680.         if(host_address[0] != 0){
  1681.           waislog(WLOG_MEDIUM, WLOG_ERROR,"Unauthorised access by: %s [%s], %s",
  1682.           host_name, host_address, VERSION);
  1683.         }
  1684.         else if(host_name[0] != 0){
  1685.           waislog(WLOG_MEDIUM, WLOG_ERROR,"Unauthorised access by: %s, %s",
  1686.           host_name, VERSION);
  1687.         }
  1688.     }
  1689.     }
  1690.     
  1691.     
  1692.   return(security_flag);
  1693.  
  1694. }
  1695.  
  1696.  
  1697.