src/api/internal/io/TcpSocketEngine_win_p.cpp

   1 // ***************************************************************************
   2 // TcpSocketEngine_win_p.cpp (c) 2011 Derek Barnett
   3 // Marth Lab, Department of Biology, Boston College
   4 // ---------------------------------------------------------------------------
   5 // Last modified: 10 November 2011 (DB)
   6 // ---------------------------------------------------------------------------
   7 // Provides low-level implementation of TCP I/O for all Windows systems
   8 // ***************************************************************************
   9
  10 #include "api/internal/io/TcpSocketEngine_p.h"
  11 #include "api/internal/io/NetWin_p.h"
  12 using namespace BamTools;
  13 using namespace BamTools::Internal;
  14
  15 #include <iostream>
  16 using namespace std;
  17
  18 // ------------------------
  19 // static utility methods
  20 // ------------------------
  21
  22 namespace BamTools {
  23 namespace Internal {
  24
  25 //static inline
  26 //void getPortAndAddress(const sockaddr* s, uint16_t& port, HostAddress& address) {
  27
  28 //    // IPv6
  29 //    if (s->sa_family == AF_INET6) {
  30 //        sockaddr_in6* ip6 = (sockaddr_in6*)s;
  31 //        port = ntohs(ip6->sin6_port);
  32 //        IPv6Address tmp;
  33 //        memcpy(&tmp, &ip6->sin6_addr.in6_addr, sizeof(tmp));
  34 //        address.SetAddress(tmp);
  35 //        return;
  36 //    }
  37
  38 //    // IPv4
  39 //    if ( s->sa_family == AF_INET ) {
  40 //        sockaddr_in* ip4 = (sockaddr_in*)s;
  41 //        port = ntohl(ip4->sin_port);
  42 //        address.SetAddress( ntohl(ip4->sin_addr) );
  43 //        return;
  44 //    }
  45
  46 //    // should be unreachable
  47 //    BT_ASSERT_X(false, "TcpSocketEngine::getPortAndAddress() : unknown network protocol ");
  48 //    return false;
  49 //}
  50
  51 } // namespace Internal
  52 } // namespace BamTools
  53
  54 // --------------------------------
  55 // TcpSocketEngine implementation
  56 // --------------------------------
  57
  58 void TcpSocketEngine::nativeClose(void) {
  59
  60 //    close(m_socketDescriptor);
  61 }
  62
  63 bool TcpSocketEngine::nativeConnect(const HostAddress& address, const uint16_t port) {
  64
  65     // setup connection parameters from address/port
  66 //    sockaddr_in  sockAddrIPv4;
  67 //    sockaddr_in6 sockAddrIPv6;
  68 //    sockaddr*    sockAddrPtr  = 0;
  69 //    BT_SOCKLEN_T sockAddrSize = 0;
  70
  71 //    // IPv6
  72 //    if ( address.GetProtocol() == HostAddress::IPv6Protocol ) {
  73
  74 //        memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));
  75 //        sockAddrIPv6.sin6_family = AF_INET6;
  76 //        sockAddrIPv6.sin6_port   = htons(port);
  77
  78 //        IPv6Address ip6 = address.GetIPv6Address();
  79 //        memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &ip6, sizeof(ip6));
  80
  81 //        sockAddrSize = sizeof(sockAddrIPv6);
  82 //        sockAddrPtr  = (sockaddr*)&sockAddrIPv6;
  83 //    }
  84
  85 //    // IPv4
  86 //    else if ( address.GetProtocol() == HostAddress::IPv4Protocol ) {
  87
  88 //        memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));
  89 //        sockAddrIPv4.sin_family      = AF_INET;
  90 //        sockAddrIPv4.sin_port        = htons(port);
  91 //        sockAddrIPv4.sin_addr.s_addr = htonl(address.GetIPv4Address());
  92
  93 //        sockAddrSize = sizeof(sockAddrIPv4);
  94 //        sockAddrPtr  = (sockaddr*)&sockAddrIPv4;
  95 //    }
  96
  97 //    // unknown (should be unreachable)
  98 //    else BT_ASSERT_X(false, "TcpSocketEngine::nativeConnect() : unknown network protocol");
  99
 100 //    // attempt conenction
 101 //    int connectResult = connect(socketDescriptor, sockAddrPtr, sockAddrSize);
 102
 103 //    // if hit error
 104 //    if ( connectResult == -1 ) {
 105
 106 //        // see what error was encountered
 107 //        switch ( errno ) {
 108
 109 //            case EISCONN:
 110 //                m_socketState = TcpSocket::ConnectedState;
 111 //                break;
 112 //            case ECONNREFUSED:
 113 //            case EINVAL:
 114 //                m_socketError = TcpSocket::ConnectionRefusedError;
 115 //                m_socketState = TcpSocket::UnconnectedState;
 116 //                m_errorString = "connection refused";
 117 //                break;
 118 //            case ETIMEDOUT:
 119 //                m_socketError = TcpSocket::NetworkError;
 120 //                m_errorString = "connection timed out";
 121 //                break;
 122 //            case EHOSTUNREACH:
 123 //                m_socketError = TcpSocket::NetworkError;
 124 //                m_socketState = TcpSocket::UnconnectedState;
 125 //                m_errorString = "host unreachable";
 126 //                break;
 127 //            case ENETUNREACH:
 128 //                m_socketError = TcpSocket::NetworkError;
 129 //                m_socketState = TcpSocket::UnconnectedState;
 130 //                m_errorString = "network unreachable";
 131 //                break;
 132 //            case EADDRINUSE:
 133 //                m_socketError = TcpSocket::NetworkError;
 134 //                m_errorString = "address already in use";
 135 //                break;
 136 //            case EACCES:
 137 //            case EPERM:
 138 //                m_socketError = TcpSocket::SocketAccessError;
 139 //                m_socketState = TcpSocket::UnconnectedState;
 140 //                m_errorString = "permission denied";
 141 //            case EAFNOSUPPORT:
 142 //            case EBADF:
 143 //            case EFAULT:
 144 //            case ENOTSOCK:
 145 //                m_socketState = TcpSocket::UnconnectedState;
 146 //            default:
 147 //                break;
 148 //        }
 149
 150 //        if ( m_socketState != TcpSocket::ConnectedState )
 151 //            return false;
 152 //    }
 153
 154 //    // otherwise, we should be good
 155 //    // update state & return success
 156 //    m_socketState = TcpSocket::ConnectedState;
 157 //    return true;
 158 }
 159
 160 bool TcpSocketEngine::nativeCreateSocket(HostAddress::NetworkProtocol protocol) {
 161
 162 //    // get protocol value for requested protocol type
 163 //    const int protocolNum = ( (protocol == HostAddress::IPv6Protocol) ? AF_INET6 : AF_INET );
 164
 165 //    // attempt to create socket
 166 //    int socketFd = socket(protocolNum, SOCK_STREAM, IPPROTO_TCP);
 167
 168 //    // if we fetched an invalid socket descriptor
 169 //    if ( socketFd <= 0 ) {
 170
 171 //        // see what error we got
 172 //        switch ( errno ) {
 173 //            case EPROTONOSUPPORT:
 174 //            case EAFNOSUPPORT:
 175 //            case EINVAL:
 176 //                m_socketError = TcpSocket::UnsupportedSocketOperationError;
 177 //                m_errorString = "protocol not supported";
 178 //                break;
 179 //            case ENFILE:
 180 //            case EMFILE:
 181 //            case ENOBUFS:
 182 //            case ENOMEM:
 183 //                m_socketError = TcpSocket::SocketResourceError;
 184 //                m_errorString = "out of resources";
 185 //                break;
 186 //            case EACCES:
 187 //                m_socketError = TcpSocket::SocketAccessError;
 188 //                m_errorString = "permission denied";
 189 //                break;
 190 //            default:
 191 //                break;
 192 //        }
 193
 194 //        // return failure
 195 //        return false;
 196 //    }
 197
 198 //    // otherwise, store our socket FD & return success
 199 //    m_socketDescriptor = socketFd;
 200 //    return true;
 201 }
 202
 203 //bool TcpSocketEngine::nativeFetchConnectionParameters(void) {
 204
 205 //    // reset addresses/ports
 206 //    m_localAddress.Clear();
 207 //    m_remoteAddress.Clear();
 208 //    m_localPort  = 0;
 209 //    m_remotePort = 0;
 210
 211 //    // skip (return failure) if invalid socket FD
 212 //    if ( m_socketDescriptor == -1 )
 213 //        return false;
 214
 215 //    sockaddr sa;
 216 //    BT_SOCKLEN_T sockAddrSize = sizeof(sa);
 217
 218 //    // fetch local address info
 219 //    memset(&sa, 0, sizeof(sa));
 220 //    if ( getsockname(m_socketDescriptor, &sa, &sockAddrSize) == 0 ) {
 221 //        getPortAndAddress(&sa, m_localPort, m_localAddress);
 222 //    }
 223 //    else if ( errno == EBADF ) {
 224 //        m_socketError = TcpSocket::UnsupportedSocketOperationError;
 225 //        m_errorString = "invalid socket descriptor";
 226 //        return false;
 227 //    }
 228
 229 //    // fetch remote address
 230 //    if ( getpeername(m_socketDescriptor, &sa, &sockAddrSize) == 0 )
 231 //        getPortAndAddress(&sa, m_remotePort, m_remoteAddress);
 232
 233 //    // return success
 234 //    return true;
 235 //}
 236
 237 size_t TcpSocketEngine::nativeNumBytesAvailable(void) const {
 238
 239 //    // fetch number of bytes, return 0 on error
 240 //    int numBytes(0);
 241 //    if ( ioctl(m_socketDescriptor, FIONREAD, (char*)&numBytes) < 0 )
 242 //        return 0;
 243 //    return static_cast<size_t>(numBytes);
 244 }
 245
 246 int64_t TcpSocketEngine::nativeRead(char* dest, size_t max) {
 247
 248 //    if ( !IsValid() )
 249 //        return -1;
 250
 251 //    ssize_t ret = read(m_socketDescriptor, dest, max);
 252 //    if ( ret < 0 ) {
 253 //        ret = -1;
 254 //        switch ( errno ) {
 255 //            case EAGAIN :
 256 //                // No data was available for reading
 257 //                ret = -2;
 258 //                break;
 259 //            case ECONNRESET :
 260 //                ret = 0;
 261 //                break;
 262 //            default:
 263 //                break;
 264 //        }
 265 //    }
 266
 267 //    return static_cast<int64_t>(ret);
 268 }
 269
 270 // negative value for msecs will block (forever) until
 271 int TcpSocketEngine::nativeSelect(int msecs, bool isRead) const {
 272
 273 //    // set up FD set
 274 //    fd_set fds;
 275 //    FD_ZERO(&fds);
 276 //    FD_SET(m_socketDescriptor, &fds);
 277
 278 //    // setup our timeout
 279 //    timeval tv;
 280 //    tv.tv_sec  = msecs / 1000;
 281 //    tv.tv_usec = (msecs % 1000) * 1000;
 282
 283 //    // do 'select'
 284 //    int ret;
 285 //    if ( isRead )
 286 //        ret = select(m_socketDescriptor + 1, &fds, 0, 0, (msecs < 0 ? 0 : &tv));
 287 //    else
 288 //        ret = select(m_socketDescriptor + 1, 0, &fds, 0, (msecs < 0 ? 0 : &tv));
 289 //    return ret;
 290 }
 291
 292 int64_t TcpSocketEngine::nativeWrite(const char* data, size_t length) {
 293
 294 //    ssize_t writtenBytes = write(m_socketDescriptor, data, length);
 295 //    if ( writtenBytes < 0 ) {
 296 //        switch (errno) {
 297 //            case EPIPE:
 298 //            case ECONNRESET:
 299 //                writtenBytes = -1;
 300 //                m_socketError = TcpSocket::RemoteHostClosedError;
 301 //                m_errorString = "remote host closed connection";
 302 //                Close();
 303 //                break;
 304 //            case EAGAIN:
 305 //                writtenBytes = 0;
 306 //                break;
 307 //            default:
 308 //                break;
 309 //        }
 310 //    }
 311
 312 //    return static_cast<int64_t>(writtenBytes);
 313 }