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