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