Plug plug;
void *private_ptr;
bufchain output_data;
+ int connected;
int writable;
int frozen; /* this causes readability notifications to be ignored */
int frozen_readable; /* this means we missed at least one readability
* notification while we were frozen */
+ int localhost_only; /* for listening sockets */
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) {
return ret;
}
+void sk_getaddr(SockAddr addr, char *buf, int buflen)
+{
+#ifdef IPV6
+ if (addr->family == AF_INET) {
+#endif
+ struct in_addr a;
+ a.s_addr = htonl(addr->address);
+ strncpy(buf, inet_ntoa(a), buflen);
+#ifdef IPV6
+ } else {
+ FIXME; /* I don't know how to get a text form of an IPv6 address. */
+ }
+#endif
+}
+
+int sk_addrtype(SockAddr addr)
+{
+ return (addr->family == AF_INET ? ADDRTYPE_IPV4 : ADDRTYPE_IPV6);
+}
+
+void sk_addrcopy(SockAddr addr, char *buf)
+{
+#ifdef IPV6
+ if (addr->family == AF_INET) {
+#endif
+ struct in_addr a;
+ a.s_addr = htonl(addr->address);
+ memcpy(buf, (char*) &a.s_addr, 4);
+#ifdef IPV6
+ } else {
+ memcpy(buf, (char*) addr->ai, 16);
+ }
+#endif
+}
+
void sk_addr_free(SockAddr addr)
{
sfree(addr);
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->sending_oob = 0;
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->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
- ret->writable = 1; /* to start with */
+ ret->connected = 0; /* to start with */
+ ret->writable = 0; /* to start with */
ret->sending_oob = 0;
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.
*/
a.sin_addr.s_addr = htonl(addr->address);
a.sin_port = htons((short) port);
}
+
+ /* Set up a select mechanism. This could be an AsyncSelect on a
+ * window, or an EventSelect on an event object. */
+ errstr = do_select(s, 1);
+ if (errstr) {
+ ret->error = errstr;
+ return (Socket) ret;
+ }
+
if ((
#ifdef IPV6
connect(s, ((addr->family == AF_INET6) ?
#endif
) == SOCKET_ERROR) {
err = WSAGetLastError();
- ret->error = winsock_error_string(err);
- return (Socket) ret;
- }
-
- /* Set up a select mechanism. This could be an AsyncSelect on a
- * window, or an EventSelect on an event object. */
- errstr = do_select(s, 1);
- if (errstr) {
- ret->error = errstr;
- return (Socket) ret;
+ /*
+ * We expect a potential EWOULDBLOCK here, because the
+ * chances are the front end has done a select for
+ * FD_CONNECT, so that connect() will complete
+ * asynchronously.
+ */
+ if ( err != WSAEWOULDBLOCK ) {
+ ret->error = winsock_error_string(err);
+ return (Socket) ret;
+ }
+ } else {
+ /*
+ * If we _don't_ get EWOULDBLOCK, the connect has completed
+ * and we should set the socket as writable.
+ */
+ ret->writable = 1;
}
add234(sktree, ret);
return (Socket) ret;
}
-Socket sk_newlistenner(int port, Plug plug)
+Socket sk_newlistener(int port, Plug plug, int local_host_only)
{
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->sending_oob = 0;
ret->frozen = 0;
ret->frozen_readable = 0;
+ ret->localhost_only = local_host_only;
+ ret->pending_error = 0;
/*
* Open socket.
if (addr->family == AF_INET6) {
memset(&a6, 0, sizeof(a6));
a6.sin6_family = AF_INET6;
-/*a6.sin6_addr = in6addr_any; *//* == 0 */
+ if (local_host_only)
+ a6.sin6_addr = in6addr_loopback;
+ else
+ a6.sin6_addr = in6addr_any;
a6.sin6_port = htons(port);
} else
#endif
{
a.sin_family = AF_INET;
- a.sin_addr.s_addr = htonl(INADDR_ANY);
+ if (local_host_only)
+ a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+ else
+ a.sin_addr.s_addr = htonl(INADDR_ANY);
a.sin_port = htons((short)port);
}
#ifdef IPV6
urgentflag = 0;
bufchain_prefix(&s->output_data, &data, &len);
}
-
nsent = send(s->s, data, len, urgentflag);
noise_ultralight(nsent);
if (nsent <= 0) {
err = (nsent < 0 ? WSAGetLastError() : 0);
- if ((err == 0 && nsent < 0) || err == WSAEWOULDBLOCK) {
+ if ((err < WSABASEERR && nsent < 0) || err == WSAEWOULDBLOCK) {
/*
* Perfectly normal: we've sent all we can for the moment.
*
- * (Apparently some WinSocks can return <0 but
- * leave no error indication - WSAGetLastError() is
- * called but returns zero - so we check that case
- * and treat it just like WSAEWOULDBLOCK.)
+ * (Some WinSock send() implementations can return
+ * <0 but leave no sensible error indication -
+ * WSAGetLastError() is called but returns zero or
+ * a small number - so we check that case and treat
+ * it just like WSAEWOULDBLOCK.)
*/
s->writable = FALSE;
return;
} else if (nsent == 0 ||
err == WSAECONNABORTED || err == WSAECONNRESET) {
/*
- * FIXME. This will have to be done better when we
- * start managing multiple sockets (e.g. SSH port
- * forwarding), because if we get CONNRESET while
- * trying to write a particular forwarded socket
- * then it isn't necessarily the end of the world.
- * Ideally I'd like to pass the error code back to
- * somewhere the next select_result() will see it,
- * but that might be hard. Perhaps I should pass it
- * back to be queued in the Windows front end bit.
+ * 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(winsock_error_string(err));
+ s->pending_error = err;
+ return;
} else {
- fatalbox(winsock_error_string(err));
+ /* We're inside the Windows frontend here, so we know
+ * that the frontend handle is unnecessary. */
+ logevent(NULL, winsock_error_string(err));
+ fatalbox("%s", winsock_error_string(err));
}
} else {
if (s->sending_oob) {
noise_ultralight(lParam);
switch (WSAGETSELECTEVENT(lParam)) {
+ case FD_CONNECT:
+ s->connected = s->writable = 1;
+ break;
case FD_READ:
/* In the case the socket is still frozen, we don't even bother */
if (s->frozen) {
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()));
+ /* We're inside the Windows frontend here, so we know
+ * that the frontend handle is unnecessary. */
+ logevent(NULL, str);
+ fatalbox("%s", str);
} else {
return plug_receive(s->plug, 2, buf, ret);
}
return open;
case FD_ACCEPT:
{
- struct sockaddr isa;
- int addrlen = sizeof(struct sockaddr);
- SOCKET t; /* socket of connection */
-
- memset(&isa, 0, sizeof(struct sockaddr));
- err = 0;
- t = accept(s->s,&isa,&addrlen);
- if (t == INVALID_SOCKET)
- {
- err = WSAGetLastError();
- if (err == WSATRY_AGAIN)
- break;
- }
-
- if (plug_accepting(s->plug, &isa, (void*)t)) {
- closesocket(t); // denied or error
- }
+ struct sockaddr_in isa;
+ int addrlen = sizeof(struct sockaddr_in);
+ SOCKET t; /* socket of connection */
+
+ memset(&isa, 0, sizeof(struct sockaddr_in));
+ err = 0;
+ t = accept(s->s,(struct sockaddr *)&isa,&addrlen);
+ if (t == INVALID_SOCKET)
+ {
+ err = WSAGetLastError();
+ if (err == WSATRY_AGAIN)
+ break;
+ }
+
+ if (s->localhost_only &&
+ ntohl(isa.sin_addr.s_addr) != INADDR_LOOPBACK) {
+ closesocket(t); /* dodgy WinSock let nonlocal through */
+ } else if (plug_accepting(s->plug, (void*)t)) {
+ closesocket(t); /* denied or error */
+ }
}
}
}
/*
+ * 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)
Actual_Socket s = index234(sktree, (*state)++);
return s ? s->s : INVALID_SOCKET;
}
+
+int net_service_lookup(char *service)
+{
+ struct servent *se;
+ se = getservbyname(service, NULL);
+ if (se != NULL)
+ return ntohs(se->s_port);
+ else
+ return 0;
+}
projects / u / mdw / putty / blobdiff