From f0a644990c77536cd87856350c6068053e007962 Mon Sep 17 00:00:00 2001
From: Matthew Flatt <mflatt@racket-lang.org>
Date: Thu, 15 Jun 2017 20:26:41 -0600
Subject: [PATCH] rktio: repairs

Compiles ons MacOS, but doesn't quite link.
---
 racket/src/racket/include/schthread.h |   2 +-
 racket/src/racket/src/Makefile.in     |  19 +-
 racket/src/racket/src/network.c       | 374 ++++++++++++--------------
 racket/src/racket/src/port.c          | 281 +++++++++----------
 racket/src/racket/src/read.c          |   2 +-
 racket/src/racket/src/schpriv.h       |   8 +-
 racket/src/racket/src/string.c        |   1 +
 racket/src/racket/src/thread.c        |  45 ++--
 racket/src/rktio/rktio.h              |  64 +++--
 racket/src/rktio/rktio_envvars.c      |   4 +-
 racket/src/rktio/rktio_fd.c           |   2 +-
 racket/src/rktio/rktio_file.c         |   6 +-
 racket/src/rktio/rktio_fs.c           |  61 ++---
 racket/src/rktio/rktio_fs_change.c    |   4 +-
 racket/src/rktio/rktio_ltps.c         |   2 +-
 racket/src/rktio/rktio_network.c      |  23 +-
 racket/src/rktio/rktio_poll_set.c     |   8 +-
 racket/src/rktio/rktio_private.h      |   2 +-
 18 files changed, 457 insertions(+), 451 deletions(-)

diff --git a/racket/src/racket/include/schthread.h b/racket/src/racket/include/schthread.h
index 0fe3996d8f..beb41386b5 100644
--- a/racket/src/racket/include/schthread.h
+++ b/racket/src/racket/include/schthread.h
@@ -307,7 +307,7 @@ typedef struct Thread_Local_Variables {
   int special_is_ok_;
   int scheme_force_port_closed_;
   int fd_reserved_;
-  int the_fd_;
+  struct rktio_fd_t *the_fd_;
   int scheme_num_read_syntax_objects_;
   struct Scheme_Load_Delay *clear_bytes_chain_;
   const char *failure_msg_for_read_;
diff --git a/racket/src/racket/src/Makefile.in b/racket/src/racket/src/Makefile.in
index e7d7aad77c..5280f334d7 100644
--- a/racket/src/racket/src/Makefile.in
+++ b/racket/src/racket/src/Makefile.in
@@ -381,10 +381,10 @@ list.@LTO@: $(COMMON_HEADERS) \
 marshal.@LTO@: $(COMMON_HEADERS) \
         $(srcdir)/stypes.h
 module.@LTO@: $(COMMON_HEADERS) \
-        $(srcdir)/stypes.h $(srcdir)/schfd.h
+        $(srcdir)/stypes.h
 mzrt.@LTO@: $(COMMON_HEADERS)
-network.@LTO@: $(COMMON_HEADERS) \
-        $(srcdir)/stypes.h  $(srcdir)/schfd.h $(srcdir)/mzmark_network.inc
+network.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
+        $(srcdir)/stypes.h $(srcdir)/mzmark_network.inc
 numarith.@LTO@: $(COMMON_HEADERS) \
          $(srcdir)/stypes.h $(srcdir)/nummacs.h
 number.@LTO@: $(COMMON_HEADERS) \
@@ -397,17 +397,16 @@ numstr.@LTO@: $(COMMON_HEADERS) \
 optimize.@LTO@: $(COMMON_HEADERS) \
          $(srcdir)/stypes.h $(srcdir)/mzmark_optimize.inc
 place.@LTO@: $(COMMON_HEADERS) \
-        $(srcdir)/stypes.h  $(srcdir)/schfd.h $(srcdir)/mzmark_place.inc
+        $(srcdir)/stypes.h $(srcdir)/mzmark_place.inc
 port.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
-        $(srcdir)/stypes.h  $(srcdir)/schfd.h $(srcdir)/mzmark_port.inc \
-        $(srcdir)/inotify.inc
+        $(srcdir)/stypes.h $(srcdir)/mzmark_port.inc
 portfun.@LTO@: $(COMMON_HEADERS) $(srcdir)/schvers.h \
-        $(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_portfun.inc
+        $(srcdir)/stypes.h $(srcdir)/mzmark_portfun.inc
 print.@LTO@: $(COMMON_HEADERS) $(srcdir)/stypes.h $(srcdir)/schcpt.h \
           $(srcdir)/schvers.h $(SCONFIG) $(srcdir)/mzmark_print.inc \
           $(srcdir)/print_vector.inc 
-thread.@LTO@: $(COMMON_HEADERS) \
-         $(srcdir)/stypes.h  $(srcdir)/schfd.h $(srcdir)/mzmark_thread.inc
+thread.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
+         $(srcdir)/stypes.h $(srcdir)/mzmark_thread.inc
 rational.@LTO@: $(COMMON_HEADERS) \
          $(srcdir)/stypes.h    
 read.@LTO@: $(COMMON_HEADERS) \
@@ -428,7 +427,7 @@ string.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
 struct.@LTO@: $(COMMON_HEADERS) \
          $(srcdir)/stypes.h $(srcdir)/mzmark_struct.inc
 syntax.@LTO@: $(COMMON_HEADERS) \
-         $(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_syntax.inc
+         $(srcdir)/stypes.h $(srcdir)/mzmark_syntax.inc
 symbol.@LTO@: $(COMMON_HEADERS) \
          $(srcdir)/stypes.h   
 sema.@LTO@: $(COMMON_HEADERS) \
diff --git a/racket/src/racket/src/network.c b/racket/src/racket/src/network.c
index 4ab528e864..5b99a14af6 100644
--- a/racket/src/racket/src/network.c
+++ b/racket/src/racket/src/network.c
@@ -29,9 +29,6 @@
 #include "schrktio.h"
 #include <ctype.h>
 
-#ifndef NO_TCP_SUPPORT
-#ifdef USE_TCP
-
 #define TCP_BUFFER_SIZE 4096
 
 typedef struct {
@@ -179,7 +176,11 @@ void scheme_init_network(Scheme_Env *env)
   scheme_finish_primitive_module(netenv);
 }
 
-static int check_fd_sema(rktio_fd_t s, int mode, Scheme_Schedule_Info *sinfo, Scheme_Object *orig)
+static int check_fd_sema(rktio_fd_t *s, int mode, Scheme_Schedule_Info *sinfo, Scheme_Object *orig)
+/* Tries to convert a file descriptor to a semaphore, and redirects
+   the sync to the semaphore if that works, which avoids a poll spin
+   on the file descriptor. The result is 0 if the shortcut determines
+   that the file descriptor is not ready. */
 {
   Scheme_Object *sema;
 
@@ -215,7 +216,6 @@ static int check_fd_sema(rktio_fd_t s, int mode, Scheme_Schedule_Info *sinfo, Sc
 static int tcp_check_accept(Scheme_Object *_listener, Scheme_Schedule_Info *sinfo)
 {
   listener_t *listener = (listener_t *)_listener;
-  int sr, i;
 
   if (!sinfo || !sinfo->is_poll) {
     /* If listeners supported semaphores, we could have a check here
@@ -229,14 +229,8 @@ static int tcp_check_accept(Scheme_Object *_listener, Scheme_Schedule_Info *sinf
   if (rktio_poll_accept_ready(scheme_rktio, listener->lnr))
     return 1;
 
-  if (sinfo && !sinfo->no_redirect) {
-    Scheme_Object *evt;
-    evt = listener_to_evt(listener);
-    if (evt)
-      scheme_set_sync_target(sinfo, evt, _listener, NULL, 0, 1, NULL);
-  } else {
-    /* CREATE_LISTEN_SEMA: This is where we'd create a semaphore for the listener, if that were possible */
-  }
+  /* CREATE_LISTEN_SEMA: This is where we'd create a semaphore for the
+     listener, if that were possible */
 
   return 0;
 }
@@ -291,7 +285,7 @@ static int tcp_check_write(Scheme_Object *port, Scheme_Schedule_Info *sinfo)
 
 static void tcp_write_needs_wakeup(Scheme_Object *port, void *fds)
 {
-  rktio_fd_t s = ((Scheme_Tcp *)((Scheme_Output_Port *)port)->port_data)->tcp;
+  rktio_fd_t *s = ((Scheme_Tcp *)((Scheme_Output_Port *)port)->port_data)->tcp;
   
   rktio_poll_add(scheme_rktio, s, fds, RKTIO_POLL_WRITE);
 }
@@ -353,7 +347,6 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
 			   int nonblock,
 			   Scheme_Object *unless)
 {
-  int errid;
   int read_amt;
   Scheme_Tcp *data;
   Scheme_Object *sema;
@@ -395,7 +388,7 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
 
     {
       int rn;
-      rn = rktio_read(scheme_rktio, data->tcp, data->b.buffer, read_amt, 0);
+      rn = rktio_read(scheme_rktio, data->tcp, data->b.buffer, read_amt);
       data->b.bufmax = rn; /* could be count, error, or EOF */
     }
     
@@ -408,7 +401,7 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
         return 0;
 
       /* block until data is (probably) available */
-      sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_READ, 1);
+      sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_READ);
       if (sema)
         scheme_wait_sema(sema, nonblock ? -1 : 0);
       else
@@ -428,8 +421,7 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
     data->b.bufmax = 0;
     scheme_raise_exn(MZEXN_FAIL_NETWORK,
 		     "tcp-read: error reading\n"
-                     "  system error: %R",
-		     errid);
+                     "  system error: %R");
     return 0;
   } else if (data->b.bufmax == RKTIO_READ_ERROR) {
     data->b.bufmax = 0;
@@ -468,9 +460,9 @@ static void tcp_close_input(Scheme_Input_Port *port)
   if (--data->b.refcount)
     return;
 
-  (void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE, 1);
+  (void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE);
 
-  rktio_close(data->tcp);
+  rktio_close(scheme_rktio, data->tcp);
 }
 
 static int
@@ -499,7 +491,7 @@ static intptr_t tcp_do_write_string(Scheme_Output_Port *port,
      can be flushed immediately, never ever blocking. */
 
   Scheme_Tcp *data;
-  int errid, would_block = 0;
+  int would_block = 0;
   intptr_t sent;
 
   data = (Scheme_Tcp *)port->port_data;
@@ -525,7 +517,7 @@ static intptr_t tcp_do_write_string(Scheme_Output_Port *port,
     /* Block for writing: */
     {
       Scheme_Object *sema;
-      sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_WRITE, 1);
+      sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_WRITE);
       if (sema)
         scheme_wait_sema(sema, enable_break ? -1 : 0);
       else
@@ -641,9 +633,9 @@ static void tcp_close_output(Scheme_Output_Port *port)
   if (--data->b.refcount)
     return;
 
-  (void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE, 1);
+  (void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE);
 
-  rktio_close(data->tcp);
+  rktio_close(scheme_rktio, data->tcp);
 }
 
 static int
@@ -732,20 +724,23 @@ make_tcp_output_port(void *data, const char *name, Scheme_Object *cust)
 
 /* Various things to free if we ever give up on a connect: */
 typedef struct Connect_Progress_Data {
-  rktio_lookup_t *lookup;
+  rktio_addrinfo_lookup_t *lookup;
   rktio_connect_t *connect;
   rktio_addrinfo_t *dest_addr;
   rktio_addrinfo_t *src_addr;
+  rktio_fd_t *trying_s;
   rktio_fd_t *s;
 } Connect_Progress_Data;
 
-static Connect_Progress_Data *make_conect_progress_data()
+static Connect_Progress_Data *make_connect_progress_data()
 {
   Connect_Progress_Data *pd;
   
-  MALLOC_ONE_ATOMIC(Connect_Progress_Data);
+  pd = MALLOC_ONE_ATOMIC(Connect_Progress_Data);
   pd->lookup = NULL;
+  pd->connect = NULL;
   pd->dest_addr = NULL;
+  pd->src_addr = NULL;
   pd->s = NULL;
 
   return pd;
@@ -758,7 +753,7 @@ static void connect_cleanup(Connect_Progress_Data *pd)
     pd->lookup = NULL;
   }
   if (pd->connect) {
-    rktio_connect_stop(rktio, pd->connect);
+    rktio_connect_stop(scheme_rktio, pd->connect);
     pd->connect = NULL;
   }
   if (pd->dest_addr) {
@@ -769,9 +764,13 @@ static void connect_cleanup(Connect_Progress_Data *pd)
     rktio_addrinfo_free(scheme_rktio, pd->src_addr);
     pd->src_addr = NULL;
   }
+  if (pd->trying_s) {
+    (void)scheme_rktio_fd_to_semaphore(pd->trying_s, MZFD_REMOVE);
+    pd->trying_s = NULL;
+  }
   if (pd->s) {
-    (void)scheme_rktio_fd_to_semaphore(s, MZFD_REMOVE, 1);
-    rktio_close(s);
+    (void)scheme_rktio_fd_to_semaphore(pd->s, MZFD_REMOVE);
+    rktio_close(scheme_rktio, pd->s);
     pd->s = NULL;
   }
 }
@@ -784,14 +783,15 @@ static int check_lookup(Connect_Progress_Data *pd, Scheme_Schedule_Info *sinfo)
   return 0;
 }
 
-static void lookup_needs_wakeup(Connect_Progress_Data *pd, void *fds)
+static void lookup_needs_wakeup(Scheme_Object *_pd, void *fds)
 {
+  Connect_Progress_Data *pd = (Connect_Progress_Data *)_pd;
   rktio_poll_add_addrinfo_lookup(scheme_rktio, pd->lookup, fds);
 }
 
 static void wait_until_lookup(Connect_Progress_Data *pd)
 {
-  while (!rktio_poll_addrinfo_lookup_ready(scheme_rktio, lookup)) {
+  while (!rktio_poll_addrinfo_lookup_ready(scheme_rktio, pd->lookup)) {
     BEGIN_ESCAPEABLE(connect_cleanup, pd);
     scheme_block_until((Scheme_Ready_Fun)check_lookup, 
                        lookup_needs_wakeup, 
@@ -804,7 +804,7 @@ static void wait_until_lookup(Connect_Progress_Data *pd)
 static rktio_addrinfo_t *do_resolve_address(const char *who, char *address, int id, int family, int show_id_on_error)
 {
   Connect_Progress_Data *pd;
-  rktio_lookup_t *loopkup;
+  rktio_addrinfo_lookup_t *lookup;
   rktio_addrinfo_t *addr;
     
   pd = make_connect_progress_data();    
@@ -855,7 +855,7 @@ const char *scheme_hostname_error(int err)
 /*                         TCP Racket interface                           */
 /*========================================================================*/
 
-static void connect_failed(Connect_Progress_Data *pd, const char *why, char *address, int id)
+static void connect_failed(Connect_Progress_Data *pd, const char *why, const char *address, int id)
 {
   if (pd) connect_cleanup(pd);
 
@@ -871,37 +871,42 @@ static void connect_failed(Connect_Progress_Data *pd, const char *why, char *add
 
 static int tcp_check_connect(Connect_Progress_Data *pd, Scheme_Schedule_Info *sinfo)
 {
-    
-  rktio_fd_t *s = (rktio_fd_t *)connector_p;
-
+  if (!pd->trying_s) {
+    rktio_fd_t *s;
+    s = rktio_connect_trying(scheme_rktio, pd->connect);
+    pd->trying_s = s;
+  }
+  
   if (!sinfo || !sinfo->is_poll) {
-    if (!check_fd_sema(s, MZFD_CHECK_WRITE, sinfo, NULL))
-      return 0;
+    if (pd->trying_s)
+      if (!check_fd_sema(pd->trying_s, MZFD_CHECK_WRITE, sinfo, NULL))
+        return 0;
   }
 
-  if (rktio_poll_connect_ready(scheme->rktio, s))
+  if (rktio_poll_connect_ready(scheme_rktio, pd->connect))
     return 1;
 
-  check_fd_sema(s, MZFD_CREATE_WRITE, sinfo, NULL);
+  if (pd->trying_s)
+    check_fd_sema(pd->trying_s, MZFD_CREATE_WRITE, sinfo, NULL);
 
   return 0;
 }
 
-static void tcp_connect_needs_wakeup(Scheme_Object *connector_p, void *fds)
+static void tcp_connect_needs_wakeup(Scheme_Object *_pd, void *fds)
 {
-  rktio_fd_t *s = (rktio_fd_t *)connector_p;
-  rktio_poll_add_connect(scheme_rktio, s, fds);
+  Connect_Progress_Data *pd = (Connect_Progress_Data *)_pd;
+  rktio_poll_add_connect(scheme_rktio, pd->connect, fds);
 }
 
 static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
 {
   Connect_Progress_Data *pd;
-  char *address = "", *src_address, *errmsg = NULL;
+  char *address = "", *src_address;
   unsigned short id, src_id;
   int no_local_spec;
   Scheme_Object *bs, *src_bs;
-  rktio_addrinfo_t *tcp_address_dest, *tcp_address_src;
-  rktio_lookup_t *lookup;
+  rktio_addrinfo_t *tcp_connect_dest, *tcp_connect_src;
+  rktio_addrinfo_lookup_t *lookup;
   rktio_connect_t *connect;
   rktio_fd_t *s;
 
@@ -948,7 +953,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
 
   pd = make_connect_progress_data();
   
-  lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, id, RKTIO_FAMILTY_ANY, 0, 1);
+  lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, id, RKTIO_FAMILY_ANY, 0, 1);
   if (!lookup)
     connect_failed(pd, "host not found", address, id);
   
@@ -963,7 +968,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
   pd->dest_addr = tcp_connect_dest;
   
   if (!no_local_spec) {
-    lookup = rktio_start_addrinfo_lookup(scheme_rktio, src_address, src_id, RKTIO_FAMILTY_ANY, 1, 1);
+    lookup = rktio_start_addrinfo_lookup(scheme_rktio, src_address, src_id, RKTIO_FAMILY_ANY, 1, 1);
     if (!lookup)
       connect_failed(pd, "local host not found", src_address, src_id);
 
@@ -971,22 +976,15 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
     wait_until_lookup(pd);
     pd->lookup = NULL;
     
-    tcp_connect_dest = rktio_addrinfo_lookup_get(scheme_rktio, lookup);
-    if (!tcp_connect_dest)
-      connect_failed(pd, "local host not found", src_address, src_id);
-
-    pd->lookup = lookup;
-    wait_until_lookup(pd);
-    pd->lookup = NULL;
-
     tcp_connect_src = rktio_addrinfo_lookup_get(scheme_rktio, lookup);
     if (!tcp_connect_src)
       connect_failed(pd, "local host not found", src_address, src_id);
-  }
+  } else
+    tcp_connect_src = NULL;
 
   pd->src_addr = tcp_connect_src;
 
-  connect = rktio_start_connect(racket_rktio, tcp_connect_dest, tcp_connect_src);
+  connect = rktio_start_connect(scheme_rktio, tcp_connect_dest, tcp_connect_src);
   if (!connect)
     connect_failed(pd, NULL, address, id);
 
@@ -1002,7 +1000,10 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
       END_ESCAPEABLE();  
     }
 
-    s = rktio_connect_finish(rktio_rktio, connect);
+    if (pd->trying_s)
+      (void)scheme_rktio_fd_to_semaphore(pd->trying_s, MZFD_REMOVE);
+
+    s = rktio_connect_finish(scheme_rktio, connect);
     
     if (!s && scheme_last_error_is_racket(RKTIO_ERROR_CONNECT_TRYING_NEXT)) {
       /* try again */
@@ -1013,7 +1014,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
   pd->connect = NULL;
 
   if (!s)
-    connect_failed(s, NULL, address, id);    
+    connect_failed(pd, NULL, address, id);    
 
   connect_cleanup(pd);
 
@@ -1022,7 +1023,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
     Scheme_Tcp *tcp;
     
     if (tcp_connect_src)
-      rktio_addrinfo_free(tcp_connect_src);
+      rktio_addrinfo_free(scheme_rktio, tcp_connect_src);
     
     tcp = make_tcp_port_data(s, 2);
     
@@ -1039,7 +1040,7 @@ tcp_connect_break(int argc, Scheme_Object *argv[])
   return scheme_call_enable_break(tcp_connect, argc, argv);
 }
 
-static void listen_failed(Connect_Progress_Data *pd, const char *why, char *address, int id)
+static void listen_failed(Connect_Progress_Data *pd, const char *why, const char *address, int id)
 {
   if (pd) connect_cleanup(pd);
 
@@ -1060,11 +1061,11 @@ static Scheme_Object *
 tcp_listen(int argc, Scheme_Object *argv[])
 {
   unsigned short id;
-  int backlog, errid;
+  int backlog;
   int reuse = 0, no_ipv6 = 0;
   const char *address;
   Connect_Progress_Data *pd;
-  rktio_lookup_t *lookup;
+  rktio_addrinfo_lookup_t *lookup;
   rktio_addrinfo_t *tcp_src;
   rktio_listener_t *lnr;
   listener_t *l;
@@ -1098,7 +1099,7 @@ tcp_listen(int argc, Scheme_Object *argv[])
   } else
     address = NULL;
 
-  scheme_security_check_network("tcp-listen", address, origid, 0);
+  scheme_security_check_network("tcp-listen", address, id, 0);
   scheme_custodian_check_available(NULL, "tcp-listen", "network");
 
   pd = make_connect_progress_data();    
@@ -1109,7 +1110,7 @@ tcp_listen(int argc, Scheme_Object *argv[])
     if (no_ipv6)
       family = rktio_get_ipv4_family(scheme_rktio);
     else
-      family = RKTIO_FAMILTY_ANY;
+      family = RKTIO_FAMILY_ANY;
     
     lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, id, family, 1, 1);
     if (!lookup)
@@ -1121,10 +1122,10 @@ tcp_listen(int argc, Scheme_Object *argv[])
 
     tcp_src = rktio_addrinfo_lookup_get(scheme_rktio, lookup);
     if (!tcp_src)
-      connect_failed(pd, "address-resolution error", address, id);
+      listen_failed(pd, "address-resolution error", address, id);
 
     pd->src_addr = tcp_src;
-    lnr = rktio_listen(rktio, tcp_src, backlog, reuse);
+    lnr = rktio_listen(scheme_rktio, tcp_src, backlog, reuse);
 
     pd->src_addr = NULL;
     rktio_addrinfo_free(scheme_rktio, tcp_src);
@@ -1166,8 +1167,6 @@ tcp_stop(int argc, Scheme_Object *argv[])
   if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
     scheme_wrong_contract("tcp-close", "tcp-listener?", 0, argc, argv);
 
-  TCP_INIT("tcp-close");
-
   was_closed = stop_listener(argv[0]);
 
   if (was_closed) {
@@ -1187,8 +1186,6 @@ tcp_accept_ready(int argc, Scheme_Object *argv[])
   if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
     scheme_wrong_contract("tcp-accept-ready?", "tcp-listener?", 0, argc, argv);
 
-  TCP_INIT("tcp-accept-ready?");
-
   if (LISTENER_WAS_CLOSED(argv[0])) {
     scheme_raise_exn(MZEXN_FAIL_NETWORK,
 		     "tcp-accept-ready?: listener is closed");
@@ -1205,11 +1202,9 @@ do_tcp_accept(int argc, Scheme_Object *argv[], Scheme_Object *cust, char **_fail
 /* If _fail_reason is not NULL, never raise an exception. */
 {
 #ifdef USE_TCP
-  int was_closed = 0, errid, ready_pos;
+  int was_closed = 0, ready_pos;
   Scheme_Object *listener;
   rktio_fd_t *s;
-  unsigned int l;
-  GC_CAN_IGNORE char tcp_accept_addr[MZ_SOCK_NAME_MAX_LEN];
 
   if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
     scheme_wrong_contract("tcp-accept", "tcp-listener?", 0, argc, argv);
@@ -1221,15 +1216,10 @@ do_tcp_accept(int argc, Scheme_Object *argv[], Scheme_Object *cust, char **_fail
   if (!was_closed) {
     ready_pos = tcp_check_accept(listener, NULL);
     if (!ready_pos) {
-      Scheme_Object *evt;
-      evt = listener_to_evt((listener_t *)listener);
-      if (evt)
-        scheme_sync(1, &evt);
-      else
-        scheme_block_until((Scheme_Ready_Fun)tcp_check_accept, 
-                           tcp_accept_needs_wakeup, 
-                           listener, 
-                           0.0);
+      scheme_block_until((Scheme_Ready_Fun)tcp_check_accept, 
+                         tcp_accept_needs_wakeup, 
+                         listener, 
+                         0.0);
       ready_pos = tcp_check_accept(listener, NULL);
     }
     was_closed = LISTENER_WAS_CLOSED(listener);
@@ -1292,13 +1282,9 @@ tcp_accept_break(int argc, Scheme_Object *argv[])
 
 void scheme_register_network_evts()
 {
-#ifdef USE_TCP
   scheme_add_evt(scheme_listener_type, (Scheme_Ready_Fun)tcp_check_accept, tcp_accept_needs_wakeup, NULL, 0);
   scheme_add_evt(scheme_tcp_accept_evt_type, (Scheme_Ready_Fun)tcp_check_accept_evt, tcp_accept_evt_needs_wakeup, NULL, 0);
-# ifdef UDP_IS_SUPPORTED
   scheme_add_evt(scheme_udp_evt_type, (Scheme_Ready_Fun)udp_evt_check_ready, udp_evt_needs_wakeup, NULL, 0);
-# endif
-#endif
 }
 
 static Scheme_Object *tcp_listener_p(int argc, Scheme_Object *argv[])
@@ -1322,13 +1308,14 @@ static int extract_svc_value(char *svc_buf)
 
 static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
 {
-#ifdef USE_TCP
   rktio_fd_t *socket = NULL;
   rktio_listener_t *lnr = NULL;
   Scheme_Tcp *tcp = NULL;
   int closed = 0, require_peer = 0;
   Scheme_Object *result[4];
   int with_ports = 0;
+  intptr_t l;
+  char **local_names, **peer_names;
 
   if (SCHEME_OUTPUT_PORTP(argv[0])) {
     Scheme_Output_Port *op;
@@ -1355,14 +1342,12 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
     require_peer = 1;
   } else {
     if (SCHEME_LISTEN_PORTP(argv[0])) {
-      listener = 1;
       if (LISTENER_WAS_CLOSED(argv[0])) {
         scheme_raise_exn(MZEXN_FAIL_NETWORK,
                          "tcp-addresses: listener is closed");
       } else
         lnr = ((listener_t *)argv[0])->lnr;
     } else if (SCHEME_UDP_PORTP(argv[0])) {
-      udp = 1;
       socket = ((Scheme_UDP *)argv[0])->s;
       if (!socket)
         scheme_raise_exn(MZEXN_FAIL_NETWORK,
@@ -1373,9 +1358,9 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
   }
 
   if (socket)
-    local_names = rktio_socket_address(socket);
+    local_names = rktio_socket_address(scheme_rktio, socket);
   else
-    local_names = rktio_listener_address(lnr);
+    local_names = rktio_listener_address(scheme_rktio, lnr);
 
   if (!local_names)
     scheme_raise_exn(MZEXN_FAIL_NETWORK, 
@@ -1383,7 +1368,7 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
                      "  system error: %R");
 
   if (socket)
-    peer_names = rktio_socket_address(socket);
+    peer_names = rktio_socket_address(scheme_rktio, socket);
   else
     peer_names = NULL;
 
@@ -1406,9 +1391,9 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
     result[with_ports ? 2 : 1] = scheme_make_utf8_string("0.0.0.0");
     result[3] = scheme_make_integer(0);
   } else {
-    result[with_ports ? 2 : 1] = scheme_make_utf8_string(host_buf);
+    result[with_ports ? 2 : 1] = scheme_make_utf8_string(peer_names[0]);
     if (with_ports) {
-      l = extract_svc_value(svc_buf);
+      l = extract_svc_value(peer_names[1]);
       result[3] = scheme_make_integer(l);
     }
   }
@@ -1419,7 +1404,7 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
   if (peer_names) {
     free(peer_names[0]);
     free(peer_names[1]);
-    free(perr_names);
+    free(peer_names);
   }
   
   return scheme_values(with_ports ? 4 : 2, result);
@@ -1559,7 +1544,7 @@ int scheme_get_port_socket(Scheme_Object *p, intptr_t *_s)
 
   if (s_ok) {
     intptr_t sv;
-    sv = rktio_fd_system_fd(s);
+    sv = rktio_fd_system_fd(scheme_rktio, s);
     *_s = sv;
     return 1;
   } else
@@ -1573,7 +1558,7 @@ void scheme_socket_to_ports(intptr_t s, const char *name, int takeover,
   Scheme_Object *v;
   rktio_fd_t *rfd;
 
-  rfd = rktio_open(s, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET | RKTIO_OPEN_OWN);
+  rfd = rktio_system_fd(scheme_rktio, s, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET | RKTIO_OPEN_OWN);
 
   tcp = make_tcp_port_data(rfd, takeover ? 2 : 3);
 
@@ -1586,74 +1571,59 @@ void scheme_socket_to_ports(intptr_t s, const char *name, int takeover,
 void scheme_socket_to_input_port(intptr_t s, Scheme_Object *name, int takeover,
                                  Scheme_Object **_inp)
 {
-#ifdef USE_TCP
   Scheme_Tcp *tcp;
   Scheme_Object *v;
+  rktio_fd_t *fd;
 
-  tcp = make_tcp_port_data(s, takeover ? 1 : 2);
+  fd = rktio_system_fd(scheme_rktio, s, (RKTIO_OPEN_READ | RKTIO_OPEN_SOCKET
+                                         | RKTIO_OPEN_INIT
+                                         | (takeover ? RKTIO_OPEN_OWN : 0)));
+
+  tcp = make_tcp_port_data(fd, takeover ? 1 : 2);
 
   v = make_tcp_input_port_symbol_name(tcp, name, NULL);
   *_inp = v;
-  
-  if (takeover) {
-    REGISTER_SOCKET(s);
-  }
-#else
-  *_inp = NULL;
-#endif
 }
 
 void scheme_socket_to_output_port(intptr_t s, Scheme_Object *name, int takeover,
                                   Scheme_Object **_outp)
 {
-#ifdef USE_TCP
   Scheme_Tcp *tcp;
   Scheme_Object *v;
-
-  tcp = make_tcp_port_data(s, takeover ? 1 : 2);
+  rktio_fd_t *fd;
+  
+  fd = rktio_system_fd(scheme_rktio, s, (RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET
+                                         | RKTIO_OPEN_INIT
+                                         | (takeover ? RKTIO_OPEN_OWN : 0)));
+  
+  tcp = make_tcp_port_data(fd, takeover ? 1 : 2);
 
   v = make_tcp_output_port_symbol_name(tcp, name, NULL);
   *_outp = v;
-  
-  if (takeover) {
-    REGISTER_SOCKET(s);
-  }
-#else
-  *_outp = NULL;
-#endif
 }
 
 intptr_t scheme_dup_socket(intptr_t fd) {
-#ifdef USE_TCP
-# ifdef USE_WINSOCK_TCP
-  intptr_t nsocket;
-  intptr_t rc;
-  WSAPROTOCOL_INFO protocolInfo;
-  rc = WSADuplicateSocket(fd, GetCurrentProcessId(), &protocolInfo);
-  if (rc)
-    return rc;
-  nsocket = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, &protocolInfo, 0, WSA_FLAG_OVERLAPPED);
-  REGISTER_SOCKET(nsocket);
-  return nsocket;
-# else
-  intptr_t nfd;
-  do {
-    nfd = dup(fd);
-  } while (nfd == -1 && errno == EINTR);
-  return nfd;
-# endif
-#else
-  return -1;
-#endif
+  rktio_fd_t *rfd, *rfd2;
+  intptr_t s;
+
+  rfd = rktio_system_fd(scheme_rktio, fd, (RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET));
+  rfd2 = rktio_dup(scheme_rktio, rfd);
+
+  s = rktio_fd_system_fd(scheme_rktio, rfd2);
+
+  rktio_forget(scheme_rktio, rfd);
+  rktio_forget(scheme_rktio, rfd2);
+
+  return s;
 }
 
 void scheme_close_socket_fd(intptr_t fd) 
 {
-#ifdef USE_TCP
-  UNREGISTER_SOCKET(fd);
-  closesocket(fd);
-  (void)scheme_fd_to_semaphore(fd, MZFD_REMOVE, 1);
-#endif
+  rktio_fd_t *rfd;
+  
+  rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_SOCKET | RKTIO_OPEN_OWN);
+  (void)scheme_rktio_fd_to_semaphore(rfd, MZFD_REMOVE);
+  rktio_close(scheme_rktio, rfd);
 }
 
 /*========================================================================*/
@@ -1671,8 +1641,14 @@ typedef struct Scheme_UDP_Evt {
   rktio_addrinfo_t *dest_addr;
 } Scheme_UDP_Evt;
 
+static void free_dest_addr(void *udp_evt, void *ignored)
+{
+  Scheme_UDP_Evt *evt = (Scheme_UDP_Evt *)udp_evt;
+  rktio_addrinfo_free(scheme_rktio, evt->dest_addr);
+}
+
 static int udp_default_family() {
-  return rktio_get_ipv4_family();
+  return rktio_get_ipv4_family(scheme_rktio);
 }
 
 static int udp_close_it(Scheme_Object *_udp)
@@ -1680,8 +1656,8 @@ static int udp_close_it(Scheme_Object *_udp)
   Scheme_UDP *udp = (Scheme_UDP *)_udp;
 
   if (udp->s) {
-    (void)scheme_fd_to_semaphore(udp->s, MZFD_REMOVE, 1);
-    rktio_close(udp->s);
+    (void)scheme_rktio_fd_to_semaphore(udp->s, MZFD_REMOVE);
+    rktio_close(scheme_rktio, udp->s);
     udp->s = NULL;
 
     scheme_remove_managed(udp->mref, (Scheme_Object *)udp);
@@ -1700,8 +1676,6 @@ static Scheme_Object *make_udp(int argc, Scheme_Object *argv[])
   unsigned short id;
   rktio_addrinfo_t *addr;
 
-  TCP_INIT("udp-open-socket");
-
   if ((argc > 0) && !SCHEME_FALSEP(argv[0]) && !SCHEME_CHAR_STRINGP(argv[0]))
     scheme_wrong_contract("udp-open-socket", "(or/c string? #f)", 0, argc, argv);
   if ((argc > 1) && !SCHEME_FALSEP(argv[1]) && !CHECK_PORT_ID(argv[1]))
@@ -1718,7 +1692,7 @@ static Scheme_Object *make_udp(int argc, Scheme_Object *argv[])
   else
     id = 0;
 
-  scheme_security_check_network("udp-open-socket", address, origid, 0);
+  scheme_security_check_network("udp-open-socket", address, id, 0);
   scheme_custodian_check_available(NULL, "udp-open-socket", "network");
 
   if (address || id) {
@@ -1727,7 +1701,7 @@ static Scheme_Object *make_udp(int argc, Scheme_Object *argv[])
     if (!id)
       id = 1025;
 
-    addr = do_resolve_address("upd-open-socket", address, id, RKTIO_FAMILTY_ANY, show_id_on_error);
+    addr = do_resolve_address("upd-open-socket", address, id, RKTIO_FAMILY_ANY, show_id_on_error);
   } else
     addr = NULL;
 
@@ -1866,7 +1840,7 @@ static Scheme_Object *udp_bind_or_connect(const char *name, int argc, Scheme_Obj
       return scheme_void;
     }
 
-    addr = do_resolve_address(name, address, port, RKTIO_FAMILTY_ANY, 1);
+    addr = do_resolve_address(name, address, port, RKTIO_FAMILY_ANY, 1);
 
     if (!do_bind) {
       /* CONNECT CASE */
@@ -1927,7 +1901,7 @@ static int udp_check_send(Scheme_Object *_udp, Scheme_Schedule_Info *sinfo)
 {
   Scheme_UDP *udp = (Scheme_UDP *)_udp;
 
-  if (udp->s == INVALID_SOCKET)
+  if (!udp->s)
     return 1;
 
   if (!sinfo || !sinfo->is_poll) {
@@ -1957,9 +1931,9 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
   intptr_t x;
 
   while (1) {
-    if (udp->s!) {
+    if (!udp->s) {
       /* socket was closed, maybe while we slept */
-      if (free_addr) rktio_addrinfo_free(dest_addr);
+      if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
       if (can_error)
         scheme_raise_exn(MZEXN_FAIL_NETWORK,
                          "%s: udp socket is closed\n"
@@ -1970,7 +1944,7 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
     if ((!dest_addr && !udp->connected)
 	|| (dest_addr && udp->connected)) {
       /* socket is unconnected, maybe disconnected while we slept */
-      if (free_addr) rktio_addrinfo_free(dest_addr);
+      if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
       if (can_error)
         scheme_raise_exn(MZEXN_FAIL_NETWORK,
                          "%s: udp socket is%s connected\n"
@@ -1983,19 +1957,16 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
 
     udp->bound = 1; /* in case it's not bound already, send[to] binds it */
 
-    x = rktio_udp_sendto(scheme_rktio, udp->s, addr,
+    x = rktio_udp_sendto(scheme_rktio, udp->s, dest_addr,
                          bstr XFORM_OK_PLUS start, end - start);
     
     if (x == RKTIO_WRITE_ERROR) {
-      if (ignore_addr_failure && scheme_last_error_is_racket(RKTIO_ERROR_ADDRESS_FAILURE)) {
-        return NULL;
-      } else
-        break;
+      break;
     } else if (!x) {
       if (can_block) {
         /* Block and eventually try again. */
         Scheme_Object *sema;
-        sema = scheme_fd_to_semaphore(udp->s, MZFD_CREATE_WRITE, 1);
+        sema = scheme_rktio_fd_to_semaphore(udp->s, MZFD_CREATE_WRITE);
         if (sema)
           scheme_wait_sema(sema, 0);
         else
@@ -2003,11 +1974,13 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
                              udp_send_needs_wakeup, 
                              (Scheme_Object *)udp, 
                              0);
-      } else
+      } else {
+        if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
         return scheme_false;
+      }
     } else if (x != (end - start)) {
       /* this isn't supposed to happen: */
-      if (free_addr) rktio_addrinfo_free(dest_addr);
+      if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
       if (can_error)
         scheme_raise_exn(MZEXN_FAIL_NETWORK,
                          "%s: didn't send enough (%d != %d)", 
@@ -2017,11 +1990,12 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
     } else
       break;
   }
-    
+
+  if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
+
   if (x != RKTIO_WRITE_ERROR) {
     return (can_block ? scheme_void : scheme_true);
   } else {
-    if (free_addr) rktio_addrinfo_free(dest_addr);
     if (can_error)
       scheme_raise_exn(MZEXN_FAIL_NETWORK,
                        "%s: send failed\n"
@@ -2037,9 +2011,9 @@ static Scheme_Object *udp_send_it(const char *name, int argc, Scheme_Object *arg
   Scheme_UDP *udp;
   char *address = "";
   intptr_t start, end;
-  int delta, err;
+  int delta;
   unsigned short id;
-  rktio_addr_info *dest_addr;
+  rktio_addrinfo_t *dest_addr;
 
   udp = (Scheme_UDP *)argv[0];
 
@@ -2070,14 +2044,13 @@ static Scheme_Object *udp_send_it(const char *name, int argc, Scheme_Object *arg
 
     scheme_security_check_network(name, address, id, 1);
 
-    dest_addr = do_resolve_address(name, address, id, RKTIO_FAMILTY_ANY, 1);
+    dest_addr = do_resolve_address(name, address, id, RKTIO_FAMILY_ANY, 1);
   } else {
     dest_addr = NULL;
   }
     
   
   if (fill_evt) {
-    char *s;
     fill_evt->str = SCHEME_BYTE_STR_VAL(argv[3+delta]);
     fill_evt->offset = start;
     fill_evt->len = end - start;
@@ -2151,10 +2124,7 @@ static void udp_recv_needs_wakeup(Scheme_Object *_udp, void *fds)
 static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t start, intptr_t end, 
 		       int can_block, int can_error, Scheme_Object **v)
 {
-  intptr_t x;
-  int errid = 0;
-  char src_addr[MZ_SOCK_NAME_MAX_LEN];
-  unsigned int asize = sizeof(src_addr);
+  rktio_length_and_addrinfo_t *result;
 
   if (!udp->bound) {
     if (can_error)
@@ -2167,8 +2137,6 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
   }
 
   while (1) {
-    rktio_length_and_addrinfo_t *result;
-
     if (!udp->s) {
       /* socket was closed, maybe while we slept */
       if (can_error)
@@ -2179,7 +2147,7 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
       return -1;
     }
 
-    result = rktio_udp_recvfrom(scheme_rktio, udp->s, buf, end - start);
+    result = rktio_udp_recvfrom(scheme_rktio, udp->s, bstr XFORM_OK_PLUS start, end - start);
     
     if (!result) {
       if (scheme_last_error_is_racket(RKTIO_ERROR_TRY_AGAIN)
@@ -2193,7 +2161,7 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
         /* Block and eventually try again. */
         {
           Scheme_Object *sema;
-          sema = scheme_fd_to_semaphore(udp->s, MZFD_CREATE_READ, 1);
+          sema = scheme_rktio_fd_to_semaphore(udp->s, MZFD_CREATE_READ);
           if (sema)
             scheme_wait_sema(sema, 0);
           else
@@ -2213,12 +2181,14 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
     } else {
       /* Data received */
       char prev_buf[64];
+      int id;
 
       v[0] = scheme_make_integer(result->len);
     
       if (udp->previous_from_addr) {
         /* See if we can use this cached string */
         mzchar *s;
+        int j;
         s = SCHEME_CHAR_STR_VAL(udp->previous_from_addr);
         for (j = 0; s[j]; j++) {
           prev_buf[j] = (char)s[j];
@@ -2239,6 +2209,11 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
       
       v[2] = scheme_make_integer(id);
 
+      free(result->address[0]);
+      free(result->address[1]);
+      free(result->address);
+      free(result);
+
       return 1;
     }
   }
@@ -2267,8 +2242,8 @@ static Scheme_Object *udp_recv(const char *name, int argc, Scheme_Object *argv[]
     fill_evt->len = end - start;
     return scheme_void;
   } else {
-    do_udp_recv(name, udp, SCHEME_BYTE_STR_VAL(argv[1]), start, end, can_block, v, 1);
-    
+    do_udp_recv(name, udp, SCHEME_BYTE_STR_VAL(argv[1]), start, end, can_block, 1, v);
+
     return scheme_values(3,v);
   }
 }
@@ -2355,7 +2330,7 @@ static int udp_evt_check_ready(Scheme_Object *_uw, Scheme_Schedule_Info *sinfo)
       
       r = do_udp_recv("udp-receive!-evt", uw->udp, 
 		      uw->str, uw->offset, uw->offset + uw->len, 
-		      0, v, !sinfo->false_pos_ok);
+		      0, !sinfo->false_positive_ok, v);
       if (r) {
         if (r != -1)
           scheme_set_sync_target(sinfo, scheme_build_list(3, v), NULL, NULL, 0, 0, NULL);
@@ -2371,7 +2346,7 @@ static int udp_evt_check_ready(Scheme_Object *_uw, Scheme_Schedule_Info *sinfo)
       r = do_udp_send_it("udp-send-evt", uw->udp, 
                          uw->str, uw->offset, uw->offset + uw->len, 
                          uw->dest_addr, 0,
-                         0, !sinfo->false_pos_ok);
+                         0, !sinfo->false_positive_ok);
       if (!r || SCHEME_TRUEP(r)) {
 	scheme_set_sync_target(sinfo, scheme_void, NULL, NULL, 0, 0, NULL);
 	return 1;
@@ -2399,7 +2374,7 @@ static void udp_check_open(char const *name, int argc, Scheme_Object *argv[])
   if (!SCHEME_UDPP(argv[0]))
     scheme_wrong_contract(name, "udp?", 0, argc, argv);
 
-  if (udp->s == INVALID_SOCKET) {
+  if (!udp->s) {
     scheme_raise_exn(MZEXN_FAIL_NETWORK,
                      "%s: udp socket was already closed\n"
                      "  socket: %V",
@@ -2504,7 +2479,8 @@ static Scheme_Object *
 udp_multicast_set_interface(int argc, Scheme_Object *argv[])
 {
   Scheme_UDP *udp = (Scheme_UDP *)argv[0];
-  rktio_addr_info_t *addr;
+  rktio_addrinfo_t *addr;
+  Scheme_Object *bs;
   int r;
   
   if (!SCHEME_UDPP(argv[0]))
@@ -2517,10 +2493,15 @@ udp_multicast_set_interface(int argc, Scheme_Object *argv[])
 
   udp_check_open("udp-multicast-set-interface!", argc, argv);
 
-  addr = do_resolve_address("udp-multicast-set-interface!", SCHEME_BYTE_STR_VAL(bs), -1, udp_default_family(), 0);
+  if (SCHEME_CHAR_STRINGP(argv[1])) {
+    bs = scheme_char_string_to_byte_string(argv[1]);
+    addr = do_resolve_address("udp-multicast-set-interface!", SCHEME_BYTE_STR_VAL(bs), -1, udp_default_family(), 0);
+  } else
+    addr = NULL;
 
-  r = rktio_udp_set_multicast_interface(scheme_rktio, scheme_rktio, addr);
-  rktio_addrinfo_free(addr);
+  r = rktio_udp_set_multicast_interface(scheme_rktio, udp->s, addr);
+
+  if (addr) rktio_addrinfo_free(scheme_rktio, addr);
 
   if (!r)
     scheme_raise_exn(MZEXN_FAIL_NETWORK,
@@ -2529,7 +2510,6 @@ udp_multicast_set_interface(int argc, Scheme_Object *argv[])
 
   return scheme_void;
 }
-}
 
 static Scheme_Object *
 do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *udp,
@@ -2539,6 +2519,8 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
   Scheme_Object *bs;
   rktio_addrinfo_t *multi_addr, *intf_addr;
   char *address;
+  rktio_addrinfo_lookup_t *lookup;
+  int r;
 
   pd = make_connect_progress_data();
 
@@ -2566,10 +2548,10 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
 
   pd->dest_addr = multi_addr;
 
-  if (SCHEME_FALSEP(intfaddrname)) {
+  if (SCHEME_FALSEP(ifaddrname)) {
     intf_addr = NULL;
   } else {
-    bs = scheme_char_string_to_byte_string(intfaddrname);
+    bs = scheme_char_string_to_byte_string(ifaddrname);
     address = SCHEME_BYTE_STR_VAL(bs);
 
     lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, -1, udp_default_family(), 0, 0);
@@ -2583,7 +2565,7 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
       intf_addr = NULL;
 
     if (!intf_addr) {
-      rktio_addrinfo_free(multi_addr);
+      rktio_addrinfo_free(scheme_rktio, multi_addr);
       scheme_raise_exn(MZEXN_FAIL_NETWORK,
                        "%s: can't resolve interface address\n"
                        "  address: %s\n"
@@ -2598,8 +2580,8 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
                                        intf_addr,
                                        optname);
 
-  rktio_addrinfo_free(multi_addr);
-  if (intf_addr) rktio_addrinfo_free(intf_addr);
+  rktio_addrinfo_free(scheme_rktio, multi_addr);
+  if (intf_addr) rktio_addrinfo_free(scheme_rktio, intf_addr);
   
 
   if (!r) 
@@ -2678,5 +2660,3 @@ static void register_traversers(void)
 END_XFORM_SKIP;
 
 #endif
-
-#endif /* !NO_TCP_SUPPORT */
diff --git a/racket/src/racket/src/port.c b/racket/src/racket/src/port.c
index 21c54bc628..e6e006747b 100644
--- a/racket/src/racket/src/port.c
+++ b/racket/src/racket/src/port.c
@@ -31,6 +31,8 @@
 
 #include "schpriv.h"
 #include "schmach.h"
+#include "schrktio.h"
+#include <errno.h>
 
 #define mzAssert(x) /* if (!(x)) abort() */
 
@@ -51,6 +53,7 @@ typedef struct {
 typedef struct Scheme_Subprocess {
   Scheme_Object so;
   rktio_process_t *proc;
+  Scheme_Custodian_Reference *mref;
 } Scheme_Subprocess;
 
 /******************** refcounts ********************/
@@ -108,13 +111,15 @@ static int adj_refcount(int *refcount, int amt)
 
 static int *stdin_refcount, *stdout_refcount, *stderr_refcount;
 
+# define MZPORT_FD_BUFFSIZE 4096
+# define MZPORT_FD_DIRECT_THRESHOLD MZPORT_FD_BUFFSIZE
+
 /* The Scheme_FD type is used for both input and output */
 typedef struct Scheme_FD {
   MZTAG_IF_REQUIRED
-  rktio_fd_t fd;
+  rktio_fd_t *fd;
   intptr_t bufcount, buffpos;
   char flushing, flush;
-  unsigned char *buffer;
   char *buffer;
   int *refcount;
   Scheme_Object *flush_handle; /* output port: registration with plumber */
@@ -139,8 +144,8 @@ int scheme_get_serialized_fd_flags(Scheme_Object* p, Scheme_Serialized_File_FD *
     fds = (Scheme_FD *) ((Scheme_Output_Port *)p)->port_data;
     so->name = ((Scheme_Output_Port *)p)->name;
   }
-  so->regfile = rktio_fd_is_regular_file(fds->fd);
-  so->textmode = (fds->textmode ? 1 : 0);
+  so->regfile = rktio_fd_is_regular_file(scheme_rktio, fds->fd);
+  so->textmode = rktio_fd_is_text_converted(scheme_rktio, fds->fd);
   so->flush_mode = fds->flush;
   return 1;
 }
@@ -186,10 +191,8 @@ THREAD_LOCAL_DECL(static int the_fd);
 READ_ONLY static Scheme_Object *fd_input_port_type;
 READ_ONLY static Scheme_Object *file_input_port_type;
 READ_ONLY Scheme_Object *scheme_string_input_port_type;
-#ifdef USE_TCP
 READ_ONLY Scheme_Object *scheme_tcp_input_port_type;
 READ_ONLY Scheme_Object *scheme_tcp_output_port_type;
-#endif
 READ_ONLY static Scheme_Object *fd_output_port_type;
 READ_ONLY static Scheme_Object *file_output_port_type;
 READ_ONLY Scheme_Object *scheme_string_output_port_type;
@@ -214,12 +217,10 @@ THREAD_LOCAL_DECL(static int put_external_event_fd);
 
 static void register_port_wait();
 
-#ifdef MZ_FDS
 static intptr_t flush_fd(Scheme_Output_Port *op,
                          const char * volatile bufstr, volatile uintptr_t buflen,
                          volatile uintptr_t offset, int immediate_only, int enable_break);
 static void flush_if_output_fds(Scheme_Object *o, Scheme_Close_Custodian_Client *f, void *data);
-#endif
 
 static Scheme_Object *subprocess(int c, Scheme_Object *args[]);
 static Scheme_Object *subprocess_status(int c, Scheme_Object *args[]);
@@ -232,6 +233,8 @@ static Scheme_Object *current_subproc_cust_mode (int, Scheme_Object *[]);
 static Scheme_Object *subproc_group_on (int, Scheme_Object *[]);
 static void register_subprocess_wait();
 
+static void unix_turn_off_timer(void);
+
 typedef struct Scheme_Read_Write_Evt {
   Scheme_Object so;
   Scheme_Object *port;
@@ -247,12 +250,7 @@ static int progress_evt_ready(Scheme_Object *rww, Scheme_Schedule_Info *sinfo);
 static int closed_evt_ready(Scheme_Object *rww, Scheme_Schedule_Info *sinfo);
 static int filesystem_change_evt_ready(Scheme_Object *evt, Scheme_Schedule_Info *sinfo);
 
-#if defined(DOS_FILE_SYSTEM) || defined(HAVE_INOTIFY_SYSCALL)
 static void filesystem_change_evt_need_wakeup (Scheme_Object *port, void *fds);
-#else
-# define filesystem_change_evt_need_wakeup NULL
-#endif
-
 
 static Scheme_Object *
 _scheme_make_named_file_input_port(FILE *fp, Scheme_Object *name, int regfile);
@@ -344,10 +342,8 @@ scheme_init_port (Scheme_Env *env)
   REGISTER_SO(fd_output_port_type);
   REGISTER_SO(file_input_port_type);
   REGISTER_SO(scheme_string_input_port_type);
-#ifdef USE_TCP
   REGISTER_SO(scheme_tcp_input_port_type);
   REGISTER_SO(scheme_tcp_output_port_type);
-#endif
   REGISTER_SO(file_output_port_type);
   REGISTER_SO(scheme_string_output_port_type);
   REGISTER_SO(scheme_user_input_port_type);
@@ -357,10 +353,6 @@ scheme_init_port (Scheme_Env *env)
   REGISTER_SO(scheme_null_output_port_type);
   REGISTER_SO(scheme_redirect_output_port_type);
 
-#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
-  REGISTER_SO(scheme_system_children);
-#endif
-
 #ifndef DONT_IGNORE_PIPE_SIGNAL
   START_XFORM_SKIP;
   MZ_SIGSET(SIGPIPE, SIG_IGN);
@@ -387,10 +379,8 @@ scheme_init_port (Scheme_Env *env)
   scheme_pipe_read_port_type = scheme_make_port_type("<pipe-input-port>");
   scheme_pipe_write_port_type = scheme_make_port_type("<pipe-output-port>");
 
-#ifdef USE_TCP
   scheme_tcp_input_port_type = scheme_make_port_type("<tcp-input-port>");
   scheme_tcp_output_port_type = scheme_make_port_type("<tcp-output-port>");
-#endif
 
   scheme_null_output_port_type = scheme_make_port_type("<null-output-port>");
   scheme_redirect_output_port_type = scheme_make_port_type("<redirect-output-port>");
@@ -423,7 +413,6 @@ void scheme_init_port_wait()
 void scheme_init_port_places(void)
 {
 
-#ifdef MZ_FDS
   scheme_add_atexit_closer(flush_if_output_fds);
   /* Note: other threads might continue to write even after
      the flush completes, but that's the threads' problem.
@@ -438,7 +427,6 @@ void scheme_init_port_places(void)
     stdout_refcount = malloc_refcount(1, 0);
     stderr_refcount = malloc_refcount(1, 0);
   }
-#endif
 
   REGISTER_SO(read_string_byte_buffer);
   REGISTER_SO(scheme_orig_stdout_port);
@@ -446,26 +434,24 @@ void scheme_init_port_places(void)
   REGISTER_SO(scheme_orig_stdin_port);
   scheme_orig_stdin_port = (scheme_make_stdin
 			    ? scheme_make_stdin()
-			    : make_fd_input_port(rktio_std_fd(RKTIO_STDIN), scheme_intern_symbol("stdin"), 0,
+			    : make_fd_input_port(rktio_std_fd(scheme_rktio, RKTIO_STDIN), scheme_intern_symbol("stdin"),
 						 stdin_refcount, 0));
 
   scheme_orig_stdout_port = (scheme_make_stdout
 			     ? scheme_make_stdout()
-			     : make_fd_output_port(rktio_std_fd(RKTIO_STDOUT), scheme_intern_symbol("stdout"), 0, 0,
+			     : make_fd_output_port(rktio_std_fd(scheme_rktio, RKTIO_STDOUT), scheme_intern_symbol("stdout"), 0,
                                                    -1, stdout_refcount));
 
   scheme_orig_stderr_port = (scheme_make_stderr
 			     ? scheme_make_stderr()
-			     : make_fd_output_port(rktio_std_fd(RKTIO_STDERR), scheme_intern_symbol("stderr"), 0, 0,
+			     : make_fd_output_port(rktio_std_fd(scheme_rktio, RKTIO_STDERR), scheme_intern_symbol("stderr"), 0,
                                                    MZ_FLUSH_ALWAYS, stderr_refcount));
 
-#ifdef MZ_FDS
   if (!scheme_current_place_id) {
     adj_refcount(stdin_refcount, -1);
     adj_refcount(stdout_refcount, -1);
     adj_refcount(stderr_refcount, -1);
   }
-#endif
 
   flush_out = SCHEME_TRUEP(scheme_terminal_port_p(1, &scheme_orig_stdout_port));
   flush_err = SCHEME_TRUEP(scheme_terminal_port_p(1, &scheme_orig_stderr_port));
@@ -517,7 +503,7 @@ void scheme_add_fd_handle(void *h, void *fds, int repost)
 
 void scheme_add_fd_nosleep(void *fds)
 {
-  rktio_poll_set_nosleep(scheme_rktio, fds);
+  rktio_poll_set_add_nosleep(scheme_rktio, fds);
 }
 
 void scheme_add_fd_eventmask(void *fds, int mask)
@@ -3288,10 +3274,8 @@ scheme_file_stream_port_p (int argc, Scheme_Object *argv[])
 
     if (SAME_OBJ(ip->sub_type, file_input_port_type))
       return scheme_true;
-#ifdef MZ_FDS
     else if (SAME_OBJ(ip->sub_type, fd_input_port_type))
       return scheme_true;
-#endif
   } else if (SCHEME_OUTPUT_PORTP(p)) {
     Scheme_Output_Port *op;
 
@@ -3299,10 +3283,8 @@ scheme_file_stream_port_p (int argc, Scheme_Object *argv[])
 
     if (SAME_OBJ(op->sub_type, file_output_port_type))
       return scheme_true;
-#ifdef MZ_FDS
     else if (SAME_OBJ(op->sub_type, fd_output_port_type))
       return scheme_true;
-#endif
   } else {
     scheme_wrong_contract("file-stream-port?", "port?", 0, argc, argv);
   }
@@ -3352,7 +3334,7 @@ int scheme_get_port_file_descriptor(Scheme_Object *p, intptr_t *_fd)
   return 1;
 }
 
-int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, rktio_fd_t *_fd)
+int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, rktio_fd_t **_fd)
 {
   if (SCHEME_INPUT_PORTP(p)) {
     Scheme_Input_Port *ip;
@@ -3430,9 +3412,9 @@ static int is_fd_terminal(intptr_t fd)
   rktio_fd_t *rfd;
   int is_term;
   
-  rfd = rktio_system_fd(fd, RKTIO_OPEN_NOT_REGFILE);
+  rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_NOT_REGFILE);
   is_term = rktio_fd_is_terminal(scheme_rktio, rfd);
-  rktio_fd_forget(rfd);
+  rktio_forget(scheme_rktio, rfd);
 
   return is_term;
 }
@@ -3457,12 +3439,10 @@ Scheme_Object *scheme_terminal_port_p(int argc, Scheme_Object *argv[])
       fd = MSC_IZE(fileno)((FILE *)((Scheme_Input_File *)ip->port_data)->f);
       fd_ok = 1;
     }
-#ifdef MZ_FDS
     else if (SAME_OBJ(ip->sub_type, fd_input_port_type)) {
-      fd = rktio_fd_to_system_fd(((Scheme_FD *)ip->port_data)->fd);
+      fd = rktio_fd_system_fd(scheme_rktio, ((Scheme_FD *)ip->port_data)->fd);
       fd_ok = 1;
     }
-#endif
   } else if (SCHEME_OUTPUT_PORTP(p)) {
     Scheme_Output_Port *op;
 
@@ -3475,12 +3455,10 @@ Scheme_Object *scheme_terminal_port_p(int argc, Scheme_Object *argv[])
       fd = MSC_IZE (fileno)((FILE *)((Scheme_Output_File *)op->port_data)->f);
       fd_ok = 1;
     }
-#ifdef MZ_FDS
     else if (SAME_OBJ(op->sub_type, fd_output_port_type))  {
-      fd = rktio_fd_to_system_fd(((Scheme_FD *)op->port_data)->fd);
+      fd = rktio_fd_system_fd(scheme_rktio, ((Scheme_FD *)op->port_data)->fd);
       fd_ok = 1;
     }
-#endif
   }
 
   if (!fd_ok)
@@ -3513,7 +3491,7 @@ static void filename_exn(char *name, char *msg, char *filename, int maybe_module
   rel = dir ? dir : (drive ? drive : "");
   post = dir ? "" : "";
 
-  if (maybe_module_errno && (err == maybe_module_errno)) {
+  if (maybe_module_errno && scheme_last_error_is_racket(maybe_module_errno)) {
     mod_path = scheme_get_param(scheme_current_config(), MZCONFIG_CURRENT_MODULE_LOAD_PATH);
     if (SCHEME_TRUEP(mod_path)) {
       if (SCHEME_STXP(mod_path)) {
@@ -3561,7 +3539,7 @@ scheme_do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[
                           int internal, int for_module)
 {
   char *filename;
-  int regfile, i;
+  int i;
   int m_set = 0, mm_set = 0, text_mode = 0;
   rktio_fd_t *fd;
 
@@ -3616,8 +3594,8 @@ scheme_do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[
   if (!internal)
     scheme_custodian_check_available(NULL, name, "file-stream");
 
-  fd = rktio_open(filename, (RKTIO_OPEN_READ
-                             | (text_mode ? RKTIO_OPEN_TEXT : 0)));
+  fd = rktio_open(scheme_rktio, filename, (RKTIO_OPEN_READ
+                                           | (text_mode ? RKTIO_OPEN_TEXT : 0)));
 
   if (!fd) {
     filename_exn(name, "cannot open input file", filename, RKTIO_ERROR_DOES_NOT_EXIST);
@@ -3636,6 +3614,7 @@ scheme_do_open_output_file(char *name, int offset, int argc, Scheme_Object *argv
   char *filename;
   char mode[4];
   int typepos;
+  rktio_fd_t *fd;
 
   mode[0] = 'w';
   mode[1] = 'b';
@@ -3738,9 +3717,9 @@ scheme_do_open_output_file(char *name, int offset, int argc, Scheme_Object *argv
 
   scheme_custodian_check_available(NULL, name, "file-stream");
 
-  fd = rktio_open(filename, (RKTIO_OPEN_WRITE
-                             | (and_read ? RKTIO_OPEN_READ : 0)
-                             | ((mode[1] == 't') ? RKTIO_OPEN_TEXT : 0)));
+  fd = rktio_open(scheme_rktio, filename, (RKTIO_OPEN_WRITE
+                                           | (and_read ? RKTIO_OPEN_READ : 0)
+                                           | ((mode[1] == 't') ? RKTIO_OPEN_TEXT : 0)));
 
   if (!fd) {
     if (scheme_last_error_is_racket(RKTIO_ERROR_EXISTS)) {
@@ -3943,9 +3922,6 @@ do_file_position(const char *who, int argc, Scheme_Object *argv[], int can_false
 			 errno);
       }
     } else if (fd) {
-      intptr_t lv;
-      int errid = 0;
-      
       if (!SCHEME_INPUT_PORTP(argv[0])) {
 	flush_fd(scheme_output_port_record(argv[0]), NULL, 0, 0, 0, 0);
       }
@@ -3953,7 +3929,7 @@ do_file_position(const char *who, int argc, Scheme_Object *argv[], int can_false
       if (!rktio_set_file_position(scheme_rktio, fd, nll,
                                    ((whence == SEEK_SET)
                                     ? RKTIO_POSITION_FROM_START
-                                    : RKTIO_POSITION_FROM__END))) {
+                                    : RKTIO_POSITION_FROM_END))) {
 	scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
 			 "file-position: position change failed on stream\n"
                          "  system error: %R");
@@ -4049,12 +4025,12 @@ do_file_position(const char *who, int argc, Scheme_Object *argv[], int can_false
           Scheme_Input_Port *ip;
           ip = scheme_input_port_record(argv[0]);
 	  pll -= ((Scheme_FD *)ip->port_data)->bufcount;
-          if (rktio_fd_is_text_converted(fd)) {
+          if (rktio_fd_is_text_converted(scheme_rktio, fd)) {
             /* Correct for CRLF->LF conversion of buffer content */
             int bp, bd;
             bd = ((Scheme_FD *)ip->port_data)->buffpos;
             for (bp = ((Scheme_FD *)ip->port_data)->bufcount; bp--; ) {
-              if (ip->bufwidths[bp + bd]) {
+              if (((Scheme_FD *)ip->port_data)->bufwidths[bp + bd]) {
                 /* this is a LF converted from CRLF */
                 pll--;
               }
@@ -4106,7 +4082,7 @@ Scheme_Object *scheme_file_truncate(int argc, Scheme_Object *argv[])
   mzlonglong nll;
   Scheme_Output_Port *op;
   rktio_fd_t *fd;
-  int errid;
+  int free_fd = 0, ok;
 
   if (!SCHEME_OUTPUT_PORTP(argv[0])
       || SCHEME_FALSEP(scheme_file_stream_port_p(1, argv)))
@@ -4125,22 +4101,28 @@ Scheme_Object *scheme_file_truncate(int argc, Scheme_Object *argv[])
   op = scheme_output_port_record(argv[0]);
   
   if (SAME_OBJ(op->sub_type, file_output_port_type)) {
-    fd = MSC_IZE (fileno)((FILE *)((Scheme_Output_File *)op->port_data)->f);
+    intptr_t sfd;
+    sfd = MSC_IZE (fileno)((FILE *)((Scheme_Output_File *)op->port_data)->f);
+    fd = rktio_system_fd(scheme_rktio, sfd, RKTIO_OPEN_NOT_REGFILE);
+    free_fd = 1;
   } else if (SAME_OBJ(op->sub_type, fd_output_port_type)) {
     fd = ((Scheme_FD *)op->port_data)->fd;
   } else
     return scheme_void;
 
-  errid = -1;
   flush_fd(scheme_output_port_record(argv[0]), NULL, 0, 0, 0, 0);
+
+  ok = rktio_set_file_size(scheme_rktio, fd, nll);
+
+  if (free_fd) rktio_forget(scheme_rktio, fd);
   
-  if (!rktio_set_file_size(scheme_rktio, fd, nll)) {
+  if (!ok) {
     scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
                      "file-truncate: size change failed\n"
                      "  system error: %R");
   }
 
-  return NULL;
+  return scheme_void;
 }
 
 intptr_t scheme_set_file_position(Scheme_Object *port, intptr_t pos)
@@ -4275,11 +4257,11 @@ Scheme_Object *scheme_file_try_lock(int argc, Scheme_Object **argv)
   check_already_closed("port-try-file-lock?", argv[0]);
 
   if (!rfd) {
-    rfd = scheme_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE);
-    r = rktio_file_lock_try(scheme_rktio, rfd, write);
+    rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
+    r = rktio_file_lock_try(scheme_rktio, rfd, writer);
     rktio_forget(scheme_rktio, rfd);
   } else
-    r = rktio_file_lock_try(scheme_rktio, rfd, write);
+    r = rktio_file_lock_try(scheme_rktio, rfd, writer);
 
   if (r == RKTIO_LOCK_ACQUIRED)
     return scheme_true;
@@ -4307,11 +4289,11 @@ Scheme_Object *scheme_file_unlock(int argc, Scheme_Object **argv)
   check_already_closed("port-file-unlock", argv[0]);
 
   if (!rfd) {
-    rfd = scheme_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE);
-    r = rktio_file_unlock(scheme_rktio, rfd, write);
+    rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
+    r = rktio_file_unlock(scheme_rktio, rfd);
     rktio_forget(scheme_rktio, rfd);
   } else
-    r = rktio_file_unlock(rktio, fd);
+    r = rktio_file_unlock(scheme_rktio, rfd);
 
   if (!r) {
     scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
@@ -4329,15 +4311,12 @@ Scheme_Object *scheme_file_unlock(int argc, Scheme_Object **argv)
 Scheme_Object *scheme_filesystem_change_evt(Scheme_Object *path, int flags, int signal_errs)
 {
   char *filename;
-  int ok = 0;
   rktio_fs_change_t *rfc;
 
   filename = scheme_expand_string_filename(path,
 					   "filesystem-change-evt",
 					   NULL,
 					   SCHEME_GUARD_FILE_EXISTS);
-  fd = 0;
-
   rfc = rktio_fs_change(scheme_rktio, filename);
   
   if (!rfc) {
@@ -4383,8 +4362,8 @@ void scheme_filesystem_change_evt_cancel(Scheme_Object *evt, void *ignored_data)
 static int filesystem_change_evt_ready(Scheme_Object *evt, Scheme_Schedule_Info *sinfo)
 {
   Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)evt;
-
-  if (!fc->rfd)
+  
+  if (!fc->rfc)
     return 1;
 
   if (rktio_poll_fs_change_ready(scheme_rktio, fc->rfc))
@@ -4393,7 +4372,7 @@ static int filesystem_change_evt_ready(Scheme_Object *evt, Scheme_Schedule_Info
   return 0;
 }
 
-static void filesystem_change_evt_need_wakeup (Scheme_Object *evt, void *fds)
+static void filesystem_change_evt_need_wakeup(Scheme_Object *evt, void *fds)
 {
   Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)evt;
 
@@ -4558,7 +4537,7 @@ fd_byte_ready (Scheme_Input_Port *port)
 {
   Scheme_FD *fip = (Scheme_FD *)port->port_data;
 
-  if (fip->regfile || port->closed)
+  if (port->closed || rktio_fd_is_regular_file(scheme_rktio, fip->fd))
     return 1;
 
   if (fip->bufcount)
@@ -4606,7 +4585,7 @@ static intptr_t fd_get_string_slow(Scheme_Input_Port *port,
       if (nonblock > 0)
         return 0;
       
-      sema = scheme_fd_to_semaphore(fip->fd, MZFD_CREATE_READ, 0);
+      sema = scheme_rktio_fd_to_semaphore(fip->fd, MZFD_CREATE_READ);
 
       if (sema)
         scheme_wait_sema(sema, nonblock ? -1 : 0);
@@ -4762,9 +4741,9 @@ fd_close_input(Scheme_Input_Port *port)
 
   rc = adj_refcount(fip->refcount, -1);
   if (!rc) {
-    rktio_close(fip->fd);
+    rktio_close(scheme_rktio, fip->fd);
   } else {
-    rktio_forget(fip->fd);
+    rktio_forget(scheme_rktio, fip->fd);
   }
 }
 
@@ -4794,7 +4773,7 @@ make_fd_input_port(rktio_fd_t *fd, Scheme_Object *name, int *refcount, int inter
 {
   Scheme_Input_Port *ip;
   Scheme_FD *fip;
-  unsigned char *bfr;
+  char *bfr;
   int start_closed = 0;
 
   fip = MALLOC_ONE_RT(Scheme_FD);
@@ -4802,7 +4781,7 @@ make_fd_input_port(rktio_fd_t *fd, Scheme_Object *name, int *refcount, int inter
   fip->type = scheme_rt_input_fd;
 #endif
 
-  bfr = (unsigned char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
+  bfr = (char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
   fip->buffer = bfr;
   if (rktio_fd_is_text_converted(scheme_rktio, fd)) {
     char *bws;
@@ -4818,7 +4797,7 @@ make_fd_input_port(rktio_fd_t *fd, Scheme_Object *name, int *refcount, int inter
     if (!adj_refcount(refcount, 1)) {
       /* fd is already closed! */
       start_closed = 1;
-      rktio_fd_forget(fd);
+      rktio_forget(scheme_rktio, fd);
       fip->fd = NULL;
     }
   }
@@ -4859,7 +4838,7 @@ scheme_make_fd_input_port(int fd, Scheme_Object *name, int regfile, int textmode
                          | (regfile
                             ? RKTIO_OPEN_REGFILE
                             : RKTIO_OPEN_NOT_REGFILE)
-                         | (textmode ? RKTIO_OPEN_TEXT)));
+                         | (textmode ? RKTIO_OPEN_TEXT : 0)));
   
   return make_fd_input_port(rfd, name, NULL, 0);
 }
@@ -5000,7 +4979,7 @@ fd_write_ready (Scheme_Object *port)
   if (op->closed)
     return 1;
 
-  if (rktio_poll_write_ready(scheme_rktio, fop->fd);
+  return rktio_poll_write_ready(scheme_rktio, fop->fd);
 }
 
 static void
@@ -5009,7 +4988,10 @@ fd_write_need_wakeup(Scheme_Object *port, void *fds)
   Scheme_Output_Port *op;
   Scheme_FD *fop;
 
-  rktio_poll_add(scheme_rktio, fds, fop->fd, RKTIO_POLL_WRITE);
+  op = scheme_output_port_record(port);
+  fop = (Scheme_FD *)op->port_data;
+
+  rktio_poll_add(scheme_rktio, fop->fd, fds, RKTIO_POLL_WRITE);
 }
 
 static void release_flushing_lock(void *_fop)
@@ -5060,9 +5042,8 @@ static intptr_t flush_fd(Scheme_Output_Port *op,
 
     while (1) {
       intptr_t len;
-      int errsaved, full_write_buffer;
 
-      len = rktio_write(scheme_rktio, fop->fd, bufstr + offset, amt);
+      len = rktio_write(scheme_rktio, fop->fd, bufstr + offset, buflen - offset);
 
       if (!len) {
         /* Need to block; remember that we're holding a lock. */
@@ -5073,7 +5054,7 @@ static intptr_t flush_fd(Scheme_Output_Port *op,
           return wrote;
         }
 
-        sema = scheme_fd_to_semaphore(fop->fd, MZFD_CREATE_WRITE, 0);
+        sema = scheme_rktio_fd_to_semaphore(fop->fd, MZFD_CREATE_WRITE);
 
         BEGIN_ESCAPEABLE(release_flushing_lock, fop);
         if (sema)
@@ -5088,12 +5069,11 @@ static intptr_t flush_fd(Scheme_Output_Port *op,
 	if (scheme_force_port_closed) {
 	  /* Don't signal exn or wait. Just give up. */
 	  return wrote;
-	} else  else {
+	} else {
 	  fop->flushing = 0;
 	  scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
 			   "error writing to stream port\n"
-                           "  system error: %R",
-			   errsaved);
+                           "  system error: %R");
 	  return 0; /* doesn't get here */
           }
       } else if ((len + offset == buflen) || immediate_only) {
@@ -5215,7 +5195,7 @@ static int end_fd_flush_done(Scheme_Object *fop)
 
 static void end_fd_flush_needs_wakeup(Scheme_Object *fop, void *fds)
 {
-  rktio_poll_add(scheme_rktio, fds, ((Scheme_FD *)fop)->fd, RKTIO_POLL_FLUSH);
+  rktio_poll_add(scheme_rktio, ((Scheme_FD *)fop)->fd, fds, RKTIO_POLL_FLUSH);
 }
   
 static void
@@ -5247,9 +5227,9 @@ fd_close_output(Scheme_Output_Port *port)
   rc = adj_refcount(fop->refcount, -1);
   if (fop->fd) {
     if (!rc)
-      rktio_close(scheme_rktio, (HANDLE)fop->fd);
+      rktio_close(scheme_rktio, fop->fd);
     else
-      rktio_fd_forget(scheme_rktio, (HANDLE)fop->fd);
+      rktio_forget(scheme_rktio, fop->fd);
   }
 }
 
@@ -5282,7 +5262,7 @@ static Scheme_Object *
 make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush_mode, int *refcount)
 {
   Scheme_FD *fop;
-  unsigned char *bfr;
+  char *bfr;
   Scheme_Object *the_port, *fh;
   int start_closed = 0;
 
@@ -5291,7 +5271,7 @@ make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush
   fop->type = scheme_rt_input_fd;
 #endif
 
-  bfr = (unsigned char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
+  bfr = (char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
   fop->buffer = bfr;
 
   fop->fd = fd;
@@ -5299,7 +5279,7 @@ make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush
 
   if (flush_mode > -1) {
     fop->flush = flush_mode;
-  } else if (is_fd_terminal(fd)) {
+  } else if (rktio_fd_is_terminal(scheme_rktio, fd)) {
     /* Line-buffering for terminal: */
     fop->flush = MZ_FLUSH_BY_LINE;
   } else {
@@ -5342,7 +5322,7 @@ make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush
     rc = malloc_refcount(1, 1);
     fop->refcount = rc;
     a[1] = the_port;
-    a[0] = make_fd_input_port(fd, name, regfile, win_textmode, rc, 0);
+    a[0] = make_fd_input_port(fd, name, rc, 0);
     return scheme_values(2, a);
   } else
     return the_port;
@@ -5371,7 +5351,7 @@ scheme_make_fd_output_port(int fd, Scheme_Object *name, int regfile, int textmod
   rfd = rktio_system_fd(scheme_rktio,
                         fd,
                         (RKTIO_OPEN_WRITE
-                         | (regefile ? RKTIO_OPEN_REGFILE : RKTIO_OPEN_NOT_REGFILE)
+                         | (regfile ? RKTIO_OPEN_REGFILE : RKTIO_OPEN_NOT_REGFILE)
                          | (read_too ? RKTIO_OPEN_READ : 0)
                          | (textmode ? RKTIO_OPEN_TEXT : 0)));
   
@@ -5737,7 +5717,7 @@ static void subp_needs_wakeup(Scheme_Object *so, void *fds)
   Scheme_Subprocess *sp = (Scheme_Subprocess*)so;
 
   if (sp->proc)
-    rktio_poll_add_process(rktio_t *rktio, sp->proc, fds);
+    rktio_poll_add_process(scheme_rktio, sp->proc, fds);
 }
 
 static Scheme_Object *subprocess_status(int argc, Scheme_Object **argv)
@@ -5760,7 +5740,7 @@ static Scheme_Object *subprocess_status(int argc, Scheme_Object **argv)
     free(st);
     return scheme_intern_symbol("running");
   } else {
-    int status = st->status;
+    int status = st->result;
     free(st);
     child_mref_done(sp);
     return scheme_make_integer_value(status);
@@ -5791,6 +5771,7 @@ static Scheme_Object *subprocess_wait(int argc, Scheme_Object **argv)
 static Scheme_Object *do_subprocess_kill(Scheme_Object *_sp, Scheme_Object *killp, int can_error)
 {
   Scheme_Subprocess *sp = (Scheme_Subprocess *)_sp;
+  int ok;
 
   if (!sp->proc)
     return scheme_void;
@@ -5830,6 +5811,8 @@ static Scheme_Object *subprocess_kill(int argc, Scheme_Object **argv)
 
 static Scheme_Object *subprocess_pid(int argc, Scheme_Object **argv)
 {
+  intptr_t pid;
+  
   if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_subprocess_type))
     scheme_wrong_contract("subprocess-pid", "subprocess?", 0, argc, argv);
 
@@ -5881,14 +5864,17 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
   Scheme_Object *errport;
   Scheme_Object *a[4];
   Scheme_Subprocess *subproc;
-  Scheme_Object *cust_mode;
+  Scheme_Object *cust_mode, *current_dir;
   int flags = 0;
   rktio_fd_t *stdout_fd = NULL;
   rktio_fd_t *stdin_fd = NULL;
   rktio_fd_t *stderr_fd = NULL;
-  int need_forget_out = 0, need_forget_in = 0, need_forget_err = 0;
+  int need_forget_out = 0, need_forget_in = 0, need_forget_err = 0, new_process_group = 0;
   rktio_envvars_t *envvars;
   rktio_process_result_t *result;
+  Scheme_Config *config;
+  int argc;
+  char **argv, *command;
 
   /*--------------------------------------------*/
   /* Sort out ports (create later if necessary) */
@@ -5904,7 +5890,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
       if (SAME_OBJ(op->sub_type, file_output_port_type)) {
 	int tmp;
 	tmp = MSC_IZE(fileno)(((Scheme_Output_File *)op->port_data)->f);
-        stdout_fd = rktio_system_fd(tmp, RKTIO_OPEN_WRITE | RKTIO_NOT_REGFILE);
+        stdout_fd = rktio_system_fd(scheme_rktio, tmp, RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
         need_forget_out = 1;
       } else if (SAME_OBJ(op->sub_type, fd_output_port_type))
 	stdout_fd = ((Scheme_FD *)op->port_data)->fd;
@@ -5922,7 +5908,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
       if (SAME_OBJ(ip->sub_type, file_input_port_type)) {
 	int tmp;
 	tmp = MSC_IZE(fileno)(((Scheme_Input_File *)ip->port_data)->f);
-        stdin_fd = rktio_system_fd(tmp, RKTIO_OPEN_READ | RKTIO_NOT_REGFILE);
+        stdin_fd = rktio_system_fd(scheme_rktio, tmp, RKTIO_OPEN_READ | RKTIO_OPEN_NOT_REGFILE);
         need_forget_in = 1;
       } else if (SAME_OBJ(ip->sub_type, fd_input_port_type))
 	stdin_fd = ((Scheme_FD *)ip->port_data)->fd;
@@ -5943,7 +5929,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
       if (SAME_OBJ(op->sub_type, file_output_port_type)) {
 	int tmp;
 	tmp = MSC_IZE(fileno)(((Scheme_Output_File *)op->port_data)->f);
-        stderr_fd = rktio_system_fd(tmp, RKTIO_OPEN_WRITE | RKTIO_NOT_REGFILE);
+        stderr_fd = rktio_system_fd(scheme_rktio, tmp, RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
         need_forget_err = 1;
       } else if (SAME_OBJ(op->sub_type, fd_output_port_type))
 	stderr_fd = ((Scheme_FD *)op->port_data)->fd;
@@ -5958,7 +5944,8 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
   /*          Sort out arguments          */
   /*--------------------------------------*/
 
-  argv = MALLOC_N(char *, c - 3 + 1);
+  argc = c - 3;
+  argv = MALLOC_N(char *, argc);
   {
     char *ef;
     ef = scheme_expand_string_filename(args[3],
@@ -5994,6 +5981,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
                             "exact command", 1, args[5],
                             NULL);
   } else {
+    int i;
     for (i = 4; i < c; i++) {
       if (((!SCHEME_CHAR_STRINGP(args[i]) && !SCHEME_BYTE_STRINGP(args[i]))
            || scheme_any_string_has_null(args[i]))
@@ -6009,7 +5997,6 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
 	argv[i - 3] = SCHEME_BYTE_STR_VAL(bs);
       }
     }
-    argv[c - 3] = NULL;
   }
 
   command = argv[0];
@@ -6021,9 +6008,11 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
   /*        Create subprocess             */
   /*--------------------------------------*/
 
-  cust_mode = scheme_get_param(scheme_current_config(), MZCONFIG_SUBPROC_GROUP_ENABLED);
+  config = scheme_current_config();
+  
+  cust_mode = scheme_get_param(config, MZCONFIG_SUBPROC_GROUP_ENABLED);
   new_process_group = SCHEME_TRUEP(cust_mode);
-  cust_mode = scheme_get_param(scheme_current_config(), MZCONFIG_SUBPROC_CUSTODIAN_MODE);
+  cust_mode = scheme_get_param(config, MZCONFIG_SUBPROC_CUSTODIAN_MODE);
 
   if (SCHEME_SYMBOLP(cust_mode)
       && !strcmp(SCHEME_SYM_VAL(cust_mode), "kill")
@@ -6032,7 +6021,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
 
   current_dir = scheme_get_param(config, MZCONFIG_CURRENT_DIRECTORY);
 
-  envvars = environment_variables_to_envvars(scheme_get_param(config, MZCONFIG_CURRENT_ENV_VARS));
+  envvars = scheme_environment_variables_to_envvars(scheme_get_param(config, MZCONFIG_CURRENT_ENV_VARS));
 
   result = rktio_process(scheme_rktio,
                          command, argc, argv,
@@ -6042,7 +6031,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
                          unix_turn_off_timer);
 
   if (envvars)
-    rktio_envvars_free(envvars);
+    rktio_envvars_free(scheme_rktio, envvars);
 
   if (!result) {
     scheme_raise_exn(MZEXN_FAIL,
@@ -6059,7 +6048,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
     if (result->stdout_fd)
       in = make_fd_input_port(result->stdout_fd, scheme_intern_symbol("subprocess-stdout"), NULL, 0);
     if (result->stdin_fd)
-      out = make_fd_output_port(result_stdin_fd, scheme_intern_symbol("subprocess-stdin"), 0, -1, NULL);
+      out = make_fd_output_port(result->stdin_fd, scheme_intern_symbol("subprocess-stdin"), 0, -1, NULL);
     if (result->stderr_fd)
       err = (err ? err : make_fd_input_port(result->stderr_fd, scheme_intern_symbol("subprocess-stderr"), NULL, 0));
     
@@ -6069,7 +6058,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
     
     subproc = MALLOC_ONE_TAGGED(Scheme_Subprocess);
     subproc->so.type = scheme_subprocess_type;
-    subproc->proc = result->proc;
+    subproc->proc = result->process;
     scheme_add_finalizer(subproc, close_subprocess_handle, NULL);
 
     if (SCHEME_TRUEP(cust_mode)) {
@@ -6215,10 +6204,10 @@ static Scheme_Object *sch_shell_execute(int c, Scheme_Object *argv[])
 
 void scheme_reserve_file_descriptor(void)
 {
-#ifdef USE_FD_PORTS
+#ifndef DOS_FILE_SYSTEM
   if (!fd_reserved) {
-    the_fd = open("/dev/null", O_RDONLY); 
-    if (the_fd != -1)
+    the_fd = rktio_open(scheme_rktio, "/dev/null", RKTIO_OPEN_READ); 
+    if (the_fd)
       fd_reserved = 1;
   }
 #endif
@@ -6226,9 +6215,9 @@ void scheme_reserve_file_descriptor(void)
 
 void scheme_release_file_descriptor(void)
 {
-#ifdef USE_FD_PORTS
+#ifndef DOS_FILE_SYSTEM
   if (fd_reserved) {
-    close(the_fd);
+    rktio_close(scheme_rktio, the_fd);
     fd_reserved = 0;
   }
 #endif
@@ -6238,6 +6227,11 @@ void scheme_release_file_descriptor(void)
 /*                             sleeping                                   */
 /*========================================================================*/
 
+static void default_sleep(float v, void *fds)
+{
+  rktio_sleep(scheme_rktio, v, fds, scheme_semaphore_fd_set);
+}
+
 void scheme_signal_received_at(void *h)
   XFORM_SKIP_PROC
 /* Ensure that Racket wakes up if asleep. */
@@ -6248,7 +6242,7 @@ void scheme_signal_received_at(void *h)
 void *scheme_get_signal_handle()
   XFORM_SKIP_PROC
 {
-  return (void *)rktio_signal_received(scheme_rktio);
+  return (void *)rktio_get_signal_handle(scheme_rktio);
 }
 
 void scheme_signal_received(void)
@@ -6352,6 +6346,7 @@ static void scheme_stop_itimer_thread()
 #ifdef USE_PTHREAD_THREAD_TIMER
 
 #include <pthread.h>
+#include <unistd.h>
 typedef struct ITimer_Data {
   int itimer;
   int state;
@@ -6493,6 +6488,37 @@ static void kickoff_itimer(intptr_t usec)
   setitimer(ITIMER_PROF, &t, &old);
 }
 
+static void unix_turn_off_timer(void)
+  XFORM_SKIP_PROC
+{
+  /* Turn off the timer. */
+  struct itimerval t, old;
+  sigset_t sigs;
+  
+  t.it_value.tv_sec = 0;
+  t.it_value.tv_usec = 0;
+  t.it_interval.tv_sec = 0;
+  t.it_interval.tv_usec = 0;
+  
+  setitimer(ITIMER_PROF, &t, &old);
+  
+  /* Clear already-queued PROF signal, if any: */
+  sigemptyset(&sigs);
+  while (!sigpending(&sigs)) {
+    if (sigismember(&sigs, SIGPROF)) {
+      sigprocmask(SIG_SETMASK, NULL, &sigs);
+      sigdelset(&sigs, SIGPROF);
+      sigsuspend(&sigs);
+      sigemptyset(&sigs);
+    } else
+      break;
+  }
+}
+
+#else
+
+static void unix_turn_off_timer(void) { }
+
 #endif
 
 void scheme_kickoff_green_thread_time_slice_timer(intptr_t usec) {
@@ -6512,16 +6538,6 @@ void scheme_kill_green_thread_timer()
 #elif defined(USE_WIN32_THREAD_TIMER)
   scheme_stop_itimer_thread();
 #endif
-
-#if defined(FILES_HAVE_FDS)
-# ifndef USE_OSKIT_CONSOLE
-  close(external_event_fd);
-  close(put_external_event_fd);
-# endif
-#endif
-#ifdef WIN32_FD_HANDLES
-  CloseHandle((HANDLE)scheme_break_semaphore);
-#endif
 }
 
 #ifdef OS_X
@@ -6613,10 +6629,7 @@ void scheme_end_sleeper_thread()
   pt_sema_wait(&done_sema);
 
   /* Clear external event flag */
-  if (external_event_fd) {
-    char buf[10];
-    read(external_event_fd, buf, 10);
-  }
+  rktio_flush_signals_received(scheme_rktio);
 }
 
 #ifdef MZ_PRECISE_GC
@@ -6775,13 +6788,7 @@ static void register_traversers(void)
   GC_REG_TRAV(scheme_rt_input_file, mark_input_file);
   GC_REG_TRAV(scheme_rt_output_file, mark_output_file);
 
-#ifdef MZ_FDS
   GC_REG_TRAV(scheme_rt_input_fd, mark_input_fd);
-#endif
-
-#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
-  GC_REG_TRAV(scheme_rt_system_child, mark_system_child);
-#endif
 
   GC_REG_TRAV(scheme_subprocess_type, mark_subprocess);
   GC_REG_TRAV(scheme_write_evt_type, mark_read_write_evt);
diff --git a/racket/src/racket/src/read.c b/racket/src/racket/src/read.c
index e3735da226..3805d911f3 100644
--- a/racket/src/racket/src/read.c
+++ b/racket/src/racket/src/read.c
@@ -6154,7 +6154,7 @@ Scheme_Object *scheme_load_delayed_code(int _which, Scheme_Load_Delay *_delay_in
     scheme_release_file_descriptor();
 
     a[0] = delay_info->path;
-    port = scheme_do_open_input_file("on-demand-loader", 0, 1, a, 1, NULL, NULL, 0);
+    port = scheme_do_open_input_file("on-demand-loader", 0, 1, a, 1, 0);
 
     savebuf = scheme_current_thread->error_buf;
     scheme_current_thread->error_buf = &newbuf;
diff --git a/racket/src/racket/src/schpriv.h b/racket/src/racket/src/schpriv.h
index 3719965858..dc42887e4f 100644
--- a/racket/src/racket/src/schpriv.h
+++ b/racket/src/racket/src/schpriv.h
@@ -4354,7 +4354,7 @@ Scheme_Object *scheme_terminal_port_p(int, Scheme_Object *[]);
 Scheme_Object *scheme_do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[], 
                                          int internal, int for_module);
 Scheme_Object *scheme_do_open_output_file(char *name, int offset, int argc, Scheme_Object *argv[], int and_read, 
-                                          int internal, char **err, int *eerrno);
+                                          int internal);
 Scheme_Object *scheme_file_position(int argc, Scheme_Object *argv[]);
 Scheme_Object *scheme_file_position_star(int argc, Scheme_Object *argv[]);
 Scheme_Object *scheme_file_truncate(int argc, Scheme_Object *argv[]);
@@ -4366,7 +4366,8 @@ Scheme_Object *scheme_file_unlock(int argc, Scheme_Object **argv);
 void scheme_reserve_file_descriptor(void);
 void scheme_release_file_descriptor(void);
 
-int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, struct rktio_fd_t *_fd);
+struct rktio_fd_t;
+int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, struct rktio_fd_t **_fd);
 
 void scheme_fs_change_properties(int *_supported, int *_scalable, int *_low_latency, int *_file_level);
 
@@ -4433,7 +4434,8 @@ void scheme_release_fd_semaphores(void);
 void scheme_check_fd_semaphores(void);
 Scheme_Object *scheme_rktio_fd_to_semaphore(struct rktio_fd_t *fd, int mode);
 
-rktio_envvars_t *scheme_environment_variables_to_envvars(Scheme_Object *ev);
+struct rktio_envvars_t;
+struct rktio_envvars_t *scheme_environment_variables_to_envvars(Scheme_Object *ev);
 
 /*========================================================================*/
 /*                         memory debugging                               */
diff --git a/racket/src/racket/src/string.c b/racket/src/racket/src/string.c
index 50c296a9e1..4dedce6fd2 100644
--- a/racket/src/racket/src/string.c
+++ b/racket/src/racket/src/string.c
@@ -2490,6 +2490,7 @@ rktio_envvars_t *scheme_environment_variables_to_envvars(Scheme_Object *ev)
   Scheme_Hash_Tree *ht = SCHEME_ENVVARS_TABLE(ev);
   rktio_envvars_t *envvars;
   mzlonglong i;
+  Scheme_Object *key, *val;
 
   if (!ht)
     return NULL;
diff --git a/racket/src/racket/src/thread.c b/racket/src/racket/src/thread.c
index 86d96516c8..b6100fe94a 100644
--- a/racket/src/racket/src/thread.c
+++ b/racket/src/racket/src/thread.c
@@ -3814,9 +3814,11 @@ static Scheme_Object *call_as_nested_thread(int argc, Scheme_Object *argv[])
 /*                     thread scheduling and termination                  */
 /*========================================================================*/
 
+static int check_fd_semaphores();
+
 void scheme_init_fd_semaphores(void)
 {
-  scheme_semaphore_fd_set = rktio_open_ltps(scheme_rktio);
+  scheme_semaphore_fd_set = rktio_ltps_open(scheme_rktio);
 }
 
 void scheme_release_fd_semaphores(void)
@@ -3824,7 +3826,7 @@ void scheme_release_fd_semaphores(void)
   if (scheme_semaphore_fd_set) {
     rktio_ltps_remove_all(scheme_rktio, scheme_semaphore_fd_set);
     (void)check_fd_semaphores();
-    rktio_ltps_close(scheme_semaphore_fd_set);
+    rktio_ltps_close(scheme_rktio, scheme_semaphore_fd_set);
   }
 }
 
@@ -3837,32 +3839,32 @@ static void log_fd_semaphore_error()
 	       "error for long-term poll set: %R");
   }
 }
-#endif
 
 Scheme_Object *scheme_fd_to_semaphore(intptr_t fd, int mode, int is_socket)
 {
   rktio_fd_t *rfd;
+  Scheme_Object *sema;
   
-  if (!scheme_semaphore_fd_mapping)
+  if (!scheme_semaphore_fd_set)
     return NULL;
 
-  rfd = rktio_system_fd(fd, (RKTIO_OPEN_READ
-                             | RKTIO_OPEN_WRITE
-                             | (is_socket ? RKTIO_OPEN_SOCKET : 0)));
+  rfd = rktio_system_fd(scheme_rktio, fd, (RKTIO_OPEN_READ
+                                           | RKTIO_OPEN_WRITE
+                                           | (is_socket ? RKTIO_OPEN_SOCKET : 0)));
 
   sema = scheme_rktio_fd_to_semaphore(rfd, mode);
 
-  rktio_forget(rfd);
+  rktio_forget(scheme_rktio, rfd);
 
   return sema;
 }
 
 Scheme_Object *scheme_rktio_fd_to_semaphore(rktio_fd_t *fd, int mode)
 {
-  rktio_handle_t *h;
+  rktio_ltps_handle_t *h;
   void **ib;
 
-  if (!scheme_semaphore_fd_mapping)
+  if (!scheme_semaphore_fd_set)
     return NULL;
 
   switch(mode) {
@@ -3883,7 +3885,7 @@ Scheme_Object *scheme_rktio_fd_to_semaphore(rktio_fd_t *fd, int mode)
     break;
   }
 
-  h = rktio_ltps_add(scheme_rktio, scheme_semaphore_fd_mapping, fd, mode);
+  h = rktio_ltps_add(scheme_rktio, scheme_semaphore_fd_set, fd, mode);
 
   if (!h) {
     if (scheme_last_error_is_racket(RKTIO_ERROR_LTPS_REMOVED)
@@ -3898,16 +3900,18 @@ Scheme_Object *scheme_rktio_fd_to_semaphore(rktio_fd_t *fd, int mode)
   ib = rktio_ltps_handle_get_data(scheme_rktio, h);
   if (!ib) {
     ib = scheme_malloc_immobile_box(scheme_make_sema(0));
-    rktio_ltps_handle_set_data(scheme_rktio, ib);
+    rktio_ltps_handle_set_data(scheme_rktio, h, ib);
   }
 
-  return *(Scheme_Object **)p;
+  return *(Scheme_Object **)ib;
 }
 
 static int check_fd_semaphores()
 {
   rktio_ltps_handle_t *h;
   int did = 0;
+  void *p;
+  Scheme_Object *sema;
 
   if (!scheme_semaphore_fd_set)
     return 0;
@@ -3915,7 +3919,6 @@ static int check_fd_semaphores()
   while (1) {
     h = rktio_ltps_get_signaled_handle(scheme_rktio, scheme_semaphore_fd_set);
     if (h) {
-      void *p;
       p = rktio_ltps_handle_get_data(scheme_rktio, h);
       free(h);
 
@@ -3997,10 +4000,6 @@ static int check_sleep(int need_activity, int sleep_now)
 {
   Scheme_Thread *p, *p2;
   int end_with_act;
-#if defined(USING_FDS)
-  DECL_FDSET(set, 3);
-  fd_set *set1, *set2;
-#endif
   void *fds;
 
   if (scheme_no_stack_overflow)
@@ -4099,12 +4098,12 @@ static int check_sleep(int need_activity, int sleep_now)
     }
   
     if (needs_sleep_cancelled) {
-      rktio_poll_set_close(scheme_rktio, fds);
+      rktio_poll_set_forget(scheme_rktio, fds);
       return 0;
     }
 
     if (post_system_idle()) {
-      rktio_poll_set_close(scheme_rktio, fds);
+      rktio_poll_set_forget(scheme_rktio, fds);
       return 0;
     }
  
@@ -9045,9 +9044,6 @@ static void get_ready_for_GC()
 #ifdef WINDOWS_PROCESSES
   scheme_suspend_remembered_threads();
 #endif
-#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
-  scheme_block_child_signals(1);
-#endif
 
   {
     GC_CAN_IGNORE void *data;
@@ -9082,9 +9078,6 @@ static void done_with_GC()
 #ifdef WINDOWS_PROCESSES
   scheme_resume_remembered_threads();
 #endif
-#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
-  scheme_block_child_signals(0);
-#endif
 
   end_this_gc_time = scheme_get_process_milliseconds();
   end_this_gc_real_time = scheme_get_inexact_milliseconds();
diff --git a/racket/src/rktio/rktio.h b/racket/src/rktio/rktio.h
index b51a53a39d..feba8df480 100644
--- a/racket/src/rktio/rktio.h
+++ b/racket/src/rktio/rktio.h
@@ -86,7 +86,7 @@ RKTIO_EXTERN rktio_bool_t rktio_fd_is_text_converted(rktio_t *rktio, rktio_fd_t
 RKTIO_EXTERN int rktio_fd_modes(rktio_t *rktio, rktio_fd_t *rfd);
 /* Returns all of the recorded mode flags. */
 
-RKTIO_EXTERN rktio_fd_t *rktio_open(rktio_t *rktio, char *src, int modes);
+RKTIO_EXTERN rktio_fd_t *rktio_open(rktio_t *rktio, const char *src, int modes);
 /* Can report `RKTIO_ERROR_DOES_NOT_EXIST` in place of system error,
    and can report `RKTIO_ERROR_UNSUPPORTED_TEXT_MODE` on Windows:=. */
 
@@ -121,7 +121,7 @@ RKTIO_EXTERN intptr_t rktio_read(rktio_t *rktio, rktio_fd_t *fd, char *buffer, i
 #define RKTIO_READ_EOF   (-1)
 #define RKTIO_READ_ERROR (-2)
 
-RKTIO_EXTERN intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *fd, char *buffer, intptr_t len);
+RKTIO_EXTERN intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *fd, const char *buffer, intptr_t len);
 /* Returns the number of bytes written, possibly 0, in non-blocking
    mode. Alternatively, the result can be `RKTIO_WRITE_ERROR` for an
    error. Although rktio_write() is intended to write only bytes that
@@ -244,6 +244,14 @@ RKTIO_EXTERN void rktio_connect_stop(rktio_t *rktio, rktio_connect_t *conn);
 RKTIO_EXTERN rktio_tri_t rktio_poll_connect_ready(rktio_t *rktio, rktio_connect_t *conn);
 /* Returns one of `RKTIO_POLL_READY`, etc. */
 
+RKTIO_EXTERN rktio_fd_t *rktio_connect_trying(rktio_t *rktio, rktio_connect_t *conn);
+/* Returns a file descriptor that `conn` is currently trying, or
+   returns NULL without setting any error. The result file descriptor
+   should not be closed, and may be closed by a `rktio_connect_finish`
+   or `rktio_connect_stop` call (so if you register it in an long-term
+   poll set, unregister it before trying to finish or stop the
+   connection). */
+
 RKTIO_EXTERN int rktio_socket_shutdown(rktio_t *rktio, rktio_fd_t *rfd, int mode);
 /* Useful for TCP to report an EOF to the other end. Does not close the socket,
    but may make it ineligible for forther use.
@@ -262,7 +270,7 @@ RKTIO_EXTERN rktio_ok_t rktio_udp_bind(rktio_t *rktio, rktio_fd_t *rfd, rktio_ad
 RKTIO_EXTERN rktio_ok_t rktio_udp_connect(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr);
 
 RKTIO_EXTERN intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr,
-                                       char *buffer, intptr_t len);
+                                       const char *buffer, intptr_t len);
 /* Extends `rktio_write` to accept a destination `addr`, and binds `rfd` if it 
    is not bound aready. The `addr` can be NULL if the socket is connected. */
 
@@ -293,6 +301,7 @@ RKTIO_EXTERN char **rktio_listener_address(rktio_t *rktio, rktio_listener_t *lnr
 
 RKTIO_EXTERN char *rktio_udp_multicast_interface(rktio_t *rktio, rktio_fd_t *rfd);
 RKTIO_EXTERN rktio_ok_t rktio_udp_set_multicast_interface(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr);
+/* The `addr` argument can be NULL to auto-select the interface. */
 
 RKTIO_EXTERN rktio_ok_t rktio_udp_change_multicast_group(rktio_t *rktio, rktio_fd_t *rfd,
                                                          rktio_addrinfo_t *group_addr,
@@ -338,8 +347,8 @@ RKTIO_EXTERN rktio_envvars_t *rktio_envvars_copy(rktio_t *rktio, rktio_envvars_t
 RKTIO_EXTERN void rktio_envvars_free(rktio_t *rktio, rktio_envvars_t *envvars);
 /* Deallocates an environment-variables record: */
 
-RKTIO_EXTERN char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, char *name);
-RKTIO_EXTERN void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, char *name, char *value);
+RKTIO_EXTERN char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, const char *name);
+RKTIO_EXTERN void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, const char *name, const char *value);
 /* Access/update environment-variables record by name. */
 
 RKTIO_EXTERN intptr_t rktio_envvars_count(rktio_t *rktio, rktio_envvars_t *envvars);
@@ -413,7 +422,7 @@ RKTIO_EXTERN int rktio_fs_change_properties(rktio_t *rktio);
 
 typedef struct rktio_fs_change_t rktio_fs_change_t;
 
-RKTIO_EXTERN rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path);
+RKTIO_EXTERN rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, const char *path);
 
 RKTIO_EXTERN void rktio_fs_change_forget(rktio_t *rktio, rktio_fs_change_t *fc);
 
@@ -470,7 +479,7 @@ RKTIO_EXTERN void rktio_poll_set_add_eventmask(rktio_t *rktio, rktio_poll_set_t
 typedef struct rktio_ltps_t rktio_ltps_t;
 typedef struct rktio_ltps_handle_t rktio_ltps_handle_t;
 
-RKTIO_EXTERN rktio_ltps_t *rktio_open_ltps(rktio_t *rktio);
+RKTIO_EXTERN rktio_ltps_t *rktio_ltps_open(rktio_t *rktio);
 
 RKTIO_EXTERN int rktio_ltps_close(rktio_t *rktio, rktio_ltps_t *lt);
 /* Closing will signal all remianing handles and free all signaled
@@ -518,33 +527,33 @@ RKTIO_EXTERN void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds
 /*************************************************/
 /* Files, directories, and links                 */
 
-RKTIO_EXTERN int rktio_file_exists(rktio_t *rktio, char *filename);
-RKTIO_EXTERN int rktio_directory_exists(rktio_t *rktio, char *dirname);
-RKTIO_EXTERN int rktio_link_exists(rktio_t *rktio, char *filename);
-RKTIO_EXTERN int rktio_is_regular_file(rktio_t *rktio, char *filename);
+RKTIO_EXTERN int rktio_file_exists(rktio_t *rktio, const char *filename);
+RKTIO_EXTERN int rktio_directory_exists(rktio_t *rktio, const char *dirname);
+RKTIO_EXTERN int rktio_link_exists(rktio_t *rktio, const char *filename);
+RKTIO_EXTERN int rktio_is_regular_file(rktio_t *rktio, const char *filename);
 
-RKTIO_EXTERN rktio_ok_t rktio_delete_file(rktio_t *rktio, char *fn, int enable_write_on_fail);
+RKTIO_EXTERN rktio_ok_t rktio_delete_file(rktio_t *rktio, const char *fn, int enable_write_on_fail);
 
-RKTIO_EXTERN rktio_ok_t rktio_rename_file(rktio_t *rktio, char *dest, char *src, int exists_ok);
+RKTIO_EXTERN rktio_ok_t rktio_rename_file(rktio_t *rktio, const char *dest, const char *src, int exists_ok);
 /* Can report `RKTIO_ERROR_EXISTS`. */
 
 RKTIO_EXTERN char *rktio_get_current_directory(rktio_t *rktio);
 RKTIO_EXTERN rktio_ok_t rktio_set_current_directory(rktio_t *rktio, const char *path);
 
-RKTIO_EXTERN rktio_ok_t rktio_make_directory(rktio_t *rktio, char *filename);
+RKTIO_EXTERN rktio_ok_t rktio_make_directory(rktio_t *rktio, const char *filename);
 /* Can report `RKTIO_ERROR_EXISTS`. */
 
-RKTIO_EXTERN rktio_ok_t rktio_delete_directory(rktio_t *rktio, char *filename, char *current_directory,
+RKTIO_EXTERN rktio_ok_t rktio_delete_directory(rktio_t *rktio, const char *filename, const char *current_directory,
                                                int enable_write_on_fail);
 /* The `current_directory` argument is used on Windows to avoid being
    in `filename` (instead) as a directory while trying to delete it.
    The `enable_write_on_fail` argument also applied to Windows. */
 
-RKTIO_EXTERN char *rktio_readlink(rktio_t *rktio, char *fullfilename);
+RKTIO_EXTERN char *rktio_readlink(rktio_t *rktio, const char *fullfilename);
 /* Argument should not have a trailing separator. Can report
    `RKTIO_ERROR_NOT_A_LINK`. */
 
-RKTIO_EXTERN rktio_ok_t rktio_make_link(rktio_t *rktio, char *src, char *dest,
+RKTIO_EXTERN rktio_ok_t rktio_make_link(rktio_t *rktio, const char *src, const char *dest,
                                         int dest_is_directory);
 /* The `dest_is_directory` argument is used only
    on Windows. Can report `RKTIO_ERROR_EXISTS`. */
@@ -554,10 +563,10 @@ RKTIO_EXTERN rktio_ok_t rktio_make_link(rktio_t *rktio, char *src, char *dest,
 
 typedef intptr_t rktio_timestamp_t;
 
-RKTIO_EXTERN rktio_filesize_t *rktio_file_size(rktio_t *rktio, char *filename);
+RKTIO_EXTERN rktio_filesize_t *rktio_file_size(rktio_t *rktio, const char *filename);
 
-RKTIO_EXTERN rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, char *file);
-RKTIO_EXTERN rktio_ok_t rktio_set_file_modify_seconds(rktio_t *rktio, char *file, rktio_timestamp_t secs);
+RKTIO_EXTERN rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, const char *file);
+RKTIO_EXTERN rktio_ok_t rktio_set_file_modify_seconds(rktio_t *rktio, const char *file, rktio_timestamp_t secs);
 
 typedef struct {
   uintptr_t a, b, c;
@@ -565,7 +574,7 @@ typedef struct {
 } rktio_identity_t;
 
 RKTIO_EXTERN rktio_identity_t *rktio_fd_identity(rktio_t *rktio, rktio_fd_t *fd);
-RKTIO_EXTERN rktio_identity_t *rktio_path_identity(rktio_t *rktio, char *path, int follow_links);
+RKTIO_EXTERN rktio_identity_t *rktio_path_identity(rktio_t *rktio, const char *path, int follow_links);
 
 /*************************************************/
 /* Permissions                                   */
@@ -577,11 +586,11 @@ RKTIO_EXTERN rktio_identity_t *rktio_path_identity(rktio_t *rktio, char *path, i
 
 #define RKTIO_PERMISSION_ERROR (-1)
 
-RKTIO_EXTERN int rktio_get_file_or_directory_permissions(rktio_t *rktio, char *filename, int all_bits);
+RKTIO_EXTERN int rktio_get_file_or_directory_permissions(rktio_t *rktio, const char *filename, int all_bits);
 /* Result is `RKTIO_PERMISSION_ERROR` for error, otherwise a combination of
    bits. If not `all_bits`, then use constants above. */
 
-RKTIO_EXTERN rktio_ok_t rktio_set_file_or_directory_permissions(rktio_t *rktio, char *filename, int new_bits);
+RKTIO_EXTERN rktio_ok_t rktio_set_file_or_directory_permissions(rktio_t *rktio, const char *filename, int new_bits);
 /* The `new_bits` format corresponds to `all_bits` for getting permissions.
    Can report `RKTIO_ERROR_BAD_PERMISSION` for bits that make no sense. */
 
@@ -590,8 +599,8 @@ RKTIO_EXTERN rktio_ok_t rktio_set_file_or_directory_permissions(rktio_t *rktio,
 
 typedef struct rktio_directory_list_t rktio_directory_list_t;
 
-RKTIO_EXTERN rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, char *filename);
-/* On Windows, the given `filename` must be normalized and not have
+RKTIO_EXTERN rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, const char *dirname);
+/* On Windows, the given `dirname` must be normalized and not have
    `.` or `..`: */
 
 RKTIO_EXTERN char *rktio_directory_list_step(rktio_t *rktio, rktio_directory_list_t *dl);
@@ -612,7 +621,7 @@ RKTIO_EXTERN char **rktio_filesystem_root_list(rktio_t *rktio);
 
 typedef struct rktio_file_copy_t rktio_file_copy_t;
 
-RKTIO_EXTERN rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, char *dest, char *src,
+RKTIO_EXTERN rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, const char *dest, const char *src,
                                                       rktio_bool_t exists_ok);
 /* Can report `RKTIO_ERROR_EXISTS`. */
 
@@ -638,7 +647,7 @@ enum {
   RKTIO_PATH_INIT_FILE
 };
 
-RKTIO_EXTERN char *rktio_expand_user_tilde(rktio_t *rktio, char *filename);
+RKTIO_EXTERN char *rktio_expand_user_tilde(rktio_t *rktio, const char *filename);
 /* Path must start with tilde, otherwise `RKTIO_ERROR_NO_TILDE`.
    Other possible errors are `RKTIO_ERROR_ILL_FORMED_USER` and
    `RKTIO_ERROR_UNKNOWN_USER`. */
@@ -653,6 +662,7 @@ RKTIO_EXTERN void rktio_signal_received_at(rktio_signal_handle_t *h);
 RKTIO_EXTERN void rktio_signal_received(rktio_t *rktio);
 
 RKTIO_EXTERN void rktio_wait_until_signal_received(rktio_t *rktio);
+RKTIO_EXTERN void rktio_flush_signals_received(rktio_t *rktio);
 
 #ifdef RKTIO_SYSTEM_UNIX
 RKTIO_EXTERN int rktio_signal_handle_to_fd();
diff --git a/racket/src/rktio/rktio_envvars.c b/racket/src/rktio/rktio_envvars.c
index 67f98c5855..17cf4b578d 100644
--- a/racket/src/rktio/rktio_envvars.c
+++ b/racket/src/rktio/rktio_envvars.c
@@ -278,7 +278,7 @@ char *rktio_envvars_value_ref(rktio_t *rktio, rktio_envvars_t *envvars, intptr_t
   return MSC_IZE(strdup)(envvars->vals[i]);
 }
 
-char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, char *name)
+char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, const char *name)
 {
   intptr_t i;
 
@@ -290,7 +290,7 @@ char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, char *name)
   return NULL;
 }
 
-void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, char *name, char *value)
+void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, const char *name, const char *value)
 {
   intptr_t i, j;
 
diff --git a/racket/src/rktio/rktio_fd.c b/racket/src/rktio/rktio_fd.c
index d76e876e7c..df0e75c663 100644
--- a/racket/src/rktio/rktio_fd.c
+++ b/racket/src/rktio/rktio_fd.c
@@ -938,7 +938,7 @@ static void WindowsFDICleanup(Win_FD_Input_Thread *th)
 /* writing                                                                */
 /*========================================================================*/
 
-intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len)
+intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len)
 {
 #ifdef RKTIO_SYSTEM_UNIX
   int flags, errsaved;
diff --git a/racket/src/rktio/rktio_file.c b/racket/src/rktio/rktio_file.c
index 560bce7c9b..3d51a5440f 100644
--- a/racket/src/rktio/rktio_file.c
+++ b/racket/src/rktio/rktio_file.c
@@ -16,7 +16,7 @@
 /* Opening a file                                                         */
 /*========================================================================*/
 
-static rktio_fd_t *open_read(rktio_t *rktio, char *filename)
+static rktio_fd_t *open_read(rktio_t *rktio, const char *filename)
 {
 #ifdef RKTIO_SYSTEM_UNIX
   int fd;
@@ -95,7 +95,7 @@ static rktio_fd_t *open_read(rktio_t *rktio, char *filename)
 #endif
 }
 
-static rktio_fd_t *open_write(rktio_t *rktio, char *filename, int modes)
+static rktio_fd_t *open_write(rktio_t *rktio, const char *filename, int modes)
 {
 #ifdef RKTIO_SYSTEM_UNIX
   int fd;
@@ -255,7 +255,7 @@ static rktio_fd_t *open_write(rktio_t *rktio, char *filename, int modes)
 #endif
 }
 
-rktio_fd_t *rktio_open(rktio_t *rktio, char *filename, int modes)
+rktio_fd_t *rktio_open(rktio_t *rktio, const char *filename, int modes)
 {
   if (modes & RKTIO_OPEN_WRITE)
     return open_write(rktio, filename, modes);
diff --git a/racket/src/rktio/rktio_fs.c b/racket/src/rktio/rktio_fs.c
index 5bd182ea35..cd6bdb1733 100644
--- a/racket/src/rktio/rktio_fs.c
+++ b/racket/src/rktio/rktio_fs.c
@@ -498,7 +498,7 @@ static int UNC_stat(rktio_t *rktio, const char *dirname, int *flags, int *isdir,
 }
 #endif
 
-int rktio_file_exists(rktio_t *rktio, char *filename)
+int rktio_file_exists(rktio_t *rktio, const char *filename)
 /* Windows: check for special filenames before calling */
 {
 # ifdef NO_STAT_PROC
@@ -530,7 +530,7 @@ int rktio_file_exists(rktio_t *rktio, char *filename)
 # endif
 }
 
-int rktio_directory_exists(rktio_t *rktio, char *dirname)
+int rktio_directory_exists(rktio_t *rktio, const char *dirname)
 {
 # ifdef NO_STAT_PROC
   return 0;
@@ -555,7 +555,7 @@ int rktio_directory_exists(rktio_t *rktio, char *dirname)
 # endif
 }
 
-int rktio_is_regular_file(rktio_t *rktio, char *filename)
+int rktio_is_regular_file(rktio_t *rktio, const char *filename)
 /* Windows: check for special filenames before calling */
 {
 # ifdef NO_STAT_PROC
@@ -574,7 +574,7 @@ int rktio_is_regular_file(rktio_t *rktio, char *filename)
 # endif  
 }
 
-int rktio_link_exists(rktio_t *rktio, char *filename)
+int rktio_link_exists(rktio_t *rktio, const char *filename)
 {
 #ifdef RKTIO_SYSTEM_WINDOWS
   {
@@ -666,7 +666,7 @@ int rktio_set_current_directory(rktio_t *rktio, const char *path)
   return !err;
 }
 
-static rktio_identity_t *get_identity(rktio_t *rktio, rktio_fd_t *fd, char *path, int follow_links)
+static rktio_identity_t *get_identity(rktio_t *rktio, rktio_fd_t *fd, const char *path, int follow_links)
 {
   uintptr_t devi = 0, inoi = 0, inoi2 = 0;
   uintptr_t devi_bits = 0, inoi_bits = 0, inoi2_bits = 0;
@@ -761,7 +761,7 @@ rktio_identity_t *rktio_fd_identity(rktio_t *rktio, rktio_fd_t *fd)
   return get_identity(rktio, fd, NULL, 0);
 }
 
-rktio_identity_t *rktio_path_identity(rktio_t *rktio, char *path, int follow_links)
+rktio_identity_t *rktio_path_identity(rktio_t *rktio, const char *path, int follow_links)
 {
   return get_identity(rktio, NULL, path, follow_links);
 }
@@ -775,7 +775,7 @@ static int enable_write_permission(rktio_t *rktio, const char *fn)
 }
 #endif
 
-int rktio_delete_file(rktio_t *rktio, char *fn, int enable_write_on_fail)
+int rktio_delete_file(rktio_t *rktio, const char *fn, int enable_write_on_fail)
 {
 #ifdef RKTIO_SYSTEM_WINDOWS
   int errid;
@@ -806,7 +806,7 @@ int rktio_delete_file(rktio_t *rktio, char *fn, int enable_write_on_fail)
 #endif
 }
 
-int rktio_rename_file(rktio_t *rktio, char *dest, char *src, int exists_ok)
+int rktio_rename_file(rktio_t *rktio, const char *dest, const char *src, int exists_ok)
 {
 #ifdef RKTIO_SYSTEM_WINDOWS
   int errid;
@@ -856,7 +856,7 @@ int rktio_rename_file(rktio_t *rktio, char *dest, char *src, int exists_ok)
 #endif
 }
 
-char *rktio_readlink(rktio_t *rktio, char *fullfilename)
+char *rktio_readlink(rktio_t *rktio, const char *fullfilename)
 /* fullfilename must not have a trailing separator */
 {
 #ifdef RKTIO_SYSTEM_WINDOWS
@@ -895,22 +895,21 @@ char *rktio_readlink(rktio_t *rktio, char *fullfilename)
 #endif
 }
 
-int rktio_make_directory(rktio_t *rktio, char *filename)
+int rktio_make_directory(rktio_t *rktio, const char *filename)
 {
 #ifdef NO_MKDIR
   set_racket_error(RKTIO_ERROR_UNSUPPORTED);
   return 0;
 #else
-  int len, copied = 0;
+  int len;
+  char *copied = NULL;
 
   /* Make sure path doesn't have trailing separator: */
   len = strlen(filename);
   while (len && IS_A_SEP(filename[len - 1])) {
-    if (!copied) {
-      filename = MSC_IZE(strdup)(filename);
-      copied = 1;
-    }
-    filename[--len] = 0;
+    copied = MSC_IZE(strdup)(filename);
+    copied[--len] = 0;
+    filename = copied;
   }
 
   while (1) {
@@ -919,7 +918,7 @@ int rktio_make_directory(rktio_t *rktio, char *filename)
 			  , 0777
 # endif
 			  )) {
-      if (copied) free(filename);
+      if (copied) free(copied);
       return 1;
     } else if (errno != EINTR)
       break;
@@ -930,12 +929,12 @@ int rktio_make_directory(rktio_t *rktio, char *filename)
   else
     get_posix_error();
 
-  if (copied) free(filename);
+  if (copied) free(copied);
 
   return 0;
 }
 
-int rktio_delete_directory(rktio_t *rktio, char *filename, char *current_directory, int enable_write_on_fail)
+int rktio_delete_directory(rktio_t *rktio, const char *filename, const char *current_directory, int enable_write_on_fail)
 {
 #ifdef RKTIO_SYSTEM_WINDOWS
   int tried_cwd = 0, tried_perm = 0;
@@ -964,7 +963,7 @@ int rktio_delete_directory(rktio_t *rktio, char *filename, char *current_directo
 #endif
 }
 
-int rktio_make_link(rktio_t *rktio, char *src, char *dest, int dest_is_directory)
+int rktio_make_link(rktio_t *rktio, const char *src, const char *dest, int dest_is_directory)
 /* `src` is the file that is written, and `dest` is written to that
    file */
 {
@@ -1002,7 +1001,7 @@ int rktio_make_link(rktio_t *rktio, char *src, char *dest, int dest_is_directory
 #endif
 }
 
-rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, char *file)
+rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, const char *file)
 {
 #ifdef RKTIO_SYSTEM_WINDOWS
   rktio_timestamp_t *secs;
@@ -1028,7 +1027,7 @@ rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, char *file)
 #endif
 }
 
-int rktio_set_file_modify_seconds(rktio_t *rktio, char *file, rktio_timestamp_t secs)
+int rktio_set_file_modify_seconds(rktio_t *rktio, const char *file, rktio_timestamp_t secs)
 {
   while (1) {
     struct MSC_IZE(utimbuf) ut;
@@ -1091,7 +1090,7 @@ static int user_in_group(rktio_t *rktio, uid_t uid, gid_t gid)
 }
 #endif
 
-int rktio_get_file_or_directory_permissions(rktio_t *rktio, char *filename, int all_bits)
+int rktio_get_file_or_directory_permissions(rktio_t *rktio, const char *filename, int all_bits)
 /* -1 result indicates an error */
 {
 # ifdef NO_STAT_PROC
@@ -1226,7 +1225,7 @@ int rktio_get_file_or_directory_permissions(rktio_t *rktio, char *filename, int
 # endif
 }
 
-int rktio_set_file_or_directory_permissions(rktio_t *rktio, char *filename, int new_bits)
+int rktio_set_file_or_directory_permissions(rktio_t *rktio, const char *filename, int new_bits)
 {
 # ifdef NO_STAT_PROC
   set_racket_error(RKTIO_ERROR_UNSUPPORTED);
@@ -1268,7 +1267,7 @@ int rktio_set_file_or_directory_permissions(rktio_t *rktio, char *filename, int
 # endif
 }
 
-rktio_filesize_t *rktio_file_size(rktio_t *rktio, char *filename)
+rktio_filesize_t *rktio_file_size(rktio_t *rktio, const char *filename)
 {
   rktio_filesize_t *sz = NULL;
 #ifdef RKTIO_SYSTEM_WINDOWS
@@ -1319,7 +1318,7 @@ struct rktio_directory_list_t {
   FF_TYPE info;
 };
 
-rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, char *filename)
+rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, const char *filename)
 /* path must be normalized */
 {
   char *pattern;
@@ -1426,7 +1425,7 @@ struct rktio_directory_list_t {
   DIR *dir;
 };
 
-rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, char *filename)
+rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, const char *filename)
 {
   rktio_directory_list_t *dl;
   DIR *dir;
@@ -1509,7 +1508,7 @@ struct rktio_file_copy_t {
   rktio_fd_t *src_fd, *dest_fd;
 };
 
-rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, char *dest, char *src, int exists_ok)
+rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, const char *dest, const char *src, int exists_ok)
 {
 #ifdef RKTIO_SYSTEM_UNIX
   {
@@ -1694,7 +1693,7 @@ char **rktio_filesystem_root_list(rktio_t *rktio)
 /* expand user tilde & system paths                                       */
 /*========================================================================*/
 
-char *rktio_expand_user_tilde(rktio_t *rktio, char *filename) {
+char *rktio_expand_user_tilde(rktio_t *rktio, const char *filename) {
 #ifdef RKTIO_SYSTEM_WINDOWS
   set_racket_error(RKTIO_ERROR_UNSUPPORTED);
   return NULL;
@@ -1760,9 +1759,7 @@ char *rktio_expand_user_tilde(rktio_t *rktio, char *filename) {
 
   free(home);
   
-  filename = naya;
-
-  return filename;
+  return naya;
 #endif
 }
 
diff --git a/racket/src/rktio/rktio_fs_change.c b/racket/src/rktio/rktio_fs_change.c
index 9c0938b571..51086eecf4 100644
--- a/racket/src/rktio/rktio_fs_change.c
+++ b/racket/src/rktio/rktio_fs_change.c
@@ -65,7 +65,7 @@ int rktio_fs_change_properties(rktio_t *rktio)
   return flags;
 }
 
-rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path)
+rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, const char *path)
 {
   int ok = 0;
 #ifndef NO_FILESYSTEM_CHANGE_EVTS
@@ -93,7 +93,7 @@ rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path)
   else {
     rktio_fd_t *rfd;
     rfd = rktio_system_fd(rktio, fd, 0);
-    lt = rktio_open_ltps(rktio);
+    lt = rktio_ltps_open(rktio);
     if (lt)
       lth = rktio_ltps_add(rktio, lt, rfd, RKTIO_LTPS_CREATE_VNODE);
     if (!lt || !lth) {
diff --git a/racket/src/rktio/rktio_ltps.c b/racket/src/rktio/rktio_ltps.c
index bdaae4cf44..d82e5ca6f7 100644
--- a/racket/src/rktio/rktio_ltps.c
+++ b/racket/src/rktio/rktio_ltps.c
@@ -94,7 +94,7 @@ void *rktio_ltps_handle_get_data(rktio_t *rktio, rktio_ltps_handle_t *s)
 
 /*========================================================================*/
 
-rktio_ltps_t *rktio_open_ltps(rktio_t *rktio)
+rktio_ltps_t *rktio_ltps_open(rktio_t *rktio)
 {
   rktio_ltps_t *lt;
 
diff --git a/racket/src/rktio/rktio_network.c b/racket/src/rktio/rktio_network.c
index f17327e6b7..45cf0199d0 100644
--- a/racket/src/rktio/rktio_network.c
+++ b/racket/src/rktio/rktio_network.c
@@ -915,6 +915,18 @@ void rktio_socket_forget_owned(rktio_t *rktio, rktio_fd_t *rfd)
 #endif
 }
 
+int rktio_socket_shutdown(rktio_t *rktio, rktio_fd_t *rfd, int mode)
+{
+  rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
+  
+  if (!shutdown(s, ((mode == RKTIO_SHUTDOWN_READ) ? SHUT_RD : SHUT_RDWR))) {
+    get_socket_error();
+    return 0;
+  }
+  
+  return 1;
+}
+
 int rktio_socket_poll_write_ready(rktio_t *rktio, rktio_fd_t *rfd)
 {
 #ifdef RKTIO_SYSTEM_UNIX
@@ -1031,7 +1043,7 @@ intptr_t rktio_socket_read(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr
   }
 }
 
-static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len,
+static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len,
                                 /* for UDP sendto: */
                                 rktio_addrinfo_t *addr)
 {
@@ -1087,7 +1099,7 @@ static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, i
   }
 }
 
-intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len)
+intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len)
 {
   return do_socket_write(rktio, rfd, buffer, len, NULL);
 }
@@ -1244,6 +1256,11 @@ void rktio_connect_stop(rktio_t *rktio, rktio_connect_t *conn)
   conn_free(conn);
 }
 
+rktio_fd_t *rktio_connect_trying(rktio_t *rktio, rktio_connect_t *conn)
+{
+  return conn->trying_fd;
+}
+
 /*========================================================================*/
 /* TCP listener and accept                                                */
 /*========================================================================*/
@@ -1782,7 +1799,7 @@ int rktio_udp_connect(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr)
   return 0;
 }
 
-intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr, char *buffer, intptr_t len)
+intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr, const char *buffer, intptr_t len)
 {
   return do_socket_write(rktio, rfd, buffer, len, addr);
 }
diff --git a/racket/src/rktio/rktio_poll_set.c b/racket/src/rktio/rktio_poll_set.c
index 703cb08d54..bfb35e7fd4 100644
--- a/racket/src/rktio/rktio_poll_set.c
+++ b/racket/src/rktio/rktio_poll_set.c
@@ -967,7 +967,7 @@ void rktio_signal_received_at(rktio_signal_handle_t *h)
 #endif
 }
 
-static void clear_signal(rktio_t *rktio)
+void rktio_flush_signals_received(rktio_t *rktio)
 {
 #ifdef RKTIO_SYSTEM_UNIX
   /* Clear external event flag */
@@ -1008,8 +1008,8 @@ void rktio_wait_until_signal_received(rktio_t *rktio)
 #ifdef RKTIO_SYSTEM_WINDOWS  
   WaitForSingleObject(rktio->break_semaphore, INFINITE);
 #endif
-  
-  clear_signal(rktio);
+
+  rktio_flush_signals_received(rktio);
 }
 
 /****************** Windows cleanup  *****************/
@@ -1276,5 +1276,5 @@ void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds, rktio_ltps_
 #endif
   }
 
-  clear_signal(rktio);
+  rktio_flush_signals_received(rktio);
 }
diff --git a/racket/src/rktio/rktio_private.h b/racket/src/rktio/rktio_private.h
index fe0db54a27..8b9287018a 100644
--- a/racket/src/rktio/rktio_private.h
+++ b/racket/src/rktio/rktio_private.h
@@ -185,7 +185,7 @@ rktio_fd_t *rktio_socket_dup(rktio_t *rktio, rktio_fd_t *rfd);
 int rktio_socket_poll_write_ready(rktio_t *rktio, rktio_fd_t *rfd);
 int rktio_socket_poll_read_ready(rktio_t *rktio, rktio_fd_t *rfd);
 
-intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len);
+intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len);
 intptr_t rktio_socket_read(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len);
   
 void rktio_free_ghbn(rktio_t *rktio);