char oobdata[1];
int sending_oob;
int oobinline;
+ int pending_error; /* in case send() returns error */
};
/*
sktree = newtree234(cmpfortree);
}
+void sk_cleanup(void)
+{
+ Actual_Socket s;
+ int i;
+
+ if (sktree) {
+ for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
+ closesocket(s->s);
+ }
+ }
+}
+
char *winsock_error_string(int error)
{
switch (error) {
static void sk_tcp_close(Socket s);
static int sk_tcp_write(Socket s, char *data, int len);
static int sk_tcp_write_oob(Socket s, char *data, int len);
+static void sk_tcp_set_private_ptr(Socket s, void *ptr);
+static void *sk_tcp_get_private_ptr(Socket s);
+static void sk_tcp_set_frozen(Socket s, int is_frozen);
static char *sk_tcp_socket_error(Socket s);
extern char *do_select(SOCKET skt, int startup);
sk_tcp_write,
sk_tcp_write_oob,
sk_tcp_flush,
+ sk_tcp_set_private_ptr,
+ sk_tcp_get_private_ptr,
+ sk_tcp_set_frozen,
sk_tcp_socket_error
};
ret->frozen = 1;
ret->frozen_readable = 0;
ret->localhost_only = 0; /* unused, but best init anyway */
+ ret->pending_error = 0;
ret->s = (SOCKET)sock;
}
Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
- Plug plug)
+ int nodelay, Plug plug)
{
static struct socket_function_table fn_table = {
sk_tcp_plug,
sk_tcp_write,
sk_tcp_write_oob,
sk_tcp_flush,
+ sk_tcp_set_private_ptr,
+ sk_tcp_get_private_ptr,
+ sk_tcp_set_frozen,
sk_tcp_socket_error
};
ret->frozen = 0;
ret->frozen_readable = 0;
ret->localhost_only = 0; /* unused, but best init anyway */
+ ret->pending_error = 0;
/*
* Open socket.
setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (void *) &b, sizeof(b));
}
+ if (nodelay) {
+ BOOL b = TRUE;
+ setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (void *) &b, sizeof(b));
+ }
+
/*
* Bind to local address.
*/
sk_tcp_write,
sk_tcp_write_oob,
sk_tcp_flush,
+ sk_tcp_set_private_ptr,
+ sk_tcp_get_private_ptr,
+ sk_tcp_set_frozen,
sk_tcp_socket_error
};
ret->frozen = 0;
ret->frozen_readable = 0;
ret->localhost_only = local_host_only;
+ ret->pending_error = 0;
/*
* Open socket.
} else if (nsent == 0 ||
err == WSAECONNABORTED || err == WSAECONNRESET) {
/*
- * ASSUMPTION:
- *
- * I'm assuming here that if a TCP connection is
- * reset or aborted once established, we will be
- * notified by a select event rather than a
- * CONNABORTED or CONNRESET from send(). In other
- * words, I'm assuming CONNABORTED and CONNRESET
- * don't come back from a _nonblocking_ send(),
- * because the local side doesn't know they've
- * happened until it waits for a response to its
- * TCP segment - so the error will arrive
- * asynchronously.
- *
- * If I'm wrong, this will be a really nasty case,
- * because we can't necessarily call plug_closing()
- * without having to make half the SSH code
- * reentrant; so instead we'll have to schedule a
- * call to plug_closing() for some suitable future
- * time.
+ * If send() returns CONNABORTED or CONNRESET, we
+ * unfortunately can't just call plug_closing(),
+ * because it's quite likely that we're currently
+ * _in_ a call from the code we'd be calling back
+ * to, so we'd have to make half the SSH code
+ * reentrant. Instead we flag a pending error on
+ * the socket, to be dealt with (by calling
+ * plug_closing()) at some suitable future moment.
*/
- fatalbox("SERIOUS NETWORK INTERNAL ERROR: %s\n"
- "Please report this immediately to "
- "<putty@projects.tartarus.org>.",
- winsock_error_string(err));
+ s->pending_error = err;
+ return;
} else {
- fatalbox(winsock_error_string(err));
+ logevent(winsock_error_string(err));
+ fatalbox("%s", winsock_error_string(err));
}
} else {
if (s->sending_oob) {
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()));
+ char *str = (ret == 0 ? "Internal networking trouble" :
+ winsock_error_string(WSAGetLastError()));
+ logevent(str);
+ fatalbox("%s", str);
} else {
return plug_receive(s->plug, 2, buf, ret);
}
memset(&isa, 0, sizeof(struct sockaddr_in));
err = 0;
- t = accept(s->s,&isa,&addrlen);
+ t = accept(s->s,(struct sockaddr *)&isa,&addrlen);
if (t == INVALID_SOCKET)
{
err = WSAGetLastError();
}
/*
+ * Deal with socket errors detected in try_send().
+ */
+void net_pending_errors(void)
+{
+ int i;
+ Actual_Socket s;
+
+ /*
+ * This might be a fiddly business, because it's just possible
+ * that handling a pending error on one socket might cause
+ * others to be closed. (I can't think of any reason this might
+ * happen in current SSH implementation, but to maintain
+ * generality of this network layer I'll assume the worst.)
+ *
+ * So what we'll do is search the socket list for _one_ socket
+ * with a pending error, and then handle it, and then search
+ * the list again _from the beginning_. Repeat until we make a
+ * pass with no socket errors present. That way we are
+ * protected against the socket list changing under our feet.
+ */
+
+ do {
+ for (i = 0; (s = index234(sktree, i)) != NULL; i++) {
+ if (s->pending_error) {
+ /*
+ * An error has occurred on this socket. Pass it to the
+ * plug.
+ */
+ plug_closing(s->plug,
+ winsock_error_string(s->pending_error),
+ s->pending_error, 0);
+ break;
+ }
+ }
+ } while (s);
+}
+
+/*
* Each socket abstraction contains a `void *' private field in
* which the client can keep state.
*/
-void sk_set_private_ptr(Socket sock, void *ptr)
+static void sk_tcp_set_private_ptr(Socket sock, void *ptr)
{
Actual_Socket s = (Actual_Socket) sock;
s->private_ptr = ptr;
}
-void *sk_get_private_ptr(Socket sock)
+static void *sk_tcp_get_private_ptr(Socket sock)
{
Actual_Socket s = (Actual_Socket) sock;
return s->private_ptr;
return s->error;
}
-void sk_set_frozen(Socket sock, int is_frozen)
+static void sk_tcp_set_frozen(Socket sock, int is_frozen)
{
Actual_Socket s = (Actual_Socket) sock;
if (s->frozen == is_frozen)
projects / u / mdw / putty / blobdiff