1 /*****************************************************************************\
4 * Author : Chris Koeritz *
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 \*****************************************************************************/
15 #include "raw_socket.h"
16 #include "tcpip_stack.h"
18 #include <basis/functions.h>
19 #include <loggers/critical_events.h>
20 #include <loggers/program_wide_logger.h>
21 #include <timely/time_stamp.h>
28 #include <arpa/inet.h>
30 #include <netinet/tcp.h>
31 #include <sys/ioctl.h>
32 #include <sys/socket.h>
34 #define OPTYPE (void *)
37 #define OPTYPE (char *)
40 using namespace basis;
41 using namespace loggers;
42 using namespace timely;
46 //#define DEBUG_RAW_SOCKET
47 // uncomment for noisy diagnostics.
50 #define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger::get(), to_print)
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.
57 class fd_set_wrapper : public fd_set {};
61 const basis::un_int NON_BLOCKING = FIONBIO;
62 const basis::un_int IOCTL_READ = FIONREAD;
66 // defined by winsock header but not present in the winsock dll.
67 int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *the_set)
69 int i = the_set->fd_count;
71 if (the_set->fd_array[i] == fd)
80 raw_socket::raw_socket()
81 : _stack(new tcpip_stack())
84 raw_socket::~raw_socket()
89 int raw_socket::close(basis::un_int &socket)
93 to_return = closesocket(socket);
96 to_return = ::close(socket);
102 //move this into parser bits as a OR combiner or something.
103 void combine(astring &existing, const astring &addition)
106 if (existing.t()) existing += " | ";
107 existing += addition;
111 astring raw_socket::interest_name(int interest)
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");
123 int raw_socket::ioctl(basis::un_int socket, int request, void *argp) const
126 return ::ioctl(socket, request, argp);
129 return ioctlsocket(socket, request, (un_long *)argp);
133 bool raw_socket::set_non_blocking(basis::un_int socket, bool non_blocking)
135 FUNCDEF("set_non_blocking");
137 int curr_flags = fcntl(socket, F_GETFL, 0);
138 if (fcntl(socket, F_SETFL, curr_flags | O_NONBLOCK) < 0) return false;
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));
149 bool raw_socket::set_nagle_algorithm(basis::un_int socket, bool use_nagle)
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,
155 LOG(a_sprintf("Could not change nagle coalescing mode on %u.", socket));
161 bool raw_socket::set_broadcast(basis::un_int socket, bool broadcasting)
163 FUNCDEF("set_broadcast");
164 int arg = int(broadcasting);
165 if (negative(setsockopt(socket, SOL_SOCKET, SO_BROADCAST, OPTYPE &arg,
167 LOG(a_sprintf("Could not change broadcast mode on %u.", socket));
173 bool raw_socket::set_reuse_address(basis::un_int socket, bool reuse)
175 FUNCDEF("set_reuse_address");
176 int arg = int(reuse);
177 if (negative(setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, OPTYPE &arg,
179 LOG(a_sprintf("Could not set reuse address mode on %u.", socket));
185 bool raw_socket::set_keep_alive(basis::un_int socket, bool keep_alive)
187 FUNCDEF("set_keep_alive");
188 int arg = int(keep_alive);
189 if (negative(setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, OPTYPE &arg,
191 LOG(a_sprintf("Could not set keep alive mode on %u.", socket));
197 int raw_socket::select(basis::un_int socket, int mode, int timeout) const
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);
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
213 FUNCDEF("inner_select");
214 // setup the file descriptor sets for the select. we check readability,
215 // writability and exception status.
217 FD_ZERO(&read_list); FD_SET(socket, &read_list);
219 FD_ZERO(&write_list); FD_SET(socket, &write_list);
221 FD_ZERO(&exceptions); FD_SET(socket, &exceptions);
223 timeval *farkle = new timeval;
225 time_stamp *t = new time_stamp();
229 time_stamp::fill_timeval_ms(time_out, timeout);
230 // timeval has tv_sec=seconds, tv_usec=microseconds.
233 // select will tell us about the socket.
234 int ret = ::select(socket + 1,
235 (mode & SELECTING_JUST_WRITE)? NIL : &read_list,
236 (mode & SELECTING_JUST_READ)? NIL : &write_list,
237 &exceptions, &time_out);
239 int error = critical_events::system_error();
242 if (!ret) return 0; // nothing to report.
244 if (ret == SOCKET_ERROR) {
247 // all real errors fall out to the error handling stuff.
248 case SOCK_EFAULT: // intentional fall-through.
249 case SOCK_ENETDOWN: // intentional fall-through.
250 case SOCK_EINVAL: // intentional fall-through.
251 case SOCK_EINTR: // intentional fall-through.
253 case SOCK_NOTINITIALISED: // intentional fall-through.
258 // hopefully all these others are bogus errors...
259 case SOCK_EINPROGRESS: // intentional fall-through.
260 case 0: // intentional fall-through.
262 #ifdef DEBUG_RAW_SOCKET
263 LOG("got to weird case, in progress or zero.");
265 return 0; // not really an error.
268 #ifdef DEBUG_RAW_SOCKET
269 LOG(a_sprintf("socket %u had error %d in select: %s.",
270 socket, error, _stack->tcpip_error_name(error).s()));
276 // if we got to here, then there are some things to report...
280 int raw_socket::test_readability(basis::un_int socket) const
282 FUNCDEF("test_readability");
284 if (negative(ioctl(socket, IOCTL_READ, &len))) {
285 LOG(astring(astring::SPRINTF, "socket %u had ioctl error: %s.",
286 socket, _stack->tcpip_error_name(critical_events::system_error()).s()));
289 if (positive(len)) return SI_READABLE;
290 else return SI_DISCONNECTED;
294 int raw_socket::analyze_select_result(basis::un_int socket, int mode,
295 fd_set_wrapper &read_list, fd_set_wrapper &write_list,
296 fd_set_wrapper &exceptions) const
298 #ifdef DEBUG_RAW_SOCKET
299 FUNCDEF("analyze_select_result");
303 // in case of an exception, we return an error.
304 if (FD_ISSET(socket, &exceptions)) {
305 #ifdef DEBUG_RAW_SOCKET
306 LOG(astring(astring::SPRINTF, "exception seen for socket %u!", socket));
310 // check to see if there are bytes to read.
311 if ( ! (mode & SELECTING_JUST_WRITE) && FD_ISSET(socket, &read_list)) {
312 // make sure we have data. if no data is available, it means a
313 // disconnect occurred.
315 int readable = test_readability(socket);
316 if (readable == SI_ERRONEOUS)
317 to_return |= SI_ERRONEOUS;
318 else if (readable == SI_READABLE)
319 to_return |= SI_READABLE;
320 else if (readable == SI_DISCONNECTED) {
321 // we need to check multiple times to be sure the OS really means this.
322 // either windoze seems to report an erroneous disconnect every few
323 // days or there's a bad synchronization issue as yet uncovered.
324 bool really_disconnected = true;
325 for (int i = 0; i < MULTIPLE_DISCONNECT_CHECKS; i++) {
326 fd_set_wrapper read_list, write_list, exceps;
327 int temp_ret = inner_select(socket, SELECTING_JUST_READ, 0, read_list,
329 // check the return value first...
331 // nothing happening (a zero return) means the socket's no longer
332 // claiming to have a readable state; our disconnect condition is
333 // thus violated and we can leave.
334 really_disconnected = false;
337 if (temp_ret == SI_ERRONEOUS) {
338 // this, on the other hand, sounds really bad. the socket doesn't
339 // seem to exist any more or something else horrid happened.
340 really_disconnected = true;
343 // if the select worked, we can check the fd_set now for readability.
344 if (!FD_ISSET(socket, &read_list)) {
345 // we are not in a disconnected state without being told we're
346 // readable. supposedly.
347 really_disconnected = false;
350 // now we really test the socket for readability by making sure there
351 // really is data pending on the socket. if it's readable but there's
352 // no data, then either a disconnection has occurred or is in progress.
353 readable = test_readability(socket);
354 if (readable != SI_DISCONNECTED) {
355 // we are not disconnected if there's really data waiting.
356 really_disconnected = false;
360 if (really_disconnected) {
361 #ifdef DEBUG_RAW_SOCKET
362 LOG(a_sprintf("connection closed on socket %u.", socket));
364 to_return |= SI_DISCONNECTED;
369 // check writability state.
370 if (! (mode & SELECTING_JUST_READ) && FD_ISSET(socket, &write_list)) {
371 to_return |= SI_WRITABLE;
377 int raw_socket::select(int_array &read_sox, int_array &write_sox,
380 #ifdef DEBUG_RAW_SOCKET
381 FUNCDEF("select [multiple]");
383 if (!read_sox.length() && !write_sox.length())
384 return 0; // nothing happened to nothing.
386 int to_return = 0; // will get bits slammed into it to report results.
388 // setup the file descriptor sets for the select. we check readability,
389 // writability and exception status.
390 fd_set_wrapper read_list; FD_ZERO(&read_list);
391 fd_set_wrapper write_list; FD_ZERO(&write_list);
392 fd_set_wrapper exceptions; FD_ZERO(&exceptions);
393 // set up the lists with the sets we were handed.
394 basis::un_int highest = 0;
396 for (i = 0; i < read_sox.length(); i++) {
397 basis::un_int sock = (basis::un_int)read_sox[i];
398 if (sock > highest) highest = sock;
399 FD_SET(sock, &read_list);
401 for (i = 0; i < write_sox.length(); i++) {
402 basis::un_int sock = (basis::un_int)write_sox[i];
403 if (sock > highest) highest = sock;
404 FD_SET(sock, &write_list);
408 time_stamp::fill_timeval_ms(time_out, timeout);
409 // timeval has tv_sec=seconds, tv_usec=microseconds.
411 // select will tell us about the socket.
412 int ret = ::select(highest + 1,
413 (read_sox.length())? &read_list : NIL,
414 (write_sox.length())? &write_list : NIL,
415 &exceptions, &time_out);
416 int error = critical_events::system_error();
418 if (ret == SOCKET_ERROR) {
420 // all real errors fall out to the error handling stuff.
421 case SOCK_EFAULT: // intentional fall-through.
422 case SOCK_ENETDOWN: // intentional fall-through.
423 case SOCK_EINVAL: // intentional fall-through.
424 case SOCK_EINTR: // intentional fall-through.
426 case SOCK_NOTINITIALISED: // intentional fall-through.
431 // hopefully all these others are bogus errors...
432 case SOCK_EINPROGRESS: // intentional fall-through.
433 case 0: // intentional fall-through.
435 #ifdef DEBUG_RAW_SOCKET
436 LOG("got to weird case, in progress or zero.");
439 //hmmm: fix retd sox? what's this outcome mean for the list?
441 return 0; // not really an error.
443 #ifdef DEBUG_RAW_SOCKET
444 LOG(a_sprintf("sockets had error %d in select: %s.",
445 error, _stack->tcpip_error_name(error).s()));
448 //hmmm: fix retd sox? what's this outcome mean for the list?
452 // we know of nothing exciting for any of these.
455 return 0; // nothing to report.
458 // if we got to here, then there are some things to report...
459 // iterate through the lists and check results.
460 for (int k = 0; k < read_sox.length(); k++) {
461 basis::un_int socket = read_sox[k];
462 int interim = analyze_select_result(socket, SELECTING_JUST_READ, read_list,
463 write_list, exceptions);
465 // nothing happened on that guy.
467 k--; // skip back to before the whack.
470 to_return |= interim; // join the results with overall result.
472 for (int p = 0; p < write_sox.length(); p++) {
473 basis::un_int socket = write_sox[p];
474 int interim = analyze_select_result(socket, SELECTING_JUST_WRITE, read_list,
475 write_list, exceptions);
477 // nothing happened on that guy.
479 p--; // skip back to before the whack.
482 to_return |= interim; // join the results with overall result.