wysockaddrinet6.cpp

一个不错

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

  Refer: ipv6(7)
*/

#define WYLIB_SOURCE
#include "wysockaddrinet6.h"
#include <cstring>
#include <memory>
#include <typeinfo>

const char WySockAddrINet6::IPAddr::class_name[]="WySockAddrINet6::IPAddr";

WyRet WySockAddrINet6::IPAddr::_init(const char* cstr)
{
 if(cstr==NULL) {
   WY_RETURN(Wym_EFAULT);
 }
 int v=::inet_pton(AF_INET6,cstr,&_addr);
 if(v<=0) {
   if(v==0) {
     WY_RETURN(Wym_EADDRNOTAVAIL);  // string in addr not recognizable
   }
   WY_RETURN(errno);
 }
 return(Ok);
};

WySockAddrINet6::IPAddr::IPAddr() WY__TSPC()
{
 std::memcpy(&_addr,&::in6addr_any,sizeof(_addr));
};

WySockAddrINet6::IPAddr::IPAddr(const InAddrType& src) WY__TSPC()
{
 std::memcpy(&_addr,&src,sizeof(_addr));
};

WySockAddrINet6::IPAddr::IPAddr(const char* cstr)
{
 WyRet r( this->_init(cstr) );
 if(r!=Ok) {
   WY_THROW( Reply(r) );
 }
};

WySockAddrINet6::IPAddr::IPAddr(const WyStr& addr)
{
 WyRet r=this->_init(addr.c_str());
 if(r!=Ok) {
   WY_THROW( Reply(r) );
 }
};

WySockAddrINet6::IPAddr::IPAddr(const IPAddr& src) WY__TSPC()
{
 std::memcpy(&_addr,&src._addr,sizeof(_addr));
};

WySockAddrINet6::IPAddr::IPAddr(IPAddr& src, Wy::ByMove_t) WY__TSPC()
{
 std::memcpy(&_addr,&src._addr,sizeof(_addr));
};

bool WySockAddrINet6::IPAddr::is_default(void) const WY__TSPC()
{
 return std::memcmp(&_addr,&::in6addr_any,sizeof(_addr))==0;
};

WyRet WySockAddrINet6::IPAddr::notation(WyStr& str) const
{
 WyRet r(str._reserve(INET6_ADDRSTRLEN));   // ref. UNP1,p76
 if(::inet_ntop(AF_INET6,&_addr,&str[0],str._capacity())==NULL) {
   WY_RETURN(errno); // no documented errno so far would occur
 }
 if((r=str._setsize(std::strlen(str.data())))!=Ok) {
   WY_RETURN(r);    // this should be an internal error
 }
 return(Ok);
};

void WySockAddrINet6::IPAddr::reset(void) WY__TSPC()
{
 std::memcpy(&_addr,&::in6addr_any,sizeof(_addr));
};

void WySockAddrINet6::IPAddr::reset(const IPAddr& src) WY__TSPC()
{
 std::memcpy(&_addr,&src._addr,sizeof(_addr));
};

void WySockAddrINet6::IPAddr::reset(const InAddrType& src) WY__TSPC()
{
 std::memcpy(&_addr,&src,sizeof(_addr));
};

WyRet WySockAddrINet6::IPAddr::reset(const char* cstr)
{
 WY_RETURN( this->_init(cstr) );
};

WyRet WySockAddrINet6::IPAddr::reset(const WyStr& str)
{
 WY_RETURN( this->_init(str.c_str()) );
};

void WySockAddrINet6::IPAddr::swap(IPAddr& iaddr) WY__TSPC()
{
 Wy__Base::memswp(&_addr,&iaddr._addr,sizeof(_addr));
};

const WySockAddrINet6::IPAddr& WySockAddrINet6::IPAddr::operator =(const IPAddr& rhs) WY__TSPC()
{
 std::memcpy(&_addr,&rhs._addr,sizeof(_addr));
 return(*this);
};

const WySockAddrINet6::IPAddr& WySockAddrINet6::IPAddr::operator =(const InAddrType& rhs) WY__TSPC()
{
 std::memcpy(&_addr,&rhs,sizeof(_addr));
 return(*this);
};

bool WySockAddrINet6::IPAddr::operator ==(const IPAddr& rhs) const WY__TSPC()
{
 return std::memcmp(&_addr,&rhs._addr,sizeof(_addr))==0;
};

bool WySockAddrINet6::IPAddr::operator !=(const IPAddr& rhs) const WY__TSPC()
{
 return std::memcmp(&_addr,&rhs._addr,sizeof(_addr))!=0;
};

bool WySockAddrINet6::IPAddr::operator ==(const InAddrType& rhs) const WY__TSPC()
{
 return std::memcmp(&_addr,&rhs,sizeof(_addr))==0;
};

bool WySockAddrINet6::IPAddr::operator !=(const InAddrType& rhs) const WY__TSPC()
{
 return std::memcmp(&_addr,&rhs,sizeof(_addr))!=0;
};

bool WySockAddrINet6::IPAddr::operator ==(const WyStr& rhs) const
{
 WySockAddrINet6::IPAddr ipaddr;
 if(ipaddr._init(rhs.c_str())!=Ok) {
   return(false);
 }
 return std::memcmp(&_addr,&ipaddr._addr,sizeof(_addr))==0;
};

bool WySockAddrINet6::IPAddr::operator ==(const char* rhs) const
{
 WySockAddrINet6::IPAddr ipaddr;
 if(ipaddr._init(rhs)!=Ok) {
   return(false);
 }
 return std::memcmp(&_addr,&ipaddr._addr,sizeof(_addr))==0;
};

namespace Wy {

WyStr wrd(const WySockAddrINet6::IPAddr& addr)
try {
 WyStr str;
 WyRet r( addr.notation(str) );
 if(r!=Ok) {
   WY_THROW( WySockAddrINet6::IPAddr::Reply(r) );
 }
 return str;
}
catch(const WyStr::Reply& e) {
  throw;
}
catch(const WySockAddrINet6::IPAddr::Reply& e) {
  throw;
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

WyStr wrd(const WySockAddrINet6& addr)
try {
 WyStr str;
 WyRet r( addr.notation(str) );
 if(r!=Ok) {
   WY_THROW( WySockAddrINet6::Reply(r) );
 }
 return str;
}
catch(const WyStr::Reply& e) {
  throw;
}
catch(const WySockAddrINet6::Reply& e) {
  throw;
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

};

//--------------------------------------------------------
const char WySockAddrINet6::class_name[]="WySockAddrINet6";
const WySockAddrINet6::InAddrType& WySockAddrINet6::DefaultIP=::in6addr_any;

#ifndef NDEBUG
class WySockAddrINet6::Wy_Assert_Check {
  public:
    Wy_Assert_Check() {
      if(DefaultIP!=WySockAddrINet6::IPAddr()) {
        WY_TERMINATE("");
      }
    };
} static const wy__do_not_use_me__;
#endif

void WySockAddrINet6::_init(void) WY__TSPC()
{
 std::memset(&_saddr,0,sizeof(_saddr));
 _saddr.sin6_family=AF_INET6;
 _saddr.sin6_port=DefaultPort;
 _saddr.sin6_flowinfo=DefaultFlowInfo;
 ::memcpy(&_saddr.sin6_addr,&DefaultIP,sizeof(DefaultIP));
 _saddr.sin6_scope_id=DefaultScopeId;
 _slen=DefaultSockLen;
 return;
};

void WySockAddrINet6::_init(const struct ::sockaddr_in6& src) WY__TSPC()
{
 // note: src.sin6_family is ignored
 //
 std::memset(&_saddr,0,sizeof(_saddr));
 _saddr.sin6_family=AF_INET6;
 ::memcpy(&_saddr.sin6_addr,&src.sin6_addr,sizeof(_saddr.sin6_addr));
 _saddr.sin6_port=src.sin6_port;
 _saddr.sin6_flowinfo=src.sin6_flowinfo;
 _saddr.sin6_scope_id=src.sin6_scope_id;
 _slen=sizeof(_saddr);
 return;
};

void WySockAddrINet6::_init(const IPAddr& ip,InPortType port) WY__TSPC()
{
 std::memset(&_saddr,0,sizeof(_saddr));
 _saddr.sin6_family=AF_INET6;
 ::memcpy(&_saddr.sin6_addr,&ip.wy_addr_ref(),sizeof(InAddrType));
 _saddr.sin6_port=htons(port);
 _saddr.sin6_flowinfo=DefaultFlowInfo;
 _saddr.sin6_scope_id=DefaultScopeId;
 _slen=sizeof(_saddr);
 return;
};

void WySockAddrINet6::_init(const WySockAddrINet6 &src) WY__TSPC()
{
#ifdef WY_DEBUG
 if(src._slen>sizeof(_saddr)) {
   WY_TERMINATE("");  // assertion failure
 }
 if(src._saddr.sin6_family!=AF_INET6) {
   WY_TERMINATE("");  // assertion failure
 }
#endif
 // self-ops ok
 _saddr=src._saddr;
 _slen=src._slen;
};

WySockAddrINet6::WySockAddrINet6() WY__TSPC()
{
 this->_init();
};

WySockAddrINet6::WySockAddrINet6(const WySockAddrINet6 &src) WY__TSPC()
{
 this->_init(src);
};

WySockAddrINet6::WySockAddrINet6(const struct ::sockaddr_in6& src) WY__TSPC()
{
 this->_init(src);
};

WySockAddrINet6::WySockAddrINet6(const IPAddr& ip,InPortType port) WY__TSPC()
{
 this->_init(ip,port);
};

WySockAddrINet6::WySockAddrINet6(WySockAddrINet6 &src, Wy::ByMove_t) WY__TSPC()
{
 this->_init(src);
};

bool WySockAddrINet6::is_default(void) const WY__TSPC()
{
 if(_slen!=DefaultSockLen) {
   return(false);
 } 
 if((_saddr.sin6_port!=DefaultPort)||
    (_saddr.sin6_addr!=DefaultIP)) {
   return(false);
 }
 if((_saddr.sin6_flowinfo!=DefaultFlowInfo)||
    (_saddr.sin6_scope_id!=DefaultScopeId)) {
   return(false);
 }
 return(true);
};

WyRet WySockAddrINet6::_swap(Wy_SockAddr& iaddr) WY__TSPC()
{
 if(WY__EQU_TYPEID(*this,iaddr)==false) {
   WY_RETURN(Wym_EBADTYPE);
 }
 WySockAddrINet6* lptr( dynamic_cast<WySockAddrINet6*>(&iaddr) );
 Wy__Base::memswp(&_saddr,&lptr->_saddr,sizeof(_saddr));
 Wy__Base::vswap(_slen,lptr->_slen);
 return(Ok);
};

WySockAddrINet6* WySockAddrINet6::_alloc(WyRet& r) const
try {
 if(WY__EQU_TYPEID(*this,WySockAddrINet6)==false) {
   r=Wym_ENOSYS; WY_HERE(r);        // _alloc not overridden
   return(NULL);
 }
 WySockAddrINet6* p=new(std::nothrow) WySockAddrINet6();
 if(p==NULL) {
   r=Wym_ENOMEM; WY_HERE(r);
 } else {
   r=Ok;
 }
 return(p);
}
catch(const Reply& e) {
 r=e; WY_HERE(r);
 return(NULL);
}
catch(const WyRet& e) {
 WY_THROW( WyRet(e) );
};

WySockAddrINet6::InPortType WySockAddrINet6::port(void) const WY__TSPC()
{
 return ntohs(_saddr.sin6_port);
};

WySockAddrINet6::IPAddr WySockAddrINet6::ip(void) const WY__TSPC()
{
 return IPAddr(_saddr.sin6_addr); 
};

WyRet WySockAddrINet6::notation(WyStr& str) const
{
 // note: doc reply is documented only for Wym_ENOMEM
 WyRet r( this->ip().notation(str) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 if((r=str.append('.'))!=Ok) {
   WY_RETURN(r);
 }
 if((r=Wy::_catstr(str,this->port()))!=Ok) {
   WY_RETURN(r);
 }
 return(Ok);
};

bool WySockAddrINet6::operator==(const WySockAddrINet6 &rhs) const WY__TSPC()
{
#ifdef WY_DEBUG
 if(_slen>DefaultSockLen) {
   WY_TERMINATE("");  // assertion failure
 }
 if((_saddr.sin6_family!=AF_INET6)||(rhs._saddr.sin6_family!=AF_INET6)) {
   WY_TERMINATE("");
 }
#endif
 if(_slen!=rhs._slen) {
   return false;
 }
 if(_saddr.sin6_port!=rhs._saddr.sin6_port) {
   return false;
 }
 if((_saddr.sin6_addr!=rhs._saddr.sin6_addr)) {
   return false;
 }
 if(_saddr.sin6_flowinfo!=rhs._saddr.sin6_flowinfo) {
   return false;
 }
 if(_saddr.sin6_scope_id!=rhs._saddr.sin6_scope_id) {
   return false;
 }
 return(true);
};

bool WySockAddrINet6::operator==(const struct ::sockaddr_in6& rhs) const WY__TSPC()
{
 // note: src.sin6_family is ignored
 //
#ifdef WY_DEBUG
 if(_slen>DefaultSockLen) {
   WY_TERMINATE("");  // assertion failure
 }
 if(_saddr.sin6_family!=AF_INET6) {
   WY_TERMINATE("");
 }
#endif
 if(_slen!=sizeof(_saddr)) {
   return false;
 }
 if(_saddr.sin6_port!=rhs.sin6_port) {
   return false;
 }
 if((_saddr.sin6_addr!=rhs.sin6_addr)) {
   return false;
 }
 if(_saddr.sin6_flowinfo!=rhs.sin6_flowinfo) {
   return false;
 }
 if(_saddr.sin6_scope_id!=rhs.sin6_scope_id) {
   return false;
 }
 return(true);
};