socket.cpp

#include "socket.h"

namespace n2nc {
namespace net {

Socket::Socket(int af,int type){
  this->m_af = af ;
  this->m_type = type ;
  this->m_fd = ::socket(af,type,0);
  if (this->m_fd == -1){
    N2NC_PRINT("socket()_error: %s\n",strerror(errno) );
  }
  this->m_buf_dirty = malloc(65535);
}


/* used by TCP socket Accept */
Socket::Socket(){
  this->m_buf_dirty = malloc(65535);
  this->m_fd = -1 ;
}

Socket::~Socket()
{
  std::cerr << "close socket FD: " << this->m_fd << " freeing: " << this->m_buf_dirty << std::endl ;
  ::free(this->m_buf_dirty);
  this->close();
}


int Socket::getAddressFamily(){
  return this->m_af ;
}


int Socket::getFD() const {
  return this->m_fd ;
}

int Socket::setSockOpt(int optname,bool value,int level){
  int val = (value ? 1 : 0 );
  return setsockopt(m_fd,level,optname,&val,sizeof(val));
}

bool Socket::getSockOpt(int optname,int level){
  int val ;
  size_t val_len = sizeof(val);
  return getsockopt(m_fd,level,optname,&val,&val_len);
}

int Socket::bind(SocketAddress &addr){
  this->setSockOpt(SO_REUSEADDR, true, SOL_SOCKET);
  int ret = ::bind(m_fd,addr.getRawSockAddr(),addr.getRawSockAddrLen());
  if (ret == -1){
    N2NC_PRINT("bind_error: %s\n",strerror(errno) );
  }
  return ret ;
}

int Socket::open(SocketAddress &addr){
  int ret = ::connect(this->m_fd,addr.getRawSockAddr(),addr.getRawSockAddrLen());
  if (ret == -1){
    N2NC_PRINT("connect_error: %s\n",strerror(errno) );
  }
  return ret;
}

int Socket::send(void *buf, size_t len){
  int ret = ::send(this->m_fd,buf,len,MSG_NOSIGNAL);
  if (ret == -1){
    N2NC_PRINT("send_error: %s\n",strerror(errno) );
  }
  return ret;
}


size_t Socket::recvCheck(){
  int ret ;
  ret = ::recv(this->m_fd,this->m_buf_dirty,65535,MSG_NOSIGNAL|MSG_DONTWAIT|MSG_PEEK);
  if (ret < 0){
    return 0 ;
  }else{
    return ret ;
  }
}

int Socket::recv(void *buf, size_t len){
  int ret = ::recv(this->m_fd,buf,len,MSG_NOSIGNAL);
  if (ret == -1){
    N2NC_PRINT("recv_error: %s len: %d\n",strerror(errno),len );
  }
  return ret;
}

int Socket::close(){
//   int ret = ::close(this->m_fd);
  int ret = ::shutdown(this->m_fd, SHUT_RDWR);
  ret = ::close(this->m_fd);
  if (ret == -1){
    N2NC_PRINT("close_error: %s\n",strerror(errno) );
  }
  return ret;
}

int n2nc::net::Socket::getType()
{
  return this->m_type ;
}

SocketAddress* Socket::getLocalSocketAddress() const{
    struct sockaddr_storage sa;
    size_t salen ;
    ::bzero(&sa,sizeof(struct sockaddr_storage));
    
    switch(this->m_af){
    case (AF_INET):
      salen = sizeof(struct sockaddr_in);
      break;
  
    case (AF_INET6):
      salen = sizeof(struct sockaddr_in6);
      break;
  
    case (AF_UNIX):
      salen = sizeof(struct sockaddr_un);
      break;
  }
  if (::getsockname(this->m_fd,(struct sockaddr*)&sa,&salen)){
    /* error */
    return NULL ;
  }
  return new SocketAddress((struct sockaddr*)&sa);
}

SocketAddress* Socket::getRemoteSocketAddress() const{
    struct sockaddr_storage sa;
    size_t salen ;
    ::bzero(&sa,sizeof(struct sockaddr_storage));
    
    switch(this->m_af){
    case (AF_INET):
      salen = sizeof(struct sockaddr_in);
      break;
  
    case (AF_INET6):
      salen = sizeof(struct sockaddr_in6);
      break;
  
    case (AF_UNIX):
      salen = sizeof(struct sockaddr_un);
      break;
  }
  if (::getpeername(this->m_fd,(struct sockaddr*)&sa,&salen)){
    /* error */
    std::cerr << "getpeername error __LINE__" << strerror(errno) << this->m_fd << std::endl ;
    return NULL ;
  }
  return new SocketAddress((struct sockaddr*)&sa);
}

bool Socket::isConnected(){

}

}
}

---