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);
131 return ioctlsocket(socket, request, (un_long *)argp);
133 return ioctlsocket(socket, request, (un_int *)argp);
139 bool raw_socket::set_non_blocking(basis::un_int socket, bool non_blocking)
141 FUNCDEF("set_non_blocking");
143 int curr_flags = fcntl(socket, F_GETFL, 0);
144 if (fcntl(socket, F_SETFL, curr_flags | O_NONBLOCK) < 0) return false;
146 int arg = int(non_blocking);
147 if (negative(ioctl(socket, NON_BLOCKING, &arg))) {
148 LOG(a_sprintf("Could not set non-blocking (FIONBIO) option on raw_socket %u.", socket));
155 bool raw_socket::set_nagle_algorithm(basis::un_int socket, bool use_nagle)
157 FUNCDEF("set_nagle_algorithm");
158 int arg = int(!use_nagle); // opposite of the flag, since we set no-delay.
159 if (negative(setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, OPTYPE &arg,
161 LOG(a_sprintf("Could not change nagle coalescing mode on %u.", socket));
167 bool raw_socket::set_broadcast(basis::un_int socket, bool broadcasting)
169 FUNCDEF("set_broadcast");
170 int arg = int(broadcasting);
171 if (negative(setsockopt(socket, SOL_SOCKET, SO_BROADCAST, OPTYPE &arg,
173 LOG(a_sprintf("Could not change broadcast mode on %u.", socket));
179 bool raw_socket::set_reuse_address(basis::un_int socket, bool reuse)
181 FUNCDEF("set_reuse_address");
182 int arg = int(reuse);
183 if (negative(setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, OPTYPE &arg,
185 LOG(a_sprintf("Could not set reuse address mode on %u.", socket));
191 bool raw_socket::set_keep_alive(basis::un_int socket, bool keep_alive)
193 FUNCDEF("set_keep_alive");
194 int arg = int(keep_alive);
195 if (negative(setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, OPTYPE &arg,
197 LOG(a_sprintf("Could not set keep alive mode on %u.", socket));
203 int raw_socket::select(basis::un_int socket, int mode, int timeout) const
205 FUNCDEF("select [single]");
206 if (!socket) return SI_ERRONEOUS;
207 fd_set_wrapper read_list, write_list, exceps;
208 int ret = inner_select(socket, mode, timeout, read_list, write_list, exceps);
209 if (!ret) return 0; // nothing is happening.
210 if (ret == SI_ERRONEOUS) return SI_ERRONEOUS; // something bad happened.
211 // otherwise we should be at base-line status.
212 return analyze_select_result(socket, mode, read_list, write_list, exceps);
215 int raw_socket::inner_select(basis::un_int socket, int mode, int timeout,
216 fd_set_wrapper &read_list, fd_set_wrapper &write_list,
217 fd_set_wrapper &exceptions) const
219 FUNCDEF("inner_select");
220 // setup the file descriptor sets for the select. we check readability,
221 // writability and exception status.
222 FD_ZERO(&read_list); FD_SET(socket, &read_list);
223 FD_ZERO(&write_list); FD_SET(socket, &write_list);
224 FD_ZERO(&exceptions); FD_SET(socket, &exceptions);
226 timeval base_time_out;
227 time_stamp::fill_timeval_ms(base_time_out, timeout);
228 // timeval has tv_sec=seconds, tv_usec=microseconds.
229 //#if !defined(__GNU_WINDOWS__)
230 timeval *time_out = &base_time_out;
232 #elif defined(__GNU_WINDOWS__)
233 __ms_timeval win_time_out;
234 win_time_out.tv_sec = base_time_out.tv_sec;
235 win_time_out.tv_usec = base_time_out.tv_usec;
236 __ms_timeval *time_out = &win_time_out;
240 // select will tell us about the socket.
241 int ret = ::select(socket + 1,
242 (mode & SELECTING_JUST_WRITE)? NULL_POINTER : &read_list,
243 (mode & SELECTING_JUST_READ)? NULL_POINTER : &write_list,
244 &exceptions, time_out);
245 int error = critical_events::system_error();
246 if (!ret) return 0; // nothing to report.
248 if (ret == SOCKET_ERROR) {
250 // all real errors fall out to the error handling stuff.
251 case SOCK_EFAULT: // intentional fall-through.
252 case SOCK_ENETDOWN: // intentional fall-through.
253 case SOCK_EINVAL: // intentional fall-through.
254 case SOCK_EINTR: // intentional fall-through.
256 case SOCK_NOTINITIALISED: // intentional fall-through.
261 // hopefully all these others are bogus errors...
262 case SOCK_EINPROGRESS: // intentional fall-through.
263 case 0: // intentional fall-through.
265 #ifdef DEBUG_RAW_SOCKET
266 LOG("got to weird case, in progress or zero.");
268 return 0; // not really an error.
270 #ifdef DEBUG_RAW_SOCKET
271 LOG(a_sprintf("socket %u had error %d in select: %s.",
272 socket, error, _stack->tcpip_error_name(error).s()));
277 // if we got to here, then there are some things to report...
281 int raw_socket::test_readability(basis::un_int socket) const
283 FUNCDEF("test_readability");
285 if (negative(ioctl(socket, IOCTL_READ, &len))) {
286 LOG(astring(astring::SPRINTF, "socket %u had ioctl error: %s.",
287 socket, _stack->tcpip_error_name(critical_events::system_error()).s()));
290 if (positive(len)) return SI_READABLE;
291 else return SI_DISCONNECTED;
295 int raw_socket::analyze_select_result(basis::un_int socket, int mode,
296 fd_set_wrapper &read_list, fd_set_wrapper &write_list,
297 fd_set_wrapper &exceptions) const
299 #ifdef DEBUG_RAW_SOCKET
300 FUNCDEF("analyze_select_result");
304 // in case of an exception, we return an error.
305 if (FD_ISSET(socket, &exceptions)) {
306 #ifdef DEBUG_RAW_SOCKET
307 LOG(astring(astring::SPRINTF, "exception seen for socket %u!", socket));
311 // check to see if there are bytes to read.
312 if ( ! (mode & SELECTING_JUST_WRITE) && FD_ISSET(socket, &read_list)) {
313 // make sure we have data. if no data is available, it means a
314 // disconnect occurred.
316 int readable = test_readability(socket);
317 if (readable == SI_ERRONEOUS)
318 to_return |= SI_ERRONEOUS;
319 else if (readable == SI_READABLE)
320 to_return |= SI_READABLE;
321 else if (readable == SI_DISCONNECTED) {
322 // we need to check multiple times to be sure the OS really means this.
323 // either windoze seems to report an erroneous disconnect every few
324 // days or there's a bad synchronization issue as yet uncovered.
325 bool really_disconnected = true;
326 for (int i = 0; i < MULTIPLE_DISCONNECT_CHECKS; i++) {
327 fd_set_wrapper read_list, write_list, exceps;
328 int temp_ret = inner_select(socket, SELECTING_JUST_READ, 0, read_list,
330 // check the return value first...
332 // nothing happening (a zero return) means the socket's no longer
333 // claiming to have a readable state; our disconnect condition is
334 // thus violated and we can leave.
335 really_disconnected = false;
338 if (temp_ret == SI_ERRONEOUS) {
339 // this, on the other hand, sounds really bad. the socket doesn't
340 // seem to exist any more or something else horrid happened.
341 really_disconnected = true;
344 // if the select worked, we can check the fd_set now for readability.
345 if (!FD_ISSET(socket, &read_list)) {
346 // we are not in a disconnected state without being told we're
347 // readable. supposedly.
348 really_disconnected = false;
351 // now we really test the socket for readability by making sure there
352 // really is data pending on the socket. if it's readable but there's
353 // no data, then either a disconnection has occurred or is in progress.
354 readable = test_readability(socket);
355 if (readable != SI_DISCONNECTED) {
356 // we are not disconnected if there's really data waiting.
357 really_disconnected = false;
361 if (really_disconnected) {
362 #ifdef DEBUG_RAW_SOCKET
363 LOG(a_sprintf("connection closed on socket %u.", socket));
365 to_return |= SI_DISCONNECTED;
370 // check writability state.
371 if (! (mode & SELECTING_JUST_READ) && FD_ISSET(socket, &write_list)) {
372 to_return |= SI_WRITABLE;
378 int raw_socket::select(int_array &read_sox, int_array &write_sox,
381 #ifdef DEBUG_RAW_SOCKET
382 FUNCDEF("select [multiple]");
384 if (!read_sox.length() && !write_sox.length())
385 return 0; // nothing happened to nothing.
387 int to_return = 0; // will get bits slammed into it to report results.
389 // setup the file descriptor sets for the select. we check readability,
390 // writability and exception status.
391 fd_set_wrapper read_list; FD_ZERO(&read_list);
392 fd_set_wrapper write_list; FD_ZERO(&write_list);
393 fd_set_wrapper exceptions; FD_ZERO(&exceptions);
394 // set up the lists with the sets we were handed.
395 basis::un_int highest = 0;
397 for (i = 0; i < read_sox.length(); i++) {
398 basis::un_int sock = (basis::un_int)read_sox[i];
399 if (sock > highest) highest = sock;
400 FD_SET(sock, &read_list);
402 for (i = 0; i < write_sox.length(); i++) {
403 basis::un_int sock = (basis::un_int)write_sox[i];
404 if (sock > highest) highest = sock;
405 FD_SET(sock, &write_list);
408 timeval base_time_out;
409 time_stamp::fill_timeval_ms(base_time_out, timeout);
410 // timeval has tv_sec=seconds, tv_usec=microseconds.
411 //#if !defined(__GNU_WINDOWS__)
412 timeval *time_out = &base_time_out;
413 /*#elif defined(__GNU_WINDOWS__)
414 __ms_timeval win_time_out;
415 win_time_out.tv_sec = base_time_out.tv_sec;
416 win_time_out.tv_usec = base_time_out.tv_usec;
417 __ms_timeval *time_out = &win_time_out;
421 // select will tell us about the socket.
422 int ret = ::select(highest + 1,
423 (read_sox.length())? &read_list : NULL_POINTER,
424 (write_sox.length())? &write_list : NULL_POINTER,
425 &exceptions, time_out);
426 int error = critical_events::system_error();
428 if (ret == SOCKET_ERROR) {
430 // all real errors fall out to the error handling stuff.
431 case SOCK_EFAULT: // intentional fall-through.
432 case SOCK_ENETDOWN: // intentional fall-through.
433 case SOCK_EINVAL: // intentional fall-through.
434 case SOCK_EINTR: // intentional fall-through.
436 case SOCK_NOTINITIALISED: // intentional fall-through.
441 // hopefully all these others are bogus errors...
442 case SOCK_EINPROGRESS: // intentional fall-through.
443 case 0: // intentional fall-through.
445 #ifdef DEBUG_RAW_SOCKET
446 LOG("got to weird case, in progress or zero.");
449 //hmmm: fix retd sox? what's this outcome mean for the list?
451 return 0; // not really an error.
453 #ifdef DEBUG_RAW_SOCKET
454 LOG(a_sprintf("sockets had error %d in select: %s.",
455 error, _stack->tcpip_error_name(error).s()));
458 //hmmm: fix retd sox? what's this outcome mean for the list?
462 // we know of nothing exciting for any of these.
465 return 0; // nothing to report.
468 // if we got to here, then there are some things to report...
469 // iterate through the lists and check results.
470 for (int k = 0; k < read_sox.length(); k++) {
471 basis::un_int socket = read_sox[k];
472 int interim = analyze_select_result(socket, SELECTING_JUST_READ, read_list,
473 write_list, exceptions);
475 // nothing happened on that guy.
477 k--; // skip back to before the whack.
480 to_return |= interim; // join the results with overall result.
482 for (int p = 0; p < write_sox.length(); p++) {
483 basis::un_int socket = write_sox[p];
484 int interim = analyze_select_result(socket, SELECTING_JUST_WRITE, read_list,
485 write_list, exceptions);
487 // nothing happened on that guy.
489 p--; // skip back to before the whack.
492 to_return |= interim; // join the results with overall result.