diff -urN ot/tcl8.5.2/unix/configure.in nt/tcl8.5.2/unix/configure.in
--- ot/tcl8.5.2/unix/configure.in	Fri Mar 28 14:41:53 2008
+++ nt/tcl8.5.2/unix/configure.in	Thu May  8 20:51:20 2008
@@ -492,6 +492,12 @@
 AC_CHECK_FUNCS(chflags)
 
 #--------------------------------------------------------------------
+# Check for support of poll function
+#--------------------------------------------------------------------
+
+AC_CHECK_FUNCS(poll)
+
+#--------------------------------------------------------------------
 # Darwin specific API checks and defines
 #--------------------------------------------------------------------
 
diff -urN ot/tcl8.5.2/unix/tclUnixChan.c nt/tcl8.5.2/unix/tclUnixChan.c
--- ot/tcl8.5.2/unix/tclUnixChan.c	Mon Mar  3 09:54:43 2008
+++ nt/tcl8.5.2/unix/tclUnixChan.c	Thu May  8 20:51:20 2008
@@ -16,6 +16,10 @@
 #include "tclInt.h"	/* Internal definitions for Tcl. */
 #include "tclIO.h"	/* To get Channel type declaration. */
 
+#ifdef HAVE_POLL
+#   include <poll.h>
+#endif
+
 #define SUPPORTS_TTY
 
 #undef DIRECT_BAUD
@@ -3021,16 +3025,128 @@
 				 * at all, and a value of -1 means wait
 				 * forever. */
 {
+#ifdef HAVE_POLL
+    int numFound, pollTimeout = 0, result = 0;
+    Tcl_Time start, delta;
+    struct pollfd pfd;
+
+    /*
+     * If there is a non-zero finite timeout, compute the time when we give
+     * up.
+     */
+
+    if (timeout < 0) {
+	timeout = INFTIM;
+    } else {
+	pollTimeout = timeout;
+	if (timeout > 0) {
+	    Tcl_GetTime(&start);
+	}
+    }
+
+    /*
+     * Initialize the poll file descriptor structure.
+     */
+
+#   define TCL_POLL_READ_EVENTS		(POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)
+#   define TCL_POLL_WRITE_EVENTS	(POLLOUT | POLLWRBAND)
+#   define TCL_POLL_EXCEPT_EVENTS_SET	POLLERR
+#   define TCL_POLL_EXCEPT_EVENTS_GET	(POLLERR | POLLHUP)
+#   define TCL_POLL_ERR_EVENTS		POLLNVAL
+
+    pfd.fd = fd;
+    pfd.events = 0;
+    if (mask & TCL_READABLE) {
+	SET_BITS(pfd.events, TCL_POLL_READ_EVENTS);
+    }
+    if (mask & TCL_WRITABLE) {
+	SET_BITS(pfd.events, TCL_POLL_WRITE_EVENTS);
+    }
+    if (mask & TCL_EXCEPTION) {
+	SET_BITS(pfd.events, TCL_POLL_EXCEPT_EVENTS_SET);
+    }
+
+    /*
+     * Loop in a mini-event loop of our own, waiting for either the
+     * file to become ready or a timeout to occur.
+     */
+
+    while (1) {
+
+	/*
+	 * Wait for the event or a timeout.
+	 */
+
+	numFound = poll(&pfd, (nfds_t) 1, timeout);
+	if (numFound == 1) {
+	    if (pfd.revents & TCL_POLL_ERR_EVENTS) {
+		Tcl_Panic("TclWaitForFile can't handle file id %d", fd);
+	    }
+	    if (pfd.revents & TCL_POLL_READ_EVENTS) {
+		SET_BITS(result, TCL_READABLE);
+	    }
+	    if (pfd.revents & TCL_POLL_WRITE_EVENTS) {
+		SET_BITS(result, TCL_WRITABLE);
+	    }
+	    if (pfd.revents & TCL_POLL_EXCEPT_EVENTS_GET) {
+		SET_BITS(result, TCL_EXCEPTION);
+	    }
+	    result &= mask;
+	    if (result) {
+		break;
+	    }
+	} else if (numFound == -1 && errno != EINTR) {
+	    Tcl_Panic("TclWaitForFile poll error %d", errno);
+	}
+	if (timeout == 0) {
+	    break;
+	}
+	if (timeout == INFTIM) {
+	    continue;
+	}
+
+	/*
+	 * The poll returned early, so we need to recompute the timeout.
+	 */
+
+	Tcl_GetTime(&delta);
+	delta.usec -= start.usec;
+	delta.sec -= start.sec;
+	if (delta.usec < 0) {
+	    delta.sec -= 1;
+	    delta.usec += 1000000;
+	}
+	timeout = pollTimeout;
+	if (delta.sec > 0) {
+		timeout -= (delta.sec * 1000);
+	}
+	if (delta.usec >= 1000) {
+		timeout -= (delta.usec / 1000);
+	}
+        if (timeout < 0) {
+	    break;
+	}
+    }
+    return result;
+#else
     Tcl_Time abortTime = {0, 0}, now; /* silence gcc 4 warning */
     struct timeval blockTime, *timeoutPtr;
-    int index, numFound, result = 0;
-    fd_mask bit;
-    fd_mask readyMasks[3*MASK_SIZE];
-    fd_mask *maskp[3];		/* This array reflects the readable/writable
-				 * conditions that were found to exist by the
-				 * last call to select. */
+    int numFound, result = 0;
+    fd_set readableMask;
+    fd_set writableMask;
+    fd_set exceptionalMask;
 
+
     /*
+     * Sanity check fd.
+     */
+
+    if (fd >= FD_SETSIZE) {
+	Tcl_Panic("TclWaitForFile can't handle file id %d", fd);
+	/* must never get here, or select masks overrun will occur below */
+    }
+
+    /*
      * If there is a non-zero finite timeout, compute the time when we give
      * up.
      */
@@ -3053,16 +3169,12 @@
     }
 
     /*
-     * Initialize the ready masks and compute the mask offsets.
+     * Initialize the select masks.
      */
 
-    if (fd >= FD_SETSIZE) {
-	Tcl_Panic("TclWaitForFile can't handle file id %d", fd);
-	/* must never get here, or readyMasks overrun will occur below */
-    }
-    memset(readyMasks, 0, 3*MASK_SIZE*sizeof(fd_mask));
-    index = fd / (NBBY*sizeof(fd_mask));
-    bit = ((fd_mask)1) << (fd % (NBBY*sizeof(fd_mask)));
+    FD_ZERO(&readableMask);
+    FD_ZERO(&writableMask);
+    FD_ZERO(&exceptionalMask);
 
     /*
      * Loop in a mini-event loop of our own, waiting for either the file to
@@ -3084,41 +3196,32 @@
 	}
 
 	/*
-	 * Set the appropriate bit in the ready masks for the fd.
+	 * Compute the logical OR of the select masks for the fd.
 	 */
 
-	if (mask & TCL_READABLE) {
-	    readyMasks[index] |= bit;
+	if (mask & TCL_READABLE)  {
+	    FD_SET(fd, &readableMask);
 	}
-	if (mask & TCL_WRITABLE) {
-	    (readyMasks+MASK_SIZE)[index] |= bit;
+	if (mask & TCL_WRITABLE)  {
+	    FD_SET(fd, &writableMask);
 	}
 	if (mask & TCL_EXCEPTION) {
-	    (readyMasks+2*(MASK_SIZE))[index] |= bit;
+	    FD_SET(fd, &exceptionalMask);
 	}
 
 	/*
 	 * Wait for the event or a timeout.
 	 */
 
-	/*
-	 * This is needed to satisfy GCC 3.3's strict aliasing rules.
-	 */
-
-	maskp[0] = &readyMasks[0];
-	maskp[1] = &readyMasks[MASK_SIZE];
-	maskp[2] = &readyMasks[2*MASK_SIZE];
-	numFound = select(fd+1, (SELECT_MASK *) maskp[0],
-		(SELECT_MASK *) maskp[1],
-		(SELECT_MASK *) maskp[2], timeoutPtr);
+	numFound = select(fd + 1, &readableMask, &writableMask, &exceptionalMask, timeoutPtr);
 	if (numFound == 1) {
-	    if (readyMasks[index] & bit) {
+	    if (FD_ISSET(fd, &readableMask))   {
 		SET_BITS(result, TCL_READABLE);
 	    }
-	    if ((readyMasks+MASK_SIZE)[index] & bit) {
+	    if (FD_ISSET(fd, &writableMask))  {
 		SET_BITS(result, TCL_WRITABLE);
 	    }
-	    if ((readyMasks+2*(MASK_SIZE))[index] & bit) {
+	    if (FD_ISSET(fd, &exceptionalMask)) { 
 		SET_BITS(result, TCL_EXCEPTION);
 	    }
 	    result &= mask;
@@ -3144,6 +3247,7 @@
 	}
     }
     return result;
+#endif
 }
 
 /*
