开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
HTWAIS.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：28k
源码类别：

浏览器

开发平台：

Unix_Linux

HTWAIS.c：源码内容
  1. /*        HTWAIS.c
  2. ** WORLDWIDEWEB - WIDE AREA INFORMAION SERVER ACCESS
  3. **
  4. ** (c) COPYRIGHT MIT 1995.
  5. ** Please first read the full copyright statement in the file COPYRIGH.
  6. **
  7. ** This module allows a WWW server or client to read data from a
  8. ** remote  WAIS server, and provide that data to a WWW client in
  9. ** hypertext form. Source files, once retrieved, are stored and used
  10. ** to provide information about the index when that is acessed.
  11. **
  12. ** Authors
  13. ** BK Brewster Kahle, Thinking Machines, <Brewster@think.com>
  14. ** TBL Tim Berners-Lee, CERN <timbl@w3.org>
  15. **
  16. ** History
  17. **    Sep 91 TBL adapted shell-ui.c (BK) with HTRetrieve.c from WWW.
  18. **    Feb 91 TBL Generated HTML cleaned up a bit (quotes, escaping)
  19. **     Refers to lists of sources. 
  20. **    Mar 93 TBL   Lib 2.0 compatible module made.
  21. **    May 95       CHJ modified for freeWAIS-0.5
  22. **
  23. ** Bugs
  24. ** Uses C stream i/o to read and write sockets, which won't work
  25. ** on VMS TCP systems.
  26. **
  27. ** Should cache connections.
  28. **
  29. ** ANSI C only as written
  30. **
  31. ** Bugs fixed
  32. **      NT Nathan Torkington (Nathan.Torkington@vuw.ac.nz)
  33. **
  34. ** WAIS comments:
  35. **
  36. ** 1. Separate directories for different system's .o would help
  37. ** 2. Document ids are rather long!
  38. **
  39. ** WWW Address mapping convention:
  40. **
  41. ** /servername/database/type/length/document-id
  42. **
  43. ** /servername/database?word+word+word
  44. */
  45. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  46.    No guarantees or restrictions.  See the readme file for the full standard
  47.    disclaimer.
  49.    Brewster@think.com
  50. */
  53. #define DIRECTORY "/cnidr.org:210/directory-of-servers"
  54. /* define DIRECTORY "/quake.think.com:210/directory-of-servers" */
  56. #define BIG 1024 /* identifier size limit  @@@@@ */
  58. /* From WAIS
  59. ** ---------
  60. */
  62. #include <ui.h>
  63. #include <sockets.h>
  65. #define MAX_MESSAGE_LEN 100000
  66. #define CHARS_PER_PAGE 10000 /* number of chars retrieved in each request */
  67. #define WAISSEARCH_DATE "Fri Jul 19 1991"
  70. /* FROM WWW
  71. ** --------
  72. */
  73. #define BUFFER_SIZE 4096 /* Arbitrary size for efficiency */
  75. #define HEX_ESCAPE '%'
  77. /* Library include files */
  78. #include "tcp.h"
  79. #include "HTUtils.h"
  80. #include "HTString.h"
  81. #include "HTParse.h"
  82. #include "HTReqMan.h"
  83. #include "HTError.h"
  84. #include "HTMLGen.h"
  85. #include "HTParse.h"
  86. #include "HTFormat.h"
  87. #include "HTTCP.h"
  88.  
  89. extern FILE * logfile; /* Log file output */
  91. PRIVATE int HTMaxWAISLines = 200;/* Max number of entries from a search */
  93. PRIVATE BOOL as_gate; /* Client is using us as gateway */
  95. PRIVATE char line[2048]; /* For building strings to display */
  96. /* Must be able to take id */
  98. /* Hypertext object building machinery */
  99. #define PUTC(c) (*target->isa->put_character)(target, c)
  100. #define PUTS(s) (*target->isa->put_string)(target, s)
  101. #define START(e) (*target->isa->start_element)(target, e, 0, 0)
  102. #define END(e) (*target->isa->end_element)(target, e)
  103. #define FREE_TARGET (*target->isa->_free)(target)
  105. struct _HTStructured {
  106. CONST HTStructuredClass * isa;
  107. /* ... */
  108. };
  110. struct _HTStream {
  111. CONST HTStreamClass * isa;
  112. /* ... */
  113. };
  116. /* showDiags
  117. */
  118. /* modified from Jonny G's version in ui/question.c */
  120. void showDiags (
  121. HTStream *  target,
  122. diagnosticRecord **  d)
  123. {
  124.   long i;
  126.   for (i = 0; d[i] != NULL; i++) {
  127.     if (d[i]->ADDINFO != NULL) {
  128.       PUTS("Diagnostic code is ");
  129.       PUTS(d[i]->DIAG);
  130.       PUTC(' ');
  131.       PUTS(d[i]->ADDINFO);
  132.       PUTC('n'); ;
  133.     }
  134.   }
  135. }
  137. /* Matrix of allowed characters in filenames
  138. ** -----------------------------------------
  139. */
  141. PRIVATE BOOL acceptable[256];
  142. PRIVATE BOOL acceptable_inited = NO;
  144. PRIVATE void init_acceptable (void)
  145. {
  146.     unsigned int i;
  147.     char * good = 
  148.       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./-_$";
  149.     for(i=0; i<256; i++) acceptable[i] = NO;
  150.     for(;*good; good++) acceptable[(unsigned int)*good] = YES;
  151.     acceptable_inited = YES;
  152. }
  154. /* Transform file identifier into WWW address
  155. ** ------------------------------------------
  156. **
  157. **
  158. ** On exit,
  159. ** returns nil if error
  160. ** pointer to malloced string (must be freed) if ok
  161. */
  162. char * WWW_from_archie  (char * file)
  163. {
  164.     char * end;
  165.     char * result;
  166.     char * colon;
  167.     for(end=file; *end > ' '; end++); /* assumes ASCII encoding*/
  168.     if ((result = (char  *) HT_MALLOC(10 + (end-file))) == NULL)
  169.         HT_OUTOFMEM("result ");
  170.     if (!result) return result; /* Malloc error */
  171.     strcpy(result, "file://");
  172.     strncat(result, file, end-file);
  173.     colon = strchr(result+7, ':'); /* Expect colon after host */
  174.     if (colon) {
  175. for(; colon[0]; colon[0]=colon[1], colon++); /* move down */
  176.     }
  177.     return result;
  178. } /* WWW_from_archie */
  180. /* Transform document identifier into URL
  181. ** --------------------------------------
  182. **
  183. ** Bugs: A static buffer of finite size is used!
  184. ** The format of the docid MUST be good!
  185. **
  186. ** On exit,
  187. ** returns nil if error
  188. ** pointer to malloced string (must be freed) if ok
  189. */
  190. PRIVATE char hex [17] = "0123456789ABCDEF";
  191. extern char from_hex (char a); /* In HTWSRC @@ */
  193. PRIVATE char * WWW_from_WAIS (any * docid)
  195. {
  196.     static unsigned char buf[BIG];
  197.     char num[10];
  198.     unsigned char * q = buf;
  199.     char * p = (docid->bytes);
  200.     int i, l;
  201.     if (PROT_TRACE) {
  202. char *p;
  203. TTYPrint(TDEST, "HTLoadWAIS.. id (%d bytes) is ", (int)docid->size);
  204. for(p=docid->bytes; p<docid->bytes+docid->size; p++) {
  205.     if ((*p >= ' ') && (*p<= '~')) /* Assume ASCII! */
  206. TTYPrint(TDEST, "%c", *p);
  207.     else
  208. TTYPrint(TDEST, "<%x>", (unsigned)*p);
  209. }
  210. TTYPrint(TDEST, "n");
  211.     }  
  212.     for (p=docid->bytes; (p<docid->bytes+docid->size) && (q<&buf[BIG]);) {
  213. if (PROT_TRACE)
  214.     TTYPrint(TDEST, "............ Record type %d, length %dn",
  215.     (unsigned char) p[0], (unsigned char) p[1]);
  216. sprintf(num, "%d", (int)*p);
  217. memcpy(q, num, strlen(num));
  218. q += strlen(num);
  219. p++;
  220. *q++ = '='; /* Separate */
  221. l = (int)((unsigned char)*p);
  222. p++;
  223. if (l > 127)
  224.     {
  225. l = (l - 128) * 128;
  226. l = l + (int)((unsigned char)*p);
  227. p++;
  228.     }
  230. for (i = 0; i < l; i++, p++)
  231.     {
  232. if (!acceptable[(unsigned char)*p]) 
  233.     {
  234. *q++ = HEX_ESCAPE;
  235. *q++ = hex[((unsigned char)*p) >> 4];
  236. *q++ = hex[((unsigned char)*p) & 15];
  237.     }
  238. else *q++ = (unsigned char)*p;
  239.     }
  240. *q++= ';'; /* Terminate field */
  241. #ifdef OLD_CODE
  242.         if (*p>10) {
  243.     if (PROT_TRACE)
  244. TTYPrint(TDEST, "WAIS........ DOCID record type of %d!n", *p);
  245.     return 0;
  246. }
  247. { /* Bug fix -- allow any byte value 15 Apr 93 */
  248.     unsigned int i = (unsigned) *p++;
  249.     
  250.     if (i > 99) {
  251. *q++ = (i/100) + '0';
  252. i = i % 100;
  253.     }
  254.     if (i > 9) {
  255. *q++ = (i/10) + '0';
  256. i = i % 10;
  257.     }
  258.     *q++ = i + '0'; /* Record type */
  259. }
  260. *q++ = '='; /* Separate */
  261. l = *p++; /* Length */
  262. for(i=0; i<l; i++, p++){
  263.     if (!acceptable[(int)*p]) {
  264. *q++ = HEX_ESCAPE; /* Means hex commming */
  265. *q++ = hex[(*p) >> 4];
  266. *q++ = hex[(*p) & 15];
  267.     }
  268.     else *q++ = *p;
  269. }
  270. *q++= ';'; /* Terminate field */
  271. #endif /* OLD_CODE */
  272.     }
  273.     *q++ = 0; /* Terminate string */
  274.     if (PROT_TRACE) TTYPrint(TDEST, "HTLoadWAIS.. WWW form of id: %sn", buf); 
  275.     {
  276.         char *result;
  277. if ((result = (char *) HT_MALLOC((int) strlen(buf)+1)) == NULL)
  278.     HT_OUTOFMEM("WWW_from_WAIS");
  279. strcpy(result, buf);
  280. return result;
  281.     }
  282. } /* WWW_from_WAIS */
  285. /* Transform URL into WAIS document identifier
  286. ** -------------------------------------------
  287. **
  288. ** On entry,
  289. ** docname points to valid name produced originally by
  290. ** WWW_from_WAIS
  291. ** On exit,
  292. ** docid->size is valid
  293. ** docid->bytes is malloced and must later be freed.
  294. */
  295. PRIVATE any * WAIS_from_WWW  (any * docid, char * docname)
  296. {
  297.     char *z;  /* Output pointer */
  298.     char *sor; /* Start of record - points to size field. */
  299.     char *p;  /* Input pointer */
  300.     char *q;  /* Poisition of "=" */
  301.     char *s;  /* Position of semicolon */
  302.     int n; /* size */
  303.     if (PROT_TRACE)
  304. TTYPrint(TDEST, "HTLoadWAIS.. WWW id (to become WAIS id): %sn",
  305. docname); 
  306.     for(n=0, p = docname; *p; p++) { /* Count sizes of strings */
  307.         n++;
  308. if (*p == ';')  n--; /* Not converted */
  309. else if (*p == HEX_ESCAPE) n=n-2; /* Save two bytes */
  310.         docid->size = n;
  311.     }
  312.     
  313.     /* result record */
  314.     if ((docid->bytes = (char *) HT_MALLOC(docid->size+32)) == NULL)
  315. HT_OUTOFMEM("docid->bytes");
  316.     z = docid->bytes;
  317.     
  318.     for(p = docname; *p; ) {
  319. q = strchr(p, '=');
  320. if (!q) 
  321.     return 0;
  322. *q = '';
  323. *z++ = atoi(p);
  324. *q = '=';
  325. s = strchr(q, ';'); /* (Check only) */
  326. if (!s) 
  327.     return 0; /* Bad! No ';'; */
  328. sor = z;          /* Remember where the size field was */
  329. z++;              /* Skip record size for now */
  331. {
  332.     int len;
  333.     int tmp;
  334.     for(p=q+1; *p!=';' ; ) {
  335. if (*p == HEX_ESCAPE) {
  336.     char c;
  337.     unsigned int b;
  338.     p++;
  339.     c = *p++;
  340.     b = from_hex(c);
  341.     c = *p++;
  342.     if (!c) 
  343. break; /* Odd number of chars! */
  344.     *z++ = (b<<4) + from_hex(c);
  345. } else {
  346.     *z++ = *p++; /* Record */
  347. }
  348.     }
  349.     len = (z-sor-1);
  350.     
  351.     z = sor;
  352.     if (len > 127) {
  353. tmp = (len / 128);
  354. len = len - (tmp * 128);
  355. tmp = tmp + 128;
  356. *z++ = (char)tmp;
  357. *z = (char)len;
  358.     } else {
  359. *z = (char)len;
  360.     }
  361.     z++;
  362. }
  364. for(p=q+1; *p!=';' ; )  {
  365.     if (*p == HEX_ESCAPE) {
  366. char c;
  367. unsigned int b;
  368. p++;
  369. c = *p++;
  370. b = from_hex(c);
  371. c = *p++;
  372. if (!c) 
  373.     break; /* Odd number of chars! */
  374. *z++ = (b<<4) + from_hex(c);
  375.     } else {
  376. *z++ = *p++; /* Record */
  377.     }
  378. }
  379. p++; /* After semicolon: start of next record */
  380.     }
  382. #ifdef OLD_CODE
  383.     for(p = docname; *p; ) { /* Convert of strings */
  384.      /* Record type */
  386. *z = 0; /* Initialize record type */
  387. while (*p >= '0' && *p <= '9') {
  388.     *z = *z*10 + (*p++ - '0'); /* Decode decimal record type */
  389. }
  390. z++;
  391. if (*p != '=') return 0;
  392. q = p;
  394. /*        *z++ = *p++ - '0';
  395. q = strchr(p , '=');
  396. if (!q) return 0;
  397. */
  398. s = strchr(q, ';'); /* (Check only) */
  399. if (!s) return 0; /* Bad! No ';'; */
  400.         sor = z; /* Remember where the size field was */
  401. z++; /* Skip record size for now */
  402. for(p=q+1; *p!=';' ; ) {
  403.    if (*p == HEX_ESCAPE) {
  404.         char c;
  405. unsigned int b;
  406. p++;
  407.         c = *p++;
  408. b =   from_hex(c);
  409. c = *p++;
  410. if (!c) break; /* Odd number of chars! */
  411. *z++ = (b<<4) + from_hex(c);
  412.     } else {
  413.         *z++ = *p++; /* Record */
  414.     }
  415. }
  416. *sor = (z-sor-1); /* Fill in size -- not counting size itself */
  417. p++; /* After semicolon: start of next record */
  418.     }
  419. #endif /* OLD_CODE */
  420.     if (PROT_TRACE) {
  421. char *p;
  422. TTYPrint(TDEST, "WAIS........ id (%d bytes) is ", (int)docid->size);
  423. for(p=docid->bytes; p<docid->bytes+docid->size; p++) {
  424.     if ((*p >= ' ') && (*p<= '~')) /* Assume ASCII! */
  425. TTYPrint(TDEST, "%c", *p);
  426.     else
  427. TTYPrint(TDEST, "<%x>", (unsigned)*p);
  428. }
  429. TTYPrint(TDEST, "n");
  430.     }  
  431.     return docid; /* Ok */
  432.     
  433. } /* WAIS_from_WWW */
  436. /* Send a plain text record to the client output_text_record()
  437. ** --------------------------------------
  438. */
  440. PRIVATE void output_text_record (
  441.     HTStream * target,
  442.     WAISDocumentText * record,
  443.     boolean quote_string_quotes,
  444.     boolean                    binary)
  445. {
  446.   long count;
  447.   if (binary) {
  448.     (*target->isa->put_block)(target,
  449.       record->DocumentText->bytes,
  450.       record->DocumentText->size);
  451.     return;
  452.   }
  454.   for(count = 0; count < record->DocumentText->size; count++){
  455.     long ch = (unsigned char)record->DocumentText->bytes[count];
  456.     if (ch == 27) { /* What is this in for? Tim */
  458.     /* then we have an escape code */
  459.     /* if the next letter is '(' or ')', then ignore two letters */
  460.     if('(' == record->DocumentText->bytes[count + 1] ||
  461. ')' == record->DocumentText->bytes[count + 1])
  462.     count += 1;             /* it is a term marker */
  463.     else count += 4; /* it is a paragraph marker */
  464.     } else if (ch == 'n' || ch == 'r') {
  465.     PUTC('n');
  466.     } else if ((ch=='t') || isprint(ch)){
  467.     PUTC(ch);
  468.     } 
  469.   }
  470. } /* output text record */
  474. /* Format A Search response for the client display_search_response
  475. ** ---------------------------------------
  476. ** modified from tracy shen's version in wutil.c
  477. ** displays either a text record or a set of headlines.
  478. */
  479. void display_search_response (HTStructured * target,
  480.       SearchResponseAPDU * response,
  481.       char * database,
  482.       char *   keywords)
  483. {
  484.   WAISSearchResponse  *info;
  485.   long i, k;
  486.   
  487.   BOOL archie =  strstr(database, "archie")!=0; /* Specical handling */
  488.   
  489.   if (PROT_TRACE) TTYPrint(TDEST, "WAIS........ Displaying search responsen");
  490.   sprintf(line,
  491.   "Index %s contains the following %d item%s relevant to '%s'.n",
  492.   database,
  493.   (int)(response->NumberOfRecordsReturned),
  494.   response->NumberOfRecordsReturned ==1 ? "" : "s",
  495.   keywords);
  496.   PUTS(line);
  497.   PUTS("The first figure for each entry is its relative score, ");
  498.   PUTS("the second the number of lines in the item.");
  499.   START(HTML_MENU);
  501.   if ( response->DatabaseDiagnosticRecords != 0 ) {
  502.     info = (WAISSearchResponse *)response->DatabaseDiagnosticRecords;
  503.     i =0; 
  505.     if (info->Diagnostics != NULL)
  506.       showDiags((HTStream*)target, info->Diagnostics);
  508.     if ( info->DocHeaders != 0 ) {
  509.       for (k=0; info->DocHeaders[k] != 0; k++ ) {
  510. WAISDocumentHeader* head = info->DocHeaders[k];
  511. char * headline = trim_junk(head->Headline);
  512. any * docid = head->DocumentID;
  513. char * docname; /* printable version of docid */
  514. i++;
  516. /* Make a printable string out of the document id.
  517. */
  518. if (PROT_TRACE)
  519.     TTYPrint(TDEST, "HTWAIS:  %2ld: Score: %4ld, lines:%4ld '%s'n", i,
  520.     (long int)(info->DocHeaders[k]->Score),
  521.     (long int)(info->DocHeaders[k]->Lines),
  522.     headline);
  524. START(HTML_LI);
  525. sprintf(line, "%4ld  %4ld  ",
  526.     head->Score,
  527.     head->Lines);
  528. PUTS(line);
  530. if (archie) {
  531.     char * www_name = WWW_from_archie(headline);
  532.     if (www_name) {
  533. HTStartAnchor(target, NULL, www_name);
  534. PUTS(headline);
  536. END(HTML_A);
  537. HT_FREE(www_name);
  538.     } else {
  539.  PUTS(headline);
  540.  PUTS(" (bad file name)");
  541.     }
  542. } else { /* Not archie */
  543.     docname =  WWW_from_WAIS(docid);
  544.     if (docname) {
  545. char * dbname = HTEscape(database, URL_XPALPHAS);
  546.                 char types_array[1000]; /* bad */
  547.                 char *type_escaped;
  548.                 types_array[0] = 0;
  549.                 if (head->Types) {
  550.                     int i;
  551.                     for (i = 0; head->Types[i]; i++)
  552.                       {
  553.                         if (i)
  554.                           strcat (types_array, ",");
  556.                         type_escaped = HTEscape (head->Types[i], URL_XALPHAS);
  557.                         strcat (types_array, type_escaped);
  558.                         HT_FREE(type_escaped);
  559.                       }
  560.                     if (PROT_TRACE)
  561.                       TTYPrint(TDEST, "WAIS........ Types_array `%s'n",
  562.        types_array);
  563. } else {
  564.                     strcat (types_array, "TEXT");
  565. }
  566. sprintf(line, "%s/%s/%d/%s",
  567.                         dbname,
  568.                         types_array,
  569.                         (int)(head->DocumentLength),
  570.                         docname);
  571. #ifdef OLD_CODE
  572. sprintf(line, "%s/%s/%d/%s", /* W3 address */
  573.     dbname,
  574.     head->Types ? head->Types[0] : "TEXT",
  575.     (int)(head->DocumentLength),
  576.     docname);
  577. #endif /* OLD_CODE */
  578. HTStartAnchor(target, NULL, ( (head->Types) 
  579.       && (!strcmp(head->Types[0], "URL"))) ? 
  580.       headline : line); /* NT, Sep 93 */
  581. PUTS(headline);
  582. END(HTML_A);
  583. HT_FREE(dbname);
  584. HT_FREE(docname);
  585.     } else {
  586.  PUTS("(bad doc id)");
  587.     }
  588.   }
  589.       } /* next document header */
  590.     } /* if there were any document headers */
  591.     
  592.     if ( info->ShortHeaders != 0 ) {
  593.       k =0;
  594.       while (info->ShortHeaders[k] != 0 ) {
  595. i++;
  596. PUTS( "(Short Header record, can't display)");
  597.       }
  598.     }
  599.     if ( info->LongHeaders != 0 ) {
  600.       k =0;
  601.       while (info->LongHeaders[k] != 0) {
  602. i++;
  603. PUTS( "nLong Header record, can't displayn");
  604.       }
  605.     }
  606.     if ( info->Text != 0 ) {
  607.       k =0;
  608.       while (info->Text[k] != 0) {
  609. i++;
  610. PUTS( "nText recordn");
  611. output_text_record((HTStream*)target, info->Text[k++], false, false);
  612.       }
  613.     }
  614.     if ( info->Headlines != 0 ) {
  615.       k =0;
  616.       while (info->Headlines[k] != 0) {
  617. i++;
  618. PUTS( "nHeadline record, can't displayn");
  619. /* dsply_headline_record( info->Headlines[k++]); */
  620.       }
  621.     }
  622.     if ( info->Codes != 0 ) {
  623.       k =0;
  624.       while (info->Codes[k] != 0) {
  625. i++;
  626. PUTS( "nCode record, can't displayn");
  627. /* dsply_code_record( info->Codes[k++]); */
  628.       }
  629.     }
  630.   } /* Loop: display user info */
  631.   END(HTML_MENU);
  632.   PUTC('n'); ;
  633. }
  638. /* Load Document from WAIS Server HTLoadWAIS()
  639. ** ------------------------------
  640. **
  641. ** On entry,
  642. ** request This is the request structure
  643. ** On exit,
  644. ** returns <0 Error has occured
  645. ** HT_LOADED OK
  646. */
  647. PUBLIC int HTLoadWAIS (SOCKET soc, HTRequest * request, SockOps ops)
  649. #define MAX_KEYWORDS_LENGTH 4000
  650. #define MAX_SERVER_LENGTH 1000
  651. #define MAX_DATABASE_LENGTH 1000
  652. #define MAX_SERVICE_LENGTH 1000
  654. {
  655.     CONST char * arg = HTAnchor_physical(request->anchor);
  656.     HTFormat format_out = request->output_format;
  657.     HTStream* sink = request->output_stream;
  658. #if 0    
  659.     static CONST char * error_header =
  660. "<h1>Access error</h1>nThe following error occured in accesing a WAIS server:<P>n";
  661. #endif
  662.     char * key;   /* pointer to keywords in URL */
  663.     char* request_message = NULL; /* arbitrary message limit */
  664.     char* response_message = NULL; /* arbitrary message limit */
  665.     long request_buffer_length; /* how of the request is left */
  666.     SearchResponseAPDU  *retrieval_response = 0;
  667.     char keywords[MAX_KEYWORDS_LENGTH + 1];
  668.     char *server_name;
  669.     char *wais_database = NULL; /* name of current database */
  670.     char *www_database; /* Same name escaped */
  671.     char *service;
  672.     char *doctype;
  673.     char *doclength;
  674.     long document_length;
  675.     char *docname;
  676.     FILE *connection = 0;
  677.     char * names; /* Copy of arg to be hacked up */
  678.     BOOL ok = NO;
  679.     int status = -1;
  680.     char *basetitle = NULL;
  681.     
  682. #if 0
  683.     extern FILE * connect_to_server();
  684. #endif
  685.     
  686.     if (PROT_TRACE)
  687. TTYPrint(TDEST, "HTLoadWAIS.. Looking for `%s'n", arg);
  688.      
  689.     if (!acceptable_inited) init_acceptable();
  690.     
  691.         
  692. /* Decipher and check syntax of WWW address:
  693. ** ----------------------------------------
  694. **
  695. ** First we remove the "wais:" if it was spcified.  920110
  696. */  
  697.     names = HTParse(arg, "", PARSE_HOST | PARSE_PATH | PARSE_PUNCTUATION);
  698.     key = strchr(names, '?');
  699.     
  700.     if (key) {
  701.      char * p;
  702. *key++ = 0; /* Split off keywords */
  703. for (p=key; *p; p++) if (*p == '+') *p = ' ';
  704. HTUnEscape(key);
  705.     }
  706.     if (names[0]== '/') {
  707. server_name = names+1;
  708. if ((as_gate =(*server_name == '/')))
  709.     server_name++; /* Accept one or two */
  710. www_database = strchr(server_name,'/');
  711. if (www_database) {
  712.     *www_database++ = 0; /* Separate database name */
  713.     doctype = strchr(www_database, '/');
  714.     if (key) ok = YES; /* Don't need doc details */
  715.     else if (doctype) { /* If not search parse doc details */
  716. *doctype++ = 0; /* Separate rest of doc address */
  717. doclength = strchr(doctype, '/');
  718. if(doclength) {
  719.     *doclength++ = 0;
  720.     document_length = atol(doclength);
  721.     if (document_length) {
  722. docname=strchr(doclength, '/');
  723. if (docname) {
  724.     *docname++ = 0;
  725.     ok = YES; /* To avoid a goto! */
  726. } /* if docname */
  727.     } /* if document_length valid */
  728. } /* if doclength */
  729.     } else { /* no doctype?  Assume index required */
  730.         if (!key) key = "";
  731. ok = YES;
  732.     } /* if doctype */
  733. } /* if database */
  734.      }
  735.      
  736.     if (!ok) {
  737. char *unescaped = NULL;
  738. StrAllocCopy(unescaped, arg);
  739. HTUnEscape(unescaped);
  740. HTRequest_addError(request, ERR_FATAL, NO, HTERR_BAD_REQUEST,
  741.    (void *) unescaped, (int) strlen(unescaped),
  742.    "HTLoadWAIS");
  743. HT_FREE(unescaped);
  744. HT_FREE(names);
  745. return -1;
  746.     }
  747.     
  748.     if (PROT_TRACE) TTYPrint(TDEST, "HTLoadWAIS.. URL Parsed OKn");
  749.      
  750.      service = strchr(names, ':');
  751.      if (service)  *service++ = 0;
  752.      else service = "210";
  753.      
  754.      if (server_name[0] == 0)
  755.         connection = NULL;
  757.      else if (!(key && !*key))
  758.       if ((connection=connect_to_server(server_name,atoi(service))) == NULL)  {
  759.   char *host = HTParse(arg, "", PARSE_HOST);
  760.   if (PROT_TRACE)
  761.       TTYPrint(TDEST, "HTLoadWAIS.. Can't open connection to %s via service %s.n",
  762.        server_name, service);
  763.   HTRequest_addError(request, ERR_FATAL, NO, HTERR_WAIS_NO_CONNECT,
  764.      (void *) host, (int) strlen(host), "HTLoadWAIS");
  765.   goto cleanup;
  766.       }
  768.     StrAllocCopy(wais_database,www_database);
  769.     HTUnEscape(wais_database);
  771.     /* Make title name without the .src */
  772.     {
  773. char *srcstr;
  774. StrAllocCopy(basetitle, wais_database);
  775. if ((srcstr = strstr(basetitle, ".src")) != NULL)
  776.     *srcstr = '';
  777.     }
  778.     
  779.     /* This below fixed size stuff is terrible */
  780.     if ((request_message = (char*)s_malloc((size_t)MAX_MESSAGE_LEN * sizeof(char))) == NULL)
  781. HT_OUTOFMEM("WAIS request message");
  782.     if ((response_message = (char*)s_malloc((size_t)MAX_MESSAGE_LEN * sizeof(char))) == NULL)
  783. HT_OUTOFMEM("WAIS response message");
  785. /* If keyword search is performed but there are no keywords,
  786. ** the user has followed a link to the index itself. It would be
  787. ** appropriate at this point to send him the .SRC file - how?
  788. */
  790.     if (key && !*key) { /* I N D E X */
  791.     
  792. #ifdef CACHE_FILE_PREFIX
  793. char filename[256];
  794. FILE * fp;
  795. #endif
  796. HTStructured * target = HTMLGenerator(request, NULL,
  797. WWW_HTML, format_out, sink);
  799. {
  800.     START(HTML_HTML);
  801.     START(HTML_HEAD);
  802.     START(HTML_TITLE);
  803.     PUTS(basetitle);
  804.     PUTS(" Index");
  805.     END(HTML_TITLE);
  806.     END(HTML_HEAD);
  807.     
  808.     START(HTML_BODY);
  809.     START(HTML_H1);
  810.     PUTS("WAIS Index: ");
  811.     PUTS(basetitle);
  812.     END(HTML_H1);
  813.     
  814. }
  815. START(HTML_ISINDEX);
  817. /* If we have seen a source file for this database, use that: */
  819. #ifdef CACHE_FILE_PREFIX
  820. sprintf(filename, "%sWSRC-%s:%s:%.100s.txt",
  821. CACHE_FILE_PREFIX,
  822. server_name, service, www_database);
  824. fp = fopen(filename, "r"); /* Have we found this already? */
  825. if (PROT_TRACE) TTYPrint(TDEST,
  826. "HTLoadWAIS.. Description of server %s %s.n",
  827. filename,
  828. fp ? "exists already" : "does NOT exist!");
  830. if (fp) {
  831.     int c;
  832.     START(HTML_PRE);  /* Preformatted description */
  833.     while((c=getc(fp)) != EOF)
  834. PUTC(c);     /* Transfer file */
  835.     END(HTML_PRE);
  836.     fclose(fp);
  837. }
  838. #endif
  839. END(HTML_BODY);
  840. END(HTML_HTML);
  841. FREE_TARGET;
  843.     } else if (key) { /* S E A R C H */
  844. char *p;
  845. HTStructured * target;
  847. strncpy(keywords, key, MAX_KEYWORDS_LENGTH);
  848. while ((p = strchr(keywords,'+'))) *p = ' ';
  849.     
  850.         /* Send advance title to get something fast to the other end */
  852. target = HTMLGenerator(request, NULL, WWW_HTML, format_out, sink);
  854. START(HTML_HTML);
  855. START(HTML_HEAD);
  856. START(HTML_TITLE);
  857. PUTS(keywords);
  858. PUTS(" in ");
  859. PUTS(basetitle);
  860. END(HTML_TITLE);
  861. END(HTML_HEAD);
  863. START(HTML_BODY);
  864. START(HTML_H1);
  865. PUTS("WAIS Search of "");
  866. PUTS(keywords);
  867. PUTS("" in ");
  868. PUTS(basetitle);
  869. END(HTML_H1);
  871. START(HTML_ISINDEX);
  873. request_buffer_length = MAX_MESSAGE_LEN; /* Amount left */
  874. if (PROT_TRACE)
  875.     TTYPrint(TDEST, "HTLoadWAIS.. Search for `%s' in `%s'n",
  876.     keywords, wais_database);
  877. if(generate_search_apdu(request_message + HEADER_LENGTH, 
  878. &request_buffer_length, 
  879. keywords, wais_database, NULL,
  880. HTMaxWAISLines) == NULL) {
  881.     if (PROT_TRACE)
  882. TTYPrint(TDEST, "WAIS Search. Too many lines in responsen");
  883.     HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
  884.        NULL, 0, "HTLoadWAIS");
  885. }
  887. if(!interpret_message(request_message, 
  888. MAX_MESSAGE_LEN - request_buffer_length, 
  889. response_message,
  890. MAX_MESSAGE_LEN,
  891. connection,
  892. false /* true verbose */
  893. )) {
  894.     if (PROT_TRACE)
  895. TTYPrint(TDEST, "WAIS Search. Too many lines in responsen");
  896.     HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
  897.        NULL, 0, "HTLoadWAIS");
  898.         } else { /* returned message ok */
  899.     SearchResponseAPDU  *query_response = 0;
  900.     readSearchResponseAPDU(&query_response,
  901.      response_message + HEADER_LENGTH);
  902.     display_search_response(target, 
  903.      query_response, wais_database, keywords);
  904.     if (query_response->DatabaseDiagnosticRecords)
  905. freeWAISSearchResponse(
  906. query_response->DatabaseDiagnosticRecords);         
  907.     freeSearchResponseAPDU( query_response);
  908. } /* returned message not too large */
  909.     
  910. END(HTML_BODY);
  911. END(HTML_HTML);
  912. FREE_TARGET;
  914.     } else { /* D O C U M E N T    F E T C H */
  915.     
  916. boolean binary;     /* how to transfer stuff coming over */
  917. HTStream * target;
  918. long count;
  919. any   doc_chunk;
  920. any * docid = &doc_chunk;
  921. if (PROT_TRACE)
  922.     TTYPrint(TDEST, 
  923.     "HTLoadWAIS.. Retrieve document `%s'n............ type `%s' length %ldn", docname, doctype, document_length);
  925. HTAnchor_setFormat(request->anchor,
  926.   !strcmp(doctype, "WSRC") ? HTAtom_for("application/x-wais-source") :
  927.   !strcmp(doctype, "TEXT") ? WWW_UNKNOWN :
  928.   !strcmp(doctype, "HTML") ? WWW_HTML:
  929.   !strcmp(doctype, "GIF")  ? WWW_GIF:
  930.                  HTAtom_for("application/octet-stream"));
  931. binary = 
  932.   0 != strcmp(doctype, "WSRC") &&
  933.   0 != strcmp(doctype, "TEXT") &&
  934.   0 != strcmp(doctype, "HTML") ;
  936. /* Guess on TEXT format as it might be HTML */
  937. if ((target = HTStreamStack(HTAnchor_format(request->anchor),
  938.     request->output_format,
  939.     request->output_stream,
  940.     request, YES)) == NULL) {
  941.     status = -1;
  942.     goto cleanup;
  943. }
  945. /* Decode hex or litteral format for document ID */
  946. WAIS_from_WWW(docid, docname);
  948. /* Loop over slices of the document */
  949. for (count = 0; count * CHARS_PER_PAGE < document_length; count++) {
  950.     char *type = s_strdup(doctype);
  951.     request_buffer_length = MAX_MESSAGE_LEN;       /* Amount left */
  952.     if (PROT_TRACE) TTYPrint(TDEST, "HTLoadWAIS.. Slice number %ldn",
  953.        count);
  954.     if (generate_retrieval_apdu(request_message + HEADER_LENGTH,
  955. &request_buffer_length, 
  956. docid, CT_byte,
  957. count * CHARS_PER_PAGE,
  958. HTMIN((count + 1) * CHARS_PER_PAGE,
  959.       document_length),
  960. type,
  961. wais_database) == 0) {
  962. HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
  963.    NULL, 0, "HTLoadWAIS");
  964.     }
  965.     HT_FREE(type);
  966.     
  967.     /* Actually do the transaction given by request_message */   
  968.     if (interpret_message(request_message, 
  969.   MAX_MESSAGE_LEN - request_buffer_length, 
  970.   response_message,
  971.   MAX_MESSAGE_LEN,
  972.   connection,
  973.   false /* true verbose */
  974.   ) == 0) {
  975. HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
  976.    NULL, 0, "HTLoadWAIS");
  977.     }
  978.     
  979.     /* Parse the result which came back into memory. */
  980.     readSearchResponseAPDU(&retrieval_response, 
  981.    response_message + HEADER_LENGTH);
  982.     {
  983. WAISSearchResponse *searchres = (WAISSearchResponse *) retrieval_response->DatabaseDiagnosticRecords;
  984. if (!searchres->Text) {
  985.     if (searchres->Diagnostics && *searchres->Diagnostics &&
  986. (*searchres->Diagnostics)->ADDINFO) {
  987. char *errmsg = (*searchres->Diagnostics)->ADDINFO;
  988. HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_MODULE,
  989.    (void *) errmsg, (int) strlen(errmsg),
  990.    "HTLoadWAIS");
  991.     } else {
  992. HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_MODULE,
  993.    NULL, 0, "HTLoadWAIS");
  994.     }
  995.     (*target->isa->_free)(target);
  996.     request->output_stream = NULL;
  997.     HT_FREE(docid->bytes);
  998.     freeWAISSearchResponse(retrieval_response->DatabaseDiagnosticRecords); 
  999.     freeSearchResponseAPDU( retrieval_response);
  1000.     goto cleanup;
  1001. } else {
  1002.     output_text_record(target, *searchres->Text,
  1003.        false, binary);
  1004.     freeWAISSearchResponse( retrieval_response->DatabaseDiagnosticRecords);
  1005.     freeSearchResponseAPDU( retrieval_response);
  1006. } /* If text existed */
  1007.     }
  1008.     
  1009. } /* Loop over slices */
  1011. (*target->isa->_free)(target);
  1012. request->output_stream = NULL;
  1013. HT_FREE(docid->bytes);
  1014.     } /* If document rather than search */
  1015.     status = HT_LOADED;
  1017.   cleanup:
  1018.     if (connection) close_connection_to_server(connection);
  1019.     if (wais_database) HT_FREE(wais_database);
  1020.     if (request_message) s_free(request_message);
  1021.     if (response_message) s_free(response_message);
  1022.     HT_FREE(names);
  1023.     HT_FREE(basetitle);
  1024.     if (status < 0) {
  1025. char *unescaped = NULL;
  1026. StrAllocCopy(unescaped, arg);
  1027. HTUnEscape(unescaped);
  1028. HTRequest_addError(request, ERR_FATAL, NO, HTERR_INTERNAL, (void *) unescaped,
  1029.    (int) strlen(unescaped), "HTLoadWAIS");
  1030. HT_FREE(unescaped);
  1031.     }
  1032.     return status;
  1033. }