#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);
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)
#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
RETURN_INT(0);
#ifdef _WIN32
- DWORD bytes_written = 0;
+ DWORD remaining_ms, write_size, bytes_written, 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) {
- /* 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");
+ if (timeout_check(&timeout))
+ break;
+
+ 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. */
+ write_size = count - total_bytes_written;
+ if (write_size > WRITEFILE_MAX_SIZE)
+ write_size = WRITEFILE_MAX_SIZE;
+
+ /* 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(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;
- if (timeout_ms) {
- /* Get time at start of operation. */
- gettimeofday(&start, NULL);
- /* 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) {
- gettimeofday(&now, NULL);
- 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");
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
}
#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;
- if (timeout_ms) {
- /* Get time at start of operation. */
- gettimeofday(&start, NULL);
- /* 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) {
- gettimeofday(&now, NULL);
- 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");
#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;
- if (timeout_ms) {
- /* Get time at start of operation. */
- gettimeofday(&start, NULL);
- /* 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) {
- gettimeofday(&now, NULL);
- 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");
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 result;
struct pollfd *pollfds;
unsigned int i;
pollfds[i].events |= POLLERR;
}
- if (timeout_ms) {
- /* Get time at start of operation. */
- gettimeofday(&start, NULL);
- /* 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 {
- gettimeofday(&now, NULL);
- 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;
+ result = poll(pollfds, event_set->count, timeout_remaining_ms(&timeout) || -1);
+
+ timeout_update(&timeout);
if (result < 0) {
if (errno == EINTR) {
}
} else if (result == 0) {
DEBUG("poll() timed out");
- if (!timeout_overflow)
+ if (!timeout.overflow)
break;
} else {
DEBUG("poll() completed");
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