kcookiejar.h

Go to the documentation of this file.

/*
    This file is part of the KDE File Manager

    Copyright (C) 1998 Waldo Bastian (bastian@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, or (at your option) version 3.

    This software 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
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this library; see the file COPYING. If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/
//----------------------------------------------------------------------------
//
// KDE File Manager -- HTTP Cookies

#ifndef KCOOKIEJAR_H
#define KCOOKIEJAR_H

#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QHash>
#include <QtCore/QSet>

class KConfig;
class KCookieJar;
class KHttpCookie;
class KHttpCookieList;

typedef KHttpCookie *KHttpCookiePtr;

enum KCookieAdvice
{
    KCookieDunno=0,
    KCookieAccept,
    KCookieAcceptForSession,
    KCookieReject,
    KCookieAsk
};

class KHttpCookie
{
    friend class KCookieJar;
    friend class KHttpCookieList;
    friend QDebug operator<<(QDebug, const KHttpCookie&); // for cookieStr()

protected:
    QString mHost;
    QString mDomain;
    QString mPath;
    QString mName;
    QString mValue;
    qint64  mExpireDate;
    int     mProtocolVersion;
    bool    mSecure;
    bool    mCrossDomain;
    bool    mHttpOnly;
    bool    mExplicitPath;
    QList<long> mWindowIds;
    QList<int> mPorts;
    KCookieAdvice mUserSelectedAdvice;

    QString cookieStr(bool useDOMFormat) const;

public:
    explicit KHttpCookie(const QString &_host=QString(),
                         const QString &_domain=QString(),
                         const QString &_path=QString(),
                         const QString &_name=QString(),
                         const QString &_value=QString(),
                         qint64 _expireDate=0,
                         int _protocolVersion=0,
                         bool _secure = false,
                         bool _httpOnly = false,
                         bool _explicitPath = false);

    QString domain() const { return mDomain; }
    QString host() const { return mHost; }
    QString path() const { return mPath; }
    QString name() const { return mName; }
    QString value() const { return mValue; }
    QList<long> &windowIds() { return mWindowIds; }
    const QList<long> &windowIds() const { return mWindowIds; }
    const QList<int> &ports() const { return mPorts; }
    void fixDomain(const QString &domain) { mDomain = domain; }
    qint64 expireDate() const { return mExpireDate; }
    int protocolVersion() const { return mProtocolVersion; }
    bool isSecure() const { return mSecure; }
    bool isExpired(qint64 currentDate = -1) const;
    bool isCrossDomain() const { return mCrossDomain; }
    bool isHttpOnly() const { return mHttpOnly; }
    bool hasExplicitPath() const { return mExplicitPath; }
    bool match(const QString &fqdn, const QStringList &domainList, const QString &path, int port=-1) const;

    KCookieAdvice getUserSelectedAdvice() const { return mUserSelectedAdvice; }
    void setUserSelectedAdvice(KCookieAdvice advice) { mUserSelectedAdvice = advice; }
};

QDebug operator<<(QDebug, const KHttpCookie&);

class KHttpCookieList : public QList<KHttpCookie>
{
public:
    KHttpCookieList() : QList<KHttpCookie>(), advice( KCookieDunno )
    { }
    virtual ~KHttpCookieList() { }

    KCookieAdvice getAdvice() const { return advice; }
    void setAdvice(KCookieAdvice _advice) { advice = _advice; }

private:
    KCookieAdvice advice;
};

QDebug operator<<(QDebug, const KHttpCookieList&);

class KCookieJar
{
public:
    KCookieJar();

    ~KCookieJar();

    bool changed() const { return m_cookiesChanged || m_configChanged; }

    bool saveCookies(const QString &_filename);

    bool loadCookies(const QString &_filename);

    void saveConfig(KConfig *_config);

    void loadConfig(KConfig *_config, bool reparse = false);

    QString findCookies(const QString &_url, bool useDOMFormat, long windowId, KHttpCookieList *pendingCookies=0);

    KHttpCookieList makeCookies(const QString &_url, const QByteArray &cookie_headers, long windowId);

    KHttpCookieList makeDOMCookies(const QString &_url, const QByteArray &cookie_domstr, long windowId);

    void addCookie(KHttpCookie &cookie);

    bool cookieIsPersistent(const KHttpCookie& cookie) const;

    KCookieAdvice cookieAdvice(const KHttpCookie& cookie) const;

    KCookieAdvice getDomainAdvice(const QString &_domain) const;

    void setDomainAdvice(const QString &_domain, KCookieAdvice _advice);

    void setDomainAdvice(const KHttpCookie& _cookie, KCookieAdvice _advice);

    KCookieAdvice getGlobalAdvice() const { return m_globalAdvice; }

    void setGlobalAdvice(KCookieAdvice _advice);

    const QStringList& getDomainList();

    KHttpCookieList *getCookieList(const QString & _domain,
                                   const QString& _fqdn );

    void eatCookie(KHttpCookieList::iterator cookieIterator);

    void eatCookiesForDomain(const QString &domain);

    void eatAllCookies();

    void eatSessionCookies( long windowId );

    void eatSessionCookies( const QString& fqdn, long windowId, bool isFQDN = true );

    static bool parseUrl(const QString &_url, QString &_fqdn, QString &_path, int *port = 0);

    void extractDomains(const QString &_fqdn,
                        QStringList &_domainList) const;

    static QString adviceToStr(KCookieAdvice _advice);
    static KCookieAdvice strToAdvice(const QString &_str);

    enum KCookieDefaultPolicy {
        ApplyToShownCookiesOnly = 0,
        ApplyToCookiesFromDomain = 1,
        ApplyToAllCookies = 2
    };
    KCookieDefaultPolicy preferredDefaultPolicy() const { return m_preferredPolicy; }

    bool showCookieDetails () const { return m_showCookieDetails; }

     void setPreferredDefaultPolicy (KCookieDefaultPolicy value) { m_preferredPolicy = value; }

     void setShowCookieDetails (bool value) { m_showCookieDetails = value; }

protected:
     void stripDomain(const QString &_fqdn, QString &_domain) const;
     QString stripDomain(const KHttpCookie& cookie) const;

protected:
    QStringList m_domainList;    
    KCookieAdvice m_globalAdvice;
    QHash<QString, KHttpCookieList*> m_cookieDomains;
    QSet<QString> m_twoLevelTLD;
    QSet<QString> m_gTLDs;

    bool m_configChanged;
    bool m_cookiesChanged;
    bool m_showCookieDetails;
    bool m_rejectCrossDomainCookies;
    bool m_autoAcceptSessionCookies;

    KCookieDefaultPolicy m_preferredPolicy;
};
#endif