NET_WebMiddleware.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_WebMiddleware.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_WEBMIDDLEWARE_H__
#define __NET_WEBMIDDLEWARE_H__

#include "NET_API.h"

#include "NET_HTTPDefines.h"

#include <UT/UT_Array.h>
#include <UT/UT_Regex.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>

class NET_HTTPRequest;
class NET_WebResponse;

class NET_API NET_WebMiddleware
{
public:
    NET_WebMiddleware() = default;
    virtual ~NET_WebMiddleware() = default;

    NET_WebMiddleware(const NET_WebMiddleware&) = delete;
    NET_WebMiddleware& operator=(const NET_WebMiddleware&) = delete;

    virtual void processRequest(NET_HTTPRequest &req) const {}
    virtual void processResponse(const NET_HTTPRequest &req, NET_WebResponse &resp) const {}
};

// Compress response with GZIP
class NET_API NET_GZipMiddleware : public NET_WebMiddleware
{
public:
    void processResponse(const NET_HTTPRequest &req, NET_WebResponse &resp) const override;
};

// Log Middleware
class NET_API NET_MessageMiddleware : public NET_WebMiddleware
{
public:
    NET_MessageMiddleware(bool process_request) :
        myProcessRequest(process_request)
    {}

    void processRequest(NET_HTTPRequest &req) const override;
    void processResponse(const NET_HTTPRequest &req, NET_WebResponse &resp) const override;

private:
    bool myProcessRequest;
};

// CORS Middleware
class NET_API NET_CORSMiddleware : public NET_WebMiddleware
{
public:
    void processResponse(const NET_HTTPRequest& req, NET_WebResponse &resp) const override;
};

// Security Middleware
class NET_API NET_SecurityMiddleware : public NET_WebMiddleware
{
public:
    NET_SecurityMiddleware();

    void processRequest(NET_HTTPRequest &req) const override;
    void processResponse(const NET_HTTPRequest& req, NET_WebResponse& resp) const override;

    void redirect(bool redirect) { myRedirect = redirect; }
    void redirectHost(const UT_StringHolder& redirect_host)
    {
        myRedirectHost = redirect_host;
    }
    void redirectExempt(const UT_StringArray& exempt)
    {
        myRedirectExempt.clear();
        myRedirectExempt.setCapacity(exempt.size());
        for (auto&& e : exempt)
            myRedirectExempt.emplace_back(e);
    }
    void stsSeconds(int sts_seconds) { myStsSeconds = sts_seconds; }
    void stsIncludeSubdomains(bool include_subdomains) { myStsIncludeSubdomains = include_subdomains; }
    void stsPreload(bool preload) { myStsPreload = preload; }
    void noSniff(bool no_sniff) { myContentNoSniff = no_sniff; }
    void referrerPolicy(const UT_StringHolder& policy) { myReferrerPolicy = policy; }
    void referrerPolicy(const UT_StringArray& policy)
    {
        UT_WorkBuffer wbuf;
        for (auto&& item : policy)
        {
            if (!wbuf.isEmpty())
                wbuf.append(',');
            wbuf.append(item);
        }
        myReferrerPolicy = std::move(wbuf);
    }
    void crossOriginOpenerPolicy(const UT_StringHolder& cross_origin_opener_policy)
    {
        myCrossOriginOpenerPolicy = cross_origin_opener_policy;
    }

private:
    bool matches(const UT_StringHolder& path, const UT_Array<UT_Regex>& items) const;

    bool myRedirect;
    UT_Array<UT_Regex> myRedirectExempt;
    UT_StringHolder myRedirectHost;
    int myStsSeconds;
    bool myStsIncludeSubdomains;
    bool myStsPreload;
    bool myContentNoSniff;
    UT_StringHolder myReferrerPolicy;
    UT_StringHolder myCrossOriginOpenerPolicy;
};

#endif // __NET_WEBMIDDLEWARE_H__