home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / ui-local.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-14  |  19.7 KB  |  720 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4.  
  5.    Brewster@think.com
  6. */
  7.  
  8. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  9.  
  10.  
  11. #ifndef lint
  12. static char *RCSid = "$Header: /usr/users/freewais/FreeWAIS-0.1/ir/ui-local.c,v 1.1 1993/02/16 15:05:35 freewais Exp $";
  13. #endif
  14.  
  15. /* Change log:
  16.  * $Log: ui-local.c,v $
  17.  * Revision 1.1  1993/02/16  15:05:35  freewais
  18.  * Initial revision
  19.  *
  20.  * Revision 1.16  92/03/18  09:01:09  jonathan
  21.  * don't free DocObjs[0]->Type, it's a copy of the input!
  22.  * 
  23.  * Revision 1.15  92/03/06  12:53:03  jonathan
  24.  * Plug another memory leak.  From ericb@baker.dartmouth.edu (Eric J Bivona).
  25.  * 
  26.  * Revision 1.14  92/02/14  15:26:53  jonathan
  27.  * Conditionalized interpret_message and locally_answer_message so client need
  28.  * not include search engine.
  29.  * 
  30.  * Revision 1.13  92/02/12  13:53:41  jonathan
  31.  * Added "$Log" so RCS will put the log message in the header
  32.  * 
  33.  * 
  34. */
  35.  
  36. /* 
  37.  * this is a simple ui toolkit for building other ui's on top.
  38.  * -brewster
  39.  * 
  40.  * top level functions:
  41.  *   generate_search_apdu
  42.  *   generate_retrieval_apdu
  43.  *   interpret_message
  44.  *
  45.  */
  46.  
  47. /* to do:
  48.  *   generate multiple queries for long documents.
  49.  *     this will crash if the file being retrieved is larger than 100k.
  50.  *   
  51.  */
  52.  
  53. #include "ui.h"
  54. #include "wutil.h"
  55. #include "ustubs.h"
  56. #include "futil.h"
  57.  
  58. #include <ctype.h>
  59. #include <errno.h>
  60. #include <string.h>
  61. #include <sys/types.h>
  62.  
  63. #ifdef WIN32
  64. #include <io.h>
  65. #endif
  66.  
  67. /* returns a pointer in the buffer of the first free byte.
  68.    if it overflows, then NULL is returned 
  69.  */
  70. char *
  71. generate_search_apdu(buff,
  72.                      buff_len,
  73.                      seed_words,
  74.                      database_name,
  75.                      docobjs,
  76.                      maxDocsRetrieved)
  77. char* buff;     /* buffer to hold the apdu */
  78. long *buff_len;    /* length of the buffer changed to reflect new data written */
  79. char *seed_words;    /* string of the seed words */
  80. char *database_name;
  81. DocObj** docobjs;
  82. long maxDocsRetrieved;
  83. {
  84.   /* local variables */
  85.  
  86.   SearchAPDU *search3;
  87.   char  *end_ptr;
  88.   static char *database_names[2] = {"", 0};
  89.   any refID;
  90.   WAISSearch *query;
  91.   refID.size = 1;
  92.   refID.bytes = "3";
  93.  
  94.   database_names[0] = database_name;
  95.   query = makeWAISSearch(seed_words,
  96.                          docobjs, /* DocObjsPtr */
  97.                          0L,
  98.                          1L,     /* DateFactor */
  99.                          0L,     /* BeginDateRange */
  100.                          0L,     /* EndDateRange */
  101.                          maxDocsRetrieved
  102.                          );
  103.  
  104.   search3 = makeSearchAPDU(30L, 
  105.                            5000L, /* should be large */
  106.                            30L,
  107.                            1L,  /* replace indicator */
  108.                            "",  /* result set name */
  109.                            database_names, /* database name */   
  110.                            QT_RelevanceFeedbackQuery, /* query_type */
  111.                            0L,   /* element name */
  112.                            NULL, /* reference ID */
  113.                            query);
  114.  
  115.   end_ptr = writeSearchAPDU(search3, buff, buff_len);
  116.  
  117.   CSTFreeWAISSearch(query);
  118.   freeSearchAPDU(search3);
  119.   return(end_ptr);
  120. }
  121.  
  122.  
  123. /* returns a pointer into the buffer of the next free byte.
  124.    if it overflowed, then NULL is returned
  125.  */
  126.  
  127. char *
  128.  generate_retrieval_apdu(buff,
  129.                         buff_len,
  130.                         docID,
  131.                         chunk_type,
  132.                         start,
  133.                         end,
  134.                         type,
  135.                         database_name)
  136. char *buff;
  137. long *buff_len;    /* length of the buffer changed to reflect new data written */
  138. any *docID;
  139. long chunk_type;
  140. long start;
  141. long end;
  142. char *type;
  143. char *database_name;
  144. {
  145.   SearchAPDU *search;
  146.   char  *end_ptr;
  147.  
  148.   static char *database_names[2];
  149.   static char *element_names[3];
  150.   any refID;
  151.  
  152.   DocObj *DocObjs[2];
  153.   any *query;                   /* changed from char* by brewster */
  154.  
  155.   if(NULL == type)
  156.     type = s_strdup("TEXT");
  157.  
  158.   database_names[0] = database_name;
  159.   database_names[1] = NULL;
  160.  
  161.   element_names[0] = " ";
  162.   element_names[1] = ES_DocumentText;
  163.   element_names[2] = NULL;
  164.  
  165.   refID.size = 1;
  166.   refID.bytes = "3";
  167.   
  168.   switch(chunk_type){
  169.   case CT_line: 
  170.     DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
  171.     break;
  172.   case CT_byte:
  173.     DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
  174.     break;
  175.   }
  176.   DocObjs[1] = NULL;
  177.  
  178.   query = makeWAISTextQuery(DocObjs);   
  179.   search = makeSearchAPDU( 10L, 16L, 15L, 
  180.                           1L,   /* replace indicator */
  181.                           "FOO", /* result set name */
  182.                           database_names, /* database name */   
  183.                           QT_TextRetrievalQuery, /* query_type */
  184.                           element_names, /* element name */
  185.                           &refID, /* reference ID */
  186.                           query);
  187.   end_ptr = writeSearchAPDU(search, buff, buff_len);
  188.   /* s_free(DocObjs[0]->Type); it's a copy of the input, don't free it! */
  189.   CSTFreeDocObj(DocObjs[0]);
  190.   CSTFreeWAISTextQuery(query);
  191.   freeSearchAPDU(search);
  192.   return(end_ptr);
  193. }
  194.  
  195. /* not currently used 
  196.  
  197. static boolean isnumber _AP((char* string));
  198.  
  199. static boolean isnumber(string)
  200. char *string;
  201. {
  202.   long count;
  203.   for(count = 0; count < strlen(string); count++){
  204.     if(!isdigit(string[count])){
  205.       return(false);
  206.     }
  207.   }
  208.   return(true);
  209. }
  210.  
  211. */
  212.  
  213. /* this will negotiate with server, and returs the maximum buffer size 
  214.    the server can handle.
  215.  
  216.    A connection should be established first using open_socket.
  217.  
  218. */
  219.  
  220. long init_connection(inBuffer, outBuffer, bufferSize, connection, userInfo)
  221. char *inBuffer, *outBuffer;
  222. long bufferSize;
  223. FILE *connection;
  224. char *userInfo;
  225. { 
  226.   InitAPDU* init = NULL;
  227.   InitResponseAPDU* reply = NULL;
  228.   long result;
  229.   /* construct an init */
  230.   init = makeInitAPDU(true,false,false,false,false,bufferSize,bufferSize,
  231.                       userInfo,defaultImplementationID(),
  232.                       defaultImplementationName(),
  233.                       defaultImplementationVersion(),NULL,userInfo);
  234.   /* write it to the buffer */
  235.   result = writeInitAPDU(init,inBuffer+HEADER_LENGTH,&bufferSize) - inBuffer;
  236.  
  237.   if(result < 0){
  238.     freeInitAPDU(init);
  239.     return(-1);
  240.   }
  241.   if(0 ==
  242.      interpret_message(inBuffer,
  243.                        result - HEADER_LENGTH,
  244.                        outBuffer,
  245.                        bufferSize,
  246.                        connection,
  247.                        false    /* true verbose */      
  248.                        )) {
  249.     /* error making a connection */
  250.     return (-1);
  251.   }
  252.   if (readInitResponseAPDU(&reply,outBuffer + HEADER_LENGTH) == NULL){
  253.     freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  254.     freeInitResponseAPDU(reply);
  255.     return(-1);
  256.   }
  257.   if (reply->Result == false)
  258.     {                           /* the server declined service */
  259.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  260.       freeInitResponseAPDU(reply);
  261.       return(-1);
  262.     }
  263.   else                          /* we got a response back */
  264.     { result = reply->MaximumRecordSize;
  265.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  266.       freeInitResponseAPDU(reply);
  267.       return(result);
  268.     }
  269. }
  270.  
  271. #ifdef LOCAL_SEARCH
  272. /* returns the length of the response, 0 if an error */
  273. long
  274. locally_answer_message(request_message,
  275.                        request_length,
  276.                        response_message,
  277.                        response_buffer_length)
  278. char *request_message;
  279. long request_length;
  280. char *response_message;
  281. long response_buffer_length;
  282. {
  283.   long request_length_internal = request_length;
  284.   long response_length;
  285.   WAISMessage header;
  286.   long maxBufferSize = response_buffer_length;
  287.  
  288.   readWAISPacketHeader(request_message, &header);
  289.   {
  290.     char length_array[11];
  291.     strncpy(length_array, header.msg_len, 10);
  292.     length_array[10] = '\0';
  293.     request_length_internal = atol(length_array);
  294.   }
  295.   /*
  296.     printf("request length is %ld (%ld from caller)\n", 
  297.     request_length_internal,
  298.     request_length);
  299.     */
  300.   
  301.   response_length =
  302.     interpret_buffer(request_message + HEADER_LENGTH, 
  303.                      request_length_internal,
  304.                      response_message + HEADER_LENGTH,
  305.                      response_buffer_length,
  306.                      &maxBufferSize,
  307.                      (long)header.hdr_vers,
  308.                      "");
  309.   if(0 > response_length)
  310.     return(0);
  311.   writeWAISPacketHeader(response_message,
  312.                         response_length,
  313.                         (long)'z',      /* Z39.50 */
  314.                         "DowQuest  ", /* server name */
  315.                         (long)NO_COMPRESSION,   /* no compression */
  316.                         (long)NO_ENCODING,(long)header.hdr_vers);
  317.   return(response_length);
  318. }
  319. #endif
  320.  
  321. /* this is a safe version of unix 'read' it does all the checking
  322.  * and looping necessary
  323.  * to those trying to modify the transport code to use non-UNIX streams:
  324.  *  This is the function to modify!
  325.  */
  326.  
  327. #ifdef LINUX
  328. long read_from_stream(stream,buf,nbytes)
  329. FILE *stream;   /* this is the stream */
  330. #else
  331. long read_from_stream(d,buf,nbytes)
  332. long d;
  333. #endif /* LINUX */
  334.  
  335. char *buf;
  336. long nbytes;
  337. {
  338.   long didRead;
  339.   long toRead = nbytes;
  340.   long totalRead = 0;           /* paranoia */
  341.  
  342.   while (toRead > 0){
  343. #ifdef LINUX
  344.     didRead = fread (buf, sizeof(char), toRead, stream);
  345. #else
  346.     didRead = read(d, buf, toRead);
  347. #endif /* LINUX */
  348.  
  349.     if(didRead == -1)           /* error*/
  350.       return(-1);
  351.     if(didRead == 0)            /* eof */
  352.       return(-2);               /* maybe this should return 0? */
  353.     toRead -= didRead;
  354.     buf += didRead;
  355.     totalRead += didRead;
  356.   }
  357.   if(totalRead != nbytes)       /* we overread for some reason */
  358.     return(- totalRead);        /* bad news */    
  359.   return(totalRead);
  360. }
  361.  
  362. /* returns the length of the response, 0 if an error */
  363.  
  364. long 
  365. transport_message(connection,
  366.                   request_message,
  367.                   request_length,
  368.                   response_message,
  369.                   response_buffer_length)
  370. FILE *connection;
  371. char *request_message;
  372. long request_length;
  373. char *response_message;
  374. long response_buffer_length;
  375. {
  376.   WAISMessage header;
  377.   long response_length;
  378.  
  379.   
  380.   /* Write out message. Read back header. Figure out response length. */
  381.   
  382. #ifdef WIN32
  383.   if( request_length + HEADER_LENGTH
  384.      != (long)fwrite (request_message, 1L, request_length + HEADER_LENGTH, connection))
  385. #else
  386.   if( request_length + HEADER_LENGTH
  387.      != fwrite (request_message, 1L, request_length + HEADER_LENGTH, connection))
  388. #endif
  389.     return 0;
  390.  
  391.   fflush(connection);
  392.  
  393.   /* read for the first '0' */
  394.  
  395.   while(1){
  396.  
  397. #ifdef LINUX
  398.     if(0 > read_from_stream(connection, response_message, 1))
  399. #else
  400.     if (0 > read_from_stream(fileno(connection), response_message, 1))
  401. #endif /* LINUX */
  402.  
  403.       return 0;
  404.     if('0' == response_message[0])
  405.       break;
  406.   }
  407.  
  408. #ifdef LINUX
  409.   if(0 > read_from_stream(connection, response_message + 1, HEADER_LENGTH - 1))
  410. #else
  411.   if (0 > read_from_stream(fileno(connection), response_message+1, HEADER_LENGTH-1))
  412. #endif /* LINUX */
  413.  
  414.     return 0;
  415.  
  416.   readWAISPacketHeader(response_message, &header);
  417.   {
  418.     char length_array[11];
  419.     strncpy(length_array, header.msg_len, 10);
  420.     length_array[10] = '\0';
  421.     response_length = atol(length_array);
  422.     /*
  423.       if(verbose){
  424.       printf("WAIS header: '%s' length_array: '%s'\n", 
  425.       response_message, length_array);
  426.       }
  427.       */
  428.     if(response_length > response_buffer_length){
  429.       /* we got a message that is too long, therefore empty the message out,
  430.          and return 0 */
  431.       long i;
  432.       for(i = 0; i < response_length; i++){
  433.  
  434. #ifdef LINUX
  435.         read_from_stream(connection, response_message + HEADER_LENGTH, 1);
  436. #else
  437.         read_from_stream(fileno(connection),response_message+HEADER_LENGTH, 1);
  438. #endif /* LINUX */
  439.  
  440.       }
  441.       return(0);
  442.     }
  443.   }
  444.  
  445. #ifdef LINUX
  446.   if(0 > read_from_stream(connection, response_message + HEADER_LENGTH,
  447.                           response_length))
  448. #else
  449.   if (0> read_from_stream(fileno(connection),response_message+HEADER_LENGTH,
  450.                           response_length))
  451. #endif /* LINUX */
  452.  
  453.     return 0;
  454.   return(response_length);
  455. }
  456.  
  457.  
  458. /* ------------------------------------------------------------*/
  459.  
  460. /*  Facility to record messages sent and recieved for testing 
  461.     and timing purposes. */
  462.  
  463. /* from c:
  464.  
  465.    putenv(strdup("IR_FILE=/users/menlo-park/brewster/tmp/infile"));
  466.  
  467.    from csh:
  468.  
  469.    setenv IR_FILE /users/menlo-park/brewster/tmp/infile
  470.  
  471.  */
  472.  
  473. boolean environment_variables_read = false; 
  474. char* ir_file_environment_variable = "IR_FILE";
  475. char* ir_file = NULL;
  476.  
  477. void read_environment_variables(host, port)
  478.      char* host;
  479.      char* port;
  480. {
  481.   
  482.   if(!environment_variables_read){
  483.     FILE *stream;
  484.     ir_file = (char*)getenv(ir_file_environment_variable);
  485.     if(ir_file){
  486.       printf("IR_file: %s\n", ir_file);
  487.       stream = fopen(ir_file, "w");
  488.       fprintf(stream, "%s %s\n", host, port);
  489.       fclose(stream);
  490.     }
  491.     environment_variables_read = true;
  492.   }
  493. }
  494.  
  495. /* returns 0 if success */
  496. long write_message_to_file(message, length, filename)
  497.      unsigned char *message;
  498.      long length;
  499.      char*filename;
  500. {
  501.   FILE *stream = fopen(filename, "a");
  502.   if(NULL == stream)
  503.     return(-1);
  504.   
  505.   printf("Writing to file: %s %d characters\n", filename, length);
  506.  
  507.   fprintf(stream, "---------------------------------\n");
  508.   
  509. #ifdef WIN32
  510.   if(length != (long)fwrite(message, sizeof(unsigned char), 
  511.                       length, stream)){
  512. #else
  513.   if(length != fwrite(message, sizeof(unsigned char), 
  514.                       length, stream)){
  515. #endif
  516.     perror("fwrite error");
  517.     fclose(stream);
  518.     return(-2);
  519.   }
  520.  
  521.   fprintf(stream, "\n");
  522.  
  523.   if(0 != fclose(stream))
  524.     return(-3);
  525.   return(0);
  526. }  
  527.  
  528. /* ------------------------------------------------------------*/
  529.  
  530. /* returns the number of bytes writeen.  0 if an error */
  531. long
  532. interpret_message(request_message,request_length,
  533.                   response_message,
  534.                   response_buffer_length,
  535.                   connection,
  536.                   verbose)
  537. char *request_message;
  538. long request_length; /* length of the buffer */
  539. char *response_message;
  540. long response_buffer_length;
  541. FILE *connection;
  542. boolean verbose;
  543. {
  544.   long response_length;
  545.  
  546.   writeWAISPacketHeader(request_message,
  547.                         request_length,
  548.                         (long)'z',      /* Z39.50 */
  549.                         "wais      ", /* server name */
  550.                         (long)NO_COMPRESSION,   /* no compression */
  551.                         (long)NO_ENCODING,(long)HEADER_VERSION);
  552.  
  553.   if(ir_file){
  554.     long error_code;
  555.     if(0 != (error_code = 
  556.              write_message_to_file((unsigned char*)request_message, 
  557.                                    request_length + HEADER_LENGTH, 
  558.                                    ir_file)))
  559.       printf("Error writing log file Code: %d\n", error_code);
  560.   }
  561.     
  562.   if(connection != NULL) {
  563.     if(0 == 
  564.        (response_length =
  565.         transport_message(connection, request_message,
  566.                           request_length,
  567.                           response_message,
  568.                           response_buffer_length)))
  569.       return(0);
  570.   }
  571.   else{
  572. #ifdef LOCAL_SEARCH    
  573.     if(0 == 
  574.        (response_length =
  575.         locally_answer_message(request_message, request_length, 
  576.                                response_message,
  577.                                response_buffer_length)))
  578.       return(0);
  579. #else
  580.     waislog(WLOG_HIGH, WLOG_ERROR, "Local search not supported in this version");
  581.     return(0);
  582. #endif
  583.   }
  584.   if(verbose){
  585.     printf ("decoded %ld bytes: \n", response_length);
  586.     twais_dsply_rsp_apdu(response_message + HEADER_LENGTH, 
  587.                          request_length);
  588.   }
  589.   if(ir_file){
  590.     long error_code;
  591.     if(0 != (error_code = 
  592.              write_message_to_file((unsigned char*)response_message, 
  593.                                    response_length + HEADER_LENGTH, 
  594.                                    ir_file)))
  595.       printf("Error writing log file Code: %d\n", error_code);
  596.   }
  597.   return(response_length);
  598. }
  599.  
  600. /* this closes the connection to the socket.
  601.  * the mythology is that this is cleaner than exiting
  602.  */
  603.  
  604. long close_connection(connection)
  605. FILE *connection;
  606. {
  607.   long result = 0;
  608.   
  609.   if(connection != NULL){
  610.     result = fclose(connection);
  611.   }
  612.   return(result);
  613. }
  614.   
  615. void
  616. display_text_record_completely(record,quote_string_quotes)
  617. WAISDocumentText *record;
  618. boolean quote_string_quotes;
  619. {
  620.   long count;
  621.   /* printf(" Text\n");
  622.      print_any("     DocumentID:  ", record->DocumentID);
  623.      printf("     VersionNumber:  %d\n", record->VersionNumber);
  624.      */
  625. #ifdef WIN32
  626.   for(count = 0; count < (long)(record->DocumentText->size); count++){
  627. #else
  628.   for(count = 0; count < record->DocumentText->size; count++){
  629. #endif
  630.     long ch = (unsigned char)record->DocumentText->bytes[count];
  631.     if(27 == ch){
  632.       /* then we have an escape code */
  633.       /* if the next letter is '(' or ')', then ignore two letters */
  634.       if('(' == record->DocumentText->bytes[count + 1] ||
  635.          ')' == record->DocumentText->bytes[count + 1])
  636.         count += 1;             /* it is a term marker */
  637.       else count += 4;          /* it is a paragraph marker */
  638.     }
  639.     else if (ch == '\t') /* a TAB! */
  640.       putc(ch, stdout);
  641.     else if (isprint(ch)){
  642.       if(quote_string_quotes && ch == '"')
  643.         putc('\\', stdout);
  644.       putc(ch, stdout);
  645.     } 
  646.     else if (ch == '\n' || ch == '\r')
  647.       printf ("\n");
  648.   }
  649. }
  650.  
  651. /* modifies the string to exclude all seeker codes. sets length to
  652.    the new length. */
  653. char *delete_seeker_codes(string,length)
  654. char *string;
  655. long *length;
  656. {
  657.   long original_count; /* index into the original string */
  658.   long new_count = 0; /* index into the collapsed string */
  659.   for(original_count = 0; original_count < *length; original_count++){
  660.     if(27 == string[original_count]){
  661.       /* then we have an escape code */
  662.       /* if the next letter is '(' or ')', then ignore two letters */
  663.       if('(' == string[original_count + 1] ||
  664.     ')' == string[original_count + 1])
  665.      original_count += 1;    /* it is a term marker */
  666.       else original_count += 4; /* it is a paragraph marker */
  667.     }
  668.     else string[new_count++] = string[original_count];
  669.   }
  670.   *length = new_count;
  671.   return(string);
  672. }
  673.  
  674.  
  675.   
  676. /* returns a pointer to a string with good stuff */
  677. char *trim_junk(headline)
  678. char *headline;
  679. {
  680.   long length = strlen(headline) + 1; /* include the trailing null */
  681.   long i,j;
  682.   headline = delete_seeker_codes(headline, &length);
  683.  
  684.  
  685.   /* delete leading spaces */
  686. #ifdef WIN32
  687.   for(i=0; i < (long)strlen(headline); i++){
  688. #else
  689.   for(i=0; i < strlen(headline); i++){
  690. #endif
  691.     if(isprint(headline[i])){
  692.       break;
  693.     }
  694.   }
  695.   headline = headline + i;
  696.   /* delete trailing stuff */
  697. #ifdef WIN32
  698.   for (i = 0, j = 0; i < (long)strlen(headline)+1; i++) {
  699. #else
  700.   for (i = 0, j = 0; i < strlen(headline)+1; i++) {
  701. #endif
  702.     if ((headline[i] != '\r') && (headline[i] != '\n')) {
  703.       headline[j++] = headline[i];
  704.     }
  705.   }
  706.   
  707.  
  708.   for(i=strlen(headline) - 1 ; i > 0; i--){
  709.     if(isprint(headline[i])){
  710.       break;
  711.     }
  712.     headline[i] = '\0';
  713.   }
  714.   
  715.   return(headline);
  716. }
  717.  
  718.  
  719.                                                                                  
  720.