NET_IpValidator.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_IpValidator.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_IPVALIDATOR_H__
#define __NET_IPVALIDATOR_H__

#include "NET_API.h"

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

#include "NET_ServerInfo.h"

/// Validates ip addresses based on a set of standard ip subnet masks and custom
/// format ip masks. Note: the custom format has been deprecated for the
/// standard format.
class NET_API NET_IpValidator
{
public:
    NET_IpValidator(const NET_IServerInfo& server) :
        myCustomMask(),
        myMasksV4(),
        myMasksV6(),
        myServer(server)
    {}
    NET_IpValidator(const NET_IServerInfo& server, const UT_StringArray& masks) :
        myServer(server)
    {
        setMasks(masks);
    }

    /// Check if the provided ip matches one of the ip masks.
    bool match(const UT_IpAddressV4& ip) const;
    /// Check if the provided ip matches one of the ip masks.
    bool match(const UT_IpAddressV6& ip) const
    {
        if (!myMasksV6.isEmpty())
        {
            UT_IpNetworkV6 host_network(ip, 128);
            for (auto&& net : myMasksV6)
            {
                // If the network address is a host address then simply check
                // the two addresses.
                if (net.isHost())
                {
                    if (net.address() == ip)
                        return true;
                }
                else if (host_network.isSubnetOf(net))
                    return true;
            }
        }
        // If no v6 masks were provided and the address is not v4 mapped then
        // report it as a match.
        else if (!ip.isV4Mapped())
        {
            return true;
        }

        // If the ip6 is an ip4 mapped to ip6 then try the ipv6 masks and the
        // fallback to converting the address to ip4. This allows both ip4 and
        // ip6 masks to be given for ip4 addresses.
        if (ip.isV4Mapped())
        {
            return match(ip.toV4());
        }

        return false;
    }
    /// Check if the provided ip matches on of the ip masks based on the ip
    /// address type.
    bool match(const UT_IpAddress& ip) const
    {
        if (ip.isV4())
            return match(ip.toV4());
        return match(ip.toV6());
    }
    /// Set the ip masks to the provided list. Note that the previous list
    /// of masks are cleared.
    void setMasks(const UT_StringArray& masks)
    {
        myCustomMask.clear();
        myMasksV4.clear();
        myMasksV6.clear();
        addMasks(masks);
    }
    /// Set the ip masks to the provided mask. Note that the previous list
    /// of masks are cleared.
    void setMask(const UT_StringHolder& mask)
    {
        myCustomMask.clear();
        myMasksV4.clear();
        myMasksV6.clear();
        addMask(mask);
    }
    /// Add the provided mask to the current list of masks.
    void addMask(const UT_StringHolder& mask);
    /// Add the provided list of masks to the current list of masks.
    void addMasks(const UT_StringArray& masks)
    {
        for (auto&& mask : masks)
            addMask(mask);
    }
    UT_StringHolder toStringV4() const
    {
        UT_WorkBuffer wbuf;
        for (auto&& mask : myMasksV4)
        {
            if (!wbuf.isEmpty())
                wbuf.append(',');
            wbuf.append(mask.toString());
        }
        if (!myCustomMask.isEmpty())
        {
            if (!wbuf.isEmpty())
                wbuf.append(',');
            wbuf.append(myCustomMask);
        }
        UT_StringHolder str(std::move(wbuf));
        return str;
    }
    UT_StringHolder toStringV6() const
    {
        UT_WorkBuffer wbuf;
        for (auto&& mask : myMasksV6)
        {
            if (!wbuf.isEmpty())
                wbuf.append(',');
            wbuf.append(mask.toString());
        }
        UT_StringHolder str(std::move(wbuf));
        return str;
    }

private:
    // Old custom format for ip mask which is only supported for ipv4
    UT_StringHolder myCustomMask;

    UT_Array<UT_IpNetworkV4> myMasksV4;
    UT_Array<UT_IpNetworkV6> myMasksV6;

    const NET_IServerInfo& myServer;
};

#endif // __NET_IPVALIDATOR_H__