Fix some warnings for size_t, DWORD and int conversions.

[libserialport.git] / serialport.c

diff --git a/serialport.c b/serialport.c
index dc62da9f418935890c76847e73204cfcc4c9315b..b2e4a7984fdcf2738209bc74cacd60f66c693a9b 100644 (file)
--- 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[] = {
@@ -61,7 +59,7 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port *
 #ifndef NO_PORT_METADATA
        enum sp_return ret;
 #endif
-       int len;
+       size_t len;
 
        TRACE("%s, %p", portname, port_ptr);
 
@@ -325,7 +323,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++)
                ;
@@ -784,40 +782,65 @@ 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;
@@ -891,7 +914,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) {
@@ -921,7 +944,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");
@@ -935,7 +958,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);
@@ -993,7 +1016,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 ||
@@ -1007,9 +1030,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)
@@ -1021,7 +1044,7 @@ 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;
@@ -1124,7 +1147,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");
@@ -1230,7 +1253,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");