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