mn_basic_ip6_address.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2018 Amber-Sophia Schroeck
*
*The Mini Thread Library is free software; you can redistribute it and/or modify
*it under the terms of the GNU Lesser General Public License as published by
*the Free Software Foundation, version 3, or (at your option) any later version.
 
*The Mini Thread Library is distributed in the hope that it will be useful, but
*WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef __MINLIBNET_BASIC_IP6_ADDRESS_H__
#define __MINLIBNET_BASIC_IP6_ADDRESS_H__
 
#include "../mn_config.hpp"
 
#if MN_THREAD_CONFIG_NET_IPADDRESS6_ENABLE == MN_THREAD_CONFIG_YES
 
#define MNNET_IPV6_ADDRESS_BYTES        16
#define MNNET_NUMBER_OF_LABELS          8
 
#define MNNET_IPV6_NEW_ARRAY_NULL       new uint8_t[MNNET_IPV6_ADDRESS_BYTES]{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }
#define MNNET_IPV6_NEW_ARRAY_LOOP       new uint8_t[MNNET_IPV6_ADDRESS_BYTES]{ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 }
 
#if MN_THREAD_CONFIG_NET_IPADDRESS6_USE_SCOPEID  == MN_THREAD_CONFIG_YES
#define MNNET_IPV6_ADDRESS_ANY          mn::net::basic_ip6_address( MNNET_IPV6_NEW_ARRAY_NULL, 0 )
#define MNNET_IPV6_ADDRESS_LOOPBACK     mn::net::basic_ip6_address( MNNET_IPV6_NEW_ARRAY_LOOP, 0 )
#else
#define MNNET_IPV6_ADDRESS_ANY          mn::net::basic_ip6_address( MNNET_IPV6_NEW_ARRAY_NULL )
#define MNNET_IPV6_ADDRESS_LOOPBACK     mn::net::basic_ip6_address( MNNET_IPV6_NEW_ARRAY_LOOP )
#endif // MN_THREAD_CONFIG_NET_IPADDRESS6_USE_SCOPEID
 
#define MNNET_IPV6_ADDRESS_NONE              MNNET_IPV6_ADDRESS_ANY
 
#include "mn_basic_ip4_address.hpp"
 
namespace mn {
    namespace net {
        class basic_ip6_address : public basic_ip_address {
        protected:
            union {
                uint8_t         m_Numbers[MNNET_IPV6_ADDRESS_BYTES];
                uint16_t        as_short[8];
                uint32_t        as_int[4];
            };
        #if MN_THREAD_CONFIG_NET_IPADDRESS6_USE_SCOPEID  == MN_THREAD_CONFIG_YES
            long                m_ScopeId;
        #endif
        public:
            basic_ip6_address();
 
            basic_ip6_address(uint32_t ax, uint32_t bx, uint32_t cx, uint32_t dx) noexcept;
 
            basic_ip6_address(uint32_t iarray[4]) noexcept;
#if MN_THREAD_CONFIG_NET_IPADDRESS6_USE_SCOPEID  == MN_THREAD_CONFIG_YES
            basic_ip6_address(uint8_t address[16], int scopid) noexcept;
#else
            basic_ip6_address(uint8_t address[16]) noexcept;
#endif
            basic_ip6_address(const char* str_ip) noexcept;
            basic_ip6_address(const basic_ip6_address& ipOther) noexcept;
 
        #if MN_THREAD_CONFIG_NET_IPADDRESS6_USE_SCOPEID  == MN_THREAD_CONFIG_YES
            long                    get_scopeid()
                { return m_ScopeId; }
            void                    set_scopeid(long scope_id)
                { m_ScopeId = id; }
        #endif
            const char*     to_string();
            uint8_t*        get_bytes();
            uint32_t*       get_array() { return as_int; }
            int length() const;
            virtual uint32_t        get_int(int index)  { return index < 4 ? as_int[index] : 0; }
 
            virtual uint32_t        get_int(int index) const  { return index < 4 ? as_int[index] : 0; }
 
            inline void             set_zero()
                { as_int[0] = 0; as_int[1] = 0; as_int[2] = 0; as_int[3] = 0; }
            inline void             set_loopback()
                { as_int[0] = 0; as_int[1] = 0; as_int[2] = 0; as_int[3] = PP_HTONL(0x00000001UL);; }
 
            virtual bool            is_loopback() { return (*this == MNNET_IPV6_ADDRESS_LOOPBACK); }
            virtual bool            is_broadcast() { return false; }
            virtual bool            is_multicast() { return ( (as_short[0] & 0xFF00 ) == 0xFF00 );  }
 
            virtual bool            is_any() { return *this == MNNET_IPV6_ADDRESS_ANY; }
            virtual bool            is_linklocal() { return ( (as_short[0] & 0xFFC0 ) == 0xFE80 );  }
            virtual bool            is_sitelocal() { return ( (as_short[0] & 0xFFC0 ) == 0xFEC0 );  }
            virtual bool            is_toredo()    { return (  as_short[0] == 0x2001 && as_short[1] == 0  );  }
            virtual bool            is_ip4mapped();
            virtual bool            is_equel(const basic_ip6_address& ipOther);
            virtual bool            is_equel(const basic_ip6_address& ipOther, const basic_ip6_address& mask);
 
            basic_ip6_address&  operator = (const basic_ip6_address& ip);
 
            uint8_t             operator[](int index) const { return m_Numbers[index]; }
            uint8_t&            operator[](int index) { return m_Numbers[index]; }
            bool                operator == (const basic_ip6_address& ipOther){ return  is_equel(ipOther); }
            bool                operator != (const basic_ip6_address& ipOther){ return !is_equel(ipOther); }
 
            basic_ip6_address   operator&(const basic_ip6_address& other)const;
            basic_ip6_address   operator|(const basic_ip6_address& other)const;
            basic_ip6_address   operator^(const basic_ip6_address& other)const;
            basic_ip6_address   operator~() const;
 
 
            static basic_ip4_address to_ip4(const basic_ip6_address& ip6) {
                return basic_ip4_address(lwip_ntohl(ip6.as_int[3]) );
            }
            static basic_ip6_address from_ip4(const basic_ip4_address& ip4) {
                return basic_ip6_address(0x00000000, 0x00000000, htonl(0xffff), (uint32_t)ip4);
            }
            static basic_ip6_address netmask(int mask);
 
            virtual void swap(basic_ip6_address& rhs) noexcept {
                basic_ip_address::swap(rhs);
                mn::swap<uint32_t>(as_int[0], rhs.as_int[0]);
                mn::swap<uint32_t>(as_int[1], rhs.as_int[1]);
                mn::swap<uint32_t>(as_int[2], rhs.as_int[2]);
                mn::swap<uint32_t>(as_int[3], rhs.as_int[3]);
            }
        };
    }
}
 
#endif // MN_THREAD_CONFIG_NET_IPADDRESS6_ENABLE
 
#endif // __MINLIBNET_BASIC_IP6_ADDRESS_H__