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