/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/net/base_socket

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_base_socket
#define inlib_base_socket

#include <string>
#include <vector>
#include <ostream>
#include <sstream>

#include "../typedefs"
#include "../platform"
#include "../file"
#include "../buffer"
#include "../mnmx"

#ifdef WIN32
#include <io.h>
//#include <winsock2.h>
#include <winsock.h>
#ifndef SD_BOTH
#define SD_BOTH 0x02
#endif
#else
#include <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <cstring>
#endif

namespace inlib {
namespace net {

inline std::string serror() {
   std::ostringstream strm;
#ifdef WIN32
   strm << (int)WSAGetLastError();
   return std::string(" error : ")+strm.str()+".";
#else
   strm << (int)errno;
   return std::string(" error : ")+strm.str()
          + " : " +std::string(strerror(errno))+".";
#endif
}

inline bool host_name(std::ostream& a_out,std::string& a_host){
  char s[512];
  if(::gethostname(s,sizeof(s))<0) {
    a_out << "inlib::net::host_name :"
          << " gethostname() :" << serror()
          << std::endl;
    a_host.clear();
    return false;
  }
  a_host = s;
  return true;
}

inline bool set_reuse_addr(std::ostream& a_out,int a_socket) {
  int val = 1;
  if(::setsockopt(a_socket,SOL_SOCKET,
                  SO_REUSEADDR,(char*)&val,sizeof(val))<0) {
    a_out << "inlib::net::set_reuse_addr :"
          << " setsockopt() :" << serror()
          << std::endl;
    return false;
  }
  return true;
}

inline bool set_input_timer(std::ostream& a_out,int a_socket,unsigned int a_micro_secs) {
  struct timeval val;
  val.tv_sec = 0;
  val.tv_usec = a_micro_secs;
  if(::setsockopt(a_socket,SOL_SOCKET,
                  SO_RCVTIMEO,(char*)&val,sizeof(val))<0) {
    a_out << "inlib::base_socket::set_input_timer :"
          << " setsockopt():" << serror()
          << std::endl;
    return false;
  }
  return true;
}

inline bool is_there_input(const std::vector<int>& a_socks,bool& a_is) {
  a_is = false;
  if(a_socks.empty()) return false;
  
  struct timeval timeout;
  timeout.tv_sec = 0;
  timeout.tv_usec = 10; //microsec
  
  fd_set mask;
  FD_ZERO(&mask);
  int nfds = 0;
 {std::vector<int>::const_iterator it;
  for(it=a_socks.begin();it!=a_socks.end();++it) {
    FD_SET(*it,&mask);
    nfds = mx(nfds,*it);
  }}
  nfds++;

  if(::select(nfds,&mask,0,0,&timeout)==(-1)) {
    a_is = false;
    return false;
  }
  
 {std::vector<int>::const_iterator it;
  for(it=a_socks.begin();it!=a_socks.end();++it) {
    if(FD_ISSET(*it,&mask)) {
      a_is = true;
      break;
    }
  }}

  return true;
}

inline bool wait_input(const std::vector<int>& a_socks) {
  if(a_socks.empty()) return false;
  
  fd_set mask;
  FD_ZERO(&mask);
  int nfds = 0;
 {std::vector<int>::const_iterator it;
  for(it=a_socks.begin();it!=a_socks.end();++it) {
    FD_SET(*it,&mask);
    nfds = mx(nfds,*it);
  }}
  nfds++;

  if(::select(nfds,&mask,0,0,0)==(-1)) return false;
  
  return true;
}

class base_socket {
public:
  virtual void disconnect() = 0;
  virtual bool fetch_cbk(inlib::uint64) {return true;}
public:
  base_socket(std::ostream& a_out,bool a_verbose)
  :m_out(a_out)
  ,m_verbose(a_verbose)
  ,m_socket(-1)           
  ,m_is_LE(true)
  { 
    m_is_LE = inlib::is_little_endian();
  }
  virtual ~base_socket(){close();}
protected:
  base_socket(const base_socket& aFrom)
  :m_out(aFrom.m_out)
  ,m_verbose(aFrom.m_verbose)
  ,m_socket(aFrom.m_socket)           
  ,m_is_LE(aFrom.m_is_LE)
  {}
  base_socket& operator=(const base_socket& aFrom){ 
    m_verbose = aFrom.m_verbose;
    m_socket = aFrom.m_socket;
    m_is_LE = aFrom.m_is_LE;
    return *this;
  }
public:
  bool verbose() const {return m_verbose;}
  bool is_connected() const {return (m_socket==(-1)?false:true);}
  int socket() const {return m_socket;}
  std::ostream& out() const {return m_out;}
protected:
  void close(){
    if(m_socket!=(-1)) {
#ifdef WIN32
      if(::shutdown(m_socket,SD_BOTH)<0) { 
        if(WSAGetLastError()==WSAENOTCONN) {
#else
      if(::shutdown(m_socket,SHUT_RDWR)<0) { 
        if(errno==ENOTCONN) { 
#endif
          // ok, the "other side" may have already done a shutdown.
        } else {
          m_out << "inlib::base_socket::close :"
                << " for socket : " << m_socket
                << ", shutdown : " << serror()
                << std::endl;
        }
      } else {
        if(m_verbose) {
          m_out << "inlib::base_socket::close :"
                << " close ok."
                << " Socket was " << m_socket << "."
                << std::endl;
        }
      }
      ::close(m_socket);
      m_socket = -1;
    }
  }
public:
  bool send_buffer(const char* a_buffer,inlib::uint64 a_length,inlib::uint64 a_BLOCK = 65536) {
    if(!a_length) return true;
    if(m_socket==(-1)) return false;
    char* buf = (char*)a_buffer;
    inlib::uint64 sent = 0;
    while(true) {
      inlib::uint64 to_send = mn(a_BLOCK,a_length-sent);
      if(!to_send) break;    
#ifdef WIN32
      int
#else
      ssize_t
#endif
      num_char = ::send(m_socket,(char*)buf,(size_t)to_send,0);
      if(num_char<0) {
        m_out << "inlib::base_socket::send_buffer :"
              << " send : " << serror()
              << std::endl;
        disconnect();
        return false;
      }
      if(num_char==0) {
        m_out << "inlib::base_socket::send_buffer :"
              << " send : returned 0."
              << std::endl;
      }
  
      //NOTE : num_char not necessary equal to to_send.
      buf += num_char;
      sent += num_char;
    }  
    return true;
  }

  bool fetch_buffer(char* a_buffer,inlib::uint64 a_length,inlib::uint64 a_BLOCK = 65536){
    if(!a_length) return true;
    if(m_socket==(-1)) return false;
    char* buf = a_buffer;
    inlib::uint64 got = 0;
    while(true) {
      inlib::uint64 to_get = mn(a_BLOCK,a_length-got);
      if(!to_get) break;
#ifdef WIN32
      int
#else
      ssize_t
#endif
      num_char = ::recv(m_socket,buf,(size_t)to_get,0);
      if(num_char<0) {
        //ECONNRESET
        m_out << "inlib::base_socket::fetch_buffer :"
              << " recv : " << serror()
              << std::endl;
        disconnect();
        return false;
      }
      if(num_char==0) {
        m_out << "inlib::base_socket::fetch_buffer :"
              << " recv : returned 0."
              << std::endl;
        return false;      
      }

      //NOTE : num_char not necessary equal to to_get.
      buf += num_char;
      got += num_char;
    }
    return true;
  }

  bool fetch_upto_char(
   char a_char
  ,char*& a_buffer
  ,inlib::uint64& a_length
  ,unsigned int a_BLOCK = 65536){
    a_buffer = 0;
    a_length = 0;    
    if(m_socket==(-1)) return false;
    char* buf = new char[a_BLOCK];
    if(!buf) return false; 
    while(true) {
#ifdef WIN32
      int
#else
      ssize_t
#endif
      num_char = ::recv(m_socket,buf,(size_t)a_BLOCK,0);
      if(num_char<0) {
        m_out << "inlib::base_socket::fetch_upto_char :"
              << " recv : " << serror()
              << std::endl;
        disconnect();
        delete [] buf;    
        delete [] a_buffer;
        a_buffer = 0;
        a_length = 0;    
        return false;
      }
      if(num_char==0) {
        m_out << "inlib::base_socket::fetch_upto_char :"
              << " recv : returned 0."
              << std::endl;
        delete [] buf;    
        delete [] a_buffer;
        a_buffer = 0;
        a_length = 0;    
        return false;      
      }

      if(m_verbose) {
        m_out << "inlib::base_socket::fetch_upto_char :"
              << " recv : " << (int)num_char
             << std::endl;
      }

      if(!a_buffer) {
        a_buffer = new char[num_char];
        if(!a_buffer) {
          delete [] buf;    
          a_length = 0;    
          return false;
        }
        ::memcpy(a_buffer,buf,num_char);
        a_length = num_char;
      } else {
        char* b = new char[(size_t)(a_length+num_char)];
        if(!b) {
          delete [] buf;    
          delete [] a_buffer;
          a_buffer = 0;
          a_length = 0;    
          return false;
        }
        ::memcpy(b,a_buffer,(size_t)a_length);
        ::memcpy(b+a_length,buf,num_char);
        delete [] a_buffer;
        a_buffer = b;
        a_length += num_char;
      }

     {char* pos = buf;    
      for(unsigned int index=0;index<(unsigned int)num_char;index++,pos++) {
        //printf("debug : %d : %d\n",index,*pos);
        if(*pos==a_char) { //found
          // 01234
          //  ^
          a_length -= (num_char-(index+1));
          delete [] buf;
          return true;
        }
      }}
  
      //a_char not in buf, continue.
    }
  }

  bool fetch_upto_end(char*& a_buffer,inlib::uint64& a_length,unsigned int a_BLOCK = 65536){
    a_buffer = 0;
    a_length = 0;    
    if(m_socket==(-1)) return false;

    char* buf = new char[a_BLOCK];
    if(!buf) return false; 
    while(true) {
      //m_out << "inlib::base_socket::fetch_upto_end :"
      //      << " recv... "
      //      << std::endl;
#ifdef WIN32
      int
#else
      ssize_t
#endif
      num_char = ::recv(m_socket,buf,(size_t)a_BLOCK,0);
      if(num_char<0) {
        //if(errno==EAGAIN) continue;
        m_out << "inlib::base_socket::fetch_upto_end :"
              << " recv : " << serror()
              << std::endl;
        disconnect();
        delete [] buf;
        delete [] a_buffer;
        a_buffer = 0;
        a_length = 0;    
        return false;
      }
      if(num_char==0) {
        if(m_verbose) {
          m_out << "inlib::base_socket::fetch_upto_end :"
                << " end."
                << std::endl;
        }
        delete [] buf;
        return true;
      }

      if(m_verbose) {
        m_out << "inlib::base_socket::fetch_upto_end :"
              << " recv : " << (int)num_char
              << std::endl;
      }
  
      if(!a_buffer) {
        a_buffer = new char[num_char];
        if(!a_buffer) {
          delete [] buf;    
          a_length = 0;    
          return false;
        }
        ::memcpy(a_buffer,buf,num_char);
        a_length = num_char;
      } else {
        char* b = new char[(size_t)(a_length+num_char)];
        if(!b) {
          delete [] buf;    
          delete [] a_buffer;
          a_buffer = 0;
          a_length = 0;    
          return false;
        }
        ::memcpy(b,a_buffer,(size_t)a_length);
        ::memcpy(b+a_length,buf,num_char);
        delete [] a_buffer;
        a_buffer = b;
        a_length += num_char;
      }
    }
  }

  bool fetch_upto_end(FILE* a_FILE,inlib::uint64& a_length,unsigned int a_BLOCK = 65536){
    a_length = 0;    
    if(m_socket==(-1)) return false;

    char* buf = new char[a_BLOCK];
    if(!buf) return false; 
    while(true) {
      //m_out << "inlib::base_socket::fetch_upto_end(FILE) :"
      //      << " recv... "
      //      << std::endl;
#ifdef WIN32
      int
#else
      ssize_t
#endif
      num_char = ::recv(m_socket,buf,(size_t)a_BLOCK,0);
      if(num_char<0) {
        //if(errno==EAGAIN) continue;
        m_out << "inlib::base_socket::fetch_upto_end(FILE) :"
              << " recv : " << serror()
              << std::endl;
        disconnect();
        delete [] buf;
        a_length = 0;    
        return false;
      }
      if(num_char==0) {
        if(m_verbose) {
          m_out << "inlib::base_socket::fetch_upto_end(FILE) :"
                << " end."
                << std::endl;
        }
        delete [] buf;
        return true;
      }

      if(m_verbose) {
        m_out << "inlib::base_socket::fetch_upto_end(FILE) :"
              << " recv : " << (int)num_char
              << std::endl;
      }
  
      if(::fwrite((char*)buf,num_char,(size_t)1,a_FILE)!=1) {
        delete [] buf;    
        a_length = 0;    
        return false;
      }
      a_length += num_char;
      if(!fetch_cbk(a_length)) {
        m_out << "inlib::base_socket::fetch_upto_end(FILE) :"
              << " fetch_cbk returns false, stop recv data."
              << std::endl;
        return false;
      }
    }
  }

  template <class T>
  bool send(const T& a_value) {
    char buffer[sizeof(T)];
    inlib::write_buffer<T>(a_value,buffer);
    return send_buffer(buffer,sizeof(T));
  }

  template <class T>
  bool fetch(T& a_value) {
    char buffer[sizeof(T)];
    if(!fetch_buffer(buffer,sizeof(T))) return false;
    inlib::read_buffer<T>(buffer,a_value);
    return true;
  }

  bool send_uchar(unsigned char a_value) {
    char buffer[1];
    ::memcpy(buffer,&a_value,1);
    return send_buffer(buffer,1);
  }

  bool fetch_uchar(unsigned char& a_value) {
    char buffer[1];
    if(!fetch_buffer(buffer,1)) return false;
    ::memcpy(&a_value,buffer,1);
    return true;
  }

  bool send_bool(bool a_value) {
    unsigned char c = a_value?1:0;
    return send_uchar(c);
  }

  bool fetch_bool(bool& a_value) {
    unsigned char c;
    if(!fetch_uchar(c)) {a_value = false;return false;}
    a_value = (c==1?true:false);
    return true;
  }

  bool send_string(const std::string& a_string) {
    if(!send<inlib::uint64>(a_string.size())) return false;
    return send_buffer(a_string.c_str(),a_string.size());
  }

  bool fetch_string(std::string& a_string) {
    inlib::uint64 length;
    if(!fetch<inlib::uint64>(length)) {
      a_string.clear();
      return false;
    }
    a_string.resize((std::string::size_type)length);
    if(!fetch_buffer((char*)a_string.c_str(),length)) {
      a_string.clear();
      return false;
    }
    return true;
  }
  
  bool send_text(const std::vector<std::string>& a_text) { 
    unsigned int number = a_text.size();
    if(!send<inlib::uint64>(number)) return false;
    for(unsigned int index=0;index<number;index++) {
      if(!send_string(a_text[index])) return false;
    }
    return true;
  }

  bool fetch_text(std::vector<std::string>& a_text){ 
    inlib::uint64 number;
    if(!fetch<inlib::uint64>(number)) {
      a_text.clear();
      return false;
    }
    for(unsigned int index=0;index<number;index++) {
      std::string s;
      if(!fetch_string(s)) {
        a_text.clear();
        return false;
      }
      a_text.push_back(s);
    }
    return true;
  }

  bool send_file(const std::string& a_file) {
    char* buffer;
    long length;
    if(!inlib::file::read_bytes(a_file,buffer,length)) {
      m_out << "inlib::base_socket::send_file : "
            << " can't read file \"" << a_file << "\"."
            << std::endl;
      return false;
    }
    if(!send<inlib::uint64>((inlib::uint64)length)) return false;
    bool stat = send_buffer(buffer,length);
    delete [] buffer;
    return stat;
  }

  bool fetch_file(const std::string& a_file) {
    inlib::uint64 length;
    if(!fetch<inlib::uint64>(length)) return false;
    char* buffer = 0;
    if(length) {
      buffer = new char[(size_t)length];
      if(!buffer) return false;
    }
    if(!fetch_buffer(buffer,length)) {
      delete [] buffer;
      return false;
    }
    bool stat = inlib::file::write_bytes(a_file,buffer,(size_t)length);
    if(!stat) {
      m_out << "inlib::base_socket::send_file : "
            << " can't write file \"" << a_file << "\"."
            << std::endl;
    }
    delete [] buffer;
    return stat;
  }

  bool is_there_input(bool& a_is) {
    a_is = false;
    if(m_socket==(-1)) return false;
  
    fd_set mask;
    FD_ZERO(&mask);
    FD_SET(m_socket,&mask);
  
    struct timeval timeout;
    timeout.tv_sec = 0;
    timeout.tv_usec = 10; //microsec
  
    int nfds = 0;
    nfds = mx(nfds,m_socket);
    nfds++;
    if(::select(nfds,&mask,0,0,&timeout)==(-1)) {
      a_is = false;
      return false;
    }
  
    a_is = FD_ISSET(m_socket,&mask)?true:false;
    return true;
  }

protected:        
  std::ostream& m_out;
  bool m_verbose;
  int m_socket;
  bool m_is_LE;
};
  

}}
  
#endif