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