diff --git a/common/rdr/FdInStream.cxx b/common/rdr/FdInStream.cxx
index 22433a1..9f35c9f 100644
--- a/common/rdr/FdInStream.cxx
+++ b/common/rdr/FdInStream.cxx
@@ -22,6 +22,7 @@
 
 #include <stdio.h>
 #include <string.h>
+#include <errno.h>
 #ifdef _WIN32
 #include <winsock2.h>
 #ifndef _WIN32_WCE
@@ -34,7 +35,6 @@
 #include <os/winerrno.h>
 #else
 #include <sys/types.h>
-#include <errno.h>
 #include <unistd.h>
 #include <sys/time.h>
 #endif
diff --git a/common/rdr/FdOutStream.cxx b/common/rdr/FdOutStream.cxx
index 83360d6..75131a6 100644
--- a/common/rdr/FdOutStream.cxx
+++ b/common/rdr/FdOutStream.cxx
@@ -23,6 +23,7 @@
 
 #include <stdio.h>
 #include <string.h>
+#include <errno.h>
 #ifdef _WIN32
 #include <winsock2.h>
 #define write(s,b,l) send(s,(const char*)b,l,0)
@@ -31,7 +32,6 @@
 #include <os/winerrno.h>
 #else
 #include <sys/types.h>
-#include <errno.h>
 #include <unistd.h>
 #include <sys/time.h>
 #endif
