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