libicq2000/src/socket.cpp

   1 /*
   2  * TCPSocket class
   3  *
   4  * Copyright (C) 2001 Barnaby Gray <barnaby@beedesign.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
  19  *
  20  */
  21
  22 #include "sstream_fix.h"
  23 #include <algorithm>
  24 #include <string.h>
  25
  26 #include "socket.h"
  27
  28 #include "buffer.h"
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include <config.h>
  32 #endif
  33
  34 #ifdef MSG_NOSIGNAL
  35     #define SEND_FLAGS MSG_NOSIGNAL
  36 #else
  37     #define SEND_FLAGS 0
  38 #endif
  39
  40 using std::string;
  41 using std::ostringstream;
  42 using std::istringstream;
  43 //using std::copy;
  44
  45 namespace ICQ2000
  46 {
  47
  48   // StringtoIP and IPtoString both work on host order ip address expressed as unsigned int's
  49   unsigned int StringtoIP(const string& s) {
  50     istringstream istr(s);
  51     unsigned char d1,d2,d3,d4;
  52     unsigned int b1,b2,b3,b4;
  53     istr >> b1 >> d1 >> b2 >> d2 >> b3 >> d3 >> b4;
  54     if (!istr) return 0;
  55     istr >> d4;
  56     if (istr) return 0;
  57
  58     if (d1 == '.' && d2 == '.' && d3 == '.'
  59         && b1 < 256 && b2 < 256 && b3 < 256 && b4 < 256) {
  60       return (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4 << 0);
  61     } else {
  62       return 0;
  63     }
  64   }
  65
  66   string IPtoString(unsigned int ip) {
  67     ostringstream ostr;
  68     ostr << (ip >> 24) << "."
  69          << ((ip >> 16) & 0xff) << "."
  70          << ((ip >> 8) & 0xff) << "."
  71          << (ip & 0xff);
  72     return ostr.str();
  73   }
  74
  75   TCPSocket::TCPSocket()
  76     : m_socketDescriptor(-1), m_socketDescriptor_valid(false),
  77       blocking(false), m_state(NOT_CONNECTED)
  78   {
  79     memset(&remoteAddr, 0, sizeof(remoteAddr));
  80   }
  81
  82   TCPSocket::TCPSocket( int fd, struct sockaddr_in addr )
  83     : m_socketDescriptor(fd), m_socketDescriptor_valid(true), remoteAddr(addr),
  84       blocking(false), m_state(CONNECTED)
  85   {
  86     socklen_t localLen = sizeof(struct sockaddr_in);
  87     getsockname( m_socketDescriptor, (struct sockaddr *)&localAddr, &localLen );
  88
  89     fcntlSetup();
  90   }
  91
  92   TCPSocket::~TCPSocket() {
  93     Disconnect();
  94   }
  95
  96   extern "C" int cw_connect(int sockfd, const struct sockaddr *serv_addr, int addrlen, int ssl);
  97
  98   void TCPSocket::Connect() {
  99     if (m_state != NOT_CONNECTED) throw SocketException("Already connected");
 100
 101     m_socketDescriptor = socket(AF_INET,SOCK_STREAM,0);
 102     if (m_socketDescriptor == -1) throw SocketException("Couldn't create socket");
 103     m_socketDescriptor_valid = true;
 104     remoteAddr.sin_family = AF_INET;
 105
 106     fcntlSetup();
 107
 108     if (cw_connect(m_socketDescriptor,(struct sockaddr *)&remoteAddr,sizeof(struct sockaddr), 0) == -1) {
 109       if (errno == EINPROGRESS) {
 110         m_state = NONBLOCKING_CONNECT;
 111         return; // non-blocking connect
 112       }
 113
 114       // m_state will still be NOT_CONNECTED
 115       close(m_socketDescriptor);
 116       m_socketDescriptor_valid = false;
 117       throw SocketException("Couldn't connect socket");
 118     }
 119
 120     socklen_t localLen = sizeof(struct sockaddr_in);
 121     getsockname( m_socketDescriptor, (struct sockaddr *)&localAddr, &localLen );
 122
 123     m_state = CONNECTED;
 124   }
 125
 126   void TCPSocket::FinishNonBlockingConnect() {
 127     // this should be called for non blocking connects
 128     // after the socket is writeable
 129     int so_error;
 130     socklen_t optlen = sizeof(so_error);
 131     if (getsockopt(m_socketDescriptor, SOL_SOCKET, SO_ERROR, (char *) &so_error, &optlen) == -1 || so_error != 0) {
 132       m_state = NOT_CONNECTED;
 133       close(m_socketDescriptor);
 134       m_socketDescriptor_valid = false;
 135       throw SocketException("Couldn't connect socket");
 136     }
 137
 138     // success
 139     socklen_t localLen = sizeof(struct sockaddr_in);
 140     getsockname( m_socketDescriptor, (struct sockaddr *)&localAddr, &localLen );
 141
 142     m_state = CONNECTED;
 143   }
 144
 145   void TCPSocket::Disconnect() {
 146
 147     if (m_socketDescriptor_valid) {
 148       close(m_socketDescriptor);
 149       m_socketDescriptor_valid = false;
 150     }
 151
 152     m_state = NOT_CONNECTED;
 153   }
 154
 155   int TCPSocket::getSocketHandle() { return m_socketDescriptor; }
 156
 157   TCPSocket::State TCPSocket::getState() const { return m_state; }
 158
 159   bool TCPSocket::connected() {
 160     return (m_state == CONNECTED);
 161   }
 162
 163   void TCPSocket::setBlocking(bool b) {
 164     blocking = b;
 165     fcntlSetup();
 166   }
 167
 168   bool TCPSocket::isBlocking() const {
 169     return blocking;
 170   }
 171
 172   void TCPSocket::fcntlSetup() {
 173     if (m_socketDescriptor_valid) {
 174       int f = fcntl(m_socketDescriptor, F_GETFL);
 175       if (blocking) fcntl(m_socketDescriptor, F_SETFL, f & ~O_NONBLOCK);
 176       else fcntl(m_socketDescriptor, F_SETFL, f | O_NONBLOCK);
 177     }
 178   }
 179
 180   void TCPSocket::Send(Buffer& b) {
 181     if (!connected()) throw SocketException("Not connected");
 182
 183     int ret;
 184     unsigned int sent = 0;
 185
 186     unsigned char *data = (unsigned char *) malloc(b.size());
 187     copy( b.begin(), b.end(), data );
 188
 189     while (sent < b.size())
 190     {
 191       ret = send(m_socketDescriptor, (char *) (data + sent), b.size() - sent, SEND_FLAGS);
 192       if (ret == -1) {
 193         m_state = NOT_CONNECTED;
 194         close(m_socketDescriptor);
 195         m_socketDescriptor_valid = false;
 196         free(data);
 197         throw SocketException("Sending on socket");
 198       }
 199
 200       sent += ret;
 201     }
 202     free(data);
 203   }
 204
 205   bool TCPSocket::Recv(Buffer& b) {
 206     if (!connected()) throw SocketException("Not connected");
 207
 208     unsigned char buffer[max_receive_size];
 209
 210     int ret = recv(m_socketDescriptor, (char *) buffer, max_receive_size, 0);
 211
 212     if (ret <= 0) {
 213       if (ret == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return false;
 214
 215       m_state = NOT_CONNECTED;
 216       close(m_socketDescriptor);
 217       m_socketDescriptor_valid = false;
 218
 219       if (ret == 0) throw SocketException( "Other end closed connection" );
 220       else throw SocketException( strerror(errno) );
 221     }
 222
 223     b.Pack(buffer,ret);
 224     return true;
 225   }
 226
 227   void TCPSocket::setBindHost(const char *host) {
 228     memset(&localAddr, 0, sizeof(localAddr));
 229     if(strlen(host)) {
 230       localAddr.sin_addr.s_addr = gethostname(host);
 231       localAddr.sin_port = 0;
 232     }
 233   }
 234
 235   void TCPSocket::setRemoteHost(const char *host) {
 236     remoteAddr.sin_addr.s_addr = gethostname(host);
 237   }
 238
 239   void TCPSocket::setRemotePort(unsigned short port) {
 240     remoteAddr.sin_port = htons(port);
 241   }
 242
 243   void TCPSocket::setRemoteIP(unsigned int ip) {
 244     remoteAddr.sin_addr.s_addr = htonl(ip);
 245   }
 246
 247   unsigned short TCPSocket::getRemotePort() const {
 248     return ntohs( remoteAddr.sin_port );
 249   }
 250
 251   unsigned int TCPSocket::getRemoteIP() const {
 252     return ntohl( remoteAddr.sin_addr.s_addr );
 253   }
 254
 255   unsigned short TCPSocket::getLocalPort() const {
 256     return ntohs( localAddr.sin_port );
 257   }
 258
 259   unsigned int TCPSocket::getLocalIP() const {
 260     return ntohl( localAddr.sin_addr.s_addr );
 261   }
 262
 263
 264   // returns ip address of host in network byte order
 265
 266   unsigned long TCPSocket::gethostname(const char *hostname) {
 267
 268     unsigned int ip = htonl( StringtoIP(hostname) );
 269     if (ip != 0) return ip;
 270
 271
 272     // try and resolve hostname
 273     struct hostent *hostEnt;
 274     if ((hostEnt = gethostbyname(hostname)) == NULL || hostEnt->h_addrtype != AF_INET) {
 275       throw SocketException("DNS lookup failed");
 276     } else {
 277       return *((unsigned long *)(hostEnt->h_addr));
 278     }
 279   }
 280
 281   /**
 282    * TCPServer class
 283    */
 284   TCPServer::TCPServer()
 285     : m_socketDescriptor_valid(false)
 286   { }
 287
 288   TCPServer::~TCPServer() {
 289     Disconnect();
 290   }
 291
 292   void TCPServer::StartServer() {
 293     StartServer(0, 0);
 294   }
 295
 296   void TCPServer::StartServer(unsigned short lower, unsigned short upper) {
 297     if (m_socketDescriptor_valid) throw SocketException("Already listening");
 298
 299     m_socketDescriptor = socket( AF_INET, SOCK_STREAM, 0 );
 300     if (m_socketDescriptor < 0) throw SocketException("Couldn't create socket");
 301     m_socketDescriptor_valid = true;
 302
 303     localAddr.sin_family = AF_INET;
 304     localAddr.sin_addr.s_addr = INADDR_ANY;
 305
 306     bool bound = false;
 307     if (lower && upper) {
 308       unsigned short port;
 309       // attempt to bind to a port within the range
 310       for (port=lower;port<=upper;port++) {
 311         localAddr.sin_port = htons(port);
 312         if ( bind( m_socketDescriptor,(struct sockaddr *)&localAddr,sizeof(struct sockaddr) ) >= 0 ) {
 313           bound = true;
 314           break;
 315         }
 316
 317       }
 318     }
 319
 320     if (!bound) {
 321       // bind to a random port
 322       localAddr.sin_port = 0;
 323       if ( bind( m_socketDescriptor,(struct sockaddr *)&localAddr,sizeof(struct sockaddr) ) < 0 )
 324         throw SocketException("Couldn't bind socket");
 325     }
 326
 327     listen( m_socketDescriptor, 5 );
 328     // queue size of 5 should be sufficient
 329
 330     socklen_t localLen = sizeof(struct sockaddr_in);
 331     getsockname( m_socketDescriptor, (struct sockaddr *)&localAddr, &localLen );
 332   }
 333
 334   unsigned short TCPServer::getPort() const {
 335     return ntohs( localAddr.sin_port );
 336   }
 337
 338   unsigned int TCPServer::getIP() const {
 339     return ntohl( localAddr.sin_addr.s_addr );
 340   }
 341
 342   TCPSocket* TCPServer::Accept() {
 343     int newsockfd;
 344     socklen_t remoteLen;
 345     struct sockaddr_in remoteAddr;
 346
 347     if (!m_socketDescriptor_valid) throw SocketException("Not connected");
 348
 349     remoteLen = sizeof(remoteAddr);
 350     newsockfd = accept( m_socketDescriptor,
 351                         (struct sockaddr *) &remoteAddr,
 352                         &remoteLen );
 353     if (newsockfd < 0) {
 354       close(m_socketDescriptor);
 355       m_socketDescriptor_valid = false;
 356       throw SocketException("Error on accept");
 357     }
 358
 359     return new TCPSocket( newsockfd, remoteAddr );
 360   }
 361
 362   int TCPServer::getSocketHandle() { return m_socketDescriptor; }
 363
 364   void TCPServer::Disconnect() {
 365     if (m_socketDescriptor_valid) {
 366       close(m_socketDescriptor);
 367       m_socketDescriptor = 0;
 368       m_socketDescriptor_valid = false;
 369     }
 370   }
 371
 372   bool TCPServer::isStarted() const { return m_socketDescriptor_valid; }
 373
 374   void TCPServer::setBindHost(const char *host) {
 375     memset(&localAddr, 0, sizeof(localAddr));
 376     if(strlen(host)) {
 377       localAddr.sin_addr.s_addr = TCPSocket::gethostname(host);
 378       localAddr.sin_port = 0;
 379     }
 380   }
 381
 382   /**
 383    * SocketException class
 384    */
 385   SocketException::SocketException(const string& text) : m_errortext(text) { }
 386
 387   const char* SocketException::what() const throw() {
 388     return m_errortext.c_str();
 389   }
 390
 391 }