#include <stdio.h>
#include <stdlib.h>
+#define DEFINE_PLUG_METHOD_MACROS
#include "putty.h"
#include "network.h"
#include "tree234.h"
#define BUFFER_GRANULE 512
struct Socket_tag {
+ struct socket_function_table *fn;
+ /* the above variable absolutely *must* be the first in this structure */
char *error;
SOCKET s;
- sk_receiver_t receiver;
+ Plug plug;
void *private_ptr;
struct buffer *head, *tail;
int writable;
int oobinline;
};
+/*
+ * We used to typedef struct Socket_tag *Socket.
+ *
+ * Since we have made the networking abstraction slightly more
+ * abstract, Socket no longer means a tcp socket (it could mean
+ * an ssl socket). So now we must use Actual_Socket when we know
+ * we are talking about a tcp socket.
+ */
+typedef struct Socket_tag *Actual_Socket;
+
struct SockAddr_tag {
char *error;
/* address family this belongs to, AF_INET for IPv4, AF_INET6 for IPv6. */
static tree234 *sktree;
static int cmpfortree(void *av, void *bv) {
- Socket a = (Socket)av, b = (Socket)bv;
+ Actual_Socket a = (Actual_Socket)av, b = (Actual_Socket)bv;
unsigned long as = (unsigned long)a->s, bs = (unsigned long)b->s;
if (as < bs) return -1;
if (as > bs) return +1;
}
static int cmpforsearch(void *av, void *bv) {
- Socket b = (Socket)bv;
+ Actual_Socket b = (Actual_Socket)bv;
unsigned long as = (unsigned long)av, bs = (unsigned long)b->s;
if (as < bs) return -1;
if (as > bs) return +1;
sfree(addr);
}
+static Plug sk_tcp_plug (Socket sock, Plug p) {
+ Actual_Socket s = (Actual_Socket) sock;
+ Plug ret = s->plug;
+ if (p) s->plug = p;
+ return ret;
+}
+
+static void sk_tcp_flush (Socket s) {
+ /*
+ * We send data to the socket as soon as we can anyway,
+ * so we don't need to do anything here. :-)
+ */
+}
+
+void sk_tcp_close (Socket s);
+void sk_tcp_write (Socket s, char *data, int len);
+void sk_tcp_write_oob (Socket s, char *data, int len);
+char *sk_tcp_socket_error(Socket s);
+
Socket sk_new(SockAddr addr, int port, int privport, int oobinline,
- sk_receiver_t receiver) {
+ 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_socket_error
+ };
+
SOCKET s;
#ifdef IPV6
SOCKADDR_IN6 a6;
SOCKADDR_IN a;
DWORD err;
char *errstr;
- Socket ret;
+ Actual_Socket ret;
extern char *do_select(SOCKET skt, int startup);
short localport;
* Create Socket structure.
*/
ret = smalloc(sizeof(struct Socket_tag));
+ ret->fn = &fn_table;
ret->error = NULL;
- ret->receiver = receiver;
+ ret->plug = plug;
ret->head = ret->tail = NULL;
ret->writable = 1; /* to start with */
ret->sending_oob = 0;
if (s == INVALID_SOCKET) {
err = WSAGetLastError();
ret->error = winsock_error_string(err);
- return ret;
+ return (Socket) ret;
}
ret->oobinline = oobinline;
if (err)
{
ret->error = winsock_error_string(err);
- return ret;
+ return (Socket) ret;
}
/*
{
err = WSAGetLastError();
ret->error = winsock_error_string(err);
- return ret;
+ return (Socket) ret;
}
/* Set up a select mechanism. This could be an AsyncSelect on a
errstr = do_select(s, 1);
if (errstr) {
ret->error = errstr;
- return ret;
+ return (Socket) ret;
}
add234(sktree, ret);
- return ret;
+ return (Socket) ret;
}
-void sk_close(Socket s) {
+static void sk_tcp_close(Socket sock) {
extern char *do_select(SOCKET skt, int startup);
+ Actual_Socket s = (Actual_Socket) sock;
del234(sktree, s);
do_select(s->s, 0);
* The function which tries to send on a socket once it's deemed
* writable.
*/
-void try_send(Socket s) {
+void try_send(Actual_Socket s) {
while (s->head) {
int nsent;
DWORD err;
noise_ultralight(nsent);
if (nsent <= 0) {
err = (nsent < 0 ? WSAGetLastError() : 0);
- if (err == WSAEWOULDBLOCK) {
- /* Perfectly normal: we've sent all we can for the moment. */
+ if ((err==0 && 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.)
+ */
s->writable = FALSE;
return;
} else if (nsent == 0 ||
}
}
-void sk_write(Socket s, char *buf, int len) {
+static void sk_tcp_write(Socket sock, char *buf, int len) {
+ Actual_Socket s = (Actual_Socket) sock;
+
/*
* Add the data to the buffer list on the socket.
*/
try_send(s);
}
-void sk_write_oob(Socket s, char *buf, int len) {
+static void sk_tcp_write_oob(Socket sock, char *buf, int len) {
+ Actual_Socket s = (Actual_Socket) sock;
+
/*
* Replace the buffer list on the socket with the data.
*/
int ret, open;
DWORD err;
char buf[BUFFER_GRANULE];
- Socket s;
+ Actual_Socket s;
u_long atmark;
/* wParam is the socket itself */
if ((err = WSAGETSELECTERROR(lParam)) != 0) {
/*
* An error has occurred on this socket. Pass it to the
- * receiver function.
+ * plug.
*/
- return s->receiver(s, 3, winsock_error_string(err), err);
+ return plug_closing (s->plug, winsock_error_string(err), err, 0);
}
noise_ultralight(lParam);
}
}
if (ret < 0) {
- return s->receiver(s, 3, winsock_error_string(err), err);
+ return plug_closing (s->plug, winsock_error_string(err), err, 0);
+ } else if (0 == ret) {
+ return plug_closing (s->plug, NULL, 0, 0);
} else {
- return s->receiver(s, atmark ? 0 : 1, buf, ret);
+ return plug_receive (s->plug, atmark ? 0 : 1, buf, ret);
}
break;
case FD_OOB:
fatalbox(ret == 0 ? "Internal networking trouble" :
winsock_error_string(WSAGetLastError()));
} else {
- return s->receiver(s, 2, buf, ret);
+ return plug_receive (s->plug, 2, buf, ret);
}
break;
case FD_WRITE:
err = WSAGetLastError();
if (err == WSAEWOULDBLOCK)
break;
- return s->receiver(s, 3, winsock_error_string(err), err);
- } else
- open &= s->receiver(s, 0, buf, ret);
+ return plug_closing (s->plug, winsock_error_string(err), err, 0);
+ } else {
+ if (ret) open &= plug_receive (s->plug, 0, buf, ret);
+ else open &= plug_closing (s->plug, NULL, 0, 0);
+ }
} while (ret > 0);
return open;
}
* Each socket abstraction contains a `void *' private field in
* which the client can keep state.
*/
-void sk_set_private_ptr(Socket s, void *ptr) {
+void sk_set_private_ptr(Socket sock, void *ptr) {
+ Actual_Socket s = (Actual_Socket) sock;
s->private_ptr = ptr;
}
-void *sk_get_private_ptr(Socket s) {
+void *sk_get_private_ptr(Socket sock) {
+ Actual_Socket s = (Actual_Socket) sock;
return s->private_ptr;
}
char *sk_addr_error(SockAddr addr) {
return addr->error;
}
-char *sk_socket_error(Socket s) {
+static char *sk_tcp_socket_error(Socket sock) {
+ Actual_Socket s = (Actual_Socket) sock;
return s->error;
}
* For Plink: enumerate all sockets currently active.
*/
SOCKET first_socket(enum234 *e) {
- Socket s = first234(sktree, e);
+ Actual_Socket s = first234(sktree, e);
return s ? s->s : INVALID_SOCKET;
}
SOCKET next_socket(enum234 *e) {
- Socket s = next234(e);
+ Actual_Socket s = next234(e);
return s ? s->s : INVALID_SOCKET;
}