src/PracticalSocket.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007-2008 Othmar Gsenger, Erwin Nindl,
  15  *                          Christian Pointner <satp@wirdorange.org>
  16  *
  17  *  This file is part of Anytun.
  18  *
  19  *  Anytun is free software: you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License version 3 as
  21  *  published by the Free Software Foundation.
  22  *
  23  *  Anytun is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
  30  */
  31
  32 #include "datatypes.h"
  33
  34 // this is from: http://cs.ecs.baylor.edu/~donahoo/practical/CSockets/practical/
  35 // and this is their header:
  36 /*
  37  *   C++ sockets on Unix and Windows
  38  *   Copyright (C) 2002
  39  *
  40  *   This program is free software; you can redistribute it and/or modify
  41  *   it under the terms of the GNU General Public License as published by
  42  *   the Free Software Foundation; either version 2 of the License, or
  43  *   (at your option) any later version.
  44  *
  45  *   This program is distributed in the hope that it will be useful,
  46  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  47  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  48  *   GNU General Public License for more details.
  49  *
  50  *   You should have received a copy of the GNU General Public License
  51  *   along with this program; if not, write to the Free Software
  52  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  53  */
  54
  55 #include "PracticalSocket.h"
  56
  57 #ifdef WIN32
  58   #include <winsock.h>         // For socket(), connect(), send(), and recv()
  59   typedef int socklen_t;
  60   typedef char raw_type;       // Type used for raw data on this platform
  61 #else
  62   #include <sys/types.h>       // For data types
  63   #include <sys/socket.h>      // For socket(), connect(), send(), and recv()
  64   #include <netdb.h>           // For gethostbyname()
  65   #include <arpa/inet.h>       // For inet_addr()
  66   #include <unistd.h>          // For close()
  67   #include <netinet/in.h>      // For sockaddr_in
  68   #include <poll.h>
  69   typedef void raw_type;       // Type used for raw data on this platform
  70 #endif
  71
  72 #include <errno.h>             // For errno
  73
  74 using namespace std;
  75
  76 #ifdef WIN32
  77 static bool initialized = false;
  78 #endif
  79
  80 // SocketException Code
  81
  82 SocketException::SocketException(const string &message, bool inclSysMsg)
  83   throw() : userMessage(message) {
  84   if (inclSysMsg) {
  85     userMessage.append(": ");
  86     char buf[STERROR_TEXT_MAX];
  87     buf[0] = 0;
  88     strerror_r(errno, buf, STERROR_TEXT_MAX);
  89     userMessage.append(buf);
  90   }
  91 }
  92
  93 SocketException::~SocketException() throw() {
  94 }
  95
  96 const char *SocketException::what() const throw() {
  97   return userMessage.c_str();
  98 }
  99
 100 // Function to fill in address structure given an address and port
 101 static void fillAddr(const string &address, unsigned short port,
 102                      sockaddr_in &addr) {
 103   memset(&addr, 0, sizeof(addr));  // Zero out address structure
 104   addr.sin_family = AF_INET;       // Internet address
 105
 106   hostent *host;  // Resolve name
 107   if ((host = gethostbyname(address.c_str())) == NULL) {
 108     // strerror() will not work for gethostbyname() and hstrerror()
 109     // is supposedly obsolete
 110     throw SocketException("Failed to resolve name (gethostbyname())");
 111   }
 112   addr.sin_addr.s_addr = *((unsigned long *) host->h_addr_list[0]);
 113
 114   addr.sin_port = htons(port);     // Assign port in network byte order
 115 }
 116
 117 // Socket Code
 118
 119 Socket::Socket(int type, int protocol) throw(SocketException) {
 120   #ifdef WIN32
 121     if (!initialized) {
 122       WORD wVersionRequested;
 123       WSADATA wsaData;
 124
 125       wVersionRequested = MAKEWORD(2, 0);              // Request WinSock v2.0
 126       if (WSAStartup(wVersionRequested, &wsaData) != 0) {  // Load WinSock DLL
 127         throw SocketException("Unable to load WinSock DLL");
 128       }
 129       initialized = true;
 130     }
 131   #endif
 132
 133   // Make a new socket
 134   if ((sockDesc = socket(PF_INET, type, protocol)) < 0) {
 135     throw SocketException("Socket creation failed (socket())", true);
 136   }
 137 }
 138
 139 Socket::Socket(int sockDesc) {
 140   this->sockDesc = sockDesc;
 141 }
 142
 143 Socket::~Socket() {
 144   #ifdef WIN32
 145     ::closesocket(sockDesc);
 146   #else
 147     ::close(sockDesc);
 148   #endif
 149   sockDesc = -1;
 150 }
 151
 152 string Socket::getLocalAddress() throw(SocketException) {
 153   sockaddr_in addr;
 154   unsigned int addr_len = sizeof(addr);
 155
 156   if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
 157     throw SocketException("Fetch of local address failed (getsockname())", true);
 158   }
 159   return inet_ntoa(addr.sin_addr);
 160 }
 161
 162 unsigned short Socket::getLocalPort() throw(SocketException) {
 163   sockaddr_in addr;
 164   unsigned int addr_len = sizeof(addr);
 165
 166   if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
 167     throw SocketException("Fetch of local port failed (getsockname())", true);
 168   }
 169   return ntohs(addr.sin_port);
 170 }
 171
 172 void Socket::setLocalPort(unsigned short localPort) throw(SocketException) {
 173   // Bind the socket to its port
 174   sockaddr_in localAddr;
 175   memset(&localAddr, 0, sizeof(localAddr));
 176   localAddr.sin_family = AF_INET;
 177   localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 178   localAddr.sin_port = htons(localPort);
 179
 180   if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
 181     throw SocketException("Set of local port failed (bind())", true);
 182   }
 183 }
 184
 185 void Socket::setLocalAddressAndPort(const string &localAddress,
 186     unsigned short localPort) throw(SocketException) {
 187   // Get the address of the requested host
 188   sockaddr_in localAddr;
 189   fillAddr(localAddress, localPort, localAddr);
 190
 191   if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
 192     throw SocketException("Set of local address and port failed (bind())", true);
 193   }
 194 }
 195
 196 void Socket::setSocketOpt(int optionName, const void* optionValue, socklen_t optionLen)
 197   throw(SocketException)
 198 {
 199   if (::setsockopt(sockDesc, SOL_SOCKET, optionName, optionValue, optionLen) < 0) {
 200     throw SocketException("setSockopt failed", true);
 201   }
 202 }
 203
 204 void Socket::cleanUp() throw(SocketException) {
 205   #ifdef WIN32
 206     if (WSACleanup() != 0) {
 207       throw SocketException("WSACleanup() failed");
 208     }
 209   #endif
 210 }
 211
 212 unsigned short Socket::resolveService(const string &service,
 213                                       const string &protocol) {
 214   struct servent *serv;        /* Structure containing service information */
 215
 216   if ((serv = getservbyname(service.c_str(), protocol.c_str())) == NULL)
 217     return atoi(service.c_str());  /* Service is port number */
 218   else
 219     return ntohs(serv->s_port);    /* Found port (network byte order) by name */
 220 }
 221
 222 // CommunicatingSocket Code
 223
 224 CommunicatingSocket::CommunicatingSocket(int type, int protocol)
 225     throw(SocketException) : Socket(type, protocol) {
 226 }
 227
 228 CommunicatingSocket::CommunicatingSocket(int newConnSD) : Socket(newConnSD) {
 229 }
 230
 231 void CommunicatingSocket::connect(const string &foreignAddress,
 232     unsigned short foreignPort) throw(SocketException) {
 233   // Get the address of the requested host
 234   sockaddr_in destAddr;
 235   fillAddr(foreignAddress, foreignPort, destAddr);
 236
 237   // Try to connect to the given port
 238   if (::connect(sockDesc, (sockaddr *) &destAddr, sizeof(destAddr)) < 0) {
 239     throw SocketException("Connect failed (connect())", true);
 240   }
 241 }
 242
 243 void CommunicatingSocket::send(const void *buffer, int bufferLen)
 244     throw(SocketException) {
 245   if (::send(sockDesc, (raw_type *) buffer, bufferLen, 0) < 0) {
 246     throw SocketException("Send failed (send())", true);
 247   }
 248 }
 249
 250 int CommunicatingSocket::recv(void *buffer, int bufferLen)
 251     throw(SocketException) {
 252   int rtn;
 253   if ((rtn = ::recv(sockDesc, (raw_type *) buffer, bufferLen, 0)) < 0) {
 254     throw SocketException("Received failed (recv())", true);
 255   }
 256
 257   return rtn;
 258 }
 259
 260 int CommunicatingSocket::recvNonBlocking(void *buffer, int bufferLen, int timeOut)
 261     throw(SocketException)
 262 {
 263   struct pollfd pfd[1];
 264   pfd[0].fd = sockDesc;
 265   pfd[0].events = POLLIN;
 266   int rtn = poll(pfd,1,timeOut);
 267   if(rtn > 0) {
 268     if ((rtn = ::recv(sockDesc, (raw_type *) buffer, bufferLen, 0)) < 0) {
 269       throw SocketException("non blocking receive failed", true);
 270     }
 271     if(!rtn) {
 272       throw SocketException("connection closed by peer", false);
 273     }
 274   }
 275   return rtn;
 276 }
 277
 278 string CommunicatingSocket::getForeignAddress()
 279     throw(SocketException) {
 280   sockaddr_in addr;
 281   unsigned int addr_len = sizeof(addr);
 282
 283   if (getpeername(sockDesc, (sockaddr *) &addr,(socklen_t *) &addr_len) < 0) {
 284     throw SocketException("Fetch of foreign address failed (getpeername())", true);
 285   }
 286   return inet_ntoa(addr.sin_addr);
 287 }
 288
 289 unsigned short CommunicatingSocket::getForeignPort() throw(SocketException) {
 290   sockaddr_in addr;
 291   unsigned int addr_len = sizeof(addr);
 292
 293   if (getpeername(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
 294     throw SocketException("Fetch of foreign port failed (getpeername())", true);
 295   }
 296   return ntohs(addr.sin_port);
 297 }
 298
 299 // TCPSocket Code
 300
 301 TCPSocket::TCPSocket()
 302     throw(SocketException) : CommunicatingSocket(SOCK_STREAM,
 303     IPPROTO_TCP) {
 304 }
 305
 306 TCPSocket::TCPSocket(const string &foreignAddress, unsigned short foreignPort)
 307     throw(SocketException) : CommunicatingSocket(SOCK_STREAM, IPPROTO_TCP) {
 308   connect(foreignAddress, foreignPort);
 309 }
 310
 311 TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD) {
 312 }
 313
 314 // TCPServerSocket Code
 315
 316 TCPServerSocket::TCPServerSocket(unsigned short localPort, int queueLen)
 317     throw(SocketException) : Socket(SOCK_STREAM, IPPROTO_TCP) {
 318   const int opt = 1;
 319   setSocketOpt(SO_REUSEADDR, &opt, sizeof(opt));
 320   setLocalPort(localPort);
 321   setListen(queueLen);
 322 }
 323
 324 TCPServerSocket::TCPServerSocket(const string &localAddress,
 325     unsigned short localPort, int queueLen)
 326     throw(SocketException) : Socket(SOCK_STREAM, IPPROTO_TCP) {
 327   const int opt = 1;
 328   setSocketOpt(SO_REUSEADDR, &opt, sizeof(opt));
 329   setLocalAddressAndPort(localAddress, localPort);
 330   setListen(queueLen);
 331 }
 332
 333 TCPSocket *TCPServerSocket::accept() throw(SocketException) {
 334   int newConnSD;
 335   if ((newConnSD = ::accept(sockDesc, NULL, 0)) < 0) {
 336     throw SocketException("Accept failed (accept())", true);
 337   }
 338
 339   return new TCPSocket(newConnSD);
 340 }
 341
 342 void TCPServerSocket::setListen(int queueLen) throw(SocketException) {
 343   if (listen(sockDesc, queueLen) < 0) {
 344     throw SocketException("Set listening socket failed (listen())", true);
 345   }
 346 }
 347
 348 // UDPSocket Code
 349
 350 UDPSocket::UDPSocket() throw(SocketException) : CommunicatingSocket(SOCK_DGRAM,
 351     IPPROTO_UDP) {
 352
 353   const int opt = 1;
 354   setSocketOpt(SO_REUSEADDR, &opt, sizeof(opt));
 355   setBroadcast();
 356 }
 357
 358 UDPSocket::UDPSocket(unsigned short localPort)  throw(SocketException) :
 359     CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) {
 360   const int opt = 1;
 361   setSocketOpt(SO_REUSEADDR, &opt, sizeof(opt));
 362   setLocalPort(localPort);
 363   setBroadcast();
 364 }
 365
 366 UDPSocket::UDPSocket(const string &localAddress, unsigned short localPort)
 367      throw(SocketException) : CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) {
 368   const int opt = 1;
 369   setSocketOpt(SO_REUSEADDR, &opt, sizeof(opt));
 370   setLocalAddressAndPort(localAddress, localPort);
 371   setBroadcast();
 372 }
 373
 374 void UDPSocket::setBroadcast() {
 375   // If this fails, we'll hear about it when we try to send.  This will allow
 376   // system that cannot broadcast to continue if they don't plan to broadcast
 377   int broadcastPermission = 1;
 378   setsockopt(sockDesc, SOL_SOCKET, SO_BROADCAST,
 379              (raw_type *) &broadcastPermission, sizeof(broadcastPermission));
 380 }
 381
 382 void UDPSocket::disconnect() throw(SocketException) {
 383   sockaddr_in nullAddr;
 384   memset(&nullAddr, 0, sizeof(nullAddr));
 385   nullAddr.sin_family = AF_UNSPEC;
 386
 387   // Try to disconnect
 388   if (::connect(sockDesc, (sockaddr *) &nullAddr, sizeof(nullAddr)) < 0) {
 389    #ifdef WIN32
 390     if (errno != WSAEAFNOSUPPORT) {
 391    #else
 392     if (errno != EAFNOSUPPORT) {
 393    #endif
 394       throw SocketException("Disconnect failed (connect())", true);
 395     }
 396   }
 397 }
 398
 399 void UDPSocket::sendTo(const void *buffer, int bufferLen,
 400     const string &foreignAddress, unsigned short foreignPort)
 401     throw(SocketException) {
 402   sockaddr_in destAddr;
 403   fillAddr(foreignAddress, foreignPort, destAddr);
 404
 405   // Write out the whole buffer as a single message.
 406   if (sendto(sockDesc, (raw_type *) buffer, bufferLen, 0,
 407              (sockaddr *) &destAddr, sizeof(destAddr)) != bufferLen) {
 408     throw SocketException("Send failed (sendto())", true);
 409   }
 410 }
 411
 412 int UDPSocket::recvFrom(void *buffer, int bufferLen, string &sourceAddress,
 413     unsigned short &sourcePort) throw(SocketException) {
 414   sockaddr_in clntAddr;
 415   socklen_t addrLen = sizeof(clntAddr);
 416   int rtn;
 417   if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, 0,
 418                       (sockaddr *) &clntAddr, (socklen_t *) &addrLen)) < 0) {
 419     throw SocketException("Receive failed (recvfrom())", true);
 420   }
 421   sourceAddress = inet_ntoa(clntAddr.sin_addr);
 422   sourcePort = ntohs(clntAddr.sin_port);
 423
 424   return rtn;
 425 }
 426
 427 int UDPSocket::recvFromNonBlocking(void *buffer, int bufferLen, string &sourceAddress,
 428     unsigned short &sourcePort, int timeOut) throw(SocketException) {
 429   sockaddr_in clntAddr;
 430   socklen_t addrLen = sizeof(clntAddr);
 431   struct pollfd pfd[1];
 432   pfd[0].fd = sockDesc;
 433   pfd[0].events = POLLIN;
 434   int rtn = poll(pfd,1,timeOut);
 435   if(rtn > 0) {
 436     if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, 0,
 437                         (sockaddr *) &clntAddr, (socklen_t *) &addrLen)) < 0) {
 438       throw SocketException("Receive failed (recvfrom())", true);
 439     }
 440     if(!rtn) {
 441       throw SocketException("connection closed by peer", false);
 442     }
 443   }
 444   sourceAddress = inet_ntoa(clntAddr.sin_addr);
 445   sourcePort = ntohs(clntAddr.sin_port);
 446
 447   return rtn;
 448 }
 449
 450 void UDPSocket::setMulticastTTL(unsigned char multicastTTL) throw(SocketException) {
 451   if (setsockopt(sockDesc, IPPROTO_IP, IP_MULTICAST_TTL,
 452                  (raw_type *) &multicastTTL, sizeof(multicastTTL)) < 0) {
 453     throw SocketException("Multicast TTL set failed (setsockopt())", true);
 454   }
 455 }
 456
 457 void UDPSocket::joinGroup(const string &multicastGroup) throw(SocketException) {
 458   struct ip_mreq multicastRequest;
 459
 460   multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
 461   multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
 462   if (setsockopt(sockDesc, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 463                  (raw_type *) &multicastRequest,
 464                  sizeof(multicastRequest)) < 0) {
 465     throw SocketException("Multicast group join failed (setsockopt())", true);
 466   }
 467 }
 468
 469 void UDPSocket::leaveGroup(const string &multicastGroup) throw(SocketException) {
 470   struct ip_mreq multicastRequest;
 471
 472   multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
 473   multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
 474   if (setsockopt(sockDesc, IPPROTO_IP, IP_DROP_MEMBERSHIP,
 475                  (raw_type *) &multicastRequest,
 476                  sizeof(multicastRequest)) < 0) {
 477     throw SocketException("Multicast group leave failed (setsockopt())", true);
 478   }
 479 }