void *private_ptr;
struct buffer *head, *tail;
int writable;
- int in_oob, sending_oob;
+ int sending_oob;
+ int oobinline;
};
struct SockAddr_tag {
sfree(addr);
}
-Socket sk_new(SockAddr addr, int port, int privport, sk_receiver_t receiver) {
+Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
+ sk_receiver_t receiver) {
SOCKET s;
#ifdef IPV6
SOCKADDR_IN6 a6;
ret->receiver = receiver;
ret->head = ret->tail = NULL;
ret->writable = 1; /* to start with */
- ret->in_oob = FALSE;
ret->sending_oob = 0;
/*
return ret;
}
+ ret->oobinline = oobinline;
+ if (oobinline) {
+ BOOL b = TRUE;
+ setsockopt (s, SOL_SOCKET, SO_OOBINLINE, (void *)&b, sizeof(b));
+ }
+
/*
* Bind to local address.
*/
}
int select_result(WPARAM wParam, LPARAM lParam) {
- int ret;
+ int ret, open;
DWORD err;
char buf[BUFFER_GRANULE];
Socket s;
return 1; /* boggle */
if ((err = WSAGETSELECTERROR(lParam)) != 0) {
- fatalbox(winsock_error_string(err));
+ /*
+ * An error has occurred on this socket. Pass it to the
+ * receiver function.
+ */
+ return s->receiver(s, 3, winsock_error_string(err), err);
}
noise_ultralight(lParam);
switch (WSAGETSELECTEVENT(lParam)) {
case FD_READ:
+ /*
+ * We have received data on the socket. For an oobinline
+ * socket, this might be data _before_ an urgent pointer,
+ * in which case we send it to the back end with type==1
+ * (data prior to urgent).
+ */
+ if (s->oobinline) {
+ atmark = 1;
+ ioctlsocket(s->s, SIOCATMARK, &atmark);
+ /*
+ * Avoid checking the return value from ioctlsocket(),
+ * on the grounds that some WinSock wrappers don't
+ * support it. If it does nothing, we get atmark==1,
+ * which is equivalent to `no OOB pending', so the
+ * effect will be to non-OOB-ify any OOB data.
+ */
+ } else
+ atmark = 1;
+
ret = recv(s->s, buf, sizeof(buf), 0);
+ noise_ultralight(ret);
if (ret < 0) {
err = WSAGetLastError();
if (err == WSAEWOULDBLOCK) {
}
}
if (ret < 0) {
- fatalbox(winsock_error_string(err));
+ return s->receiver(s, 3, winsock_error_string(err), err);
} else {
- int type = s->in_oob ? 2 : 0;
- s->in_oob = FALSE;
- return s->receiver(s, type, buf, ret);
+ return s->receiver(s, atmark ? 0 : 1, buf, ret);
}
break;
case FD_OOB:
- /*
- * Read all data up to the OOB marker, and send it to the
- * receiver with urgent==1 (OOB pending).
- */
- atmark = 1;
- s->in_oob = TRUE;
- /* Some WinSock wrappers don't support this call, so we
- * deliberately don't check the return value. If the call
- * fails and does nothing, we will get back atmark==1,
- * which is good enough to keep going at least. */
- ioctlsocket(s->s, SIOCATMARK, &atmark);
+ /*
+ * This will only happen on a non-oobinline socket. It
+ * indicates that we can immediately perform an OOB read
+ * and get back OOB data, which we will send to the back
+ * end with type==2 (urgent data).
+ */
ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
noise_ultralight(ret);
if (ret <= 0) {
fatalbox(ret == 0 ? "Internal networking trouble" :
winsock_error_string(WSAGetLastError()));
} else {
- return s->receiver(s, atmark ? 2 : 1, buf, ret);
+ return s->receiver(s, 2, buf, ret);
}
break;
case FD_WRITE:
try_send(s);
break;
case FD_CLOSE:
- /* Signal a close on the socket. */
- return s->receiver(s, 0, NULL, 0);
- break;
+ /* Signal a close on the socket. First read any outstanding data. */
+ open = 1;
+ do {
+ ret = recv(s->s, buf, sizeof(buf), 0);
+ if (ret < 0) {
+ err = WSAGetLastError();
+ if (err == WSAEWOULDBLOCK)
+ break;
+ return s->receiver(s, 3, winsock_error_string(err), err);
+ } else
+ open &= s->receiver(s, 0, buf, ret);
+ } while (ret > 0);
+ return open;
}
return 1;