diff options
Diffstat (limited to 'debian/htdig/htdig-3.2.0b6/htnet/HtHTTP.h')
| -rw-r--r-- | debian/htdig/htdig-3.2.0b6/htnet/HtHTTP.h | 452 |
1 files changed, 452 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/htnet/HtHTTP.h b/debian/htdig/htdig-3.2.0b6/htnet/HtHTTP.h new file mode 100644 index 00000000..b4b052fb --- /dev/null +++ b/debian/htdig/htdig-3.2.0b6/htnet/HtHTTP.h @@ -0,0 +1,452 @@ +// +// HtHTTP.h +// +// HtHTTP: Class for HTTP messaging (derived from Transport) +// +// Gabriele Bartolini - Prato - Italia +// started: 03.05.1999 +// +// //////////////////////////////////////////////////////////// +// +// The HtHTTP class should provide (as I hope) an interface for +// retrieving document on the Web. It derives from Transport class. +// +// It should be HTTP/1.1 compatible. +// +// It also let us take advantage of persitent connections use, +// and optimize request times (specially if directed to the same +// server). +// +// HtHTTP use another class to store the response returned by the +// remote server. +// +// Now cookies management is enabled. +// +/////// +// +// Part of the ht://Dig package <http://www.htdig.org/> +// Copyright (c) 1995-2004 The ht://Dig Group +// For copyright details, see the file COPYING in your distribution +// or the GNU Library General Public License (LGPL) version 2 or later +// <http://www.gnu.org/copyleft/lgpl.html> +// +// $Id: HtHTTP.h,v 1.15 2004/05/28 13:15:23 lha Exp $ +// + +#ifndef _HTHTTP_H +#define _HTHTTP_H + +#ifdef HAVE_CONFIG_H +#include "htconfig.h" +#endif /* HAVE_CONFIG_H */ + +#include "Transport.h" + +// Cookie support +#include "HtCookie.h" +#include "HtCookieJar.h" + +#include "URL.h" +#include "htString.h" + +// for HtHTTP::ShowStatistics#ifdef HAVE_STD +#ifdef HAVE_STD +#include <iostream> +#ifdef HAVE_NAMESPACES +using namespace std; +#endif +#else +#include <iostream.h> +#endif /* HAVE_STD */ + +// In advance declarations + +class HtHTTP; + + +class HtHTTP_Response : public Transport_Response +{ + + friend class HtHTTP; // declaring friendship + + public: +/////// + // Construction / Destruction +/////// + + HtHTTP_Response(); + ~HtHTTP_Response(); + + +/////// + // Interface +/////// + + // Reset + void Reset(); + + // Get the HTTP version + const String &GetVersion() const { return _version; } + + // Get the Transfer-encoding + const String &GetTransferEncoding() const + { return _transfer_encoding; } + + // Get server info + const String &GetServer() const { return _server; } + + // Get Connection info + const String &GetConnectionInfo() const { return _hdrconnection; } + + // Get Content language + const String &GetContentLanguage() const { return _content_language; } + + + protected: + + // Status line information + + String _version; // HTTP Version + + // Other header information + + String _transfer_encoding; // Transfer-encoding + String _server; // Server string returned + String _hdrconnection; // Connection header + String _content_language; // Content-language + +}; + + + +class HtHTTP : public Transport +{ +private: + HtHTTP() {} // Declared private - avoids default constructor to be created + // in some cases by the compiler. +public: + +/////// + // Construction/Destruction +/////// + + HtHTTP(Connection&); + virtual ~HtHTTP() = 0; + + // Information about the method to be used in the request + + enum Request_Method + { + Method_GET, + Method_HEAD + }; + + + +/////// + // Sends an HTTP request message +/////// + + // manages a Transport request (method inherited from Transport class) + virtual DocStatus Request (); + + // Sends a request message for HTTP + virtual DocStatus HTTPRequest (); + + +/////// + // Control of member the variables +/////// + + /////// + // Set the Request Method + /////// + + void SetRequestMethod (Request_Method rm) { _Method = rm; } + Request_Method GetRequestMethod() { return _Method; } + + + /////// + // Interface for resource retrieving + /////// + + // Set and get the document to be retrieved + void SetRequestURL(const URL &u) { _url = u;} + URL GetRequestURL () { return _url;} + + + // Set and get the referring URL + void SetRefererURL (const URL& u) { _referer = u;} + URL GetRefererURL () { return _referer;} + + // Set and get the accept-language string + void SetAcceptLanguage (const String& al) { _accept_language = al; } + URL GetAcceptLanguage () { return _accept_language; } + + // Info for multiple requests (static) + // Get the User agent string + static void SetRequestUserAgent (const String &s) { _user_agent=s; } + static const String &GetRequestUserAgent() { return _user_agent; } + + // Set (Basic) Authentication Credentials + virtual void SetCredentials (const String& s); + + // Set (Basic) Authentication Credentials for the HTTP Proxy + virtual void SetProxyCredentials (const String& s); + + /////// + // Interface for the HTTP Response + /////// + + // We have a valid response only if the status code is not equal to + // initialization value + + Transport_Response *GetResponse() + { + if (_response._status_code != -1) + return &_response; + else return 0;} + + + // Get the document status + virtual DocStatus GetDocumentStatus() + { return GetDocumentStatus (_response); } + + // It's a static method + static DocStatus GetDocumentStatus(HtHTTP_Response &); + + + +/////// + // Persistent connection choices interface +/////// + + // Is allowed + bool isPersistentConnectionAllowed() {return _persistent_connection_allowed;} + + // Is possible + bool isPersistentConnectionPossible() {return _persistent_connection_possible;} + + // Check if a persistent connection is possible depending on the HTTP response + void CheckPersistentConnection(HtHTTP_Response &); + + // Is Up (is both allowed and permitted by the server too) + bool isPersistentConnectionUp() + { return isConnected() && isPersistentConnectionAllowed() && + isPersistentConnectionPossible(); } + + // Allow Persistent Connection + void AllowPersistentConnection() { _persistent_connection_allowed=true; } + + // Disable Persistent Connection + void DisablePersistentConnection() { _persistent_connection_allowed=false; } + + // Allow Cookies + void AllowCookies() { _send_cookies=true; } + + // Disable Persistent Connection + void DisableCookies() { _send_cookies=false; } + + +/////// + // Set the cookie manager class (that is to say the class) +/////// + + // It's set only if not done before + static void SetCookieJar(HtCookieJar *cj) { _cookie_jar = cj; } + + +/////// + // Manage statistics +/////// + + static int GetTotSeconds () { return _tot_seconds; } + + static int GetTotRequests () { return _tot_requests; } + + static int GetTotBytes () { return _tot_bytes; } + + static double GetAverageRequestTime () + { return _tot_seconds?( ((double) _tot_seconds) / _tot_requests) : 0; } + + static float GetAverageSpeed () + { return _tot_bytes?( ((double) _tot_bytes) / _tot_seconds) : 0; } + + static void ResetStatistics () + { _tot_seconds=0; _tot_requests=0; _tot_bytes=0;} + + // Show stats + static ostream &ShowStatistics (ostream &out); + + + +/////// + // Set the _head_before_get option + // make a request to be made up of a HEAD call and then, + // if necessary, a GET call +/////// + + static void EnableHeadBeforeGet() { _head_before_get = true; } + static void DisableHeadBeforeGet() { _head_before_get = false; } + + static bool HeadBeforeGet() { return _head_before_get; } + + +/////// + // Set the controller for the parsing check. That is to say + // that External function that checks if a document is parsable or not. + // CanBeParsed static attribute should point to a function + // that returns an int value, given a char * containing the content-type. +/////// + + static void SetParsingController (int (*f)(char*)) { CanBeParsed = f; } + +protected: + +/////// + // Member attributes +/////// + + Request_Method _Method; + + /////// + // Http single Request information (Member attributes) + /////// + + int _bytes_read; // Bytes read + URL _url; // URL to retrieve + URL _referer; // Referring URL + + String _accept_language; // accept-language directive + + /////// + // Http multiple Request information + /////// + + static String _user_agent; // User agent + + + + /////// + // Http Response information + /////// + + HtHTTP_Response _response; // Object where response + // information will be stored into + + + /////// + // Allow or not a persistent connection (user choice) + /////// + + bool _persistent_connection_allowed; + + + /////// + // Is a persistent connection possible (with this http server)? + /////// + + bool _persistent_connection_possible; + + /////// + // Are cookies enabled? + /////// + + bool _send_cookies; + + /////// + // Option that, if set to true, make a request to be made up + // of a HEAD call and then, if necessary, a GET call + /////// + + static bool _head_before_get; + +/////// + // Manager of the body reading +/////// + + int (HtHTTP::*_readbody) (); + + +/////// + // Enum +/////// + + // Information about the status of a connection + + enum ConnectionStatus + { + Connection_ok, + Connection_already_up, + Connection_open_failed, + Connection_no_server, + Connection_no_port, + Connection_failed + }; + + +/////// + // Protected Services or method (Hidden by outside) +/////// + + + /////// + // Establish the connection + /////// + + ConnectionStatus EstablishConnection (); + + + /////// + // Set the string of the command containing the request + /////// + + void SetRequestCommand(String &); + + + /////// + // Parse the header returned by the server + /////// + + int ParseHeader(); + + /////// + // Check if a document is parsable looking the content-type info + /////// + + static bool isParsable(const char *); + + /////// + // Read the body returned by the server + /////// + + void SetBodyReadingController (int (HtHTTP::*f)()) { _readbody = f; } + int ReadBody(); + int ReadChunkedBody(); // Read the body of a chunked encoded-response + + + // Finish the request and return a DocStatus value; + + DocStatus FinishRequest (DocStatus); + + +/////// + // Static attributes and methods +/////// + + // Unique cookie Jar + static HtCookieJar *_cookie_jar; // Jar containing all of the cookies + + static int _tot_seconds; // Requests last (in seconds) + static int _tot_requests; // Number of requests + static int _tot_bytes; // Number of bytes read + + // This is a pointer to function that check if a ContentType + // is parsable or less. + + static int (*CanBeParsed) (char *); + +}; + +#endif + |