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;
#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. */
- 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");
#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. */
- 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");
#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. */
- 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");
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. */
- 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;
+ 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");
projects / libserialport.git / blobdiff