wysockaddrinet4.cpp

一个不错

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

   Refer: ip(7) tcp(7)
*/

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

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

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

WySockAddrINet4::IPAddr::IPAddr() WY__TSPC()
{
 _addr.s_addr=DefaultIP;
};

WySockAddrINet4::IPAddr::IPAddr(const IPAddr& src) WY__TSPC()
{
 // self-op ok
 _addr.s_addr=src._addr.s_addr;
};

WySockAddrINet4::IPAddr::IPAddr(const InAddrType& src) WY__TSPC()
{
 // self-op ok
 _addr.s_addr=src.s_addr;
};

WySockAddrINet4::IPAddr::IPAddr(::in_addr_t ip) WY__TSPC()
{
 _addr.s_addr=htonl(ip);
};

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

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

WySockAddrINet4::IPAddr::IPAddr(IPAddr& src, Wy::ByMove_t) WY__TSPC()
{
 // self-op ok
 _addr.s_addr=src._addr.s_addr;
};

bool WySockAddrINet4::IPAddr::is_default(void) const WY__TSPC()
{
 return( _addr.s_addr==DefaultIP);
};

WyRet WySockAddrINet4::IPAddr::notation(WyStr& str) const
{
 WyRet r(str._reserve(INET_ADDRSTRLEN)); // ref. UNP1,p76
 if(::inet_ntop(AF_INET,&_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);
 }
 return(Ok);
};

void WySockAddrINet4::IPAddr::reset(void) WY__TSPC()
{
 _addr.s_addr=DefaultIP;
};

void WySockAddrINet4::IPAddr::reset(const IPAddr& src) WY__TSPC()
{
 _addr.s_addr=src._addr.s_addr;
};

void WySockAddrINet4::IPAddr::reset(const InAddrType& src) WY__TSPC()
{
 _addr.s_addr=src.s_addr;
};

void WySockAddrINet4::IPAddr::reset(::in_addr_t ip) WY__TSPC()
{
 _addr.s_addr=htonl(ip);
};

WyRet WySockAddrINet4::IPAddr::reset(const char* cstr)
{
 const WyRet r( this->_init(cstr) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 return(Ok);
};

WyRet WySockAddrINet4::IPAddr::reset(const WyStr& str)
{
 const WyRet r( this->_init(str.c_str()) );
 if(r!=Ok) {
   WY_RETURN(r);
 }
 return(Ok);
};

void WySockAddrINet4::IPAddr::swap(IPAddr& iaddr) WY__TSPC()
{
 Wy__Base::vswap(_addr.s_addr,iaddr._addr.s_addr);
};

const WySockAddrINet4::IPAddr& WySockAddrINet4::IPAddr::operator =(const IPAddr& rhs) WY__TSPC()
{
 _addr=rhs._addr;
 return(*this);
};

bool WySockAddrINet4::IPAddr::operator ==(const IPAddr& rhs) const WY__TSPC()
{
 return _addr.s_addr==rhs._addr.s_addr;
};

bool WySockAddrINet4::IPAddr::operator ==(const InAddrType& rhs) const WY__TSPC()
{
 return _addr.s_addr==rhs.s_addr;
};

bool WySockAddrINet4::IPAddr::operator ==(::in_addr_t rhs) const WY__TSPC()
{
 return _addr.s_addr==htonl(rhs); 
};

bool WySockAddrINet4::IPAddr::operator ==(const WyStr& rhs) const
{
 WySockAddrINet4::IPAddr ipaddr;
 if(ipaddr._init(rhs.c_str())!=Ok) {
   return(false);
 }
 return _addr.s_addr==ipaddr._addr.s_addr;
};

bool WySockAddrINet4::IPAddr::operator ==(const char* rhs) const
{
 WySockAddrINet4::IPAddr ipaddr;
 if(ipaddr._init(rhs)!=Ok) {
   return(false);
 }
 return _addr.s_addr==ipaddr._addr.s_addr;
};

namespace Wy {

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

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

};

//-----------------------------------------------------------
const char WySockAddrINet4::class_name[]="WySockAddrINet4";

#ifndef NDEBUG
class WySockAddrINet4::Wy_Assert_Check {
  public:
    Wy_Assert_Check() {
      if(DefaultSockLen!=sizeof(struct ::sockaddr_in)) {
        WY_TERMINATE("");
      }
    };
} static const wy__do_not_use_me__;
#endif

void WySockAddrINet4::_init(void) WY__TSPC()
{
 std::memset(&_saddr,0,sizeof(_saddr));
 _saddr.sin_family=AF_INET;
 _saddr.sin_addr.s_addr=DefaultIP;
 _saddr.sin_port=DefaultPort;
 _slen=DefaultSockLen;
 return;
};

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

void WySockAddrINet4::_init(const struct ::sockaddr_in& src) WY__TSPC()
{
 // note: ::sockaddr_in.sin_family is ignored
 //
 _saddr=src;
 _slen=sizeof(_saddr);
 _saddr.sin_family=AF_INET;  // overwrite
};

void WySockAddrINet4::_init(const IPAddr& ip,InPortType port) WY__TSPC()
{
 std::memset(&_saddr,0,sizeof(_saddr));
 _saddr.sin_family=AF_INET;
 _saddr.sin_addr.s_addr=ip.c_addr().s_addr;
 _saddr.sin_port=htons(port);
 _slen=sizeof(_saddr);
};

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

WySockAddrINet4::WySockAddrINet4(const WySockAddrINet4 &src) WY__TSPC()
{
 this->_init(src);
#ifdef WY_DEBUG
 if(_slen>sizeof(_saddr)) {
   WY_TERMINATE("");  // assertion failure
 }
 if(_saddr.sin_family!=AF_INET) {
   WY_TERMINATE("");
 }
#endif
};

WySockAddrINet4::WySockAddrINet4(const struct ::sockaddr_in& saddr) WY__TSPC()
{
 this->_init(saddr);
};

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

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

 src._slen=0;    // for safety and error detection
};

bool WySockAddrINet4::is_default(void) const WY__TSPC()
{
 if((_slen!=DefaultSockLen)||
    (_saddr.sin_port!=DefaultPort)||
    (_saddr.sin_addr.s_addr!=DefaultIP)) {
   return(false);
 }
 return(true);
};

WySockAddrINet4::IPAddr WySockAddrINet4::ip(void) const WY__TSPC()
{
 return(_saddr.sin_addr); 
};

WySockAddrINet4::InPortType WySockAddrINet4::port(void) const WY__TSPC()
{
 return ntohs(_saddr.sin_port);
};
    
WyRet WySockAddrINet4::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);
};

void WySockAddrINet4::reset(void) WY__TSPC()
{
 this->_init();
};

void WySockAddrINet4::reset(const WySockAddrINet4 &src) WY__TSPC()
{
 this->_init(src); 
};

void WySockAddrINet4::reset(const struct ::sockaddr_in& saddr) WY__TSPC()
{
 this->_init(saddr); 
};

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

const WySockAddrINet4& WySockAddrINet4::operator=(const WySockAddrINet4 &rhs) WY__TSPC()
{
 this->_init(rhs); 
 return(*this); 
};

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

WySockAddrINet4* WySockAddrINet4::_alloc(WyRet& r) const
try {
 if(WY__EQU_TYPEID(*this,WySockAddrINet4)==false) {
   r=Wym_ENOSYS; WY_HERE(r);        // _alloc not overridden
   return(NULL);
 }
 WySockAddrINet4* p=new(std::nothrow) WySockAddrINet4();
 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) );
};

bool WySockAddrINet4::operator==(const WySockAddrINet4 &rhs) const WY__TSPC()
{
#ifdef WY_DEBUG
 if(_slen>sizeof(_saddr)) {
   WY_TERMINATE("");  // assertion failure
 }
 if(_saddr.sin_family!=rhs._saddr.sin_family) {
   WY_TERMINATE("");
 }
#endif
 if(_slen!=rhs._slen) {
   return false;
 }
 if(_saddr.sin_port!=rhs._saddr.sin_port) {
   return false;
 }
 return(_saddr.sin_addr.s_addr==rhs._saddr.sin_addr.s_addr);
};