serialport.c

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