X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=serialport.c;h=30c83739a360f63031c50ba3357eb2f0a6abe668;hb=6aaf844863e63b71b5cf6b557bf3cd9257b5cffd;hp=15ca1fda35bc9e85f4404c18109c4cd7c9c10beb;hpb=f40ea9d461dd270caefed6460c62ab142476b211;p=libserialport.git diff --git a/serialport.c b/serialport.c index 15ca1fd..30c8373 100644 --- a/serialport.c +++ b/serialport.c @@ -49,26 +49,12 @@ 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; @@ -555,7 +541,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) @@ -734,7 +720,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 +784,84 @@ 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, 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. */ + 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. */ - 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"); @@ -1052,41 +1047,27 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, #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"); @@ -1190,40 +1171,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; - 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"); @@ -1473,12 +1440,8 @@ 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 result; struct pollfd *pollfds; unsigned int i; @@ -1497,42 +1460,20 @@ 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; + result = poll(pollfds, event_set->count, timeout_remaining_ms(&timeout) || -1); + + timeout_update(&timeout); if (result < 0) { if (errno == EINTR) { @@ -1544,7 +1485,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");