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