* 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>
*
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <config.h>
#include "libserialport.h"
#include "libserialport_internal.h"
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;
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");
#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
#ifdef _WIN32
if (port->usb_path)
free(port->usb_path);
+ if (port->write_buf)
+ free(port->write_buf);
#endif
free(port);
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;
#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 { \
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)
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)
#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_ms)
{
#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. */
if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) {
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)) {
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)
- RETURN_FAIL("GetOverlappedResult() failed");
+ 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 {
if (timeout_ms) {
/* Get time at start of operation. */
- gettimeofday(&start, NULL);
+ get_time(&start);
/* Define duration of timeout. */
delta.tv_sec = timeout_ms / 1000;
delta.tv_usec = (timeout_ms % 1000) * 1000;
* select() is even run.
*/
if (timeout_ms && started) {
- gettimeofday(&now, NULL);
+ get_time(&now);
if (timercmp(&now, &end, >))
/* Timeout has expired. */
break;
RETURN_INT(0);
#ifdef _WIN32
- DWORD written = 0;
- BYTE *ptr = (BYTE *) buf;
+ DWORD buf_bytes;
/* Check whether previous write is complete. */
if (port->writing) {
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
}
/* Set timeout. */
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");
#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;
if (timeout_ms) {
/* Get time at start of operation. */
- gettimeofday(&start, NULL);
+ get_time(&start);
/* Define duration of timeout. */
delta.tv_sec = timeout_ms / 1000;
delta.tv_usec = (timeout_ms % 1000) * 1000;
* select() is even run.
*/
if (timeout_ms && started) {
- gettimeofday(&now, NULL);
+ get_time(&now);
if (timercmp(&now, &end, >))
/* Timeout has expired. */
break;
#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
+}
+
SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf,
size_t count)
{
/* Set timeout. */
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");
TRY(restart_wait_if_needed(port, bytes_read));
RETURN_OK();
#else
struct timeval start, delta, now, end = {0, 0};
- int started = 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 pollfd *pollfds;
unsigned int i;
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)
if (timeout_ms) {
/* Get time at start of operation. */
- gettimeofday(&start, NULL);
+ get_time(&start);
/* Define duration of timeout. */
delta.tv_sec = timeout_ms / 1000;
delta.tv_usec = (timeout_ms % 1000) * 1000;
* to avoid any issues if a short timeout is reached before
* poll() is even run.
*/
- if (timeout_ms && started) {
- gettimeofday(&now, NULL);
+ 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;
}
- result = poll(pollfds, event_set->count, timeout_ms ? timeout_remaining_ms : -1);
+ result = poll(pollfds, event_set->count, timeout_remaining_ms);
started = 1;
if (result < 0) {
}
} else if (result == 0) {
DEBUG("poll() timed out");
- break;
+ if (!timeout_overflow)
+ break;
} else {
DEBUG("poll() completed");
break;
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) {
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)
projects / libserialport.git / blobdiff