serialport.c

   1 /*
   2  * This file is part of the libserialport project.
   3  *
   4  * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
   5  * Copyright (C) 2010-2012 Uwe Hermann <uwe@hermann-uwe.de>
   6  * Copyright (C) 2013 Martin Ling <martin-libserialport@earth.li>
   7  * Copyright (C) 2013 Matthias Heidbrink <m-sigrok@heidbrink.biz>
   8  *
   9  * This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU Lesser General Public License as
  11  * published by the Free Software Foundation, either version 3 of the
  12  * License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <stdio.h>
  31 #include <stdarg.h>
  32 #ifdef _WIN32
  33 #include <windows.h>
  34 #include <tchar.h>
  35 #include <stdio.h>
  36 #else
  37 #include <limits.h>
  38 #include <termios.h>
  39 #include <sys/ioctl.h>
  40 #include <sys/time.h>
  41 #include <limits.h>
  42 #include <poll.h>
  43 #endif
  44 #ifdef __APPLE__
  45 #include <IOKit/IOKitLib.h>
  46 #include <IOKit/serial/IOSerialKeys.h>
  47 #include <IOKit/serial/ioss.h>
  48 #include <sys/syslimits.h>
  49 #endif
  50 #ifdef __linux__
  51 #ifdef HAVE_LIBUDEV
  52 #include "libudev.h"
  53 #endif
  54 #ifndef __ANDROID__
  55 #include "linux/serial.h"
  56 #endif
  57 #include "linux_termios.h"
  58
  59 /* TCGETX/TCSETX is not available everywhere. */
  60 #if defined(TCGETX) && defined(TCSETX) && defined(HAVE_TERMIOX)
  61 #define USE_TERMIOX
  62 #endif
  63 #endif
  64
  65 /* TIOCINQ/TIOCOUTQ is not available everywhere. */
  66 #if !defined(TIOCINQ) && defined(FIONREAD)
  67 #define TIOCINQ FIONREAD
  68 #endif
  69 #if !defined(TIOCOUTQ) && defined(FIONWRITE)
  70 #define TIOCOUTQ FIONWRITE
  71 #endif
  72
  73 #ifndef _WIN32
  74 #include "linux_termios.h"
  75 #endif
  76
  77 #include "libserialport.h"
  78
  79 struct sp_port {
  80         char *name;
  81 #ifdef _WIN32
  82         HANDLE hdl;
  83         COMMTIMEOUTS timeouts;
  84         OVERLAPPED write_ovl;
  85         OVERLAPPED read_ovl;
  86         OVERLAPPED wait_ovl;
  87         DWORD events;
  88         BYTE pending_byte;
  89         BOOL writing;
  90 #else
  91         int fd;
  92 #endif
  93 };
  94
  95 struct sp_port_config {
  96         int baudrate;
  97         int bits;
  98         enum sp_parity parity;
  99         int stopbits;
 100         enum sp_rts rts;
 101         enum sp_cts cts;
 102         enum sp_dtr dtr;
 103         enum sp_dsr dsr;
 104         enum sp_xonxoff xon_xoff;
 105 };
 106
 107 struct port_data {
 108 #ifdef _WIN32
 109         DCB dcb;
 110 #else
 111         struct termios term;
 112         int controlbits;
 113         int termiox_supported;
 114         int flow;
 115 #endif
 116 };
 117
 118 #ifdef _WIN32
 119 typedef HANDLE event_handle;
 120 #else
 121 typedef int event_handle;
 122 #endif
 123
 124 /* Standard baud rates. */
 125 #ifdef _WIN32
 126 #define BAUD_TYPE DWORD
 127 #define BAUD(n) {CBR_##n, n}
 128 #else
 129 #define BAUD_TYPE speed_t
 130 #define BAUD(n) {B##n, n}
 131 #endif
 132
 133 struct std_baudrate {
 134         BAUD_TYPE index;
 135         int value;
 136 };
 137
 138 const struct std_baudrate std_baudrates[] = {
 139 #ifdef _WIN32
 140         /*
 141          * The baudrates 50/75/134/150/200/1800/230400/460800 do not seem to
 142          * have documented CBR_* macros.
 143          */
 144         BAUD(110), BAUD(300), BAUD(600), BAUD(1200), BAUD(2400), BAUD(4800),
 145         BAUD(9600), BAUD(14400), BAUD(19200), BAUD(38400), BAUD(57600),
 146         BAUD(115200), BAUD(128000), BAUD(256000),
 147 #else
 148         BAUD(50), BAUD(75), BAUD(110), BAUD(134), BAUD(150), BAUD(200),
 149         BAUD(300), BAUD(600), BAUD(1200), BAUD(1800), BAUD(2400), BAUD(4800),
 150         BAUD(9600), BAUD(19200), BAUD(38400), BAUD(57600), BAUD(115200),
 151         BAUD(230400),
 152 #if !defined(__APPLE__) && !defined(__OpenBSD__)
 153         BAUD(460800),
 154 #endif
 155 #endif
 156 };
 157
 158 void (*sp_debug_handler)(const char *format, ...) = sp_default_debug_handler;
 159
 160 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
 161 #define NUM_STD_BAUDRATES ARRAY_SIZE(std_baudrates)
 162
 163 /* Debug output macros. */
 164 #define DEBUG(fmt, ...) do { if (sp_debug_handler) sp_debug_handler(fmt ".\n", ##__VA_ARGS__); } while (0)
 165 #define DEBUG_ERROR(err, msg) DEBUG("%s returning " #err ": " msg, __func__)
 166 #define DEBUG_FAIL(msg) do { \
 167         char *errmsg = sp_last_error_message(); \
 168         DEBUG("%s returning SP_ERR_FAIL: " msg ": %s", __func__, errmsg); \
 169         sp_free_error_message(errmsg); \
 170 } while (0);
 171 #define RETURN() do { DEBUG("%s returning", __func__); return; } while(0)
 172 #define RETURN_CODE(x) do { DEBUG("%s returning " #x, __func__); return x; } while (0)
 173 #define RETURN_CODEVAL(x) do { \
 174         switch (x) { \
 175                 case SP_OK: RETURN_CODE(SP_OK); \
 176                 case SP_ERR_ARG: RETURN_CODE(SP_ERR_ARG); \
 177                 case SP_ERR_FAIL: RETURN_CODE(SP_ERR_FAIL); \
 178                 case SP_ERR_MEM: RETURN_CODE(SP_ERR_MEM); \
 179                 case SP_ERR_SUPP: RETURN_CODE(SP_ERR_SUPP); \
 180         } \
 181 } while (0)
 182 #define RETURN_OK() RETURN_CODE(SP_OK);
 183 #define RETURN_ERROR(err, msg) do { DEBUG_ERROR(err, msg); return err; } while (0)
 184 #define RETURN_FAIL(msg) do { DEBUG_FAIL(msg); return SP_ERR_FAIL; } while (0)
 185 #define RETURN_VALUE(fmt, x) do { \
 186         typeof(x) _x = x; \
 187         DEBUG("%s returning " fmt, __func__, _x); \
 188         return _x; \
 189 } while (0)
 190 #define SET_ERROR(val, err, msg) do { DEBUG_ERROR(err, msg); val = err; } while (0)
 191 #define SET_FAIL(val, msg) do { DEBUG_FAIL(msg); val = SP_ERR_FAIL; } while (0)
 192 #define TRACE(fmt, ...) DEBUG("%s(" fmt ") called", __func__, ##__VA_ARGS__)
 193
 194 #define TRY(x) do { int ret = x; if (ret != SP_OK) RETURN_CODEVAL(ret); } while (0)
 195
 196 /* Helper functions. */
 197 static struct sp_port **list_append(struct sp_port **list, const char *portname);
 198 static enum sp_return get_config(struct sp_port *port, struct port_data *data,
 199         struct sp_port_config *config);
 200 static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 201         const struct sp_port_config *config);
 202
 203 enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr)
 204 {
 205         struct sp_port *port;
 206         int len;
 207
 208         TRACE("%s, %p", portname, port_ptr);
 209
 210         if (!port_ptr)
 211                 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
 212
 213         *port_ptr = NULL;
 214
 215         if (!portname)
 216                 RETURN_ERROR(SP_ERR_ARG, "Null port name");
 217
 218         DEBUG("Building structure for port %s", portname);
 219
 220         if (!(port = malloc(sizeof(struct sp_port))))
 221                 RETURN_ERROR(SP_ERR_MEM, "Port structure malloc failed");
 222
 223         len = strlen(portname) + 1;
 224
 225         if (!(port->name = malloc(len))) {
 226                 free(port);
 227                 RETURN_ERROR(SP_ERR_MEM, "Port name malloc failed");
 228         }
 229
 230         memcpy(port->name, portname, len);
 231
 232 #ifdef _WIN32
 233         port->hdl = INVALID_HANDLE_VALUE;
 234 #else
 235         port->fd = -1;
 236 #endif
 237
 238         *port_ptr = port;
 239
 240         RETURN_OK();
 241 }
 242
 243 char *sp_get_port_name(const struct sp_port *port)
 244 {
 245         TRACE("%p", port);
 246
 247         if (!port)
 248                 return NULL;
 249
 250         RETURN_VALUE("%s", port->name);
 251 }
 252
 253 enum sp_return sp_get_port_handle(const struct sp_port *port, void *result_ptr)
 254 {
 255         TRACE("%p, %p", port, result_ptr);
 256
 257         if (!port)
 258                 RETURN_ERROR(SP_ERR_ARG, "Null port");
 259
 260 #ifdef _WIN32
 261         HANDLE *handle_ptr = result_ptr;
 262         *handle_ptr = port->hdl;
 263 #else
 264         int *fd_ptr = result_ptr;
 265         *fd_ptr = port->fd;
 266 #endif
 267
 268         RETURN_OK();
 269 }
 270
 271 enum sp_return sp_copy_port(const struct sp_port *port, struct sp_port **copy_ptr)
 272 {
 273         TRACE("%p, %p", port, copy_ptr);
 274
 275         if (!copy_ptr)
 276                 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
 277
 278         *copy_ptr = NULL;
 279
 280         if (!port)
 281                 RETURN_ERROR(SP_ERR_ARG, "Null port");
 282
 283         if (!port->name)
 284                 RETURN_ERROR(SP_ERR_ARG, "Null port name");
 285
 286         DEBUG("Copying port structure");
 287
 288         RETURN_VALUE("%p", sp_get_port_by_name(port->name, copy_ptr));
 289 }
 290
 291 void sp_free_port(struct sp_port *port)
 292 {
 293         TRACE("%p", port);
 294
 295         if (!port) {
 296                 DEBUG("Null port");
 297                 RETURN();
 298         }
 299
 300         DEBUG("Freeing port structure");
 301
 302         if (port->name)
 303                 free(port->name);
 304
 305         free(port);
 306
 307         RETURN();
 308 }
 309
 310 static struct sp_port **list_append(struct sp_port **list, const char *portname)
 311 {
 312         void *tmp;
 313         unsigned int count;
 314
 315         for (count = 0; list[count]; count++);
 316         if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2))))
 317                 goto fail;
 318         list = tmp;
 319         if (sp_get_port_by_name(portname, &list[count]) != SP_OK)
 320                 goto fail;
 321         list[count + 1] = NULL;
 322         return list;
 323
 324 fail:
 325         sp_free_port_list(list);
 326         return NULL;
 327 }
 328
 329 enum sp_return sp_list_ports(struct sp_port ***list_ptr)
 330 {
 331         struct sp_port **list;
 332         int ret = SP_ERR_SUPP;
 333
 334         TRACE("%p", list_ptr);
 335
 336         if (!list_ptr)
 337                 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
 338
 339         DEBUG("Enumerating ports");
 340
 341         if (!(list = malloc(sizeof(struct sp_port **))))
 342                 RETURN_ERROR(SP_ERR_MEM, "Port list malloc failed");
 343
 344         list[0] = NULL;
 345
 346 #ifdef _WIN32
 347         HKEY key;
 348         TCHAR *value, *data;
 349         DWORD max_value_len, max_data_size, max_data_len;
 350         DWORD value_len, data_size, data_len;
 351         DWORD type, index = 0;
 352         char *name;
 353         int name_len;
 354
 355         ret = SP_OK;
 356
 357         DEBUG("Opening registry key");
 358         if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("HARDWARE\\DEVICEMAP\\SERIALCOMM"),
 359                         0, KEY_QUERY_VALUE, &key) != ERROR_SUCCESS) {
 360                 SET_FAIL(ret, "RegOpenKeyEx() failed");
 361                 goto out_done;
 362         }
 363         DEBUG("Querying registry key value and data sizes");
 364         if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 365                                 &max_value_len, &max_data_size, NULL, NULL) != ERROR_SUCCESS) {
 366                 SET_FAIL(ret, "RegQueryInfoKey() failed");
 367                 goto out_close;
 368         }
 369         max_data_len = max_data_size / sizeof(TCHAR);
 370         if (!(value = malloc((max_value_len + 1) * sizeof(TCHAR)))) {
 371                 SET_ERROR(ret, SP_ERR_MEM, "registry value malloc failed");
 372                 goto out_close;
 373         }
 374         if (!(data = malloc((max_data_len + 1) * sizeof(TCHAR)))) {
 375                 SET_ERROR(ret, SP_ERR_MEM, "registry data malloc failed");
 376                 goto out_free_value;
 377         }
 378         DEBUG("Iterating over values");
 379         while (
 380                 value_len = max_value_len + 1,
 381                 data_size = max_data_size,
 382                 RegEnumValue(key, index, value, &value_len,
 383                         NULL, &type, (LPBYTE)data, &data_size) == ERROR_SUCCESS)
 384         {
 385                 data_len = data_size / sizeof(TCHAR);
 386                 data[data_len] = '\0';
 387 #ifdef UNICODE
 388                 name_len = WideCharToMultiByte(CP_ACP, 0, data, -1, NULL, 0, NULL, NULL)
 389 #else
 390                 name_len = data_len + 1;
 391 #endif
 392                 if (!(name = malloc(name_len))) {
 393                         SET_ERROR(ret, SP_ERR_MEM, "registry port name malloc failed");
 394                         goto out;
 395                 }
 396 #ifdef UNICODE
 397                 WideCharToMultiByte(CP_ACP, 0, data, -1, name, name_len, NULL, NULL);
 398 #else
 399                 strcpy(name, data);
 400 #endif
 401                 if (type == REG_SZ) {
 402                         DEBUG("Found port %s", name);
 403                         if (!(list = list_append(list, name))) {
 404                                 SET_ERROR(ret, SP_ERR_MEM, "list append failed");
 405                                 goto out;
 406                         }
 407                 }
 408                 index++;
 409         }
 410 out:
 411         free(data);
 412 out_free_value:
 413         free(value);
 414 out_close:
 415         RegCloseKey(key);
 416 out_done:
 417 #endif
 418 #ifdef __APPLE__
 419         mach_port_t master;
 420         CFMutableDictionaryRef classes;
 421         io_iterator_t iter;
 422         char *path;
 423         io_object_t port;
 424         CFTypeRef cf_path;
 425         Boolean result;
 426
 427         ret = SP_OK;
 428
 429         DEBUG("Getting IOKit master port");
 430         if (IOMasterPort(MACH_PORT_NULL, &master) != KERN_SUCCESS) {
 431                 SET_FAIL(ret, "IOMasterPort() failed");
 432                 goto out_done;
 433         }
 434
 435         DEBUG("Creating matching dictionary");
 436         if (!(classes = IOServiceMatching(kIOSerialBSDServiceValue))) {
 437                 SET_FAIL(ret, "IOServiceMatching() failed");
 438                 goto out_done;
 439         }
 440
 441         CFDictionarySetValue(classes,
 442                         CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes));
 443
 444         DEBUG("Getting matching services");
 445         if (IOServiceGetMatchingServices(master, classes, &iter) != KERN_SUCCESS) {
 446                 SET_FAIL(ret, "IOServiceGetMatchingServices() failed");
 447                 goto out_done;
 448         }
 449
 450         if (!(path = malloc(PATH_MAX))) {
 451                 SET_ERROR(ret, SP_ERR_MEM, "device path malloc failed");
 452                 goto out_release;
 453         }
 454
 455         DEBUG("Iterating over results");
 456         while ((port = IOIteratorNext(iter))) {
 457                 cf_path = IORegistryEntryCreateCFProperty(port,
 458                                 CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
 459                 if (cf_path) {
 460                         result = CFStringGetCString(cf_path,
 461                                         path, PATH_MAX, kCFStringEncodingASCII);
 462                         CFRelease(cf_path);
 463                         if (result) {
 464                                 DEBUG("Found port %s", path);
 465                                 if (!(list = list_append(list, path))) {
 466                                         SET_ERROR(ret, SP_ERR_MEM, "list append failed");
 467                                         IOObjectRelease(port);
 468                                         goto out;
 469                                 }
 470                         }
 471                 }
 472                 IOObjectRelease(port);
 473         }
 474 out:
 475         free(path);
 476 out_release:
 477         IOObjectRelease(iter);
 478 out_done:
 479 #endif
 480 #if defined(__linux__) && defined(HAVE_LIBUDEV)
 481         struct udev *ud;
 482         struct udev_enumerate *ud_enumerate;
 483         struct udev_list_entry *ud_list;
 484         struct udev_list_entry *ud_entry;
 485         const char *path;
 486         struct udev_device *ud_dev, *ud_parent;
 487         const char *name;
 488         const char *driver;
 489         int fd, ioctl_result;
 490         struct serial_struct serial_info;
 491
 492         ret = SP_OK;
 493
 494         DEBUG("Enumerating tty devices");
 495         ud = udev_new();
 496         ud_enumerate = udev_enumerate_new(ud);
 497         udev_enumerate_add_match_subsystem(ud_enumerate, "tty");
 498         udev_enumerate_scan_devices(ud_enumerate);
 499         ud_list = udev_enumerate_get_list_entry(ud_enumerate);
 500         DEBUG("Iterating over results");
 501         udev_list_entry_foreach(ud_entry, ud_list) {
 502                 path = udev_list_entry_get_name(ud_entry);
 503                 DEBUG("Found device %s", path);
 504                 ud_dev = udev_device_new_from_syspath(ud, path);
 505                 /* If there is no parent device, this is a virtual tty. */
 506                 ud_parent = udev_device_get_parent(ud_dev);
 507                 if (ud_parent == NULL) {
 508                         DEBUG("No parent device, assuming virtual tty");
 509                         udev_device_unref(ud_dev);
 510                         continue;
 511                 }
 512                 name = udev_device_get_devnode(ud_dev);
 513                 /* The serial8250 driver has a hardcoded number of ports.
 514                  * The only way to tell which actually exist on a given system
 515                  * is to try to open them and make an ioctl call. */
 516                 driver = udev_device_get_driver(ud_parent);
 517                 if (driver && !strcmp(driver, "serial8250")) {
 518                         DEBUG("serial8250 device, attempting to open");
 519                         if ((fd = open(name, O_RDWR | O_NONBLOCK | O_NOCTTY)) < 0) {
 520                                 DEBUG("open failed, skipping");
 521                                 goto skip;
 522                         }
 523                         ioctl_result = ioctl(fd, TIOCGSERIAL, &serial_info);
 524                         close(fd);
 525                         if (ioctl_result != 0) {
 526                                 DEBUG("ioctl failed, skipping");
 527                                 goto skip;
 528                         }
 529                         if (serial_info.type == PORT_UNKNOWN) {
 530                                 DEBUG("port type is unknown, skipping");
 531                                 goto skip;
 532                         }
 533                 }
 534                 DEBUG("Found port %s", name);
 535                 list = list_append(list, name);
 536 skip:
 537                 udev_device_unref(ud_dev);
 538                 if (!list) {
 539                         SET_ERROR(ret, SP_ERR_MEM, "list append failed");
 540                         goto out;
 541                 }
 542         }
 543 out:
 544         udev_enumerate_unref(ud_enumerate);
 545         udev_unref(ud);
 546 #endif
 547
 548         switch (ret) {
 549         case SP_OK:
 550                 *list_ptr = list;
 551                 RETURN_OK();
 552         case SP_ERR_SUPP:
 553                 DEBUG_ERROR(SP_ERR_SUPP, "Enumeration not supported on this platform");
 554         default:
 555                 if (list)
 556                         sp_free_port_list(list);
 557                 *list_ptr = NULL;
 558                 return ret;
 559         }
 560 }
 561
 562 void sp_free_port_list(struct sp_port **list)
 563 {
 564         unsigned int i;
 565
 566         TRACE("%p", list);
 567
 568         if (!list) {
 569                 DEBUG("Null list");
 570                 RETURN();
 571         }
 572
 573         DEBUG("Freeing port list");
 574
 575         for (i = 0; list[i]; i++)
 576                 sp_free_port(list[i]);
 577         free(list);
 578
 579         RETURN();
 580 }
 581
 582 #define CHECK_PORT() do { \
 583         if (port == NULL) \
 584                 RETURN_ERROR(SP_ERR_ARG, "Null port"); \
 585         if (port->name == NULL) \
 586                 RETURN_ERROR(SP_ERR_ARG, "Null port name"); \
 587 } while (0)
 588 #ifdef _WIN32
 589 #define CHECK_PORT_HANDLE() do { \
 590         if (port->hdl == INVALID_HANDLE_VALUE) \
 591                 RETURN_ERROR(SP_ERR_ARG, "Invalid port handle"); \
 592 } while (0)
 593 #else
 594 #define CHECK_PORT_HANDLE() do { \
 595         if (port->fd < 0) \
 596                 RETURN_ERROR(SP_ERR_ARG, "Invalid port fd"); \
 597 } while (0)
 598 #endif
 599 #define CHECK_OPEN_PORT() do { \
 600         CHECK_PORT(); \
 601         CHECK_PORT_HANDLE(); \
 602 } while (0)
 603
 604 enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
 605 {
 606         struct port_data data;
 607         struct sp_port_config config;
 608         enum sp_return ret;
 609
 610         TRACE("%p, 0x%x", port, flags);
 611
 612         CHECK_PORT();
 613
 614         if (flags > (SP_MODE_READ | SP_MODE_WRITE))
 615                 RETURN_ERROR(SP_ERR_ARG, "Invalid flags");
 616
 617         DEBUG("Opening port %s", port->name);
 618
 619 #ifdef _WIN32
 620         DWORD desired_access = 0, flags_and_attributes = 0, errors;
 621         char *escaped_port_name;
 622         COMSTAT status;
 623
 624         /* Prefix port name with '\\.\' to work with ports above COM9. */
 625         if (!(escaped_port_name = malloc(strlen(port->name + 5))))
 626                 RETURN_ERROR(SP_ERR_MEM, "Escaped port name malloc failed");
 627         sprintf(escaped_port_name, "\\\\.\\%s", port->name);
 628
 629         /* Map 'flags' to the OS-specific settings. */
 630         flags_and_attributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
 631         if (flags & SP_MODE_READ)
 632                 desired_access |= GENERIC_READ;
 633         if (flags & SP_MODE_WRITE)
 634                 desired_access |= GENERIC_WRITE;
 635
 636         port->hdl = CreateFile(escaped_port_name, desired_access, 0, 0,
 637                          OPEN_EXISTING, flags_and_attributes, 0);
 638
 639         free(escaped_port_name);
 640
 641         if (port->hdl == INVALID_HANDLE_VALUE)
 642                 RETURN_FAIL("port CreateFile() failed");
 643
 644         /* All timeouts initially disabled. */
 645         port->timeouts.ReadIntervalTimeout = 0;
 646         port->timeouts.ReadTotalTimeoutMultiplier = 0;
 647         port->timeouts.ReadTotalTimeoutConstant = 0;
 648         port->timeouts.WriteTotalTimeoutMultiplier = 0;
 649         port->timeouts.WriteTotalTimeoutConstant = 0;
 650
 651         if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) {
 652                 sp_close(port);
 653                 RETURN_FAIL("SetCommTimeouts() failed");
 654         }
 655
 656         /* Prepare OVERLAPPED structures. */
 657 #define INIT_OVERLAPPED(ovl) do { \
 658         memset(&port->ovl, 0, sizeof(port->ovl)); \
 659         port->ovl.hEvent = INVALID_HANDLE_VALUE; \
 660         if ((port->ovl.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)) \
 661                         == INVALID_HANDLE_VALUE) { \
 662                 sp_close(port); \
 663                 RETURN_FAIL(#ovl "CreateEvent() failed"); \
 664         } \
 665 } while (0)
 666
 667         INIT_OVERLAPPED(read_ovl);
 668         INIT_OVERLAPPED(write_ovl);
 669         INIT_OVERLAPPED(wait_ovl);
 670
 671         /* Set event mask for RX and error events. */
 672         if (SetCommMask(port->hdl, EV_RXCHAR | EV_ERR) == 0) {
 673                 sp_close(port);
 674                 RETURN_FAIL("SetCommMask() failed");
 675         }
 676
 677         /* Start background operation for RX and error events. */
 678         if (WaitCommEvent(port->hdl, &port->events, &port->wait_ovl) == 0) {
 679                 if (GetLastError() != ERROR_IO_PENDING) {
 680                         sp_close(port);
 681                         RETURN_FAIL("WaitCommEvent() failed");
 682                 }
 683         }
 684
 685         port->writing = FALSE;
 686
 687 #else
 688         int flags_local = O_NONBLOCK | O_NOCTTY;
 689
 690         /* Map 'flags' to the OS-specific settings. */
 691         if (flags & (SP_MODE_READ | SP_MODE_WRITE))
 692                 flags_local |= O_RDWR;
 693         else if (flags & SP_MODE_READ)
 694                 flags_local |= O_RDONLY;
 695         else if (flags & SP_MODE_WRITE)
 696                 flags_local |= O_WRONLY;
 697
 698         if ((port->fd = open(port->name, flags_local)) < 0)
 699                 RETURN_FAIL("open() failed");
 700 #endif
 701
 702         ret = get_config(port, &data, &config);
 703
 704         if (ret < 0) {
 705                 sp_close(port);
 706                 RETURN_CODEVAL(ret);
 707         }
 708
 709         /* Set sane port settings. */
 710 #ifdef _WIN32
 711         data.dcb.fBinary = TRUE;
 712         data.dcb.fDsrSensitivity = FALSE;
 713         data.dcb.fErrorChar = FALSE;
 714         data.dcb.fNull = FALSE;
 715         data.dcb.fAbortOnError = TRUE;
 716 #else
 717         /* Turn off all fancy termios tricks, give us a raw channel. */
 718         data.term.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IMAXBEL);
 719 #ifdef IUCLC
 720         data.term.c_iflag &= ~IUCLC;
 721 #endif
 722         data.term.c_oflag &= ~(OPOST | ONLCR | OCRNL | ONOCR | ONLRET);
 723 #ifdef OLCUC
 724         data.term.c_oflag &= ~OLCUC;
 725 #endif
 726 #ifdef NLDLY
 727         data.term.c_oflag &= ~NLDLY;
 728 #endif
 729 #ifdef CRDLY
 730         data.term.c_oflag &= ~CRDLY;
 731 #endif
 732 #ifdef TABDLY
 733         data.term.c_oflag &= ~TABDLY;
 734 #endif
 735 #ifdef BSDLY
 736         data.term.c_oflag &= ~BSDLY;
 737 #endif
 738 #ifdef VTDLY
 739         data.term.c_oflag &= ~VTDLY;
 740 #endif
 741 #ifdef FFDLY
 742         data.term.c_oflag &= ~FFDLY;
 743 #endif
 744 #ifdef OFILL
 745         data.term.c_oflag &= ~OFILL;
 746 #endif
 747         data.term.c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN);
 748         data.term.c_cc[VMIN] = 0;
 749         data.term.c_cc[VTIME] = 0;
 750
 751         /* Ignore modem status lines; enable receiver; leave control lines alone on close. */
 752         data.term.c_cflag |= (CLOCAL | CREAD | HUPCL);
 753 #endif
 754
 755 #ifdef _WIN32
 756         if (ClearCommError(port->hdl, &errors, &status) == 0)
 757                 RETURN_FAIL("ClearCommError() failed");
 758 #endif
 759
 760         ret = set_config(port, &data, &config);
 761
 762         if (ret < 0) {
 763                 sp_close(port);
 764                 RETURN_CODEVAL(ret);
 765         }
 766
 767         RETURN_OK();
 768 }
 769
 770 enum sp_return sp_close(struct sp_port *port)
 771 {
 772         TRACE("%p", port);
 773
 774         CHECK_OPEN_PORT();
 775
 776         DEBUG("Closing port %s", port->name);
 777
 778 #ifdef _WIN32
 779         /* Returns non-zero upon success, 0 upon failure. */
 780         if (CloseHandle(port->hdl) == 0)
 781                 RETURN_FAIL("port CloseHandle() failed");
 782         port->hdl = INVALID_HANDLE_VALUE;
 783
 784         /* Close event handles for overlapped structures. */
 785 #define CLOSE_OVERLAPPED(ovl) do { \
 786         if (port->ovl.hEvent != INVALID_HANDLE_VALUE && \
 787                 CloseHandle(port->ovl.hEvent) == 0) \
 788                 RETURN_FAIL(# ovl "event CloseHandle() failed"); \
 789 } while (0)
 790         CLOSE_OVERLAPPED(read_ovl);
 791         CLOSE_OVERLAPPED(write_ovl);
 792         CLOSE_OVERLAPPED(wait_ovl);
 793
 794 #else
 795         /* Returns 0 upon success, -1 upon failure. */
 796         if (close(port->fd) == -1)
 797                 RETURN_FAIL("close() failed");
 798         port->fd = -1;
 799 #endif
 800
 801         RETURN_OK();
 802 }
 803
 804 enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers)
 805 {
 806         TRACE("%p, 0x%x", port, buffers);
 807
 808         CHECK_OPEN_PORT();
 809
 810         if (buffers > SP_BUF_BOTH)
 811                 RETURN_ERROR(SP_ERR_ARG, "Invalid buffer selection");
 812
 813         const char *buffer_names[] = {"no", "input", "output", "both"};
 814
 815         DEBUG("Flushing %s buffers on port %s", buffer_names[buffers], port->name);
 816
 817 #ifdef _WIN32
 818         DWORD flags = 0;
 819         if (buffers & SP_BUF_INPUT)
 820                 flags |= PURGE_RXCLEAR;
 821         if (buffers & SP_BUF_OUTPUT)
 822                 flags |= PURGE_TXCLEAR;
 823
 824         /* Returns non-zero upon success, 0 upon failure. */
 825         if (PurgeComm(port->hdl, flags) == 0)
 826                 RETURN_FAIL("PurgeComm() failed");
 827 #else
 828         int flags = 0;
 829         if (buffers & SP_BUF_BOTH)
 830                 flags = TCIOFLUSH;
 831         else if (buffers & SP_BUF_INPUT)
 832                 flags = TCIFLUSH;
 833         else if (buffers & SP_BUF_OUTPUT)
 834                 flags = TCOFLUSH;
 835
 836         /* Returns 0 upon success, -1 upon failure. */
 837         if (tcflush(port->fd, flags) < 0)
 838                 RETURN_FAIL("tcflush() failed");
 839 #endif
 840         RETURN_OK();
 841 }
 842
 843 enum sp_return sp_drain(struct sp_port *port)
 844 {
 845         TRACE("%p", port);
 846
 847         CHECK_OPEN_PORT();
 848
 849         DEBUG("Draining port %s", port->name);
 850
 851 #ifdef _WIN32
 852         /* Returns non-zero upon success, 0 upon failure. */
 853         if (FlushFileBuffers(port->hdl) == 0)
 854                 RETURN_FAIL("FlushFileBuffers() failed");
 855         RETURN_OK();
 856 #else
 857         int result;
 858         while (1) {
 859 #ifdef __ANDROID__
 860                 int arg = 1;
 861                 result = ioctl(port->fd, TCSBRK, &arg);
 862 #else
 863                 result = tcdrain(port->fd);
 864 #endif
 865                 if (result < 0) {
 866                         if (errno == EINTR) {
 867                                 DEBUG("tcdrain() was interrupted");
 868                                 continue;
 869                         } else {
 870                                 RETURN_FAIL("tcdrain() failed");
 871                         }
 872                 } else {
 873                         RETURN_OK();
 874                 }
 875         }
 876 #endif
 877 }
 878
 879 enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, size_t count, unsigned int timeout)
 880 {
 881         TRACE("%p, %p, %d, %d", port, buf, count, timeout);
 882
 883         CHECK_OPEN_PORT();
 884
 885         if (!buf)
 886                 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
 887
 888         if (timeout)
 889                 DEBUG("Writing %d bytes to port %s, timeout %d ms", count, port->name, timeout);
 890         else
 891                 DEBUG("Writing %d bytes to port %s, no timeout", count, port->name);
 892
 893         if (count == 0)
 894                 RETURN_VALUE("0", 0);
 895
 896 #ifdef _WIN32
 897         DWORD bytes_written = 0;
 898         BOOL result;
 899
 900         /* Wait for previous non-blocking write to complete, if any. */
 901         if (port->writing) {
 902                 DEBUG("Waiting for previous write to complete");
 903                 result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE);
 904                 port->writing = 0;
 905                 if (!result)
 906                         RETURN_FAIL("Previous write failed to complete");
 907                 DEBUG("Previous write completed");
 908         }
 909
 910         /* Set timeout. */
 911         port->timeouts.WriteTotalTimeoutConstant = timeout;
 912         if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
 913                 RETURN_FAIL("SetCommTimeouts() failed");
 914
 915         /* Start write. */
 916         if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl) == 0) {
 917                 if (GetLastError() == ERROR_IO_PENDING) {
 918                         DEBUG("Waiting for write to complete");
 919                         GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE);
 920                         DEBUG("Write completed, %d/%d bytes written", bytes_written, count);
 921                         RETURN_VALUE("%d", bytes_written);
 922                 } else {
 923                         RETURN_FAIL("WriteFile() failed");
 924                 }
 925         } else {
 926                 DEBUG("Write completed immediately");
 927                 RETURN_VALUE("%d", count);
 928         }
 929 #else
 930         size_t bytes_written = 0;
 931         unsigned char *ptr = (unsigned char *) buf;
 932         struct timeval start, delta, now, end = {0, 0};
 933         fd_set fds;
 934         int result;
 935
 936         if (timeout) {
 937                 /* Get time at start of operation. */
 938                 gettimeofday(&start, NULL);
 939                 /* Define duration of timeout. */
 940                 delta.tv_sec = timeout / 1000;
 941                 delta.tv_usec = (timeout % 1000) * 1000;
 942                 /* Calculate time at which we should give up. */
 943                 timeradd(&start, &delta, &end);
 944         }
 945
 946         /* Loop until we have written the requested number of bytes. */
 947         while (bytes_written < count)
 948         {
 949                 /* Wait until space is available. */
 950                 FD_ZERO(&fds);
 951                 FD_SET(port->fd, &fds);
 952                 if (timeout) {
 953                         gettimeofday(&now, NULL);
 954                         if (timercmp(&now, &end, >)) {
 955                                 DEBUG("write timed out");
 956                                 RETURN_VALUE("%d", bytes_written);
 957                         }
 958                         timersub(&end, &now, &delta);
 959                 }
 960                 result = select(port->fd + 1, NULL, &fds, NULL, timeout ? &delta : NULL);
 961                 if (result < 0) {
 962                         if (errno == EINTR) {
 963                                 DEBUG("select() call was interrupted, repeating");
 964                                 continue;
 965                         } else {
 966                                 RETURN_FAIL("select() failed");
 967                         }
 968                 } else if (result == 0) {
 969                         DEBUG("write timed out");
 970                         RETURN_VALUE("%d", bytes_written);
 971                 }
 972
 973                 /* Do write. */
 974                 result = write(port->fd, ptr, count - bytes_written);
 975
 976                 if (result < 0) {
 977                         if (errno == EAGAIN)
 978                                 /* This shouldn't happen because we did a select() first, but handle anyway. */
 979                                 continue;
 980                         else
 981                                 /* This is an actual failure. */
 982                                 RETURN_FAIL("write() failed");
 983                 }
 984
 985                 bytes_written += result;
 986                 ptr += result;
 987         }
 988
 989         RETURN_VALUE("%d", bytes_written);
 990 #endif
 991 }
 992
 993 enum sp_return sp_nonblocking_write(struct sp_port *port, const void *buf, size_t count)
 994 {
 995         TRACE("%p, %p, %d", port, buf, count);
 996
 997         CHECK_OPEN_PORT();
 998
 999         if (!buf)
1000                 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
1001
1002         DEBUG("Writing up to %d bytes to port %s", count, port->name);
1003
1004         if (count == 0)
1005                 RETURN_VALUE("0", 0);
1006
1007 #ifdef _WIN32
1008         DWORD written = 0;
1009         BYTE *ptr = (BYTE *) buf;
1010
1011         /* Check whether previous write is complete. */
1012         if (port->writing) {
1013                 if (HasOverlappedIoCompleted(&port->write_ovl)) {
1014                         DEBUG("Previous write completed");
1015                         port->writing = 0;
1016                 } else {
1017                         DEBUG("Previous write not complete");
1018                         /* Can't take a new write until the previous one finishes. */
1019                         RETURN_VALUE("0", 0);
1020                 }
1021         }
1022
1023         /* Set timeout. */
1024         port->timeouts.WriteTotalTimeoutConstant = 0;
1025         if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
1026                 RETURN_FAIL("SetCommTimeouts() failed");
1027
1028         /* Keep writing data until the OS has to actually start an async IO for it.
1029          * At that point we know the buffer is full. */
1030         while (written < count)
1031         {
1032                 /* Copy first byte of user buffer. */
1033                 port->pending_byte = *ptr++;
1034
1035                 /* Start asynchronous write. */
1036                 if (WriteFile(port->hdl, &port->pending_byte, 1, NULL, &port->write_ovl) == 0) {
1037                         if (GetLastError() == ERROR_IO_PENDING) {
1038                                 if (HasOverlappedIoCompleted(&port->write_ovl)) {
1039                                         DEBUG("Asynchronous write completed immediately");
1040                                         port->writing = 0;
1041                                         written++;
1042                                         continue;
1043                                 } else {
1044                                         DEBUG("Asynchronous write running");
1045                                         port->writing = 1;
1046                                         RETURN_VALUE("%d", ++written);
1047                                 }
1048                         } else {
1049                                 /* Actual failure of some kind. */
1050                                 RETURN_FAIL("WriteFile() failed");
1051                         }
1052                 } else {
1053                         DEBUG("Single byte written immediately");
1054                         written++;
1055                 }
1056         }
1057
1058         DEBUG("All bytes written immediately");
1059
1060         RETURN_VALUE("%d", written);
1061 #else
1062         /* Returns the number of bytes written, or -1 upon failure. */
1063         ssize_t written = write(port->fd, buf, count);
1064
1065         if (written < 0)
1066                 RETURN_FAIL("write() failed");
1067         else
1068                 RETURN_VALUE("%d", written);
1069 #endif
1070 }
1071
1072 enum sp_return sp_blocking_read(struct sp_port *port, void *buf, size_t count, unsigned int timeout)
1073 {
1074         TRACE("%p, %p, %d, %d", port, buf, count, timeout);
1075
1076         CHECK_OPEN_PORT();
1077
1078         if (!buf)
1079                 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
1080
1081         if (timeout)
1082                 DEBUG("Reading %d bytes from port %s, timeout %d ms", count, port->name, timeout);
1083         else
1084                 DEBUG("Reading %d bytes from port %s, no timeout", count, port->name);
1085
1086         if (count == 0)
1087                 RETURN_VALUE("0", 0);
1088
1089 #ifdef _WIN32
1090         DWORD bytes_read = 0;
1091
1092         /* Set timeout. */
1093         port->timeouts.ReadIntervalTimeout = 0;
1094         port->timeouts.ReadTotalTimeoutConstant = timeout;
1095         if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
1096                 RETURN_FAIL("SetCommTimeouts() failed");
1097
1098         /* Start read. */
1099         if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) {
1100                 if (GetLastError() == ERROR_IO_PENDING) {
1101                         DEBUG("Waiting for read to complete");
1102                         GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE);
1103                         DEBUG("Read completed, %d/%d bytes read", bytes_read, count);
1104                 } else {
1105                         RETURN_FAIL("ReadFile() failed");
1106                 }
1107         } else {
1108                 DEBUG("Read completed immediately");
1109                 bytes_read = count;
1110         }
1111
1112         /* Start background operation for subsequent events. */
1113         if (WaitCommEvent(port->hdl, &port->events, &port->wait_ovl) == 0) {
1114                 if (GetLastError() != ERROR_IO_PENDING)
1115                         RETURN_FAIL("WaitCommEvent() failed");
1116         }
1117
1118         RETURN_VALUE("%d", bytes_read);
1119
1120 #else
1121         size_t bytes_read = 0;
1122         unsigned char *ptr = (unsigned char *) buf;
1123         struct timeval start, delta, now, end = {0, 0};
1124         fd_set fds;
1125         int result;
1126
1127         if (timeout) {
1128                 /* Get time at start of operation. */
1129                 gettimeofday(&start, NULL);
1130                 /* Define duration of timeout. */
1131                 delta.tv_sec = timeout / 1000;
1132                 delta.tv_usec = (timeout % 1000) * 1000;
1133                 /* Calculate time at which we should give up. */
1134                 timeradd(&start, &delta, &end);
1135         }
1136
1137         /* Loop until we have the requested number of bytes. */
1138         while (bytes_read < count)
1139         {
1140                 /* Wait until data is available. */
1141                 FD_ZERO(&fds);
1142                 FD_SET(port->fd, &fds);
1143                 if (timeout) {
1144                         gettimeofday(&now, NULL);
1145                         if (timercmp(&now, &end, >))
1146                                 /* Timeout has expired. */
1147                                 RETURN_VALUE("%d", bytes_read);
1148                         timersub(&end, &now, &delta);
1149                 }
1150                 result = select(port->fd + 1, &fds, NULL, NULL, timeout ? &delta : NULL);
1151                 if (result < 0) {
1152                         if (errno == EINTR) {
1153                                 DEBUG("select() call was interrupted, repeating");
1154                                 continue;
1155                         } else {
1156                                 RETURN_FAIL("select() failed");
1157                         }
1158                 } else if (result == 0) {
1159                         DEBUG("read timed out");
1160                         RETURN_VALUE("%d", bytes_read);
1161                 }
1162
1163                 /* Do read. */
1164                 result = read(port->fd, ptr, count - bytes_read);
1165
1166                 if (result < 0) {
1167                         if (errno == EAGAIN)
1168                                 /* This shouldn't happen because we did a select() first, but handle anyway. */
1169                                 continue;
1170                         else
1171                                 /* This is an actual failure. */
1172                                 RETURN_FAIL("read() failed");
1173                 }
1174
1175                 bytes_read += result;
1176                 ptr += result;
1177         }
1178
1179         RETURN_VALUE("%d", bytes_read);
1180 #endif
1181 }
1182
1183 enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, size_t count)
1184 {
1185         TRACE("%p, %p, %d", port, buf, count);
1186
1187         CHECK_OPEN_PORT();
1188
1189         if (!buf)
1190                 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
1191
1192         DEBUG("Reading up to %d bytes from port %s", count, port->name);
1193
1194 #ifdef _WIN32
1195         DWORD bytes_read;
1196
1197         /* Set timeout. */
1198         port->timeouts.ReadIntervalTimeout = MAXDWORD;
1199         port->timeouts.ReadTotalTimeoutConstant = 0;
1200         if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
1201                 RETURN_FAIL("SetCommTimeouts() failed");
1202
1203         /* Do read. */
1204         if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0)
1205                 RETURN_FAIL("ReadFile() failed");
1206
1207         /* Get number of bytes read. */
1208         if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
1209                 RETURN_FAIL("GetOverlappedResult() failed");
1210
1211         if (bytes_read > 0) {
1212                 /* Start background operation for subsequent events. */
1213                 if (WaitCommEvent(port->hdl, &port->events, &port->wait_ovl) == 0) {
1214                         if (GetLastError() != ERROR_IO_PENDING)
1215                                 RETURN_FAIL("WaitCommEvent() failed");
1216                 }
1217         }
1218
1219         RETURN_VALUE("%d", bytes_read);
1220 #else
1221         ssize_t bytes_read;
1222
1223         /* Returns the number of bytes read, or -1 upon failure. */
1224         if ((bytes_read = read(port->fd, buf, count)) < 0) {
1225                 if (errno == EAGAIN)
1226                         /* No bytes available. */
1227                         bytes_read = 0;
1228                 else
1229                         /* This is an actual failure. */
1230                         RETURN_FAIL("read() failed");
1231         }
1232         RETURN_VALUE("%d", bytes_read);
1233 #endif
1234 }
1235
1236 enum sp_return sp_input_waiting(struct sp_port *port)
1237 {
1238         TRACE("%p", port);
1239
1240         CHECK_OPEN_PORT();
1241
1242         DEBUG("Checking input bytes waiting on port %s", port->name);
1243
1244 #ifdef _WIN32
1245         DWORD errors;
1246         COMSTAT comstat;
1247
1248         if (ClearCommError(port->hdl, &errors, &comstat) == 0)
1249                 RETURN_FAIL("ClearCommError() failed");
1250         RETURN_VALUE("%d", comstat.cbInQue);
1251 #else
1252         int bytes_waiting;
1253         if (ioctl(port->fd, TIOCINQ, &bytes_waiting) < 0)
1254                 RETURN_FAIL("TIOCINQ ioctl failed");
1255         RETURN_VALUE("%d", bytes_waiting);
1256 #endif
1257 }
1258
1259 enum sp_return sp_output_waiting(struct sp_port *port)
1260 {
1261         TRACE("%p", port);
1262
1263         CHECK_OPEN_PORT();
1264
1265         DEBUG("Checking output bytes waiting on port %s", port->name);
1266
1267 #ifdef _WIN32
1268         DWORD errors;
1269         COMSTAT comstat;
1270
1271         if (ClearCommError(port->hdl, &errors, &comstat) == 0)
1272                 RETURN_FAIL("ClearCommError() failed");
1273         RETURN_VALUE("%d", comstat.cbOutQue);
1274 #else
1275         int bytes_waiting;
1276         if (ioctl(port->fd, TIOCOUTQ, &bytes_waiting) < 0)
1277                 RETURN_FAIL("TIOCOUTQ ioctl failed");
1278         RETURN_VALUE("%d", bytes_waiting);
1279 #endif
1280 }
1281
1282 enum sp_return sp_new_event_set(struct sp_event_set **result_ptr)
1283 {
1284         struct sp_event_set *result;
1285
1286         TRACE("%p", result_ptr);
1287
1288         if (!result_ptr)
1289                 RETURN_ERROR(SP_ERR_ARG, "Null result");
1290
1291         *result_ptr = NULL;
1292
1293         if (!(result = malloc(sizeof(struct sp_event_set))))
1294                 RETURN_ERROR(SP_ERR_MEM, "sp_event_set malloc() failed");
1295
1296         memset(result, 0, sizeof(struct sp_event_set));
1297
1298         *result_ptr = result;
1299
1300         RETURN_OK();
1301 }
1302
1303 static enum sp_return add_handle(struct sp_event_set *event_set,
1304                 event_handle handle, enum sp_event mask)
1305 {
1306         void *new_handles;
1307         enum sp_event *new_masks;
1308
1309         TRACE("%p, %d, %d", event_set, handle, mask);
1310
1311         if (!(new_handles = realloc(event_set->handles,
1312                         sizeof(event_handle) * (event_set->count + 1))))
1313                 RETURN_ERROR(SP_ERR_MEM, "handle array realloc() failed");
1314
1315         if (!(new_masks = realloc(event_set->masks,
1316                         sizeof(enum sp_event) * (event_set->count + 1))))
1317                 RETURN_ERROR(SP_ERR_MEM, "mask array realloc() failed");
1318
1319         event_set->handles = new_handles;
1320         event_set->masks = new_masks;
1321
1322         ((event_handle *) event_set->handles)[event_set->count] = handle;
1323         event_set->masks[event_set->count] = mask;
1324
1325         event_set->count++;
1326
1327         RETURN_OK();
1328 }
1329
1330 enum sp_return sp_add_port_events(struct sp_event_set *event_set,
1331         const struct sp_port *port, enum sp_event mask)
1332 {
1333         TRACE("%p, %p, %d", event_set, port, mask);
1334
1335         if (!event_set)
1336                 RETURN_ERROR(SP_ERR_ARG, "Null event set");
1337
1338         if (!port)
1339                 RETURN_ERROR(SP_ERR_ARG, "Null port");
1340
1341         if (mask > (SP_EVENT_RX_READY | SP_EVENT_TX_READY | SP_EVENT_ERROR))
1342                 RETURN_ERROR(SP_ERR_ARG, "Invalid event mask");
1343
1344         if (!mask)
1345                 RETURN_OK();
1346
1347 #ifdef _WIN32
1348         enum sp_event handle_mask;
1349         if ((handle_mask = mask & SP_EVENT_TX_READY))
1350                 TRY(add_handle(event_set, port->write_ovl.hEvent, handle_mask));
1351         if ((handle_mask = mask & (SP_EVENT_RX_READY | SP_EVENT_ERROR)))
1352                 TRY(add_handle(event_set, port->wait_ovl.hEvent, handle_mask));
1353 #else
1354         TRY(add_handle(event_set, port->fd, mask));
1355 #endif
1356
1357         RETURN_OK();
1358 }
1359
1360 void sp_free_event_set(struct sp_event_set *event_set)
1361 {
1362         TRACE("%p", event_set);
1363
1364         if (!event_set) {
1365                 DEBUG("Null event set");
1366                 RETURN();
1367         }
1368
1369         DEBUG("Freeing event set");
1370
1371         if (event_set->handles)
1372                 free(event_set->handles);
1373         if (event_set->masks)
1374                 free(event_set->masks);
1375
1376         free(event_set);
1377
1378         RETURN();
1379 }
1380
1381 enum sp_return sp_wait(struct sp_event_set *event_set, unsigned int timeout)
1382 {
1383         TRACE("%p, %d", event_set, timeout);
1384
1385         if (!event_set)
1386                 RETURN_ERROR(SP_ERR_ARG, "Null event set");
1387
1388 #ifdef _WIN32
1389         if (WaitForMultipleObjects(event_set->count, event_set->handles, FALSE,
1390                         timeout ? timeout : INFINITE) == WAIT_FAILED)
1391                 RETURN_FAIL("WaitForMultipleObjects() failed");
1392
1393         RETURN_OK();
1394 #else
1395         struct timeval start, delta, now, end = {0, 0};
1396         int result, timeout_remaining;
1397         struct pollfd *pollfds;
1398         unsigned int i;
1399
1400         if (!(pollfds = malloc(sizeof(struct pollfd) * event_set->count)))
1401                 RETURN_ERROR(SP_ERR_MEM, "pollfds malloc() failed");
1402
1403         for (i = 0; i < event_set->count; i++) {
1404                 pollfds[i].fd = ((int *) event_set->handles)[i];
1405                 pollfds[i].events = 0;
1406                 pollfds[i].revents = 0;
1407                 if (event_set->masks[i] & SP_EVENT_RX_READY)
1408                         pollfds[i].events |= POLLIN;
1409                 if (event_set->masks[i] & SP_EVENT_TX_READY)
1410                         pollfds[i].events |= POLLOUT;
1411                 if (event_set->masks[i] & SP_EVENT_ERROR)
1412                         pollfds[i].events |= POLLERR;
1413         }
1414
1415         if (timeout) {
1416                 /* Get time at start of operation. */
1417                 gettimeofday(&start, NULL);
1418                 /* Define duration of timeout. */
1419                 delta.tv_sec = timeout / 1000;
1420                 delta.tv_usec = (timeout % 1000) * 1000;
1421                 /* Calculate time at which we should give up. */
1422                 timeradd(&start, &delta, &end);
1423         }
1424
1425         /* Loop until an event occurs. */
1426         while (1)
1427         {
1428                 if (timeout) {
1429                         gettimeofday(&now, NULL);
1430                         if (timercmp(&now, &end, >)) {
1431                                 DEBUG("wait timed out");
1432                                 break;
1433                         }
1434                         timersub(&end, &now, &delta);
1435                         timeout_remaining = delta.tv_sec * 1000 + delta.tv_usec / 1000;
1436                 }
1437
1438                 result = poll(pollfds, event_set->count, timeout ? timeout_remaining : -1);
1439
1440                 if (result < 0) {
1441                         if (errno == EINTR) {
1442                                 DEBUG("poll() call was interrupted, repeating");
1443                                 continue;
1444                         } else {
1445                                 free(pollfds);
1446                                 RETURN_FAIL("poll() failed");
1447                         }
1448                 } else if (result == 0) {
1449                         DEBUG("poll() timed out");
1450                         break;
1451                 } else {
1452                         DEBUG("poll() completed");
1453                         break;
1454                 }
1455         }
1456
1457         free(pollfds);
1458         RETURN_OK();
1459 #endif
1460 }
1461
1462 #ifdef __linux__
1463 static enum sp_return get_baudrate(int fd, int *baudrate)
1464 {
1465         void *data;
1466
1467         TRACE("%d, %p", fd, baudrate);
1468
1469         DEBUG("Getting baud rate");
1470
1471         if (!(data = malloc(get_termios_size())))
1472                 RETURN_ERROR(SP_ERR_MEM, "termios malloc failed");
1473
1474         if (ioctl(fd, get_termios_get_ioctl(), data) < 0) {
1475                 free(data);
1476                 RETURN_FAIL("getting termios failed");
1477         }
1478
1479         *baudrate = get_termios_speed(data);
1480
1481         free(data);
1482
1483         RETURN_OK();
1484 }
1485
1486 static enum sp_return set_baudrate(int fd, int baudrate)
1487 {
1488         void *data;
1489
1490         TRACE("%d, %d", fd, baudrate);
1491
1492         DEBUG("Getting baud rate");
1493
1494         if (!(data = malloc(get_termios_size())))
1495                 RETURN_ERROR(SP_ERR_MEM, "termios malloc failed");
1496
1497         if (ioctl(fd, get_termios_get_ioctl(), data) < 0) {
1498                 free(data);
1499                 RETURN_FAIL("getting termios failed");
1500         }
1501
1502         DEBUG("Setting baud rate");
1503
1504         set_termios_speed(data, baudrate);
1505
1506         if (ioctl(fd, get_termios_set_ioctl(), data) < 0) {
1507                 free(data);
1508                 RETURN_FAIL("setting termios failed");
1509         }
1510
1511         free(data);
1512
1513         RETURN_OK();
1514 }
1515
1516 #ifdef USE_TERMIOX
1517 static enum sp_return get_flow(int fd, int *flow)
1518 {
1519         void *data;
1520
1521         TRACE("%d, %p", fd, flow);
1522
1523         DEBUG("Getting advanced flow control");
1524
1525         if (!(data = malloc(get_termiox_size())))
1526                 RETURN_ERROR(SP_ERR_MEM, "termiox malloc failed");
1527
1528         if (ioctl(fd, TCGETX, data) < 0) {
1529                 free(data);
1530                 RETURN_FAIL("getting termiox failed");
1531         }
1532
1533         *flow = get_termiox_flow(data);
1534
1535         free(data);
1536
1537         RETURN_OK();
1538 }
1539
1540 static enum sp_return set_flow(int fd, int flow)
1541 {
1542         void *data;
1543
1544         TRACE("%d, %d", fd, flow);
1545
1546         DEBUG("Getting advanced flow control");
1547
1548         if (!(data = malloc(get_termiox_size())))
1549                 RETURN_ERROR(SP_ERR_MEM, "termiox malloc failed");
1550
1551         if (ioctl(fd, TCGETX, data) < 0) {
1552                 free(data);
1553                 RETURN_FAIL("getting termiox failed");
1554         }
1555
1556         DEBUG("Setting advanced flow control");
1557
1558         set_termiox_flow(data, flow);
1559
1560         if (ioctl(fd, TCSETX, data) < 0) {
1561                 free(data);
1562                 RETURN_FAIL("setting termiox failed");
1563         }
1564
1565         free(data);
1566
1567         RETURN_OK();
1568 }
1569 #endif /* USE_TERMIOX */
1570 #endif /* __linux__ */
1571
1572 static enum sp_return get_config(struct sp_port *port, struct port_data *data,
1573         struct sp_port_config *config)
1574 {
1575         unsigned int i;
1576
1577         TRACE("%p, %p, %p", port, data, config);
1578
1579         DEBUG("Getting configuration for port %s", port->name);
1580
1581 #ifdef _WIN32
1582         if (!GetCommState(port->hdl, &data->dcb))
1583                 RETURN_FAIL("GetCommState() failed");
1584
1585         for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1586                 if (data->dcb.BaudRate == std_baudrates[i].index) {
1587                         config->baudrate = std_baudrates[i].value;
1588                         break;
1589                 }
1590         }
1591
1592         if (i == NUM_STD_BAUDRATES)
1593                 /* BaudRate field can be either an index or a custom baud rate. */
1594                 config->baudrate = data->dcb.BaudRate;
1595
1596         config->bits = data->dcb.ByteSize;
1597
1598         if (data->dcb.fParity)
1599                 switch (data->dcb.Parity) {
1600                 case NOPARITY:
1601                         config->parity = SP_PARITY_NONE;
1602                         break;
1603                 case ODDPARITY:
1604                         config->parity = SP_PARITY_ODD;
1605                         break;
1606                 case EVENPARITY:
1607                         config->parity = SP_PARITY_EVEN;
1608                         break;
1609                 case MARKPARITY:
1610                         config->parity = SP_PARITY_MARK;
1611                         break;
1612                 case SPACEPARITY:
1613                         config->parity = SP_PARITY_SPACE;
1614                         break;
1615                 default:
1616                         config->parity = -1;
1617                 }
1618         else
1619                 config->parity = SP_PARITY_NONE;
1620
1621         switch (data->dcb.StopBits) {
1622         case ONESTOPBIT:
1623                 config->stopbits = 1;
1624                 break;
1625         case TWOSTOPBITS:
1626                 config->stopbits = 2;
1627                 break;
1628         default:
1629                 config->stopbits = -1;
1630         }
1631
1632         switch (data->dcb.fRtsControl) {
1633         case RTS_CONTROL_DISABLE:
1634                 config->rts = SP_RTS_OFF;
1635                 break;
1636         case RTS_CONTROL_ENABLE:
1637                 config->rts = SP_RTS_ON;
1638                 break;
1639         case RTS_CONTROL_HANDSHAKE:
1640                 config->rts = SP_RTS_FLOW_CONTROL;
1641                 break;
1642         default:
1643                 config->rts = -1;
1644         }
1645
1646         config->cts = data->dcb.fOutxCtsFlow ? SP_CTS_FLOW_CONTROL : SP_CTS_IGNORE;
1647
1648         switch (data->dcb.fDtrControl) {
1649         case DTR_CONTROL_DISABLE:
1650                 config->dtr = SP_DTR_OFF;
1651                 break;
1652         case DTR_CONTROL_ENABLE:
1653                 config->dtr = SP_DTR_ON;
1654                 break;
1655         case DTR_CONTROL_HANDSHAKE:
1656                 config->dtr = SP_DTR_FLOW_CONTROL;
1657                 break;
1658         default:
1659                 config->dtr = -1;
1660         }
1661
1662         config->dsr = data->dcb.fOutxDsrFlow ? SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE;
1663
1664         if (data->dcb.fInX) {
1665                 if (data->dcb.fOutX)
1666                         config->xon_xoff = SP_XONXOFF_INOUT;
1667                 else
1668                         config->xon_xoff = SP_XONXOFF_IN;
1669         } else {
1670                 if (data->dcb.fOutX)
1671                         config->xon_xoff = SP_XONXOFF_OUT;
1672                 else
1673                         config->xon_xoff = SP_XONXOFF_DISABLED;
1674         }
1675
1676 #else // !_WIN32
1677
1678         if (tcgetattr(port->fd, &data->term) < 0)
1679                 RETURN_FAIL("tcgetattr() failed");
1680
1681         if (ioctl(port->fd, TIOCMGET, &data->controlbits) < 0)
1682                 RETURN_FAIL("TIOCMGET ioctl failed");
1683
1684 #ifdef USE_TERMIOX
1685         int ret = get_flow(port->fd, &data->flow);
1686
1687         if (ret == SP_ERR_FAIL && errno == EINVAL)
1688                 data->termiox_supported = 0;
1689         else if (ret < 0)
1690                 RETURN_CODEVAL(ret);
1691         else
1692                 data->termiox_supported = 1;
1693 #else
1694         data->termiox_supported = 0;
1695 #endif
1696
1697         for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1698                 if (cfgetispeed(&data->term) == std_baudrates[i].index) {
1699                         config->baudrate = std_baudrates[i].value;
1700                         break;
1701                 }
1702         }
1703
1704         if (i == NUM_STD_BAUDRATES) {
1705 #ifdef __APPLE__
1706                 config->baudrate = (int)data->term.c_ispeed;
1707 #elif defined(__linux__)
1708                 TRY(get_baudrate(port->fd, &config->baudrate));
1709 #else
1710                 config->baudrate = -1;
1711 #endif
1712         }
1713
1714         switch (data->term.c_cflag & CSIZE) {
1715         case CS8:
1716                 config->bits = 8;
1717                 break;
1718         case CS7:
1719                 config->bits = 7;
1720                 break;
1721         case CS6:
1722                 config->bits = 6;
1723                 break;
1724         case CS5:
1725                 config->bits = 5;
1726                 break;
1727         default:
1728                 config->bits = -1;
1729         }
1730
1731         if (!(data->term.c_cflag & PARENB) && (data->term.c_iflag & IGNPAR))
1732                 config->parity = SP_PARITY_NONE;
1733         else if (!(data->term.c_cflag & PARENB) || (data->term.c_iflag & IGNPAR))
1734                 config->parity = -1;
1735 #ifdef CMSPAR
1736         else if (data->term.c_cflag & CMSPAR)
1737                 config->parity = (data->term.c_cflag & PARODD) ? SP_PARITY_MARK : SP_PARITY_SPACE;
1738 #endif
1739         else
1740                 config->parity = (data->term.c_cflag & PARODD) ? SP_PARITY_ODD : SP_PARITY_EVEN;
1741
1742         config->stopbits = (data->term.c_cflag & CSTOPB) ? 2 : 1;
1743
1744         if (data->term.c_cflag & CRTSCTS) {
1745                 config->rts = SP_RTS_FLOW_CONTROL;
1746                 config->cts = SP_CTS_FLOW_CONTROL;
1747         } else {
1748                 if (data->termiox_supported && data->flow & RTS_FLOW)
1749                         config->rts = SP_RTS_FLOW_CONTROL;
1750                 else
1751                         config->rts = (data->controlbits & TIOCM_RTS) ? SP_RTS_ON : SP_RTS_OFF;
1752
1753                 config->cts = (data->termiox_supported && data->flow & CTS_FLOW) ?
1754                         SP_CTS_FLOW_CONTROL : SP_CTS_IGNORE;
1755         }
1756
1757         if (data->termiox_supported && data->flow & DTR_FLOW)
1758                 config->dtr = SP_DTR_FLOW_CONTROL;
1759         else
1760                 config->dtr = (data->controlbits & TIOCM_DTR) ? SP_DTR_ON : SP_DTR_OFF;
1761
1762         config->dsr = (data->termiox_supported && data->flow & DSR_FLOW) ?
1763                 SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE;
1764
1765         if (data->term.c_iflag & IXOFF) {
1766                 if (data->term.c_iflag & IXON)
1767                         config->xon_xoff = SP_XONXOFF_INOUT;
1768                 else
1769                         config->xon_xoff = SP_XONXOFF_IN;
1770         } else {
1771                 if (data->term.c_iflag & IXON)
1772                         config->xon_xoff = SP_XONXOFF_OUT;
1773                 else
1774                         config->xon_xoff = SP_XONXOFF_DISABLED;
1775         }
1776 #endif
1777
1778         RETURN_OK();
1779 }
1780
1781 static enum sp_return set_config(struct sp_port *port, struct port_data *data,
1782         const struct sp_port_config *config)
1783 {
1784         unsigned int i;
1785 #ifdef __APPLE__
1786         BAUD_TYPE baud_nonstd;
1787
1788         baud_nonstd = B0;
1789 #endif
1790 #ifdef __linux__
1791         int baud_nonstd = 0;
1792 #endif
1793
1794         TRACE("%p, %p, %p", port, data, config);
1795
1796         DEBUG("Setting configuration for port %s", port->name);
1797
1798 #ifdef _WIN32
1799         if (config->baudrate >= 0) {
1800                 for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1801                         if (config->baudrate == std_baudrates[i].value) {
1802                                 data->dcb.BaudRate = std_baudrates[i].index;
1803                                 break;
1804                         }
1805                 }
1806
1807                 if (i == NUM_STD_BAUDRATES)
1808                         data->dcb.BaudRate = config->baudrate;
1809         }
1810
1811         if (config->bits >= 0)
1812                 data->dcb.ByteSize = config->bits;
1813
1814         if (config->parity >= 0) {
1815                 switch (config->parity) {
1816                 case SP_PARITY_NONE:
1817                         data->dcb.Parity = NOPARITY;
1818                         break;
1819                 case SP_PARITY_ODD:
1820                         data->dcb.Parity = ODDPARITY;
1821                         break;
1822                 case SP_PARITY_EVEN:
1823                         data->dcb.Parity = EVENPARITY;
1824                         break;
1825                 case SP_PARITY_MARK:
1826                         data->dcb.Parity = MARKPARITY;
1827                         break;
1828                 case SP_PARITY_SPACE:
1829                         data->dcb.Parity = SPACEPARITY;
1830                         break;
1831                 default:
1832                         RETURN_ERROR(SP_ERR_ARG, "Invalid parity setting");
1833                 }
1834         }
1835
1836         if (config->stopbits >= 0) {
1837                 switch (config->stopbits) {
1838                 /* Note: There's also ONE5STOPBITS == 1.5 (unneeded so far). */
1839                 case 1:
1840                         data->dcb.StopBits = ONESTOPBIT;
1841                         break;
1842                 case 2:
1843                         data->dcb.StopBits = TWOSTOPBITS;
1844                         break;
1845                 default:
1846                         RETURN_ERROR(SP_ERR_ARG, "Invalid stop bit setting");
1847                 }
1848         }
1849
1850         if (config->rts >= 0) {
1851                 switch (config->rts) {
1852                 case SP_RTS_OFF:
1853                         data->dcb.fRtsControl = RTS_CONTROL_DISABLE;
1854                         break;
1855                 case SP_RTS_ON:
1856                         data->dcb.fRtsControl = RTS_CONTROL_ENABLE;
1857                         break;
1858                 case SP_RTS_FLOW_CONTROL:
1859                         data->dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
1860                         break;
1861                 default:
1862                         RETURN_ERROR(SP_ERR_ARG, "Invalid RTS setting");
1863                 }
1864         }
1865
1866         if (config->cts >= 0) {
1867                 switch (config->cts) {
1868                 case SP_CTS_IGNORE:
1869                         data->dcb.fOutxCtsFlow = FALSE;
1870                         break;
1871                 case SP_CTS_FLOW_CONTROL:
1872                         data->dcb.fOutxCtsFlow = TRUE;
1873                         break;
1874                 default:
1875                         RETURN_ERROR(SP_ERR_ARG, "Invalid CTS setting");
1876                 }
1877         }
1878
1879         if (config->dtr >= 0) {
1880                 switch (config->dtr) {
1881                 case SP_DTR_OFF:
1882                         data->dcb.fDtrControl = DTR_CONTROL_DISABLE;
1883                         break;
1884                 case SP_DTR_ON:
1885                         data->dcb.fDtrControl = DTR_CONTROL_ENABLE;
1886                         break;
1887                 case SP_DTR_FLOW_CONTROL:
1888                         data->dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
1889                         break;
1890                 default:
1891                         RETURN_ERROR(SP_ERR_ARG, "Invalid DTR setting");
1892                 }
1893         }
1894
1895         if (config->dsr >= 0) {
1896                 switch (config->dsr) {
1897                 case SP_DSR_IGNORE:
1898                         data->dcb.fOutxDsrFlow = FALSE;
1899                         break;
1900                 case SP_DSR_FLOW_CONTROL:
1901                         data->dcb.fOutxDsrFlow = TRUE;
1902                         break;
1903                 default:
1904                         RETURN_ERROR(SP_ERR_ARG, "Invalid DSR setting");
1905                 }
1906         }
1907
1908         if (config->xon_xoff >= 0) {
1909                 switch (config->xon_xoff) {
1910                 case SP_XONXOFF_DISABLED:
1911                         data->dcb.fInX = FALSE;
1912                         data->dcb.fOutX = FALSE;
1913                         break;
1914                 case SP_XONXOFF_IN:
1915                         data->dcb.fInX = TRUE;
1916                         data->dcb.fOutX = FALSE;
1917                         break;
1918                 case SP_XONXOFF_OUT:
1919                         data->dcb.fInX = FALSE;
1920                         data->dcb.fOutX = TRUE;
1921                         break;
1922                 case SP_XONXOFF_INOUT:
1923                         data->dcb.fInX = TRUE;
1924                         data->dcb.fOutX = TRUE;
1925                         break;
1926                 default:
1927                         RETURN_ERROR(SP_ERR_ARG, "Invalid XON/XOFF setting");
1928                 }
1929         }
1930
1931         if (!SetCommState(port->hdl, &data->dcb))
1932                 RETURN_FAIL("SetCommState() failed");
1933
1934 #else /* !_WIN32 */
1935
1936         int controlbits;
1937
1938         if (config->baudrate >= 0) {
1939                 for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1940                         if (config->baudrate == std_baudrates[i].value) {
1941                                 if (cfsetospeed(&data->term, std_baudrates[i].index) < 0)
1942                                         RETURN_FAIL("cfsetospeed() failed");
1943
1944                                 if (cfsetispeed(&data->term, std_baudrates[i].index) < 0)
1945                                         RETURN_FAIL("cfsetispeed() failed");
1946                                 break;
1947                         }
1948                 }
1949
1950                 /* Non-standard baud rate */
1951                 if (i == NUM_STD_BAUDRATES) {
1952 #ifdef __APPLE__
1953                         /* Set "dummy" baud rate. */
1954                         if (cfsetspeed(&data->term, B9600) < 0)
1955                                 RETURN_FAIL("cfsetspeed() failed");
1956                         baud_nonstd = config->baudrate;
1957 #elif defined(__linux__)
1958                         baud_nonstd = 1;
1959 #else
1960                         RETURN_ERROR(SP_ERR_SUPP, "Non-standard baudrate not supported");
1961 #endif
1962                 }
1963         }
1964
1965         if (config->bits >= 0) {
1966                 data->term.c_cflag &= ~CSIZE;
1967                 switch (config->bits) {
1968                 case 8:
1969                         data->term.c_cflag |= CS8;
1970                         break;
1971                 case 7:
1972                         data->term.c_cflag |= CS7;
1973                         break;
1974                 case 6:
1975                         data->term.c_cflag |= CS6;
1976                         break;
1977                 case 5:
1978                         data->term.c_cflag |= CS5;
1979                         break;
1980                 default:
1981                         RETURN_ERROR(SP_ERR_ARG, "Invalid data bits setting");
1982                 }
1983         }
1984
1985         if (config->parity >= 0) {
1986                 data->term.c_iflag &= ~IGNPAR;
1987                 data->term.c_cflag &= ~(PARENB | PARODD);
1988 #ifdef CMSPAR
1989                 data->term.c_cflag &= ~CMSPAR;
1990 #endif
1991                 switch (config->parity) {
1992                 case SP_PARITY_NONE:
1993                         data->term.c_iflag |= IGNPAR;
1994                         break;
1995                 case SP_PARITY_EVEN:
1996                         data->term.c_cflag |= PARENB;
1997                         break;
1998                 case SP_PARITY_ODD:
1999                         data->term.c_cflag |= PARENB | PARODD;
2000                         break;
2001 #ifdef CMSPAR
2002                 case SP_PARITY_MARK:
2003                         data->term.c_cflag |= PARENB | PARODD;
2004                         data->term.c_cflag |= CMSPAR;
2005                         break;
2006                 case SP_PARITY_SPACE:
2007                         data->term.c_cflag |= PARENB;
2008                         data->term.c_cflag |= CMSPAR;
2009                         break;
2010 #else
2011                 case SP_PARITY_MARK:
2012                 case SP_PARITY_SPACE:
2013                         RETURN_ERROR(SP_ERR_SUPP, "Mark/space parity not supported");
2014 #endif
2015                 default:
2016                         RETURN_ERROR(SP_ERR_ARG, "Invalid parity setting");
2017                 }
2018         }
2019
2020         if (config->stopbits >= 0) {
2021                 data->term.c_cflag &= ~CSTOPB;
2022                 switch (config->stopbits) {
2023                 case 1:
2024                         data->term.c_cflag &= ~CSTOPB;
2025                         break;
2026                 case 2:
2027                         data->term.c_cflag |= CSTOPB;
2028                         break;
2029                 default:
2030                         RETURN_ERROR(SP_ERR_ARG, "Invalid stop bits setting");
2031                 }
2032         }
2033
2034         if (config->rts >= 0 || config->cts >= 0) {
2035                 if (data->termiox_supported) {
2036                         data->flow &= ~(RTS_FLOW | CTS_FLOW);
2037                         switch (config->rts) {
2038                         case SP_RTS_OFF:
2039                         case SP_RTS_ON:
2040                                 controlbits = TIOCM_RTS;
2041                                 if (ioctl(port->fd, config->rts == SP_RTS_ON ? TIOCMBIS : TIOCMBIC, &controlbits) < 0)
2042                                         RETURN_FAIL("Setting RTS signal level failed");
2043                                 break;
2044                         case SP_RTS_FLOW_CONTROL:
2045                                 data->flow |= RTS_FLOW;
2046                                 break;
2047                         default:
2048                                 break;
2049                         }
2050                         if (config->cts == SP_CTS_FLOW_CONTROL)
2051                                 data->flow |= CTS_FLOW;
2052
2053                         if (data->flow & (RTS_FLOW | CTS_FLOW))
2054                                 data->term.c_iflag |= CRTSCTS;
2055                         else
2056                                 data->term.c_iflag &= ~CRTSCTS;
2057                 } else {
2058                         /* Asymmetric use of RTS/CTS not supported. */
2059                         if (data->term.c_iflag & CRTSCTS) {
2060                                 /* Flow control can only be disabled for both RTS & CTS together. */
2061                                 if (config->rts >= 0 && config->rts != SP_RTS_FLOW_CONTROL) {
2062                                         if (config->cts != SP_CTS_IGNORE)
2063                                                 RETURN_ERROR(SP_ERR_SUPP, "RTS & CTS flow control must be disabled together");
2064                                 }
2065                                 if (config->cts >= 0 && config->cts != SP_CTS_FLOW_CONTROL) {
2066                                         if (config->rts <= 0 || config->rts == SP_RTS_FLOW_CONTROL)
2067                                                 RETURN_ERROR(SP_ERR_SUPP, "RTS & CTS flow control must be disabled together");
2068                                 }
2069                         } else {
2070                                 /* Flow control can only be enabled for both RTS & CTS together. */
2071                                 if (((config->rts == SP_RTS_FLOW_CONTROL) && (config->cts != SP_CTS_FLOW_CONTROL)) ||
2072                                         ((config->cts == SP_CTS_FLOW_CONTROL) && (config->rts != SP_RTS_FLOW_CONTROL)))
2073                                         RETURN_ERROR(SP_ERR_SUPP, "RTS & CTS flow control must be enabled together");
2074                         }
2075
2076                         if (config->rts >= 0) {
2077                                 if (config->rts == SP_RTS_FLOW_CONTROL) {
2078                                         data->term.c_iflag |= CRTSCTS;
2079                                 } else {
2080                                         controlbits = TIOCM_RTS;
2081                                         if (ioctl(port->fd, config->rts == SP_RTS_ON ? TIOCMBIS : TIOCMBIC,
2082                                                         &controlbits) < 0)
2083                                                 RETURN_FAIL("Setting RTS signal level failed");
2084                                 }
2085                         }
2086                 }
2087         }
2088
2089         if (config->dtr >= 0 || config->dsr >= 0) {
2090                 if (data->termiox_supported) {
2091                         data->flow &= ~(DTR_FLOW | DSR_FLOW);
2092                         switch (config->dtr) {
2093                         case SP_DTR_OFF:
2094                         case SP_DTR_ON:
2095                                 controlbits = TIOCM_DTR;
2096                                 if (ioctl(port->fd, config->dtr == SP_DTR_ON ? TIOCMBIS : TIOCMBIC, &controlbits) < 0)
2097                                         RETURN_FAIL("Setting DTR signal level failed");
2098                                 break;
2099                         case SP_DTR_FLOW_CONTROL:
2100                                 data->flow |= DTR_FLOW;
2101                                 break;
2102                         default:
2103                                 break;
2104                         }
2105                         if (config->dsr == SP_DSR_FLOW_CONTROL)
2106                                 data->flow |= DSR_FLOW;
2107                 } else {
2108                         /* DTR/DSR flow control not supported. */
2109                         if (config->dtr == SP_DTR_FLOW_CONTROL || config->dsr == SP_DSR_FLOW_CONTROL)
2110                                 RETURN_ERROR(SP_ERR_SUPP, "DTR/DSR flow control not supported");
2111
2112                         if (config->dtr >= 0) {
2113                                 controlbits = TIOCM_DTR;
2114                                 if (ioctl(port->fd, config->dtr == SP_DTR_ON ? TIOCMBIS : TIOCMBIC,
2115                                                 &controlbits) < 0)
2116                                         RETURN_FAIL("Setting DTR signal level failed");
2117                         }
2118                 }
2119         }
2120
2121         if (config->xon_xoff >= 0) {
2122                 data->term.c_iflag &= ~(IXON | IXOFF | IXANY);
2123                 switch (config->xon_xoff) {
2124                 case SP_XONXOFF_DISABLED:
2125                         break;
2126                 case SP_XONXOFF_IN:
2127                         data->term.c_iflag |= IXOFF;
2128                         break;
2129                 case SP_XONXOFF_OUT:
2130                         data->term.c_iflag |= IXON | IXANY;
2131                         break;
2132                 case SP_XONXOFF_INOUT:
2133                         data->term.c_iflag |= IXON | IXOFF | IXANY;
2134                         break;
2135                 default:
2136                         RETURN_ERROR(SP_ERR_ARG, "Invalid XON/XOFF setting");
2137                 }
2138         }
2139
2140         if (tcsetattr(port->fd, TCSANOW, &data->term) < 0)
2141                 RETURN_FAIL("tcsetattr() failed");
2142
2143 #ifdef __APPLE__
2144         if (baud_nonstd != B0) {
2145                 if (ioctl(port->fd, IOSSIOSPEED, &baud_nonstd) == -1)
2146                         RETURN_FAIL("IOSSIOSPEED ioctl failed");
2147                 /* Set baud rates in data->term to correct, but incompatible
2148                  * with tcsetattr() value, same as delivered by tcgetattr(). */
2149                 if (cfsetspeed(&data->term, baud_nonstd) < 0)
2150                         RETURN_FAIL("cfsetspeed() failed");
2151         }
2152 #elif defined(__linux__)
2153         if (baud_nonstd)
2154                 TRY(set_baudrate(port->fd, config->baudrate));
2155 #ifdef USE_TERMIOX
2156         if (data->termiox_supported)
2157                 TRY(set_flow(port->fd, data->flow));
2158 #endif
2159 #endif
2160
2161 #endif /* !_WIN32 */
2162
2163         RETURN_OK();
2164 }
2165
2166 enum sp_return sp_new_config(struct sp_port_config **config_ptr)
2167 {
2168         struct sp_port_config *config;
2169
2170         TRACE("%p", config_ptr);
2171
2172         if (!config_ptr)
2173                 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
2174
2175         *config_ptr = NULL;
2176
2177         if (!(config = malloc(sizeof(struct sp_port_config))))
2178                 RETURN_ERROR(SP_ERR_MEM, "config malloc failed");
2179
2180         config->baudrate = -1;
2181         config->bits = -1;
2182         config->parity = -1;
2183         config->stopbits = -1;
2184         config->rts = -1;
2185         config->cts = -1;
2186         config->dtr = -1;
2187         config->dsr = -1;
2188
2189         *config_ptr = config;
2190
2191         RETURN_OK();
2192 }
2193
2194 void sp_free_config(struct sp_port_config *config)
2195 {
2196         TRACE("%p", config);
2197
2198         if (!config)
2199                 DEBUG("Null config");
2200         else
2201                 free(config);
2202
2203         RETURN();
2204 }
2205
2206 enum sp_return sp_get_config(struct sp_port *port, struct sp_port_config *config)
2207 {
2208         struct port_data data;
2209
2210         TRACE("%p, %p", port, config);
2211
2212         CHECK_OPEN_PORT();
2213
2214         if (!config)
2215                 RETURN_ERROR(SP_ERR_ARG, "Null config");
2216
2217         TRY(get_config(port, &data, config));
2218
2219         RETURN_OK();
2220 }
2221
2222 enum sp_return sp_set_config(struct sp_port *port, const struct sp_port_config *config)
2223 {
2224         struct port_data data;
2225         struct sp_port_config prev_config;
2226
2227         TRACE("%p, %p", port, config);
2228
2229         CHECK_OPEN_PORT();
2230
2231         if (!config)
2232                 RETURN_ERROR(SP_ERR_ARG, "Null config");
2233
2234         TRY(get_config(port, &data, &prev_config));
2235         TRY(set_config(port, &data, config));
2236
2237         RETURN_OK();
2238 }
2239
2240 #define CREATE_ACCESSORS(x, type) \
2241 enum sp_return sp_set_##x(struct sp_port *port, type x) { \
2242         struct port_data data; \
2243         struct sp_port_config config; \
2244         TRACE("%p, %d", port, x); \
2245         CHECK_OPEN_PORT(); \
2246         TRY(get_config(port, &data, &config)); \
2247         config.x = x; \
2248         TRY(set_config(port, &data, &config)); \
2249         RETURN_OK(); \
2250 } \
2251 enum sp_return sp_get_config_##x(const struct sp_port_config *config, type *x) { \
2252         TRACE("%p, %p", config, x); \
2253         if (!config) \
2254                 RETURN_ERROR(SP_ERR_ARG, "Null config"); \
2255         *x = config->x; \
2256         RETURN_OK(); \
2257 } \
2258 enum sp_return sp_set_config_##x(struct sp_port_config *config, type x) { \
2259         TRACE("%p, %d", config, x); \
2260         if (!config) \
2261                 RETURN_ERROR(SP_ERR_ARG, "Null config"); \
2262         config->x = x; \
2263         RETURN_OK(); \
2264 }
2265
2266 CREATE_ACCESSORS(baudrate, int)
2267 CREATE_ACCESSORS(bits, int)
2268 CREATE_ACCESSORS(parity, enum sp_parity)
2269 CREATE_ACCESSORS(stopbits, int)
2270 CREATE_ACCESSORS(rts, enum sp_rts)
2271 CREATE_ACCESSORS(cts, enum sp_cts)
2272 CREATE_ACCESSORS(dtr, enum sp_dtr)
2273 CREATE_ACCESSORS(dsr, enum sp_dsr)
2274 CREATE_ACCESSORS(xon_xoff, enum sp_xonxoff)
2275
2276 enum sp_return sp_set_config_flowcontrol(struct sp_port_config *config, enum sp_flowcontrol flowcontrol)
2277 {
2278         if (!config)
2279                 RETURN_ERROR(SP_ERR_ARG, "Null configuration");
2280
2281         if (flowcontrol > SP_FLOWCONTROL_DTRDSR)
2282                 RETURN_ERROR(SP_ERR_ARG, "Invalid flow control setting");
2283
2284         if (flowcontrol == SP_FLOWCONTROL_XONXOFF)
2285                 config->xon_xoff = SP_XONXOFF_INOUT;
2286         else
2287                 config->xon_xoff = SP_XONXOFF_DISABLED;
2288
2289         if (flowcontrol == SP_FLOWCONTROL_RTSCTS) {
2290                 config->rts = SP_RTS_FLOW_CONTROL;
2291                 config->cts = SP_CTS_FLOW_CONTROL;
2292         } else {
2293                 if (config->rts == SP_RTS_FLOW_CONTROL)
2294                         config->rts = SP_RTS_ON;
2295                 config->cts = SP_CTS_IGNORE;
2296         }
2297
2298         if (flowcontrol == SP_FLOWCONTROL_DTRDSR) {
2299                 config->dtr = SP_DTR_FLOW_CONTROL;
2300                 config->dsr = SP_DSR_FLOW_CONTROL;
2301         } else {
2302                 if (config->dtr == SP_DTR_FLOW_CONTROL)
2303                         config->dtr = SP_DTR_ON;
2304                 config->dsr = SP_DSR_IGNORE;
2305         }
2306
2307         RETURN_OK();
2308 }
2309
2310 enum sp_return sp_set_flowcontrol(struct sp_port *port, enum sp_flowcontrol flowcontrol)
2311 {
2312         struct port_data data;
2313         struct sp_port_config config;
2314
2315         TRACE("%p, %d", port, flowcontrol);
2316
2317         CHECK_OPEN_PORT();
2318
2319         TRY(get_config(port, &data, &config));
2320
2321         TRY(sp_set_config_flowcontrol(&config, flowcontrol));
2322
2323         TRY(set_config(port, &data, &config));
2324
2325         RETURN_OK();
2326 }
2327
2328 enum sp_return sp_get_signals(struct sp_port *port, enum sp_signal *signals)
2329 {
2330         TRACE("%p, %p", port, signals);
2331
2332         CHECK_OPEN_PORT();
2333
2334         if (!signals)
2335                 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
2336
2337         DEBUG("Getting control signals for port %s", port->name);
2338
2339         *signals = 0;
2340 #ifdef _WIN32
2341         DWORD bits;
2342         if (GetCommModemStatus(port->hdl, &bits) == 0)
2343                 RETURN_FAIL("GetCommModemStatus() failed");
2344         if (bits & MS_CTS_ON)
2345                 *signals |= SP_SIG_CTS;
2346         if (bits & MS_DSR_ON)
2347                 *signals |= SP_SIG_DSR;
2348         if (bits & MS_RLSD_ON)
2349                 *signals |= SP_SIG_DCD;
2350         if (bits & MS_RING_ON)
2351                 *signals |= SP_SIG_RI;
2352 #else
2353         int bits;
2354         if (ioctl(port->fd, TIOCMGET, &bits) < 0)
2355                 RETURN_FAIL("TIOCMGET ioctl failed");
2356         if (bits & TIOCM_CTS)
2357                 *signals |= SP_SIG_CTS;
2358         if (bits & TIOCM_DSR)
2359                 *signals |= SP_SIG_DSR;
2360         if (bits & TIOCM_CAR)
2361                 *signals |= SP_SIG_DCD;
2362         if (bits & TIOCM_RNG)
2363                 *signals |= SP_SIG_RI;
2364 #endif
2365         RETURN_OK();
2366 }
2367
2368 enum sp_return sp_start_break(struct sp_port *port)
2369 {
2370         TRACE("%p", port);
2371
2372         CHECK_OPEN_PORT();
2373 #ifdef _WIN32
2374         if (SetCommBreak(port->hdl) == 0)
2375                 RETURN_FAIL("SetCommBreak() failed");
2376 #else
2377         if (ioctl(port->fd, TIOCSBRK, 1) < 0)
2378                 RETURN_FAIL("TIOCSBRK ioctl failed");
2379 #endif
2380
2381         RETURN_OK();
2382 }
2383
2384 enum sp_return sp_end_break(struct sp_port *port)
2385 {
2386         TRACE("%p", port);
2387
2388         CHECK_OPEN_PORT();
2389 #ifdef _WIN32
2390         if (ClearCommBreak(port->hdl) == 0)
2391                 RETURN_FAIL("ClearCommBreak() failed");
2392 #else
2393         if (ioctl(port->fd, TIOCCBRK, 1) < 0)
2394                 RETURN_FAIL("TIOCCBRK ioctl failed");
2395 #endif
2396
2397         RETURN_OK();
2398 }
2399
2400 int sp_last_error_code(void)
2401 {
2402         TRACE("");
2403 #ifdef _WIN32
2404         RETURN_VALUE("%d", GetLastError());
2405 #else
2406         RETURN_VALUE("%d", errno);
2407 #endif
2408 }
2409
2410 char *sp_last_error_message(void)
2411 {
2412         TRACE("");
2413
2414 #ifdef _WIN32
2415         LPVOID message;
2416         DWORD error = GetLastError();
2417
2418         FormatMessage(
2419                 FORMAT_MESSAGE_ALLOCATE_BUFFER |
2420                 FORMAT_MESSAGE_FROM_SYSTEM |
2421                 FORMAT_MESSAGE_IGNORE_INSERTS,
2422                 NULL,
2423                 error,
2424                 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
2425                 (LPTSTR) &message,
2426                 0, NULL );
2427
2428         RETURN_VALUE("%s", message);
2429 #else
2430         RETURN_VALUE("%s", strerror(errno));
2431 #endif
2432 }
2433
2434 void sp_free_error_message(char *message)
2435 {
2436         TRACE("%s", message);
2437
2438 #ifdef _WIN32
2439         LocalFree(message);
2440 #else
2441         (void)message;
2442 #endif
2443
2444         RETURN();
2445 }
2446
2447 void sp_set_debug_handler(void (*handler)(const char *format, ...))
2448 {
2449         TRACE("%p", handler);
2450
2451         sp_debug_handler = handler;
2452
2453         RETURN();
2454 }
2455
2456 void sp_default_debug_handler(const char *format, ...)
2457 {
2458         va_list args;
2459         va_start(args, format);
2460         if (getenv("LIBSERIALPORT_DEBUG")) {
2461                 fputs("sp: ", stderr);
2462                 vfprintf(stderr, format, args);
2463         }
2464         va_end(args);
2465 }