#include "network.h"
#include "tree234.h"
+#define ipv4_is_loopback(addr) \
+ ((ntohl(addr.s_addr) & 0xFF000000L) == 0x7F000000L)
+
struct Socket_tag {
struct socket_function_table *fn;
/* the above variable absolutely *must* be the first in this structure */
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) {
#endif
}
+int sk_hostname_is_local(char *name)
+{
+ return !strcmp(name, "localhost");
+}
+
+int sk_address_is_local(SockAddr addr)
+{
+#ifdef IPV6
+ if (addr->family == AF_INET) {
+#endif
+ struct in_addr a;
+ a.s_addr = htonl(addr->address);
+ return ipv4_is_loopback(a);
+#ifdef IPV6
+ } else {
+ FIXME; /* someone who can compile for IPV6 had better do this bit */
+ }
+#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
};
}
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
};
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.
*/
return (Socket) ret;
}
-Socket sk_newlistener(int port, Plug plug, int local_host_only)
+Socket sk_newlistener(char *srcaddr, 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
};
if (addr->family == AF_INET6) {
memset(&a6, 0, sizeof(a6));
a6.sin6_family = AF_INET6;
+ /* FIXME: srcaddr is ignored for IPv6, because I (SGT) don't
+ * know how to do it. :-) */
if (local_host_only)
a6.sin6_addr = in6addr_loopback;
else
} else
#endif
{
+ int got_addr = 0;
a.sin_family = AF_INET;
- if (local_host_only)
- a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
- else
- a.sin_addr.s_addr = htonl(INADDR_ANY);
+
+ /*
+ * Bind to source address. First try an explicitly
+ * specified one...
+ */
+ if (srcaddr) {
+ a.sin_addr.s_addr = inet_addr(srcaddr);
+ if (a.sin_addr.s_addr != INADDR_NONE) {
+ /* Override localhost_only with specified listen addr. */
+ ret->localhost_only = ipv4_is_loopback(a.sin_addr);
+ got_addr = 1;
+ }
+ }
+
+ /*
+ * ... and failing that, go with one of the standard ones.
+ */
+ if (!got_addr) {
+ 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
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) {
u_long atmark;
/* wParam is the socket itself */
+
+ /*
+ * One user has reported an assertion failure in tree234 which
+ * indicates a null element pointer has been passed to a
+ * find*234 function. The following find234 is the only one in
+ * the whole program that I can see being capable of doing
+ * this, hence I'm forced to conclude that WinSock is capable
+ * of sending me netevent messages with wParam==0. I want to
+ * know what the rest of the message is if it does so!
+ */
+ if (wParam == 0) {
+ char *str;
+ str = dupprintf("Strange WinSock message: wp=%08x lp=%08x",
+ (int)wParam, (int)lParam);
+ logevent(NULL, str);
+ connection_fatal(NULL, str);
+ sfree(str);
+ }
+
s = find234(sktree, (void *) wParam, cmpforsearch);
if (!s)
return 1; /* boggle */
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);
}
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();
break;
}
- if (s->localhost_only &&
- ntohl(isa.sin_addr.s_addr) != INADDR_LOOPBACK) {
+ if (s->localhost_only && !ipv4_is_loopback(isa.sin_addr)) {
closesocket(t); /* dodgy WinSock let nonlocal through */
} else if (plug_accepting(s->plug, (void*)t)) {
closesocket(t); /* denied or error */
* 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