home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / WAIS / ir / ui.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-02  |  13.6 KB  |  544 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. /* 
  9.  * this is a simple ui toolkit for building other ui's on top.
  10.  * -brewster
  11.  * 
  12.  * top level functions:
  13.  *   generate_search_apdu
  14.  *   generate_retrieval_apdu
  15.  *   interpret_message
  16.  *
  17.  */
  18.  
  19. /* to do:
  20.  *   generate multiple queries for long documents.
  21.  *     this will crash if the file being retrieved is larger than 100k.
  22.  *   
  23.  */
  24.  
  25. #include "ui.h"
  26. #include "wutil.h"
  27. #include "ustubs.h"
  28.  
  29. #include <ctype.h>
  30. #include <errno.h>
  31. #include <string.h>
  32. #include <sys/types.h>
  33.  
  34. #define HOSTNAME_BUFFER_SIZE 120
  35.  
  36. /* returns a pointer in the buffer of the first free byte.
  37.    if it overflows, then NULL is returned 
  38.  */
  39. char *
  40. generate_search_apdu(buff,
  41.              buff_len,
  42.              seed_words,
  43.              database_name,
  44.              docobjs,
  45.              maxDocsRetrieved)
  46. char* buff;     /* buffer to hold the apdu */
  47. long *buff_len;    /* length of the buffer changed to reflect new data written */
  48. char *seed_words;    /* string of the seed words */
  49. char *database_name;
  50. DocObj** docobjs;
  51. long maxDocsRetrieved;
  52. {
  53.   /* local variables */
  54.  
  55.   SearchAPDU *search3;
  56.   char  *end_ptr;
  57.   static char *database_names[2] = {"", 0};
  58.   any refID;
  59.   WAISSearch *query;
  60.   refID.size = 1;
  61.   refID.bytes = "3";
  62.  
  63.   database_names[0] = database_name;
  64.   query = makeWAISSearch(seed_words,
  65.                          docobjs, /* DocObjsPtr */
  66.                          0L,
  67.                          1L,     /* DateFactor */
  68.                          0L,     /* BeginDateRange */
  69.                          0L,     /* EndDateRange */
  70.                          maxDocsRetrieved
  71.                          );
  72.  
  73.   search3 = makeSearchAPDU(30L, 
  74.                5000L, /* should be large */
  75.                30L,
  76.                            1L,    /* replace indicator */
  77.                            "",    /* result set name */
  78.                            database_names, /* database name */   
  79.                            QT_RelevanceFeedbackQuery, /* query_type */
  80.                            0L,   /* element name */
  81.                            NULL, /* reference ID */
  82.                            query);
  83.  
  84.   end_ptr = writeSearchAPDU(search3, buff, buff_len);
  85.  
  86.   CSTFreeWAISSearch(query);
  87.   freeSearchAPDU(search3);
  88.   return(end_ptr);
  89. }
  90.  
  91.  
  92. /* returns a pointer into the buffer of the next free byte.
  93.    if it overflowed, then NULL is returned
  94.  */
  95.  
  96. char *
  97. generate_retrieval_apdu(buff,
  98.             buff_len,
  99.             docID,
  100.             chunk_type,
  101.             start,
  102.             end,
  103.             type,
  104.             database_name)
  105. char *buff;
  106. long *buff_len;    /* length of the buffer changed to reflect new data written */
  107. any *docID;
  108. long chunk_type;
  109. long start;
  110. long end;
  111. char *type;
  112. char *database_name;
  113. {
  114.   SearchAPDU *search;
  115.   char  *end_ptr;
  116.  
  117.   static char *database_names[2];
  118.   static char *element_names[3];
  119.   any refID;
  120.  
  121.   DocObj *DocObjs[2];
  122.   any *query;            /* changed from char* by brewster */
  123.  
  124.   if(NULL == type)
  125.     type = s_strdup("TEXT");
  126.  
  127.   database_names[0] = database_name;
  128.   database_names[1] = NULL;
  129.  
  130.   element_names[0] = " ";
  131.   element_names[1] = ES_DocumentText;
  132.   element_names[2] = NULL;
  133.  
  134.   refID.size = 1;
  135.   refID.bytes = "3";
  136.   
  137.   switch(chunk_type){
  138.   case CT_line: 
  139.     DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
  140.     break;
  141.   case CT_byte:
  142.     DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
  143.     break;
  144.   }
  145.   DocObjs[1] = NULL;
  146.  
  147.   query = makeWAISTextQuery(DocObjs);   
  148.   search = makeSearchAPDU( 10L, 16L, 15L, 
  149.               1L,    /* replace indicator */
  150.               "FOO", /* result set name */
  151.               database_names, /* database name */   
  152.               QT_TextRetrievalQuery, /* query_type */
  153.               element_names, /* element name */
  154.               &refID, /* reference ID */
  155.               query);
  156.   end_ptr = writeSearchAPDU(search, buff, buff_len);
  157.   CSTFreeWAISTextQuery(query);
  158.   freeSearchAPDU(search);
  159.   return(end_ptr);
  160. }
  161.  
  162. /* not currently used 
  163.  
  164. static boolean isnumber _AP((char* string));
  165.  
  166. static boolean isnumber(string)
  167. char *string;
  168. {
  169.   long count;
  170.   for(count = 0; count < strlen(string); count++){
  171.     if(!isdigit(string[count])){
  172.       return(false);
  173.     }
  174.   }
  175.   return(true);
  176. }
  177.  
  178. */
  179.  
  180. /* this will negotiate with server, and returs the maximum buffer size 
  181.    the server can handle.
  182.  
  183.    A connection should be established first using open_socket.
  184.  
  185. */
  186.  
  187. long init_connection(inBuffer, outBuffer, bufferSize, connection, userInfo)
  188. char *inBuffer, *outBuffer;
  189. long bufferSize;
  190. FILE *connection;
  191. char *userInfo;
  192. { 
  193.   InitAPDU* init = NULL;
  194.   InitResponseAPDU* reply = NULL;
  195.   long result;
  196.   /* construct an init */
  197.   init = makeInitAPDU(true,false,false,false,false,bufferSize,bufferSize,
  198.               userInfo,defaultImplementationID(),
  199.               defaultImplementationName(),
  200.               defaultImplementationVersion(),NULL,userInfo);
  201.   /* write it to the buffer */
  202.   result = writeInitAPDU(init,inBuffer+HEADER_LENGTH,&bufferSize) - inBuffer;
  203.  
  204.   if(result < 0){
  205.     freeInitAPDU(init);
  206.     return(-1);
  207.   }
  208.   if(0 ==
  209.      interpret_message(inBuffer,
  210.                result - HEADER_LENGTH,
  211.                outBuffer,
  212.                bufferSize,
  213.                connection,
  214.                false    /* true verbose */    
  215.                )) {
  216.     /* error making a connection */
  217.     return (-1);
  218.   }
  219.   if (readInitResponseAPDU(&reply,outBuffer + HEADER_LENGTH) == NULL){
  220.     freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  221.     freeInitResponseAPDU(reply);
  222.     return(-1);
  223.   }
  224.   if (reply->Result == false)
  225.     {                /* the server declined service */
  226.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  227.       freeInitResponseAPDU(reply);
  228.       return(-1);
  229.     }
  230.   else                /* we got a response back */
  231.     { result = reply->MaximumRecordSize;
  232.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  233.       freeInitResponseAPDU(reply);
  234.       return(result);
  235.     }
  236. }
  237.  
  238. /* returns the length of the response, 0 if an error */
  239. long
  240. locally_answer_message(request_message,
  241.                request_length,
  242.                response_message,
  243.                response_buffer_length)
  244. char *request_message;
  245. long request_length;
  246. char *response_message;
  247. long response_buffer_length;
  248. {
  249.   long request_length_internal = request_length;
  250.   long response_length;
  251.   WAISMessage header;
  252.   long maxBufferSize = response_buffer_length;
  253.  
  254.   readWAISPacketHeader(request_message, &header);
  255.   {
  256.     char length_array[11];
  257.     strncpy(length_array, header.msg_len, 10);
  258.     length_array[10] = '\0';
  259.     request_length_internal = atol(length_array);
  260.   }
  261.   /*
  262.     printf("request length is %ld (%ld from caller)\n", 
  263.     request_length_internal,
  264.     request_length);
  265.     */
  266.   
  267.   response_length =
  268.     interpret_buffer(request_message + HEADER_LENGTH, 
  269.              request_length_internal,
  270.              response_message + HEADER_LENGTH,
  271.              response_buffer_length,
  272.              &maxBufferSize,
  273.              (long)header.hdr_vers,
  274.              NULL);
  275.   if(0 == response_length)
  276.     return(0);
  277.   writeWAISPacketHeader(response_message,
  278.             response_length,
  279.             (long)'z',    /* Z39.50 */
  280.             "DowQuest  ", /* server name */
  281.             (long)NO_COMPRESSION,    /* no compression */
  282.             (long)NO_ENCODING,(long)header.hdr_vers);
  283.   return(response_length);
  284. }
  285.  
  286. /* this is a safe version of unix 'read' it does all the checking
  287.  * and looping necessary
  288.  * to those trying to modify the transport code to use non-UNIX streams:
  289.  *  This is the function to modify!
  290.  */
  291. long read_from_stream(d,buf,nbytes)
  292. long d;                /* this is the stream */
  293. char *buf;
  294. long nbytes;
  295. {
  296.   long didRead;
  297.   long toRead = nbytes;
  298.   long totalRead = 0;        /* paranoia */
  299.  
  300.   while (toRead > 0){
  301.     didRead = read (d, buf, toRead);
  302.     if(didRead == -1)        /* error*/
  303.       return(-1);
  304.     if(didRead == 0)        /* eof */
  305.       return(-2);        /* maybe this should return 0? */
  306.     toRead -= didRead;
  307.     buf += didRead;
  308.     totalRead += didRead;
  309.   }
  310.   if(totalRead != nbytes)    /* we overread for some reason */
  311.     return(- totalRead);    /* bad news */    
  312.   return(totalRead);
  313. }
  314.  
  315. /* returns the length of the response, 0 if an error */
  316.  
  317. long 
  318. transport_message(connection,
  319.           request_message,
  320.           request_length,
  321.           response_message,
  322.           response_buffer_length)
  323. FILE *connection;
  324. char *request_message;
  325. long request_length;
  326. char *response_message;
  327. long response_buffer_length;
  328. {
  329.   WAISMessage header;
  330.   long response_length;
  331.  
  332.   
  333.   /* Write out message. Read back header. Figure out response length. */
  334.   
  335.   if( request_length + HEADER_LENGTH
  336.      != fwrite (request_message, 1L, request_length + HEADER_LENGTH, connection))
  337.     return 0;
  338.  
  339.   fflush(connection);
  340.  
  341.   /* read for the first '0' */
  342.  
  343.   while(1){
  344.     if(0 > read_from_stream(connection->_file, response_message, 1))
  345.       return 0;
  346.     if('0' == response_message[0])
  347.       break;
  348.   }
  349.  
  350.   if(0 > read_from_stream(connection->_file, 
  351.                   response_message + 1, 
  352.                   HEADER_LENGTH - 1))
  353.     return 0;
  354.  
  355.   readWAISPacketHeader(response_message, &header);
  356.   {
  357.     char length_array[11];
  358.     strncpy(length_array, header.msg_len, 10);
  359.     length_array[10] = '\0';
  360.     response_length = atol(length_array);
  361.     /*
  362.       if(verbose){
  363.       printf("WAIS header: '%s' length_array: '%s'\n", 
  364.       response_message, length_array);
  365.       }
  366.       */
  367.     if(response_length > response_buffer_length){
  368.       /* we got a message that is too long, therefore empty the message out,
  369.      and return 0 */
  370.       long i;
  371.       for(i = 0; i < response_length; i++){
  372.     read_from_stream(connection->_file, 
  373.              response_message + HEADER_LENGTH,
  374.              1);
  375. /*    fread(response_message + HEADER_LENGTH, 1, 1, connection); */
  376.       }
  377.       return(0);
  378.     }
  379.   }
  380.   if(0 > read_from_stream(connection->_file, 
  381.                   response_message + HEADER_LENGTH,
  382.                   response_length))
  383. /*  if(0 > fread(response_message + HEADER_LENGTH,
  384.            1, response_length, connection)) */
  385.     return 0;
  386.   return(response_length);
  387. }
  388.  
  389. /* returns the number of bytes writeen.  0 if an error */
  390. long
  391. interpret_message(request_message,request_length,
  392.           response_message,
  393.           response_buffer_length,
  394.           connection,
  395.           verbose)
  396. char *request_message;
  397. long request_length; /* length of the buffer */
  398. char *response_message;
  399. long response_buffer_length;
  400. FILE *connection;
  401. boolean verbose;
  402. {
  403.   long response_length;
  404.  
  405.   /* ?
  406.   if(verbose){
  407.     printf ("sending");
  408.     if(hostname_internal && strlen(hostname_internal) > 0)
  409.       printf(" to host %s", hostname_internal);
  410.     if(service_name && strlen(service_name) > 0)
  411.       printf(" for service %s", service_name);
  412.     printf("\n");
  413.     twais_dsply_rsp_apdu(request_message + HEADER_LENGTH, 
  414.              request_length);
  415.   }
  416.  
  417.   */
  418.  
  419.   writeWAISPacketHeader(request_message,
  420.             request_length,
  421.             (long)'z',    /* Z39.50 */
  422.             "wais      ", /* server name */
  423.             (long)NO_COMPRESSION,    /* no compression */
  424.             (long)NO_ENCODING,(long)HEADER_VERSION);
  425.   if(connection != NULL) {
  426.     if(0 == 
  427.        (response_length =
  428.     transport_message(connection, request_message,
  429.               request_length,
  430.               response_message,
  431.               response_buffer_length)))
  432.       return(0);
  433.   }
  434.   else{
  435.     if(0 == 
  436.        (response_length =
  437.     locally_answer_message(request_message, request_length, 
  438.                    response_message,
  439.                    response_buffer_length)))
  440.       return(0);
  441.   }
  442.   if(verbose){
  443.     printf ("decoded %ld bytes: \n", response_length);
  444.     twais_dsply_rsp_apdu(response_message + HEADER_LENGTH, 
  445.              request_length);
  446.   }
  447.   return(response_length);
  448. }
  449.  
  450. /* this closes the connection to the socket.
  451.  * the mythology is that this is cleaner than exiting
  452.  */
  453.  
  454. long close_connection(connection)
  455. FILE *connection;
  456. {
  457.   long result = 0;
  458.   
  459.   if(connection != NULL){
  460.     result = fclose(connection);
  461.   }
  462.   return(result);
  463. }
  464.   
  465. void
  466. display_text_record_completely(record,quote_string_quotes)
  467. WAISDocumentText *record;
  468. boolean quote_string_quotes;
  469. {
  470.   long count;
  471.   /* printf(" Text\n");
  472.      print_any("     DocumentID:  ", record->DocumentID);
  473.      printf("     VersionNumber:  %d\n", record->VersionNumber);
  474.      */
  475.   for(count = 0; count < record->DocumentText->size; count++){
  476.     long ch = (unsigned char)record->DocumentText->bytes[count];
  477.     if(27 == ch){
  478.       /* then we have an escape code */
  479.       /* if the next letter is '(' or ')', then ignore two letters */
  480.       if('(' == record->DocumentText->bytes[count + 1] ||
  481.      ')' == record->DocumentText->bytes[count + 1])
  482.     count += 1;             /* it is a term marker */
  483.       else count += 4;        /* it is a paragraph marker */
  484.     }
  485.     else if (ch == '\t') /* a TAB! */
  486.       putc(ch, stdout);
  487.     else if (isprint(ch)){
  488.       if(quote_string_quotes && ch == '"')
  489.     putc('\\', stdout);
  490.       putc(ch, stdout);
  491.     } 
  492.     else if (ch == '\n' || ch == '\r')
  493.       printf ("\n");
  494.   }
  495. }
  496.  
  497. /* modifies the string to exclude all seeker codes. sets length to
  498.    the new length. */
  499. char *delete_seeker_codes(string,length)
  500. char *string;
  501. long *length;
  502. {
  503.   long original_count; /* index into the original string */
  504.   long new_count = 0; /* index into the collapsed string */
  505.   for(original_count = 0; original_count < *length; original_count++){
  506.     if(27 == string[original_count]){
  507.       /* then we have an escape code */
  508.       /* if the next letter is '(' or ')', then ignore two letters */
  509.       if('(' == string[original_count + 1] ||
  510.     ')' == string[original_count + 1])
  511.      original_count += 1;    /* it is a term marker */
  512.       else original_count += 4; /* it is a paragraph marker */
  513.     }
  514.     else string[new_count++] = string[original_count];
  515.   }
  516.   *length = new_count;
  517.   return(string);
  518. }
  519.   
  520.  
  521. /* returns a pointer to a string with good stuff */
  522. char *trim_junk(headline)
  523. char *headline;
  524. {
  525.   long length = strlen(headline) + 1; /* include the trailing null */
  526.   long i;
  527.   headline = delete_seeker_codes(headline, &length);
  528.   /* delete leading spaces */
  529.   for(i=0; i < strlen(headline); i++){
  530.     if(isprint(headline[i])){
  531.       break;
  532.     }
  533.   }
  534.   headline = headline + i;
  535.   /* delete trailing stuff */
  536.   for(i=strlen(headline) - 1 ; i > 0; i--){
  537.     if(isprint(headline[i])){
  538.       break;
  539.     }
  540.     headline[i] = '\0';
  541.   }
  542.   return(headline);
  543. }
  544.