NET_NetworkCookieStore.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_NetworkCookieStore.h
 *
 * COMMENTS:
 *      A Qt QNetworkCookieJar based cookie store that is designed to interface
 *      with QWebEngine. This class is also fully thread safe.
 */

#ifndef __NET_NETWORKCOOKIESTORE_H__
#define __NET_NETWORKCOOKIESTORE_H__

#include "NET_API.h"
#include "NET_NetworkCookie.h"

#include <UT/UT_Array.h>
#include <UT/UT_LMHost.h>
#include <UT/UT_Lock.h>
#include <UT/UT_Optional.h>
#include <UT/UT_SQL.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Url.h>
#include <UT/UT_WorkBuffer.h>

#include <SYS/SYS_Compiler.h>
#include <SYS/SYS_Hash.h>

#define NO_DISCARD SYS_NO_DISCARD_RESULT

class NET_API NET_NetworkCookieStore
{
public:
    using CookieList = UT_Array<NET_NetworkCookie>;
    using iterator = CookieList::iterator;
    using const_iterator = CookieList::const_iterator;

    enum StoragePolicy
    {
        NoPersistentCookies,
        AllowPersistentCookies,
        ForcePersistentCookies
    };

    enum Mode
    {
        Sync,
        Async
    };

    NET_NetworkCookieStore();
    virtual ~NET_NetworkCookieStore();

    void init();

    // Start the thread to async load and flush pending ops
    void setPersistentStoragePath(const UT_StringRef &storage_location);

    virtual bool load();
    virtual void loadAsync();
    // Flush any pending operations
    virtual bool flush();

    // Delete the cookie from the in memory cookie store and the persistent
    // store.
    virtual bool deleteCookie(const NET_NetworkCookie &cookie);
    // Check if we can update an existing cookie. Otherwise insert the cookie.
    // In either case pending operations are added to update the persistent
    // store.
    virtual bool insertCookie(const NET_NetworkCookie &cookie);
    // Try to update an existing cookie in the store. This adds a pending
    // operation if a cookie was added.
    virtual bool updateCookie(const NET_NetworkCookie &cookie);
    // Grab all cookies that apply to the passed in url.
    virtual CookieList cookiesForUrl(const UT_Url &url);
    // Insert or update existing cookies based on the url.
    virtual bool setCookiesFromUrl(const CookieList &cookies,
                                   const UT_Url &url);
    // Remove all cookies in our store
    void deleteAllCookies();

    void setStoragePolicy(StoragePolicy policy);

    void setMode(Mode mode);

    // Useful for debug printing whats currently in the store.
    void debugPrintStore() const;

    // The launcher does not depend on FS so the default cookie storage is in
    // UT which then gets used here so that everyone can share the same cookie
    // store path.
    NO_DISCARD static UT_StringHolder defaultCookieStoragePath(
            UT_LMHost::AppType app_type,
            const UT_StringRef &name);
    /// Find a cookie in the cookie store based on the cookie identifier.
    UT_Optional<NET_NetworkCookie> find(const NET_NetworkCookie &cookie) const;

    // Create the directories for the db file.
    void createDBFileLocationIfNeeded();
    // Grab a list of all cookies. This is really only meant to be used for
    // debugging and testing.
    CookieList allCookies() const
    {
        CookieList cookies;
        cookies.setCapacity(myCookies.size());
        for (auto&& it : myCookies)
        {
            cookies.emplace_back(it.second);
        }
        return cookies;
    }

    const UT_StringHolder& persistentStorage() const { return myPersistentStorage; }

    bool isAsync() const { return myMode == Async; }
protected:
    // Clear all existing cookies and pending operations and set the cookie
    // store to the passed in cookie list.
    void setAllCookies(const CookieList &cookies);
    // Validate the cookie is usable for the passed in url
    NO_DISCARD virtual bool validateCookie(const NET_NetworkCookie &cookie,
                                           const UT_Url &url) const;

private:

    // This class allows us to defer an operation to our persistent storage
    // until we have accumulated enough operations, timeout expired or
    // we are exiting the application. This also allows us to modify the
    // persistent storage only when something has changed with that storage
    class PendingOperation
    {
    public:
        enum Type
        {
            INSERT_COOKIE,
            DELETE_COOKIE,
            UPDATE_ACCESS
        };

        PendingOperation(Type type, const NET_NetworkCookie &cookie)
            : myType(type), myCookie(cookie)
        {
        }

        Type myType;
        NET_NetworkCookie myCookie;
    };
    using PendingOperationList = UT_Array<PendingOperation>;

    // Represents the unique key as defined in the sqlite db.
    class UniqueKey
    {
    public:
        UniqueKey(const NET_NetworkCookie &cookie)
            : myDomain(cookie.domain())
            , myName(cookie.name())
            , myPath(cookie.path())
        {
        }

        bool operator==(const UniqueKey &other) const
        {
            return myDomain == other.myDomain && myName == other.myName
                   && myPath == other.myPath;
        }
        bool operator!=(const UniqueKey &other) const
        {
            return !(*this == other);
        }

        SYS_HashType hash() const
        {
            SYS_HashType h = myDomain.hash();
            SYShashCombine(h, myName.hash());
            SYShashCombine(h, myPath.hash());
            return h;
        }

        friend std::size_t hash_value(const UniqueKey &key)
        {
            return key.hash();
        }

    private:
        UT_StringHolder myDomain;
        UT_StringHolder myName;
        UT_StringHolder myPath;
    };

    // Try to update the cookies access time if we already have one in our
    // store.
    bool updateCookieAccess(const NET_NetworkCookie& cookie);
    // Insert the cookie into our in memory store. Returns true if the cookie
    // was inserted.
    // WARNING:
    //      Be very careful when you use this function as duplicate checking
    //      is not done and a pending operation is not added. If you need
    //      duplicate checking or to add a pending operation then call
    //      updateCookie() or insertCookie()
    bool internalInsertCookie(const NET_NetworkCookie &cookie);
    // Add a cookie and the associated operation to our pending operations to
    // be processed at a later time.
    void addPendingOperation(PendingOperation::Type type,
                             const NET_NetworkCookie &cookie);
    // Every 30s or more we want to update the cookie store. The idea is to lazy
    // update the store. Its unlikely that the store will be updated constantly
    // so we only update every so often.
    void refreshIfRequired();
    static bool isPersistentCookie(StoragePolicy policy,
                                   const NET_NetworkCookie &cookie);

    bool fail(const UT_ErrorCode& ec, const char* msg);

    UT_UniquePtr<UT_SqlDatabase> myDB;
    mutable UT_Lock myLock;
    UT_StringHolder myPersistentStorage;
    StoragePolicy myStoragePolicy;
    Mode myMode;
    UT_Map<UniqueKey, NET_NetworkCookie> myCookies;
    PendingOperationList myPendingOps;
    time_t myLastUpdate;
};

#endif // __NET_NETWORKCOOKIESTORE_H__