diff --git a/ports/unix/include/arch/sys_arch.h b/ports/unix/include/arch/sys_arch.h
index 7e6a2c9..56d20af 100644
--- a/ports/unix/include/arch/sys_arch.h
+++ b/ports/unix/include/arch/sys_arch.h
@@ -41,9 +41,16 @@ typedef u32_t sys_prot_t;
 
 struct sys_sem;
 typedef struct sys_sem * sys_sem_t;
+#define sys_sem_valid(sem) (((sem) != NULL) && (*(sem) != NULL))
+#define sys_sem_set_invalid(sem) do { if((sem) != NULL) { *(sem) = NULL; }}while(0)
+
+/* let sys.h use binary semaphores for mutexes */
+#define LWIP_COMPAT_MUTEX 1
 
 struct sys_mbox;
 typedef struct sys_mbox *sys_mbox_t;
+#define sys_mbox_valid(mbox) (((mbox) != NULL) && (*(mbox) != NULL))
+#define sys_mbox_set_invalid(mbox) do { if((mbox) != NULL) { *(mbox) = NULL; }}while(0)
 
 struct sys_thread;
 typedef struct sys_thread * sys_thread_t;
diff --git a/ports/unix/netif/delif.c b/ports/unix/netif/delif.c
index a807c9a..eef3d57 100644
--- a/ports/unix/netif/delif.c
+++ b/ports/unix/netif/delif.c
@@ -284,8 +284,10 @@ delif_thread(void *arg)
   sys_timeout(DELIF_TIMEOUT, delif_input_timeout, netif);
   sys_timeout(DELIF_TIMEOUT, delif_output_timeout, netif);
 
-  sem = sys_sem_new(0);
-  sys_sem_wait(sem);
+  if(sys_sem_new(&sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
+  sys_sem_wait(&sem);
 
 }
 /*-----------------------------------------------------------------------------------*/
diff --git a/ports/unix/netif/fifo.c b/ports/unix/netif/fifo.c
index e15244d..53465aa 100644
--- a/ports/unix/netif/fifo.c
+++ b/ports/unix/netif/fifo.c
@@ -22,14 +22,14 @@ u8_t fifoGet(fifo_t * fifo)
 {
 	u8_t c;
 
-	sys_sem_wait(fifo->sem);      /* enter critical section */
+	sys_sem_wait(&fifo->sem);      /* enter critical section */
 
 	if (fifo->dataslot == fifo->emptyslot) 
 	{
             fifo->getWaiting = TRUE;    /* tell putFifo to signal us when data is available */
-            sys_sem_signal(fifo->sem);  /* leave critical section (allow input from serial port..) */
-            sys_sem_wait(fifo->getSem); /* wait 4 data */
-            sys_sem_wait(fifo->sem);    /* reenter critical section */
+            sys_sem_signal(&fifo->sem);  /* leave critical section (allow input from serial port..) */
+            sys_sem_wait(&fifo->getSem); /* wait 4 data */
+            sys_sem_wait(&fifo->sem);    /* reenter critical section */
 	}
 
 	c = fifo->data[fifo->dataslot++];
@@ -39,7 +39,7 @@ u8_t fifoGet(fifo_t * fifo)
 	{
 		fifo->dataslot = 0; 
 	}
-	sys_sem_signal(fifo->sem);    /* leave critical section */
+	sys_sem_signal(&fifo->sem);    /* leave critical section */
 	return c;
 }
 
@@ -48,7 +48,7 @@ s16_t fifoGetNonBlock(fifo_t * fifo)
 {
 	u16_t c;
 
-	sys_sem_wait(fifo->sem);      /* enter critical section */
+	sys_sem_wait(&fifo->sem);      /* enter critical section */
 
 	if (fifo->dataslot == fifo->emptyslot) 
 	{
@@ -65,7 +65,7 @@ s16_t fifoGetNonBlock(fifo_t * fifo)
 			fifo->dataslot = 0; 
 		}
 	}
-	sys_sem_signal(fifo->sem);    /* leave critical section */
+	sys_sem_signal(&fifo->sem);    /* leave critical section */
 	return c;
 }
 
@@ -75,7 +75,7 @@ void fifoPut(fifo_t * fifo, int fd)
 	/* FIXME: mutex around struct data.. */
 	int cnt=0;
 
-	sys_sem_wait( fifo->sem ); /* enter critical */
+	sys_sem_wait(&fifo->sem ); /* enter critical */
 
 	LWIP_DEBUGF( SIO_FIFO_DEBUG,("fifoput: len%d dat%d empt%d --> ", fifo->len, fifo->dataslot, fifo->emptyslot ) );
 
@@ -105,17 +105,17 @@ void fifoPut(fifo_t * fifo, int fd)
 		fifo->emptyslot = 0;
 		LWIP_DEBUGF( SIO_FIFO_DEBUG, ("(WRAP) ") );
 
-		sys_sem_signal( fifo->sem ); /* leave critical */
+		sys_sem_signal(&fifo->sem ); /* leave critical */
 		fifoPut( fifo, fd );
 		return;
 	}
 	if ( fifo->getWaiting )
 	{
 		fifo->getWaiting = FALSE;
-		sys_sem_signal( fifo->getSem );
+		sys_sem_signal(&fifo->getSem );
 	}
 
-	sys_sem_signal( fifo->sem ); /* leave critical */
+	sys_sem_signal(&fifo->sem ); /* leave critical */
 	return;
 }
 
@@ -125,7 +125,11 @@ void fifoInit(fifo_t * fifo)
   fifo->dataslot  = 0;
   fifo->emptyslot = 0;
   fifo->len       = 0;
-  fifo->sem    = sys_sem_new(1);  /* critical section 1=free to enter */
-  fifo->getSem = sys_sem_new(0);  /* 0 = no one waiting */
+  if(sys_sem_new(&fifo->sem, 1) != ERR_OK) {  /* critical section 1=free to enter */
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
+  if(sys_sem_new(&fifo->getSem, 0) != ERR_OK) {  /* 0 = no one waiting */
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   fifo->getWaiting = FALSE;
 }
diff --git a/ports/unix/netif/pcapif.c b/ports/unix/netif/pcapif.c
index f958997..f722f88 100644
--- a/ports/unix/netif/pcapif.c
+++ b/ports/unix/netif/pcapif.c
@@ -141,7 +141,7 @@ timeout(void *arg)
     printf("ip_lookup dropped\n");
   }
 
-  sys_sem_signal(pcapif->sem);
+  sys_sem_signal(&pcapif->sem);
 }
 /*-----------------------------------------------------------------------------------*/
 static void
@@ -181,7 +181,7 @@ pcapif_thread(void *arg)
 
   while (1) {
     pcap_loop(pcapif->pd, 1, callback, (u_char *)netif);
-    sys_sem_wait(pcapif->sem);
+    sys_sem_wait(&pcapif->sem);
     if (pcapif->p != NULL) {
       netif->input(pcapif->p, netif);
     }
@@ -207,7 +207,9 @@ pcapif_init(struct netif *netif)
     return ERR_IF;
   }
 
-  p->sem = sys_sem_new(0);
+  if(sys_sem_new(&p->sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   p->p = NULL;
   p->lasttime = 0; 
   
diff --git a/ports/unix/netif/unixif.c b/ports/unix/netif/unixif.c
index c59f65e..0afc5c0 100644
--- a/ports/unix/netif/unixif.c
+++ b/ports/unix/netif/unixif.c
@@ -251,7 +251,7 @@ unixif_thread(void *arg)
 
 
   while (1) {
-    sys_sem_wait(unixif->sem);
+    sys_sem_wait(&unixif->sem);
     unixif_input_handler(netif);
   }
   
@@ -274,7 +274,7 @@ unixif_thread2(void *arg)
     FD_SET(unixif->fd, &fdset);
   
     if (select(unixif->fd + 1, &fdset, NULL, NULL, NULL) > 0) {
-      sys_sem_signal(unixif->sem);
+      sys_sem_signal(&unixif->sem);
     }
   }
 }
@@ -453,7 +453,9 @@ unixif_init_server(struct netif *netif)
   LWIP_DEBUGF(UNIXIF_DEBUG, ("unixif_accept: %d\n", fd2));
 
   unixif->fd = fd2;
-  unixif->sem = sys_sem_new(0);
+  if(sys_sem_new(&unixif->sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   sys_thread_new("unixif_thread", unixif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
   sys_thread_new("unixif_thread2", unixif_thread2, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
   return ERR_OK;
@@ -477,7 +479,9 @@ unixif_init_client(struct netif *netif)
     abort();
   }
   unixif->q = list_new(UNIXIF_QUEUELEN);
-  unixif->sem = sys_sem_new(0);
+  if(sys_sem_new(&unixif->sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   sys_thread_new("unixif_thread", unixif_thread, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
   sys_thread_new("unixif_thread2", unixif_thread2, netif, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
   return ERR_OK;
diff --git a/ports/unix/proj/lib/Makefile b/ports/unix/proj/lib/Makefile
index e924ce4..df95f47 100644
--- a/ports/unix/proj/lib/Makefile
+++ b/ports/unix/proj/lib/Makefile
@@ -39,7 +39,7 @@ LWIPDIR=$(CONTRIBDIR)/../lwip/src
 
 CCDEP=gcc
 CC=gcc
-CFLAGS=-g -Wall -fPIC -DIPv4 -DLWIP_DEBUG
+CFLAGS=-g -Wall -DIPv4 -DLWIP_DEBUG
 
 CFLAGS:=$(CFLAGS) \
 	-I$(LWIPDIR)/include -I$(LWIPARCH)/include -I$(LWIPDIR)/include/ipv4 \
diff --git a/ports/unix/proj/lib/unixlib.c b/ports/unix/proj/lib/unixlib.c
index de790f2..33f4187 100644
--- a/ports/unix/proj/lib/unixlib.c
+++ b/ports/unix/proj/lib/unixlib.c
@@ -26,7 +26,7 @@
  * 
  * Author: Kieran Mansley <kjm25@cam.ac.uk>
  *
- * $Id: unixlib.c,v 1.8 2010/02/09 13:19:01 goldsimon Exp $
+ * $Id: unixlib.c,v 1.9 2010/02/12 13:57:58 goldsimon Exp $
  */
 
 /*-----------------------------------------------------------------------------------*/
@@ -79,10 +79,12 @@ tcpip_init_done(void *arg)
 void _init(void){
   sys_sem_t sem;
 
-  sem = sys_sem_new(0);
+  if(sys_sem_new(&sem, 0) != ERR_OK) {
+    LWIP_ASSERT("failed to create semaphore", 0);
+  }
   tcpip_init(tcpip_init_done, &sem);
-  sys_sem_wait(sem);
-  sys_sem_free(sem);
+  sys_sem_wait(&sem);
+  sys_sem_free(&sem);
 }
 
 void _fini(void){
diff --git a/ports/unix/proj/unixsim/simhost.c b/ports/unix/proj/unixsim/simhost.c
index 62290e9..5d9f844 100644
--- a/ports/unix/proj/unixsim/simhost.c
+++ b/ports/unix/proj/unixsim/simhost.c
@@ -382,10 +382,11 @@ main_thread(void *arg)
 
   netif_init();
 
-  sem = sys_sem_new(0);
+  if(sys_sem_new(&sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   tcpip_init(tcpip_init_done, &sem);
-  sys_sem_wait(sem);
-  sys_sem_free(sem);
+  sys_sem_wait(&sem);
   printf("TCP/IP initialized.\n");
 
 #if LWIP_RAW
@@ -404,9 +405,8 @@ main_thread(void *arg)
 #if 0
     stats_display();
 #endif
-  /* Block for ever. */
-  sem = sys_sem_new(0);
-  sys_sem_wait(sem);
+  /* Block forever. */
+  sys_sem_wait(&sem);
 }
 /*-----------------------------------------------------------------------------------*/
 int
diff --git a/ports/unix/proj/unixsim/simnode.c b/ports/unix/proj/unixsim/simnode.c
index 1df5c5d..ebdadb3 100644
--- a/ports/unix/proj/unixsim/simnode.c
+++ b/ports/unix/proj/unixsim/simnode.c
@@ -109,19 +109,19 @@ main_thread(void *arg)
 {
   sys_sem_t sem;
 
-  sem = sys_sem_new(0);
+  if(sys_sem_new(&sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   tcpip_init(tcpip_init_done, &sem);
-  sys_sem_wait(sem);
-  sys_sem_free(sem);
+  sys_sem_wait(&sem);
   printf("TCP/IP initialized.\n");
 
 #ifdef MEM_PERF
   mem_perf_init("/tmp/memstats.client");
 #endif /* MEM_PERF */
 
-  sem = sys_sem_new(0);
-  sys_sem_wait(sem);
-
+  /* Block forever. */
+  sys_sem_wait(&sem);
 }
 /*-----------------------------------------------------------------------------------*/
 int
diff --git a/ports/unix/proj/unixsim/simrouter.c b/ports/unix/proj/unixsim/simrouter.c
index 9cff13e..c22e0d0 100644
--- a/ports/unix/proj/unixsim/simrouter.c
+++ b/ports/unix/proj/unixsim/simrouter.c
@@ -124,17 +124,18 @@ main_thread(void *arg)
 {
   sys_sem_t sem;
 
-  sem = sys_sem_new(0);
+  if(sys_sem_new(&sem, 0) != ERR_OK) {
+    LWIP_ASSERT("Failed to create semaphore", 0);
+  }
   tcpip_init(tcpip_init_done, &sem);
-  sys_sem_wait(sem);
-  sys_sem_free(sem);
+  sys_sem_wait(&sem);
   printf("TCP/IP initialized.\n");
 
 #ifdef MEM_PERF
   mem_perf_init("/tmp/memstats.client");
 #endif /* MEM_PERF */
-  sem = sys_sem_new(0);
-  sys_sem_wait(sem);
+  /* Block forever. */
+  sys_sem_wait(&sem);
 }
 /*-----------------------------------------------------------------------------------*/
 int
diff --git a/ports/unix/sys_arch.c b/ports/unix/sys_arch.c
index 9c6b6d1..f301b86 100644
--- a/ports/unix/sys_arch.c
+++ b/ports/unix/sys_arch.c
@@ -94,7 +94,7 @@ struct sys_thread {
 };
 
 static pthread_mutex_t lwprot_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_t lwprot_thread = (pthread_t) 0xDEAD;
+static pthread_t lwprot_thread = (pthread_t)0xDEAD;
 static int lwprot_count = 0;
 
 static struct sys_sem *sys_sem_new_internal(u8_t count);
@@ -150,38 +150,41 @@ sys_thread_new(char *name, void (* function)(void *arg), void *arg, int stacksiz
   return st;
 }
 /*-----------------------------------------------------------------------------------*/
-struct sys_mbox *
-sys_mbox_new(int size)
+err_t
+sys_mbox_new(struct sys_mbox **mb, int size)
 {
   struct sys_mbox *mbox;
   LWIP_UNUSED_ARG(size);
   
   mbox = malloc(sizeof(struct sys_mbox));
-  if (mbox != NULL) {
-    mbox->first = mbox->last = 0;
-    mbox->not_empty = sys_sem_new_internal(0);
-    mbox->not_full = sys_sem_new_internal(0);
-    mbox->mutex = sys_sem_new_internal(1);
-    mbox->wait_send = 0;
-  
-#if SYS_STATS
-    lwip_stats.sys.mbox.used++;
-    if (lwip_stats.sys.mbox.used > lwip_stats.sys.mbox.max) {
-      lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
-    }
-#endif /* SYS_STATS */
+  if (mbox == NULL) {
+    return ERR_MEM;
   }
-  return mbox;
+  mbox->first = mbox->last = 0;
+  mbox->not_empty = sys_sem_new_internal(0);
+  mbox->not_full = sys_sem_new_internal(0);
+  mbox->mutex = sys_sem_new_internal(1);
+  mbox->wait_send = 0;
+
+#if SYS_STATS
+  lwip_stats.sys.mbox.used++;
+  if (lwip_stats.sys.mbox.used > lwip_stats.sys.mbox.max) {
+    lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
+  }
+#endif /* SYS_STATS */
+  *mb = mbox;
+  return ERR_OK;
 }
 /*-----------------------------------------------------------------------------------*/
 void
-sys_mbox_free(struct sys_mbox *mbox)
+sys_mbox_free(struct sys_mbox **mb)
 {
-  if (mbox != SYS_MBOX_NULL) {
+  if ((mb != NULL) && (*mb != SYS_MBOX_NULL)) {
+    struct sys_mbox *mbox = *mb;
 #if SYS_STATS
     lwip_stats.sys.mbox.used--;
 #endif /* SYS_STATS */
-    sys_arch_sem_wait(mbox->mutex, 0);
+    sys_arch_sem_wait(&mbox->mutex, 0);
     
     sys_sem_free_internal(mbox->not_empty);
     sys_sem_free_internal(mbox->not_full);
@@ -193,17 +196,20 @@ sys_mbox_free(struct sys_mbox *mbox)
 }
 /*-----------------------------------------------------------------------------------*/
 err_t
-sys_mbox_trypost(struct sys_mbox *mbox, void *msg)
+sys_mbox_trypost(struct sys_mbox **mb, void *msg)
 {
   u8_t first;
+  struct sys_mbox *mbox;
+  LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
+  mbox = *mb;
   
-  sys_arch_sem_wait(mbox->mutex, 0);
+  sys_arch_sem_wait(&mbox->mutex, 0);
   
   LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_trypost: mbox %p msg %p\n",
                           (void *)mbox, (void *)msg));
   
   if ((mbox->last + 1) >= (mbox->first + SYS_MBOX_SIZE)) {
-    sys_sem_signal(mbox->mutex);
+    sys_sem_signal(&mbox->mutex);
     return ERR_MEM;
   }
 
@@ -218,28 +224,31 @@ sys_mbox_trypost(struct sys_mbox *mbox, void *msg)
   mbox->last++;
   
   if (first) {
-    sys_sem_signal(mbox->not_empty);
+    sys_sem_signal(&mbox->not_empty);
   }
 
-  sys_sem_signal(mbox->mutex);
+  sys_sem_signal(&mbox->mutex);
 
   return ERR_OK;
 }
 /*-----------------------------------------------------------------------------------*/
 void
-sys_mbox_post(struct sys_mbox *mbox, void *msg)
+sys_mbox_post(struct sys_mbox **mb, void *msg)
 {
   u8_t first;
-  
-  sys_arch_sem_wait(mbox->mutex, 0);
+  struct sys_mbox *mbox;
+  LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
+  mbox = *mb;
+
+  sys_arch_sem_wait(&mbox->mutex, 0);
   
   LWIP_DEBUGF(SYS_DEBUG, ("sys_mbox_post: mbox %p msg %p\n", (void *)mbox, (void *)msg));
   
   while ((mbox->last + 1) >= (mbox->first + SYS_MBOX_SIZE)) {
     mbox->wait_send++;
-    sys_sem_signal(mbox->mutex);
-    sys_arch_sem_wait(mbox->not_full, 0);
-    sys_arch_sem_wait(mbox->mutex, 0);
+    sys_sem_signal(&mbox->mutex);
+    sys_arch_sem_wait(&mbox->not_full, 0);
+    sys_arch_sem_wait(&mbox->mutex, 0);
     mbox->wait_send--;
   }
   
@@ -254,19 +263,23 @@ sys_mbox_post(struct sys_mbox *mbox, void *msg)
   mbox->last++;
   
   if (first) {
-    sys_sem_signal(mbox->not_empty);
+    sys_sem_signal(&mbox->not_empty);
   }
 
-  sys_sem_signal(mbox->mutex);
+  sys_sem_signal(&mbox->mutex);
 }
 /*-----------------------------------------------------------------------------------*/
 u32_t
-sys_arch_mbox_tryfetch(struct sys_mbox *mbox, void **msg)
+sys_arch_mbox_tryfetch(struct sys_mbox **mb, void **msg)
 {
-  sys_arch_sem_wait(mbox->mutex, 0);
+  struct sys_mbox *mbox;
+  LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
+  mbox = *mb;
+
+  sys_arch_sem_wait(&mbox->mutex, 0);
 
   if (mbox->first == mbox->last) {
-    sys_sem_signal(mbox->mutex);
+    sys_sem_signal(&mbox->mutex);
     return SYS_MBOX_EMPTY;
   }
 
@@ -281,39 +294,42 @@ sys_arch_mbox_tryfetch(struct sys_mbox *mbox, void **msg)
   mbox->first++;
   
   if (mbox->wait_send) {
-    sys_sem_signal(mbox->not_full);
+    sys_sem_signal(&mbox->not_full);
   }
 
-  sys_sem_signal(mbox->mutex);
+  sys_sem_signal(&mbox->mutex);
 
   return 0;
 }
 /*-----------------------------------------------------------------------------------*/
 u32_t
-sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u32_t timeout)
+sys_arch_mbox_fetch(struct sys_mbox **mb, void **msg, u32_t timeout)
 {
   u32_t time_needed = 0;
-  
+  struct sys_mbox *mbox;
+  LWIP_ASSERT("invalid mbox", (mb != NULL) && (*mb != NULL));
+  mbox = *mb;
+
   /* The mutex lock is quick so we don't bother with the timeout
      stuff here. */
-  sys_arch_sem_wait(mbox->mutex, 0);
+  sys_arch_sem_wait(&mbox->mutex, 0);
 
   while (mbox->first == mbox->last) {
-    sys_sem_signal(mbox->mutex);
+    sys_sem_signal(&mbox->mutex);
     
     /* We block while waiting for a mail to arrive in the mailbox. We
        must be prepared to timeout. */
     if (timeout != 0) {
-      time_needed = sys_arch_sem_wait(mbox->not_empty, timeout);
+      time_needed = sys_arch_sem_wait(&mbox->not_empty, timeout);
       
       if (time_needed == SYS_ARCH_TIMEOUT) {
         return SYS_ARCH_TIMEOUT;
       }
     } else {
-      sys_arch_sem_wait(mbox->not_empty, 0);
+      sys_arch_sem_wait(&mbox->not_empty, 0);
     }
     
-    sys_arch_sem_wait(mbox->mutex, 0);
+    sys_arch_sem_wait(&mbox->mutex, 0);
   }
 
   if (msg != NULL) {
@@ -327,10 +343,10 @@ sys_arch_mbox_fetch(struct sys_mbox *mbox, void **msg, u32_t timeout)
   mbox->first++;
   
   if (mbox->wait_send) {
-    sys_sem_signal(mbox->not_full);
+    sys_sem_signal(&mbox->not_full);
   }
 
-  sys_sem_signal(mbox->mutex);
+  sys_sem_signal(&mbox->mutex);
 
   return time_needed;
 }
@@ -349,8 +365,8 @@ sys_sem_new_internal(u8_t count)
   return sem;
 }
 /*-----------------------------------------------------------------------------------*/
-struct sys_sem *
-sys_sem_new(u8_t count)
+err_t
+sys_sem_new(struct sys_sem **sem, u8_t count)
 {
 #if SYS_STATS
   lwip_stats.sys.sem.used++;
@@ -358,7 +374,11 @@ sys_sem_new(u8_t count)
     lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
   }
 #endif /* SYS_STATS */
-  return sys_sem_new_internal(count);
+  *sem = sys_sem_new_internal(count);
+  if (*sem == NULL) {
+    return ERR_MEM;
+  }
+  return ERR_OK;
 }
 /*-----------------------------------------------------------------------------------*/
 static u32_t
@@ -405,10 +425,13 @@ cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex, u32_t timeout)
 }
 /*-----------------------------------------------------------------------------------*/
 u32_t
-sys_arch_sem_wait(struct sys_sem *sem, u32_t timeout)
+sys_arch_sem_wait(struct sys_sem **s, u32_t timeout)
 {
   u32_t time_needed = 0;
-  
+  struct sys_sem *sem;
+  LWIP_ASSERT("invalid sem", (s != NULL) && (*s != NULL));
+  sem = *s;
+
   pthread_mutex_lock(&(sem->mutex));
   while (sem->c <= 0) {
     if (timeout > 0) {
@@ -430,8 +453,12 @@ sys_arch_sem_wait(struct sys_sem *sem, u32_t timeout)
 }
 /*-----------------------------------------------------------------------------------*/
 void
-sys_sem_signal(struct sys_sem *sem)
+sys_sem_signal(struct sys_sem **s)
 {
+  struct sys_sem *sem;
+  LWIP_ASSERT("invalid sem", (s != NULL) && (*s != NULL));
+  sem = *s;
+
   pthread_mutex_lock(&(sem->mutex));
   sem->c++;
 
@@ -452,13 +479,13 @@ sys_sem_free_internal(struct sys_sem *sem)
 }
 /*-----------------------------------------------------------------------------------*/
 void
-sys_sem_free(struct sys_sem *sem)
+sys_sem_free(struct sys_sem **sem)
 {
-  if (sem != SYS_SEM_NULL) {
+  if ((sem != NULL) && (*sem != SYS_SEM_NULL)) {
 #if SYS_STATS
     lwip_stats.sys.sem.used--;
 #endif /* SYS_STATS */
-    sys_sem_free_internal(sem);
+    sys_sem_free_internal(*sem);
   }
 }
 #endif /* !NO_SYS */
diff --git a/ports/win32/include/arch/sys_arch.h b/ports/win32/include/arch/sys_arch.h
index 72af42e..472dd54 100644
--- a/ports/win32/include/arch/sys_arch.h
+++ b/ports/win32/include/arch/sys_arch.h
@@ -35,10 +35,17 @@
 /* HANDLE is used for sys_sem_t but we won't include windows.h */
 typedef void* sys_sem_t;
 #define SYS_SEM_NULL NULL
+#define sys_sem_valid(sem) (((sem) != NULL) && (*(sem) != NULL))
+#define sys_sem_set_invalid(sem) do { if((sem) != NULL) { *(sem) = NULL; }}while(0)
+
+/* let sys.h use binary semaphores for mutexes */
+#define LWIP_COMPAT_MUTEX 1
 
 struct lwip_mbox;
 typedef struct lwip_mbox* sys_mbox_t;
 #define SYS_MBOX_NULL NULL
+#define sys_mbox_valid(mbox) (((mbox) != NULL) && (*(mbox) != NULL))
+#define sys_mbox_set_invalid(mbox) do { if((mbox) != NULL) { *(mbox) = NULL; }}while(0)
 
 /* DWORD (thread id) is used for sys_thread_t but we won't include windows.h */
 typedef u32_t sys_thread_t;
diff --git a/ports/win32/sys_arch.c b/ports/win32/sys_arch.c
index 513d567..fd80233 100644
--- a/ports/win32/sys_arch.c
+++ b/ports/win32/sys_arch.c
@@ -121,7 +121,7 @@ void do_sleep(int ms)
   Sleep(ms);
 }
 
-sys_sem_t sys_sem_new(u8_t count)
+err_t sys_sem_new(sys_sem_t *sem, u8_t count)
 {
   HANDLE new_sem = NULL;
   new_sem = CreateSemaphore(0, count, 100000, 0);
@@ -134,22 +134,25 @@ sys_sem_t sys_sem_new(u8_t count)
       lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
     }
 #endif /* LWIP_STATS */
-    return new_sem;
+    *sem = new_sem;
+    return ERR_OK;
   }
    
   /* failed to allocate memory... */
 #if LWIP_STATS
   SYS_STATS_INC(sem.err);
 #endif /* LWIP_STATS */
-  return SYS_SEM_NULL;
+  *sem = SYS_SEM_NULL;
+  return ERR_MEM;
 }
 
-void sys_sem_free(sys_sem_t sem)
+void sys_sem_free(sys_sem_t *sem)
 {
   /* parameter check */
   LWIP_ASSERT("sem != NULL", sem != NULL);
-  LWIP_ASSERT("sem != INVALID_HANDLE_VALUE", sem != INVALID_HANDLE_VALUE);
-  CloseHandle(sem);
+  LWIP_ASSERT("*sem != NULL", *sem != NULL);
+  LWIP_ASSERT("*sem != INVALID_HANDLE_VALUE", *sem != INVALID_HANDLE_VALUE);
+  CloseHandle(*sem);
 
 #if LWIP_STATS
   SYS_STATS_DEC(sem.used);
@@ -157,17 +160,18 @@ void sys_sem_free(sys_sem_t sem)
 #endif /* LWIP_STATS */
 }
 
-u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
+u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
 {
   DWORD ret;
   LONGLONG starttime, endtime;
   LWIP_ASSERT("sem != NULL", sem != NULL);
-  LWIP_ASSERT("sem != INVALID_HANDLE_VALUE", sem != INVALID_HANDLE_VALUE);
+  LWIP_ASSERT("*sem != NULL", *sem != NULL);
+  LWIP_ASSERT("*sem != INVALID_HANDLE_VALUE", *sem != INVALID_HANDLE_VALUE);
   if(!timeout)
   {
     /* wait infinite */
     starttime = sys_get_ms_longlong();
-    ret = WaitForSingleObject(sem, INFINITE);
+    ret = WaitForSingleObject(*sem, INFINITE);
     LWIP_ASSERT("Error waiting for mutex", ret == WAIT_OBJECT_0);
     endtime = sys_get_ms_longlong();
     /* return the time we waited for the sem */
@@ -177,7 +181,7 @@ u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
   {
     int ret;
     starttime = sys_get_ms_longlong();
-    ret = WaitForSingleObject(sem, timeout);
+    ret = WaitForSingleObject(*sem, timeout);
     LWIP_ASSERT("Error waiting for mutex", (ret == WAIT_OBJECT_0) || (ret == WAIT_TIMEOUT));
     if(ret == WAIT_OBJECT_0)
     {
@@ -193,12 +197,13 @@ u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
   }
 }
 
-void sys_sem_signal(sys_sem_t sem)
+void sys_sem_signal(sys_sem_t *sem)
 {
   DWORD ret;
   LWIP_ASSERT("sem != NULL", sem != NULL);
-  LWIP_ASSERT("sem != INVALID_HANDLE_VALUE", sem != INVALID_HANDLE_VALUE);
-  ret = ReleaseSemaphore(sem, 1, NULL);
+  LWIP_ASSERT("*sem != NULL", *sem != NULL);
+  LWIP_ASSERT("*sem != INVALID_HANDLE_VALUE", *sem != INVALID_HANDLE_VALUE);
+  ret = ReleaseSemaphore(*sem, 1, NULL);
   LWIP_ASSERT("Error releasing mutex", ret != 0);
 }
 
@@ -229,19 +234,20 @@ sys_thread_t sys_thread_new(char *name, lwip_thread_fn function, void *arg, int
   return 0;
 }
 
-sys_mbox_t sys_mbox_new(int size)
+err_t sys_mbox_new(sys_mbox_t *mbox, int size)
 {
   struct lwip_mbox *new_mbox;
 
   LWIP_UNUSED_ARG(size);
 
+  *mbox = SYS_SEM_NULL;
   new_mbox = (struct lwip_mbox*)malloc(sizeof(struct lwip_mbox));
   LWIP_ASSERT("new_mbox != NULL", new_mbox != NULL);
   if(new_mbox == NULL) {
 #if LWIP_STATS
     SYS_STATS_INC(mbox.err);
 #endif /* LWIP_STATS */
-    return SYS_SEM_NULL;
+    return ERR_MEM;
   }
   new_mbox->sem = CreateSemaphore(0, 0, MAX_QUEUE_ENTRIES, 0);
   LWIP_ASSERT("Error creating semaphore", new_mbox->sem != NULL);
@@ -250,8 +256,7 @@ sys_mbox_t sys_mbox_new(int size)
     SYS_STATS_INC(mbox.err);
 #endif /* LWIP_STATS */
     free(new_mbox);
-    new_mbox = NULL;
-    return SYS_SEM_NULL;
+    return ERR_MEM;
   }
   memset(&new_mbox->q_mem, 0, sizeof(u32_t)*MAX_QUEUE_ENTRIES);
   new_mbox->head = 0;
@@ -263,32 +268,38 @@ sys_mbox_t sys_mbox_new(int size)
     lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
   }
 #endif /* LWIP_STATS */
-  return new_mbox;
+  *mbox = new_mbox;
+  return ERR_OK;
 }
 
-void sys_mbox_free(sys_mbox_t mbox)
+void sys_mbox_free(sys_mbox_t *mbox)
 {
   /* parameter check */
-  LWIP_ASSERT("sys_mbox_free ", mbox != SYS_MBOX_NULL );
-  LWIP_ASSERT("mbox->sem != NULL", mbox->sem != NULL);
-  LWIP_ASSERT("mbox->sem != INVALID_HANDLE_VALUE", mbox->sem != INVALID_HANDLE_VALUE);
+  LWIP_ASSERT("mbox != NULL", mbox != NULL);
+  LWIP_ASSERT("*mbox != NULL", *mbox != NULL);
+  LWIP_ASSERT("(*mbox)->sem != NULL", (*mbox)->sem != NULL);
+  LWIP_ASSERT("(*mbox)->sem != INVALID_HANDLE_VALUE", (*mbox)->sem != INVALID_HANDLE_VALUE);
 
-  CloseHandle(mbox->sem);
-  free(mbox);
+  CloseHandle((*mbox)->sem);
+  free(*mbox);
 
 #if LWIP_STATS
    SYS_STATS_DEC(mbox.used);
    LWIP_ASSERT( "sys_mbox_free() ", lwip_stats.sys.mbox.used!= (u16_t)-1 );
 #endif /* LWIP_STATS */
+   *mbox = NULL;
 }
 
-void sys_mbox_post(sys_mbox_t q, void *msg)
+void sys_mbox_post(sys_mbox_t *mbox, void *msg)
 {
   DWORD ret;
+  struct lwip_mbox* q;
   SYS_ARCH_DECL_PROTECT(lev);
 
   /* parameter check */
-  LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
+  LWIP_ASSERT("mbox != NULL", mbox != NULL);
+  q = *mbox;
+  LWIP_ASSERT("q != NULL", q != NULL);
   LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
   LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
 
@@ -305,14 +316,17 @@ void sys_mbox_post(sys_mbox_t q, void *msg)
   SYS_ARCH_UNPROTECT(lev);
 }
 
-err_t sys_mbox_trypost(sys_mbox_t q, void *msg)
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
 {
   u32_t new_head;
   DWORD ret;
+  struct lwip_mbox *q;
   SYS_ARCH_DECL_PROTECT(lev);
 
   /* parameter check */
-  LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
+  LWIP_ASSERT("mbox != NULL", mbox != NULL);
+  q = *mbox;
+  LWIP_ASSERT("q != NULL", q != NULL);
   LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
   LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
 
@@ -337,14 +351,17 @@ err_t sys_mbox_trypost(sys_mbox_t q, void *msg)
   return ERR_OK;
 }
 
-u32_t sys_arch_mbox_fetch(sys_mbox_t q, void **msg, u32_t timeout)
+u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
 {
   DWORD ret;
   LONGLONG starttime, endtime;
+  struct lwip_mbox *q;
   SYS_ARCH_DECL_PROTECT(lev);
 
   /* parameter check */
-  LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
+  LWIP_ASSERT("mbox != NULL", mbox != NULL);
+  q = *mbox;
+  LWIP_ASSERT("q != NULL", q != NULL);
   LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
   LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
 
@@ -377,13 +394,16 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t q, void **msg, u32_t timeout)
   }
 }
 
-u32_t sys_arch_mbox_tryfetch(sys_mbox_t q, void **msg)
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
 {
   DWORD ret;
+  struct lwip_mbox *q;
   SYS_ARCH_DECL_PROTECT(lev);
 
   /* parameter check */
-  LWIP_ASSERT("sys_mbox_free ", q != SYS_MBOX_NULL );
+  LWIP_ASSERT("mbox != NULL", mbox != NULL);
+  q = *mbox;
+  LWIP_ASSERT("q != NULL", q != NULL);
   LWIP_ASSERT("q->sem != NULL", q->sem != NULL);
   LWIP_ASSERT("q->sem != INVALID_HANDLE_VALUE", q->sem != INVALID_HANDLE_VALUE);
 
diff --git a/ports/win32/test.c b/ports/win32/test.c
index 994dfcc..1b2290b 100644
--- a/ports/win32/test.c
+++ b/ports/win32/test.c
@@ -358,9 +358,9 @@ test_init(void * arg)
 #if NO_SYS
   LWIP_UNUSED_ARG(arg);
 #else /* NO_SYS */
-  sys_sem_t init_sem;
+  sys_sem_t *init_sem;
   LWIP_ASSERT("arg != NULL", arg != NULL);
-  init_sem = (sys_sem_t)arg;
+  init_sem = (sys_sem_t*)arg;
 #endif /* NO_SYS */
 
   /* init network interfaces */
@@ -389,6 +389,7 @@ static void pppCloseCallback(void *arg)
 void main_loop()
 {
 #if !NO_SYS
+  err_t err;
   sys_sem_t init_sem;
 #endif /* NO_SYS */
 #if PPP_SUPPORT
@@ -404,12 +405,12 @@ void main_loop()
   lwip_init();
   test_init(NULL);
 #else /* NO_SYS */
-  init_sem = sys_sem_new(0);
-  tcpip_init(test_init, init_sem);
+  err = sys_sem_new(&init_sem, 0);
+  tcpip_init(test_init, &init_sem);
   /* we have to wait for initialization to finish before
    * calling update_adapter()! */
-  sys_sem_wait(init_sem);
-  sys_sem_free(init_sem);
+  sys_sem_wait(&init_sem);
+  sys_sem_free(&init_sem);
 #endif /* NO_SYS */
 
   /* MAIN LOOP for driver update (and timers if NO_SYS) */