#include "network.h"
#include "tree234.h"
+#define ipv4_is_loopback(addr) (inet_netof(addr) == IN_LOOPBACKNET)
+
struct Socket_tag {
struct socket_function_table *fn;
/* the above variable absolutely *must* be the first in this structure */
struct SockAddr_tag {
char *error;
- /* address family this belongs to, AF_INET for IPv4, AF_INET6 for IPv6. */
+ /*
+ * Which address family this address belongs to. AF_INET for
+ * IPv4; AF_INET6 for IPv6; AF_UNSPEC indicates that name
+ * resolution has not been done and a simple host name is held
+ * in this SockAddr structure.
+ */
int family;
unsigned long address; /* Address IPv4 style. */
#ifdef IPV6
struct addrinfo *ai; /* Address IPv6 style. */
#endif
+ char hostname[512]; /* Store an unresolved host name. */
};
static tree234 *sktree;
return ret;
}
+SockAddr sk_nonamelookup(char *host)
+{
+ SockAddr ret = smalloc(sizeof(struct SockAddr_tag));
+ ret->error = NULL;
+ ret->family = AF_UNSPEC;
+ strncpy(ret->hostname, host, lenof(ret->hostname));
+ ret->hostname[lenof(ret->hostname)-1] = '\0';
+ return ret;
+}
+
void sk_getaddr(SockAddr addr, char *buf, int buflen)
{
#ifdef IPV6
- if (addr->family == AF_INET) {
+ if (addr->family == AF_INET6) {
+ FIXME; /* I don't know how to get a text form of an IPv6 address. */
+ } else
#endif
+ if (addr->family == AF_INET) {
struct in_addr a;
a.s_addr = htonl(addr->address);
strncpy(buf, inet_ntoa(a), buflen);
-#ifdef IPV6
+ buf[buflen-1] = '\0';
} else {
- FIXME; /* I don't know how to get a text form of an IPv6 address. */
+ assert(addr->family == AF_UNSPEC);
+ strncpy(buf, addr->hostname, buflen);
+ buf[buflen-1] = '\0';
}
+}
+
+int sk_hostname_is_local(char *name)
+{
+ return !strcmp(name, "localhost");
+}
+
+int sk_address_is_local(SockAddr addr)
+{
+#ifdef IPV6
+ if (addr->family == AF_INET6) {
+ FIXME; /* someone who can compile for IPV6 had better do this bit */
+ } else
#endif
+ if (addr->family == AF_INET) {
+ struct in_addr a;
+ a.s_addr = htonl(addr->address);
+ return ipv4_is_loopback(a);
+ } else {
+ assert(addr->family == AF_UNSPEC);
+ return 0; /* we don't know; assume not */
+ }
}
int sk_addrtype(SockAddr addr)
{
- return (addr->family == AF_INET ? ADDRTYPE_IPV4 : ADDRTYPE_IPV6);
+ return (addr->family == AF_INET ? ADDRTYPE_IPV4 :
+#ifdef IPV6
+ addr->family == AF_INET6 ? ADDRTYPE_IPV6 :
+#endif
+ ADDRTYPE_NAME);
}
void sk_addrcopy(SockAddr addr, char *buf)
{
+ assert(addr->family != AF_UNSPEC);
#ifdef IPV6
- if (addr->family == AF_INET) {
+ if (addr->family == AF_INET6) {
+ memcpy(buf, (char*) addr->ai, 16);
+ } else
#endif
+ if (addr->family == AF_INET) {
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)
}
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 int sk_tcp_write(Socket s, const char *data, int len);
+static int sk_tcp_write_oob(Socket s, const 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);
+static struct socket_function_table tcp_fn_table = {
+ sk_tcp_plug,
+ sk_tcp_close,
+ 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_register(void *sock, Plug plug)
{
- static struct socket_function_table fn_table = {
- sk_tcp_plug,
- sk_tcp_close,
- 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
- };
-
Actual_Socket ret;
/*
* Create Socket structure.
*/
ret = smalloc(sizeof(struct Socket_tag));
- ret->fn = &fn_table;
+ ret->fn = &tcp_fn_table;
ret->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
int nodelay, Plug plug)
{
- static struct socket_function_table fn_table = {
- sk_tcp_plug,
- sk_tcp_close,
- 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
- };
-
int s;
#ifdef IPV6
struct sockaddr_in6 a6;
* Create Socket structure.
*/
ret = smalloc(sizeof(struct Socket_tag));
- ret->fn = &fn_table;
+ ret->fn = &tcp_fn_table;
ret->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
/*
* Open socket.
*/
+ assert(addr->family != AF_UNSPEC);
s = socket(addr->family, SOCK_STREAM, 0);
ret->s = s;
a.sin_port = htons((short) port);
}
+ {
+ int i = 1;
+ ioctl(s, FIONBIO, &i);
+ }
+
if ((
#ifdef IPV6
connect(s, ((addr->family == AF_INET6) ?
connect(s, (struct sockaddr *) &a, sizeof(a))
#endif
) < 0) {
- /*
- * FIXME: We are prepared to receive EWOULDBLOCK here,
- * because we might want the connection to be made
- * asynchronously; but how do we actually arrange this in
- * Unix? I forget.
- */
- if ( errno != EWOULDBLOCK ) {
+ if ( errno != EINPROGRESS ) {
ret->error = error_string(errno);
return (Socket) ret;
}
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_close,
- 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
- };
-
int s;
#ifdef IPV6
struct sockaddr_in6 a6;
* Create Socket structure.
*/
ret = smalloc(sizeof(struct Socket_tag));
- ret->fn = &fn_table;
+ ret->fn = &tcp_fn_table;
ret->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
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
sfree(s);
}
+int sk_getxdmdata(void *sock, unsigned long *ip, int *port)
+{
+ Actual_Socket s = (Actual_Socket) sock;
+ struct sockaddr_in addr;
+ socklen_t addrlen;
+
+ /*
+ * We must check that this socket really _is_ an Actual_Socket.
+ */
+ if (s->fn != &tcp_fn_table)
+ return 0; /* failure */
+
+ /*
+ * If we ever implement connecting to a local X server through
+ * a Unix socket, we return 0xFFFFFFFF for the IP address and
+ * our current pid for the port. Bizarre, but such is life.
+ */
+
+ addrlen = sizeof(addr);
+ if (getsockname(s->s, (struct sockaddr *)&addr, &addrlen) < 0 ||
+ addr.sin_family != AF_INET)
+ return 0;
+
+ *ip = ntohl(addr.sin_addr.s_addr);
+ *port = ntohs(addr.sin_port);
+
+ return 1;
+}
+
/*
* The function which tries to send on a socket once it's deemed
* writable.
}
}
-static int sk_tcp_write(Socket sock, char *buf, int len)
+static int sk_tcp_write(Socket sock, const char *buf, int len)
{
Actual_Socket s = (Actual_Socket) sock;
return bufchain_size(&s->output_data);
}
-static int sk_tcp_write_oob(Socket sock, char *buf, int len)
+static int sk_tcp_write_oob(Socket sock, const char *buf, int len)
{
Actual_Socket s = (Actual_Socket) sock;
noise_ultralight(event);
switch (event) {
-#ifdef FIXME_NONBLOCKING_CONNECTIONS
- case FIXME: /* connected */
- s->connected = s->writable = 1;
- break;
-#endif
case 4: /* exceptional */
if (!s->oobinline) {
/*
break;
}
- if (s->localhost_only &&
- ntohl(isa.sin_addr.s_addr) != INADDR_LOOPBACK) {
+ if (s->localhost_only && !ipv4_is_loopback(isa.sin_addr)) {
close(t); /* someone let nonlocal through?! */
} else if (plug_accepting(s->plug, (void*)t)) {
close(t); /* denied or error */
}
break;
case 2: /* writable */
- {
+ if (!s->connected) {
+ /*
+ * select() reports a socket as _writable_ when an
+ * asynchronous connection is completed.
+ */
+ s->connected = s->writable = 1;
+ break;
+ } else {
int bufsize_before, bufsize_after;
s->writable = 1;
bufsize_before = s->sending_oob + bufchain_size(&s->output_data);
static void set_rwx(Actual_Socket s, int *rwx)
{
int val = 0;
+ if (!s->connected)
+ val |= 2; /* write == connect */
if (s->connected && !s->frozen)
val |= 1 | 4; /* read, except */
if (bufchain_size(&s->output_data))