NET_NetworkCookie.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_NetworkCookie.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_NETWORKCOOKIE_H__
#define __NET_NETWORKCOOKIE_H__

#include "NET_API.h"

#include "NET_ConvertToType.h"
#include "NET_Time.h"

#include <UT/UT_Array.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Url.h>

#include <ctime>

class NET_NetworkCookie;
using NET_CookieList = UT_Array<NET_NetworkCookie>;

class NET_API NET_NetworkCookie
{
public:
    enum StringForm
    {
        NameAndValueOnly,
        Full
    };

    enum SameSite
    {
        SAME_SITE_NONE,
        SAME_SITE_LAX,
        SAME_SITE_STRICT,
    };

    NET_NetworkCookie();
    NET_NetworkCookie(const UT_StringRef &name, const UT_StringRef &value);

    NET_NetworkCookie(const NET_NetworkCookie &cookie) = default;
    NET_NetworkCookie &operator=(const NET_NetworkCookie &cookie) = default;

    NET_NetworkCookie(NET_NetworkCookie &&cookie) = default;
    NET_NetworkCookie &operator=(NET_NetworkCookie &&cookie) = default;

    bool operator==(const NET_NetworkCookie &cookie) const;
    bool operator!=(const NET_NetworkCookie &cookie) const;

    bool hasSameIdentifier(const NET_NetworkCookie &cookie) const;
    UT_StringHolder toString(StringForm form = Full) const;
    bool hasMatchingDomain(const NET_NetworkCookie &cookie) const;
    bool hasMatchingDomain(const UT_Url &url) const;
    bool hasMatchingPath(const UT_StringRef &path) const;
    bool hasMatchingPath(const UT_Url &url) const;
    bool hasMatchingPath(const NET_NetworkCookie &cookie) const;
    bool isEquivalent(const NET_NetworkCookie &cookie) const
    {
        return myName == cookie.myName && myDomain == cookie.myDomain
               && myPath == cookie.myPath;
    }

    bool isValid() const;
    bool hasExpired() const;

    void normalize(const UT_Url &url);

    bool parseCookie(const UT_StringRef& cookie);
    static void parseCookies(const UT_StringArray &cookie_string,
                             NET_CookieList &cookies);

    const UT_StringHolder &name() const { return myName; }
    const UT_StringHolder &domain() const { return myDomain; }
    const NET_Time &creation() const { return myCreationDate; }
    const NET_Time &expiration() const { return myExpirationDate; }
    const UT_StringHolder &path() const { return myPath; }
    const UT_StringHolder &value() const { return myValue; }
    bool isHttpOnly() const { return myHttpOnly; }
    bool isSecure() const { return myIsSecure; }
    const NET_Time &lastAccess() const { return myLastAccessDate; }
    bool isPersistent() const { return myIsPersistent; }
    int maxAge() const { return myMaxAge; }
    SameSite sameSite() const { return mySameSite; }

    void setName(const UT_StringHolder &name) { myName = name; }
    void setDomain(const UT_StringHolder &domain) { myDomain = domain; }
    void setCreation(const NET_Time &t) { myCreationDate = t; }
    void setExpiration(const NET_Time &t)
    {
        myExpirationDate = t;
        myHasExpires = !myExpirationDate.isNull();
        setPersistent(myHasExpires);
    }
    bool setExpiration(const UT_StringRef& date)
    {
        bool result = NET_Time::fromUTCString(date, myExpirationDate);

        myHasExpires = result && !myExpirationDate.isNull();
        setPersistent(myHasExpires);
        return result;
    }
    void setPath(const UT_StringHolder &path) { myPath = path; }
    void setValue(const UT_StringHolder &value) { myValue = value; }
    void setHttpOnly(bool http_only) { myHttpOnly = http_only; }
    void setSecure(bool is_secure) { myIsSecure = is_secure; }
    void setLastAccess(const NET_Time &t) { myLastAccessDate = t; }
    void setPersistent(bool is_persistent) { myIsPersistent = is_persistent; }
    void setMaxAge(int max_age) { myMaxAge = max_age; }
    void setSameSite(SameSite same_site) { mySameSite = same_site; }

    // Debug print the entire contents of the cookie
    void dump() const;
private:
    friend class NET_NetworkCookieStore;

    UT_StringHolder myName;
    UT_StringHolder myDomain;
    NET_Time myCreationDate;
    NET_Time myExpirationDate;
    UT_StringHolder myPath;
    UT_StringHolder myValue;
    bool myHttpOnly;
    bool myIsSecure;
    bool myIsPersistent;
    NET_Time myLastAccessDate;
    bool myHasExpires;
    int myMaxAge = 0;
    SameSite mySameSite = SAME_SITE_NONE;
    // These variables are not used. They are only used to interface properly
    // with QtWebEngine
    int myPriority;
};

inline bool
NET_NetworkCookie::operator==(const NET_NetworkCookie &cookie) const
{
    return myName == cookie.myName && myDomain == cookie.myDomain &&
           myExpirationDate == cookie.myExpirationDate &&
           myPath == cookie.myPath && myValue == cookie.myValue &&
           myHttpOnly == cookie.myHttpOnly && myIsSecure == cookie.myIsSecure &&
           myIsPersistent == cookie.myIsPersistent &&
           myHasExpires == cookie.myHasExpires && myMaxAge == cookie.myMaxAge &&
           mySameSite == cookie.mySameSite;
}

inline bool
NET_NetworkCookie::operator!=(const NET_NetworkCookie &cookie) const
{
    return !(*this == cookie);
}

// Serialize
template<>
inline bool NETserialize<NET_NetworkCookie>(UT_JSONWriter& writer, const NET_NetworkCookie &cookie)
{
    if (!cookie.isValid())
        return false;

    writer.jsonValue(cookie.toString());
    return true;
}

template <>
inline bool NETserialize<NET_NetworkCookie>(const UT_JSONValue& data, NET_NetworkCookie& cookie)
{
    UT_StringHolder str_cookie;
    if (!data.import(str_cookie))
        return false;

    return cookie.parseCookie(str_cookie);    
}

#endif // __NET_NETWORKCOOKIE_H__