X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=e6097eeda975f914ec7b960f72c9e2df546e8281;hb=HEAD;hp=45f9773bd56020dfbc9fba2453fbb0f3b3b0b73e;hpb=33fd8804b8a81da4cc3ffcf43ded2288381aad49;p=libserialport.git diff --git a/serialport.c b/serialport.c index 45f9773..1b5a95e 100644 --- a/serialport.c +++ b/serialport.c @@ -2,9 +2,10 @@ * This file is part of the libserialport project. * * Copyright (C) 2010-2012 Bert Vermeulen - * Copyright (C) 2010-2012 Uwe Hermann - * Copyright (C) 2013 Martin Ling + * Copyright (C) 2010-2015 Uwe Hermann + * Copyright (C) 2013-2015 Martin Ling * Copyright (C) 2013 Matthias Heidbrink + * Copyright (C) 2014 Aurelien Jacobs * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as @@ -20,113 +21,9 @@ * along with this program. If not, see . */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifdef _WIN32 -#include -#include -#include -#else -#include -#include -#include -#include -#include -#endif -#ifdef __APPLE__ -#include -#include -#include -#include -#endif -#ifdef __linux__ -#ifdef HAVE_LIBUDEV -#include "libudev.h" -#endif -#ifndef __ANDROID__ -#include "linux/serial.h" -#endif -#include "linux_termios.h" - -/* TCGETX/TCSETX is not available everywhere. */ -#if defined(TCGETX) && defined(TCSETX) && defined(HAVE_TERMIOX) -#define USE_TERMIOX -#endif -#endif - -/* TIOCINQ/TIOCOUTQ is not available everywhere. */ -#if !defined(TIOCINQ) && defined(FIONREAD) -#define TIOCINQ FIONREAD -#endif -#if !defined(TIOCOUTQ) && defined(FIONWRITE) -#define TIOCOUTQ FIONWRITE -#endif - -#ifndef _WIN32 -#include "linux_termios.h" -#endif - -#include "libserialport.h" - -struct sp_port { - char *name; -#ifdef _WIN32 - HANDLE hdl; - COMMTIMEOUTS timeouts; - OVERLAPPED write_ovl; - OVERLAPPED read_ovl; - BYTE pending_byte; - BOOL writing; -#else - int fd; -#endif -}; - -struct sp_port_config { - int baudrate; - int bits; - enum sp_parity parity; - int stopbits; - enum sp_rts rts; - enum sp_cts cts; - enum sp_dtr dtr; - enum sp_dsr dsr; - enum sp_xonxoff xon_xoff; -}; - -struct port_data { -#ifdef _WIN32 - DCB dcb; -#else - struct termios term; - int controlbits; - int termiox_supported; - int flow; -#endif -}; +#include "libserialport_internal.h" -/* Standard baud rates. */ -#ifdef _WIN32 -#define BAUD_TYPE DWORD -#define BAUD(n) {CBR_##n, n} -#else -#define BAUD_TYPE speed_t -#define BAUD(n) {B##n, n} -#endif - -struct std_baudrate { - BAUD_TYPE index; - int value; -}; - -const struct std_baudrate std_baudrates[] = { +static const struct std_baudrate std_baudrates[] = { #ifdef _WIN32 /* * The baudrates 50/75/134/150/200/1800/230400/460800 do not seem to @@ -146,51 +43,23 @@ const struct std_baudrate std_baudrates[] = { #endif }; -void (*sp_debug_handler)(const char *format, ...) = sp_default_debug_handler; - -#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) #define NUM_STD_BAUDRATES ARRAY_SIZE(std_baudrates) -/* Debug output macros. */ -#define DEBUG(fmt, ...) do { if (sp_debug_handler) sp_debug_handler(fmt ".\n", ##__VA_ARGS__); } while (0) -#define DEBUG_ERROR(err, msg) DEBUG("%s returning " #err ": " msg, __func__) -#define DEBUG_FAIL(msg) do { \ - char *errmsg = sp_last_error_message(); \ - DEBUG("%s returning SP_ERR_FAIL: " msg ": %s", __func__, errmsg); \ - sp_free_error_message(errmsg); \ -} while (0); -#define RETURN() do { DEBUG("%s returning", __func__); return; } while(0) -#define RETURN_CODE(x) do { DEBUG("%s returning " #x, __func__); return x; } while (0) -#define RETURN_CODEVAL(x) do { \ - switch (x) { \ - case SP_OK: RETURN_CODE(SP_OK); \ - case SP_ERR_ARG: RETURN_CODE(SP_ERR_ARG); \ - case SP_ERR_FAIL: RETURN_CODE(SP_ERR_FAIL); \ - case SP_ERR_MEM: RETURN_CODE(SP_ERR_MEM); \ - case SP_ERR_SUPP: RETURN_CODE(SP_ERR_SUPP); \ - } \ -} while (0) -#define RETURN_OK() RETURN_CODE(SP_OK); -#define RETURN_ERROR(err, msg) do { DEBUG_ERROR(err, msg); return err; } while (0) -#define RETURN_FAIL(msg) do { DEBUG_FAIL(msg); return SP_ERR_FAIL; } while (0) -#define RETURN_VALUE(fmt, x) do { DEBUG("%s returning " fmt, __func__, x); return x; } while (0) -#define SET_ERROR(val, err, msg) do { DEBUG_ERROR(err, msg); val = err; } while (0) -#define SET_FAIL(val, msg) do { DEBUG_FAIL(msg); val = SP_ERR_FAIL; } while (0) -#define TRACE(fmt, ...) DEBUG("%s(" fmt ") called", __func__, ##__VA_ARGS__) - -#define TRY(x) do { int ret = x; if (ret != SP_OK) RETURN_CODEVAL(ret); } while (0) - -/* Helper functions. */ -static struct sp_port **list_append(struct sp_port **list, const char *portname); +void (*sp_debug_handler)(const char *format, ...) = sp_default_debug_handler; + 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); -enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr) +SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr) { struct sp_port *port; - int len; +#ifndef NO_PORT_METADATA + enum sp_return ret; +#endif + size_t len; TRACE("%s, %p", portname, port_ptr); @@ -202,7 +71,21 @@ enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_p if (!portname) RETURN_ERROR(SP_ERR_ARG, "Null port name"); - DEBUG("Building structure for port %s", portname); + 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"); @@ -217,32 +100,154 @@ enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_p memcpy(port->name, portname, len); #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 + port->description = NULL; + port->transport = SP_TRANSPORT_NATIVE; + port->usb_bus = -1; + port->usb_address = -1; + port->usb_vid = -1; + port->usb_pid = -1; + port->usb_manufacturer = NULL; + port->usb_product = NULL; + port->usb_serial = NULL; + port->bluetooth_address = NULL; + +#ifndef NO_PORT_METADATA + if ((ret = get_port_details(port)) != SP_OK) { + sp_free_port(port); + return ret; + } +#endif + *port_ptr = port; RETURN_OK(); } -char *sp_get_port_name(const struct sp_port *port) +SP_API char *sp_get_port_name(const struct sp_port *port) { TRACE("%p", port); if (!port) return NULL; - RETURN_VALUE("%s", port->name); + RETURN_STRING(port->name); +} + +SP_API char *sp_get_port_description(const struct sp_port *port) +{ + TRACE("%p", port); + + if (!port || !port->description) + return NULL; + + RETURN_STRING(port->description); +} + +SP_API enum sp_transport sp_get_port_transport(const struct sp_port *port) +{ + TRACE("%p", port); + + RETURN_INT(port ? port->transport : SP_TRANSPORT_NATIVE); +} + +SP_API enum sp_return sp_get_port_usb_bus_address(const struct sp_port *port, + int *usb_bus,int *usb_address) +{ + TRACE("%p", port); + + if (!port) + RETURN_ERROR(SP_ERR_ARG, "Null port"); + if (port->transport != SP_TRANSPORT_USB) + RETURN_ERROR(SP_ERR_ARG, "Port does not use USB transport"); + if (port->usb_bus < 0 || port->usb_address < 0) + RETURN_ERROR(SP_ERR_SUPP, "Bus and address values are not available"); + + if (usb_bus) + *usb_bus = port->usb_bus; + if (usb_address) + *usb_address = port->usb_address; + + RETURN_OK(); } -enum sp_return sp_get_port_handle(const struct sp_port *port, void *result_ptr) +SP_API enum sp_return sp_get_port_usb_vid_pid(const struct sp_port *port, + int *usb_vid, int *usb_pid) +{ + TRACE("%p", port); + + if (!port) + RETURN_ERROR(SP_ERR_ARG, "Null port"); + if (port->transport != SP_TRANSPORT_USB) + RETURN_ERROR(SP_ERR_ARG, "Port does not use USB transport"); + if (port->usb_vid < 0 || port->usb_pid < 0) + RETURN_ERROR(SP_ERR_SUPP, "VID:PID values are not available"); + + if (usb_vid) + *usb_vid = port->usb_vid; + if (usb_pid) + *usb_pid = port->usb_pid; + + RETURN_OK(); +} + +SP_API char *sp_get_port_usb_manufacturer(const struct sp_port *port) +{ + TRACE("%p", port); + + if (!port || port->transport != SP_TRANSPORT_USB || !port->usb_manufacturer) + return NULL; + + RETURN_STRING(port->usb_manufacturer); +} + +SP_API char *sp_get_port_usb_product(const struct sp_port *port) +{ + TRACE("%p", port); + + if (!port || port->transport != SP_TRANSPORT_USB || !port->usb_product) + return NULL; + + RETURN_STRING(port->usb_product); +} + +SP_API char *sp_get_port_usb_serial(const struct sp_port *port) +{ + TRACE("%p", port); + + if (!port || port->transport != SP_TRANSPORT_USB || !port->usb_serial) + return NULL; + + RETURN_STRING(port->usb_serial); +} + +SP_API char *sp_get_port_bluetooth_address(const struct sp_port *port) +{ + TRACE("%p", port); + + if (!port || port->transport != SP_TRANSPORT_BLUETOOTH + || !port->bluetooth_address) + return NULL; + + RETURN_STRING(port->bluetooth_address); +} + +SP_API enum sp_return sp_get_port_handle(const struct sp_port *port, + void *result_ptr) { TRACE("%p, %p", port, result_ptr); if (!port) RETURN_ERROR(SP_ERR_ARG, "Null port"); + if (!result_ptr) + RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); #ifdef _WIN32 HANDLE *handle_ptr = result_ptr; @@ -255,7 +260,8 @@ enum sp_return sp_get_port_handle(const struct sp_port *port, void *result_ptr) RETURN_OK(); } -enum sp_return sp_copy_port(const struct sp_port *port, struct sp_port **copy_ptr) +SP_API enum sp_return sp_copy_port(const struct sp_port *port, + struct sp_port **copy_ptr) { TRACE("%p, %p", port, copy_ptr); @@ -272,10 +278,10 @@ enum sp_return sp_copy_port(const struct sp_port *port, struct sp_port **copy_pt DEBUG("Copying port structure"); - RETURN_VALUE("%p", sp_get_port_by_name(port->name, copy_ptr)); + RETURN_INT(sp_get_port_by_name(port->name, copy_ptr)); } -void sp_free_port(struct sp_port *port) +SP_API void sp_free_port(struct sp_port *port) { TRACE("%p", port); @@ -288,18 +294,36 @@ void sp_free_port(struct sp_port *port) if (port->name) free(port->name); + if (port->description) + free(port->description); + if (port->usb_manufacturer) + free(port->usb_manufacturer); + if (port->usb_product) + free(port->usb_product); + if (port->usb_serial) + free(port->usb_serial); + if (port->bluetooth_address) + free(port->bluetooth_address); +#ifdef _WIN32 + if (port->usb_path) + free(port->usb_path); + if (port->write_buf) + free(port->write_buf); +#endif free(port); RETURN(); } -static struct sp_port **list_append(struct sp_port **list, const char *portname) +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++); + for (count = 0; list[count]; count++) + ; if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2)))) goto fail; list = tmp; @@ -313,240 +337,44 @@ fail: return NULL; } -enum sp_return sp_list_ports(struct sp_port ***list_ptr) +SP_API enum sp_return sp_list_ports(struct sp_port ***list_ptr) { +#ifndef NO_ENUMERATION struct sp_port **list; - int ret = SP_ERR_SUPP; + int ret; +#endif TRACE("%p", list_ptr); if (!list_ptr) RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); + *list_ptr = NULL; + +#ifdef NO_ENUMERATION + RETURN_ERROR(SP_ERR_SUPP, "Enumeration not supported on this platform"); +#else DEBUG("Enumerating ports"); - if (!(list = malloc(sizeof(struct sp_port **)))) + if (!(list = malloc(sizeof(struct sp_port *)))) RETURN_ERROR(SP_ERR_MEM, "Port list malloc failed"); list[0] = NULL; -#ifdef _WIN32 - HKEY key; - TCHAR *value, *data; - DWORD max_value_len, max_data_size, max_data_len; - DWORD value_len, data_size, data_len; - DWORD type, index = 0; - char *name; - int name_len; - - ret = SP_OK; - - DEBUG("Opening registry key"); - if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("HARDWARE\\DEVICEMAP\\SERIALCOMM"), - 0, KEY_QUERY_VALUE, &key) != ERROR_SUCCESS) { - SET_FAIL(ret, "RegOpenKeyEx() failed"); - goto out_done; - } - DEBUG("Querying registry key value and data sizes"); - if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL, NULL, NULL, NULL, - &max_value_len, &max_data_size, NULL, NULL) != ERROR_SUCCESS) { - SET_FAIL(ret, "RegQueryInfoKey() failed"); - goto out_close; - } - max_data_len = max_data_size / sizeof(TCHAR); - if (!(value = malloc((max_value_len + 1) * sizeof(TCHAR)))) { - SET_ERROR(ret, SP_ERR_MEM, "registry value malloc failed"); - goto out_close; - } - if (!(data = malloc((max_data_len + 1) * sizeof(TCHAR)))) { - SET_ERROR(ret, SP_ERR_MEM, "registry data malloc failed"); - goto out_free_value; - } - DEBUG("Iterating over values"); - while ( - value_len = max_value_len + 1, - data_size = max_data_size, - RegEnumValue(key, index, value, &value_len, - NULL, &type, (LPBYTE)data, &data_size) == ERROR_SUCCESS) - { - data_len = data_size / sizeof(TCHAR); - data[data_len] = '\0'; -#ifdef UNICODE - name_len = WideCharToMultiByte(CP_ACP, 0, data, -1, NULL, 0, NULL, NULL) -#else - name_len = data_len + 1; -#endif - if (!(name = malloc(name_len))) { - SET_ERROR(ret, SP_ERR_MEM, "registry port name malloc failed"); - goto out; - } -#ifdef UNICODE - WideCharToMultiByte(CP_ACP, 0, data, -1, name, name_len, NULL, NULL); -#else - strcpy(name, data); -#endif - if (type == REG_SZ) { - DEBUG("Found port %s", name); - if (!(list = list_append(list, name))) { - SET_ERROR(ret, SP_ERR_MEM, "list append failed"); - goto out; - } - } - index++; - } -out: - free(data); -out_free_value: - free(value); -out_close: - RegCloseKey(key); -out_done: -#endif -#ifdef __APPLE__ - mach_port_t master; - CFMutableDictionaryRef classes; - io_iterator_t iter; - char *path; - io_object_t port; - CFTypeRef cf_path; - Boolean result; - - ret = SP_OK; - - DEBUG("Getting IOKit master port"); - if (IOMasterPort(MACH_PORT_NULL, &master) != KERN_SUCCESS) { - SET_FAIL(ret, "IOMasterPort() failed"); - goto out_done; - } - - DEBUG("Creating matching dictionary"); - if (!(classes = IOServiceMatching(kIOSerialBSDServiceValue))) { - SET_FAIL(ret, "IOServiceMatching() failed"); - goto out_done; - } - - CFDictionarySetValue(classes, - CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes)); - - DEBUG("Getting matching services"); - if (IOServiceGetMatchingServices(master, classes, &iter) != KERN_SUCCESS) { - SET_FAIL(ret, "IOServiceGetMatchingServices() failed"); - goto out_done; - } - - if (!(path = malloc(PATH_MAX))) { - SET_ERROR(ret, SP_ERR_MEM, "device path malloc failed"); - goto out_release; - } - - DEBUG("Iterating over results"); - while ((port = IOIteratorNext(iter))) { - cf_path = IORegistryEntryCreateCFProperty(port, - CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0); - if (cf_path) { - result = CFStringGetCString(cf_path, - path, PATH_MAX, kCFStringEncodingASCII); - CFRelease(cf_path); - if (result) { - DEBUG("Found port %s", path); - if (!(list = list_append(list, path))) { - SET_ERROR(ret, SP_ERR_MEM, "list append failed"); - IOObjectRelease(port); - goto out; - } - } - } - IOObjectRelease(port); - } -out: - free(path); -out_release: - IOObjectRelease(iter); -out_done: -#endif -#if defined(__linux__) && defined(HAVE_LIBUDEV) - struct udev *ud; - struct udev_enumerate *ud_enumerate; - struct udev_list_entry *ud_list; - struct udev_list_entry *ud_entry; - const char *path; - struct udev_device *ud_dev, *ud_parent; - const char *name; - const char *driver; - int fd, ioctl_result; - struct serial_struct serial_info; - - ret = SP_OK; - - DEBUG("Enumerating tty devices"); - ud = udev_new(); - ud_enumerate = udev_enumerate_new(ud); - udev_enumerate_add_match_subsystem(ud_enumerate, "tty"); - udev_enumerate_scan_devices(ud_enumerate); - ud_list = udev_enumerate_get_list_entry(ud_enumerate); - DEBUG("Iterating over results"); - udev_list_entry_foreach(ud_entry, ud_list) { - path = udev_list_entry_get_name(ud_entry); - DEBUG("Found device %s", path); - ud_dev = udev_device_new_from_syspath(ud, path); - /* If there is no parent device, this is a virtual tty. */ - ud_parent = udev_device_get_parent(ud_dev); - if (ud_parent == NULL) { - DEBUG("No parent device, assuming virtual tty"); - udev_device_unref(ud_dev); - continue; - } - name = udev_device_get_devnode(ud_dev); - /* The serial8250 driver has a hardcoded number of ports. - * The only way to tell which actually exist on a given system - * is to try to open them and make an ioctl call. */ - driver = udev_device_get_driver(ud_parent); - if (driver && !strcmp(driver, "serial8250")) { - DEBUG("serial8250 device, attempting to open"); - if ((fd = open(name, O_RDWR | O_NONBLOCK | O_NOCTTY)) < 0) { - DEBUG("open failed, skipping"); - goto skip; - } - ioctl_result = ioctl(fd, TIOCGSERIAL, &serial_info); - close(fd); - if (ioctl_result != 0) { - DEBUG("ioctl failed, skipping"); - goto skip; - } - if (serial_info.type == PORT_UNKNOWN) { - DEBUG("port type is unknown, skipping"); - goto skip; - } - } - DEBUG("Found port %s", name); - list = list_append(list, name); -skip: - udev_device_unref(ud_dev); - if (!list) { - SET_ERROR(ret, SP_ERR_MEM, "list append failed"); - goto out; - } - } -out: - udev_enumerate_unref(ud_enumerate); - udev_unref(ud); -#endif + ret = list_ports(&list); - switch (ret) { - case SP_OK: + if (ret == SP_OK) { *list_ptr = list; - RETURN_OK(); - case SP_ERR_SUPP: - DEBUG_ERROR(SP_ERR_SUPP, "Enumeration not supported on this platform."); - default: - if (list) - sp_free_port_list(list); + } else { + sp_free_port_list(list); *list_ptr = NULL; - return ret; } + + RETURN_CODEVAL(ret); +#endif } -void sp_free_port_list(struct sp_port **list) +SP_API void sp_free_port_list(struct sp_port **list) { unsigned int i; @@ -567,20 +395,20 @@ void sp_free_port_list(struct sp_port **list) } #define CHECK_PORT() do { \ - if (port == NULL) \ + if (!port) \ RETURN_ERROR(SP_ERR_ARG, "Null port"); \ - if (port->name == NULL) \ + if (!port->name) \ RETURN_ERROR(SP_ERR_ARG, "Null port name"); \ } while (0) #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 { \ @@ -588,7 +416,44 @@ void sp_free_port_list(struct sp_port **list) CHECK_PORT_HANDLE(); \ } while (0) -enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) +#ifdef WIN32 +/** To be called after port receive buffer is emptied. */ +static enum sp_return restart_wait(struct sp_port *port) +{ + DWORD wait_result; + + if (port->wait_running) { + /* Check status of running wait operation. */ + if (GetOverlappedResult(port->hdl, &port->wait_ovl, + &wait_result, FALSE)) { + DEBUG("Previous wait completed"); + port->wait_running = FALSE; + } else if (GetLastError() == ERROR_IO_INCOMPLETE) { + DEBUG("Previous wait still running"); + RETURN_OK(); + } else { + RETURN_FAIL("GetOverlappedResult() failed"); + } + } + + if (!port->wait_running) { + /* Start new wait operation. */ + if (WaitCommEvent(port->hdl, &port->events, + &port->wait_ovl)) { + DEBUG("New wait returned, events already pending"); + } else if (GetLastError() == ERROR_IO_PENDING) { + DEBUG("New wait running in background"); + port->wait_running = TRUE; + } else { + RETURN_FAIL("WaitCommEvent() failed"); + } + } + + RETURN_OK(); +} +#endif + +SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) { struct port_data data; struct sp_port_config config; @@ -598,17 +463,18 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) CHECK_PORT(); - if (flags > (SP_MODE_READ | SP_MODE_WRITE)) + if (flags > SP_MODE_READ_WRITE) RETURN_ERROR(SP_ERR_ARG, "Invalid flags"); - DEBUG("Opening port %s", port->name); + DEBUG_FMT("Opening port %s", port->name); #ifdef _WIN32 - DWORD desired_access = 0, flags_and_attributes = 0; + DWORD desired_access = 0, flags_and_attributes = 0, errors; char *escaped_port_name; + COMSTAT status; /* Prefix port name with '\\.\' to work with ports above COM9. */ - if (!(escaped_port_name = malloc(strlen(port->name + 5)))) + if (!(escaped_port_name = malloc(strlen(port->name) + 5))) RETURN_ERROR(SP_ERR_MEM, "Escaped port name malloc failed"); sprintf(escaped_port_name, "\\\\.\\%s", port->name); @@ -619,13 +485,13 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) if (flags & SP_MODE_WRITE) desired_access |= GENERIC_WRITE; - port->hdl = CreateFile(escaped_port_name, desired_access, 0, 0, + port->hdl = CreateFileA(escaped_port_name, desired_access, 0, 0, OPEN_EXISTING, flags_and_attributes, 0); free(escaped_port_name); if (port->hdl == INVALID_HANDLE_VALUE) - RETURN_FAIL("port CreateFile() failed"); + RETURN_FAIL("Port CreateFile() failed"); /* All timeouts initially disabled. */ port->timeouts.ReadIntervalTimeout = 0; @@ -640,26 +506,40 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) } /* Prepare OVERLAPPED structures. */ - memset(&port->read_ovl, 0, sizeof(port->read_ovl)); - memset(&port->write_ovl, 0, sizeof(port->write_ovl)); - port->read_ovl.hEvent = INVALID_HANDLE_VALUE; - port->write_ovl.hEvent = INVALID_HANDLE_VALUE; - if ((port->read_ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL)) == INVALID_HANDLE_VALUE) { - sp_close(port); - RETURN_FAIL("read event CreateEvent() failed"); - } - if ((port->write_ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL)) == INVALID_HANDLE_VALUE) { +#define INIT_OVERLAPPED(ovl) do { \ + memset(&port->ovl, 0, sizeof(port->ovl)); \ + port->ovl.hEvent = INVALID_HANDLE_VALUE; \ + if ((port->ovl.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)) \ + == INVALID_HANDLE_VALUE) { \ + sp_close(port); \ + RETURN_FAIL(#ovl "CreateEvent() failed"); \ + } \ +} while (0) + + INIT_OVERLAPPED(read_ovl); + INIT_OVERLAPPED(write_ovl); + INIT_OVERLAPPED(wait_ovl); + + /* Set event mask for RX and error events. */ + if (SetCommMask(port->hdl, EV_RXCHAR | EV_ERR) == 0) { sp_close(port); - RETURN_FAIL("write event CreateEvent() failed"); + RETURN_FAIL("SetCommMask() failed"); } port->writing = FALSE; + port->wait_running = FALSE; + + ret = restart_wait(port); + if (ret < 0) { + sp_close(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 | SP_MODE_WRITE)) + if ((flags & SP_MODE_READ_WRITE) == SP_MODE_READ_WRITE) flags_local |= O_RDWR; else if (flags & SP_MODE_READ) flags_local |= O_RDONLY; @@ -668,6 +548,39 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) if ((port->fd = open(port->name, flags_local)) < 0) RETURN_FAIL("open() failed"); + + /* + * On POSIX in the default case the file descriptor of a serial port + * is not opened exclusively. Therefore the settings of a port are + * overwritten if the serial port is opened a second time. Windows + * opens all serial ports exclusively. + * So the idea is to open the serial ports alike in the exclusive mode. + * + * ioctl(*, TIOCEXCL) defines the file descriptor as exclusive. So all + * further open calls on the serial port will fail. + * + * There is a race condition if two processes open the same serial + * port. None of the processes will notice the exclusive ownership of + * the other process because ioctl() doesn't return an error code if + * the file descriptor is already marked as exclusive. + * This can be solved with flock(). It returns an error if the file + * descriptor is already locked by another process. + */ +#ifdef HAVE_FLOCK + if (flock(port->fd, LOCK_EX | LOCK_NB) < 0) + RETURN_FAIL("flock() failed"); +#endif + +#ifdef TIOCEXCL + /* + * Before Linux 3.8 ioctl(*, TIOCEXCL) was not implemented and could + * lead to EINVAL or ENOTTY. + * These errors aren't fatal and can be ignored. + */ + if (ioctl(port->fd, TIOCEXCL) < 0 && errno != EINVAL && errno != ENOTTY) + RETURN_FAIL("ioctl() failed"); +#endif + #endif ret = get_config(port, &data, &config); @@ -677,13 +590,22 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) RETURN_CODEVAL(ret); } + /* + * Assume a default baudrate if the OS does not provide one. + * Cannot assign -1 here since Windows holds the baudrate in + * the DCB and does not configure the rate individually. + */ + if (config.baudrate == 0) { + config.baudrate = 9600; + } + /* Set sane port settings. */ #ifdef _WIN32 data.dcb.fBinary = TRUE; data.dcb.fDsrSensitivity = FALSE; data.dcb.fErrorChar = FALSE; data.dcb.fNull = FALSE; - data.dcb.fAbortOnError = TRUE; + data.dcb.fAbortOnError = FALSE; #else /* Turn off all fancy termios tricks, give us a raw channel. */ data.term.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IMAXBEL); @@ -720,7 +642,13 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) data.term.c_cc[VTIME] = 0; /* Ignore modem status lines; enable receiver; leave control lines alone on close. */ - data.term.c_cflag |= (CLOCAL | CREAD | HUPCL); + data.term.c_cflag |= (CLOCAL | CREAD); + data.term.c_cflag &= ~(HUPCL); +#endif + +#ifdef _WIN32 + if (ClearCommError(port->hdl, &errors, &status) == 0) + RETURN_FAIL("ClearCommError() failed"); #endif ret = set_config(port, &data, &config); @@ -733,25 +661,34 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) RETURN_OK(); } -enum sp_return sp_close(struct sp_port *port) +SP_API enum sp_return sp_close(struct sp_port *port) { TRACE("%p", port); CHECK_OPEN_PORT(); - DEBUG("Closing port %s", port->name); + DEBUG_FMT("Closing port %s", port->name); #ifdef _WIN32 /* Returns non-zero upon success, 0 upon failure. */ if (CloseHandle(port->hdl) == 0) - RETURN_FAIL("port CloseHandle() failed"); + RETURN_FAIL("Port CloseHandle() failed"); port->hdl = INVALID_HANDLE_VALUE; - /* Close event handle created for overlapped reads. */ - if (port->read_ovl.hEvent != INVALID_HANDLE_VALUE && CloseHandle(port->read_ovl.hEvent) == 0) - RETURN_FAIL("read event CloseHandle() failed"); - /* Close event handle created for overlapped writes. */ - if (port->write_ovl.hEvent != INVALID_HANDLE_VALUE && CloseHandle(port->write_ovl.hEvent) == 0) - RETURN_FAIL("write event CloseHandle() failed"); + + /* Close event handles for overlapped structures. */ +#define CLOSE_OVERLAPPED(ovl) do { \ + if (port->ovl.hEvent != INVALID_HANDLE_VALUE && \ + CloseHandle(port->ovl.hEvent) == 0) \ + RETURN_FAIL(# ovl "event CloseHandle() failed"); \ +} while (0) + CLOSE_OVERLAPPED(read_ovl); + 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) @@ -762,7 +699,7 @@ enum sp_return sp_close(struct sp_port *port) RETURN_OK(); } -enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers) +SP_API enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers) { TRACE("%p, 0x%x", port, buffers); @@ -773,7 +710,8 @@ enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers) const char *buffer_names[] = {"no", "input", "output", "both"}; - DEBUG("Flushing %s buffers on port %s", buffer_names[buffers], port->name); + DEBUG_FMT("Flushing %s buffers on port %s", + buffer_names[buffers], port->name); #ifdef _WIN32 DWORD flags = 0; @@ -785,13 +723,16 @@ enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers) /* Returns non-zero upon success, 0 upon failure. */ if (PurgeComm(port->hdl, flags) == 0) RETURN_FAIL("PurgeComm() failed"); + + if (buffers & SP_BUF_INPUT) + TRY(restart_wait(port)); #else int flags = 0; - if (buffers & SP_BUF_BOTH) + if (buffers == SP_BUF_BOTH) flags = TCIOFLUSH; - else if (buffers & SP_BUF_INPUT) + else if (buffers == SP_BUF_INPUT) flags = TCIFLUSH; - else if (buffers & SP_BUF_OUTPUT) + else if (buffers == SP_BUF_OUTPUT) flags = TCOFLUSH; /* Returns 0 upon success, -1 upon failure. */ @@ -801,13 +742,13 @@ enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers) RETURN_OK(); } -enum sp_return sp_drain(struct sp_port *port) +SP_API enum sp_return sp_drain(struct sp_port *port) { TRACE("%p", port); CHECK_OPEN_PORT(); - DEBUG("Draining port %s", port->name); + DEBUG_FMT("Draining port %s", port->name); #ifdef _WIN32 /* Returns non-zero upon success, 0 upon failure. */ @@ -817,7 +758,9 @@ 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 @@ -837,88 +780,335 @@ enum sp_return sp_drain(struct sp_port *port) #endif } -enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, size_t count, unsigned int timeout) +#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) { - TRACE("%p, %p, %d, %d", port, buf, count, timeout); + TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms); CHECK_OPEN_PORT(); if (!buf) RETURN_ERROR(SP_ERR_ARG, "Null buffer"); - if (timeout) - DEBUG("Writing %d bytes to port %s, timeout %d ms", count, port->name, timeout); + if (timeout_ms) + DEBUG_FMT("Writing %d bytes to port %s, timeout %d ms", + count, port->name, timeout_ms); else - DEBUG("Writing %d bytes to port %s, no timeout", count, port->name); + DEBUG_FMT("Writing %d bytes to port %s, no timeout", + count, port->name); if (count == 0) - RETURN_VALUE("0", 0); + RETURN_INT(0); #ifdef _WIN32 - DWORD bytes_written = 0; - BOOL result; + 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; - /* Wait for previous non-blocking write to complete, if any. */ + timeout_start(&timeout, timeout_ms); + + TRY(await_write_completion(port)); + + while (total_bytes_written < count) { + + 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. */ + 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"); + } + + 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; + struct timeout timeout; + fd_set fds; + ssize_t result; + + 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) { + + 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"); + continue; + } else { + RETURN_FAIL("select() failed"); + } + } else if (result == 0) { + /* Timeout has expired. */ + break; + } + + /* Do write. */ + result = write(port->fd, ptr, count - bytes_written); + + 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("write() failed"); + } + + bytes_written += result; + ptr += result; + } + + if (bytes_written < count) + DEBUG("Write timed out"); + + RETURN_INT(bytes_written); +#endif +} + +SP_API enum sp_return sp_nonblocking_write(struct sp_port *port, + const void *buf, size_t count) +{ + TRACE("%p, %p, %d", port, buf, count); + + CHECK_OPEN_PORT(); + + if (!buf) + RETURN_ERROR(SP_ERR_ARG, "Null buffer"); + + DEBUG_FMT("Writing up to %d bytes to port %s", count, port->name); + + if (count == 0) + RETURN_INT(0); + +#ifdef _WIN32 + size_t buf_bytes; + + /* Check whether previous write is complete. */ 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"); + if (HasOverlappedIoCompleted(&port->write_ovl)) { + DEBUG("Previous write completed"); + port->writing = 0; + } else { + DEBUG("Previous write not complete"); + /* Can't take a new write until the previous one finishes. */ + RETURN_INT(0); + } } /* Set timeout. */ - port->timeouts.WriteTotalTimeoutConstant = timeout; - if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) - RETURN_FAIL("SetCommTimeouts() failed"); + if (port->timeouts.WriteTotalTimeoutConstant != 0) { + port->timeouts.WriteTotalTimeoutConstant = 0; + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) + RETURN_FAIL("SetCommTimeouts() 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, (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"); + else + DEBUG("Asynchronous write running"); + } else { + /* Actual failure of some kind. */ + RETURN_FAIL("WriteFile() failed"); + } + } + + DEBUG("All bytes written immediately"); + + RETURN_INT((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) { + if (errno == EAGAIN) + // Buffer is full, no bytes written. + RETURN_INT(0); + else + RETURN_FAIL("write() failed"); + } else { + RETURN_INT(written); + } +#endif +} + +#ifdef _WIN32 +/* Restart wait operation if buffer was emptied. */ +static enum sp_return restart_wait_if_needed(struct sp_port *port, unsigned int bytes_read) +{ + DWORD errors; + COMSTAT comstat; + + if (bytes_read == 0) + RETURN_OK(); + + if (ClearCommError(port->hdl, &errors, &comstat) == 0) + RETURN_FAIL("ClearCommError() failed"); + + if (comstat.cbInQue == 0) + TRY(restart_wait(port)); + + RETURN_OK(); +} +#endif + +SP_API enum sp_return sp_blocking_read(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 (timeout_ms) + DEBUG_FMT("Reading %d bytes from port %s, timeout %d ms", + count, port->name, timeout_ms); + else + DEBUG_FMT("Reading %d bytes from port %s, no timeout", + count, port->name); + + if (count == 0) + RETURN_INT(0); + +#ifdef _WIN32 + DWORD bytes_read; + + /* 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"); + } - /* Start write. */ - if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl) == 0) { - if (GetLastError() == ERROR_IO_PENDING) { - DEBUG("Waiting for write to complete"); - GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); - DEBUG("Write completed, %d/%d bytes written", bytes_written, count); - RETURN_VALUE("%d", bytes_written); - } else { - RETURN_FAIL("WriteFile() failed"); - } + /* Start read. */ + if (ReadFile(port->hdl, buf, (DWORD) count, NULL, &port->read_ovl)) { + DEBUG("Read completed immediately"); + 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) + RETURN_FAIL("GetOverlappedResult() failed"); + DEBUG_FMT("Read completed, %d/%d bytes read", bytes_read, count); } else { - DEBUG("Write completed immediately"); - RETURN_VALUE("%d", count); + RETURN_FAIL("ReadFile() failed"); } + + TRY(restart_wait_if_needed(port, bytes_read)); + + RETURN_INT((int) bytes_read); + #else - size_t bytes_written = 0; + size_t bytes_read = 0; unsigned char *ptr = (unsigned char *) buf; - struct timeval start, delta, now, end = {0, 0}; + struct timeout timeout; fd_set fds; - int result; + ssize_t result; - if (timeout) { - /* Get time at start of operation. */ - gettimeofday(&start, NULL); - /* Define duration of timeout. */ - delta.tv_sec = timeout / 1000; - delta.tv_usec = (timeout % 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) { + + if (timeout_check(&timeout)) + /* Timeout has expired. */ + break; + + result = select(port->fd + 1, &fds, NULL, NULL, timeout_timeval(&timeout)); + + timeout_update(&timeout); - /* Loop until we have written the requested number of bytes. */ - while (bytes_written < count) - { - /* Wait until space is available. */ - FD_ZERO(&fds); - FD_SET(port->fd, &fds); - if (timeout) { - gettimeofday(&now, NULL); - if (timercmp(&now, &end, >)) { - DEBUG("write timed out"); - RETURN_VALUE("%d", bytes_written); - } - timersub(&end, &now, &delta); - } - result = select(port->fd + 1, NULL, &fds, NULL, timeout ? &delta : NULL); if (result < 0) { if (errno == EINTR) { DEBUG("select() call was interrupted, repeating"); @@ -927,173 +1117,121 @@ enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, size_t c RETURN_FAIL("select() failed"); } } else if (result == 0) { - DEBUG("write timed out"); - RETURN_VALUE("%d", bytes_written); + /* Timeout has expired. */ + break; } - /* Do write. */ - result = write(port->fd, ptr, count - bytes_written); + /* Do read. */ + result = read(port->fd, ptr, count - bytes_read); if (result < 0) { if (errno == EAGAIN) - /* This shouldn't happen because we did a select() first, but handle anyway. */ + /* + * This shouldn't happen because we did a + * select() first, but handle anyway. + */ continue; else /* This is an actual failure. */ - RETURN_FAIL("write() failed"); + RETURN_FAIL("read() failed"); } - bytes_written += result; + bytes_read += result; ptr += result; } - RETURN_VALUE("%d", bytes_written); + if (bytes_read < count) + DEBUG("Read timed out"); + + RETURN_INT(bytes_read); #endif } -enum sp_return sp_nonblocking_write(struct sp_port *port, const void *buf, size_t count) +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", port, buf, count); + TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms); CHECK_OPEN_PORT(); if (!buf) RETURN_ERROR(SP_ERR_ARG, "Null buffer"); - DEBUG("Writing up to %d bytes to port %s", count, port->name); - if (count == 0) - RETURN_VALUE("0", 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 written = 0; - BYTE *ptr = (BYTE *) buf; + DWORD bytes_read = 0; - /* Check whether previous write is complete. */ - if (port->writing) { - if (HasOverlappedIoCompleted(&port->write_ovl)) { - DEBUG("Previous write completed"); - port->writing = 0; - } else { - DEBUG("Previous write not complete"); - /* Can't take a new write until the previous one finishes. */ - RETURN_VALUE("0", 0); - } - } + /* If timeout_ms == 0, set maximum timeout. */ + DWORD timeout_val = (timeout_ms == 0 ? MAXDWORD - 1 : timeout_ms); /* Set timeout. */ - port->timeouts.WriteTotalTimeoutConstant = 0; - if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) - 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) { - DEBUG("Asynchronous write started"); - port->writing = 1; - RETURN_VALUE("%d", ++written); + 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, (DWORD) 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 { - /* Actual failure of some kind. */ - RETURN_FAIL("WriteFile() failed"); + DEBUG("Restarting read"); } } else { - DEBUG("Single byte written immediately."); - written++; + RETURN_FAIL("ReadFile() failed"); } } - DEBUG("All bytes written immediately."); - - RETURN_VALUE("%d", written); -#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 - RETURN_VALUE("%d", written); -#endif -} - -enum sp_return sp_blocking_read(struct sp_port *port, void *buf, size_t count, unsigned int timeout) -{ - TRACE("%p, %p, %d, %d", port, buf, count, timeout); + TRY(restart_wait_if_needed(port, bytes_read)); - CHECK_OPEN_PORT(); + RETURN_INT(bytes_read); - if (!buf) - RETURN_ERROR(SP_ERR_ARG, "Null buffer"); +#else + size_t bytes_read = 0; + struct timeout timeout; + fd_set fds; + ssize_t result; - if (timeout) - DEBUG("Reading %d bytes from port %s, timeout %d ms", count, port->name, timeout); - else - DEBUG("Reading %d bytes from port %s, no timeout", count, port->name); + timeout_start(&timeout, timeout_ms); - if (count == 0) - RETURN_VALUE("0", 0); + FD_ZERO(&fds); + FD_SET(port->fd, &fds); -#ifdef _WIN32 - DWORD bytes_read = 0; + /* Loop until we have at least one byte, or timeout is reached. */ + while (bytes_read == 0) { - /* Set timeout. */ - port->timeouts.ReadIntervalTimeout = 0; - port->timeouts.ReadTotalTimeoutConstant = timeout; - if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) - RETURN_FAIL("SetCommTimeouts() failed"); + if (timeout_check(&timeout)) + /* Timeout has expired. */ + break; - /* Start read. */ - if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) { - if (GetLastError() == ERROR_IO_PENDING) { - DEBUG("Waiting for read to complete"); - GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE); - DEBUG("Read completed, %d/%d bytes read", bytes_read, count); - RETURN_VALUE("%d", bytes_read); - } else { - RETURN_FAIL("ReadFile() failed"); - } - } else { - DEBUG("Read completed immediately"); - RETURN_VALUE("%d", count); - } -#else - size_t bytes_read = 0; - unsigned char *ptr = (unsigned char *) buf; - struct timeval start, delta, now, end = {0, 0}; - fd_set fds; - int result; + result = select(port->fd + 1, &fds, NULL, NULL, timeout_timeval(&timeout)); - if (timeout) { - /* Get time at start of operation. */ - gettimeofday(&start, NULL); - /* Define duration of timeout. */ - delta.tv_sec = timeout / 1000; - delta.tv_usec = (timeout % 1000) * 1000; - /* Calculate time at which we should give up. */ - timeradd(&start, &delta, &end); - } + timeout_update(&timeout); - /* Loop until we have the requested number of bytes. */ - while (bytes_read < count) - { - /* Wait until data is available. */ - FD_ZERO(&fds); - FD_SET(port->fd, &fds); - if (timeout) { - gettimeofday(&now, NULL); - if (timercmp(&now, &end, >)) - /* Timeout has expired. */ - RETURN_VALUE("%d", bytes_read); - timersub(&end, &now, &delta); - } - result = select(port->fd + 1, &fds, NULL, NULL, timeout ? &delta : NULL); if (result < 0) { if (errno == EINTR) { DEBUG("select() call was interrupted, repeating"); @@ -1102,12 +1240,12 @@ enum sp_return sp_blocking_read(struct sp_port *port, void *buf, size_t count, u RETURN_FAIL("select() failed"); } } else if (result == 0) { - DEBUG("read timed out"); - RETURN_VALUE("%d", bytes_read); + /* Timeout has expired. */ + break; } /* Do read. */ - result = read(port->fd, ptr, count - bytes_read); + result = read(port->fd, buf, count); if (result < 0) { if (errno == EAGAIN) @@ -1118,15 +1256,18 @@ enum sp_return sp_blocking_read(struct sp_port *port, void *buf, size_t count, u RETURN_FAIL("read() failed"); } - bytes_read += result; - ptr += result; + bytes_read = result; } - RETURN_VALUE("%d", bytes_read); + if (bytes_read == 0) + DEBUG("Read timed out"); + + RETURN_INT(bytes_read); #endif } -enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, size_t count) +SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, + size_t count) { TRACE("%p, %p, %d", port, buf, count); @@ -1135,25 +1276,34 @@ enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, size_t count if (!buf) RETURN_ERROR(SP_ERR_ARG, "Null buffer"); - DEBUG("Reading up to %d bytes from port %s", count, port->name); + DEBUG_FMT("Reading up to %d bytes from port %s", count, port->name); #ifdef _WIN32 DWORD bytes_read; /* Set timeout. */ - port->timeouts.ReadIntervalTimeout = MAXDWORD; - port->timeouts.ReadTotalTimeoutConstant = 0; - if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) - RETURN_FAIL("SetCommTimeouts() failed"); + 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 (ReadFile(port->hdl, buf, (DWORD) count, NULL, &port->read_ovl) == 0) + if (GetLastError() != ERROR_IO_PENDING) + RETURN_FAIL("ReadFile() failed"); /* Get number of bytes read. */ - GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE); + if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, FALSE) == 0) + RETURN_FAIL("GetOverlappedResult() failed"); - RETURN_VALUE("%d", bytes_read); + TRY(restart_wait_if_needed(port, bytes_read)); + + RETURN_INT(bytes_read); #else ssize_t bytes_read; @@ -1166,57 +1316,241 @@ enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, size_t count /* This is an actual failure. */ RETURN_FAIL("read() failed"); } - RETURN_VALUE("%d", bytes_read); + RETURN_INT(bytes_read); #endif } -enum sp_return sp_input_waiting(struct sp_port *port) +SP_API enum sp_return sp_input_waiting(struct sp_port *port) { TRACE("%p", port); CHECK_OPEN_PORT(); - DEBUG("Checking input bytes waiting on port %s", port->name); + DEBUG_FMT("Checking input bytes waiting on port %s", port->name); #ifdef _WIN32 DWORD errors; COMSTAT comstat; if (ClearCommError(port->hdl, &errors, &comstat) == 0) - RETURN_FAIL("ClearComError() failed"); - RETURN_VALUE("%d", comstat.cbInQue); + RETURN_FAIL("ClearCommError() failed"); + RETURN_INT(comstat.cbInQue); #else int bytes_waiting; if (ioctl(port->fd, TIOCINQ, &bytes_waiting) < 0) RETURN_FAIL("TIOCINQ ioctl failed"); - RETURN_VALUE("%d", bytes_waiting); + RETURN_INT(bytes_waiting); #endif } -enum sp_return sp_output_waiting(struct sp_port *port) +SP_API enum sp_return sp_output_waiting(struct sp_port *port) { TRACE("%p", port); +#ifdef __CYGWIN__ + /* TIOCOUTQ is not defined in Cygwin headers */ + RETURN_ERROR(SP_ERR_SUPP, + "Getting output bytes waiting is not supported on Cygwin"); +#else CHECK_OPEN_PORT(); - DEBUG("Checking output bytes waiting on port %s", port->name); + DEBUG_FMT("Checking output bytes waiting on port %s", port->name); #ifdef _WIN32 DWORD errors; COMSTAT comstat; if (ClearCommError(port->hdl, &errors, &comstat) == 0) - RETURN_FAIL("ClearComError() failed"); - RETURN_VALUE("%d", comstat.cbOutQue); + RETURN_FAIL("ClearCommError() failed"); + RETURN_INT(comstat.cbOutQue); #else int bytes_waiting; if (ioctl(port->fd, TIOCOUTQ, &bytes_waiting) < 0) RETURN_FAIL("TIOCOUTQ ioctl failed"); - RETURN_VALUE("%d", bytes_waiting); + RETURN_INT(bytes_waiting); +#endif +#endif +} + +SP_API enum sp_return sp_new_event_set(struct sp_event_set **result_ptr) +{ + struct sp_event_set *result; + + TRACE("%p", result_ptr); + + if (!result_ptr) + RETURN_ERROR(SP_ERR_ARG, "Null result"); + + *result_ptr = NULL; + + if (!(result = malloc(sizeof(struct sp_event_set)))) + RETURN_ERROR(SP_ERR_MEM, "sp_event_set malloc() failed"); + + memset(result, 0, sizeof(struct sp_event_set)); + + *result_ptr = result; + + RETURN_OK(); +} + +static enum sp_return add_handle(struct sp_event_set *event_set, + event_handle handle, enum sp_event mask) +{ + void *new_handles; + enum sp_event *new_masks; + + TRACE("%p, %d, %d", event_set, handle, mask); + + if (!(new_handles = realloc(event_set->handles, + sizeof(event_handle) * (event_set->count + 1)))) + RETURN_ERROR(SP_ERR_MEM, "Handle array realloc() failed"); + + event_set->handles = new_handles; + + if (!(new_masks = realloc(event_set->masks, + sizeof(enum sp_event) * (event_set->count + 1)))) + RETURN_ERROR(SP_ERR_MEM, "Mask array realloc() failed"); + + event_set->masks = new_masks; + + ((event_handle *) event_set->handles)[event_set->count] = handle; + event_set->masks[event_set->count] = mask; + + event_set->count++; + + RETURN_OK(); +} + +SP_API enum sp_return sp_add_port_events(struct sp_event_set *event_set, + const struct sp_port *port, enum sp_event mask) +{ + TRACE("%p, %p, %d", event_set, port, mask); + + if (!event_set) + RETURN_ERROR(SP_ERR_ARG, "Null event set"); + + if (!port) + RETURN_ERROR(SP_ERR_ARG, "Null port"); + + if (mask > (SP_EVENT_RX_READY | SP_EVENT_TX_READY | SP_EVENT_ERROR)) + RETURN_ERROR(SP_ERR_ARG, "Invalid event mask"); + + if (!mask) + RETURN_OK(); + +#ifdef _WIN32 + enum sp_event handle_mask; + if ((handle_mask = mask & SP_EVENT_TX_READY)) + TRY(add_handle(event_set, port->write_ovl.hEvent, handle_mask)); + if ((handle_mask = mask & (SP_EVENT_RX_READY | SP_EVENT_ERROR))) + TRY(add_handle(event_set, port->wait_ovl.hEvent, handle_mask)); +#else + TRY(add_handle(event_set, port->fd, mask)); +#endif + + RETURN_OK(); +} + +SP_API void sp_free_event_set(struct sp_event_set *event_set) +{ + TRACE("%p", event_set); + + if (!event_set) { + DEBUG("Null event set"); + RETURN(); + } + + DEBUG("Freeing event set"); + + if (event_set->handles) + free(event_set->handles); + if (event_set->masks) + free(event_set->masks); + + free(event_set); + + RETURN(); +} + +SP_API enum sp_return sp_wait(struct sp_event_set *event_set, + unsigned int timeout_ms) +{ + TRACE("%p, %d", event_set, timeout_ms); + + if (!event_set) + RETURN_ERROR(SP_ERR_ARG, "Null event set"); + +#ifdef _WIN32 + if (WaitForMultipleObjects(event_set->count, event_set->handles, FALSE, + timeout_ms ? timeout_ms : INFINITE) == WAIT_FAILED) + RETURN_FAIL("WaitForMultipleObjects() failed"); + + RETURN_OK(); +#else + struct timeout timeout; + int poll_timeout; + int result; + struct pollfd *pollfds; + unsigned int i; + + if (!(pollfds = malloc(sizeof(struct pollfd) * event_set->count))) + 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].events = 0; + pollfds[i].revents = 0; + if (event_set->masks[i] & SP_EVENT_RX_READY) + pollfds[i].events |= POLLIN; + if (event_set->masks[i] & SP_EVENT_TX_READY) + pollfds[i].events |= POLLOUT; + if (event_set->masks[i] & SP_EVENT_ERROR) + pollfds[i].events |= POLLERR; + } + + timeout_start(&timeout, timeout_ms); + timeout_limit(&timeout, INT_MAX); + + /* Loop until an event occurs. */ + while (1) { + + if (timeout_check(&timeout)) { + DEBUG("Wait timed out"); + break; + } + + poll_timeout = (int) timeout_remaining_ms(&timeout); + if (poll_timeout == 0) + poll_timeout = -1; + + result = poll(pollfds, event_set->count, poll_timeout); + + timeout_update(&timeout); + + if (result < 0) { + if (errno == EINTR) { + DEBUG("poll() call was interrupted, repeating"); + continue; + } else { + free(pollfds); + RETURN_FAIL("poll() failed"); + } + } else if (result == 0) { + DEBUG("poll() timed out"); + if (!timeout.overflow) + break; + } else { + DEBUG("poll() completed"); + break; + } + } + + free(pollfds); + RETURN_OK(); #endif } -#ifdef __linux__ +#ifdef USE_TERMIOS_SPEED static enum sp_return get_baudrate(int fd, int *baudrate) { void *data; @@ -1230,7 +1564,7 @@ static enum sp_return get_baudrate(int fd, int *baudrate) if (ioctl(fd, get_termios_get_ioctl(), data) < 0) { free(data); - RETURN_FAIL("getting termios failed"); + RETURN_FAIL("Getting termios failed"); } *baudrate = get_termios_speed(data); @@ -1253,7 +1587,7 @@ static enum sp_return set_baudrate(int fd, int baudrate) if (ioctl(fd, get_termios_get_ioctl(), data) < 0) { free(data); - RETURN_FAIL("getting termios failed"); + RETURN_FAIL("Getting termios failed"); } DEBUG("Setting baud rate"); @@ -1262,69 +1596,71 @@ static enum sp_return set_baudrate(int fd, int baudrate) if (ioctl(fd, get_termios_set_ioctl(), data) < 0) { free(data); - RETURN_FAIL("setting termios failed"); + RETURN_FAIL("Setting termios failed"); } free(data); RETURN_OK(); } +#endif /* USE_TERMIOS_SPEED */ #ifdef USE_TERMIOX -static enum sp_return get_flow(int fd, int *flow) +static enum sp_return get_flow(int fd, struct port_data *data) { - void *data; + void *termx; - TRACE("%d, %p", fd, flow); + TRACE("%d, %p", fd, data); DEBUG("Getting advanced flow control"); - if (!(data = malloc(get_termiox_size()))) + if (!(termx = malloc(get_termiox_size()))) RETURN_ERROR(SP_ERR_MEM, "termiox malloc failed"); - if (ioctl(fd, TCGETX, data) < 0) { - free(data); - RETURN_FAIL("getting termiox failed"); + if (ioctl(fd, TCGETX, termx) < 0) { + free(termx); + RETURN_FAIL("Getting termiox failed"); } - *flow = get_termiox_flow(data); + get_termiox_flow(termx, &data->rts_flow, &data->cts_flow, + &data->dtr_flow, &data->dsr_flow); - free(data); + free(termx); RETURN_OK(); } -static enum sp_return set_flow(int fd, int flow) +static enum sp_return set_flow(int fd, struct port_data *data) { - void *data; + void *termx; - TRACE("%d, %d", fd, flow); + TRACE("%d, %p", fd, data); DEBUG("Getting advanced flow control"); - if (!(data = malloc(get_termiox_size()))) + if (!(termx = malloc(get_termiox_size()))) RETURN_ERROR(SP_ERR_MEM, "termiox malloc failed"); - if (ioctl(fd, TCGETX, data) < 0) { - free(data); - RETURN_FAIL("getting termiox failed"); + if (ioctl(fd, TCGETX, termx) < 0) { + free(termx); + RETURN_FAIL("Getting termiox failed"); } DEBUG("Setting advanced flow control"); - set_termiox_flow(data, flow); + set_termiox_flow(termx, data->rts_flow, data->cts_flow, + data->dtr_flow, data->dsr_flow); - if (ioctl(fd, TCSETX, data) < 0) { - free(data); - RETURN_FAIL("setting termiox failed"); + if (ioctl(fd, TCSETX, termx) < 0) { + free(termx); + RETURN_FAIL("Setting termiox failed"); } - free(data); + free(termx); RETURN_OK(); } #endif /* USE_TERMIOX */ -#endif /* __linux__ */ static enum sp_return get_config(struct sp_port *port, struct port_data *data, struct sp_port_config *config) @@ -1333,7 +1669,7 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, TRACE("%p, %p, %p", port, data, config); - DEBUG("Getting configuration for port %s", port->name); + DEBUG_FMT("Getting configuration for port %s", port->name); #ifdef _WIN32 if (!GetCommState(port->hdl, &data->dcb)) @@ -1352,28 +1688,25 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, config->bits = data->dcb.ByteSize; - if (data->dcb.fParity) - switch (data->dcb.Parity) { - case NOPARITY: - config->parity = SP_PARITY_NONE; - break; - case ODDPARITY: - config->parity = SP_PARITY_ODD; - break; - case EVENPARITY: - config->parity = SP_PARITY_EVEN; - break; - case MARKPARITY: - config->parity = SP_PARITY_MARK; - break; - case SPACEPARITY: - config->parity = SP_PARITY_SPACE; - break; - default: - config->parity = -1; - } - else + switch (data->dcb.Parity) { + case NOPARITY: config->parity = SP_PARITY_NONE; + break; + case ODDPARITY: + config->parity = SP_PARITY_ODD; + break; + case EVENPARITY: + config->parity = SP_PARITY_EVEN; + break; + case MARKPARITY: + config->parity = SP_PARITY_MARK; + break; + case SPACEPARITY: + config->parity = SP_PARITY_SPACE; + break; + default: + config->parity = -1; + } switch (data->dcb.StopBits) { case ONESTOPBIT: @@ -1439,7 +1772,7 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, RETURN_FAIL("TIOCMGET ioctl failed"); #ifdef USE_TERMIOX - int ret = get_flow(port->fd, &data->flow); + int ret = get_flow(port->fd, data); if (ret == SP_ERR_FAIL && errno == EINVAL) data->termiox_supported = 0; @@ -1461,7 +1794,7 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, if (i == NUM_STD_BAUDRATES) { #ifdef __APPLE__ config->baudrate = (int)data->term.c_ispeed; -#elif defined(__linux__) +#elif defined(USE_TERMIOS_SPEED) TRY(get_baudrate(port->fd, &config->baudrate)); #else config->baudrate = -1; @@ -1502,21 +1835,21 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, config->rts = SP_RTS_FLOW_CONTROL; config->cts = SP_CTS_FLOW_CONTROL; } else { - if (data->termiox_supported && data->flow & RTS_FLOW) + if (data->termiox_supported && data->rts_flow) config->rts = SP_RTS_FLOW_CONTROL; else config->rts = (data->controlbits & TIOCM_RTS) ? SP_RTS_ON : SP_RTS_OFF; - config->cts = (data->termiox_supported && data->flow & CTS_FLOW) ? + config->cts = (data->termiox_supported && data->cts_flow) ? SP_CTS_FLOW_CONTROL : SP_CTS_IGNORE; } - if (data->termiox_supported && data->flow & DTR_FLOW) + if (data->termiox_supported && data->dtr_flow) config->dtr = SP_DTR_FLOW_CONTROL; else config->dtr = (data->controlbits & TIOCM_DTR) ? SP_DTR_ON : SP_DTR_OFF; - config->dsr = (data->termiox_supported && data->flow & DSR_FLOW) ? + config->dsr = (data->termiox_supported && data->dsr_flow) ? SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE; if (data->term.c_iflag & IXOFF) { @@ -1544,15 +1877,19 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, baud_nonstd = B0; #endif -#ifdef __linux__ +#ifdef USE_TERMIOS_SPEED int baud_nonstd = 0; #endif TRACE("%p, %p, %p", port, data, config); - DEBUG("Setting configuration for port %s", port->name); + DEBUG_FMT("Setting configuration for port %s", port->name); #ifdef _WIN32 + BYTE* new_buf; + + TRY(await_write_completion(port)); + if (config->baudrate >= 0) { for (i = 0; i < NUM_STD_BAUDRATES; i++) { if (config->baudrate == std_baudrates[i].value) { @@ -1563,6 +1900,13 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, 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); + new_buf = realloc(port->write_buf, port->write_buf_size); + if (!new_buf) + RETURN_ERROR(SP_ERR_MEM, "Allocating write buffer failed"); + port->write_buf = new_buf; } if (config->bits >= 0) @@ -1570,7 +1914,6 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (config->parity >= 0) { switch (config->parity) { - /* Note: There's also SPACEPARITY, MARKPARITY (unneeded so far). */ case SP_PARITY_NONE: data->dcb.Parity = NOPARITY; break; @@ -1712,7 +2055,7 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (cfsetspeed(&data->term, B9600) < 0) RETURN_FAIL("cfsetspeed() failed"); baud_nonstd = config->baudrate; -#elif defined(__linux__) +#elif defined(USE_TERMIOS_SPEED) baud_nonstd = 1; #else RETURN_ERROR(SP_ERR_SUPP, "Non-standard baudrate not supported"); @@ -1791,7 +2134,7 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (config->rts >= 0 || config->cts >= 0) { if (data->termiox_supported) { - data->flow &= ~(RTS_FLOW | CTS_FLOW); + data->rts_flow = data->cts_flow = 0; switch (config->rts) { case SP_RTS_OFF: case SP_RTS_ON: @@ -1800,15 +2143,15 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, RETURN_FAIL("Setting RTS signal level failed"); break; case SP_RTS_FLOW_CONTROL: - data->flow |= RTS_FLOW; + data->rts_flow = 1; break; default: break; } if (config->cts == SP_CTS_FLOW_CONTROL) - data->flow |= CTS_FLOW; + data->cts_flow = 1; - if (data->flow & (RTS_FLOW | CTS_FLOW)) + if (data->rts_flow && data->cts_flow) data->term.c_iflag |= CRTSCTS; else data->term.c_iflag &= ~CRTSCTS; @@ -1846,7 +2189,7 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (config->dtr >= 0 || config->dsr >= 0) { if (data->termiox_supported) { - data->flow &= ~(DTR_FLOW | DSR_FLOW); + data->dtr_flow = data->dsr_flow = 0; switch (config->dtr) { case SP_DTR_OFF: case SP_DTR_ON: @@ -1855,13 +2198,13 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, RETURN_FAIL("Setting DTR signal level failed"); break; case SP_DTR_FLOW_CONTROL: - data->flow |= DTR_FLOW; + data->dtr_flow = 1; break; default: break; } if (config->dsr == SP_DSR_FLOW_CONTROL) - data->flow |= DSR_FLOW; + data->dsr_flow = 1; } else { /* DTR/DSR flow control not supported. */ if (config->dtr == SP_DTR_FLOW_CONTROL || config->dsr == SP_DSR_FLOW_CONTROL) @@ -1902,17 +2245,21 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (baud_nonstd != B0) { if (ioctl(port->fd, IOSSIOSPEED, &baud_nonstd) == -1) RETURN_FAIL("IOSSIOSPEED ioctl failed"); - /* Set baud rates in data->term to correct, but incompatible - * with tcsetattr() value, same as delivered by tcgetattr(). */ + /* + * Set baud rates in data->term to correct, but incompatible + * with tcsetattr() value, same as delivered by tcgetattr(). + */ if (cfsetspeed(&data->term, baud_nonstd) < 0) RETURN_FAIL("cfsetspeed() failed"); } #elif defined(__linux__) +#ifdef USE_TERMIOS_SPEED if (baud_nonstd) TRY(set_baudrate(port->fd, config->baudrate)); +#endif #ifdef USE_TERMIOX if (data->termiox_supported) - TRY(set_flow(port->fd, data->flow)); + TRY(set_flow(port->fd, data)); #endif #endif @@ -1921,7 +2268,7 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, RETURN_OK(); } -enum sp_return sp_new_config(struct sp_port_config **config_ptr) +SP_API enum sp_return sp_new_config(struct sp_port_config **config_ptr) { struct sp_port_config *config; @@ -1933,7 +2280,7 @@ enum sp_return sp_new_config(struct sp_port_config **config_ptr) *config_ptr = NULL; if (!(config = malloc(sizeof(struct sp_port_config)))) - RETURN_ERROR(SP_ERR_MEM, "config malloc failed"); + RETURN_ERROR(SP_ERR_MEM, "Config malloc failed"); config->baudrate = -1; config->bits = -1; @@ -1949,7 +2296,7 @@ enum sp_return sp_new_config(struct sp_port_config **config_ptr) RETURN_OK(); } -void sp_free_config(struct sp_port_config *config) +SP_API void sp_free_config(struct sp_port_config *config) { TRACE("%p", config); @@ -1961,7 +2308,8 @@ void sp_free_config(struct sp_port_config *config) RETURN(); } -enum sp_return sp_get_config(struct sp_port *port, struct sp_port_config *config) +SP_API enum sp_return sp_get_config(struct sp_port *port, + struct sp_port_config *config) { struct port_data data; @@ -1977,7 +2325,8 @@ enum sp_return sp_get_config(struct sp_port *port, struct sp_port_config *config RETURN_OK(); } -enum sp_return sp_set_config(struct sp_port *port, const struct sp_port_config *config) +SP_API enum sp_return sp_set_config(struct sp_port *port, + const struct sp_port_config *config) { struct port_data data; struct sp_port_config prev_config; @@ -1996,7 +2345,7 @@ enum sp_return sp_set_config(struct sp_port *port, const struct sp_port_config * } #define CREATE_ACCESSORS(x, type) \ -enum sp_return sp_set_##x(struct sp_port *port, type x) { \ +SP_API enum sp_return sp_set_##x(struct sp_port *port, type x) { \ struct port_data data; \ struct sp_port_config config; \ TRACE("%p, %d", port, x); \ @@ -2006,14 +2355,18 @@ enum sp_return sp_set_##x(struct sp_port *port, type x) { \ TRY(set_config(port, &data, &config)); \ RETURN_OK(); \ } \ -enum sp_return sp_get_config_##x(const struct sp_port_config *config, type *x) { \ +SP_API enum sp_return sp_get_config_##x(const struct sp_port_config *config, \ + type *x) { \ TRACE("%p, %p", config, x); \ + if (!x) \ + RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); \ if (!config) \ RETURN_ERROR(SP_ERR_ARG, "Null config"); \ *x = config->x; \ RETURN_OK(); \ } \ -enum sp_return sp_set_config_##x(struct sp_port_config *config, type x) { \ +SP_API enum sp_return sp_set_config_##x(struct sp_port_config *config, \ + type x) { \ TRACE("%p, %d", config, x); \ if (!config) \ RETURN_ERROR(SP_ERR_ARG, "Null config"); \ @@ -2031,7 +2384,8 @@ CREATE_ACCESSORS(dtr, enum sp_dtr) CREATE_ACCESSORS(dsr, enum sp_dsr) CREATE_ACCESSORS(xon_xoff, enum sp_xonxoff) -enum sp_return sp_set_config_flowcontrol(struct sp_port_config *config, enum sp_flowcontrol flowcontrol) +SP_API enum sp_return sp_set_config_flowcontrol(struct sp_port_config *config, + enum sp_flowcontrol flowcontrol) { if (!config) RETURN_ERROR(SP_ERR_ARG, "Null configuration"); @@ -2065,7 +2419,8 @@ enum sp_return sp_set_config_flowcontrol(struct sp_port_config *config, enum sp_ RETURN_OK(); } -enum sp_return sp_set_flowcontrol(struct sp_port *port, enum sp_flowcontrol flowcontrol) +SP_API enum sp_return sp_set_flowcontrol(struct sp_port *port, + enum sp_flowcontrol flowcontrol) { struct port_data data; struct sp_port_config config; @@ -2083,7 +2438,8 @@ enum sp_return sp_set_flowcontrol(struct sp_port *port, enum sp_flowcontrol flow RETURN_OK(); } -enum sp_return sp_get_signals(struct sp_port *port, enum sp_signal *signals) +SP_API enum sp_return sp_get_signals(struct sp_port *port, + enum sp_signal *signals) { TRACE("%p, %p", port, signals); @@ -2092,7 +2448,7 @@ enum sp_return sp_get_signals(struct sp_port *port, enum sp_signal *signals) if (!signals) RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); - DEBUG("Getting control signals for port %s", port->name); + DEBUG_FMT("Getting control signals for port %s", port->name); *signals = 0; #ifdef _WIN32 @@ -2123,7 +2479,7 @@ enum sp_return sp_get_signals(struct sp_port *port, enum sp_signal *signals) RETURN_OK(); } -enum sp_return sp_start_break(struct sp_port *port) +SP_API enum sp_return sp_start_break(struct sp_port *port) { TRACE("%p", port); @@ -2139,7 +2495,7 @@ enum sp_return sp_start_break(struct sp_port *port) RETURN_OK(); } -enum sp_return sp_end_break(struct sp_port *port) +SP_API enum sp_return sp_end_break(struct sp_port *port) { TRACE("%p", port); @@ -2155,41 +2511,44 @@ enum sp_return sp_end_break(struct sp_port *port) RETURN_OK(); } -int sp_last_error_code(void) +SP_API int sp_last_error_code(void) { - TRACE(""); + TRACE_VOID(); #ifdef _WIN32 - RETURN_VALUE("%d", GetLastError()); + RETURN_INT(GetLastError()); #else - RETURN_VALUE("%d", errno); + RETURN_INT(errno); #endif } -char *sp_last_error_message(void) +SP_API char *sp_last_error_message(void) { - TRACE(""); + TRACE_VOID(); #ifdef _WIN32 - LPVOID message; + char *message; DWORD error = GetLastError(); - FormatMessage( + DWORD length = FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), - (LPTSTR) &message, + (LPSTR) &message, 0, NULL ); - RETURN_VALUE("%s", message); + if (length >= 2 && message[length - 2] == '\r') + message[length - 2] = '\0'; + + RETURN_STRING(message); #else - RETURN_VALUE("%s", strerror(errno)); + RETURN_STRING(strerror(errno)); #endif } -void sp_free_error_message(char *message) +SP_API void sp_free_error_message(char *message) { TRACE("%s", message); @@ -2202,7 +2561,7 @@ void sp_free_error_message(char *message) RETURN(); } -void sp_set_debug_handler(void (*handler)(const char *format, ...)) +SP_API void sp_set_debug_handler(void (*handler)(const char *format, ...)) { TRACE("%p", handler); @@ -2211,7 +2570,7 @@ void sp_set_debug_handler(void (*handler)(const char *format, ...)) RETURN(); } -void sp_default_debug_handler(const char *format, ...) +SP_API void sp_default_debug_handler(const char *format, ...) { va_list args; va_start(args, format); @@ -2221,3 +2580,45 @@ void sp_default_debug_handler(const char *format, ...) } va_end(args); } + +SP_API int sp_get_major_package_version(void) +{ + return SP_PACKAGE_VERSION_MAJOR; +} + +SP_API int sp_get_minor_package_version(void) +{ + return SP_PACKAGE_VERSION_MINOR; +} + +SP_API int sp_get_micro_package_version(void) +{ + return SP_PACKAGE_VERSION_MICRO; +} + +SP_API const char *sp_get_package_version_string(void) +{ + return SP_PACKAGE_VERSION_STRING; +} + +SP_API int sp_get_current_lib_version(void) +{ + return SP_LIB_VERSION_CURRENT; +} + +SP_API int sp_get_revision_lib_version(void) +{ + return SP_LIB_VERSION_REVISION; +} + +SP_API int sp_get_age_lib_version(void) +{ + return SP_LIB_VERSION_AGE; +} + +SP_API const char *sp_get_lib_version_string(void) +{ + return SP_LIB_VERSION_STRING; +} + +/** @} */