htwais.c

www工具包. 这是W3C官方支持的www支撑库. 其中提供通用目的的客户端的WebAPI: complete HTTP/1.1 (with caching, pipelining, PUT, POS

	/* Accept one or two */
    if ((theWAISinfo->as_gate = (*server_name == '/'))) server_name++;

    if ((theWAISinfo->www_database = strchr(server_name, '/')))
      {
       *(theWAISinfo->www_database)++ = 0;  /* Separate database name */
       doctype = strchr(theWAISinfo->www_database, '/');

       if (key)
	 ok = YES;	/* Don't need doc details */
        else
	 if (doctype)
	   {	/* If not search parse doc details */
	    char* doclength;

	    *doctype++ = 0;	/* Separate rest of doc address */
	    doclength = strchr(doctype, '/');
	    if (doclength)
	      {
	       *doclength++ = 0;
	       document_length = atol(doclength);
	       if (document_length)
		 {
		  docname = strchr(doclength, '/');
		  if (docname)
		    {
		     *docname++ = 0;
		     ok = YES;	/* To avoid a goto! */
		    } /* if docname */
		 } /* if document_length valid */
	      } /* if doclength */
	   }
	  else
	   { /* no doctype?  Assume index required */
	    if (!key) key = "";
	    ok = YES;
	   } /* if doctype */
      } /* if database */
   }
     
 if (!ok)
   {
    char *unescaped = NULL;

    StrAllocCopy(unescaped, arg);
    HTUnEscape(unescaped);
    HTRequest_addError(request, ERR_FATAL, NO, HTERR_BAD_REQUEST,
		       (void *) unescaped, (int) strlen(unescaped),
		       "HTLoadWAIS");
    HT_FREE(unescaped);
    HT_FREE(theWAISinfo->names);
    return -1;
   }
    
 HTTRACE(PROT_TRACE, "HTLoadWAIS.. URL Parsed OK\n");
 theWAISinfo->state = HTWAIS_NEED_CONNECTION;

 if ((service = strchr(theWAISinfo->names, ':')))
   *service++ = 0;
  else
   service = "210";

 if ((server_name ? server_name[0] : 0))
   {
    boolean do_need_to_connect_to_server = true;

    if (key) if ((*key) == 0) do_need_to_connect_to_server = false;

    if (do_need_to_connect_to_server)
      {
       if ((theWAISinfo->connection = connect_to_server(server_name,
							atoi(service)))
	   == NULL)
	 {
	  char* host = HTParse(arg, "", PARSE_HOST);

	  HTTRACE(PROT_TRACE, "HTLoadWAIS.."
		    " Can't open connection to %s via service %s.\n" _ 
		    server_name _ service);

	  HTRequest_addError(request, ERR_FATAL, NO, HTERR_WAIS_NO_CONNECT,
			     (void *) host, (int) strlen(host), "HTLoadWAIS");
	  theWAISinfo->result = HT_ERROR;
	  HTWAISCleanup(request, status);
	  return status;
	 }
      }
   }
  else
   theWAISinfo->connection = NULL;

 StrAllocCopy(theWAISinfo->wais_database, theWAISinfo->www_database);
 HTUnEscape(theWAISinfo->wais_database);


 /* Make title name without the .src */
 {
  char *srcstr;

  StrAllocCopy(theWAISinfo->basetitle, theWAISinfo->wais_database);
  if ((srcstr = strstr(theWAISinfo->basetitle, ".src")) != NULL)
    *srcstr = '\0';
 }
    

 /* This below fixed size stuff is terrible */
 if ((theWAISinfo->request_message =
                       (char*)s_malloc((size_t)MAX_MESSAGE_LEN * sizeof(char)))
     == NULL)
   HT_OUTOFMEM("WAIS request message");

 if ((theWAISinfo->response_message =
                       (char*)s_malloc((size_t)MAX_MESSAGE_LEN * sizeof(char)))
     == NULL)
   HT_OUTOFMEM("WAIS response message");


 /*	If keyword search is performed but there are no keywords,
 **	the user has followed a link to the index itself.
 **     It would be appropriate at this point to send him the .SRC file - how?
 */

 if (key)
   {
    if (*key)
      {
      /*
       *   S E A R C H   (nonempty key (*key != 0))
       */
       char *p;
       HTStructured* target;

       theWAISinfo->state = HTWAIS_NEED_RESPONSE;

       strncpy(keywords, key, MAX_KEYWORDS_LENGTH);
       while ((p = strchr(keywords,'+'))) *p = ' ';

       /* Send advance title to get something fast to the other end */

       target = HTMLGenerator(request, NULL, WWW_HTML, format_out, sink);

       START(HTML_HTML);
       START(HTML_HEAD);
       START(HTML_TITLE);
       PUTS(keywords);
       PUTS(" in ");
       PUTS(theWAISinfo->basetitle);
       END(HTML_TITLE);
       END(HTML_HEAD);

       START(HTML_BODY);
       START(HTML_H1);
       PUTS("WAIS Search of \"");
       PUTS(keywords);
       PUTS("\" in ");
       PUTS(theWAISinfo->basetitle);
       END(HTML_H1);

       START(HTML_ISINDEX);

       request_buffer_length = MAX_MESSAGE_LEN; /* Amount left */
       HTTRACE(PROT_TRACE, "HTLoadWAIS.. Search for `%s' in `%s'\n" _ 
		 keywords _ theWAISinfo->wais_database);

       if (generate_search_apdu(theWAISinfo->request_message + HEADER_LENGTH, 
				&request_buffer_length, 
				keywords, theWAISinfo->wais_database, NULL,
				HTMaxWAISLines) == NULL)
	 {
	  HTTRACE(PROT_TRACE, "WAIS Search. Too many lines in response\n");

	  HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
			     NULL, 0, "HTLoadWAIS");
	 }

       if (!interpret_message(theWAISinfo->request_message, 
			      MAX_MESSAGE_LEN - request_buffer_length, 
			      theWAISinfo->response_message,
			      MAX_MESSAGE_LEN,
			      theWAISinfo->connection,
			      false	/* true verbose */
			      ))
	 {
	  HTTRACE(PROT_TRACE, "WAIS Search. Too many lines in response\n");

	  HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
			     NULL, 0, "HTLoadWAIS");
	 }
        else
	 {	/* returned message ok */
	  SearchResponseAPDU  *query_response = 0;

	  readSearchResponseAPDU(&query_response,
				theWAISinfo->response_message + HEADER_LENGTH);
	  display_search_response(target, 
				  query_response, theWAISinfo->wais_database,
				  keywords);
	  if (query_response->DatabaseDiagnosticRecords)
	    freeWAISSearchResponse(query_response->DatabaseDiagnosticRecords);

	  freeSearchResponseAPDU(query_response);
	 }	/* returned message not too large */

       END(HTML_BODY);
       END(HTML_HTML);
       FREE_TARGET;

       HTAnchor_setFormat(anchor, WWW_HTML);

       theWAISinfo->result = status = HT_LOADED;
      }
     else
      {
      /*
       *   I N D E X   (key is empty (*key = 0))
       */
#ifdef CACHE_FILE_PREFIX
       char filename[256];
       FILE * fp;
#endif
       HTStructured* target = HTMLGenerator(request, NULL,
					    WWW_HTML, format_out, sink);

       theWAISinfo->state = HTWAIS_NEED_REQUEST;

       {
	START(HTML_HTML);
	START(HTML_HEAD);
	START(HTML_TITLE);
	PUTS(theWAISinfo->basetitle);
	PUTS(" Index");
	END(HTML_TITLE);
	END(HTML_HEAD);

	START(HTML_BODY);
	START(HTML_H1);
	PUTS("WAIS Index: ");
	PUTS(theWAISinfo->basetitle);
	END(HTML_H1);
       }

       START(HTML_ISINDEX);

       /* If we have seen a source file for this database, use that: */

#ifdef CACHE_FILE_PREFIX
       sprintf(filename,
	       "%sWSRC-%s:%s:%.100s.txt",
	       CACHE_FILE_PREFIX,
	       server_name, service, theWAISinfo->www_database);

       fp = fopen(filename, "r");	/* Have we found this already? */
       HTTRACE(PROT_TRACE, "HTLoadWAIS.. Description of server %s %s.\n" _ 
		 filename _ 
		 fp ? "exists already" : "does NOT exist!");

       if (fp)
	 {
	  int c;

	  START(HTML_PRE);   /* Preformatted description */
	  while((c=getc(fp)) != EOF) PUTC(c);   /* Transfer file */
	  END(HTML_PRE);
	  fclose(fp);
	 }
#endif

       END(HTML_BODY);
       END(HTML_HTML);
       FREE_TARGET;
      }

    HTAnchor_setFormat(anchor, WWW_HTML);

    theWAISinfo->result = status = HT_LOADED;
   }
  else
   {/* document rather than search */
   /*
    *   D O C U M E N T    F E T C H   (no key (key == NULL))
    */
    boolean binary = true;     /* how to transfer stuff coming over */
    HTStream* target;
    HTAtom* document_type_atom = HTAtom_for("application/octet-stream");
    long count;
    any   doc_chunk;
    any * docid = &doc_chunk;

    theWAISinfo->state = HTWAIS_FETCH_DOCUMENT;
    HTTRACE(PROT_TRACE, "HTLoadWAIS.. Retrieve document `%s'\n"
	      "............ type `%s' length %ld\n" _ 
	      (docname ? docname : "unknown") _ 
	      (doctype ? doctype : "unknown") _ 
	      document_length);

    if (doctype)
      {
       if (strcmp(doctype, "WSRC") == 0)
	 {
	  document_type_atom = HTAtom_for("application/x-wais-source");
	  binary = false;
	 }
        else
	 if (strcmp(doctype, "TEXT") == 0)
	   {
	    document_type_atom = WWW_UNKNOWN;
	    binary = false;
	   }
	  else
	   if (strcmp(doctype, "HTML") == 0)
	     {
	      document_type_atom = WWW_HTML;
	      binary = false;
	     }
	    else
	     if (strcmp(doctype, "GIF") == 0) document_type_atom = WWW_GIF;
      }

    HTAnchor_setFormat(anchor, document_type_atom);

    /* Guess on TEXT format as it might be HTML */
    if ((target = HTStreamStack(HTAnchor_format(anchor),
				HTRequest_outputFormat(request),
				HTRequest_outputStream(request),
				request, YES))
	== NULL)
      {
       theWAISinfo->result = HT_ERROR;
       status = -1;
       HTWAISCleanup(request, status);
       return status;
      }

    /* Decode hex or litteral format for document ID */
    WAIS_from_WWW(docid, docname);

    /* Loop over slices of the document */
    for (count = 0; count * CHARS_PER_PAGE < document_length; count++)
      {
       char *type = s_strdup(doctype);

       request_buffer_length = MAX_MESSAGE_LEN;	      /* Amount left */
       HTTRACE(PROT_TRACE, "HTLoadWAIS.. Slice number %ld\n" _ count);
       if (generate_retrieval_apdu(theWAISinfo->request_message + HEADER_LENGTH,
				   &request_buffer_length, 
				   docid, CT_byte,
				   count * CHARS_PER_PAGE,
				   HTMIN((count + 1) * CHARS_PER_PAGE,
					 document_length),
				     type,
				   theWAISinfo->wais_database) == 0)
	 {
	  HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
			     NULL, 0, "HTLoadWAIS");
	 }

       HT_FREE(type);

       /* Actually do the transaction given by request_message */   
       if (interpret_message(theWAISinfo->request_message, 
			     MAX_MESSAGE_LEN - request_buffer_length, 
			     theWAISinfo->response_message,
			     MAX_MESSAGE_LEN,
			     theWAISinfo->connection,
			     false /* true verbose */	
			     )
	   == 0)
	 {
	  HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_OVERFLOW, 
			     NULL, 0, "HTLoadWAIS");
	 }

       /* Parse the result which came back into memory. */
       readSearchResponseAPDU(&retrieval_response, 
			      theWAISinfo->response_message + HEADER_LENGTH);
       {
	WAISSearchResponse* searchres = (WAISSearchResponse*)retrieval_response->DatabaseDiagnosticRecords;

	if (!searchres->Text)
	  {
	   if (searchres->Diagnostics &&
	       *searchres->Diagnostics &&
	       (*searchres->Diagnostics)->ADDINFO)
	     {
	      char *errmsg = (*searchres->Diagnostics)->ADDINFO;

	      HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_MODULE,
				 (void *) errmsg, (int) strlen(errmsg),
				 "HTLoadWAIS");
	     }
	    else
	     {
	      HTRequest_addError(request, ERR_WARN, NO, HTERR_WAIS_MODULE,
				 NULL, 0, "HTLoadWAIS");
	     }

	   (*target->isa->_free)(target);
	   HTRequest_setOutputStream(request, NULL);
	   HT_FREE(docid->bytes);
	   freeWAISSearchResponse(retrieval_response->DatabaseDiagnosticRecords); 
	   freeSearchResponseAPDU(retrieval_response);
	   theWAISinfo->result = HT_OK;
	   HTWAISCleanup(request, status);
	  }
	 else
	  {
	   output_text_record(target, *searchres->Text,
			      false, binary);
	   freeWAISSearchResponse(retrieval_response->DatabaseDiagnosticRecords);
	   freeSearchResponseAPDU(retrieval_response);
	  } /* If text existed */
       }
      } /* Loop over slices */

    (*target->isa->_free)(target);
    HTRequest_setOutputStream(request, NULL);
    HT_FREE(docid->bytes);

    theWAISinfo->result = status = HT_LOADED;
   }
 /* End ``if (key)'' */

 HTWAISCleanup(request, status);

 return status;
}


PUBLIC int HTLoadWAIS (SOCKET soc, HTRequest* request)
{
 wais_info* theWAISinfo;  /* Specific protocol information */
 HTNet* net;              /* Generic protocol information */
 HTParentAnchor* anchor;

 /*
  * Initiate a new wais structure and bind to request structure.
  * This is actually state HTWAIS_BEGIN,
  * but it can't be in the state machine,
  * as we need the structure first.
  */

 if (request)
   {
    if ((anchor = HTRequest_anchor(request)) == NULL) return HT_ERROR;
    if ((net = HTRequest_net(request)) == NULL) return HT_ERROR;
   }
  else
   return HT_ERROR;

 HTTRACE(PROT_TRACE, "HTWAIS...... Looking for `%s\'\n" _ HTAnchor_physical(anchor));

                     /* Get existing copy */
 if ((theWAISinfo = (wais_info*)HTNet_context(net)) == NULL)
   {
    if ((theWAISinfo = (wais_info*)HT_CALLOC(1, sizeof(wais_info))) == NULL)
      HT_OUTOFMEM("HTLoadWAIS");

    HTNet_setEventCallback(net, HTWAISEvent);
    HTNet_setEventParam(net, theWAISinfo);  /* callbacks get theWAISinfo* */
    HTNet_setContext(net, theWAISinfo);

    theWAISinfo->state  = HTWAIS_BEGIN;
    theWAISinfo->result = HT_ERROR;
    theWAISinfo->net    = net;
   }

 /* get it started - ops is ignored */
 return HTWAISEvent(soc, theWAISinfo, HTEvent_BEGIN);
}

#endif /* HT_DIRECT_WAIS */