2 * Windows networking abstraction.
4 * Due to this clean abstraction it was possible
5 * to easily implement IPv6 support :)
7 * IPv6 patch 1 (27 October 2000) Jeroen Massar <jeroen@unfix.org>
8 * - Preliminary hacked IPv6 support.
9 * - Connecting to IPv6 address (eg fec0:4242:4242:100:2d0:b7ff:fe8f:5d42) works.
10 * - Connecting to IPv6 hostname (eg heaven.ipv6.unfix.org) works.
11 * - Compiles as either IPv4 or IPv6.
13 * IPv6 patch 2 (29 October 2000) Jeroen Massar <jeroen@unfix.org>
14 * - When compiled as IPv6 it also allows connecting to IPv4 hosts.
15 * - Added some more documentation.
17 * IPv6 patch 3 (18 November 2000) Jeroen Massar <jeroen@unfix.org>
18 * - It now supports dynamically loading the IPv6 resolver dll's.
19 * This way we should be able to distribute one (1) binary
20 * which supports both IPv4 and IPv6.
21 * - getaddrinfo() and getnameinfo() are loaded dynamicaly if possible.
22 * - in6addr_any is defined in this file so we don't need to link to wship6.lib
23 * - The patch is now more unified so that we can still
24 * remove all IPv6 support by undef'ing IPV6.
25 * But where it fallsback to IPv4 it uses the IPv4 code which is already in place...
26 * - Canonical name resolving works.
28 * IPv6 patch 4 (07 January 2001) Jeroen Massar <jeroen@unfix.org>
29 * - patch against CVS of today, will be submitted to the bugs list
30 * as a 'cvs diff -u' on Simon's request...
35 * Define IPV6 to have IPv6 on-the-fly-loading support.
36 * This means that one doesn't have to have an IPv6 stack to use it.
37 * But if an IPv6 stack is found it is used with a fallback to IPv4.
56 #define BUFFER_GRANULE 512
61 sk_receiver_t receiver;
63 struct buffer *head, *tail;
70 /* address family this belongs to, AF_INET for IPv4, AF_INET6 for IPv6. */
72 unsigned long address; /* Address IPv4 style. */
74 struct addrinfo *ai; /* Address IPv6 style. */
77 * We need to have this lengthy enough to hold *any* hostname
78 * (including IPv6 reverse...)
86 char buf[BUFFER_GRANULE];
89 static tree234 *sktree;
91 static int cmpfortree(void *av, void *bv) {
92 Socket a = (Socket)av, b = (Socket)bv;
93 unsigned long as = (unsigned long)a->s, bs = (unsigned long)b->s;
94 if (as < bs) return -1;
95 if (as > bs) return +1;
99 static int cmpforsearch(void *av, void *bv) {
100 Socket b = (Socket)bv;
101 unsigned long as = (unsigned long)av, bs = (unsigned long)b->s;
102 if (as < bs) return -1;
103 if (as > bs) return +1;
108 sktree = newtree234(cmpfortree);
111 char *winsock_error_string(int error) {
113 case WSAEACCES: return "Network error: Permission denied";
114 case WSAEADDRINUSE: return "Network error: Address already in use";
115 case WSAEADDRNOTAVAIL: return "Network error: Cannot assign requested address";
116 case WSAEAFNOSUPPORT: return "Network error: Address family not supported by protocol family";
117 case WSAEALREADY: return "Network error: Operation already in progress";
118 case WSAECONNABORTED: return "Network error: Software caused connection abort";
119 case WSAECONNREFUSED: return "Network error: Connection refused";
120 case WSAECONNRESET: return "Network error: Connection reset by peer";
121 case WSAEDESTADDRREQ: return "Network error: Destination address required";
122 case WSAEFAULT: return "Network error: Bad address";
123 case WSAEHOSTDOWN: return "Network error: Host is down";
124 case WSAEHOSTUNREACH: return "Network error: No route to host";
125 case WSAEINPROGRESS: return "Network error: Operation now in progress";
126 case WSAEINTR: return "Network error: Interrupted function call";
127 case WSAEINVAL: return "Network error: Invalid argument";
128 case WSAEISCONN: return "Network error: Socket is already connected";
129 case WSAEMFILE: return "Network error: Too many open files";
130 case WSAEMSGSIZE: return "Network error: Message too long";
131 case WSAENETDOWN: return "Network error: Network is down";
132 case WSAENETRESET: return "Network error: Network dropped connection on reset";
133 case WSAENETUNREACH: return "Network error: Network is unreachable";
134 case WSAENOBUFS: return "Network error: No buffer space available";
135 case WSAENOPROTOOPT: return "Network error: Bad protocol option";
136 case WSAENOTCONN: return "Network error: Socket is not connected";
137 case WSAENOTSOCK: return "Network error: Socket operation on non-socket";
138 case WSAEOPNOTSUPP: return "Network error: Operation not supported";
139 case WSAEPFNOSUPPORT: return "Network error: Protocol family not supported";
140 case WSAEPROCLIM: return "Network error: Too many processes";
141 case WSAEPROTONOSUPPORT: return "Network error: Protocol not supported";
142 case WSAEPROTOTYPE: return "Network error: Protocol wrong type for socket";
143 case WSAESHUTDOWN: return "Network error: Cannot send after socket shutdown";
144 case WSAESOCKTNOSUPPORT: return "Network error: Socket type not supported";
145 case WSAETIMEDOUT: return "Network error: Connection timed out";
146 case WSAEWOULDBLOCK: return "Network error: Resource temporarily unavailable";
147 case WSAEDISCON: return "Network error: Graceful shutdown in progress";
148 default: return "Unknown network error";
152 SockAddr sk_namelookup(char *host, char **canonicalname)
154 SockAddr ret = smalloc(sizeof(struct SockAddr_tag));
156 struct hostent *h = NULL;
158 /* Clear the structure and default to IPv4. */
159 memset(ret, 0, sizeof(struct SockAddr_tag));
160 ret->family = 0; /* We set this one when we have resolved the host. */
161 *canonicalname = ret->realhost; /* This makes sure we always have a hostname to return. */
163 if ( (a = inet_addr(host)) == (unsigned long) INADDR_NONE)
167 /* Try to get the getaddrinfo() function from wship6.dll */
168 /* This way one doesn't need to have IPv6 dll's to use PuTTY and
169 * it will fallback to IPv4. */
170 typedef int (CALLBACK* FGETADDRINFO)(const char *nodename,
171 const char *servname,
172 const struct addrinfo *hints,
173 struct addrinfo **res);
174 FGETADDRINFO fGetAddrInfo = NULL;
176 HINSTANCE dllWSHIP6 = LoadLibrary("wship6.dll");
178 fGetAddrInfo = (FGETADDRINFO)GetProcAddress(dllWSHIP6,
182 * Use fGetAddrInfo when it's available (which usually also
183 * means IPv6 is installed...)
187 /*debug(("Resolving \"%s\" with getaddrinfo() (IPv4+IPv6 capable)...\n", host)); */
188 if (fGetAddrInfo(host, NULL, NULL, &ret->ai) == 0)
189 ret->family = ret->ai->ai_family;
194 * Otherwise use the IPv4-only gethostbyname...
195 * (NOTE: we don't use gethostbyname as a
198 if (ret->family == 0)
200 /*debug(("Resolving \"%s\" with gethostbyname() (IPv4 only)...\n", host)); */
201 if (h = gethostbyname(host)) ret->family = AF_INET;
203 /*debug(("Done resolving...(family is %d) AF_INET = %d, AF_INET6 = %d\n", ret->family, AF_INET, AF_INET6)); */
205 if (ret->family == 0)
207 DWORD err = WSAGetLastError();
208 ret->error = (err == WSAENETDOWN ? "Network is down" :
209 err == WSAHOST_NOT_FOUND ? "Host does not exist" :
210 err == WSATRY_AGAIN ? "Host not found" :
212 fGetAddrInfo ? "getaddrinfo: unknown error" :
214 "gethostbyname: unknown error");
218 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL);
219 /*debug(("Error %ld: %s (h=%lx)\n", err, lpMsgBuf, h));*/
220 /* Free the buffer. */
230 /* If we got an address info use that... */
233 typedef int (CALLBACK* FGETNAMEINFO)
234 (const struct sockaddr FAR *sa, socklen_t salen,
235 char FAR * host, size_t hostlen, char FAR * serv,
236 size_t servlen, int flags);
237 FGETNAMEINFO fGetNameInfo = NULL;
239 /* Are we in IPv4 fallback mode? */
240 /* We put the IPv4 address into the a variable so we can further-on use the IPv4 code... */
241 if (ret->family == AF_INET)
242 memcpy(&a, (char *)&((SOCKADDR_IN *)ret->ai->ai_addr)->sin_addr, sizeof(a));
244 /* Now let's find that canonicalname... */
245 if ((dllWSHIP6) && (fGetNameInfo = (FGETNAMEINFO)GetProcAddress(dllWSHIP6, "getnameinfo")))
247 if (fGetNameInfo((struct sockaddr *)ret->ai->ai_addr,
248 ret->family == AF_INET ?
249 sizeof(SOCKADDR_IN) :
250 sizeof(SOCKADDR_IN6), ret->realhost,
251 sizeof(ret->realhost), NULL,
254 strncpy(ret->realhost, host,
255 sizeof(ret->realhost));
259 /* We used the IPv4-only gethostbyname()... */
263 memcpy(&a, h->h_addr, sizeof(a));
264 /* This way we are always sure the h->h_name is valid :) */
265 strncpy(ret->realhost, h->h_name, sizeof(ret->realhost));
271 FreeLibrary(dllWSHIP6);
277 * Hack inserted to deal with problems with numeric IPs.
278 * FIXME: how will this work in IPv6?
280 ret->family = AF_INET;
281 *canonicalname = host;
283 ret->address = ntohl(a);
287 void sk_addr_free(SockAddr addr) {
291 Socket sk_new(SockAddr addr, int port, int privport, sk_receiver_t receiver) {
300 extern char *do_select(SOCKET skt, int startup);
304 * Create Socket structure.
306 ret = smalloc(sizeof(struct Socket_tag));
308 ret->receiver = receiver;
309 ret->head = ret->tail = NULL;
310 ret->writable = 1; /* to start with */
311 ret->sending_oob = 0;
316 s = socket(addr->family, SOCK_STREAM, 0);
319 if (s == INVALID_SOCKET) {
320 err = WSAGetLastError();
321 ret->error = winsock_error_string(err);
326 setsockopt (s, SOL_SOCKET, SO_OOBINLINE, (void *)&b, sizeof(b));
330 * Bind to local address.
333 localport = 1023; /* count from 1023 downwards */
335 localport = 0; /* just use port 0 (ie winsock picks) */
337 /* Loop round trying to bind */
342 if (addr->family == AF_INET6)
344 memset(&a6,0,sizeof(a6));
345 a6.sin6_family = AF_INET6;
346 /*a6.sin6_addr = in6addr_any;*/ /* == 0 */
347 a6.sin6_port = htons(localport);
352 a.sin_family = AF_INET;
353 a.sin_addr.s_addr = htonl(INADDR_ANY);
354 a.sin_port = htons(localport);
357 retcode = bind (s, (addr->family == AF_INET6 ?
358 (struct sockaddr *)&a6 :
359 (struct sockaddr *)&a),
360 (addr->family == AF_INET6 ? sizeof(a6) : sizeof(a)));
362 retcode = bind (s, (struct sockaddr *)&a, sizeof(a));
364 if (retcode != SOCKET_ERROR) {
368 err = WSAGetLastError();
369 if (err != WSAEADDRINUSE) /* failed, for a bad reason */
374 break; /* we're only looping once */
377 break; /* we might have got to the end */
382 ret->error = winsock_error_string(err);
387 * Connect to remote address.
390 if (addr->family == AF_INET6)
392 memset(&a,0,sizeof(a));
393 a6.sin6_family = AF_INET6;
394 a6.sin6_port = htons((short)port);
395 a6.sin6_addr = ((struct sockaddr_in6 *)addr->ai->ai_addr)->sin6_addr;
400 a.sin_family = AF_INET;
401 a.sin_addr.s_addr = htonl(addr->address);
402 a.sin_port = htons((short)port);
405 if (connect (s, (addr->family == AF_INET6) ? (struct sockaddr *)&a6 : (struct sockaddr *)&a, (addr->family == AF_INET6) ? sizeof(a6) : sizeof(a)) == SOCKET_ERROR)
407 if (connect (s, (struct sockaddr *)&a, sizeof(a)) == SOCKET_ERROR)
410 err = WSAGetLastError();
411 ret->error = winsock_error_string(err);
415 /* Set up a select mechanism. This could be an AsyncSelect on a
416 * window, or an EventSelect on an event object. */
417 errstr = do_select(s, 1);
428 void sk_close(Socket s) {
429 extern char *do_select(SOCKET skt, int startup);
438 * The function which tries to send on a socket once it's deemed
441 void try_send(Socket s) {
447 if (s->sending_oob) {
448 urgentflag = MSG_OOB;
449 len = s->sending_oob;
452 len = s->head->buflen - s->head->bufpos;
455 nsent = send(s->s, s->head->buf + s->head->bufpos, len, urgentflag);
456 noise_ultralight(nsent);
458 err = (nsent < 0 ? WSAGetLastError() : 0);
459 if (err == WSAEWOULDBLOCK) {
460 /* Perfectly normal: we've sent all we can for the moment. */
463 } else if (nsent == 0 ||
464 err == WSAECONNABORTED ||
465 err == WSAECONNRESET) {
467 * FIXME. This will have to be done better when we
468 * start managing multiple sockets (e.g. SSH port
469 * forwarding), because if we get CONNRESET while
470 * trying to write a particular forwarded socket
471 * then it isn't necessarily the end of the world.
472 * Ideally I'd like to pass the error code back to
473 * somewhere the next select_result() will see it,
474 * but that might be hard. Perhaps I should pass it
475 * back to be queued in the Windows front end bit.
477 fatalbox(winsock_error_string(err));
479 fatalbox(winsock_error_string(err));
482 s->head->bufpos += nsent;
484 s->sending_oob -= nsent;
485 if (s->head->bufpos >= s->head->buflen) {
486 struct buffer *tmp = s->head;
496 void sk_write(Socket s, char *buf, int len) {
498 * Add the data to the buffer list on the socket.
500 if (s->tail && s->tail->buflen < BUFFER_GRANULE) {
501 int copylen = min(len, BUFFER_GRANULE - s->tail->buflen);
502 memcpy(s->tail->buf + s->tail->buflen, buf, copylen);
505 s->tail->buflen += copylen;
508 int grainlen = min(len, BUFFER_GRANULE);
509 struct buffer *newbuf;
510 newbuf = smalloc(sizeof(struct buffer));
512 newbuf->buflen = grainlen;
513 memcpy(newbuf->buf, buf, grainlen);
517 s->tail->next = newbuf;
519 s->head = s->tail = newbuf;
525 * Now try sending from the start of the buffer list.
531 void sk_write_oob(Socket s, char *buf, int len) {
533 * Replace the buffer list on the socket with the data.
536 s->head = smalloc(sizeof(struct buffer));
538 struct buffer *walk = s->head->next;
540 struct buffer *tmp = walk;
545 s->head->next = NULL;
547 s->head->buflen = len;
548 memcpy(s->head->buf, buf, len);
551 * Set the Urgent marker.
553 s->sending_oob = len;
556 * Now try sending from the start of the buffer list.
562 int select_result(WPARAM wParam, LPARAM lParam) {
565 char buf[BUFFER_GRANULE];
569 /* wParam is the socket itself */
570 s = find234(sktree, (void *)wParam, cmpforsearch);
572 return 1; /* boggle */
574 if ((err = WSAGETSELECTERROR(lParam)) != 0) {
576 * An error has occurred on this socket. Pass it to the
579 return s->receiver(s, 3, winsock_error_string(err), err);
582 noise_ultralight(lParam);
584 switch (WSAGETSELECTEVENT(lParam)) {
587 /* Some WinSock wrappers don't support this call, so we
588 * deliberately don't check the return value. If the call
589 * fails and does nothing, we will get back atmark==1,
590 * which is good enough to keep going at least. */
591 ioctlsocket(s->s, SIOCATMARK, &atmark);
592 ret = recv(s->s, buf, sizeof(buf), 0);
594 err = WSAGetLastError();
595 if (err == WSAEWOULDBLOCK) {
600 return s->receiver(s, 3, winsock_error_string(err), err);
604 ioctlsocket(s->s, SIOCATMARK, &atmark);
605 if(atmark) type = 2; else type = 1;
607 return s->receiver(s, type, buf, ret);
612 * Read all data up to the OOB marker, and send it to the
613 * receiver with urgent==1 (OOB pending).
615 ret = recv(s->s, buf, sizeof(buf), MSG_OOB);
616 noise_ultralight(ret);
618 fatalbox(ret == 0 ? "Internal networking trouble" :
619 winsock_error_string(WSAGetLastError()));
621 return s->receiver(s, 2, buf, ret);
629 /* Signal a close on the socket. First read any outstanding data. */
632 ret = recv(s->s, buf, sizeof(buf), 0);
634 err = WSAGetLastError();
635 if (err == WSAEWOULDBLOCK)
637 return s->receiver(s, 3, winsock_error_string(err), err);
639 open &= s->receiver(s, 0, buf, ret);
648 * Each socket abstraction contains a `void *' private field in
649 * which the client can keep state.
651 void sk_set_private_ptr(Socket s, void *ptr) {
652 s->private_ptr = ptr;
654 void *sk_get_private_ptr(Socket s) {
655 return s->private_ptr;
659 * Special error values are returned from sk_namelookup and sk_new
660 * if there's a problem. These functions extract an error message,
661 * or return NULL if there's no problem.
663 char *sk_addr_error(SockAddr addr) {
666 char *sk_socket_error(Socket s) {
671 * For Plink: enumerate all sockets currently active.
673 SOCKET first_socket(enum234 *e) {
674 Socket s = first234(sktree, e);
675 return s ? s->s : INVALID_SOCKET;
677 SOCKET next_socket(enum234 *e) {
678 Socket s = next234(e);
679 return s ? s->s : INVALID_SOCKET;