X-Git-Url: https://sigrok.org/gitweb/?p=libserialport.git;a=blobdiff_plain;f=serialport.c;h=e6097eeda975f914ec7b960f72c9e2df546e8281;hp=15ca1fda35bc9e85f4404c18109c4cd7c9c10beb;hb=HEAD;hpb=f40ea9d461dd270caefed6460c62ab142476b211

diff --git a/serialport.c b/serialport.c
index 15ca1fd..1b5a95e 100644
--- a/serialport.c
+++ b/serialport.c
@@ -21,8 +21,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <config.h>
-#include "libserialport.h"
 #include "libserialport_internal.h"
 
 static const struct std_baudrate std_baudrates[] = {
@@ -49,33 +47,19 @@ static const struct std_baudrate std_baudrates[] = {
 
 void (*sp_debug_handler)(const char *format, ...) = sp_default_debug_handler;
 
-static void get_time(struct timeval *time);
-
 static enum sp_return get_config(struct sp_port *port, struct port_data *data,
 	struct sp_port_config *config);
 
 static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 	const struct sp_port_config *config);
 
-static void get_time(struct timeval *time)
-{
-#ifdef HAVE_CLOCK_GETTIME
-	struct timespec ts;
-	clock_gettime(CLOCK_MONOTONIC, &ts);
-	time->tv_sec = ts.tv_sec;
-	time->tv_usec = ts.tv_nsec / 1000;
-#else
-	gettimeofday(time, NULL);
-#endif
-}
-
 SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr)
 {
 	struct sp_port *port;
 #ifndef NO_PORT_METADATA
 	enum sp_return ret;
 #endif
-	int len;
+	size_t len;
 
 	TRACE("%s, %p", portname, port_ptr);
 
@@ -171,10 +155,7 @@ SP_API enum sp_transport sp_get_port_transport(const struct sp_port *port)
 {
 	TRACE("%p", port);
 
-	if (!port)
-		RETURN_ERROR(SP_ERR_ARG, "Null port");
-
-	RETURN_INT(port->transport);
+	RETURN_INT(port ? port->transport : SP_TRANSPORT_NATIVE);
 }
 
 SP_API enum sp_return sp_get_port_usb_bus_address(const struct sp_port *port,
@@ -339,7 +320,7 @@ SP_PRIV struct sp_port **list_append(struct sp_port **list,
                                      const char *portname)
 {
 	void *tmp;
-	unsigned int count;
+	size_t count;
 
 	for (count = 0; list[count]; count++)
 		;
@@ -504,7 +485,7 @@ SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
 	if (flags & SP_MODE_WRITE)
 		desired_access |= GENERIC_WRITE;
 
-	port->hdl = CreateFile(escaped_port_name, desired_access, 0, 0,
+	port->hdl = CreateFileA(escaped_port_name, desired_access, 0, 0,
 			 OPEN_EXISTING, flags_and_attributes, 0);
 
 	free(escaped_port_name);
@@ -555,7 +536,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)
@@ -567,6 +548,39 @@ SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
 
 	if ((port->fd = open(port->name, flags_local)) < 0)
 		RETURN_FAIL("open() failed");
+
+	/*
+	 * On POSIX in the default case the file descriptor of a serial port
+	 * is not opened exclusively. Therefore the settings of a port are
+	 * overwritten if the serial port is opened a second time. Windows
+	 * opens all serial ports exclusively.
+	 * So the idea is to open the serial ports alike in the exclusive mode.
+	 *
+	 * ioctl(*, TIOCEXCL) defines the file descriptor as exclusive. So all
+	 * further open calls on the serial port will fail.
+	 *
+	 * There is a race condition if two processes open the same serial
+	 * port. None of the processes will notice the exclusive ownership of
+	 * the other process because ioctl() doesn't return an error code if
+	 * the file descriptor is already marked as exclusive.
+	 * This can be solved with flock(). It returns an error if the file
+	 * descriptor is already locked by another process.
+	 */
+#ifdef HAVE_FLOCK
+	if (flock(port->fd, LOCK_EX | LOCK_NB) < 0)
+		RETURN_FAIL("flock() failed");
+#endif
+
+#ifdef TIOCEXCL
+	/*
+	 * Before Linux 3.8 ioctl(*, TIOCEXCL) was not implemented and could
+	 * lead to EINVAL or ENOTTY.
+	 * These errors aren't fatal and can be ignored.
+	 */
+	if (ioctl(port->fd, TIOCEXCL) < 0 && errno != EINVAL && errno != ENOTTY)
+		RETURN_FAIL("ioctl() failed");
+#endif
+
 #endif
 
 	ret = get_config(port, &data, &config);
@@ -576,6 +590,15 @@ SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
 		RETURN_CODEVAL(ret);
 	}
 
+	/*
+	 * Assume a default baudrate if the OS does not provide one.
+	 * Cannot assign -1 here since Windows holds the baudrate in
+	 * the DCB and does not configure the rate individually.
+	 */
+	if (config.baudrate == 0) {
+		config.baudrate = 9600;
+	}
+
 	/* Set sane port settings. */
 #ifdef _WIN32
 	data.dcb.fBinary = TRUE;
@@ -619,7 +642,8 @@ SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
 	data.term.c_cc[VTIME] = 0;
 
 	/* Ignore modem status lines; enable receiver; leave control lines alone on close. */
-	data.term.c_cflag |= (CLOCAL | CREAD | HUPCL);
+	data.term.c_cflag |= (CLOCAL | CREAD);
+	data.term.c_cflag &= ~(HUPCL);
 #endif
 
 #ifdef _WIN32
@@ -734,7 +758,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
@@ -796,77 +822,87 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
 		RETURN_INT(0);
 
 #ifdef _WIN32
-	DWORD bytes_written = 0;
+	DWORD remaining_ms, write_size, bytes_written;
+	size_t remaining_bytes, total_bytes_written = 0;
+	const uint8_t *write_ptr = (uint8_t *) buf;
+	bool result;
+	struct timeout timeout;
+
+	timeout_start(&timeout, timeout_ms);
 
 	TRY(await_write_completion(port));
 
-	/* Set timeout. */
-	if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) {
-		port->timeouts.WriteTotalTimeoutConstant = timeout_ms;
-		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
-			RETURN_FAIL("SetCommTimeouts() failed");
-	}
+	while (total_bytes_written < count) {
 
-	/* Reduce count if it exceeds the WriteFile limit. */
-	if (count > WRITEFILE_MAX_SIZE)
-		count = WRITEFILE_MAX_SIZE;
+		if (timeout_check(&timeout))
+			break;
 
-	/* Start write. */
-	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");
+		remaining_ms = timeout_remaining_ms(&timeout);
+
+		if (port->timeouts.WriteTotalTimeoutConstant != remaining_ms) {
+			port->timeouts.WriteTotalTimeoutConstant = remaining_ms;
+			if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+				RETURN_FAIL("SetCommTimeouts() failed");
+		}
+
+		/* Reduce write size if it exceeds the WriteFile limit. */
+		remaining_bytes = count - total_bytes_written;
+		if (remaining_bytes > WRITEFILE_MAX_SIZE)
+			write_size = WRITEFILE_MAX_SIZE;
+		else
+			write_size = (DWORD) remaining_bytes;
+
+		/* Start write. */
+
+		result = WriteFile(port->hdl, write_ptr, write_size, NULL, &port->write_ovl);
+
+		timeout_update(&timeout);
+
+		if (result) {
+			DEBUG("Write completed immediately");
+			bytes_written = write_size;
+		} 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");
+					break;
+				} else {
+					RETURN_FAIL("GetOverlappedResult() failed");
+				}
 			}
+			DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, write_size);
+		} else {
+			RETURN_FAIL("WriteFile() failed");
 		}
-		DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count);
-		RETURN_INT(bytes_written);
-	} else {
-		RETURN_FAIL("WriteFile() failed");
+
+		write_ptr += bytes_written;
+		total_bytes_written += bytes_written;
 	}
+
+	RETURN_INT((int) total_bytes_written);
 #else
 	size_t bytes_written = 0;
 	unsigned char *ptr = (unsigned char *) buf;
-	struct timeval start, delta, now, end = {0, 0};
-	int started = 0;
+	struct timeout timeout;
 	fd_set fds;
-	int result;
+	ssize_t 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);
-	}
+	timeout_start(&timeout, timeout_ms);
 
 	FD_ZERO(&fds);
 	FD_SET(port->fd, &fds);
 
 	/* Loop until we have written the requested number of bytes. */
 	while (bytes_written < count) {
-		/*
-		 * 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_ms ? &delta : NULL);
-		started = 1;
+
+		if (timeout_check(&timeout))
+			break;
+
+		result = select(port->fd + 1, NULL, &fds, NULL, timeout_timeval(&timeout));
+
+		timeout_update(&timeout);
+
 		if (result < 0) {
 			if (errno == EINTR) {
 				DEBUG("select() call was interrupted, repeating");
@@ -918,7 +954,7 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port,
 		RETURN_INT(0);
 
 #ifdef _WIN32
-	DWORD buf_bytes;
+	size_t buf_bytes;
 
 	/* Check whether previous write is complete. */
 	if (port->writing) {
@@ -948,7 +984,7 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port,
 	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 (WriteFile(port->hdl, port->write_buf, (DWORD) buf_bytes, NULL, &port->write_ovl) == 0) {
 		if (GetLastError() == ERROR_IO_PENDING) {
 			if ((port->writing = !HasOverlappedIoCompleted(&port->write_ovl)))
 				DEBUG("Asynchronous write completed immediately");
@@ -962,7 +998,7 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port,
 
 	DEBUG("All bytes written immediately");
 
-	RETURN_INT(buf_bytes);
+	RETURN_INT((int) buf_bytes);
 #else
 	/* Returns the number of bytes written, or -1 upon failure. */
 	ssize_t written = write(port->fd, buf, count);
@@ -1020,7 +1056,7 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 		RETURN_INT(0);
 
 #ifdef _WIN32
-	DWORD bytes_read = 0;
+	DWORD bytes_read;
 
 	/* Set timeout. */
 	if (port->timeouts.ReadIntervalTimeout != 0 ||
@@ -1034,9 +1070,9 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 	}
 
 	/* Start read. */
-	if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl)) {
+	if (ReadFile(port->hdl, buf, (DWORD) count, NULL, &port->read_ovl)) {
 		DEBUG("Read completed immediately");
-		bytes_read = count;
+		bytes_read = (DWORD) count;
 	} else if (GetLastError() == ERROR_IO_PENDING) {
 		DEBUG("Waiting for read to complete");
 		if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
@@ -1048,45 +1084,31 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
 
 	TRY(restart_wait_if_needed(port, bytes_read));
 
-	RETURN_INT(bytes_read);
+	RETURN_INT((int) bytes_read);
 
 #else
 	size_t bytes_read = 0;
-	unsigned char *ptr = (unsigned char *)buf;
-	struct timeval start, delta, now, end = {0, 0};
-	int started = 0;
+	unsigned char *ptr = (unsigned char *) buf;
+	struct timeout timeout;
 	fd_set fds;
-	int result;
+	ssize_t 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);
-	}
+	timeout_start(&timeout, timeout_ms);
 
 	FD_ZERO(&fds);
 	FD_SET(port->fd, &fds);
 
 	/* Loop until we have the requested number of bytes. */
 	while (bytes_read < count) {
-		/*
-		 * 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 (timeout_check(&timeout))
+			/* Timeout has expired. */
+			break;
+
+		result = select(port->fd + 1, &fds, NULL, NULL, timeout_timeval(&timeout));
+
+		timeout_update(&timeout);
+
 		if (result < 0) {
 			if (errno == EINTR) {
 				DEBUG("select() call was interrupted, repeating");
@@ -1165,7 +1187,7 @@ SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf,
 	/* 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)) {
+		if (ReadFile(port->hdl, buf, (DWORD) count, &bytes_read, &port->read_ovl)) {
 			DEBUG("Read completed immediately");
 		} else if (GetLastError() == ERROR_IO_PENDING) {
 			DEBUG("Waiting for read to complete");
@@ -1190,40 +1212,26 @@ SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf,
 
 #else
 	size_t bytes_read = 0;
-	struct timeval start, delta, now, end = {0, 0};
-	int started = 0;
+	struct timeout timeout;
 	fd_set fds;
-	int result;
+	ssize_t 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);
-	}
+	timeout_start(&timeout, timeout_ms);
 
 	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 (timeout_check(&timeout))
+			/* Timeout has expired. */
+			break;
+
+		result = select(port->fd + 1, &fds, NULL, NULL, timeout_timeval(&timeout));
+
+		timeout_update(&timeout);
+
 		if (result < 0) {
 			if (errno == EINTR) {
 				DEBUG("select() call was interrupted, repeating");
@@ -1285,7 +1293,7 @@ SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf,
 	}
 
 	/* Do read. */
-	if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0)
+	if (ReadFile(port->hdl, buf, (DWORD) count, NULL, &port->read_ovl) == 0)
 		if (GetLastError() != ERROR_IO_PENDING)
 			RETURN_FAIL("ReadFile() failed");
 
@@ -1339,6 +1347,11 @@ SP_API enum sp_return sp_output_waiting(struct sp_port *port)
 {
 	TRACE("%p", port);
 
+#ifdef __CYGWIN__
+	/* TIOCOUTQ is not defined in Cygwin headers */
+	RETURN_ERROR(SP_ERR_SUPP,
+			"Getting output bytes waiting is not supported on Cygwin");
+#else
 	CHECK_OPEN_PORT();
 
 	DEBUG_FMT("Checking output bytes waiting on port %s", port->name);
@@ -1356,6 +1369,7 @@ SP_API enum sp_return sp_output_waiting(struct sp_port *port)
 		RETURN_FAIL("TIOCOUTQ ioctl failed");
 	RETURN_INT(bytes_waiting);
 #endif
+#endif
 }
 
 SP_API enum sp_return sp_new_event_set(struct sp_event_set **result_ptr)
@@ -1473,12 +1487,9 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
 
 	RETURN_OK();
 #else
-	struct timeval start, delta, now, end = {0, 0};
-	const struct timeval max_delta = {
-		(INT_MAX / 1000), (INT_MAX % 1000) * 1000
-	};
-	int started = 0, timeout_overflow = 0;
-	int result, timeout_remaining_ms;
+	struct timeout timeout;
+	int poll_timeout;
+	int result;
 	struct pollfd *pollfds;
 	unsigned int i;
 
@@ -1497,42 +1508,24 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
 			pollfds[i].events |= POLLERR;
 	}
 
-	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);
-	}
+	timeout_start(&timeout, timeout_ms);
+	timeout_limit(&timeout, INT_MAX);
 
 	/* Loop until an event occurs. */
 	while (1) {
-		/*
-		 * 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);
-			if ((timeout_overflow = timercmp(&delta, &max_delta, >)))
-				delta = max_delta;
-			timeout_remaining_ms = delta.tv_sec * 1000 + delta.tv_usec / 1000;
+
+		if (timeout_check(&timeout)) {
+			DEBUG("Wait timed out");
+			break;
 		}
 
-		result = poll(pollfds, event_set->count, timeout_remaining_ms);
-		started = 1;
+		poll_timeout = (int) timeout_remaining_ms(&timeout);
+		if (poll_timeout == 0)
+			poll_timeout = -1;
+
+		result = poll(pollfds, event_set->count, poll_timeout);
+
+		timeout_update(&timeout);
 
 		if (result < 0) {
 			if (errno == EINTR) {
@@ -1544,7 +1537,7 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
 			}
 		} else if (result == 0) {
 			DEBUG("poll() timed out");
-			if (!timeout_overflow)
+			if (!timeout.overflow)
 				break;
 		} else {
 			DEBUG("poll() completed");
@@ -1695,28 +1688,25 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data,
 
 	config->bits = data->dcb.ByteSize;
 
-	if (data->dcb.fParity)
-		switch (data->dcb.Parity) {
-		case NOPARITY:
-			config->parity = SP_PARITY_NONE;
-			break;
-		case ODDPARITY:
-			config->parity = SP_PARITY_ODD;
-			break;
-		case EVENPARITY:
-			config->parity = SP_PARITY_EVEN;
-			break;
-		case MARKPARITY:
-			config->parity = SP_PARITY_MARK;
-			break;
-		case SPACEPARITY:
-			config->parity = SP_PARITY_SPACE;
-			break;
-		default:
-			config->parity = -1;
-		}
-	else
+	switch (data->dcb.Parity) {
+	case NOPARITY:
 		config->parity = SP_PARITY_NONE;
+		break;
+	case ODDPARITY:
+		config->parity = SP_PARITY_ODD;
+		break;
+	case EVENPARITY:
+		config->parity = SP_PARITY_EVEN;
+		break;
+	case MARKPARITY:
+		config->parity = SP_PARITY_MARK;
+		break;
+	case SPACEPARITY:
+		config->parity = SP_PARITY_SPACE;
+		break;
+	default:
+		config->parity = -1;
+	}
 
 	switch (data->dcb.StopBits) {
 	case ONESTOPBIT:
@@ -1896,6 +1886,7 @@ 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
+	BYTE* new_buf;
 
 	TRY(await_write_completion(port));
 
@@ -1912,11 +1903,10 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 
 		/* 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)
+		new_buf = realloc(port->write_buf, port->write_buf_size);
+		if (!new_buf)
 			RETURN_ERROR(SP_ERR_MEM, "Allocating write buffer failed");
+		port->write_buf = new_buf;
 	}
 
 	if (config->bits >= 0)
@@ -2536,17 +2526,17 @@ SP_API char *sp_last_error_message(void)
 	TRACE_VOID();
 
 #ifdef _WIN32
-	TCHAR *message;
+	char *message;
 	DWORD error = GetLastError();
 
-	DWORD length = FormatMessage(
+	DWORD length = FormatMessageA(
 		FORMAT_MESSAGE_ALLOCATE_BUFFER |
 		FORMAT_MESSAGE_FROM_SYSTEM |
 		FORMAT_MESSAGE_IGNORE_INSERTS,
 		NULL,
 		error,
 		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-		(LPTSTR) &message,
+		(LPSTR) &message,
 		0, NULL );
 
 	if (length >= 2 && message[length - 2] == '\r')