Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 577 insertions, 0 deletions

diff --git a/kioslave/http/http.h b/kioslave/http/http.h
new file mode 100644
index 000000000..ea2e68a8a
--- /dev/null
+++ b/kioslave/http/http.h
@@ -0,0 +1,577 @@
+/*
+   Copyright (C) 2000,2001 Dawit Alemayehu <adawit@kde.org>
+   Copyright (C) 2000,2001 Waldo Bastian <bastian@kde.org>
+   Copyright (C) 2000,2001 George Staikos <staikos@kde.org>
+   Copyright (C) 2001,2002 Hamish Rodda <rodda@kde.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#ifndef HTTP_H_
+#define HTTP_H_
+
+
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <qptrlist.h>
+#include <qstrlist.h>
+#include <qstringlist.h>
+
+#include <kurl.h>
+#include "kio/tcpslavebase.h"
+#include "kio/http.h"
+
+class DCOPClient;
+class QDomElement;
+class QDomNodeList;
+
+namespace KIO {
+    class AuthInfo;
+}
+
+class HTTPProtocol : public QObject, public KIO::TCPSlaveBase
+{
+  Q_OBJECT
+public:
+  HTTPProtocol( const QCString &protocol, const QCString &pool,
+                const QCString &app );
+  virtual ~HTTPProtocol();
+
+  /** HTTP version **/
+  enum HTTP_REV    {HTTP_None, HTTP_Unknown, HTTP_10, HTTP_11, SHOUTCAST};
+
+  /** Authorization method used **/
+  enum HTTP_AUTH   {AUTH_None, AUTH_Basic, AUTH_NTLM, AUTH_Digest, AUTH_Negotiate};
+
+  /** HTTP / DAV method **/
+  // Removed to interfaces/kio/http.h
+  //enum HTTP_METHOD {HTTP_GET, HTTP_PUT, HTTP_POST, HTTP_HEAD, HTTP_DELETE,
+  //                  HTTP_OPTIONS, DAV_PROPFIND, DAV_PROPPATCH, DAV_MKCOL,
+  //                  DAV_COPY, DAV_MOVE, DAV_LOCK, DAV_UNLOCK, DAV_SEARCH };
+
+  /** State of the current Connection **/
+  struct HTTPState
+  {
+    HTTPState ()
+    {
+      port = 0;
+      doProxy = false;
+    }
+
+    QString hostname;
+    QString encoded_hostname;
+    short unsigned int port;
+    QString user;
+    QString passwd;
+    bool  doProxy;
+  };
+
+  /** DAV-specific request elements for the current connection **/
+  struct DAVRequest
+  {
+    DAVRequest ()
+    {
+      overwrite = false;
+      depth = 0;
+    }
+
+    QString desturl;
+    bool overwrite;
+    int depth;
+  };
+
+  /** The request for the current connection **/
+  struct HTTPRequest
+  {
+    HTTPRequest ()
+    {
+      port = 0;
+      method = KIO::HTTP_UNKNOWN;
+      offset = 0;
+      doProxy = false;
+      allowCompressedPage = false;
+      disablePassDlg = false;
+      bNoAuth = false;
+      bUseCache = false;
+      bCachedRead = false;
+      bCachedWrite = false;
+      fcache = 0;
+      bMustRevalidate = false;
+      cacheExpireDateOffset = 0;
+      bErrorPage = false;
+      bUseCookiejar = false;
+      expireDate = 0;
+      creationDate = 0;
+    }
+
+    QString hostname;
+    QString encoded_hostname;
+    short unsigned int port;
+    QString user;
+    QString passwd;
+    QString path;
+    QString query;
+    KIO::HTTP_METHOD method;
+    KIO::CacheControl cache;
+    KIO::filesize_t offset;
+    bool doProxy;
+    KURL url;
+    QString window;                 // Window Id this request is related to.
+    QString referrer;
+    QString charsets;
+    QString languages;
+    bool allowCompressedPage;
+    bool disablePassDlg;
+    QString userAgent;
+    QString id;
+    DAVRequest davData;
+
+    bool bNoAuth; // Do not authenticate
+
+    // Cache related
+    QString cef; // Cache Entry File belonging to this URL.
+    bool bUseCache; // Whether the cache is active
+    bool bCachedRead; // Whether the file is to be read from m_fcache.
+    bool bCachedWrite; // Whether the file is to be written to m_fcache.
+    FILE* fcache; // File stream of a cache entry
+    QString etag; // ETag header.
+    QString lastModified; // Last modified.
+    bool bMustRevalidate; // Cache entry is expired.
+    long cacheExpireDateOffset; // Position in the cache entry where the
+                                  // 16 byte expire date is stored.
+    time_t expireDate; // Date when the cache entry will expire
+    time_t creationDate; // Date when the cache entry was created
+    QString strCharset; // Charset
+
+    // Indicates whether an error-page or error-msg should is preferred.
+    bool bErrorPage;
+
+    // Cookie flags
+    bool bUseCookiejar;
+    enum { CookiesAuto, CookiesManual, CookiesNone } cookieMode;
+  };
+
+  struct DigestAuthInfo
+  {
+    QCString nc;
+    QCString qop;
+    QCString realm;
+    QCString nonce;
+    QCString method;
+    QCString cnonce;
+    QCString username;
+    QCString password;
+    QStrList digestURI;
+    QCString algorithm;
+    QCString entityBody;
+  };
+
+//---------------------- Re-implemented methods ----------------
+  virtual void setHost(const QString& host, int port, const QString& user,
+                       const QString& pass);
+
+  virtual void slave_status();
+
+  virtual void get( const KURL& url );
+  virtual void put( const KURL& url, int permissions, bool overwrite,
+                    bool resume );
+
+//----------------- Re-implemented methods for WebDAV -----------
+  virtual void listDir( const KURL& url );
+  virtual void mkdir( const KURL& url, int permissions );
+
+  virtual void rename( const KURL& src, const KURL& dest, bool overwrite );
+  virtual void copy( const KURL& src, const KURL& dest, int permissions, bool overwrite );
+  virtual void del( const KURL& url, bool isfile );
+
+  // ask the host whether it supports WebDAV & cache this info
+  bool davHostOk();
+
+  // send generic DAV request
+  void davGeneric( const KURL& url, KIO::HTTP_METHOD method );
+
+  // Send requests to lock and unlock resources
+  void davLock( const KURL& url, const QString& scope,
+                const QString& type, const QString& owner );
+  void davUnlock( const KURL& url );
+
+  // Calls httpClose() and finished()
+  void davFinished();
+
+  // Handle error conditions
+  QString davError( int code = -1, QString url = QString::null );
+//---------------------------- End WebDAV -----------------------
+
+  /**
+   * Special commands supported by this slave :
+   * 1 - HTTP POST
+   * 2 - Cache has been updated
+   * 3 - SSL Certificate Cache has been updated
+   * 4 - HTTP multi get
+   * 5 - DAV LOCK     (see
+   * 6 - DAV UNLOCK     README.webdav)
+   */
+  virtual void special( const QByteArray &data );
+
+  virtual void mimetype( const KURL& url);
+
+  virtual void stat( const KURL& url );
+
+  virtual void reparseConfiguration();
+
+  virtual void closeConnection(); // Forced close of connection
+
+  void post( const KURL& url );
+  void multiGet(const QByteArray &data);
+  bool checkRequestURL( const KURL& );
+  void cacheUpdate( const KURL &url, bool nocache, time_t expireDate);
+
+  void httpError(); // Generate error message based on response code
+
+  bool isOffline(const KURL &url); // Check network status
+
+protected slots:
+  void slotData(const QByteArray &);
+  void error( int _errid, const QString &_text );
+
+protected:
+  int readChunked();    // Read a chunk
+  int readLimited();    // Read maximum m_iSize bytes.
+  int readUnlimited();  // Read as much as possible.
+
+  /**
+    * A "smart" wrapper around write that will use SSL_write or
+    * write(2) depending on whether you've got an SSL connection or not.
+    * The only shortcomming is that it uses the "global" file handles and
+    * soforth.  So you can't really use this on individual files/sockets.
+    */
+  ssize_t write(const void *buf, size_t nbytes);
+
+  /**
+    * Another "smart" wrapper, this time around read that will
+    * use SSL_read or read(2) depending on whether you've got an
+    * SSL connection or not.
+    */
+  ssize_t read (void *b, size_t nbytes);
+
+  char *gets (char *str, int size);
+
+  void setRewindMarker();
+  void rewind();
+
+  /**
+    * Add an encoding on to the appropriate stack this
+    * is nececesary because transfer encodings and
+    * content encodings must be handled separately.
+    */
+  void addEncoding(QString, QStringList &);
+
+  void configAuth( char *, bool );
+
+  bool httpOpen();             // Open transfer
+  void httpClose(bool keepAlive);  // Close transfer
+
+  bool httpOpenConnection();   // Open connection
+  void httpCloseConnection();  // Close connection
+  void httpCheckConnection();  // Check whether to keep connection.
+
+  void forwardHttpResponseHeader();
+
+  bool readHeader();
+
+  bool sendBody();
+
+  // where dataInternal == true, the content is to be made available
+  // to an internal function.
+  bool readBody( bool dataInternal = false );
+
+  /**
+   * Performs a WebDAV stat or list
+   */
+  void davSetRequest( const QCString& requestXML );
+  void davStatList( const KURL& url, bool stat = true );
+  void davParsePropstats( const QDomNodeList& propstats, KIO::UDSEntry& entry );
+  void davParseActiveLocks( const QDomNodeList& activeLocks,
+                            uint& lockCount );
+
+  /**
+   * Parses a date & time string
+   */
+  long parseDateTime( const QString& input, const QString& type );
+
+  /**
+   * Returns the error code from a "HTTP/1.1 code Code Name" string
+   */
+  int codeFromResponse( const QString& response );
+
+  /**
+   * Extracts locks from metadata
+   * Returns the appropriate If: header
+   */
+  QString davProcessLocks();
+
+  /**
+   * Send a cookie to the cookiejar
+   */
+  void addCookies( const QString &url, const QCString &cookieHeader);
+
+  /**
+   * Look for cookies in the cookiejar
+   */
+  QString findCookies( const QString &url);
+
+  /**
+   * Do a cache lookup for the current url. (m_state.url)
+   *
+   * @param readWrite If true, file is opened read/write.
+   *                  If false, file is opened read-only.
+   *
+   * @return a file stream open for reading and at the start of
+   *         the header section when the Cache entry exists and is valid.
+   *         0 if no cache entry could be found, or if the entry is not
+   *         valid (any more).
+   */
+  FILE *checkCacheEntry(bool readWrite = false);
+
+  /**
+   * Create a cache entry for the current url. (m_state.url)
+   *
+   * Set the contents type of the cache entry to 'mimetype'.
+   */
+  void createCacheEntry(const QString &mimetype, time_t expireDate);
+
+  /**
+   * Write data to cache.
+   *
+   * Write 'nbytes' from 'buffer' to the Cache Entry File
+   */
+  void writeCacheEntry( const char *buffer, int nbytes);
+
+  /**
+   * Close cache entry
+   */
+  void closeCacheEntry();
+
+  /**
+   * Update expire time of current cache entry.
+   */
+  void updateExpireDate(time_t expireDate, bool updateCreationDate=false);
+
+  /**
+   * Quick check whether the cache needs cleaning.
+   */
+  void cleanCache();
+
+  /**
+   * Performs a GET HTTP request.
+   */
+  // where dataInternal == true, the content is to be made available
+  // to an internal function.
+  void retrieveContent( bool dataInternal = false );
+
+  /**
+   * Performs a HEAD HTTP request.
+   */
+  bool retrieveHeader(bool close_connection = true);
+
+  /**
+   * Resets any per session settings.
+   */
+  void resetSessionSettings();
+
+  /**
+   * Resets settings related to parsing a response.
+   */
+  void resetResponseSettings();
+
+  /**
+   * Resets any per connection settings.  These are different from
+   * per-session settings in that they must be invalidates every time
+   * a request is made, e.g. a retry to re-send the header to the
+   * server, as compared to only when a new request arrives.
+   */
+  void resetConnectionSettings();
+
+  /**
+   * Returns any pre-cached proxy authentication info
+   * info in HTTP header format.
+   */
+  QString proxyAuthenticationHeader();
+
+  /**
+   * Retrieves authorization info from cache or user.
+   */
+  bool getAuthorization();
+
+  /**
+   * Saves valid authorization info in the cache daemon.
+   */
+  void saveAuthorization();
+
+  /**
+   * Creates the entity-header for Basic authentication.
+   */
+  QString createBasicAuth( bool isForProxy = false );
+
+  /**
+   * Creates the entity-header for Digest authentication.
+   */
+  QString createDigestAuth( bool isForProxy = false );
+
+  /**
+   * Creates the entity-header for NTLM authentication.
+   */
+  QString createNTLMAuth( bool isForProxy = false );
+
+  /**
+   * Creates the entity-header for Negotiate authentication.
+   */
+  QString createNegotiateAuth();
+
+  /**
+   * create GSS error string
+   */
+  QCString gssError( int major_status, int minor_status );
+
+  /**
+   * Calcualtes the message digest response based on RFC 2617.
+   */
+  void calculateResponse( DigestAuthInfo &info, QCString &Response );
+
+  /**
+   * Prompts the user for authorization retry.
+   */
+  bool retryPrompt();
+
+  /**
+   * Creates authorization prompt info.
+   */
+  void promptInfo( KIO::AuthInfo& info );
+
+protected:
+  HTTPState m_state;
+  HTTPRequest m_request;
+  QPtrList<HTTPRequest> m_requestQueue;
+
+  bool m_bBusy; // Busy handling request queue.
+  bool m_bEOF;
+  bool m_bEOD;
+
+//--- Settings related to a single response only
+  QStringList m_responseHeader; // All headers
+  KURL m_redirectLocation;
+  bool m_bRedirect; // Indicates current request is a redirection
+
+  // Processing related
+  bool m_bChunked; // Chunked tranfer encoding
+  KIO::filesize_t m_iSize; // Expected size of message
+  KIO::filesize_t m_iBytesLeft; // # of bytes left to receive in this message.
+  KIO::filesize_t m_iContentLeft; // # of content bytes left
+  QByteArray m_bufReceive; // Receive buffer
+  bool m_dataInternal; // Data is for internal consumption
+  char m_lineBuf[1024];
+  char m_rewindBuf[8192];
+  size_t m_rewindCount;
+  char *m_linePtr;
+  size_t m_lineCount;
+  char *m_lineBufUnget;
+  char *m_linePtrUnget;
+  size_t m_lineCountUnget;
+
+  // Mimetype determination
+  bool m_cpMimeBuffer;
+  QByteArray m_mimeTypeBuffer;
+
+  // Language/Encoding related
+  QStringList m_qTransferEncodings;
+  QStringList m_qContentEncodings;
+  QString m_sContentMD5;
+  QString m_strMimeType;
+
+
+//--- WebDAV
+  // Data structure to hold data which will be passed to an internal func.
+  QByteArray m_bufWebDavData;
+  QStringList m_davCapabilities;
+
+  bool m_davHostOk;
+  bool m_davHostUnsupported;
+//----------
+
+  // Holds the POST data so it won't get lost on if we
+  // happend to get a 401/407 response when submitting,
+  // a form.
+  QByteArray m_bufPOST;
+
+  // Cache related
+  int m_maxCacheAge; // Maximum age of a cache entry.
+  long m_maxCacheSize; // Maximum cache size in Kb.
+  QString m_strCacheDir; // Location of the cache.
+
+
+
+//--- Proxy related members
+  bool m_bUseProxy;
+  bool m_bNeedTunnel; // Whether we need to make a SSL tunnel
+  bool m_bIsTunneled; // Whether we have an active SSL tunnel
+  bool m_bProxyAuthValid;
+  int m_iProxyPort;
+  KURL m_proxyURL;
+  QString m_strProxyRealm;
+
+  // Operation mode
+  QCString m_protocol;
+
+  // Authentication
+  QString m_strRealm;
+  QString m_strAuthorization;
+  QString m_strProxyAuthorization;
+  HTTP_AUTH Authentication;
+  HTTP_AUTH ProxyAuthentication;
+  bool m_bUnauthorized;
+  short unsigned int m_iProxyAuthCount;
+  short unsigned int m_iWWWAuthCount;
+
+  // First request on a connection
+  bool m_bFirstRequest;
+
+  // Persistent connections
+  bool m_bKeepAlive;
+  int m_keepAliveTimeout; // Timeout in seconds.
+
+  // Persistent proxy connections
+  bool m_bPersistentProxyConnection;
+
+
+  // Indicates whether there was some connection error.
+  bool m_bError;
+
+  // Previous and current response codes
+  unsigned int m_responseCode;
+  unsigned int m_prevResponseCode;
+
+  // Values that determine the remote connection timeouts.
+  int m_proxyConnTimeout;
+  int m_remoteConnTimeout;
+  int m_remoteRespTimeout;
+
+  int m_pid;
+};
+#endif