wysockaddrinet6.h

一个不错

/* Copyright is licensed under GNU LGPL.                 by I.J.Wang 2005

  WySockAddrINet6 deals with the IPv6 address (AF_INET6)

  Note: Class is not decided to be inherited
  Note: construction not support from WyCSeg directly

  [Converted] struct sockaddr/ socklen_t/inet_ntop
                  sockaddr_in6
*/

#ifndef WYSOCKADDRINET6_H__
#define WYSOCKADDRINET6_H__
#define WYSOCKADDRINET6_VERSION 31

#include "wyret.h"
#include "wystr.h"
#include "wy_sockaddr.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

// Class for IPv6 address (family=AF_INET6)
//
class WySockAddrINet6 : public Wy_SockAddr {
  public:
    typedef struct ::in6_addr InAddrType;
    typedef ::in_port_t InPortType;

  private:
    class Wy_Assert_Check;
    static const InAddrType& DefaultIP;
    static const InPortType DefaultPort=0;          // net format
    static const uint32_t DefaultFlowInfo=0;        // net format
    static const uint32_t DefaultScopeId=0;         // net format
    static const socklen_t DefaultSockLen=sizeof(struct ::sockaddr_in6); 

    struct ::sockaddr_in6 _saddr;
    socklen_t _slen;

  public:
    class IPAddr {
        InAddrType _addr;

        // [Ret] Ok
        //       Wym_EFAULT str inaccessible
        //       Wym_EADDRNOTAVAIL str not recognizable
        //       Wym_EAFNOSUPPORT  str invalid
        //
        WyRet _init(const char* str);
      public:
        static const char class_name[];
        WY_THROW_REPLY;

        IPAddr() WY__TSPC();
        IPAddr(const IPAddr&) WY__TSPC();
        IPAddr(const InAddrType&) WY__TSPC();
        IPAddr(const char* cstr);
        IPAddr(const WyStr& str);
        IPAddr(IPAddr&,Wy::ByMove_t) WY__TSPC();
        bool is_default(void) const WY__TSPC();
        InAddrType c_addr(void) const WY__TSPC()
           { return _addr; };
        WyRet notation(WyStr& addr) const;
        void reset(void) WY__TSPC();
        void reset(const IPAddr&) WY__TSPC();
        void reset(const InAddrType&) WY__TSPC();
        WyRet reset(const char* cstr);
        WyRet reset(const WyStr& str);
        void swap(IPAddr& addr) WY__TSPC();

        const IPAddr& operator =(const IPAddr&) WY__TSPC();
        const IPAddr& operator =(const InAddrType&) WY__TSPC();

        bool operator ==(const IPAddr& rhs) const WY__TSPC();
        bool operator !=(const IPAddr& rhs) const WY__TSPC();
        bool operator ==(const InAddrType& rhs) const WY__TSPC();
        bool operator !=(const InAddrType& rhs) const WY__TSPC();
        bool operator ==(const WyStr& rhs) const;
        bool operator !=(const WyStr& rhs) const
             { return !this->operator==(rhs); };
        bool operator ==(const char* rhs) const;
        bool operator !=(const char* rhs) const
             { return !this->operator==(rhs); };

        const InAddrType& wy_addr_ref(void) const WY__NOTHROW__
           { return _addr; };
    };

    static const char class_name[];
    inline static int family(void) WY__TSPC()
              { return AF_INET6; };
    WY_THROW_REPLY;

    WySockAddrINet6() WY__TSPC();
    WySockAddrINet6(const WySockAddrINet6 &) WY__TSPC();
    WySockAddrINet6(const struct ::sockaddr_in6&) WY__TSPC();
    WySockAddrINet6(const IPAddr&, InPortType) WY__TSPC();
    WySockAddrINet6(WySockAddrINet6& src, Wy::ByMove_t) WY__TSPC();

    bool is_default(void) const WY__TSPC();

    IPAddr ip(void) const WY__TSPC();
    InPortType port(void) const WY__TSPC();
    uint32_t _flowinfo(void) const WY__TSPC()
              { return htonl(_saddr.sin6_flowinfo); };
    uint32_t _scope_id(void) const WY__TSPC()
              { return htonl(_saddr.sin6_scope_id); };

    // [Override]
    virtual WyRet notation(WyStr& str) const;

    virtual void reset(void) WY__TSPC()
              { this->_init(); };
    virtual void reset(const struct ::sockaddr_in6& src) WY__TSPC()
              { this->_init(src); };
    virtual void reset(const IPAddr& ip, InPortType port) WY__TSPC()
              { this->_init(ip,port); };
    virtual void reset(const WySockAddrINet6 &src) WY__TSPC()
              { this->_init(src); };

    virtual const WySockAddrINet6 &operator=(const WySockAddrINet6 &rhs) WY__TSPC()
              {
                this->_init(rhs); 
                return(*this); 
              };
    virtual const WySockAddrINet6 &operator=(const struct ::sockaddr_in6& rhs) WY__TSPC()
              {
                this->_init(rhs); 
                return(*this); 
              };

    virtual WyRet _swap(Wy_SockAddr& iaddr) WY__TSPC();
    virtual WySockAddrINet6* _alloc(WyRet&) const;

    bool operator==(const WySockAddrINet6 &rhs) const WY__TSPC();
    bool operator!=(const WySockAddrINet6 &rhs) const WY__TSPC()
              { return !operator==(rhs); };
    bool operator==(const struct ::sockaddr_in6& rhs) const WY__TSPC();
    bool operator!=(const struct ::sockaddr_in6& rhs) const WY__TSPC()
              { return !operator==(rhs); };

    const struct ::sockaddr_in6& wy_sockaddr_ref(void) const WY__TSPC()
           { return _saddr; };
  private:
    virtual struct ::sockaddr& c_sockaddr(void) WY__TSPC()
              { return (struct ::sockaddr&)(_saddr); };
    virtual const struct ::sockaddr& c_sockaddr(void) const WY__TSPC()
              { return (struct ::sockaddr&)(_saddr); };

    virtual size_t c_sockaddr_size(void) const WY__TSPC()
              { return sizeof(_saddr); };

    virtual  socklen_t& c_addrlen(void) WY__TSPC()
              { return _slen; };
    virtual const socklen_t& c_addrlen(void) const WY__TSPC()
              { return _slen; };

    // [Internal] Initialize object to the default state
    //
    //     family() = AF_INET6
    //         ip() = ::in6addr_any
    //       port() = 0
    //   _flowinfo()= 0
    //   _scope_id()= 0
    //
    void _init(void) WY__TSPC();

    // [Internal] Initialize object from ::sockaddr_in6
    //
    //     family() = AF_INET6
    //         ip() = from src.sin6_addr
    //       port() = from src.sin6_port
    //   _flowinfo()= from src.sin6_flowinfo
    //   _scope_id()= from src.sin6_scope_id
    //
    void _init(const struct ::sockaddr_in6& src) WY__TSPC();

    // [Internal] Initialize object to the state by the arguments
    //
    //     family() = AF_INET6
    //         ip() = ip.ip()
    //       port() = port
    //   _flowinfo()= 0
    //   _scope_id()= 0
    //
    void _init(const IPAddr& ip, InPortType port) WY__TSPC();

    // [Internal] Reconstruct object by copy from src
    //
    //     family() = AF_INET6
    //         ip() = from src
    //       port() = ditto
    //   _flowinfo()= ditto
    //   _scope_id()= ditto
    //
    void _init(const WySockAddrINet6 &src) WY__TSPC();
};

inline bool operator ==(const WySockAddrINet6::InAddrType& ip1, const WySockAddrINet6::IPAddr& ip2) WY__TSPC()
{ return ip2==WySockAddrINet6::IPAddr(ip1); };
inline bool operator !=(const WySockAddrINet6::InAddrType& ip1, const WySockAddrINet6::IPAddr& ip2) WY__TSPC()
{ return ip2!=WySockAddrINet6::IPAddr(ip1); };
inline bool operator ==(const char* ip1, const WySockAddrINet6::IPAddr& ip2) 
{ return ip2==ip1; };
inline bool operator !=(const char* ip1, const WySockAddrINet6::IPAddr& ip2)
{ return ip2!=ip1; };
inline bool operator ==(const WyStr& ip1, const WySockAddrINet6::IPAddr& ip2)
{ return ip2==ip1; };
inline bool operator !=(const WyStr& ip1, const WySockAddrINet6::IPAddr& ip2)
{ return ip2!=ip1; };

inline bool operator==(const struct ::sockaddr_in6& a1, const WySockAddrINet6& a2) WY__TSPC()
              { return a2==a1; };
inline bool operator!=(const struct ::sockaddr_in6& a1, const WySockAddrINet6& a2) WY__TSPC()
              { return a2!=a1; };

namespace Wy {
 WyStr wrd(const WySockAddrINet6::IPAddr& addr);
 WyStr wrd(const WySockAddrINet6& addr);
};

/*
// Wy_Array specilization to support struct in6_addr, sockaddr_in6
//
#include "wy_array.h"

template<>
struct Wy_Array< ::in6_addr > : Wy__ArrayValue< ::in6_addr > {
  Wy_Array() : Wy__ArrayValue< ::in6_addr >() {};
  Wy_Array(size_t s, const ::in6_addr& elem) : Wy__ArrayValue< ::in6_addr >(s,elem) {};
  Wy_Array(const Wy_Array& s) : Wy__ArrayValue< ::in6_addr >(s) {};
  Wy_Array(Wy_Array& p, Wy::ByMove_t t) : Wy__ArrayValue< ::in6_addr >(p,t) {};
};

template<>
struct Wy_Array< ::sockaddr_in6 > : Wy__ArrayValue< ::sockaddr_in6 > {
  Wy_Array() : Wy__ArrayValue< ::sockaddr_in6 >() {};
  Wy_Array(size_t s, const ::sockaddr_in6& elem) : Wy__ArrayValue< ::sockaddr_in6 >(s,elem) {};
  Wy_Array(const Wy_Array& s) : Wy__ArrayValue< ::sockaddr_in6 >(s) {};
  Wy_Array(Wy_Array& p, Wy::ByMove_t t) : Wy__ArrayValue< ::sockaddr_in6 >(p,t) {};
};
*/

#endif