?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved FatalAppExit functions to win32/except.c.
[wine.git] / misc / comm.c
blob6d49786a1615dc94fdd6a77b202ed37a0f39ed12
1 /*
2 * DEC 93 Erik Bos <erik@xs4all.nl>
3 *
4 * Copyright 1996 Marcus Meissner
5 *
6 * Mar 31, 1999. Ove Kåven <ovek@arcticnet.no>
7 * - Implemented buffers and EnableCommNotification.
8 *
9 * Apr 3, 1999. Lawson Whitney <lawson_whitney@juno.com>
10 * - Fixed the modem control part of EscapeCommFunction16.
11 *
12 * Mar 3, 1999. Ove Kåven <ovek@arcticnet.no>
13 * - Use port indices instead of unixfds for win16
14 * - Moved things around (separated win16 and win32 routines)
15 * - Added some hints on how to implement buffers and EnableCommNotification.
16 *
17 * May 26, 1997. Fixes and comments by Rick Richardson <rick@dgii.com> [RER]
18 * - ptr->fd wasn't getting cleared on close.
19 * - GetCommEventMask() and GetCommError() didn't do much of anything.
20 * IMHO, they are still wrong, but they at least implement the RXCHAR
21 * event and return I/O queue sizes, which makes the app I'm interested
22 * in (analog devices EZKIT DSP development system) work.
23 *
24 * August 12, 1997. Take a bash at SetCommEventMask - Lawson Whitney
25 * <lawson_whitney@juno.com>
26 * July 6, 1998. Fixes and comments by Valentijn Sessink
27 * <vsessink@ic.uva.nl> [V]
28 * Oktober 98, Rein Klazes [RHK]
29 * A program that wants to monitor the modem status line (RLSD/DCD) may
30 * poll the modem status register in the commMask structure. I update the bit
31 * in GetCommError, waiting for an implementation of communication events.
32 *
33 */
34
35 #include "config.h"
36
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <termios.h>
40 #include <fcntl.h>
41 #include <string.h>
42 #ifdef HAVE_STRINGS_H
43 # include <strings.h>
44 #endif
45 #include <errno.h>
46 #include <ctype.h>
47 #include <sys/stat.h>
48 #ifdef HAVE_SYS_FILIO_H
49 # include <sys/filio.h>
50 #endif
51 #include <sys/ioctl.h>
52 #include <unistd.h>
53
54 #include "windef.h"
55 #include "wingdi.h"
56 #include "wine/winuser16.h"
57 #include "comm.h"
58 #ifdef HAVE_SYS_MODEM_H
59 # include <sys/modem.h>
60 #endif
61 #ifdef HAVE_SYS_STRTIO_H
62 # include <sys/strtio.h>
63 #endif
64 #include "heap.h"
65 #include "options.h"
66
67 #include "server.h"
68 #include "process.h"
69 #include "winerror.h"
70 #include "services.h"
71 #include "callback.h"
72 #include "file.h"
73
74 #include "debugtools.h"
75
76 DEFAULT_DEBUG_CHANNEL(comm);
77
78 #ifndef TIOCINQ
79 #define TIOCINQ FIONREAD
80 #endif
81 #define COMM_MSR_OFFSET 35 /* see knowledge base Q101417 */
82 #define FLAG_LPT 0x80
83
84 struct DosDeviceStruct COM[MAX_PORTS];
85 struct DosDeviceStruct LPT[MAX_PORTS];
86 /* pointers to unknown(==undocumented) comm structure */
87 LPCVOID *unknown[MAX_PORTS];
88 /* save terminal states */
89 static struct termios m_stat[MAX_PORTS];
90
91 void COMM_Init(void)
92 {
93 int x;
94 char option[10], temp[256], *btemp;
95 struct stat st;
96
97 for (x=0; x!=MAX_PORTS; x++) {
98 strcpy(option,"COMx");
99 option[3] = '1' + x;
100 option[4] = '\0';
101
102 PROFILE_GetWineIniString( "serialports", option, "*",
103 temp, sizeof(temp) );
104 if (!strcmp(temp, "*") || *temp == '\0')
105 COM[x].devicename = NULL;
106 else {
107 btemp = strchr(temp,',');
108 if (btemp != NULL) {
109 *btemp++ = '\0';
110 COM[x].baudrate = atoi(btemp);
111 } else {
112 COM[x].baudrate = -1;
113 }
114 stat(temp, &st);
115 if (!S_ISCHR(st.st_mode))
116 WARN("Can't use `%s' as %s !\n", temp, option);
117 else
118 if ((COM[x].devicename = malloc(strlen(temp)+1)) == NULL)
119 WARN("Can't malloc for device info!\n");
120 else {
121 COM[x].fd = 0;
122 strcpy(COM[x].devicename, temp);
123 }
124 TRACE("%s = %s\n", option, COM[x].devicename);
125 }
126
127 strcpy(option, "LPTx");
128 option[3] = '1' + x;
129 option[4] = '\0';
130
131 PROFILE_GetWineIniString( "parallelports", option, "*",
132 temp, sizeof(temp) );
133 if (!strcmp(temp, "*") || *temp == '\0')
134 LPT[x].devicename = NULL;
135 else {
136 stat(temp, &st);
137 if (!S_ISCHR(st.st_mode))
138 WARN("Can't use `%s' as %s !\n", temp, option);
139 else
140 if ((LPT[x].devicename = malloc(strlen(temp)+1)) == NULL)
141 WARN("Can't malloc for device info!\n");
142 else {
143 LPT[x].fd = 0;
144 strcpy(LPT[x].devicename, temp);
145 }
146 TRACE("%s = %s\n", option, LPT[x].devicename);
147 }
148
149 }
150 }
151
152
153 static struct DosDeviceStruct *GetDeviceStruct(int fd)
154 {
155 if ((fd&0x7F)<=MAX_PORTS) {
156 if (!(fd&FLAG_LPT)) {
157 if (COM[fd].fd)
158 return &COM[fd];
159 } else {
160 fd &= 0x7f;
161 if (LPT[fd].fd)
162 return &LPT[fd];
163 }
164 }
165
166 return NULL;
167 }
168
169 static int GetCommPort_fd(int fd)
170 {
171 int x;
172
173 for (x=0; x<MAX_PORTS; x++) {
174 if (COM[x].fd == fd)
175 return x;
176 }
177
178 return -1;
179 }
180
181 static int ValidCOMPort(int x)
182 {
183 return(x < MAX_PORTS ? (int) COM[x].devicename : 0);
184 }
185
186 static int ValidLPTPort(int x)
187 {
188 return(x < MAX_PORTS ? (int) LPT[x].devicename : 0);
189 }
190
191 static int WinError(void)
192 {
193 TRACE("errno = %d\n", errno);
194 switch (errno) {
195 default:
196 return CE_IOE;
197 }
198 }
199
200 static unsigned comm_inbuf(struct DosDeviceStruct *ptr)
201 {
202 return ((ptr->ibuf_tail > ptr->ibuf_head) ? ptr->ibuf_size : 0)
203 + ptr->ibuf_head - ptr->ibuf_tail;
204 }
205
206 static unsigned comm_outbuf(struct DosDeviceStruct *ptr)
207 {
208 return ((ptr->obuf_tail > ptr->obuf_head) ? ptr->obuf_size : 0)
209 + ptr->obuf_head - ptr->obuf_tail;
210 }
211
212 static int COMM_WhackModem(int fd, unsigned int andy, unsigned int orrie)
213 {
214 unsigned int mstat, okay;
215 okay = ioctl(fd, TIOCMGET, &mstat);
216 if (okay) return okay;
217 if (andy) mstat &= andy;
218 mstat |= orrie;
219 return ioctl(fd, TIOCMSET, &mstat);
220 }
221
222 static void CALLBACK comm_notification( ULONG_PTR private )
223 {
224 struct DosDeviceStruct *ptr = (struct DosDeviceStruct *)private;
225 int prev, bleft, len;
226 WORD mask = 0;
227 int cid = GetCommPort_fd(ptr->fd);
228
229 TRACE("async notification\n");
230 /* read data from comm port */
231 prev = comm_inbuf(ptr);
232 do {
233 bleft = ((ptr->ibuf_tail > ptr->ibuf_head) ? (ptr->ibuf_tail-1) : ptr->ibuf_size)
234 - ptr->ibuf_head;
235 len = read(ptr->fd, ptr->inbuf + ptr->ibuf_head, bleft?bleft:1);
236 if (len > 0) {
237 if (!bleft) {
238 ptr->commerror = CE_RXOVER;
239 } else {
240 /* check for events */
241 if ((ptr->eventmask & EV_RXFLAG) &&
242 memchr(ptr->inbuf + ptr->ibuf_head, ptr->evtchar, len)) {
243 *(WORD*)(unknown[cid]) |= EV_RXFLAG;
244 mask |= CN_EVENT;
245 }
246 if (ptr->eventmask & EV_RXCHAR) {
247 *(WORD*)(unknown[cid]) |= EV_RXCHAR;
248 mask |= CN_EVENT;
249 }
250 /* advance buffer position */
251 ptr->ibuf_head += len;
252 if (ptr->ibuf_head >= ptr->ibuf_size)
253 ptr->ibuf_head = 0;
254 }
255 }
256 } while (len > 0);
257 /* check for notification */
258 if (ptr->wnd && (ptr->n_read>0) && (prev<ptr->n_read) &&
259 (comm_inbuf(ptr)>=ptr->n_read)) {
260 /* passed the receive notification threshold */
261 mask |= CN_RECEIVE;
262 }
263
264 /* write any TransmitCommChar character */
265 if (ptr->xmit>=0) {
266 len = write(ptr->fd, &(ptr->xmit), 1);
267 if (len > 0) ptr->xmit = -1;
268 }
269 /* write from output queue */
270 prev = comm_outbuf(ptr);
271 do {
272 bleft = ((ptr->obuf_tail <= ptr->obuf_head) ? ptr->obuf_head : ptr->obuf_size)
273 - ptr->obuf_tail;
274 len = bleft ? write(ptr->fd, ptr->outbuf + ptr->obuf_tail, bleft) : 0;
275 if (len > 0) {
276 ptr->obuf_tail += len;
277 if (ptr->obuf_tail >= ptr->obuf_size)
278 ptr->obuf_tail = 0;
279 /* flag event */
280 if (ptr->obuf_tail == ptr->obuf_head) {
281 if (ptr->s_write) {
282 SERVICE_Delete( ptr->s_write );
283 ptr->s_write = INVALID_HANDLE_VALUE;
284 }
285 if (ptr->eventmask & EV_TXEMPTY) {
286 *(WORD*)(unknown[cid]) |= EV_TXEMPTY;
287 mask |= CN_EVENT;
288 }
289 }
290 }
291 } while (len > 0);
292 /* check for notification */
293 if (ptr->wnd && (ptr->n_write>0) && (prev>=ptr->n_write) &&
294 (comm_outbuf(ptr)<ptr->n_write)) {
295 /* passed the transmit notification threshold */
296 mask |= CN_TRANSMIT;
297 }
298
299 /* send notifications, if any */
300 if (ptr->wnd && mask) {
301 TRACE("notifying %04x: cid=%d, mask=%02x\n", ptr->wnd, cid, mask);
302 Callout.PostMessage16(ptr->wnd, WM_COMMNOTIFY, cid, mask);
303 }
304 }
305
306 static void comm_waitread(struct DosDeviceStruct *ptr)
307 {
308 if (ptr->s_read != INVALID_HANDLE_VALUE) return;
309 ptr->s_read = SERVICE_AddObject( FILE_DupUnixHandle( ptr->fd,
310 GENERIC_READ | SYNCHRONIZE ),
311 comm_notification,
312 (ULONG_PTR)ptr );
313 }
314
315 static void comm_waitwrite(struct DosDeviceStruct *ptr)
316 {
317 if (ptr->s_write != INVALID_HANDLE_VALUE) return;
318 ptr->s_write = SERVICE_AddObject( FILE_DupUnixHandle( ptr->fd,
319 GENERIC_WRITE | SYNCHRONIZE ),
320 comm_notification,
321 (ULONG_PTR)ptr );
322 }
323
324 /**************************************************************************
325 * BuildCommDCB (USER.213)
326 */
327 BOOL16 WINAPI BuildCommDCB16(LPCSTR device, LPDCB16 lpdcb)
328 {
329 /* "COM1:9600,n,8,1" */
330 /* 012345 */
331 int port;
332 char *ptr, temp[256];
333
334 TRACE("(%s), ptr %p\n", device, lpdcb);
335
336 if (!lstrncmpiA(device,"COM",3)) {
337 port = device[3] - '0';
338
339
340 if (port-- == 0) {
341 ERR("BUG ! COM0 can't exist!.\n");
342 return -1;
343 }
344
345 if (!ValidCOMPort(port)) {
346 FIXME("invalid COM port %d?\n",port);
347 return -1;
348 }
349
350 memset(lpdcb, 0, sizeof(DCB16)); /* initialize */
351
352 lpdcb->Id = port;
353
354 if (!*(device+4))
355 return 0;
356
357 if (*(device+4) != ':')
358 return -1;
359
360 strcpy(temp,device+5);
361 ptr = strtok(temp, ", ");
362
363 if (COM[port].baudrate > 0)
364 lpdcb->BaudRate = COM[port].baudrate;
365 else
366 lpdcb->BaudRate = atoi(ptr);
367 TRACE("baudrate (%d)\n", lpdcb->BaudRate);
368
369 ptr = strtok(NULL, ", ");
370 if (islower(*ptr))
371 *ptr = toupper(*ptr);
372
373 TRACE("parity (%c)\n", *ptr);
374 lpdcb->fParity = TRUE;
375 switch (*ptr) {
376 case 'N':
377 lpdcb->Parity = NOPARITY;
378 lpdcb->fParity = FALSE;
379 break;
380 case 'E':
381 lpdcb->Parity = EVENPARITY;
382 break;
383 case 'M':
384 lpdcb->Parity = MARKPARITY;
385 break;
386 case 'O':
387 lpdcb->Parity = ODDPARITY;
388 break;
389 default:
390 WARN("Unknown parity `%c'!\n", *ptr);
391 return -1;
392 }
393
394 ptr = strtok(NULL, ", ");
395 TRACE("charsize (%c)\n", *ptr);
396 lpdcb->ByteSize = *ptr - '0';
397
398 ptr = strtok(NULL, ", ");
399 TRACE("stopbits (%c)\n", *ptr);
400 switch (*ptr) {
401 case '1':
402 lpdcb->StopBits = ONESTOPBIT;
403 break;
404 case '2':
405 lpdcb->StopBits = TWOSTOPBITS;
406 break;
407 default:
408 WARN("Unknown # of stopbits `%c'!\n", *ptr);
409 return -1;
410 }
411 }
412
413 return 0;
414 }
415
416 /*****************************************************************************
417 * OpenComm (USER.200)
418 */
419 INT16 WINAPI OpenComm16(LPCSTR device,UINT16 cbInQueue,UINT16 cbOutQueue)
420 {
421 int port,fd;
422
423 TRACE("%s, %d, %d\n", device, cbInQueue, cbOutQueue);
424
425 if (strlen(device) < 4)
426 return IE_BADID;
427
428 port = device[3] - '0';
429
430 if (port-- == 0)
431 ERR("BUG ! COM0 or LPT0 don't exist !\n");
432
433 if (!lstrncmpiA(device,"COM",3)) {
434
435 TRACE("%s = %s\n", device, COM[port].devicename);
436
437 if (!ValidCOMPort(port))
438 return IE_BADID;
439
440 if (COM[port].fd)
441 return IE_OPEN;
442
443 fd = open(COM[port].devicename, O_RDWR | O_NONBLOCK);
444 if (fd == -1) {
445 ERR("error=%d\n", errno);
446 return IE_HARDWARE;
447 } else {
448 unknown[port] = SEGPTR_ALLOC(40);
449 bzero(unknown[port],40);
450 COM[port].fd = fd;
451 COM[port].commerror = 0;
452 COM[port].eventmask = 0;
453 COM[port].evtchar = 0; /* FIXME: default? */
454 /* save terminal state */
455 tcgetattr(fd,&m_stat[port]);
456 /* set default parameters */
457 if(COM[port].baudrate>-1){
458 DCB16 dcb;
459 GetCommState16(port, &dcb);
460 dcb.BaudRate=COM[port].baudrate;
461 /* more defaults:
462 * databits, parity, stopbits
463 */
464 SetCommState16( &dcb);
465 }
466 /* init priority characters */
467 COM[port].unget = -1;
468 COM[port].xmit = -1;
469 /* allocate buffers */
470 COM[port].ibuf_size = cbInQueue;
471 COM[port].ibuf_head = COM[port].ibuf_tail= 0;
472 COM[port].obuf_size = cbOutQueue;
473 COM[port].obuf_head = COM[port].obuf_tail = 0;
474
475 COM[port].inbuf = malloc(cbInQueue);
476 if (COM[port].inbuf) {
477 COM[port].outbuf = malloc(cbOutQueue);
478 if (!COM[port].outbuf)
479 free(COM[port].inbuf);
480 } else COM[port].outbuf = NULL;
481 if (!COM[port].outbuf) {
482 /* not enough memory */
483 tcsetattr(COM[port].fd,TCSANOW,&m_stat[port]);
484 close(COM[port].fd);
485 ERR("out of memory");
486 return IE_MEMORY;
487 }
488
489 COM[port].s_read = INVALID_HANDLE_VALUE;
490 COM[port].s_write = INVALID_HANDLE_VALUE;
491 comm_waitread( &COM[port] );
492 return port;
493 }
494 }
495 else
496 if (!lstrncmpiA(device,"LPT",3)) {
497
498 if (!ValidLPTPort(port))
499 return IE_BADID;
500
501 if (LPT[port].fd)
502 return IE_OPEN;
503
504 fd = open(LPT[port].devicename, O_RDWR | O_NONBLOCK, 0);
505 if (fd == -1) {
506 return IE_HARDWARE;
507 } else {
508 LPT[port].fd = fd;
509 LPT[port].commerror = 0;
510 LPT[port].eventmask = 0;
511 return port|FLAG_LPT;
512 }
513 }
514 return 0;
515 }
516
517 /*****************************************************************************
518 * CloseComm (USER.207)
519 */
520 INT16 WINAPI CloseComm16(INT16 cid)
521 {
522 struct DosDeviceStruct *ptr;
523
524 TRACE("cid=%d\n", cid);
525 if ((ptr = GetDeviceStruct(cid)) == NULL) {
526 FIXME("no cid=%d found!\n", cid);
527 return -1;
528 }
529 if (!(cid&FLAG_LPT)) {
530 /* COM port */
531 SEGPTR_FREE(unknown[cid]); /* [LW] */
532
533 SERVICE_Delete( COM[cid].s_write );
534 SERVICE_Delete( COM[cid].s_read );
535 /* free buffers */
536 free(ptr->outbuf);
537 free(ptr->inbuf);
538
539 /* reset modem lines */
540 tcsetattr(ptr->fd,TCSANOW,&m_stat[cid]);
541 }
542
543 if (close(ptr->fd) == -1) {
544 ptr->commerror = WinError();
545 /* FIXME: should we clear ptr->fd here? */
546 return -1;
547 } else {
548 ptr->commerror = 0;
549 ptr->fd = 0;
550 return 0;
551 }
552 }
553
554 /*****************************************************************************
555 * SetCommBreak (USER.210)
556 */
557 INT16 WINAPI SetCommBreak16(INT16 cid)
558 {
559 struct DosDeviceStruct *ptr;
560
561 TRACE("cid=%d\n", cid);
562 if ((ptr = GetDeviceStruct(cid)) == NULL) {
563 FIXME("no cid=%d found!\n", cid);
564 return -1;
565 }
566
567 ptr->suspended = 1;
568 ptr->commerror = 0;
569 return 0;
570 }
571
572 /*****************************************************************************
573 * ClearCommBreak (USER.211)
574 */
575 INT16 WINAPI ClearCommBreak16(INT16 cid)
576 {
577 struct DosDeviceStruct *ptr;
578
579 TRACE("cid=%d\n", cid);
580 if (!(ptr = GetDeviceStruct(cid))) {
581 FIXME("no cid=%d found!\n", cid);
582 return -1;
583 }
584 ptr->suspended = 0;
585 ptr->commerror = 0;
586 return 0;
587 }
588
589 /*****************************************************************************
590 * EscapeCommFunction (USER.214)
591 */
592 LONG WINAPI EscapeCommFunction16(UINT16 cid,UINT16 nFunction)
593 {
594 int max;
595 struct DosDeviceStruct *ptr;
596 struct termios port;
597
598 TRACE("cid=%d, function=%d\n", cid, nFunction);
599 if ((nFunction != GETMAXCOM) && (nFunction != GETMAXLPT)) {
600 if ((ptr = GetDeviceStruct(cid)) == NULL) {
601 FIXME("no cid=%d found!\n", cid);
602 return -1;
603 }
604 if (tcgetattr(ptr->fd,&port) == -1) {
605 TRACE("tcgetattr failed\n");
606 ptr->commerror=WinError();
607 return -1;
608 }
609 } else ptr = NULL;
610
611 switch (nFunction) {
612 case RESETDEV:
613 TRACE("RESETDEV\n");
614 break;
615
616 case GETMAXCOM:
617 TRACE("GETMAXCOM\n");
618 for (max = MAX_PORTS;!COM[max].devicename;max--)
619 ;
620 return max;
621 break;
622
623 case GETMAXLPT:
624 TRACE("GETMAXLPT\n");
625 for (max = MAX_PORTS;!LPT[max].devicename;max--)
626 ;
627 return FLAG_LPT + max;
628 break;
629
630 case GETBASEIRQ:
631 TRACE("GETBASEIRQ\n");
632 /* FIXME: use tables */
633 /* just fake something for now */
634 if (cid & FLAG_LPT) {
635 /* LPT1: irq 7, LPT2: irq 5 */
636 return (cid & 0x7f) ? 5 : 7;
637 } else {
638 /* COM1: irq 4, COM2: irq 3,
639 COM3: irq 4, COM4: irq 3 */
640 return 4 - (cid & 1);
641 }
642 break;
643
644 case CLRDTR:
645 TRACE("CLRDTR\n");
646 #ifdef TIOCM_DTR
647 return COMM_WhackModem(ptr->fd, ~TIOCM_DTR, 0);
648 #endif
649 case CLRRTS:
650 TRACE("CLRRTS\n");
651 #ifdef TIOCM_RTS
652 return COMM_WhackModem(ptr->fd, ~TIOCM_RTS, 0);
653 #endif
654
655 case SETDTR:
656 TRACE("SETDTR\n");
657 #ifdef TIOCM_DTR
658 return COMM_WhackModem(ptr->fd, 0, TIOCM_DTR);
659 #endif
660
661 case SETRTS:
662 TRACE("SETRTS\n");
663 #ifdef TIOCM_RTS
664 return COMM_WhackModem(ptr->fd, 0, TIOCM_RTS);
665 #endif
666
667 case SETXOFF:
668 TRACE("SETXOFF\n");
669 port.c_iflag |= IXOFF;
670 break;
671
672 case SETXON:
673 TRACE("SETXON\n");
674 port.c_iflag |= IXON;
675 break;
676
677 default:
678 WARN("(cid=%d,nFunction=%d): Unknown function\n",
679 cid, nFunction);
680 break;
681 }
682
683 if (tcsetattr(ptr->fd, TCSADRAIN, &port) == -1) {
684 ptr->commerror = WinError();
685 return -1;
686 } else {
687 ptr->commerror = 0;
688 return 0;
689 }
690 }
691
692 /*****************************************************************************
693 * FlushComm (USER.215)
694 */
695 INT16 WINAPI FlushComm16(INT16 cid,INT16 fnQueue)
696 {
697 int queue;
698 struct DosDeviceStruct *ptr;
699
700 TRACE("cid=%d, queue=%d\n", cid, fnQueue);
701 if ((ptr = GetDeviceStruct(cid)) == NULL) {
702 FIXME("no cid=%d found!\n", cid);
703 return -1;
704 }
705 switch (fnQueue) {
706 case 0:
707 queue = TCOFLUSH;
708 ptr->obuf_tail = ptr->obuf_head;
709 break;
710 case 1:
711 queue = TCIFLUSH;
712 ptr->ibuf_head = ptr->ibuf_tail;
713 break;
714 default:
715 WARN("(cid=%d,fnQueue=%d):Unknown queue\n",
716 cid, fnQueue);
717 return -1;
718 }
719 if (tcflush(ptr->fd, queue)) {
720 ptr->commerror = WinError();
721 return -1;
722 } else {
723 ptr->commerror = 0;
724 return 0;
725 }
726 }
727
728 /********************************************************************
729 * GetCommError (USER.203)
730 */
731 INT16 WINAPI GetCommError16(INT16 cid,LPCOMSTAT16 lpStat)
732 {
733 int temperror;
734 struct DosDeviceStruct *ptr;
735 unsigned char *stol;
736 unsigned int mstat;
737
738 if ((ptr = GetDeviceStruct(cid)) == NULL) {
739 FIXME("no handle for cid = %0x!.\n",cid);
740 return -1;
741 }
742 if (cid&FLAG_LPT) {
743 WARN(" cid %d not comm port\n",cid);
744 return CE_MODE;
745 }
746 stol = (unsigned char *)unknown[cid] + COMM_MSR_OFFSET;
747 ioctl(ptr->fd,TIOCMGET,&mstat);
748 if( mstat&TIOCM_CAR )
749 *stol |= 0x80;
750 else
751 *stol &=0x7f;
752
753 if (lpStat) {
754 lpStat->status = 0;
755
756 lpStat->cbOutQue = comm_outbuf(ptr);
757 lpStat->cbInQue = comm_inbuf(ptr);
758
759 TRACE("cid %d, error %d, lpStat %d %d %d stol %x\n",
760 cid, ptr->commerror, lpStat->status, lpStat->cbInQue,
761 lpStat->cbOutQue, *stol);
762 }
763 else
764 TRACE("cid %d, error %d, lpStat NULL stol %x\n",
765 cid, ptr->commerror, *stol);
766
767 /* Return any errors and clear it */
768 temperror = ptr->commerror;
769 ptr->commerror = 0;
770 return(temperror);
771 }
772
773 /*****************************************************************************
774 * SetCommEventMask (USER.208)
775 */
776 SEGPTR WINAPI SetCommEventMask16(INT16 cid,UINT16 fuEvtMask)
777 {
778 struct DosDeviceStruct *ptr;
779 unsigned char *stol;
780 int repid;
781 unsigned int mstat;
782
783 TRACE("cid %d,mask %d\n",cid,fuEvtMask);
784 if ((ptr = GetDeviceStruct(cid)) == NULL) {
785 FIXME("no handle for cid = %0x!.\n",cid);
786 return (SEGPTR)NULL;
787 }
788
789 ptr->eventmask = fuEvtMask;
790
791 if ((cid&FLAG_LPT) || !ValidCOMPort(cid)) {
792 WARN(" cid %d not comm port\n",cid);
793 return (SEGPTR)NULL;
794 }
795 /* it's a COM port ? -> modify flags */
796 stol = (unsigned char *)unknown[cid] + COMM_MSR_OFFSET;
797 repid = ioctl(ptr->fd,TIOCMGET,&mstat);
798 TRACE(" ioctl %d, msr %x at %p %p\n",repid,mstat,stol,unknown[cid]);
799 if ((mstat&TIOCM_CAR))
800 *stol |= 0x80;
801 else
802 *stol &=0x7f;
803
804 TRACE(" modem dcd construct %x\n",*stol);
805 return SEGPTR_GET(unknown[cid]);
806 }
807
808 /*****************************************************************************
809 * GetCommEventMask (USER.209)
810 */
811 UINT16 WINAPI GetCommEventMask16(INT16 cid,UINT16 fnEvtClear)
812 {
813 struct DosDeviceStruct *ptr;
814 WORD events;
815
816 TRACE("cid %d, mask %d\n", cid, fnEvtClear);
817 if ((ptr = GetDeviceStruct(cid)) == NULL) {
818 FIXME("no handle for cid = %0x!.\n",cid);
819 return 0;
820 }
821
822 if ((cid&FLAG_LPT) || !ValidCOMPort(cid)) {
823 WARN(" cid %d not comm port\n",cid);
824 return 0;
825 }
826
827 events = *(WORD*)(unknown[cid]) & fnEvtClear;
828 *(WORD*)(unknown[cid]) &= ~fnEvtClear;
829 return events;
830 }
831
832 /*****************************************************************************
833 * SetCommState16 (USER.201)
834 */
835 INT16 WINAPI SetCommState16(LPDCB16 lpdcb)
836 {
837 struct termios port;
838 struct DosDeviceStruct *ptr;
839
840 TRACE("cid %d, ptr %p\n", lpdcb->Id, lpdcb);
841 if ((ptr = GetDeviceStruct(lpdcb->Id)) == NULL) {
842 FIXME("no handle for cid = %0x!.\n",lpdcb->Id);
843 return -1;
844 }
845 if (tcgetattr(ptr->fd, &port) == -1) {
846 ptr->commerror = WinError();
847 return -1;
848 }
849
850 port.c_cc[VMIN] = 0;
851 port.c_cc[VTIME] = 1;
852
853 #ifdef IMAXBEL
854 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
855 #else
856 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
857 #endif
858 port.c_iflag |= (IGNBRK);
859
860 port.c_oflag &= ~(OPOST);
861
862 port.c_cflag &= ~(HUPCL);
863 port.c_cflag |= CLOCAL | CREAD;
864
865 port.c_lflag &= ~(ICANON|ECHO|ISIG);
866 port.c_lflag |= NOFLSH;
867
868 TRACE("baudrate %d\n",lpdcb->BaudRate);
869 #ifdef CBAUD
870 port.c_cflag &= ~CBAUD;
871 switch (lpdcb->BaudRate) {
872 case 110:
873 case CBR_110:
874 port.c_cflag |= B110;
875 break;
876 case 300:
877 case CBR_300:
878 port.c_cflag |= B300;
879 break;
880 case 600:
881 case CBR_600:
882 port.c_cflag |= B600;
883 break;
884 case 1200:
885 case CBR_1200:
886 port.c_cflag |= B1200;
887 break;
888 case 2400:
889 case CBR_2400:
890 port.c_cflag |= B2400;
891 break;
892 case 4800:
893 case CBR_4800:
894 port.c_cflag |= B4800;
895 break;
896 case 9600:
897 case CBR_9600:
898 port.c_cflag |= B9600;
899 break;
900 case 19200:
901 case CBR_19200:
902 port.c_cflag |= B19200;
903 break;
904 case 38400:
905 case CBR_38400:
906 port.c_cflag |= B38400;
907 break;
908 #ifdef B57600
909 case 57600:
910 port.c_cflag |= B57600;
911 break;
912 #endif
913 #ifdef B115200
914 case 57601:
915 port.c_cflag |= B115200;
916 break;
917 #endif
918 default:
919 ptr->commerror = IE_BAUDRATE;
920 return -1;
921 }
922 #elif !defined(__EMX__)
923 switch (lpdcb->BaudRate) {
924 case 110:
925 case CBR_110:
926 port.c_ospeed = B110;
927 break;
928 case 300:
929 case CBR_300:
930 port.c_ospeed = B300;
931 break;
932 case 600:
933 case CBR_600:
934 port.c_ospeed = B600;
935 break;
936 case 1200:
937 case CBR_1200:
938 port.c_ospeed = B1200;
939 break;
940 case 2400:
941 case CBR_2400:
942 port.c_ospeed = B2400;
943 break;
944 case 4800:
945 case CBR_4800:
946 port.c_ospeed = B4800;
947 break;
948 case 9600:
949 case CBR_9600:
950 port.c_ospeed = B9600;
951 break;
952 case 19200:
953 case CBR_19200:
954 port.c_ospeed = B19200;
955 break;
956 case 38400:
957 case CBR_38400:
958 port.c_ospeed = B38400;
959 break;
960 default:
961 ptr->commerror = IE_BAUDRATE;
962 return -1;
963 }
964 port.c_ispeed = port.c_ospeed;
965 #endif
966 TRACE("bytesize %d\n",lpdcb->ByteSize);
967 port.c_cflag &= ~CSIZE;
968 switch (lpdcb->ByteSize) {
969 case 5:
970 port.c_cflag |= CS5;
971 break;
972 case 6:
973 port.c_cflag |= CS6;
974 break;
975 case 7:
976 port.c_cflag |= CS7;
977 break;
978 case 8:
979 port.c_cflag |= CS8;
980 break;
981 default:
982 ptr->commerror = IE_BYTESIZE;
983 return -1;
984 }
985
986 TRACE("fParity %d Parity %d\n",lpdcb->fParity, lpdcb->Parity);
987 port.c_cflag &= ~(PARENB | PARODD);
988 if (lpdcb->fParity)
989 port.c_iflag |= INPCK;
990 else
991 port.c_iflag &= ~INPCK;
992 switch (lpdcb->Parity) {
993 case NOPARITY:
994 break;
995 case ODDPARITY:
996 port.c_cflag |= (PARENB | PARODD);
997 break;
998 case EVENPARITY:
999 port.c_cflag |= PARENB;
1000 break;
1001 default:
1002 ptr->commerror = IE_BYTESIZE;
1003 return -1;
1004 }
1005
1006
1007 TRACE("stopbits %d\n",lpdcb->StopBits);
1008
1009 switch (lpdcb->StopBits) {
1010 case ONESTOPBIT:
1011 port.c_cflag &= ~CSTOPB;
1012 break;
1013 case TWOSTOPBITS:
1014 port.c_cflag |= CSTOPB;
1015 break;
1016 default:
1017 ptr->commerror = IE_BYTESIZE;
1018 return -1;
1019 }
1020 #ifdef CRTSCTS
1021
1022 if (lpdcb->fDtrflow || lpdcb->fRtsflow || lpdcb->fOutxCtsFlow)
1023 port.c_cflag |= CRTSCTS;
1024
1025 if (lpdcb->fDtrDisable)
1026 port.c_cflag &= ~CRTSCTS;
1027 #endif
1028 if (lpdcb->fInX)
1029 port.c_iflag |= IXON;
1030 else
1031 port.c_iflag &= ~IXON;
1032 if (lpdcb->fOutX)
1033 port.c_iflag |= IXOFF;
1034 else
1035 port.c_iflag &= ~IXOFF;
1036
1037 ptr->evtchar = lpdcb->EvtChar;
1038
1039 if (tcsetattr(ptr->fd, TCSADRAIN, &port) == -1) {
1040 ptr->commerror = WinError();
1041 return FALSE;
1042 } else {
1043 ptr->commerror = 0;
1044 return 0;
1045 }
1046 }
1047
1048 /*****************************************************************************
1049 * GetCommState (USER.202)
1050 */
1051 INT16 WINAPI GetCommState16(INT16 cid, LPDCB16 lpdcb)
1052 {
1053 int speed;
1054 struct DosDeviceStruct *ptr;
1055 struct termios port;
1056
1057 TRACE("cid %d, ptr %p\n", cid, lpdcb);
1058 if ((ptr = GetDeviceStruct(cid)) == NULL) {
1059 FIXME("no handle for cid = %0x!.\n",cid);
1060 return -1;
1061 }
1062 if (tcgetattr(ptr->fd, &port) == -1) {
1063 ptr->commerror = WinError();
1064 return -1;
1065 }
1066 lpdcb->Id = cid;
1067 #ifndef __EMX__
1068 #ifdef CBAUD
1069 speed = port.c_cflag & CBAUD;
1070 #else
1071 speed = port.c_ospeed;
1072 #endif
1073 switch(speed) {
1074 case B110:
1075 lpdcb->BaudRate = 110;
1076 break;
1077 case B300:
1078 lpdcb->BaudRate = 300;
1079 break;
1080 case B600:
1081 lpdcb->BaudRate = 600;
1082 break;
1083 case B1200:
1084 lpdcb->BaudRate = 1200;
1085 break;
1086 case B2400:
1087 lpdcb->BaudRate = 2400;
1088 break;
1089 case B4800:
1090 lpdcb->BaudRate = 4800;
1091 break;
1092 case B9600:
1093 lpdcb->BaudRate = 9600;
1094 break;
1095 case B19200:
1096 lpdcb->BaudRate = 19200;
1097 break;
1098 case B38400:
1099 lpdcb->BaudRate = 38400;
1100 break;
1101 #ifdef B57600
1102 case B57600:
1103 lpdcb->BaudRate = 57600;
1104 break;
1105 #endif
1106 #ifdef B115200
1107 case B115200:
1108 lpdcb->BaudRate = 57601;
1109 break;
1110 #endif
1111 }
1112 #endif
1113 switch (port.c_cflag & CSIZE) {
1114 case CS5:
1115 lpdcb->ByteSize = 5;
1116 break;
1117 case CS6:
1118 lpdcb->ByteSize = 6;
1119 break;
1120 case CS7:
1121 lpdcb->ByteSize = 7;
1122 break;
1123 case CS8:
1124 lpdcb->ByteSize = 8;
1125 break;
1126 }
1127
1128 if(port.c_iflag & INPCK)
1129 lpdcb->fParity = TRUE;
1130 else
1131 lpdcb->fParity = FALSE;
1132 switch (port.c_cflag & (PARENB | PARODD)) {
1133 case 0:
1134 lpdcb->Parity = NOPARITY;
1135 break;
1136 case PARENB:
1137 lpdcb->Parity = EVENPARITY;
1138 break;
1139 case (PARENB | PARODD):
1140 lpdcb->Parity = ODDPARITY;
1141 break;
1142 }
1143
1144 if (port.c_cflag & CSTOPB)
1145 lpdcb->StopBits = TWOSTOPBITS;
1146 else
1147 lpdcb->StopBits = ONESTOPBIT;
1148
1149 lpdcb->RlsTimeout = 50;
1150 lpdcb->CtsTimeout = 50;
1151 lpdcb->DsrTimeout = 50;
1152 lpdcb->fNull = 0;
1153 lpdcb->fChEvt = 0;
1154 lpdcb->fBinary = 1;
1155 lpdcb->fDtrDisable = 0;
1156
1157 #ifdef CRTSCTS
1158
1159 if (port.c_cflag & CRTSCTS) {
1160 lpdcb->fDtrflow = 1;
1161 lpdcb->fRtsflow = 1;
1162 lpdcb->fOutxCtsFlow = 1;
1163 lpdcb->fOutxDsrFlow = 1;
1164 } else
1165 #endif
1166 lpdcb->fDtrDisable = 1;
1167
1168 if (port.c_iflag & IXON)
1169 lpdcb->fInX = 1;
1170 else
1171 lpdcb->fInX = 0;
1172
1173 if (port.c_iflag & IXOFF)
1174 lpdcb->fOutX = 1;
1175 else
1176 lpdcb->fOutX = 0;
1177 /*
1178 lpdcb->XonChar =
1179 lpdcb->XoffChar =
1180 */
1181 lpdcb->XonLim = 10;
1182 lpdcb->XoffLim = 10;
1183
1184 lpdcb->EvtChar = ptr->evtchar;
1185
1186 ptr->commerror = 0;
1187 return 0;
1188 }
1189
1190 /*****************************************************************************
1191 * TransmitCommChar (USER.206)
1192 */
1193 INT16 WINAPI TransmitCommChar16(INT16 cid,CHAR chTransmit)
1194 {
1195 struct DosDeviceStruct *ptr;
1196
1197 TRACE("cid %d, data %d \n", cid, chTransmit);
1198 if ((ptr = GetDeviceStruct(cid)) == NULL) {
1199 FIXME("no handle for cid = %0x!.\n",cid);
1200 return -1;
1201 }
1202
1203 if (ptr->suspended) {
1204 ptr->commerror = IE_HARDWARE;
1205 return -1;
1206 }
1207
1208 if (ptr->xmit >= 0) {
1209 /* character already queued */
1210 /* FIXME: which error would Windows return? */
1211 ptr->commerror = CE_TXFULL;
1212 return -1;
1213 }
1214
1215 if (ptr->obuf_head == ptr->obuf_tail) {
1216 /* transmit queue empty, try to transmit directly */
1217 if (write(ptr->fd, &chTransmit, 1) == -1) {
1218 /* didn't work, queue it */
1219 ptr->xmit = chTransmit;
1220 comm_waitwrite(ptr);
1221 }
1222 } else {
1223 /* data in queue, let this char be transmitted next */
1224 ptr->xmit = chTransmit;
1225 comm_waitwrite(ptr);
1226 }
1227
1228 ptr->commerror = 0;
1229 return 0;
1230 }
1231
1232 /*****************************************************************************
1233 * UngetCommChar (USER.212)
1234 */
1235 INT16 WINAPI UngetCommChar16(INT16 cid,CHAR chUnget)
1236 {
1237 struct DosDeviceStruct *ptr;
1238
1239 TRACE("cid %d (char %d)\n", cid, chUnget);
1240 if ((ptr = GetDeviceStruct(cid)) == NULL) {
1241 FIXME("no handle for cid = %0x!.\n",cid);
1242 return -1;
1243 }
1244
1245 if (ptr->suspended) {
1246 ptr->commerror = IE_HARDWARE;
1247 return -1;
1248 }
1249
1250 if (ptr->unget>=0) {
1251 /* character already queued */
1252 /* FIXME: which error would Windows return? */
1253 ptr->commerror = CE_RXOVER;
1254 return -1;
1255 }
1256
1257 ptr->unget = chUnget;
1258
1259 ptr->commerror = 0;
1260 return 0;
1261 }
1262
1263 /*****************************************************************************
1264 * ReadComm (USER.204)
1265 */
1266 INT16 WINAPI ReadComm16(INT16 cid,LPSTR lpvBuf,INT16 cbRead)
1267 {
1268 int status, length;
1269 struct DosDeviceStruct *ptr;
1270 LPSTR orgBuf = lpvBuf;
1271
1272 TRACE("cid %d, ptr %p, length %d\n", cid, lpvBuf, cbRead);
1273 if ((ptr = GetDeviceStruct(cid)) == NULL) {
1274 FIXME("no handle for cid = %0x!.\n",cid);
1275 return -1;
1276 }
1277
1278 if (ptr->suspended) {
1279 ptr->commerror = IE_HARDWARE;
1280 return -1;
1281 }
1282
1283 /* read unget character */
1284 if (ptr->unget>=0) {
1285 *lpvBuf++ = ptr->unget;
1286 ptr->unget = -1;
1287
1288 length = 1;
1289 } else
1290 length = 0;
1291
1292 /* read from receive buffer */
1293 while (length < cbRead) {
1294 status = ((ptr->ibuf_head < ptr->ibuf_tail) ?
1295 ptr->ibuf_size : ptr->ibuf_head) - ptr->ibuf_tail;
1296 if (!status) break;
1297 if ((cbRead - length) < status)
1298 status = cbRead - length;
1299
1300 memcpy(lpvBuf, ptr->inbuf + ptr->ibuf_tail, status);
1301 ptr->ibuf_tail += status;
1302 if (ptr->ibuf_tail >= ptr->ibuf_size)
1303 ptr->ibuf_tail = 0;
1304 lpvBuf += status;
1305 length += status;
1306 }
1307
1308 TRACE("%.*s\n", length, orgBuf);
1309 ptr->commerror = 0;
1310 return length;
1311 }
1312
1313 /*****************************************************************************
1314 * WriteComm (USER.205)
1315 */
1316 INT16 WINAPI WriteComm16(INT16 cid, LPSTR lpvBuf, INT16 cbWrite)
1317 {
1318 int status, length;
1319 struct DosDeviceStruct *ptr;
1320
1321 TRACE("cid %d, ptr %p, length %d\n",
1322 cid, lpvBuf, cbWrite);
1323 if ((ptr = GetDeviceStruct(cid)) == NULL) {
1324 FIXME("no handle for cid = %0x!.\n",cid);
1325 return -1;
1326 }
1327
1328 if (ptr->suspended) {
1329 ptr->commerror = IE_HARDWARE;
1330 return -1;
1331 }
1332
1333 TRACE("%.*s\n", cbWrite, lpvBuf );
1334
1335 length = 0;
1336 while (length < cbWrite) {
1337 if ((ptr->obuf_head == ptr->obuf_tail) && (ptr->xmit < 0)) {
1338 /* no data queued, try to write directly */
1339 status = write(ptr->fd, lpvBuf, cbWrite - length);
1340 if (status > 0) {
1341 lpvBuf += status;
1342 length += status;
1343 continue;
1344 }
1345 }
1346 /* can't write directly, put into transmit buffer */
1347 status = ((ptr->obuf_tail > ptr->obuf_head) ?
1348 (ptr->obuf_tail-1) : ptr->obuf_size) - ptr->obuf_head;
1349 if (!status) break;
1350 if ((cbWrite - length) < status)
1351 status = cbWrite - length;
1352 memcpy(lpvBuf, ptr->outbuf + ptr->obuf_head, status);
1353 ptr->obuf_head += status;
1354 if (ptr->obuf_head >= ptr->obuf_size)
1355 ptr->obuf_head = 0;
1356 lpvBuf += status;
1357 length += status;
1358 comm_waitwrite(ptr);
1359 }
1360
1361 ptr->commerror = 0;
1362 return length;
1363 }
1364
1365 /***********************************************************************
1366 * EnableCommNotification (USER.246)
1367 */
1368 BOOL16 WINAPI EnableCommNotification16( INT16 cid, HWND16 hwnd,
1369 INT16 cbWriteNotify, INT16 cbOutQueue )
1370 {
1371 struct DosDeviceStruct *ptr;
1372
1373 TRACE("(%d, %x, %d, %d)\n", cid, hwnd, cbWriteNotify, cbOutQueue);
1374 if ((ptr = GetDeviceStruct(cid)) == NULL) {
1375 FIXME("no handle for cid = %0x!.\n",cid);
1376 ptr->commerror = IE_BADID;
1377 return -1;
1378 }
1379 ptr->wnd = hwnd;
1380 ptr->n_read = cbWriteNotify;
1381 ptr->n_write = cbOutQueue;
1382 return TRUE;
1383 }
1384
1385
1386 /**************************************************************************
1387 * BuildCommDCBA (KERNEL32.14)
1388 */
1389 BOOL WINAPI BuildCommDCBA(LPCSTR device,LPDCB lpdcb)
1390 {
1391 return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
1392 }
1393
1394 /**************************************************************************
1395 * BuildCommDCBAndTimeoutsA (KERNEL32.15)
1396 */
1397 BOOL WINAPI BuildCommDCBAndTimeoutsA(LPCSTR device, LPDCB lpdcb,
1398 LPCOMMTIMEOUTS lptimeouts)
1399 {
1400 int port;
1401 char *ptr,*temp;
1402
1403 TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
1404
1405 if (!lstrncmpiA(device,"COM",3)) {
1406 port=device[3]-'0';
1407 if (port--==0) {
1408 ERR("BUG! COM0 can't exists!.\n");
1409 return FALSE;
1410 }
1411 if (!ValidCOMPort(port))
1412 return FALSE;
1413 if (*(device+4)!=':')
1414 return FALSE;
1415 temp=(LPSTR)(device+5);
1416 } else
1417 temp=(LPSTR)device;
1418
1419 memset(lpdcb, 0, sizeof(DCB)); /* initialize */
1420
1421 lpdcb->DCBlength = sizeof(DCB);
1422 if (strchr(temp,',')) { /* old style */
1423 DCB16 dcb16;
1424 BOOL16 ret;
1425 char last=temp[strlen(temp)-1];
1426
1427 ret=BuildCommDCB16(device,&dcb16);
1428 if (!ret)
1429 return FALSE;
1430 lpdcb->BaudRate = dcb16.BaudRate;
1431 lpdcb->ByteSize = dcb16.ByteSize;
1432 lpdcb->fBinary = dcb16.fBinary;
1433 lpdcb->Parity = dcb16.Parity;
1434 lpdcb->fParity = dcb16.fParity;
1435 lpdcb->fNull = dcb16.fNull;
1436 lpdcb->StopBits = dcb16.StopBits;
1437 if (last == 'x') {
1438 lpdcb->fInX = TRUE;
1439 lpdcb->fOutX = TRUE;
1440 lpdcb->fOutxCtsFlow = FALSE;
1441 lpdcb->fOutxDsrFlow = FALSE;
1442 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
1443 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
1444 } else if (last=='p') {
1445 lpdcb->fInX = FALSE;
1446 lpdcb->fOutX = FALSE;
1447 lpdcb->fOutxCtsFlow = TRUE;
1448 lpdcb->fOutxDsrFlow = TRUE;
1449 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
1450 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
1451 } else {
1452 lpdcb->fInX = FALSE;
1453 lpdcb->fOutX = FALSE;
1454 lpdcb->fOutxCtsFlow = FALSE;
1455 lpdcb->fOutxDsrFlow = FALSE;
1456 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
1457 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
1458 }
1459 lpdcb->XonChar = dcb16.XonChar;
1460 lpdcb->XoffChar = dcb16.XoffChar;
1461 lpdcb->ErrorChar= dcb16.PeChar;
1462 lpdcb->fErrorChar= dcb16.fPeChar;
1463 lpdcb->EofChar = dcb16.EofChar;
1464 lpdcb->EvtChar = dcb16.EvtChar;
1465 lpdcb->XonLim = dcb16.XonLim;
1466 lpdcb->XoffLim = dcb16.XoffLim;
1467 return TRUE;
1468 }
1469 ptr=strtok(temp," ");
1470 while (ptr) {
1471 DWORD flag,x;
1472
1473 flag=0;
1474 if (!strncmp("baud=",ptr,5)) {
1475 if (!sscanf(ptr+5,"%ld",&x))
1476 WARN("Couldn't parse %s\n",ptr);
1477 lpdcb->BaudRate = x;
1478 flag=1;
1479 }
1480 if (!strncmp("stop=",ptr,5)) {
1481 if (!sscanf(ptr+5,"%ld",&x))
1482 WARN("Couldn't parse %s\n",ptr);
1483 lpdcb->StopBits = x;
1484 flag=1;
1485 }
1486 if (!strncmp("data=",ptr,5)) {
1487 if (!sscanf(ptr+5,"%ld",&x))
1488 WARN("Couldn't parse %s\n",ptr);
1489 lpdcb->ByteSize = x;
1490 flag=1;
1491 }
1492 if (!strncmp("parity=",ptr,7)) {
1493 lpdcb->fParity = TRUE;
1494 switch (ptr[8]) {
1495 case 'N':case 'n':
1496 lpdcb->fParity = FALSE;
1497 lpdcb->Parity = NOPARITY;
1498 break;
1499 case 'E':case 'e':
1500 lpdcb->Parity = EVENPARITY;
1501 break;
1502 case 'O':case 'o':
1503 lpdcb->Parity = ODDPARITY;
1504 break;
1505 case 'M':case 'm':
1506 lpdcb->Parity = MARKPARITY;
1507 break;
1508 }
1509 flag=1;
1510 }
1511 if (!flag)
1512 ERR("Unhandled specifier '%s', please report.\n",ptr);
1513 ptr=strtok(NULL," ");
1514 }
1515 if (lpdcb->BaudRate==110)
1516 lpdcb->StopBits = 2;
1517 return TRUE;
1518 }
1519
1520 /**************************************************************************
1521 * BuildCommDCBAndTimeoutsW (KERNEL32.16)
1522 */
1523 BOOL WINAPI BuildCommDCBAndTimeoutsW( LPCWSTR devid, LPDCB lpdcb,
1524 LPCOMMTIMEOUTS lptimeouts )
1525 {
1526 LPSTR devidA;
1527 BOOL ret;
1528
1529 TRACE("(%p,%p,%p)\n",devid,lpdcb,lptimeouts);
1530 devidA = HEAP_strdupWtoA( GetProcessHeap(), 0, devid );
1531 ret=BuildCommDCBAndTimeoutsA(devidA,lpdcb,lptimeouts);
1532 HeapFree( GetProcessHeap(), 0, devidA );
1533 return ret;
1534 }
1535
1536 /**************************************************************************
1537 * BuildCommDCBW (KERNEL32.17)
1538 */
1539 BOOL WINAPI BuildCommDCBW(LPCWSTR devid,LPDCB lpdcb)
1540 {
1541 return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
1542 }
1543
1544 /*****************************************************************************
1545 * COMM_GetReadFd
1546 * Returns a file descriptor for reading.
1547 * Make sure to close the handle afterwards!
1548 */
1549 static int COMM_GetReadFd( HANDLE handle)
1550 {
1551 int fd;
1552 struct get_read_fd_request *req = get_req_buffer();
1553 req->handle = handle;
1554 server_call_fd( REQ_GET_READ_FD, -1, &fd );
1555 return fd;
1556 }
1557
1558 /*****************************************************************************
1559 * COMM_GetWriteFd
1560 * Returns a file descriptor for writing.
1561 * Make sure to close the handle afterwards!
1562 */
1563 static int COMM_GetWriteFd( HANDLE handle)
1564 {
1565 int fd = -1;
1566 struct get_write_fd_request *req = get_req_buffer();
1567 req->handle = handle;
1568 server_call_fd( REQ_GET_WRITE_FD, -1, &fd );
1569 return fd;
1570 }
1571
1572 /* FIXME: having these global for win32 for now */
1573 int commerror=0,eventmask=0;
1574
1575 /*****************************************************************************
1576 * SetCommBreak (KERNEL32.449)
1577 */
1578 BOOL WINAPI SetCommBreak(HANDLE handle)
1579 {
1580 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1581 int fd,result;
1582
1583 fd = COMM_GetWriteFd(handle);
1584 if(fd<0) {
1585 TRACE("COMM_GetWriteFd failed\n");
1586 return FALSE;
1587 }
1588 result = ioctl(fd,TIOCSBRK,0);
1589 close(fd);
1590 if (result ==-1)
1591 {
1592 TRACE("ioctl failed\n");
1593 SetLastError(ERROR_NOT_SUPPORTED);
1594 return FALSE;
1595 }
1596 return TRUE;
1597 #else
1598 FIXME("ioctl not available\n");
1599 SetLastError(ERROR_NOT_SUPPORTED);
1600 return FALSE;
1601 #endif
1602 }
1603
1604 /*****************************************************************************
1605 * ClearCommBreak (KERNEL32.20)
1606 */
1607 BOOL WINAPI ClearCommBreak(HANDLE handle)
1608 {
1609 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1610 int fd,result;
1611
1612 fd = COMM_GetWriteFd(handle);
1613 if(fd<0) {
1614 TRACE("COMM_GetWriteFd failed\n");
1615 return FALSE;
1616 }
1617 result = ioctl(fd,TIOCCBRK,0);
1618 close(fd);
1619 if (result ==-1)
1620 {
1621 TRACE("ioctl failed\n");
1622 SetLastError(ERROR_NOT_SUPPORTED);
1623 return FALSE;
1624 }
1625 return TRUE;
1626 #else
1627 FIXME("ioctl not available\n");
1628 SetLastError(ERROR_NOT_SUPPORTED);
1629 return FALSE;
1630 #endif
1631 }
1632
1633 /*****************************************************************************
1634 * EscapeCommFunction (KERNEL32.214)
1635 */
1636 BOOL WINAPI EscapeCommFunction(HANDLE handle,UINT nFunction)
1637 {
1638 int fd,direct=FALSE,result=FALSE;
1639 struct termios port;
1640
1641 TRACE("handle %d, function=%d\n", handle, nFunction);
1642 fd = COMM_GetWriteFd(handle);
1643 if(fd<0) {
1644 FIXME("handle %d not found.\n",handle);
1645 return FALSE;
1646 }
1647
1648 if (tcgetattr(fd,&port) == -1) {
1649 commerror=WinError();
1650 close(fd);
1651 return FALSE;
1652 }
1653
1654 switch (nFunction) {
1655 case RESETDEV:
1656 TRACE("\n");
1657 break;
1658
1659 case CLRDTR:
1660 TRACE("CLRDTR\n");
1661 #ifdef TIOCM_DTR
1662 direct=TRUE;
1663 result= COMM_WhackModem(fd, ~TIOCM_DTR, 0);
1664 break;
1665 #endif
1666
1667 case CLRRTS:
1668 TRACE("CLRRTS\n");
1669 #ifdef TIOCM_RTS
1670 direct=TRUE;
1671 result= COMM_WhackModem(fd, ~TIOCM_RTS, 0);
1672 break;
1673 #endif
1674
1675 case SETDTR:
1676 TRACE("SETDTR\n");
1677 #ifdef TIOCM_DTR
1678 direct=TRUE;
1679 result= COMM_WhackModem(fd, 0, TIOCM_DTR);
1680 break;
1681 #endif
1682
1683 case SETRTS:
1684 TRACE("SETRTS\n");
1685 #ifdef TIOCM_DTR
1686 direct=TRUE;
1687 result= COMM_WhackModem(fd, 0, TIOCM_RTS);
1688 break;
1689 #endif
1690
1691 case SETXOFF:
1692 TRACE("SETXOFF\n");
1693 port.c_iflag |= IXOFF;
1694 break;
1695
1696 case SETXON:
1697 TRACE("SETXON\n");
1698 port.c_iflag |= IXON;
1699 break;
1700 case SETBREAK:
1701 TRACE("setbreak\n");
1702 #ifdef TIOCSBRK
1703 direct=TRUE;
1704 result = ioctl(fd,TIOCSBRK,0);
1705 break;
1706 #endif
1707 case CLRBREAK:
1708 TRACE("clrbreak\n");
1709 #ifdef TIOCSBRK
1710 direct=TRUE;
1711 result = ioctl(fd,TIOCCBRK,0);
1712 break;
1713 #endif
1714 default:
1715 WARN("(handle=%d,nFunction=%d): Unknown function\n",
1716 handle, nFunction);
1717 break;
1718 }
1719
1720 if (!direct)
1721 if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
1722 commerror = WinError();
1723 close(fd);
1724 return FALSE;
1725 } else
1726 result= TRUE;
1727 else
1728 {
1729 if (result == -1)
1730 {
1731 result= FALSE;
1732 commerror=WinError();
1733 }
1734 else
1735 result = TRUE;
1736 }
1737 close(fd);
1738 return result;
1739 }
1740
1741 /********************************************************************
1742 * PurgeComm (KERNEL32.557)
1743 */
1744 BOOL WINAPI PurgeComm( HANDLE handle, DWORD flags)
1745 {
1746 int fd;
1747
1748 TRACE("handle %d, flags %lx\n", handle, flags);
1749
1750 fd = COMM_GetWriteFd(handle);
1751 if(fd<0) {
1752 FIXME("no handle %d found\n",handle);
1753 return FALSE;
1754 }
1755
1756 /*
1757 ** not exactly sure how these are different
1758 ** Perhaps if we had our own internal queues, one flushes them
1759 ** and the other flushes the kernel's buffers.
1760 */
1761 if(flags&PURGE_TXABORT)
1762 tcflush(fd,TCOFLUSH);
1763 if(flags&PURGE_RXABORT)
1764 tcflush(fd,TCIFLUSH);
1765 if(flags&PURGE_TXCLEAR)
1766 tcflush(fd,TCOFLUSH);
1767 if(flags&PURGE_RXCLEAR)
1768 tcflush(fd,TCIFLUSH);
1769 close(fd);
1770
1771 return 1;
1772 }
1773
1774 /*****************************************************************************
1775 * ClearCommError (KERNEL32.21)
1776 */
1777 BOOL WINAPI ClearCommError(INT handle,LPDWORD errors,LPCOMSTAT lpStat)
1778 {
1779 int fd;
1780
1781 fd=COMM_GetReadFd(handle);
1782 if(0>fd)
1783 {
1784 FIXME("no handle %d found\n",handle);
1785 return FALSE;
1786 }
1787
1788 if (lpStat)
1789 {
1790 lpStat->status = 0;
1791
1792 #ifdef TIOCOUTQ
1793 if(ioctl(fd, TIOCOUTQ, &lpStat->cbOutQue))
1794 WARN("ioctl returned error\n");
1795 #else
1796 lpStat->cbOutQue = 0; /* FIXME: find a different way to find out */
1797 #endif
1798
1799 if(ioctl(fd, TIOCINQ, &lpStat->cbInQue))
1800 WARN("ioctl returned error\n");
1801
1802 TRACE("handle %d cbInQue = %ld cbOutQue = %ld\n",
1803 handle, lpStat->cbInQue, lpStat->cbOutQue);
1804 }
1805
1806 close(fd);
1807
1808 if(errors)
1809 *errors = 0;
1810
1811 /*
1812 ** After an asynchronous write opperation, the
1813 ** app will call ClearCommError to see if the
1814 ** results are ready yet. It waits for ERROR_IO_PENDING
1815 */
1816 commerror = ERROR_IO_PENDING;
1817
1818 return TRUE;
1819 }
1820
1821 /*****************************************************************************
1822 * SetupComm (KERNEL32.676)
1823 */
1824 BOOL WINAPI SetupComm( HANDLE handle, DWORD insize, DWORD outsize)
1825 {
1826 int fd;
1827
1828 FIXME("insize %ld outsize %ld unimplemented stub\n", insize, outsize);
1829 fd=COMM_GetWriteFd(handle);
1830 if(0>fd) {
1831 FIXME("handle %d not found?\n",handle);
1832 return FALSE;
1833 }
1834 close(fd);
1835 return TRUE;
1836 }
1837
1838 /*****************************************************************************
1839 * GetCommMask (KERNEL32.156)
1840 */
1841 BOOL WINAPI GetCommMask(HANDLE handle,LPDWORD evtmask)
1842 {
1843 int fd;
1844
1845 TRACE("handle %d, mask %p\n", handle, evtmask);
1846 if(0>(fd=COMM_GetReadFd(handle)))
1847 {
1848 FIXME("no handle %d found\n",handle);
1849 return FALSE;
1850 }
1851 close(fd);
1852 *evtmask = eventmask;
1853 TRACE("%s%s%s%s%s%s%s%s%s\n",
1854 (eventmask&EV_BREAK)?"EV_BREAK":"",
1855 (eventmask&EV_CTS)?"EV_CTS":"",
1856 (eventmask&EV_DSR)?"EV_DSR":"",
1857 (eventmask&EV_ERR)?"EV_ERR":"",
1858 (eventmask&EV_RING)?"EV_RING":"",
1859 (eventmask&EV_RLSD)?"EV_RLSD":"",
1860 (eventmask&EV_RXCHAR)?"EV_RXCHAR":"",
1861 (eventmask&EV_RXFLAG)?"EV_RXFLAG":"",
1862 (eventmask&EV_TXEMPTY)?"EV_TXEMPTY":"");
1863
1864 return TRUE;
1865 }
1866
1867 /*****************************************************************************
1868 * SetCommMask (KERNEL32.451)
1869 */
1870 BOOL WINAPI SetCommMask(INT handle,DWORD evtmask)
1871 {
1872 int fd;
1873
1874 TRACE("handle %d, mask %lx\n", handle, evtmask);
1875 TRACE("%s%s%s%s%s%s%s%s%s\n",
1876 (evtmask&EV_BREAK)?"EV_BREAK":"",
1877 (evtmask&EV_CTS)?"EV_CTS":"",
1878 (evtmask&EV_DSR)?"EV_DSR":"",
1879 (evtmask&EV_ERR)?"EV_ERR":"",
1880 (evtmask&EV_RING)?"EV_RING":"",
1881 (evtmask&EV_RLSD)?"EV_RLSD":"",
1882 (evtmask&EV_RXCHAR)?"EV_RXCHAR":"",
1883 (evtmask&EV_RXFLAG)?"EV_RXFLAG":"",
1884 (evtmask&EV_TXEMPTY)?"EV_TXEMPTY":"");
1885
1886 if(0>(fd=COMM_GetWriteFd(handle))) {
1887 FIXME("no handle %d found\n",handle);
1888 return FALSE;
1889 }
1890 close(fd);
1891 eventmask = evtmask;
1892 return TRUE;
1893 }
1894
1895 /*****************************************************************************
1896 * SetCommState (KERNEL32.452)
1897 */
1898 BOOL WINAPI SetCommState(INT handle,LPDCB lpdcb)
1899 {
1900 struct termios port;
1901 int fd;
1902
1903 TRACE("handle %d, ptr %p\n", handle, lpdcb);
1904 TRACE("bytesize %d baudrate %ld fParity %d Parity %d stopbits %d\n",
1905 lpdcb->ByteSize,lpdcb->BaudRate,lpdcb->fParity, lpdcb->Parity,
1906 (lpdcb->StopBits == ONESTOPBIT)?1:
1907 (lpdcb->StopBits == TWOSTOPBITS)?2:0);
1908 TRACE("%s %s\n",(lpdcb->fInX)?"IXON":"~IXON",
1909 (lpdcb->fOutX)?"IXOFF":"~IXOFF");
1910
1911 if ((fd = COMM_GetWriteFd(handle)) < 0) {
1912 FIXME("no handle %d found\n",handle);
1913 return FALSE;
1914 }
1915
1916 if ((tcgetattr(fd,&port)) == -1) {
1917 int save_error = errno;
1918 commerror = WinError();
1919 close( fd );
1920 #ifdef HAVE_STRERROR
1921 ERR("tcgetattr error '%s'\n", strerror(save_error));
1922 #else
1923 ERR("tcgetattr error %d\n", save_error);
1924 #endif
1925 return FALSE;
1926 }
1927
1928 port.c_cc[VMIN] = 0;
1929 port.c_cc[VTIME] = 1;
1930
1931 #ifdef IMAXBEL
1932 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
1933 #else
1934 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
1935 #endif
1936 port.c_iflag |= (IGNBRK);
1937
1938 port.c_oflag &= ~(OPOST);
1939
1940 port.c_cflag &= ~(HUPCL);
1941 port.c_cflag |= CLOCAL | CREAD;
1942
1943 port.c_lflag &= ~(ICANON|ECHO|ISIG);
1944 port.c_lflag |= NOFLSH;
1945
1946 /*
1947 ** MJM - removed default baudrate settings
1948 ** TRACE(comm,"baudrate %ld\n",lpdcb->BaudRate);
1949 */
1950 #ifdef CBAUD
1951 port.c_cflag &= ~CBAUD;
1952 switch (lpdcb->BaudRate) {
1953 case 110:
1954 case CBR_110:
1955 port.c_cflag |= B110;
1956 break;
1957 case 300:
1958 case CBR_300:
1959 port.c_cflag |= B300;
1960 break;
1961 case 600:
1962 case CBR_600:
1963 port.c_cflag |= B600;
1964 break;
1965 case 1200:
1966 case CBR_1200:
1967 port.c_cflag |= B1200;
1968 break;
1969 case 2400:
1970 case CBR_2400:
1971 port.c_cflag |= B2400;
1972 break;
1973 case 4800:
1974 case CBR_4800:
1975 port.c_cflag |= B4800;
1976 break;
1977 case 9600:
1978 case CBR_9600:
1979 port.c_cflag |= B9600;
1980 break;
1981 case 19200:
1982 case CBR_19200:
1983 port.c_cflag |= B19200;
1984 break;
1985 case 38400:
1986 case CBR_38400:
1987 port.c_cflag |= B38400;
1988 break;
1989 #ifdef B57600
1990 case 57600:
1991 port.c_cflag |= B57600;
1992 break;
1993 #endif
1994 #ifdef B115200
1995 case 115200:
1996 port.c_cflag |= B115200;
1997 break;
1998 #endif
1999 #ifdef B230400
2000 case 230400:
2001 port.c_cflag |= B230400;
2002 break;
2003 #endif
2004 #ifdef B460800
2005 case 460600:
2006 port.c_cflag |= B460800;
2007 break;
2008 #endif
2009 default:
2010 commerror = IE_BAUDRATE;
2011 close( fd );
2012 ERR("baudrate %ld\n",lpdcb->BaudRate);
2013 return FALSE;
2014 }
2015 #elif !defined(__EMX__)
2016 switch (lpdcb->BaudRate) {
2017 case 110:
2018 case CBR_110:
2019 port.c_ospeed = B110;
2020 break;
2021 case 300:
2022 case CBR_300:
2023 port.c_ospeed = B300;
2024 break;
2025 case 600:
2026 case CBR_600:
2027 port.c_ospeed = B600;
2028 break;
2029 case 1200:
2030 case CBR_1200:
2031 port.c_ospeed = B1200;
2032 break;
2033 case 2400:
2034 case CBR_2400:
2035 port.c_ospeed = B2400;
2036 break;
2037 case 4800:
2038 case CBR_4800:
2039 port.c_ospeed = B4800;
2040 break;
2041 case 9600:
2042 case CBR_9600:
2043 port.c_ospeed = B9600;
2044 break;
2045 case 19200:
2046 case CBR_19200:
2047 port.c_ospeed = B19200;
2048 break;
2049 case 38400:
2050 case CBR_38400:
2051 port.c_ospeed = B38400;
2052 break;
2053 default:
2054 commerror = IE_BAUDRATE;
2055 close( fd );
2056 ERR("baudrate %d \n",lpdcb->BaudRate);
2057 return FALSE;
2058 }
2059 port.c_ispeed = port.c_ospeed;
2060 #endif
2061 port.c_cflag &= ~CSIZE;
2062 switch (lpdcb->ByteSize) {
2063 case 5:
2064 port.c_cflag |= CS5;
2065 break;
2066 case 6:
2067 port.c_cflag |= CS6;
2068 break;
2069 case 7:
2070 port.c_cflag |= CS7;
2071 break;
2072 case 8:
2073 port.c_cflag |= CS8;
2074 break;
2075 default:
2076 commerror = IE_BYTESIZE;
2077 close( fd );
2078 ERR("ByteSize\n");
2079 return FALSE;
2080 }
2081
2082 port.c_cflag &= ~(PARENB | PARODD);
2083 if (lpdcb->fParity)
2084 port.c_iflag |= INPCK;
2085 else
2086 port.c_iflag &= ~INPCK;
2087 switch (lpdcb->Parity) {
2088 case NOPARITY:
2089 break;
2090 case ODDPARITY:
2091 port.c_cflag |= (PARENB | PARODD);
2092 break;
2093 case EVENPARITY:
2094 port.c_cflag |= PARENB;
2095 break;
2096 default:
2097 commerror = IE_BYTESIZE;
2098 close( fd );
2099 ERR("Parity\n");
2100 return FALSE;
2101 }
2102
2103
2104 switch (lpdcb->StopBits) {
2105 case ONESTOPBIT:
2106 port.c_cflag &= ~CSTOPB;
2107 break;
2108 case TWOSTOPBITS:
2109 port.c_cflag |= CSTOPB;
2110 break;
2111 default:
2112 commerror = IE_BYTESIZE;
2113 close( fd );
2114 ERR("StopBits\n");
2115 return FALSE;
2116 }
2117 #ifdef CRTSCTS
2118 if ( lpdcb->fOutxCtsFlow ||
2119 lpdcb->fDtrControl == DTR_CONTROL_ENABLE||
2120 lpdcb->fRtsControl == RTS_CONTROL_ENABLE
2121 )
2122 {
2123 port.c_cflag |= CRTSCTS;
2124 TRACE("CRTSCTS\n");
2125 }
2126
2127 if (lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
2128 {
2129 port.c_cflag &= ~CRTSCTS;
2130 TRACE("~CRTSCTS\n");
2131 }
2132
2133 #endif
2134 if (lpdcb->fInX)
2135 port.c_iflag |= IXON;
2136 else
2137 port.c_iflag &= ~IXON;
2138 if (lpdcb->fOutX)
2139 port.c_iflag |= IXOFF;
2140 else
2141 port.c_iflag &= ~IXOFF;
2142
2143 if (tcsetattr(fd,TCSANOW,&port)==-1) { /* otherwise it hangs with pending input*/
2144 int save_error=errno;
2145 commerror = WinError();
2146 close( fd );
2147 #ifdef HAVE_STRERROR
2148 ERR("tcgetattr error '%s'\n", strerror(save_error));
2149 #else
2150 ERR("tcgetattr error %d\n", save_error);
2151 #endif
2152 return FALSE;
2153 } else {
2154 commerror = 0;
2155 close( fd );
2156 return TRUE;
2157 }
2158 }
2159
2160
2161 /*****************************************************************************
2162 * GetCommState (KERNEL32.159)
2163 */
2164 BOOL WINAPI GetCommState(INT handle, LPDCB lpdcb)
2165 {
2166 struct termios port;
2167 int fd,speed;
2168
2169 TRACE("handle %d, ptr %p\n", handle, lpdcb);
2170
2171 if ((fd = COMM_GetReadFd(handle)) < 0)
2172 {
2173 ERR("can't get COMM_GetReadFd\n");
2174 return FALSE;
2175 }
2176 if (tcgetattr(fd, &port) == -1) {
2177 int save_error=errno;
2178 #ifdef HAVE_STRERROR
2179 ERR("tcgetattr error '%s'\n", strerror(save_error));
2180 #else
2181 ERR("tcgetattr error %d\n", save_error);
2182 #endif
2183 commerror = WinError();
2184 close( fd );
2185 return FALSE;
2186 }
2187 close( fd );
2188 #ifndef __EMX__
2189 #ifdef CBAUD
2190 speed= (port.c_cflag & CBAUD);
2191 #else
2192 speed= (cfgetospeed(&port));
2193 #endif
2194 switch (speed) {
2195 case B110:
2196 lpdcb->BaudRate = 110;
2197 break;
2198 case B300:
2199 lpdcb->BaudRate = 300;
2200 break;
2201 case B600:
2202 lpdcb->BaudRate = 600;
2203 break;
2204 case B1200:
2205 lpdcb->BaudRate = 1200;
2206 break;
2207 case B2400:
2208 lpdcb->BaudRate = 2400;
2209 break;
2210 case B4800:
2211 lpdcb->BaudRate = 4800;
2212 break;
2213 case B9600:
2214 lpdcb->BaudRate = 9600;
2215 break;
2216 case B19200:
2217 lpdcb->BaudRate = 19200;
2218 break;
2219 case B38400:
2220 lpdcb->BaudRate = 38400;
2221 break;
2222 #ifdef B57600
2223 case B57600:
2224 lpdcb->BaudRate = 57600;
2225 break;
2226 #endif
2227 #ifdef B115200
2228 case B115200:
2229 lpdcb->BaudRate = 115200;
2230 break;
2231 #endif
2232 #ifdef B230400
2233 case B230400:
2234 lpdcb->BaudRate = 230400;
2235 break;
2236 #endif
2237 #ifdef B460800
2238 case B460800:
2239 lpdcb->BaudRate = 460800;
2240 break;
2241 #endif
2242 default:
2243 ERR("unknown speed %x \n",speed);
2244 }
2245 #endif
2246 switch (port.c_cflag & CSIZE) {
2247 case CS5:
2248 lpdcb->ByteSize = 5;
2249 break;
2250 case CS6:
2251 lpdcb->ByteSize = 6;
2252 break;
2253 case CS7:
2254 lpdcb->ByteSize = 7;
2255 break;
2256 case CS8:
2257 lpdcb->ByteSize = 8;
2258 break;
2259 default:
2260 ERR("unknown size %x \n",port.c_cflag & CSIZE);
2261 }
2262
2263 if(port.c_iflag & INPCK)
2264 lpdcb->fParity = TRUE;
2265 else
2266 lpdcb->fParity = FALSE;
2267 switch (port.c_cflag & (PARENB | PARODD)) {
2268 case 0:
2269 lpdcb->Parity = NOPARITY;
2270 break;
2271 case PARENB:
2272 lpdcb->Parity = EVENPARITY;
2273 break;
2274 case (PARENB | PARODD):
2275 lpdcb->Parity = ODDPARITY;
2276 break;
2277 }
2278
2279 if (port.c_cflag & CSTOPB)
2280 lpdcb->StopBits = TWOSTOPBITS;
2281 else
2282 lpdcb->StopBits = ONESTOPBIT;
2283
2284 lpdcb->fNull = 0;
2285 lpdcb->fBinary = 1;
2286
2287 #ifdef CRTSCTS
2288
2289 if (port.c_cflag & CRTSCTS) {
2290 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
2291 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
2292 lpdcb->fOutxCtsFlow = 1;
2293 lpdcb->fOutxDsrFlow = 1;
2294 } else
2295 #endif
2296 {
2297 lpdcb->fDtrControl = DTR_CONTROL_DISABLE;
2298 lpdcb->fRtsControl = RTS_CONTROL_DISABLE;
2299 }
2300 if (port.c_iflag & IXON)
2301 lpdcb->fInX = 1;
2302 else
2303 lpdcb->fInX = 0;
2304
2305 if (port.c_iflag & IXOFF)
2306 lpdcb->fOutX = 1;
2307 else
2308 lpdcb->fOutX = 0;
2309 /*
2310 lpdcb->XonChar =
2311 lpdcb->XoffChar =
2312 */
2313 lpdcb->XonLim = 10;
2314 lpdcb->XoffLim = 10;
2315
2316 commerror = 0;
2317
2318 TRACE("OK\n");
2319
2320 TRACE("bytesize %d baudrate %ld fParity %d Parity %d stopbits %d\n",
2321 lpdcb->ByteSize,lpdcb->BaudRate,lpdcb->fParity, lpdcb->Parity,
2322 (lpdcb->StopBits == ONESTOPBIT)?1:
2323 (lpdcb->StopBits == TWOSTOPBITS)?2:0);
2324 TRACE("%s %s\n",(lpdcb->fInX)?"IXON":"~IXON",
2325 (lpdcb->fOutX)?"IXOFF":"~IXOFF");
2326 #ifdef CRTSCTS
2327 if ( lpdcb->fOutxCtsFlow ||
2328 lpdcb->fDtrControl == DTR_CONTROL_ENABLE||
2329 lpdcb->fRtsControl == RTS_CONTROL_ENABLE
2330 )
2331 TRACE("CRTSCTS\n");
2332
2333 if (lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
2334 TRACE("~CRTSCTS\n");
2335
2336 #endif
2337 return TRUE;
2338 }
2339
2340 /*****************************************************************************
2341 * TransmitCommChar (KERNEL32.535)
2342 */
2343 BOOL WINAPI TransmitCommChar(INT cid,CHAR chTransmit)
2344 {
2345 struct DosDeviceStruct *ptr;
2346
2347 FIXME("(%d,'%c'), use win32 handle!\n",cid,chTransmit);
2348 if ((ptr = GetDeviceStruct(cid)) == NULL)
2349 FIXME("no handle for cid = %0x!.\n",cid);
2350 return FALSE;
2351
2352 if (ptr->suspended) {
2353 ptr->commerror = IE_HARDWARE;
2354 return FALSE;
2355 }
2356 if (write(ptr->fd, (void *) &chTransmit, 1) == -1) {
2357 ptr->commerror = WinError();
2358 return FALSE;
2359 } else {
2360 ptr->commerror = 0;
2361 return TRUE;
2362 }
2363 }
2364
2365 /*****************************************************************************
2366 * GetCommTimeouts (KERNEL32.160)
2367 */
2368 BOOL WINAPI GetCommTimeouts(HANDLE hcom,LPCOMMTIMEOUTS lptimeouts)
2369 {
2370 FIXME("(%x,%p):stub.\n",hcom,lptimeouts);
2371 return TRUE;
2372 }
2373
2374 /*****************************************************************************
2375 * SetCommTimeouts (KERNEL32.453)
2376 */
2377 BOOL WINAPI SetCommTimeouts(HANDLE hcom,LPCOMMTIMEOUTS lptimeouts) {
2378 /* struct DosDeviceStruct *ptr; */
2379 struct termios tios;
2380 int fd;
2381
2382 FIXME("(%x,%p):stub.\n",hcom,lptimeouts);
2383 /*
2384 if ((ptr = GetDeviceStruct(hcom)) == NULL) {
2385 FIXME("no handle for cid = %0x!.\n",hcom);
2386 return FALSE;
2387 }
2388 */
2389
2390 fd = COMM_GetWriteFd(hcom);
2391 if (fd < 0) {
2392 FIXME("no fd for cid = %0x!.\n",hcom);
2393 return FALSE;
2394 }
2395
2396
2397 FIXME("ReadIntervalTimeout %ld\n",lptimeouts->ReadIntervalTimeout);
2398 FIXME("ReadTotalTimeoutMultiplier %ld\n",lptimeouts->ReadTotalTimeoutMultiplier);
2399 FIXME("ReadTotalTimeoutConstant %ld\n",lptimeouts->ReadTotalTimeoutConstant);
2400 FIXME("WriteTotalTimeoutMultiplier %ld\n",lptimeouts->WriteTotalTimeoutMultiplier);
2401 FIXME("WriteTotalTimeoutConstant %ld\n",lptimeouts->WriteTotalTimeoutConstant);
2402
2403
2404 if (-1==tcgetattr(fd,&tios)) {
2405 FIXME("tcgetattr on fd %d failed!\n",fd);
2406 return FALSE;
2407 }
2408 /* VTIME is in 1/10 seconds */
2409 tios.c_cc[VTIME]= (lptimeouts->ReadIntervalTimeout+99)/100;
2410 if (-1==tcsetattr(fd,0,&tios)) {
2411 FIXME("tcsetattr on fd %d failed!\n",fd);
2412 return FALSE;
2413 }
2414 return TRUE;
2415 }
2416
2417 /***********************************************************************
2418 * GetCommModemStatus (KERNEL32.285)
2419 */
2420 BOOL WINAPI GetCommModemStatus(HANDLE hFile,LPDWORD lpModemStat )
2421 {
2422 int fd,mstat, result=FALSE;
2423
2424 *lpModemStat=0;
2425 #ifdef TIOCMGET
2426 fd = COMM_GetWriteFd(hFile);
2427 if(fd<0)
2428 return FALSE;
2429 result = ioctl(fd, TIOCMGET, &mstat);
2430 close(fd);
2431 if (result == -1)
2432 {
2433 TRACE("ioctl failed\n");
2434 return FALSE;
2435 }
2436 if (mstat & TIOCM_CTS)
2437 *lpModemStat |= MS_CTS_ON;
2438 if (mstat & TIOCM_DSR)
2439 *lpModemStat |= MS_DSR_ON;
2440 if (mstat & TIOCM_RNG)
2441 *lpModemStat |= MS_RING_ON;
2442 /*FIXME: Not really sure about RLSD UB 990810*/
2443 if (mstat & TIOCM_CAR)
2444 *lpModemStat |= MS_RLSD_ON;
2445 TRACE("%s%s%s%s\n",
2446 (*lpModemStat &MS_RLSD_ON)?"MS_RLSD_ON ":"",
2447 (*lpModemStat &MS_RING_ON)?"MS_RING_ON ":"",
2448 (*lpModemStat &MS_DSR_ON)?"MS_DSR_ON ":"",
2449 (*lpModemStat &MS_CTS_ON)?"MS_CTS_ON ":"");
2450 return TRUE;
2451 #else
2452 return FALSE;
2453 #endif
2454 }
2455 /***********************************************************************
2456 * WaitCommEvent (KERNEL32.719)
2457 */
2458 BOOL WINAPI WaitCommEvent(HANDLE hFile,LPDWORD eventmask ,LPOVERLAPPED overlapped)
2459 {
2460 FIXME("(%d %p %p )\n",hFile, eventmask,overlapped);
2461 return TRUE;
2462 }
2463
2464 /***********************************************************************
2465 * GetCommProperties (KERNEL32.???)
2466 */
2467 BOOL WINAPI GetCommProperties(HANDLE hFile, LPDCB *dcb)
2468 {
2469 FIXME("(%d %p )\n",hFile,dcb);
2470 return TRUE;
2471 }
2472
2473 /***********************************************************************
2474 * SetCommProperties (KERNEL32.???)
2475 */
2476 BOOL WINAPI SetCommProperties(HANDLE hFile, LPDCB dcb)
2477 {
2478 FIXME("(%d %p )\n",hFile,dcb);
2479 return TRUE;
2480 }
2481
Windows API implementation