X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=serialport.c;h=c233b28564c799b66cd3e903cd92dd45a9ea6ded;hb=89c3d63e1a36c243fa79edd8f914acd0c54f98db;hp=272bdf6013a525b96a30cd869ea3e99ca0ea0499;hpb=ad036cc8efcdcae5d2b8727996108c38c4915d2b;p=libserialport.git

diff --git a/serialport.c b/serialport.c
index 272bdf6..c233b28 100644
--- a/serialport.c
+++ b/serialport.c
@@ -2,8 +2,8 @@
  * This file is part of the libserialport project.
  *
  * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
- * Copyright (C) 2010-2012 Uwe Hermann <uwe@hermann-uwe.de>
- * Copyright (C) 2013 Martin Ling <martin-libserialport@earth.li>
+ * Copyright (C) 2010-2015 Uwe Hermann <uwe@hermann-uwe.de>
+ * Copyright (C) 2013-2015 Martin Ling <martin-libserialport@earth.li>
  * Copyright (C) 2013 Matthias Heidbrink <m-sigrok@heidbrink.biz>
  * Copyright (C) 2014 Aurelien Jacobs <aurel@gnuage.org>
  *
@@ -21,6 +21,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <config.h>
 #include "libserialport.h"
 #include "libserialport_internal.h"
 
@@ -54,6 +55,28 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data,
 static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 	const struct sp_port_config *config);
 
+#ifndef _WIN32
+static void get_time(struct timeval *time)
+{
+#ifdef HAVE_CLOCK_GETTIME
+	struct timespec ts;
+	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
+		clock_gettime(CLOCK_REALTIME, &ts);
+	time->tv_sec = ts.tv_sec;
+	time->tv_usec = ts.tv_nsec / 1000;
+#elif defined(__APPLE__)
+	mach_timebase_info_data_t info;
+	mach_timebase_info(&info);
+	uint64_t ticks = mach_absolute_time();
+	uint64_t ns = (ticks * info.numer) / info.denom;
+	time->tv_sec = ns / 1000000000;
+	time->tv_usec = (ns % 1000000000) / 1000;
+#else
+	gettimeofday(time, NULL);
+#endif
+}
+#endif
+
 SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr)
 {
 	struct sp_port *port;
@@ -74,6 +97,20 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port *
 
 	DEBUG_FMT("Building structure for port %s", portname);
 
+#if !defined(_WIN32) && defined(HAVE_REALPATH)
+	/*
+	 * get_port_details() below tries to be too smart and figure out
+	 * some transport properties from the port name which breaks with
+	 * symlinks. Therefore we canonicalize the portname first.
+	 */
+	char pathbuf[PATH_MAX + 1];
+	char *res = realpath(portname, pathbuf);
+	if (!res)
+		RETURN_ERROR(SP_ERR_ARG, "Could not retrieve realpath behind port name");
+
+	portname = pathbuf;
+#endif
+
 	if (!(port = malloc(sizeof(struct sp_port))))
 		RETURN_ERROR(SP_ERR_MEM, "Port structure malloc failed");
 
@@ -89,6 +126,8 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port *
 #ifdef _WIN32
 	port->usb_path = NULL;
 	port->hdl = INVALID_HANDLE_VALUE;
+	port->write_buf = NULL;
+	port->write_buf_size = 0;
 #else
 	port->fd = -1;
 #endif
@@ -126,7 +165,7 @@ SP_API char *sp_get_port_name(const struct sp_port *port)
 	RETURN_STRING(port->name);
 }
 
-SP_API char *sp_get_port_description(struct sp_port *port)
+SP_API char *sp_get_port_description(const struct sp_port *port)
 {
 	TRACE("%p", port);
 
@@ -234,6 +273,8 @@ SP_API enum sp_return sp_get_port_handle(const struct sp_port *port,
 
 	if (!port)
 		RETURN_ERROR(SP_ERR_ARG, "Null port");
+	if (!result_ptr)
+		RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
 
 #ifdef _WIN32
 	HANDLE *handle_ptr = result_ptr;
@@ -293,6 +334,8 @@ SP_API void sp_free_port(struct sp_port *port)
 #ifdef _WIN32
 	if (port->usb_path)
 		free(port->usb_path);
+	if (port->write_buf)
+		free(port->write_buf);
 #endif
 
 	free(port);
@@ -306,7 +349,8 @@ SP_PRIV struct sp_port **list_append(struct sp_port **list,
 	void *tmp;
 	unsigned int count;
 
-	for (count = 0; list[count]; count++);
+	for (count = 0; list[count]; count++)
+		;
 	if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2))))
 		goto fail;
 	list = tmp;
@@ -332,6 +376,8 @@ SP_API enum sp_return sp_list_ports(struct sp_port ***list_ptr)
 	if (!list_ptr)
 		RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
 
+	*list_ptr = NULL;
+
 #ifdef NO_ENUMERATION
 	RETURN_ERROR(SP_ERR_SUPP, "Enumeration not supported on this platform");
 #else
@@ -384,12 +430,12 @@ SP_API void sp_free_port_list(struct sp_port **list)
 #ifdef _WIN32
 #define CHECK_PORT_HANDLE() do { \
 	if (port->hdl == INVALID_HANDLE_VALUE) \
-		RETURN_ERROR(SP_ERR_ARG, "Invalid port handle"); \
+		RETURN_ERROR(SP_ERR_ARG, "Port not open"); \
 } while (0)
 #else
 #define CHECK_PORT_HANDLE() do { \
 	if (port->fd < 0) \
-		RETURN_ERROR(SP_ERR_ARG, "Invalid port fd"); \
+		RETURN_ERROR(SP_ERR_ARG, "Port not open"); \
 } while (0)
 #endif
 #define CHECK_OPEN_PORT() do { \
@@ -517,7 +563,7 @@ SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
 		RETURN_CODEVAL(ret);
 	}
 #else
-	int flags_local = O_NONBLOCK | O_NOCTTY;
+	int flags_local = O_NONBLOCK | O_NOCTTY | O_CLOEXEC;
 
 	/* Map 'flags' to the OS-specific settings. */
 	if ((flags & SP_MODE_READ_WRITE) == SP_MODE_READ_WRITE)
@@ -623,6 +669,10 @@ SP_API enum sp_return sp_close(struct sp_port *port)
 	CLOSE_OVERLAPPED(write_ovl);
 	CLOSE_OVERLAPPED(wait_ovl);
 
+	if (port->write_buf) {
+		free(port->write_buf);
+		port->write_buf = NULL;
+	}
 #else
 	/* Returns 0 upon success, -1 upon failure. */
 	if (close(port->fd) == -1)
@@ -692,7 +742,9 @@ SP_API enum sp_return sp_drain(struct sp_port *port)
 #else
 	int result;
 	while (1) {
-#ifdef __ANDROID__
+#if defined(__ANDROID__) && (__ANDROID_API__ < 21)
+		/* Android only has tcdrain from platform 21 onwards.
+		 * On previous API versions, use the ioctl directly. */
 		int arg = 1;
 		result = ioctl(port->fd, TCSBRK, &arg);
 #else
@@ -712,19 +764,40 @@ SP_API enum sp_return sp_drain(struct sp_port *port)
 #endif
 }
 
+#ifdef _WIN32
+static enum sp_return await_write_completion(struct sp_port *port)
+{
+	TRACE("%p", port);
+	DWORD bytes_written;
+	BOOL result;
+
+	/* Wait for previous non-blocking write to complete, if any. */
+	if (port->writing) {
+		DEBUG("Waiting for previous write to complete");
+		result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE);
+		port->writing = 0;
+		if (!result)
+			RETURN_FAIL("Previous write failed to complete");
+		DEBUG("Previous write completed");
+	}
+
+	RETURN_OK();
+}
+#endif
+
 SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
-                                        size_t count, unsigned int timeout)
+                                        size_t count, unsigned int timeout_ms)
 {
-	TRACE("%p, %p, %d, %d", port, buf, count, timeout);
+	TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms);
 
 	CHECK_OPEN_PORT();
 
 	if (!buf)
 		RETURN_ERROR(SP_ERR_ARG, "Null buffer");
 
-	if (timeout)
+	if (timeout_ms)
 		DEBUG_FMT("Writing %d bytes to port %s, timeout %d ms",
-			count, port->name, timeout);
+			count, port->name, timeout_ms);
 	else
 		DEBUG_FMT("Writing %d bytes to port %s, no timeout",
 			count, port->name);
@@ -734,68 +807,76 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
 
 #ifdef _WIN32
 	DWORD bytes_written = 0;
-	BOOL result;
 
-	/* Wait for previous non-blocking write to complete, if any. */
-	if (port->writing) {
-		DEBUG("Waiting for previous write to complete");
-		result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE);
-		port->writing = 0;
-		if (!result)
-			RETURN_FAIL("Previous write failed to complete");
-		DEBUG("Previous write completed");
-	}
+	TRY(await_write_completion(port));
 
 	/* Set timeout. */
-	port->timeouts.WriteTotalTimeoutConstant = timeout;
-	if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
-		RETURN_FAIL("SetCommTimeouts() failed");
+	if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) {
+		port->timeouts.WriteTotalTimeoutConstant = timeout_ms;
+		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+			RETURN_FAIL("SetCommTimeouts() failed");
+	}
+
+	/* Reduce count if it exceeds the WriteFile limit. */
+	if (count > WRITEFILE_MAX_SIZE)
+		count = WRITEFILE_MAX_SIZE;
 
 	/* Start write. */
-	if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl) == 0) {
-		if (GetLastError() == ERROR_IO_PENDING) {
-			DEBUG("Waiting for write to complete");
-			GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE);
-			DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count);
-			RETURN_INT(bytes_written);
-		} else {
-			RETURN_FAIL("WriteFile() failed");
-		}
-	} else {
+	if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl)) {
 		DEBUG("Write completed immediately");
 		RETURN_INT(count);
+	} else if (GetLastError() == ERROR_IO_PENDING) {
+		DEBUG("Waiting for write to complete");
+		if (GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE) == 0) {
+			if (GetLastError() == ERROR_SEM_TIMEOUT) {
+				DEBUG("Write timed out");
+				RETURN_INT(0);
+			} else {
+				RETURN_FAIL("GetOverlappedResult() failed");
+			}
+		}
+		DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count);
+		RETURN_INT(bytes_written);
+	} else {
+		RETURN_FAIL("WriteFile() failed");
 	}
 #else
 	size_t bytes_written = 0;
 	unsigned char *ptr = (unsigned char *) buf;
 	struct timeval start, delta, now, end = {0, 0};
+	int started = 0;
 	fd_set fds;
 	int result;
 
-	if (timeout) {
+	if (timeout_ms) {
 		/* Get time at start of operation. */
-		gettimeofday(&start, NULL);
+		get_time(&start);
 		/* Define duration of timeout. */
-		delta.tv_sec = timeout / 1000;
-		delta.tv_usec = (timeout % 1000) * 1000;
+		delta.tv_sec = timeout_ms / 1000;
+		delta.tv_usec = (timeout_ms % 1000) * 1000;
 		/* Calculate time at which we should give up. */
 		timeradd(&start, &delta, &end);
 	}
 
+	FD_ZERO(&fds);
+	FD_SET(port->fd, &fds);
+
 	/* Loop until we have written the requested number of bytes. */
 	while (bytes_written < count) {
-		/* Wait until space is available. */
-		FD_ZERO(&fds);
-		FD_SET(port->fd, &fds);
-		if (timeout) {
-			gettimeofday(&now, NULL);
-			if (timercmp(&now, &end, >)) {
-				DEBUG("Write timed out");
-				RETURN_INT(bytes_written);
-			}
+		/*
+		 * Check timeout only if we have run select() at least once,
+		 * to avoid any issues if a short timeout is reached before
+		 * select() is even run.
+		 */
+		if (timeout_ms && started) {
+			get_time(&now);
+			if (timercmp(&now, &end, >))
+				/* Timeout has expired. */
+				break;
 			timersub(&end, &now, &delta);
 		}
-		result = select(port->fd + 1, NULL, &fds, NULL, timeout ? &delta : NULL);
+		result = select(port->fd + 1, NULL, &fds, NULL, timeout_ms ? &delta : NULL);
+		started = 1;
 		if (result < 0) {
 			if (errno == EINTR) {
 				DEBUG("select() call was interrupted, repeating");
@@ -804,8 +885,8 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
 				RETURN_FAIL("select() failed");
 			}
 		} else if (result == 0) {
-			DEBUG("Write timed out");
-			RETURN_INT(bytes_written);
+			/* Timeout has expired. */
+			break;
 		}
 
 		/* Do write. */
@@ -824,6 +905,9 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
 		ptr += result;
 	}
 
+	if (bytes_written < count)
+		DEBUG("Write timed out");
+
 	RETURN_INT(bytes_written);
 #endif
 }
@@ -844,8 +928,7 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port,
 		RETURN_INT(0);
 
 #ifdef _WIN32
-	DWORD written = 0;
-	BYTE *ptr = (BYTE *) buf;
+	DWORD buf_bytes;
 
 	/* Check whether previous write is complete. */
 	if (port->writing) {
@@ -860,68 +943,85 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port,
 	}
 
 	/* Set timeout. */
-	port->timeouts.WriteTotalTimeoutConstant = 0;
-	if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
-		RETURN_FAIL("SetCommTimeouts() failed");
+	if (port->timeouts.WriteTotalTimeoutConstant != 0) {
+		port->timeouts.WriteTotalTimeoutConstant = 0;
+		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+			RETURN_FAIL("SetCommTimeouts() failed");
+	}
 
-	/*
-	 * Keep writing data until the OS has to actually start an async IO
-	 * for it. At that point we know the buffer is full.
-	 */
-	while (written < count) {
-		/* Copy first byte of user buffer. */
-		port->pending_byte = *ptr++;
-
-		/* Start asynchronous write. */
-		if (WriteFile(port->hdl, &port->pending_byte, 1, NULL, &port->write_ovl) == 0) {
-			if (GetLastError() == ERROR_IO_PENDING) {
-				if (HasOverlappedIoCompleted(&port->write_ovl)) {
-					DEBUG("Asynchronous write completed immediately");
-					port->writing = 0;
-					written++;
-					continue;
-				} else {
-					DEBUG("Asynchronous write running");
-					port->writing = 1;
-					RETURN_INT(++written);
-				}
-			} else {
-				/* Actual failure of some kind. */
-				RETURN_FAIL("WriteFile() failed");
-			}
+	/* Reduce count if it exceeds the WriteFile limit. */
+	if (count > WRITEFILE_MAX_SIZE)
+		count = WRITEFILE_MAX_SIZE;
+
+	/* Copy data to our write buffer. */
+	buf_bytes = min(port->write_buf_size, count);
+	memcpy(port->write_buf, buf, buf_bytes);
+
+	/* Start asynchronous write. */
+	if (WriteFile(port->hdl, port->write_buf, buf_bytes, NULL, &port->write_ovl) == 0) {
+		if (GetLastError() == ERROR_IO_PENDING) {
+			if ((port->writing = !HasOverlappedIoCompleted(&port->write_ovl)))
+				DEBUG("Asynchronous write completed immediately");
+			else
+				DEBUG("Asynchronous write running");
 		} else {
-			DEBUG("Single byte written immediately");
-			written++;
+			/* Actual failure of some kind. */
+			RETURN_FAIL("WriteFile() failed");
 		}
 	}
 
 	DEBUG("All bytes written immediately");
 
-	RETURN_INT(written);
+	RETURN_INT(buf_bytes);
 #else
 	/* Returns the number of bytes written, or -1 upon failure. */
 	ssize_t written = write(port->fd, buf, count);
 
-	if (written < 0)
-		RETURN_FAIL("write() failed");
-	else
+	if (written < 0) {
+		if (errno == EAGAIN)
+			// Buffer is full, no bytes written.
+			RETURN_INT(0);
+		else
+			RETURN_FAIL("write() failed");
+	} else {
 		RETURN_INT(written);
+	}
 #endif
 }
 
+#ifdef _WIN32
+/* Restart wait operation if buffer was emptied. */
+static enum sp_return restart_wait_if_needed(struct sp_port *port, unsigned int bytes_read)
+{
+	DWORD errors;
+	COMSTAT comstat;
+
+	if (bytes_read == 0)
+		RETURN_OK();
+
+	if (ClearCommError(port->hdl, &errors, &comstat) == 0)
+		RETURN_FAIL("ClearCommError() failed");
+
+	if (comstat.cbInQue == 0)
+		TRY(restart_wait(port));
+
+	RETURN_OK();
+}
+#endif
+
 SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
-                                       size_t count, unsigned int timeout)
+                                       size_t count, unsigned int timeout_ms)
 {
-	TRACE("%p, %p, %d, %d", port, buf, count, timeout);
+	TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms);
 
 	CHECK_OPEN_PORT();
 
 	if (!buf)
 		RETURN_ERROR(SP_ERR_ARG, "Null buffer");
 
-	if (timeout)
+	if (timeout_ms)
 		DEBUG_FMT("Reading %d bytes from port %s, timeout %d ms",
-			count, port->name, timeout);
+			count, port->name, timeout_ms);
 	else
 		DEBUG_FMT("Reading %d bytes from port %s, no timeout",
 			count, port->name);
@@ -931,72 +1031,72 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 
 #ifdef _WIN32
 	DWORD bytes_read = 0;
-	DWORD bytes_remaining;
-	int ret;
 
 	/* Set timeout. */
-	port->timeouts.ReadIntervalTimeout = 0;
-	port->timeouts.ReadTotalTimeoutConstant = timeout;
-	if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
-		RETURN_FAIL("SetCommTimeouts() failed");
+	if (port->timeouts.ReadIntervalTimeout != 0 ||
+			port->timeouts.ReadTotalTimeoutMultiplier != 0 ||
+			port->timeouts.ReadTotalTimeoutConstant != timeout_ms) {
+		port->timeouts.ReadIntervalTimeout = 0;
+		port->timeouts.ReadTotalTimeoutMultiplier = 0;
+		port->timeouts.ReadTotalTimeoutConstant = timeout_ms;
+		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+			RETURN_FAIL("SetCommTimeouts() failed");
+	}
 
 	/* Start read. */
-	if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) {
-		if (GetLastError() == ERROR_IO_PENDING) {
-			DEBUG("Waiting for read to complete");
-			GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE);
-			DEBUG_FMT("Read completed, %d/%d bytes read", bytes_read, count);
-		} else {
-			RETURN_FAIL("ReadFile() failed");
-		}
-	} else {
+	if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl)) {
 		DEBUG("Read completed immediately");
 		bytes_read = count;
+	} else if (GetLastError() == ERROR_IO_PENDING) {
+		DEBUG("Waiting for read to complete");
+		if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
+			RETURN_FAIL("GetOverlappedResult() failed");
+		DEBUG_FMT("Read completed, %d/%d bytes read", bytes_read, count);
+	} else {
+		RETURN_FAIL("ReadFile() failed");
 	}
 
-	ret = sp_input_waiting(port);
-
-	if (ret < 0)
-		RETURN_CODEVAL(ret);
-
-	bytes_remaining = ret;
-
-	/* Restart wait operation if buffer was emptied. */
-	if (bytes_read > 0 && bytes_remaining == 0)
-		TRY(restart_wait(port));
+	TRY(restart_wait_if_needed(port, bytes_read));
 
 	RETURN_INT(bytes_read);
 
 #else
 	size_t bytes_read = 0;
-	unsigned char *ptr = (unsigned char *) buf;
+	unsigned char *ptr = (unsigned char *)buf;
 	struct timeval start, delta, now, end = {0, 0};
+	int started = 0;
 	fd_set fds;
 	int result;
 
-	if (timeout) {
+	if (timeout_ms) {
 		/* Get time at start of operation. */
-		gettimeofday(&start, NULL);
+		get_time(&start);
 		/* Define duration of timeout. */
-		delta.tv_sec = timeout / 1000;
-		delta.tv_usec = (timeout % 1000) * 1000;
+		delta.tv_sec = timeout_ms / 1000;
+		delta.tv_usec = (timeout_ms % 1000) * 1000;
 		/* Calculate time at which we should give up. */
 		timeradd(&start, &delta, &end);
 	}
 
+	FD_ZERO(&fds);
+	FD_SET(port->fd, &fds);
+
 	/* Loop until we have the requested number of bytes. */
 	while (bytes_read < count) {
-		/* Wait until data is available. */
-		FD_ZERO(&fds);
-		FD_SET(port->fd, &fds);
-		if (timeout) {
-			gettimeofday(&now, NULL);
+		/*
+		 * Check timeout only if we have run select() at least once,
+		 * to avoid any issues if a short timeout is reached before
+		 * select() is even run.
+		 */
+		if (timeout_ms && started) {
+			get_time(&now);
 			if (timercmp(&now, &end, >))
 				/* Timeout has expired. */
-				RETURN_INT(bytes_read);
+				break;
 			timersub(&end, &now, &delta);
 		}
-		result = select(port->fd + 1, &fds, NULL, NULL, timeout ? &delta : NULL);
+		result = select(port->fd + 1, &fds, NULL, NULL, timeout_ms ? &delta : NULL);
+		started = 1;
 		if (result < 0) {
 			if (errno == EINTR) {
 				DEBUG("select() call was interrupted, repeating");
@@ -1005,8 +1105,8 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 				RETURN_FAIL("select() failed");
 			}
 		} else if (result == 0) {
-			DEBUG("Read timed out");
-			RETURN_INT(bytes_read);
+			/* Timeout has expired. */
+			break;
 		}
 
 		/* Do read. */
@@ -1014,7 +1114,10 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 
 		if (result < 0) {
 			if (errno == EAGAIN)
-				/* This shouldn't happen because we did a select() first, but handle anyway. */
+				/*
+				 * This shouldn't happen because we did a
+				 * select() first, but handle anyway.
+				 */
 				continue;
 			else
 				/* This is an actual failure. */
@@ -1025,6 +1128,142 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 		ptr += result;
 	}
 
+	if (bytes_read < count)
+		DEBUG("Read timed out");
+
+	RETURN_INT(bytes_read);
+#endif
+}
+
+SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf,
+                                            size_t count, unsigned int timeout_ms)
+{
+	TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms);
+
+	CHECK_OPEN_PORT();
+
+	if (!buf)
+		RETURN_ERROR(SP_ERR_ARG, "Null buffer");
+
+	if (count == 0)
+		RETURN_ERROR(SP_ERR_ARG, "Zero count");
+
+	if (timeout_ms)
+		DEBUG_FMT("Reading next max %d bytes from port %s, timeout %d ms",
+			count, port->name, timeout_ms);
+	else
+		DEBUG_FMT("Reading next max %d bytes from port %s, no timeout",
+			count, port->name);
+
+#ifdef _WIN32
+	DWORD bytes_read = 0;
+
+	/* If timeout_ms == 0, set maximum timeout. */
+	DWORD timeout_val = (timeout_ms == 0 ? MAXDWORD - 1 : timeout_ms);
+
+	/* Set timeout. */
+	if (port->timeouts.ReadIntervalTimeout != MAXDWORD ||
+			port->timeouts.ReadTotalTimeoutMultiplier != MAXDWORD ||
+			port->timeouts.ReadTotalTimeoutConstant != timeout_val) {
+		port->timeouts.ReadIntervalTimeout = MAXDWORD;
+		port->timeouts.ReadTotalTimeoutMultiplier = MAXDWORD;
+		port->timeouts.ReadTotalTimeoutConstant = timeout_val;
+		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+			RETURN_FAIL("SetCommTimeouts() failed");
+	}
+
+	/* Loop until we have at least one byte, or timeout is reached. */
+	while (bytes_read == 0) {
+		/* Start read. */
+		if (ReadFile(port->hdl, buf, count, &bytes_read, &port->read_ovl)) {
+			DEBUG("Read completed immediately");
+		} else if (GetLastError() == ERROR_IO_PENDING) {
+			DEBUG("Waiting for read to complete");
+			if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
+				RETURN_FAIL("GetOverlappedResult() failed");
+			if (bytes_read > 0) {
+				DEBUG("Read completed");
+			} else if (timeout_ms > 0) {
+				DEBUG("Read timed out");
+				break;
+			} else {
+				DEBUG("Restarting read");
+			}
+		} else {
+			RETURN_FAIL("ReadFile() failed");
+		}
+	}
+
+	TRY(restart_wait_if_needed(port, bytes_read));
+
+	RETURN_INT(bytes_read);
+
+#else
+	size_t bytes_read = 0;
+	struct timeval start, delta, now, end = {0, 0};
+	int started = 0;
+	fd_set fds;
+	int result;
+
+	if (timeout_ms) {
+		/* Get time at start of operation. */
+		get_time(&start);
+		/* Define duration of timeout. */
+		delta.tv_sec = timeout_ms / 1000;
+		delta.tv_usec = (timeout_ms % 1000) * 1000;
+		/* Calculate time at which we should give up. */
+		timeradd(&start, &delta, &end);
+	}
+
+	FD_ZERO(&fds);
+	FD_SET(port->fd, &fds);
+
+	/* Loop until we have at least one byte, or timeout is reached. */
+	while (bytes_read == 0) {
+		/*
+		 * Check timeout only if we have run select() at least once,
+		 * to avoid any issues if a short timeout is reached before
+		 * select() is even run.
+		 */
+		if (timeout_ms && started) {
+			get_time(&now);
+			if (timercmp(&now, &end, >))
+				/* Timeout has expired. */
+				break;
+			timersub(&end, &now, &delta);
+		}
+		result = select(port->fd + 1, &fds, NULL, NULL, timeout_ms ? &delta : NULL);
+		started = 1;
+		if (result < 0) {
+			if (errno == EINTR) {
+				DEBUG("select() call was interrupted, repeating");
+				continue;
+			} else {
+				RETURN_FAIL("select() failed");
+			}
+		} else if (result == 0) {
+			/* Timeout has expired. */
+			break;
+		}
+
+		/* Do read. */
+		result = read(port->fd, buf, count);
+
+		if (result < 0) {
+			if (errno == EAGAIN)
+				/* This shouldn't happen because we did a select() first, but handle anyway. */
+				continue;
+			else
+				/* This is an actual failure. */
+				RETURN_FAIL("read() failed");
+		}
+
+		bytes_read = result;
+	}
+
+	if (bytes_read == 0)
+		DEBUG("Read timed out");
+
 	RETURN_INT(bytes_read);
 #endif
 }
@@ -1043,33 +1282,28 @@ SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf,
 
 #ifdef _WIN32
 	DWORD bytes_read;
-	DWORD bytes_remaining;
-	int ret;
 
 	/* Set timeout. */
-	port->timeouts.ReadIntervalTimeout = MAXDWORD;
-	port->timeouts.ReadTotalTimeoutConstant = 0;
-	if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
-		RETURN_FAIL("SetCommTimeouts() failed");
+	if (port->timeouts.ReadIntervalTimeout != MAXDWORD ||
+			port->timeouts.ReadTotalTimeoutMultiplier != 0 ||
+			port->timeouts.ReadTotalTimeoutConstant != 0) {
+		port->timeouts.ReadIntervalTimeout = MAXDWORD;
+		port->timeouts.ReadTotalTimeoutMultiplier = 0;
+		port->timeouts.ReadTotalTimeoutConstant = 0;
+		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+			RETURN_FAIL("SetCommTimeouts() failed");
+	}
 
 	/* Do read. */
 	if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0)
-		RETURN_FAIL("ReadFile() failed");
+		if (GetLastError() != ERROR_IO_PENDING)
+			RETURN_FAIL("ReadFile() failed");
 
 	/* Get number of bytes read. */
-	if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
+	if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, FALSE) == 0)
 		RETURN_FAIL("GetOverlappedResult() failed");
 
-	ret = sp_input_waiting(port);
-
-	if (ret < 0)
-		RETURN_CODEVAL(ret);
-
-	bytes_remaining = ret;
-
-	/* Restart wait operation if buffer was emptied. */
-	if (bytes_read > 0 && bytes_remaining == 0)
-		TRY(restart_wait(port));
+	TRY(restart_wait_if_needed(port, bytes_read));
 
 	RETURN_INT(bytes_read);
 #else
@@ -1235,22 +1469,26 @@ SP_API void sp_free_event_set(struct sp_event_set *event_set)
 }
 
 SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
-                              unsigned int timeout)
+                              unsigned int timeout_ms)
 {
-	TRACE("%p, %d", event_set, timeout);
+	TRACE("%p, %d", event_set, timeout_ms);
 
 	if (!event_set)
 		RETURN_ERROR(SP_ERR_ARG, "Null event set");
 
 #ifdef _WIN32
 	if (WaitForMultipleObjects(event_set->count, event_set->handles, FALSE,
-			timeout ? timeout : INFINITE) == WAIT_FAILED)
+			timeout_ms ? timeout_ms : INFINITE) == WAIT_FAILED)
 		RETURN_FAIL("WaitForMultipleObjects() failed");
 
 	RETURN_OK();
 #else
 	struct timeval start, delta, now, end = {0, 0};
-	int result, timeout_remaining;
+	const struct timeval max_delta = {
+		(INT_MAX / 1000), (INT_MAX % 1000) * 1000
+	};
+	int started = 0, timeout_overflow = 0;
+	int result, timeout_remaining_ms;
 	struct pollfd *pollfds;
 	unsigned int i;
 
@@ -1258,7 +1496,7 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
 		RETURN_ERROR(SP_ERR_MEM, "pollfds malloc() failed");
 
 	for (i = 0; i < event_set->count; i++) {
-		pollfds[i].fd = ((int *) event_set->handles)[i];
+		pollfds[i].fd = ((int *)event_set->handles)[i];
 		pollfds[i].events = 0;
 		pollfds[i].revents = 0;
 		if (event_set->masks[i] & SP_EVENT_RX_READY)
@@ -1269,29 +1507,42 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
 			pollfds[i].events |= POLLERR;
 	}
 
-	if (timeout) {
+	if (timeout_ms) {
 		/* Get time at start of operation. */
-		gettimeofday(&start, NULL);
+		get_time(&start);
 		/* Define duration of timeout. */
-		delta.tv_sec = timeout / 1000;
-		delta.tv_usec = (timeout % 1000) * 1000;
+		delta.tv_sec = timeout_ms / 1000;
+		delta.tv_usec = (timeout_ms % 1000) * 1000;
 		/* Calculate time at which we should give up. */
 		timeradd(&start, &delta, &end);
 	}
 
 	/* Loop until an event occurs. */
 	while (1) {
-		if (timeout) {
-			gettimeofday(&now, NULL);
+		/*
+		 * Check timeout only if we have run poll() at least once,
+		 * to avoid any issues if a short timeout is reached before
+		 * poll() is even run.
+		 */
+		if (!timeout_ms) {
+			timeout_remaining_ms = -1;
+		} else if (!started) {
+			timeout_overflow = (timeout_ms > INT_MAX);
+			timeout_remaining_ms = timeout_overflow ? INT_MAX : timeout_ms;
+		} else {
+			get_time(&now);
 			if (timercmp(&now, &end, >)) {
 				DEBUG("Wait timed out");
 				break;
 			}
 			timersub(&end, &now, &delta);
-			timeout_remaining = delta.tv_sec * 1000 + delta.tv_usec / 1000;
+			if ((timeout_overflow = timercmp(&delta, &max_delta, >)))
+				delta = max_delta;
+			timeout_remaining_ms = delta.tv_sec * 1000 + delta.tv_usec / 1000;
 		}
 
-		result = poll(pollfds, event_set->count, timeout ? timeout_remaining : -1);
+		result = poll(pollfds, event_set->count, timeout_remaining_ms);
+		started = 1;
 
 		if (result < 0) {
 			if (errno == EINTR) {
@@ -1303,7 +1554,8 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
 			}
 		} else if (result == 0) {
 			DEBUG("poll() timed out");
-			break;
+			if (!timeout_overflow)
+				break;
 		} else {
 			DEBUG("poll() completed");
 			break;
@@ -1654,6 +1906,9 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 	DEBUG_FMT("Setting configuration for port %s", port->name);
 
 #ifdef _WIN32
+
+	TRY(await_write_completion(port));
+
 	if (config->baudrate >= 0) {
 		for (i = 0; i < NUM_STD_BAUDRATES; i++) {
 			if (config->baudrate == std_baudrates[i].value) {
@@ -1664,6 +1919,14 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 
 		if (i == NUM_STD_BAUDRATES)
 			data->dcb.BaudRate = config->baudrate;
+
+		/* Allocate write buffer for 50ms of data at baud rate. */
+		port->write_buf_size = max(config->baudrate / (8 * 20), 1);
+		port->write_buf = realloc(port->write_buf,
+					  port->write_buf_size);
+
+		if (!port->write_buf)
+			RETURN_ERROR(SP_ERR_MEM, "Allocating write buffer failed");
 	}
 
 	if (config->bits >= 0)
@@ -2115,6 +2378,8 @@ SP_API enum sp_return sp_set_##x(struct sp_port *port, type x) { \
 SP_API enum sp_return sp_get_config_##x(const struct sp_port_config *config, \
                                         type *x) { \
 	TRACE("%p, %p", config, x); \
+	if (!x) \
+		RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); \
 	if (!config) \
 		RETURN_ERROR(SP_ERR_ARG, "Null config"); \
 	*x = config->x; \
@@ -2281,10 +2546,10 @@ SP_API char *sp_last_error_message(void)
 	TRACE_VOID();
 
 #ifdef _WIN32
-	LPVOID message;
+	TCHAR *message;
 	DWORD error = GetLastError();
 
-	FormatMessage(
+	DWORD length = FormatMessage(
 		FORMAT_MESSAGE_ALLOCATE_BUFFER |
 		FORMAT_MESSAGE_FROM_SYSTEM |
 		FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -2294,6 +2559,9 @@ SP_API char *sp_last_error_message(void)
 		(LPTSTR) &message,
 		0, NULL );
 
+	if (length >= 2 && message[length - 2] == '\r')
+		message[length - 2] = '\0';
+
 	RETURN_STRING(message);
 #else
 	RETURN_STRING(strerror(errno));