octopi/library/sockets/raw_socket.cpp

   1 /*****************************************************************************\
   2 *                                                                             *
   3 *  Name   : raw_socket                                                        *
   4 *  Author : Chris Koeritz                                                     *
   5 *                                                                             *
   6 *******************************************************************************
   7 * Copyright (c) 1991-$now By Author.  This program is free software; you can  *
   8 * redistribute it and/or modify it under the terms of the GNU General Public  *
   9 * License as published by the Free Software Foundation; either version 2 of   *
  10 * the License or (at your option) any later version.  This is online at:      *
  11 *     http://www.fsf.org/copyleft/gpl.html                                    *
  12 * Please send any updates to: fred@gruntose.com                               *
  13 \*****************************************************************************/
  14
  15 #include "raw_socket.h"
  16 #include "tcpip_stack.h"
  17
  18 #include <basis/functions.h>
  19 #include <loggers/critical_events.h>
  20 #include <loggers/program_wide_logger.h>
  21 #include <timely/time_stamp.h>
  22
  23 #include <stdlib.h>
  24 #ifdef __APPLE__
  25   #include <fcntl.h>
  26 #endif
  27 #ifdef __UNIX__
  28   #include <arpa/inet.h>
  29   #include <errno.h>
  30   #include <netinet/tcp.h>
  31   #include <sys/ioctl.h>
  32   #include <sys/socket.h>
  33   #include <unistd.h>
  34   #define OPTYPE (void *)
  35 #endif
  36 #ifdef __WIN32__
  37   #define OPTYPE (char *)
  38 #endif
  39
  40 using namespace basis;
  41 using namespace loggers;
  42 using namespace timely;
  43
  44 namespace sockets {
  45
  46 //#define DEBUG_RAW_SOCKET
  47   // uncomment for noisy diagnostics.
  48
  49 #undef LOG
  50 #define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger::get(), to_print)
  51
  52 const int MULTIPLE_DISCONNECT_CHECKS = 28;
  53   // we will make certain that select really says there's data and ioctl
  54   // really says there's no data waiting before we believe there's been
  55   // a disconnect.  we'll check that state the number of times specified.
  56
  57 class fd_set_wrapper : public fd_set {};
  58
  59 //////////////
  60
  61 const basis::un_int NON_BLOCKING = FIONBIO;
  62 const basis::un_int IOCTL_READ = FIONREAD;
  63
  64 #ifdef __WIN32__
  65 /*
  66 // defined by winsock header but not present in the winsock dll.
  67 int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *the_set)
  68 {
  69   int i = the_set->fd_count;
  70   while (i--)
  71     if (the_set->fd_array[i] == fd)
  72       return true;
  73   return false;
  74 }
  75 */
  76 #endif
  77
  78 //////////////
  79
  80 raw_socket::raw_socket()
  81 : _stack(new tcpip_stack())
  82 {}
  83
  84 raw_socket::~raw_socket()
  85 {
  86   WHACK(_stack);
  87 }
  88
  89 int raw_socket::close(basis::un_int &socket)
  90 {
  91   int to_return = 0;
  92 #ifdef __WIN32__
  93   to_return = closesocket(socket);
  94 #endif
  95 #ifdef __UNIX__
  96   to_return = ::close(socket);
  97 #endif
  98   socket = 0;
  99   return to_return;
 100 }
 101
 102 //move this into parser bits as a OR combiner or something.
 103 void combine(astring &existing, const astring &addition)
 104 {
 105   if (addition.t()) {
 106     if (existing.t()) existing += " | ";
 107     existing += addition;
 108   }
 109 }
 110
 111 astring raw_socket::interest_name(int interest)
 112 {
 113   astring to_return;
 114   if (interest & SI_CONNECTED) combine(to_return, "CONNECTED");
 115   if (interest & SI_DISCONNECTED) combine(to_return, "DISCONNECTED");
 116   if (interest & SI_WRITABLE) combine(to_return, "WRITABLE");
 117   if (interest & SI_READABLE) combine(to_return, "READABLE");
 118   if (interest & SI_ERRONEOUS) combine(to_return, "ERRONEOUS");
 119   if (!interest) combine(to_return, "NORMAL");
 120   return to_return;
 121 }
 122
 123 int raw_socket::ioctl(basis::un_int socket, int request, void *argp) const
 124 {
 125 #ifdef __UNIX__
 126   return ::ioctl(socket, request, argp);
 127 #endif
 128 #ifdef __WIN32__
 129   return ioctlsocket(socket, request, (un_long *)argp);
 130 #endif
 131 }
 132
 133 bool raw_socket::set_non_blocking(basis::un_int socket, bool non_blocking)
 134 {
 135   FUNCDEF("set_non_blocking");
 136 #ifdef __APPLE__
 137   int curr_flags = fcntl(socket, F_GETFL, 0);
 138   if (fcntl(socket, F_SETFL, curr_flags | O_NONBLOCK) < 0) return false;
 139 #else
 140   int arg = int(non_blocking);
 141   if (negative(ioctl(socket, NON_BLOCKING, &arg))) {
 142     LOG(a_sprintf("Could not set non-blocking (FIONBIO) option on raw_socket %u.", socket));
 143     return false;
 144   }
 145 #endif
 146   return true;
 147 }
 148
 149 bool raw_socket::set_nagle_algorithm(basis::un_int socket, bool use_nagle)
 150 {
 151   FUNCDEF("set_nagle_algorithm");
 152   int arg = int(!use_nagle);  // opposite of the flag, since we set no-delay.
 153   if (negative(setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, OPTYPE &arg,
 154       sizeof(arg)))) {
 155     LOG(a_sprintf("Could not change nagle coalescing mode on %u.", socket));
 156     return false;
 157   }
 158   return true;
 159 }
 160
 161 bool raw_socket::set_broadcast(basis::un_int socket, bool broadcasting)
 162 {
 163   FUNCDEF("set_broadcast");
 164   int arg = int(broadcasting);
 165   if (negative(setsockopt(socket, SOL_SOCKET, SO_BROADCAST, OPTYPE &arg,
 166       sizeof(arg)))) {
 167     LOG(a_sprintf("Could not change broadcast mode on %u.", socket));
 168     return false;
 169   }
 170   return true;
 171 }
 172
 173 bool raw_socket::set_reuse_address(basis::un_int socket, bool reuse)
 174 {
 175   FUNCDEF("set_reuse_address");
 176   int arg = int(reuse);
 177   if (negative(setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, OPTYPE &arg,
 178       sizeof(arg)))) {
 179     LOG(a_sprintf("Could not set reuse address mode on %u.", socket));
 180     return false;
 181   }
 182   return true;
 183 }
 184
 185 bool raw_socket::set_keep_alive(basis::un_int socket, bool keep_alive)
 186 {
 187   FUNCDEF("set_keep_alive");
 188   int arg = int(keep_alive);
 189   if (negative(setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, OPTYPE &arg,
 190       sizeof(arg)))) {
 191     LOG(a_sprintf("Could not set keep alive mode on %u.", socket));
 192     return false;
 193   }
 194   return true;
 195 }
 196
 197 int raw_socket::select(basis::un_int socket, int mode, int timeout) const
 198 {
 199   FUNCDEF("select [single]");
 200   if (!socket) return SI_ERRONEOUS;
 201   fd_set_wrapper read_list, write_list, exceps;
 202   int ret = inner_select(socket, mode, timeout, read_list, write_list, exceps);
 203   if (!ret) return 0;  // nothing is happening.
 204   if (ret == SI_ERRONEOUS) return SI_ERRONEOUS;  // something bad happened.
 205   // otherwise we should be at base-line status.
 206   return analyze_select_result(socket, mode, read_list, write_list, exceps);
 207 }
 208
 209 int raw_socket::inner_select(basis::un_int socket, int mode, int timeout,
 210     fd_set_wrapper &read_list, fd_set_wrapper &write_list,
 211     fd_set_wrapper &exceptions) const
 212 {
 213   FUNCDEF("inner_select");
 214   // setup the file descriptor sets for the select.  we check readability,
 215   // writability and exception status.
 216   FD_ZERO(&read_list); FD_SET(socket, &read_list);
 217   FD_ZERO(&write_list); FD_SET(socket, &write_list);
 218   FD_ZERO(&exceptions); FD_SET(socket, &exceptions);
 219
 220   timeval time_out;
 221   time_stamp::fill_timeval_ms(time_out, timeout);
 222     // timeval has tv_sec=seconds, tv_usec=microseconds.
 223
 224   // select will tell us about the socket.
 225   int ret = ::select(socket + 1,
 226       (mode & SELECTING_JUST_WRITE)? NIL : &read_list,
 227       (mode & SELECTING_JUST_READ)? NIL : &write_list,
 228       &exceptions, &time_out);
 229   int error = critical_events::system_error();
 230   if (!ret) return 0;  // nothing to report.
 231
 232   if (ret == SOCKET_ERROR) {
 233     switch (error) {
 234       // all real errors fall out to the error handling stuff.
 235       case SOCK_EFAULT:  // intentional fall-through.
 236       case SOCK_ENETDOWN:  // intentional fall-through.
 237       case SOCK_EINVAL:  // intentional fall-through.
 238       case SOCK_EINTR:  // intentional fall-through.
 239 #ifdef __WIN32__
 240       case SOCK_NOTINITIALISED:  // intentional fall-through.
 241 #endif
 242       case SOCK_ENOTSOCK:
 243         break;
 244
 245       // hopefully all these others are bogus errors...
 246       case SOCK_EINPROGRESS:  // intentional fall-through.
 247       case 0:  // intentional fall-through.
 248       default:
 249 #ifdef DEBUG_RAW_SOCKET
 250         LOG("got to weird case, in progress or zero.");
 251 #endif
 252         return 0;  // not really an error.
 253     }
 254 #ifdef DEBUG_RAW_SOCKET
 255     LOG(a_sprintf("socket %u had error %d in select: %s.",
 256         socket, error, _stack->tcpip_error_name(error).s()));
 257 #endif
 258     return SI_ERRONEOUS;
 259   }
 260
 261   // if we got to here, then there are some things to report...
 262   return SI_BASELINE;
 263 }
 264
 265 int raw_socket::test_readability(basis::un_int socket) const
 266 {
 267   FUNCDEF("test_readability");
 268   basis::un_int len;
 269   if (negative(ioctl(socket, IOCTL_READ, &len))) {
 270     LOG(astring(astring::SPRINTF, "socket %u had ioctl error: %s.",
 271         socket, _stack->tcpip_error_name(critical_events::system_error()).s()));
 272     return SI_ERRONEOUS;
 273   } else {
 274     if (positive(len)) return SI_READABLE;
 275     else return SI_DISCONNECTED;
 276   }
 277 }
 278
 279 int raw_socket::analyze_select_result(basis::un_int socket, int mode,
 280     fd_set_wrapper &read_list, fd_set_wrapper &write_list,
 281     fd_set_wrapper &exceptions) const
 282 {
 283 #ifdef DEBUG_RAW_SOCKET
 284   FUNCDEF("analyze_select_result");
 285 #endif
 286   int to_return = 0;
 287
 288   // in case of an exception, we return an error.
 289   if (FD_ISSET(socket, &exceptions)) {
 290 #ifdef DEBUG_RAW_SOCKET
 291     LOG(astring(astring::SPRINTF, "exception seen for socket %u!", socket));
 292 #endif
 293   }
 294
 295   // check to see if there are bytes to read.
 296   if ( ! (mode & SELECTING_JUST_WRITE) && FD_ISSET(socket, &read_list)) {
 297     // make sure we have data.  if no data is available, it means a
 298     // disconnect occurred.
 299
 300     int readable = test_readability(socket);
 301     if (readable == SI_ERRONEOUS)
 302       to_return |= SI_ERRONEOUS;
 303     else if (readable == SI_READABLE)
 304       to_return |= SI_READABLE;
 305     else if (readable == SI_DISCONNECTED) {
 306       // we need to check multiple times to be sure the OS really means this.
 307       // either windoze seems to report an erroneous disconnect every few
 308       // days or there's a bad synchronization issue as yet uncovered.
 309       bool really_disconnected = true;
 310       for (int i = 0; i < MULTIPLE_DISCONNECT_CHECKS; i++) {
 311         fd_set_wrapper read_list, write_list, exceps;
 312         int temp_ret = inner_select(socket, SELECTING_JUST_READ, 0, read_list,
 313             write_list, exceps);
 314         // check the return value first...
 315         if (!temp_ret) {
 316           // nothing happening (a zero return) means the socket's no longer
 317           // claiming to have a readable state; our disconnect condition is
 318           // thus violated and we can leave.
 319           really_disconnected = false;
 320           break;
 321         }
 322         if (temp_ret == SI_ERRONEOUS) {
 323           // this, on the other hand, sounds really bad.  the socket doesn't
 324           // seem to exist any more or something else horrid happened.
 325           really_disconnected = true;
 326           break;
 327         }
 328         // if the select worked, we can check the fd_set now for readability.
 329         if (!FD_ISSET(socket, &read_list)) {
 330           // we are not in a disconnected state without being told we're
 331           // readable.  supposedly.
 332           really_disconnected = false;
 333           break;
 334         }
 335         // now we really test the socket for readability by making sure there
 336         // really is data pending on the socket.  if it's readable but there's
 337         // no data, then either a disconnection has occurred or is in progress.
 338         readable = test_readability(socket);
 339         if (readable != SI_DISCONNECTED) {
 340           // we are not disconnected if there's really data waiting.
 341           really_disconnected = false;
 342           break;
 343         }
 344       }
 345       if (really_disconnected) {
 346 #ifdef DEBUG_RAW_SOCKET
 347         LOG(a_sprintf("connection closed on socket %u.", socket));
 348 #endif
 349         to_return |= SI_DISCONNECTED;
 350       }
 351     }
 352   }
 353
 354   // check writability state.
 355   if (! (mode & SELECTING_JUST_READ) && FD_ISSET(socket, &write_list)) {
 356     to_return |= SI_WRITABLE;
 357   }
 358
 359   return to_return;
 360 }
 361
 362 int raw_socket::select(int_array &read_sox, int_array &write_sox,
 363     int timeout) const
 364 {
 365 #ifdef DEBUG_RAW_SOCKET
 366   FUNCDEF("select [multiple]");
 367 #endif
 368   if (!read_sox.length() && !write_sox.length())
 369    return 0;  // nothing happened to nothing.
 370
 371   int to_return = 0;  // will get bits slammed into it to report results.
 372
 373   // setup the file descriptor sets for the select.  we check readability,
 374   // writability and exception status.
 375   fd_set_wrapper read_list; FD_ZERO(&read_list);
 376   fd_set_wrapper write_list; FD_ZERO(&write_list);
 377   fd_set_wrapper exceptions; FD_ZERO(&exceptions);
 378   // set up the lists with the sets we were handed.
 379   basis::un_int highest = 0;
 380   int i = 0;
 381   for (i = 0; i < read_sox.length(); i++) {
 382     basis::un_int sock = (basis::un_int)read_sox[i];
 383     if (sock > highest) highest = sock;
 384     FD_SET(sock, &read_list);
 385   }
 386   for (i = 0; i < write_sox.length(); i++) {
 387     basis::un_int sock = (basis::un_int)write_sox[i];
 388     if (sock > highest) highest = sock;
 389     FD_SET(sock, &write_list);
 390   }
 391
 392   timeval time_out;
 393   time_stamp::fill_timeval_ms(time_out, timeout);
 394     // timeval has tv_sec=seconds, tv_usec=microseconds.
 395
 396   // select will tell us about the socket.
 397   int ret = ::select(highest + 1,
 398       (read_sox.length())? &read_list : NIL,
 399       (write_sox.length())? &write_list : NIL,
 400       &exceptions, &time_out);
 401   int error = critical_events::system_error();
 402
 403   if (ret == SOCKET_ERROR) {
 404     switch (error) {
 405       // all real errors fall out to the error handling stuff.
 406       case SOCK_EFAULT:  // intentional fall-through.
 407       case SOCK_ENETDOWN:  // intentional fall-through.
 408       case SOCK_EINVAL:  // intentional fall-through.
 409       case SOCK_EINTR:  // intentional fall-through.
 410 #ifdef __WIN32__
 411       case SOCK_NOTINITIALISED:  // intentional fall-through.
 412 #endif
 413       case SOCK_ENOTSOCK:
 414         break;
 415
 416       // hopefully all these others are bogus errors...
 417       case SOCK_EINPROGRESS:  // intentional fall-through.
 418       case 0:  // intentional fall-through.
 419       default:
 420 #ifdef DEBUG_RAW_SOCKET
 421         LOG("got to weird case, in progress or zero.");
 422 #endif
 423
 424 //hmmm: fix retd sox?  what's this outcome mean for the list?
 425
 426         return 0;  // not really an error.
 427     }
 428 #ifdef DEBUG_RAW_SOCKET
 429     LOG(a_sprintf("sockets had error %d in select: %s.",
 430         error, _stack->tcpip_error_name(error).s()));
 431 #endif
 432
 433 //hmmm: fix retd sox?  what's this outcome mean for the list?
 434
 435     return SI_ERRONEOUS;
 436   } else if (!ret) {
 437     // we know of nothing exciting for any of these.
 438     read_sox.reset();
 439     write_sox.reset();
 440     return 0;  // nothing to report.
 441   }
 442
 443   // if we got to here, then there are some things to report...
 444   // iterate through the lists and check results.
 445   for (int k = 0; k < read_sox.length(); k++) {
 446     basis::un_int socket = read_sox[k];
 447     int interim = analyze_select_result(socket, SELECTING_JUST_READ, read_list,
 448         write_list, exceptions);
 449     if (!interim) {
 450       // nothing happened on that guy.
 451       read_sox.zap(k, k);
 452       k--;  // skip back to before the whack.
 453       continue;
 454     }
 455     to_return |= interim;  // join the results with overall result.
 456   }
 457   for (int p = 0; p < write_sox.length(); p++) {
 458     basis::un_int socket = write_sox[p];
 459     int interim = analyze_select_result(socket, SELECTING_JUST_WRITE, read_list,
 460         write_list, exceptions);
 461     if (!interim) {
 462       // nothing happened on that guy.
 463       write_sox.zap(p, p);
 464       p--;  // skip back to before the whack.
 465       continue;
 466     }
 467     to_return |= interim;  // join the results with overall result.
 468   }
 469
 470   return to_return;
 471 }
 472
 473 } //namespace.
 474