Merge branch 'master' of feistymeow.org:feisty_meow
[feisty_meow.git] / octopi / library / sockets / spocket.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : spocket                                                           *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 2001-$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 "internet_address.h"
16 #include "raw_socket.h"
17 #include "spocket.h"
18 #include "tcpip_stack.h"
19
20 #include <basis/byte_array.h>
21 #include <basis/functions.h>
22 #include <basis/astring.h>
23 #include <basis/mutex.h>
24 #include <loggers/critical_events.h>
25 #include <loggers/program_wide_logger.h>
26 #include <structures/static_memory_gremlin.h>
27 #include <timely/time_control.h>
28 #include <timely/time_stamp.h>
29
30 #ifdef __UNIX__
31   #include <arpa/inet.h>
32   #include <errno.h>
33   #include <netdb.h>
34   #include <signal.h>
35   #include <string.h>
36   #include <sys/ioctl.h>
37   #include <sys/socket.h>
38   #include <sys/types.h>
39   #include <termios.h>
40   #include <unistd.h>
41 #endif
42
43 using namespace basis;
44 using namespace loggers;
45 using namespace structures;
46 using namespace timely;
47
48 namespace sockets {
49
50 //#define DEBUG_SPOCKET
51   // uncomment for noisy version.
52
53 #undef LOG
54 #define LOG(to_print) CLASS_EMERGENCY_LOG(program_wide_logger::get(), to_print)
55
56 const int PENDING_CONNECTIONS_ALLOWED = 14;
57   // we allow this many connections to queue up before they get rejected.
58   // if the OS is windoze, this number is ignored if it's greater than the
59   // hardcoded maximum of like 5.
60
61 const int RESOLVE_INTERVAL = 300;
62   // we'll re-resolve the ip address at this rate.  this mainly comes into
63   // play for the connect call, since the address passed in could have changed
64   // or been invalid to start with.  we're not losing much by trying to
65   // resolve the address again during connection time.
66
67 #define RECOGNIZE_DISCO \
68   _client_bind = false; \
69   _was_connected = false
70
71 // ensure that the socket is in a good state.
72 #define ENSURE_HEALTH(retval) \
73   if (!was_connected()) return retval;  /* never has been. */ \
74   if (!_socket) { RECOGNIZE_DISCO; return retval; /* not set. */ }
75
76 #define CHECK_BOGUS(retval) \
77   if (is_bogus()) { return retval;  /* this spocket is junk. */ }
78
79 #undef GRAB_LOCK
80 #ifdef __WIN32__
81   // win32 seems to trip over selects unless we protect them.
82   #define GRAB_LOCK auto_synchronizer l(*_select_lock)
83     // and in truth, the locking turns out to be needed on win32 if we're
84     // going to allow sharing a spocket across threads.  this is one of the
85     // design goals so we're honor bound to support that.
86 #else
87   #define GRAB_LOCK 
88 #endif
89
90 #ifdef __UNIX__
91   SAFE_STATIC(mutex, __broken_pipe_synch, )
92 #endif
93
94 spocket::spocket(const internet_address &where, sock_types type)
95 : _type(type),
96   _socket(0),
97   _server_socket(0),
98   _was_connected(false),
99   _client(false),
100   _where(new internet_address(where)),
101   _remote(new internet_address),
102   _socks(new raw_socket),
103   _stack(new tcpip_stack),
104   _select_lock(new mutex),
105   _last_resolve(new time_stamp),  // don't force an immediate resolve.
106   _client_bind(false),
107   _cli_bind(new internet_address)
108 {
109   FUNCDEF("constructor");
110   if ( (_type == BROADCAST) || (_type == UNICAST) ) {
111     // casting types are never servers.
112     _client = true;
113   } else if ( (type == CONNECTED) || (type == BOGUS_SOCK) ) {
114     // nothing special here currently.
115   } else {
116     // this is an unknown type.
117     LOG(a_sprintf("unknown socket type %d; failing out.", _type));
118 //hmmm: without a validity flag of some sort, this doesn't mean much.
119     return;
120   }
121 }
122
123 spocket::~spocket()
124 {
125   FUNCDEF("destructor");
126 #ifdef DEBUG_SPOCKET
127   LOG(a_sprintf("closing spocket: ") + text_form());
128 #endif
129   disconnect();
130   WHACK(_where);
131   WHACK(_socks);
132   WHACK(_stack);
133   WHACK(_remote);
134   WHACK(_select_lock);
135   WHACK(_last_resolve);
136   WHACK(_cli_bind);
137   _client_bind = false;
138 }
139
140 // where and remote don't need to be protected unless we revise the design of
141 // the class and allow a reset or re-open kind of method.
142 const internet_address &spocket::where() const { return *_where; }
143 const internet_address &spocket::remote() const { return *_remote; }
144
145 tcpip_stack &spocket::stack() const { return *_stack; }
146
147 // doesn't need to be protected since the sockets are being treated as simple
148 // ints and since _where currently does not get destroyed.
149 astring spocket::text_form()
150 {
151   FUNCDEF("text_form");
152   astring to_return = is_client()? "client" :
153       (is_root_server()? "root-server" : "server");
154   to_return += " spocket: ";
155   if (connected()) {
156     to_return += "connected, ";
157   } else {
158     if (was_connected()) to_return += "unconnected (was once), ";
159     else to_return += "never-connected, ";
160   }
161   to_return += a_sprintf("socket=%u, ", _socket);
162   if (is_root_server()) {
163     to_return += a_sprintf("root-socket=%u, ", _server_socket);
164   }
165   to_return += _where->text_form().s();
166   return to_return;
167 }
168
169 void spocket::bind_client(const internet_address &addr)
170 {
171   _client_bind = true;
172   *_cli_bind = addr;
173 }
174
175 const char *spocket::outcome_name(const outcome &to_name)
176 {
177   switch (to_name.value()) {
178     case NOT_SERVER: return "NOT_SERVER";
179     default: return communication_commons::outcome_name(to_name);
180   }
181 }
182
183 outcome spocket::disconnect()
184 {
185   FUNCDEF("disconnect");
186   RECOGNIZE_DISCO; 
187   if (_socket) {
188 #ifdef DEBUG_SPOCKET
189     LOG(a_sprintf("closing socket %d", _socket));
190 #endif
191     _socks->close(_socket);
192     _socket = 0;
193   }
194   if (_server_socket) {
195 #ifdef DEBUG_SPOCKET
196     LOG(a_sprintf("closing server socket %d", _server_socket));
197 #endif
198     _socks->close(_server_socket);
199     _server_socket = 0;
200   }
201   return OKAY;
202 }
203
204 bool spocket::connected()
205 {
206   FUNCDEF("connected");
207   ENSURE_HEALTH(false);
208
209   if (_type != CONNECTED) return was_connected();
210
211   if (!_socket) return false;
212
213   // do examination on spocket.
214   int sel_mode = 0;
215   GRAB_LOCK;
216
217   try {
218     int ret = _socks->select(_socket, sel_mode);
219     if (ret == 0) {
220       return true;  // we are happy.
221     }
222     if ( (ret & SI_DISCONNECTED) || (ret & SI_ERRONEOUS) ) {
223       RECOGNIZE_DISCO; 
224       return false;
225     }
226     return true;
227   } catch (...) {
228     LOG("caught exception thrown from select, returning false.");
229     return false;
230   }
231 }
232
233 outcome spocket::await_readable(int timeout)
234 {
235   FUNCDEF("await_readable");
236   CHECK_BOGUS(NO_CONNECTION);
237   ENSURE_HEALTH(NO_CONNECTION);
238   GRAB_LOCK;
239   int mode = raw_socket::SELECTING_JUST_READ;
240   int ret = _socks->select(_socket, mode, timeout);
241   if (ret & SI_READABLE) return OKAY;
242     // we found something to report.
243   if (ret & SI_DISCONNECTED) {
244     RECOGNIZE_DISCO; 
245     return NO_CONNECTION;
246   }
247   return _socket? NONE_READY : NO_CONNECTION;
248     // nothing is ready currently.
249 }
250
251 outcome spocket::await_writable(int timeout)
252 {
253   FUNCDEF("await_writable");
254   CHECK_BOGUS(NO_CONNECTION);
255   ENSURE_HEALTH(NO_CONNECTION);
256   GRAB_LOCK;
257   int mode = raw_socket::SELECTING_JUST_WRITE;
258   int ret = _socks->select(_socket, mode, timeout);
259   if (ret & SI_WRITABLE) return OKAY;
260     // we found something to report.
261   if (ret & SI_DISCONNECTED) {
262     RECOGNIZE_DISCO; 
263     return NO_CONNECTION;
264   }
265   return _socket? NONE_READY : NO_CONNECTION;
266     // nothing is ready currently.
267 }
268
269 outcome spocket::connect(int communication_wait)
270 {
271   FUNCDEF("connect");
272   CHECK_BOGUS(NO_CONNECTION);
273   {
274     GRAB_LOCK;  // short lock.
275     if ( (was_connected() && !_client) || _server_socket) {
276 #ifdef DEBUG_SPOCKET
277       LOG("this object was already opened as a server!");
278 #endif
279       return BAD_INPUT;
280     }
281     _client = true;  // set our state now that we're sure this is okay.
282     _was_connected = false;  // reset this, since we're connecting now.
283   }
284
285   if (!_socket) {
286     // the socket was never created (or was cleaned up previously).  this is
287     // where we create the socket so we can communicate.
288 #ifdef DEBUG_SPOCKET
289     LOG(astring("creating socket now for ") + _where->text_form());
290 #endif
291     GRAB_LOCK;
292     int sock_type = SOCK_STREAM;
293     int proto = IPPROTO_TCP;
294
295     if ( (_type == BROADCAST) || (_type == UNICAST) ) {
296       sock_type = SOCK_DGRAM;
297       proto = IPPROTO_IP;
298     }
299     _socket = int(::socket(AF_INET, sock_type, proto));
300     if ( (_socket == basis::un_int(INVALID_SOCKET)) || !_socket) {
301       _socket = 0;
302       LOG("Failed to open the client's connecting spocket.");
303       return ACCESS_DENIED;
304     }
305
306     // mark the spocket for _blocking_ I/O.  we want connect to sit there
307     // until it's connected or returns with an error.
308     _socks->set_non_blocking(_socket, false);
309
310     if (_type == BROADCAST) {
311       if (!_socks->set_broadcast(_socket)) return ACCESS_DENIED;
312         // mark the socket for broadcast capability.
313     }
314
315     if (!_socks->set_reuse_address(_socket)) return ACCESS_DENIED;
316       // mark the socket so we don't get bind errors on in-use conditions.
317   }
318
319   if (_type == CONNECTED) {
320     GRAB_LOCK;
321     // turn on the keepalive timer so that loss of the connection will
322     // eventually be detected by the OS.  the duration that is allowed to
323     // elapse before a dead connection is noticed varies with the operating
324     // system and is not configured at this level.
325     if (!_socks->set_keep_alive(_socket)) {
326 #ifdef DEBUG_SPOCKET
327       LOG("couldn't set watchdog timer on socket.");
328 #endif
329     }
330
331 //hmmm: doesn't this need to be done for bcast too?
332
333     // create the spocket address that we will connect to.
334     if (strlen(_where->hostname)
335 //        && (_where->is_nil_address() 
336 //            || (*_last_resolve < time_stamp(-RESOLVE_INTERVAL) ) ) ) {
337 //
338 //moving to always re-resolving before a connect.  otherwise we have somewhat
339 //hard to predict behavior about when the re-resolve will happen.
340           ) {
341       // we know we need to resolve if the address is NULL_POINTER or if the re-resolve
342       // interval has elapsed.
343       astring full_host;
344       byte_array ip_addr = _stack->full_resolve(_where->hostname, full_host);
345       if (ip_addr.length()) {
346         ip_addr.stuff(internet_address::ADDRESS_SIZE, _where->ip_address);
347         LOG(astring("successfully re-resolved address--") + _where->text_form());
348       }
349       *_last_resolve = time_stamp();  // reset since we just resolved.
350     }
351
352     // special code for forcing a client to bind.
353     if (_client_bind) {
354       sockaddr sock = _stack->convert(*_cli_bind);
355
356 #ifdef DEBUG_SPOCKET
357       LOG(a_sprintf("binding client socket %d to ", _socket)
358           + inet_ntoa(((sockaddr_in *)&sock)->sin_addr));
359 #endif
360
361       // now, the socket address is bound to our socket.
362       if (negative(bind(_socket, &sock, sizeof(sock)))) {
363         LOG(a_sprintf("error binding socket %d to ", _socket)
364             + inet_ntoa(((sockaddr_in *)&sock)->sin_addr));
365       }
366     }
367
368   } else if ( (_type == BROADCAST) || (_type == UNICAST) ) {
369     // this is the last piece of preparation for a broadcast or unicast socket.
370     // there's no real connection, so we just need to get it bound and ready
371     // to fling packets.
372     GRAB_LOCK;
373     sockaddr sock = _stack->convert(*_where);
374
375 #ifdef DEBUG_SPOCKET
376     LOG(a_sprintf("binding socket %d to ", _socket)
377         + inet_ntoa(((sockaddr_in *)&sock)->sin_addr));
378 #endif
379
380     // now, the socket address is bound to our socket.
381     if (negative(bind(_socket, &sock, sizeof(sock)))) {
382       LOG(a_sprintf("error binding socket %d to ", _socket)
383           + inet_ntoa(((sockaddr_in *)&sock)->sin_addr));
384     }
385
386     // that's it for broadcast preparation.  we should be ready.
387     _was_connected = true;
388     return OKAY;
389   }
390
391   // the following is for connected mode only.
392
393   sockaddr sock = _stack->convert(*_where);
394
395   // attempt the connection now.
396
397 //hmmm: error returns are done differently on bsd, right?
398 //hmmm: perhaps hide the base connect in a func that sets our internal
399 //      error variable and then allows comparison to enums we provide.
400
401   time_stamp abort_time(communication_wait);
402
403   bool connected = false;  // did we connect.
404
405   int sock_len = sizeof(sock);
406
407   while (time_stamp() < abort_time) {
408     // make the low-level socket connection.
409     int ret = ::connect(_socket, &sock, sock_len);
410     if (ret != SOCKET_ERROR) {
411       connected = true;
412       _socks->set_non_blocking(_socket, true);
413       break;
414     }
415
416     basis::un_int last_error = critical_events::system_error();
417
418     // if we're already done, then make this look like a normal connect.
419     if (last_error == SOCK_EISCONN) {
420       connected = true;
421       break;
422     }
423
424     if ( (last_error != SOCK_EWOULDBLOCK)
425         && (last_error != SOCK_EINPROGRESS) ) {
426       // this seems like a real error here.
427 #ifdef DEBUG_SPOCKET
428       LOG(a_sprintf("Connect failed (error %s or %d) on address:",
429           critical_events::system_error_text(last_error).s(), last_error)
430           + _where->text_form());
431 #endif
432       if (last_error == SOCK_ECONNREFUSED) return NO_ANSWER;
433 //hmmm: fix more of the possibilities to be sensible outcomes?
434       return ACCESS_DENIED;
435     }
436
437     if (time_stamp() >= abort_time) break;  // skip before sleeping if T.O.
438
439     // snooze for a bit before trying again.
440     time_control::sleep_ms(10);
441   }
442
443   if (connected) {
444 #ifdef DEBUG_SPOCKET
445     LOG(a_sprintf("socket %d connected to server.", _socket));
446 #endif
447     GRAB_LOCK;  // short lock.
448     _was_connected = true;
449     return OKAY;
450   }
451
452   return TIMED_OUT;
453 }
454
455 outcome spocket::accept(spocket * &sock, bool wait)
456 {
457   FUNCDEF("accept");
458   CHECK_BOGUS(NO_CONNECTION);
459   if (_type != CONNECTED) return BAD_INPUT;
460
461   // we don't lock in here; we should not be locking on the server socket.
462
463   sock = NULL_POINTER;  // reset.
464
465   if (_socket) {
466 #ifdef DEBUG_SPOCKET
467     LOG("tried to accept on a client spocket.");
468 #endif
469     return NOT_SERVER;
470   }
471   _client = false;
472
473   if (!_server_socket) {
474     _server_socket = int(::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
475 #ifdef DEBUG_SPOCKET
476     LOG(a_sprintf("srv sock is %d", _server_socket));
477     LOG(astring("creating server socket now for ") + _where->text_form());
478 #endif
479
480     if (_server_socket == basis::un_int(INVALID_SOCKET)) {
481       LOG("Failed to open the serving spocket.");
482       return BAD_INPUT;
483     }
484
485     // mark the socket so we don't get bind errors on in-use conditions.
486     if (!_socks->set_reuse_address(_server_socket)) 
487       LOG("Failed to mark the socket for re-use.");
488
489     // create the spocket address for where we exist.
490     sockaddr sock = _stack->convert(*_where);
491
492     // now, the spocket address is bound to our spocket.
493     int sock_len = sizeof(sock);
494     if (bind(_server_socket, (sockaddr *)&sock, sock_len) < 0) {
495       LOG(astring("Error on bind of ") + critical_events::system_error_text(critical_events::system_error()));
496       _socks->close(_server_socket);
497       return ACCESS_DENIED;
498     }
499
500     // now listen for a connection on our spocket.
501     if (listen(_server_socket, PENDING_CONNECTIONS_ALLOWED) < 0) {
502       LOG(astring("Listen failed with error of ")
503           + critical_events::system_error_text(critical_events::system_error()));
504       _socks->close(_server_socket);
505       return ACCESS_DENIED;
506     }
507   }
508
509   // do the kind of accept they want; either block on it or don't.
510   // since our server socket is never used for sends or receives, we pretty
511   // much control it completely and this is safe.
512   if (!wait) {
513     _socks->set_non_blocking(_server_socket, true);
514       // mark our socket as non-blocking so we don't get stuck in accepts.
515   } else {
516     _socks->set_non_blocking(_server_socket, false);
517       // mark our socket as blocking; we will be paused until accept occurs.
518   }
519
520   // now try accepting a connection on the spocket.
521   sockaddr new_sock;
522   socklen_t sock_len = sizeof(new_sock);
523   basis::un_int accepted = int(::accept(_server_socket, &new_sock, &sock_len));
524   int error = critical_events::system_error();
525   if (!accepted || (accepted == INVALID_SOCKET)) {
526     if (error == SOCK_EWOULDBLOCK) return NO_CONNECTION;
527 #ifdef DEBUG_SPOCKET
528     LOG(astring("Accept got no client, with an error of ")
529         + critical_events::system_error_text(error));
530 #endif
531     return ACCESS_DENIED;
532   }
533
534   // mark the new spocket for non-blocking I/O.
535   _socks->set_non_blocking(accepted, true);
536
537 //move to socks object!
538   int sock_hop = 1;
539   if (setsockopt(accepted, SOL_SOCKET, SO_KEEPALIVE, (char *)&sock_hop,
540       sizeof(sock_hop)) < 0) {
541 #ifdef DEBUG_SPOCKET
542     LOG("couldn't set watchdog timer on socket.");
543 #endif
544   }
545
546 #ifdef DEBUG_SPOCKET
547   LOG(astring("accepted a client on our socket: ") + _where->text_form());
548 #endif
549
550 // NOTE: normally, our network code sets the spocket to be kept alive (using
551 //       keep alives), but we are trying to have a minimal spocket usage and
552 //       a minimal network load for this test scenario.
553
554   // create the spocket address that we will connect to.
555   sock = new spocket(*_where);
556   *sock->_remote = _stack->convert(new_sock);
557   sock->_socket = accepted;
558   sock->_server_socket = 0;  // reset to avoid whacking.
559   sock->_was_connected = true;
560   return OKAY;
561 }
562
563 outcome spocket::send(const byte_array &to_send, int &len_sent)
564 {
565   return send(to_send.observe(), to_send.length(), len_sent);
566 }
567
568 outcome spocket::send(const abyte *buffer, int size, int &len_sent)
569 {
570   FUNCDEF("send");
571   CHECK_BOGUS(OKAY);
572   if (_type != CONNECTED) return BAD_INPUT;
573   GRAB_LOCK;
574   ENSURE_HEALTH(NO_CONNECTION);
575
576   len_sent = ::send(_socket, (char *)buffer, size, 0);
577   int error_code = critical_events::system_error();
578   if (!len_sent) {
579 #ifdef DEBUG_SPOCKET
580     LOG("No data went out on the spocket.");
581 #endif
582     return PARTIAL;
583   }
584   if (len_sent == SOCKET_ERROR) {
585     if (error_code == SOCK_EWOULDBLOCK) {
586 #ifdef DEBUG_SPOCKET
587       LOG("would block, will try later...");
588       if (len_sent > 0)
589         LOG("HEY HEY!  some was sent but we were not counting it!!!");
590 #endif
591       return NONE_READY;
592     }
593 #ifdef DEBUG_SPOCKET
594     LOG(astring("Error ") + critical_events::system_error_text(error_code)
595         + " occurred during the send!");
596 #endif
597     if (!connected()) return NO_CONNECTION;
598 #ifdef DEBUG_SPOCKET
599     LOG(a_sprintf("forcing disconnect on socket %d.", _socket));
600 #endif
601     // we're trying this new approach here...  we found that the socket doesn't
602     // really know that it got disconnected in some circumstances.
603     disconnect();
604     return ACCESS_DENIED;
605   }
606   if (len_sent != size) {
607     // only sent part of the buffer.
608 #ifdef DEBUG_SPOCKET
609     LOG(a_sprintf("sent %d bytes out of %d.", len_sent, size));
610 #endif
611     return PARTIAL;
612   }
613
614   return OKAY;
615 }
616
617 outcome spocket::send_to(const internet_address &where_to,
618     const byte_array &to_send, int &len_sent)
619 {
620   return send_to(where_to, to_send.observe(), to_send.length(), len_sent);
621 }
622
623 outcome spocket::send_to(const internet_address &where_to, const abyte *to_send,
624     int size, int &len_sent)
625 {
626   FUNCDEF("send_to");
627   CHECK_BOGUS(OKAY);
628   if (_type == CONNECTED) return BAD_INPUT;
629   sockaddr dest = _stack->convert(where_to);
630   int ret = sendto(_socket, (char *)to_send, size, 0, &dest, sizeof(dest));
631   int error = critical_events::system_error();
632   if (ret < 0) {
633     if (error == SOCK_EWOULDBLOCK) return NONE_READY;  // no buffer space?
634     LOG(astring("failed to send packet; error ")
635         + _stack->tcpip_error_name(error));
636     return ACCESS_DENIED;
637   }
638   if (ret != size) {
639     LOG(astring("didn't send whole datagram!"));
640   }
641   len_sent = ret;
642   return OKAY;
643 }
644
645 outcome spocket::receive(byte_array &buffer, int &size)
646 {
647   FUNCDEF("receive");
648   CHECK_BOGUS(NONE_READY);
649   if (_type != CONNECTED) return BAD_INPUT;
650   if (size <= 0) return BAD_INPUT;
651   buffer.reset(size);
652   outcome to_return = receive(buffer.access(), size);
653   // trim the buffer to the actual received size.
654   if (to_return == OKAY)
655     buffer.zap(size, buffer.last());
656   return to_return;
657 }
658
659 outcome spocket::receive(abyte *buffer, int &size)
660 {
661   FUNCDEF("receive");
662   CHECK_BOGUS(NONE_READY);
663   if (_type != CONNECTED) return BAD_INPUT;
664   ENSURE_HEALTH(NO_CONNECTION);
665   int expected = size;
666   size = 0;
667   if (expected <= 0) return BAD_INPUT;
668   GRAB_LOCK;
669   int len = recv(_socket, (char *)buffer, expected, 0);
670   if (!len) {
671     // check to make sure we're not disconnected.
672     int ret = _socks->select(_socket, raw_socket::SELECTING_JUST_READ);
673     if (ret & SI_DISCONNECTED) {
674       RECOGNIZE_DISCO; 
675       return NO_CONNECTION;
676     }
677     // seems like more normal absence of data.
678     return NONE_READY;
679   } else if (len < 0) {
680     if (critical_events::system_error() == SOCK_EWOULDBLOCK) return NONE_READY;
681 #ifdef DEBUG_SPOCKET
682     LOG(astring("The receive failed with an error ")
683         + critical_events::system_error_text(critical_events::system_error()));
684 #endif
685     if (!connected()) return NO_CONNECTION;
686     return ACCESS_DENIED;
687   }
688   size = len;
689   return OKAY;
690 }
691
692 outcome spocket::receive_from(byte_array &buffer, int &size,
693     internet_address &where_from)
694 {
695   FUNCDEF("receive_from");
696   where_from = internet_address();
697   CHECK_BOGUS(NONE_READY);
698   if (_type == CONNECTED) return BAD_INPUT;
699   if (size <= 0) return BAD_INPUT;
700   buffer.reset(size);
701   outcome to_return = receive_from(buffer.access(), size, where_from);
702   // trim the buffer to the actual received size.
703   if (to_return == OKAY)
704     buffer.zap(size, buffer.last());
705   return to_return;
706 }
707
708 outcome spocket::receive_from(abyte *buffer, int &size,
709     internet_address &where_from)
710 {
711   FUNCDEF("receive_from");
712   where_from = internet_address();
713   CHECK_BOGUS(NONE_READY);
714   if (_type == CONNECTED) return BAD_INPUT;
715   ENSURE_HEALTH(NO_CONNECTION);
716   int expected = size;
717   size = 0;
718   if (expected <= 0) return BAD_INPUT;
719   GRAB_LOCK;
720   sockaddr from;
721   socklen_t fromlen = sizeof(from);
722   int len = recvfrom(_socket, (char *)buffer, expected, 0, &from, &fromlen);
723   int err = critical_events::system_error();
724   if (!len) return NONE_READY;
725   else if (len < 0) {
726 #ifdef DEBUG_SPOCKET
727     LOG(a_sprintf("actual sys err value=%d", err));
728 #endif
729     if (err == SOCK_EWOULDBLOCK) return NONE_READY;
730     if (err == SOCK_ECONNRESET) return NONE_READY;
731       // this seems to be a necessary windoze kludge; we're not connected
732       // and never were but it says this idiotic garbage about the connection
733       // being reset.
734 #ifdef DEBUG_SPOCKET
735     LOG(astring("The recvfrom failed with an error ")
736         + critical_events::system_error_text(err));
737 #endif
738     if (!connected()) return NO_CONNECTION;
739     return ACCESS_DENIED;
740   }
741   where_from = _stack->convert(from);
742   size = len;
743   return OKAY;
744 }
745
746 } //namespace.
747