config_netobj.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef CONFIG_NETOBJ_H
#define CONFIG_NETOBJ_H
#include <config_obj.h>
 
class config_localname : public config_string
{
    public:
         config_localname(config_obj &owner, NBString def_val, const char *name, const char *desc = NULL)
             : config_string(owner, def_val, name, desc){};
 
         config_localname(config_localname &&l)
             : config_string((config_string&&)l)
         { }
 
         config_localname(NBString def_val, const char *name, const char *desc = NULL) : config_string(def_val, name, desc){};
 
         config_localname(config_obj &owner, const char *def_val, const char *name, const char *desc = NULL)
             : config_string(owner, def_val, name, desc){};
 
         config_localname(const char *def_val, const char *name, const char *desc = NULL) : config_string(def_val, name, desc){};
 
         virtual void CommitTestedValue(uint32_t permission_mask);
        operator NBString() const { return val; };
 
        config_localname &operator=(const char *p)
        {
            pend_val = val = p;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            return *this;
        };
 
        config_localname &operator=(const NBString &s)
        {
            pend_val = val = s;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            return *this;
        };
 
        config_localname &operator=(const config_string &ci)
        {
            pend_val = val = ci.val;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            return *this;
        };
 
        config_localname &operator=(const config_localname &ci)
        {
            pend_val = val = ci.val;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            return *this;
        }
};
 
 
class I4Record;
class CUR_IPADDR4 : public config_value
{
    protected:
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    IPADDR4 i4;
    ConfigEndMarker;
    CUR_IPADDR4(const char *name, const char *desc = NULL) : config_value(name, desc)
    {
        SetFlag(fConfigReadOnly | fConfigNoSave);
        i4 = 0;
    }
 
    CUR_IPADDR4(CUR_IPADDR4 &&I)
        : config_value((config_value&&)I), i4(I.i4)
    {
 
    }
 
    virtual void GetTextValue(NBString &s) { s.siprintf("\"%hI\"", i4); };
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) { return eUnchanged; }
    virtual void CommitTestedValue(uint32_t permission_mask){};
 
    CUR_IPADDR4 &operator=(const CUR_IPADDR4 &v)
    {
        if(i4!=v.i4)
        {
            i4 = v.i4;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            AssignmentNotify();
        }
        return *this;
    };
    CUR_IPADDR4 &operator=(const IPADDR4 &v)
    {
        if(i4!=v)
        {
            i4 = v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            AssignmentNotify();
        }
        return *this;
    };
    CUR_IPADDR4 &operator=(const uint32_t v)
    {
        if(i4!=v)
        {
            i4 = v;
            if (GetFlags(fConfigIsDefault))
                ClrBranchFlag(fConfigIsDefault, true);
            AssignmentNotify();
        }
        return *this;
    };
 
    virtual void ExtendedSchema(int fd, int indent, bool pretty) { DoSchemaLine(fd, "format", "ipv4", indent, pretty); };
    virtual void GetTypeValue(NBString &s) { s = "string"; };
    operator IPADDR4() { return i4; };
 
    inline bool IsNull() const { return i4.IsNull(); };
    inline bool NotNull() const { return i4.NotNull(); };
    inline void SetNull() { return i4.SetNull(); };
    inline bool IsLoopBack() const { return i4.IsLoopBack(); };
    inline bool IsMultiCast() const { return i4.IsMultiCast(); };
    inline bool IsGlobalBroadCast() const { return i4.IsGlobalBroadCast(); };
    inline bool IsAutoIP() { return i4.IsAutoIP(); };
};
 
inline bool operator==(const IPADDR4 i, const CUR_IPADDR4 &j)
{
    return i == j.i4;
}
inline bool operator!=(const IPADDR4 i, const CUR_IPADDR4 &j)
{
    return i != j.i4;
}
inline bool operator>(const IPADDR4 i, const CUR_IPADDR4 &j)
{
    return i > j.i4;
}
inline bool operator<(const IPADDR4 i, const CUR_IPADDR4 &j)
{
    return i > j.i4;
}
 
inline bool operator==(const CUR_IPADDR4 & i, const IPADDR4 j)
{
    return i.i4 == j;
}
inline bool operator!=(const CUR_IPADDR4 & i, const IPADDR4 j)
{
    return i.i4 != j;
}
inline bool operator>(const CUR_IPADDR4 & i, const IPADDR4 j)
{
    return i.i4 > j;
}
inline bool operator<(const CUR_IPADDR4 & i, const IPADDR4 j)
{
    return i.i4 > j;
}
 
inline bool operator==(const uint32_t i, const CUR_IPADDR4 &j)
{
    return i == j.i4;
}
inline bool operator!=(const uint32_t i, const CUR_IPADDR4 &j)
{
    return i != j.i4;
}
inline bool operator>(const uint32_t i, const CUR_IPADDR4 &j)
{
    return i > j.i4;
}
inline bool operator<(const uint32_t i, const CUR_IPADDR4 &j)
{
    return i < j.i4;
}
 
inline bool operator==(const CUR_IPADDR4 &i, const uint32_t j)
{
    return i.i4 == j;
}
inline bool operator!=(const CUR_IPADDR4 &i, const uint32_t j)
{
    return i.i4 != j;
}
inline bool operator>(const CUR_IPADDR4 &i, const uint32_t j)
{
    return i.i4 > j;
}
inline bool operator<(const CUR_IPADDR4 &i, const uint32_t j)
{
    return i.i4 < j;
}
 
class I4Record : public config_obj
{
    void *m_pBlock_if;
 
   public:
    config_chooser mode{"Mode", "DHCP", "DHCP,DHCP w Fallback,Static,Disabled",
                        "DHCP,DHCP with backup static address,Static preconfigured address,Disabled"};
    config_IPADDR4 addr{"0.0.0.0", "StaticAddr", "Configured IP Address"};
    config_IPADDR4 mask{"0.0.0.0", "StaticMask", "Configured IP Mask"};
    config_IPADDR4 gate{"0.0.0.0", "StaticGate", "Configured IP Gateway"};
    config_IPADDR4 dns1{"0.0.0.0", "StaticDNS1", "Configured IP DNS(1)"};
    config_IPADDR4 dns2{"0.0.0.0", "StaticDNS2", "Configured IP DNS(2)"};
 
    config_bool autoip{true, "AutoIPEn", "Enable Auto IP"};
 
    //These are the only values used activly by the system
    CUR_IPADDR4 cur_addr{"ActiveAddr", "Current IPV4 address in use"};
    CUR_IPADDR4 cur_mask{"ActiveMask", "Current IPV4 mask in use"};
    CUR_IPADDR4 cur_gate{"ActiveGate", "Current IPV4 gateway in use"};
    CUR_IPADDR4 cur_dns1{"ActiveDNS1", "Current IPV4 dns(1) in use"};
    CUR_IPADDR4 cur_dns2{"ActiveDNS2", "Current IPV4 dns(2) in use"};
    CUR_IPADDR4 cur_auto{"AutoIPAddr", "Current IPV4 auto address in use"};
    config_bool mac_dns {true,"EnableMacmDNS","Enable nburnxxxxxx.local using mac address"};
    config_localname  local_name{"","LocalName","The local name to resolve with mDNS (.local assumed)"};
 
    ConfigEndMarker;
 
    I4Record(const char *name, const char *desc = NULL) : config_obj(name, desc) { m_pBlock_if = 0; };
 
    I4Record(I4Record &&IR);
 
    void Attach(void *pb) { m_pBlock_if = pb; }
    void GetReportItem(NBString &s, int item);
};
 
#ifdef IPV6
class I6Record;
 
class Dynamic_IPADDR : public config_value
{
    int m_nItem;
    I6Record *m_pI6;
    ConfigEndMarker;
 
    protected:
    virtual int FdPrintValue(int fd, bool raw) override;
   public:
    virtual void GetTextValue(NBString &s);
 
    Dynamic_IPADDR(const char *name, int item, I6Record *pI6, const char *desc = NULL) : config_value(name, desc)
    {
        m_nItem = item;
        m_pI6 = pI6;
        SetFlag(fConfigReadOnly | fConfigNoSave);
    }
    Dynamic_IPADDR(Dynamic_IPADDR &&di);
 
    virtual ConfigTestResult TestNewValue(ParsedJsonDataSet &pjs) { return eUnchanged; }
    virtual void CommitTestedValue(uint32_t permission_mask){};
    void AddToJsonOutObject(ParsedJsonDataSet &jo, const char *name);
    virtual void ExtendedSchema(int fd, int indent, bool pretty) { DoSchemaLine(fd, "format", "ipv6", indent, pretty); };
    virtual void GetTypeValue(NBString &s) { s = "array"; };
};
 
class I6Record : public config_obj
{
    int m_nIf;
 
   public:
    config_chooser mode{"Mode", "DHCP", "DHCP,DHCP w Fallback,Static,Disabled",
                        "DHCP,DHCP with backup static address,Static preconfigured address,Disabled"};
    config_IPADDR addr{"0::0", "StaticAddr", "Configured IPV6 address"};
    config_IPADDR dns1{"0::0", "StaticDNS1", "Configured IPV6 DNS(1)"};
    config_IPADDR dns2{"0::0", "StaticDNS2", "Configured IPV6 DNS(2)"};
 
    Dynamic_IPADDR address_list{"ActiveAddr", 0, this, "Active currently in user IPV6 addres(s)"};
    Dynamic_IPADDR dns_list{"ActiveDNS", 1, this, "Active currently in user IPV6 DNS(s)"};
    Dynamic_IPADDR route_list{"ActiveRoute", 2, this, "Active currently in user IPV6 routes"};
 
    ConfigEndMarker;
 
    I6Record(const char *name, const char *desc = NULL) : config_obj(name, desc) { m_nIf = -1; };
    I6Record(I6Record &&i6);
    void Attach(int nif) { m_nIf = nif; };
    void ReportGetTextValue(NBString &s, int item);
    int GetnIf() { return m_nIf; };
};
#endif
 
#endif