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 "NET_RWLock.h"

#include <UT/UT_BoostAsio.h>
#include <UT/UT_ErrorCode.h>
#include <UT/UT_LMHost.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Optional.h>
#include <UT/UT_SQL.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_Lock.h>

#define NO_DISCARD SYS_NO_DISCARD_RESULT

class UT_SqlDatabase;

class NET_API NET_INetworkCookieStoreObserver
    : public UTenable_shared_from_this<NET_INetworkCookieStoreObserver>
{
public:
    virtual ~NET_INetworkCookieStoreObserver() = default;
    UT_NON_COPYABLE(NET_INetworkCookieStoreObserver);

    template <typename T, typename... Args>
    static UT_SharedPtr<T> create(Args&&... args)
    {
        return UTmakeShared<T>(std::forward<Args>(args)...);
    }

    void notifyInsert(const NET_NetworkCookie &cookie)
    {
        notify_(&NET_INetworkCookieStoreObserver::onInsert, cookie);
    }
    void notifyDelete(const NET_NetworkCookie &cookie)
    {
        notify_(&NET_INetworkCookieStoreObserver::onDelete, cookie);
    }

protected:
    virtual void onInsert(const NET_NetworkCookie &cookie) = 0;
    virtual void onDelete(const NET_NetworkCookie &cookie) = 0;

    explicit NET_INetworkCookieStoreObserver(const ASIO_AnyExecutor &exc)
        : myExecutor(exc)
    {
    }

private:

    using func_ptr_t = void (NET_INetworkCookieStoreObserver::*)(
            const NET_NetworkCookie &);
    void notify_(func_ptr_t ptr, const NET_NetworkCookie &cookie)
    {
        hboost::asio::post(
                myExecutor,
                [weak = weak_from_this(), ptr, cookie]()
                {
                    if (UT_SharedPtr<NET_INetworkCookieStoreObserver> self
                        = weak.lock();
                        self != nullptr)
                    {
                        NET_INetworkCookieStoreObserver &observer = *self;

                        (observer.*ptr)(cookie);
                    }
                });
    }

    ASIO_AnyExecutor myExecutor;
};

class NET_API NET_NetworkCookieStore
    : public UTenable_shared_from_this<NET_NetworkCookieStore>
{
protected:
    struct PrivateCtorTag
    {
        explicit PrivateCtorTag(int) {}
    };

public:
    using CookieList = UT_Array<NET_NetworkCookie>;
    using iterator = CookieList::iterator;
    using const_iterator = CookieList::const_iterator;

    enum StoragePolicy
    {
        NoPersistentCookies,
        AllowPersistentCookies,
        ForcePersistentCookies
    };

    // Represents the unique key as defined in the sqlite db.
    class UniqueKey
    {
    public:
        explicit 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;
    };

    NET_NetworkCookieStore(
            const PrivateCtorTag &,
            const ASIO_AnyExecutor &exc)
        : NET_NetworkCookieStore(exc)
    {
    }
    ~NET_NetworkCookieStore();
    UT_NON_COPYABLE(NET_NetworkCookieStore);

    template <
            typename ExecutionContext,
            typename = typename std::enable_if_t<std::is_convertible_v<
                    ExecutionContext &,
                    hboost::asio::execution_context &>>>
    static UT_SharedPtr<NET_NetworkCookieStore> create(
            ExecutionContext &ctx,
            const UT_StringHolder &filename,
            StoragePolicy policy)
    {
        return create(ctx.get_executor(), filename, policy);
    }
    static UT_SharedPtr<NET_NetworkCookieStore> create(
            const ASIO_AnyExecutor& exc,
            const UT_StringHolder &filename,
            StoragePolicy policy)
    {
        auto store = UTmakeShared<NET_NetworkCookieStore>(
                PrivateCtorTag{0}, exc);
        store->configure(filename, policy);
        return store;
    }
    template <
            typename ExecutionContext,
            typename = typename std::enable_if_t<std::is_convertible_v<
                    ExecutionContext &,
                    hboost::asio::execution_context &>>>
    static UT_SharedPtr<NET_NetworkCookieStore> create(
            ExecutionContext &ctx)
    {
        return create(ctx.get_executor());
    }
    static UT_SharedPtr<NET_NetworkCookieStore> create(
            const ASIO_AnyExecutor &exc)
    {
        return UTmakeShared<NET_NetworkCookieStore>(PrivateCtorTag{0}, exc);
    }
    void configure(const UT_StringHolder &storage, StoragePolicy policy);

    void shutdown();

    bool load();
    // Flush any pending operations
    bool flush();

    // Delete the cookie from the in memory cookie store and the persistent
    // store.
    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.
    bool insertCookie(const NET_NetworkCookie &cookie);
    // Notify any observers a cookie was inserted.
    void notifyInsert_(const NET_NetworkCookie &cookie);
    // Try to update an existing cookie in the store. This adds a pending
    // operation if a cookie was added.
    bool updateCookie(const NET_NetworkCookie &cookie);
    bool updateCookieAccess(const NET_NetworkCookie& cookie);
    // Grab all cookies that apply to the passed in url.
    CookieList cookiesForUrl(const UT_Url &url) const;
    // Insert or update existing cookies based on the url.
    bool setCookiesFromUrl(const CookieList &cookies, const UT_Url &url);
    // Remove all cookies in our store
    void deleteAllCookies();

    void setStoragePolicy(StoragePolicy policy);

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

    /// Find a cookie in the cookie store based on the cookie identifier.
    UT_Optional<NET_NetworkCookie> find(const NET_NetworkCookie &cookie) const;

    // Grab a list of all cookies. This is really only meant to be used for
    // debugging and testing.
    CookieList allCookies() const;

    bool filter(NET_CookieList& cookies, const UT_StringRef& name) const;

    void attachObserver(
            const UT_SharedPtr<NET_INetworkCookieStoreObserver> &observer);
    void detachObserver(
            const UT_SharedPtr<NET_INetworkCookieStoreObserver> &observer);

private:
    explicit NET_NetworkCookieStore(const ASIO_AnyExecutor& exc);

    // 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>;

private:
    void addPendingOperation_(
            PendingOperation::Type type,
            const NET_NetworkCookie &cookie);
    bool insertCookie_(const NET_NetworkCookie& cookie);
    bool deleteCookie_(const NET_NetworkCookie &cookie);
    bool load_(
            UT_Array<NET_NetworkCookie> &cookies,
            PendingOperationList &pending_ops);
    bool fail(const UT_ErrorCode& ec, const char* what);

    UT_Lock myDBLock;
    UT_SqlDatabase myDB;

    mutable NET_RWLock myRWLock;
    UT_StringHolder myPersistentStorage;
    StoragePolicy myStoragePolicy = StoragePolicy::ForcePersistentCookies;
    UT_Map<UniqueKey, NET_NetworkCookie> myCookies;
    PendingOperationList myPendingOps;
    ASIO_AnyExecutor myExecutor;

    UT_ArraySet<UT_SharedPtr<NET_INetworkCookieStoreObserver>> myObservers;
};

#endif // __NET_NETWORKCOOKIESTORE_H__