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_int *)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 base_time_out;
 221   time_stamp::fill_timeval_ms(base_time_out, timeout);
 222     // timeval has tv_sec=seconds, tv_usec=microseconds.
 223 #if !defined(__GNU_WINDOWS__)
 224   timeval *time_out = &base_time_out;
 225 #elif defined(__GNU_WINDOWS__)
 226   __ms_timeval win_time_out;
 227   win_time_out.tv_sec = base_time_out.tv_sec;
 228   win_time_out.tv_usec = base_time_out.tv_usec;
 229   __ms_timeval *time_out = &win_time_out;
 230 #endif
 231
 232   // select will tell us about the socket.
 233   int ret = ::select(socket + 1,
 234       (mode & SELECTING_JUST_WRITE)? NIL : &read_list,
 235       (mode & SELECTING_JUST_READ)? NIL : &write_list,
 236       &exceptions, time_out);
 237   int error = critical_events::system_error();
 238   if (!ret) return 0;  // nothing to report.
 239
 240   if (ret == SOCKET_ERROR) {
 241     switch (error) {
 242       // all real errors fall out to the error handling stuff.
 243       case SOCK_EFAULT:  // intentional fall-through.
 244       case SOCK_ENETDOWN:  // intentional fall-through.
 245       case SOCK_EINVAL:  // intentional fall-through.
 246       case SOCK_EINTR:  // intentional fall-through.
 247 #ifdef __WIN32__
 248       case SOCK_NOTINITIALISED:  // intentional fall-through.
 249 #endif
 250       case SOCK_ENOTSOCK:
 251         break;
 252
 253       // hopefully all these others are bogus errors...
 254       case SOCK_EINPROGRESS:  // intentional fall-through.
 255       case 0:  // intentional fall-through.
 256       default:
 257 #ifdef DEBUG_RAW_SOCKET
 258         LOG("got to weird case, in progress or zero.");
 259 #endif
 260         return 0;  // not really an error.
 261     }
 262 #ifdef DEBUG_RAW_SOCKET
 263     LOG(a_sprintf("socket %u had error %d in select: %s.",
 264         socket, error, _stack->tcpip_error_name(error).s()));
 265 #endif
 266     return SI_ERRONEOUS;
 267   }
 268
 269   // if we got to here, then there are some things to report...
 270   return SI_BASELINE;
 271 }
 272
 273 int raw_socket::test_readability(basis::un_int socket) const
 274 {
 275   FUNCDEF("test_readability");
 276   basis::un_int len;
 277   if (negative(ioctl(socket, IOCTL_READ, &len))) {
 278     LOG(astring(astring::SPRINTF, "socket %u had ioctl error: %s.",
 279         socket, _stack->tcpip_error_name(critical_events::system_error()).s()));
 280     return SI_ERRONEOUS;
 281   } else {
 282     if (positive(len)) return SI_READABLE;
 283     else return SI_DISCONNECTED;
 284   }
 285 }
 286
 287 int raw_socket::analyze_select_result(basis::un_int socket, int mode,
 288     fd_set_wrapper &read_list, fd_set_wrapper &write_list,
 289     fd_set_wrapper &exceptions) const
 290 {
 291 #ifdef DEBUG_RAW_SOCKET
 292   FUNCDEF("analyze_select_result");
 293 #endif
 294   int to_return = 0;
 295
 296   // in case of an exception, we return an error.
 297   if (FD_ISSET(socket, &exceptions)) {
 298 #ifdef DEBUG_RAW_SOCKET
 299     LOG(astring(astring::SPRINTF, "exception seen for socket %u!", socket));
 300 #endif
 301   }
 302
 303   // check to see if there are bytes to read.
 304   if ( ! (mode & SELECTING_JUST_WRITE) && FD_ISSET(socket, &read_list)) {
 305     // make sure we have data.  if no data is available, it means a
 306     // disconnect occurred.
 307
 308     int readable = test_readability(socket);
 309     if (readable == SI_ERRONEOUS)
 310       to_return |= SI_ERRONEOUS;
 311     else if (readable == SI_READABLE)
 312       to_return |= SI_READABLE;
 313     else if (readable == SI_DISCONNECTED) {
 314       // we need to check multiple times to be sure the OS really means this.
 315       // either windoze seems to report an erroneous disconnect every few
 316       // days or there's a bad synchronization issue as yet uncovered.
 317       bool really_disconnected = true;
 318       for (int i = 0; i < MULTIPLE_DISCONNECT_CHECKS; i++) {
 319         fd_set_wrapper read_list, write_list, exceps;
 320         int temp_ret = inner_select(socket, SELECTING_JUST_READ, 0, read_list,
 321             write_list, exceps);
 322         // check the return value first...
 323         if (!temp_ret) {
 324           // nothing happening (a zero return) means the socket's no longer
 325           // claiming to have a readable state; our disconnect condition is
 326           // thus violated and we can leave.
 327           really_disconnected = false;
 328           break;
 329         }
 330         if (temp_ret == SI_ERRONEOUS) {
 331           // this, on the other hand, sounds really bad.  the socket doesn't
 332           // seem to exist any more or something else horrid happened.
 333           really_disconnected = true;
 334           break;
 335         }
 336         // if the select worked, we can check the fd_set now for readability.
 337         if (!FD_ISSET(socket, &read_list)) {
 338           // we are not in a disconnected state without being told we're
 339           // readable.  supposedly.
 340           really_disconnected = false;
 341           break;
 342         }
 343         // now we really test the socket for readability by making sure there
 344         // really is data pending on the socket.  if it's readable but there's
 345         // no data, then either a disconnection has occurred or is in progress.
 346         readable = test_readability(socket);
 347         if (readable != SI_DISCONNECTED) {
 348           // we are not disconnected if there's really data waiting.
 349           really_disconnected = false;
 350           break;
 351         }
 352       }
 353       if (really_disconnected) {
 354 #ifdef DEBUG_RAW_SOCKET
 355         LOG(a_sprintf("connection closed on socket %u.", socket));
 356 #endif
 357         to_return |= SI_DISCONNECTED;
 358       }
 359     }
 360   }
 361
 362   // check writability state.
 363   if (! (mode & SELECTING_JUST_READ) && FD_ISSET(socket, &write_list)) {
 364     to_return |= SI_WRITABLE;
 365   }
 366
 367   return to_return;
 368 }
 369
 370 int raw_socket::select(int_array &read_sox, int_array &write_sox,
 371     int timeout) const
 372 {
 373 #ifdef DEBUG_RAW_SOCKET
 374   FUNCDEF("select [multiple]");
 375 #endif
 376   if (!read_sox.length() && !write_sox.length())
 377    return 0;  // nothing happened to nothing.
 378
 379   int to_return = 0;  // will get bits slammed into it to report results.
 380
 381   // setup the file descriptor sets for the select.  we check readability,
 382   // writability and exception status.
 383   fd_set_wrapper read_list; FD_ZERO(&read_list);
 384   fd_set_wrapper write_list; FD_ZERO(&write_list);
 385   fd_set_wrapper exceptions; FD_ZERO(&exceptions);
 386   // set up the lists with the sets we were handed.
 387   basis::un_int highest = 0;
 388   int i = 0;
 389   for (i = 0; i < read_sox.length(); i++) {
 390     basis::un_int sock = (basis::un_int)read_sox[i];
 391     if (sock > highest) highest = sock;
 392     FD_SET(sock, &read_list);
 393   }
 394   for (i = 0; i < write_sox.length(); i++) {
 395     basis::un_int sock = (basis::un_int)write_sox[i];
 396     if (sock > highest) highest = sock;
 397     FD_SET(sock, &write_list);
 398   }
 399
 400   timeval base_time_out;
 401   time_stamp::fill_timeval_ms(base_time_out, timeout);
 402     // timeval has tv_sec=seconds, tv_usec=microseconds.
 403 #if !defined(__GNU_WINDOWS__)
 404   timeval *time_out = &base_time_out;
 405 #elif defined(__GNU_WINDOWS__)
 406   __ms_timeval win_time_out;
 407   win_time_out.tv_sec = base_time_out.tv_sec;
 408   win_time_out.tv_usec = base_time_out.tv_usec;
 409   __ms_timeval *time_out = &win_time_out;
 410 #endif
 411
 412   // select will tell us about the socket.
 413   int ret = ::select(highest + 1,
 414       (read_sox.length())? &read_list : NIL,
 415       (write_sox.length())? &write_list : NIL,
 416       &exceptions, time_out);
 417   int error = critical_events::system_error();
 418
 419   if (ret == SOCKET_ERROR) {
 420     switch (error) {
 421       // all real errors fall out to the error handling stuff.
 422       case SOCK_EFAULT:  // intentional fall-through.
 423       case SOCK_ENETDOWN:  // intentional fall-through.
 424       case SOCK_EINVAL:  // intentional fall-through.
 425       case SOCK_EINTR:  // intentional fall-through.
 426 #ifdef __WIN32__
 427       case SOCK_NOTINITIALISED:  // intentional fall-through.
 428 #endif
 429       case SOCK_ENOTSOCK:
 430         break;
 431
 432       // hopefully all these others are bogus errors...
 433       case SOCK_EINPROGRESS:  // intentional fall-through.
 434       case 0:  // intentional fall-through.
 435       default:
 436 #ifdef DEBUG_RAW_SOCKET
 437         LOG("got to weird case, in progress or zero.");
 438 #endif
 439
 440 //hmmm: fix retd sox?  what's this outcome mean for the list?
 441
 442         return 0;  // not really an error.
 443     }
 444 #ifdef DEBUG_RAW_SOCKET
 445     LOG(a_sprintf("sockets had error %d in select: %s.",
 446         error, _stack->tcpip_error_name(error).s()));
 447 #endif
 448
 449 //hmmm: fix retd sox?  what's this outcome mean for the list?
 450
 451     return SI_ERRONEOUS;
 452   } else if (!ret) {
 453     // we know of nothing exciting for any of these.
 454     read_sox.reset();
 455     write_sox.reset();
 456     return 0;  // nothing to report.
 457   }
 458
 459   // if we got to here, then there are some things to report...
 460   // iterate through the lists and check results.
 461   for (int k = 0; k < read_sox.length(); k++) {
 462     basis::un_int socket = read_sox[k];
 463     int interim = analyze_select_result(socket, SELECTING_JUST_READ, read_list,
 464         write_list, exceptions);
 465     if (!interim) {
 466       // nothing happened on that guy.
 467       read_sox.zap(k, k);
 468       k--;  // skip back to before the whack.
 469       continue;
 470     }
 471     to_return |= interim;  // join the results with overall result.
 472   }
 473   for (int p = 0; p < write_sox.length(); p++) {
 474     basis::un_int socket = write_sox[p];
 475     int interim = analyze_select_result(socket, SELECTING_JUST_WRITE, read_list,
 476         write_list, exceptions);
 477     if (!interim) {
 478       // nothing happened on that guy.
 479       write_sox.zap(p, p);
 480       p--;  // skip back to before the whack.
 481       continue;
 482     }
 483     to_return |= interim;  // join the results with overall result.
 484   }
 485
 486   return to_return;
 487 }
 488
 489 } //namespace.
 490