?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980503
[wine.git] / misc / comm.c
blob333adb9aee508f1a46b3972b815b23e550ca4a17
1 /*
2 * DEC 93 Erik Bos <erik@xs4all.nl>
3 *
4 * Copyright 1996 Marcus Meissner
5 * FIXME: use HFILEs instead of unixfds
6 * the win32 functions here get HFILEs already.
7 *
8 * May 26, 1997. Fixes and comments by Rick Richardson <rick@dgii.com> [RER]
9 * - ptr->fd wasn't getting cleared on close.
10 * - GetCommEventMask() and GetCommError() didn't do much of anything.
11 * IMHO, they are still wrong, but they at least implement the RXCHAR
12 * event and return I/O queue sizes, which makes the app I'm interested
13 * in (analog devices EZKIT DSP development system) work.
14 *
15 * August 12, 1997. Take a bash at SetCommEventMask - Lawson Whitney
16 * <lawson_whitney@juno.com>
17 */
18
19 #include "config.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <termios.h>
24 #include <fcntl.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <ctype.h>
28 #include <sys/stat.h>
29 #ifdef HAVE_SYS_FILIO_H
30 # include <sys/filio.h>
31 #endif
32 #include <sys/ioctl.h>
33 #include <unistd.h>
34
35 #include "windows.h"
36 #include "comm.h"
37 #include "heap.h"
38 #include "options.h"
39 #include "debug.h"
40
41 #ifndef TIOCINQ
42 #define TIOCINQ FIONREAD
43 #endif
44 #define msr 35 /* offset in unknown structure commMask */
45 /*
46 * [RER] These are globals are wrong. They should be in DosDeviceStruct
47 * on a per port basis.
48 */
49 int commerror = 0, eventmask = 0;
50
51 struct DosDeviceStruct COM[MAX_PORTS];
52 struct DosDeviceStruct LPT[MAX_PORTS];
53 LPCVOID *unknown[MAX_PORTS];
54
55 void COMM_Init(void)
56 {
57 int x;
58 char option[10], temp[256], *btemp;
59 struct stat st;
60
61 for (x=0; x!=MAX_PORTS; x++) {
62 strcpy(option,"COMx");
63 option[3] = '1' + x;
64 option[4] = '\0';
65
66 PROFILE_GetWineIniString( "serialports", option, "*",
67 temp, sizeof(temp) );
68 if (!strcmp(temp, "*") || *temp == '\0')
69 COM[x].devicename = NULL;
70 else {
71 btemp = strchr(temp,',');
72 if (btemp != NULL) {
73 *btemp++ = '\0';
74 COM[x].baudrate = atoi(btemp);
75 } else {
76 COM[x].baudrate = -1;
77 }
78 stat(temp, &st);
79 if (!S_ISCHR(st.st_mode))
80 WARN(comm,"Can't use `%s' as %s !\n", temp, option);
81 else
82 if ((COM[x].devicename = malloc(strlen(temp)+1)) == NULL)
83 WARN(comm,"Can't malloc for device info!\n");
84 else {
85 COM[x].fd = 0;
86 strcpy(COM[x].devicename, temp);
87 }
88 TRACE(comm, "%s = %s\n", option, COM[x].devicename);
89 }
90
91 strcpy(option, "LPTx");
92 option[3] = '1' + x;
93 option[4] = '\0';
94
95 PROFILE_GetWineIniString( "parallelports", option, "*",
96 temp, sizeof(temp) );
97 if (!strcmp(temp, "*") || *temp == '\0')
98 LPT[x].devicename = NULL;
99 else {
100 stat(temp, &st);
101 if (!S_ISCHR(st.st_mode))
102 WARN(comm,"Can't use `%s' as %s !\n", temp, option);
103 else
104 if ((LPT[x].devicename = malloc(strlen(temp)+1)) == NULL)
105 WARN(comm,"Can't malloc for device info!\n");
106 else {
107 LPT[x].fd = 0;
108 strcpy(LPT[x].devicename, temp);
109 }
110 TRACE(comm, "%s = %s\n", option, LPT[x].devicename);
111 }
112
113 }
114 }
115
116
117 struct DosDeviceStruct *GetDeviceStruct(int fd)
118 {
119 int x;
120
121 for (x=0; x!=MAX_PORTS; x++) {
122 if (COM[x].fd == fd)
123 return &COM[x];
124 if (LPT[x].fd == fd)
125 return &LPT[x];
126 }
127
128 return NULL;
129 }
130
131 int GetCommPort(int fd)
132 {
133 int x;
134
135 for (x=0; x<MAX_PORTS; x++) {
136 if (COM[x].fd == fd)
137 return x;
138 }
139
140 return -1;
141 }
142
143 int ValidCOMPort(int x)
144 {
145 return(x < MAX_PORTS ? (int) COM[x].devicename : 0);
146 }
147
148 int ValidLPTPort(int x)
149 {
150 return(x < MAX_PORTS ? (int) LPT[x].devicename : 0);
151 }
152
153 int WinError(void)
154 {
155 TRACE(comm, "errno = %d\n", errno);
156 switch (errno) {
157 default:
158 return CE_IOE;
159 }
160 }
161
162 /**************************************************************************
163 * BuildCommDCB (USER.213)
164 */
165 BOOL16 WINAPI BuildCommDCB16(LPCSTR device, LPDCB16 lpdcb)
166 {
167 /* "COM1:9600,n,8,1" */
168 /* 012345 */
169 int port;
170 char *ptr, temp[256];
171
172 TRACE(comm, "(%s), ptr %p\n", device, lpdcb);
173 commerror = 0;
174
175 if (!lstrncmpi32A(device,"COM",3)) {
176 port = device[3] - '0';
177
178
179 if (port-- == 0) {
180 ERR(comm, "BUG ! COM0 can't exists!.\n");
181 commerror = IE_BADID;
182 }
183
184 if (!ValidCOMPort(port)) {
185 commerror = IE_BADID;
186 return -1;
187 }
188
189 memset(lpdcb, 0, sizeof(DCB16)); /* initialize */
190
191 if (!COM[port].fd) {
192 OpenComm(device, 0, 0);
193 }
194 lpdcb->Id = COM[port].fd;
195
196 if (!*(device+4))
197 return 0;
198
199 if (*(device+4) != ':')
200 return -1;
201
202 strcpy(temp,device+5);
203 ptr = strtok(temp, ", ");
204
205 if (COM[port].baudrate > 0)
206 lpdcb->BaudRate = COM[port].baudrate;
207 else
208 lpdcb->BaudRate = atoi(ptr);
209 TRACE(comm,"baudrate (%d)\n", lpdcb->BaudRate);
210
211 ptr = strtok(NULL, ", ");
212 if (islower(*ptr))
213 *ptr = toupper(*ptr);
214
215 TRACE(comm,"parity (%c)\n", *ptr);
216 lpdcb->fParity = 1;
217 switch (*ptr) {
218 case 'N':
219 lpdcb->Parity = NOPARITY;
220 lpdcb->fParity = 0;
221 break;
222 case 'E':
223 lpdcb->Parity = EVENPARITY;
224 break;
225 case 'M':
226 lpdcb->Parity = MARKPARITY;
227 break;
228 case 'O':
229 lpdcb->Parity = ODDPARITY;
230 break;
231 default:
232 WARN(comm,"Unknown parity `%c'!\n", *ptr);
233 return -1;
234 }
235
236 ptr = strtok(NULL, ", ");
237 TRACE(comm, "charsize (%c)\n", *ptr);
238 lpdcb->ByteSize = *ptr - '0';
239
240 ptr = strtok(NULL, ", ");
241 TRACE(comm, "stopbits (%c)\n", *ptr);
242 switch (*ptr) {
243 case '1':
244 lpdcb->StopBits = ONESTOPBIT;
245 break;
246 case '2':
247 lpdcb->StopBits = TWOSTOPBITS;
248 break;
249 default:
250 WARN(comm,"Unknown # of stopbits `%c'!\n", *ptr);
251 return -1;
252 }
253 }
254
255 return 0;
256 }
257
258 /**************************************************************************
259 * BuildCommDCBA (KERNEL32.14)
260 */
261 BOOL32 WINAPI BuildCommDCB32A(LPCSTR device,LPDCB32 lpdcb)
262 {
263 return BuildCommDCBAndTimeouts32A(device,lpdcb,NULL);
264 }
265
266 /**************************************************************************
267 * BuildCommDCBAndTimeoutsA (KERNEL32.15)
268 */
269 BOOL32 WINAPI BuildCommDCBAndTimeouts32A(LPCSTR device, LPDCB32 lpdcb,
270 LPCOMMTIMEOUTS lptimeouts)
271 {
272 int port;
273 char *ptr,*temp;
274
275 TRACE(comm,"(%s,%p,%p)\n",device,lpdcb,lptimeouts);
276 commerror = 0;
277
278 if (!lstrncmpi32A(device,"COM",3)) {
279 port=device[3]-'0';
280 if (port--==0) {
281 ERR(comm,"BUG! COM0 can't exists!.\n");
282 return FALSE;
283 }
284 if (!ValidCOMPort(port))
285 return FALSE;
286 if (*(device+4)!=':')
287 return FALSE;
288 temp=(LPSTR)(device+5);
289 } else
290 temp=(LPSTR)device;
291
292 memset(lpdcb, 0, sizeof(DCB32)); /* initialize */
293
294 lpdcb->DCBlength = sizeof(DCB32);
295 if (strchr(temp,',')) { /* old style */
296 DCB16 dcb16;
297 BOOL16 ret;
298 char last=temp[strlen(temp)-1];
299
300 ret=BuildCommDCB16(device,&dcb16);
301 if (!ret)
302 return FALSE;
303 lpdcb->BaudRate = dcb16.BaudRate;
304 lpdcb->ByteSize = dcb16.ByteSize;
305 lpdcb->fBinary = dcb16.fBinary;
306 lpdcb->Parity = dcb16.Parity;
307 lpdcb->fParity = dcb16.fParity;
308 lpdcb->fNull = dcb16.fNull;
309 lpdcb->StopBits = dcb16.StopBits;
310 if (last == 'x') {
311 lpdcb->fInX = TRUE;
312 lpdcb->fOutX = TRUE;
313 lpdcb->fOutxCtsFlow = FALSE;
314 lpdcb->fOutxDsrFlow = FALSE;
315 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
316 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
317 } else if (last=='p') {
318 lpdcb->fInX = FALSE;
319 lpdcb->fOutX = FALSE;
320 lpdcb->fOutxCtsFlow = TRUE;
321 lpdcb->fOutxDsrFlow = TRUE;
322 lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
323 lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
324 } else {
325 lpdcb->fInX = FALSE;
326 lpdcb->fOutX = FALSE;
327 lpdcb->fOutxCtsFlow = FALSE;
328 lpdcb->fOutxDsrFlow = FALSE;
329 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
330 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
331 }
332 lpdcb->XonChar = dcb16.XonChar;
333 lpdcb->XoffChar = dcb16.XoffChar;
334 lpdcb->ErrorChar= dcb16.PeChar;
335 lpdcb->fErrorChar= dcb16.fPeChar;
336 lpdcb->EofChar = dcb16.EofChar;
337 lpdcb->EvtChar = dcb16.EvtChar;
338 lpdcb->XonLim = dcb16.XonLim;
339 lpdcb->XoffLim = dcb16.XoffLim;
340 return TRUE;
341 }
342 ptr=strtok(temp," ");
343 while (ptr) {
344 DWORD flag,x;
345
346 flag=0;
347 if (!strncmp("baud=",ptr,5)) {
348 if (!sscanf(ptr+5,"%ld",&x))
349 WARN(comm,"Couldn't parse %s\n",ptr);
350 lpdcb->BaudRate = x;
351 flag=1;
352 }
353 if (!strncmp("stop=",ptr,5)) {
354 if (!sscanf(ptr+5,"%ld",&x))
355 WARN(comm,"Couldn't parse %s\n",ptr);
356 lpdcb->StopBits = x;
357 flag=1;
358 }
359 if (!strncmp("data=",ptr,5)) {
360 if (!sscanf(ptr+5,"%ld",&x))
361 WARN(comm,"Couldn't parse %s\n",ptr);
362 lpdcb->ByteSize = x;
363 flag=1;
364 }
365 if (!strncmp("parity=",ptr,7)) {
366 lpdcb->fParity = TRUE;
367 switch (ptr[8]) {
368 case 'N':case 'n':
369 lpdcb->fParity = FALSE;
370 lpdcb->Parity = NOPARITY;
371 break;
372 case 'E':case 'e':
373 lpdcb->Parity = EVENPARITY;
374 break;
375 case 'O':case 'o':
376 lpdcb->Parity = ODDPARITY;
377 break;
378 case 'M':case 'm':
379 lpdcb->Parity = MARKPARITY;
380 break;
381 }
382 flag=1;
383 }
384 if (!flag)
385 ERR(comm,"Unhandled specifier '%s', please report.\n",ptr);
386 ptr=strtok(NULL," ");
387 }
388 if (lpdcb->BaudRate==110)
389 lpdcb->StopBits = 2;
390 return TRUE;
391 }
392
393 /**************************************************************************
394 * BuildCommDCBAndTimeoutsW (KERNEL32.16)
395 */
396 BOOL32 WINAPI BuildCommDCBAndTimeouts32W( LPCWSTR devid, LPDCB32 lpdcb,
397 LPCOMMTIMEOUTS lptimeouts )
398 {
399 LPSTR devidA;
400 BOOL32 ret;
401
402 TRACE(comm,"(%p,%p,%p)\n",devid,lpdcb,lptimeouts);
403 devidA = HEAP_strdupWtoA( GetProcessHeap(), 0, devid );
404 ret=BuildCommDCBAndTimeouts32A(devidA,lpdcb,lptimeouts);
405 HeapFree( GetProcessHeap(), 0, devidA );
406 return ret;
407 }
408
409 /**************************************************************************
410 * BuildCommDCBW (KERNEL32.17)
411 */
412 BOOL32 WINAPI BuildCommDCB32W(LPCWSTR devid,LPDCB32 lpdcb)
413 {
414 return BuildCommDCBAndTimeouts32W(devid,lpdcb,NULL);
415 }
416
417 /*****************************************************************************
418 * OpenComm (USER.200)
419 */
420 INT16 WINAPI OpenComm(LPCSTR device,UINT16 cbInQueue,UINT16 cbOutQueue)
421 {
422 int port,fd;
423
424 TRACE(comm, "%s, %d, %d\n", device, cbInQueue, cbOutQueue);
425 commerror = 0;
426
427 if (!lstrncmpi32A(device,"COM",3)) {
428 port = device[3] - '0';
429
430 if (port-- == 0) {
431 ERR(comm, "BUG ! COM0 doesn't exist !\n");
432 commerror = IE_BADID;
433 }
434
435 TRACE(comm, "%s = %s\n", device, COM[port].devicename);
436
437 if (!ValidCOMPort(port)) {
438 commerror = IE_BADID;
439 return -1;
440 }
441 if (COM[port].fd) {
442 return COM[port].fd;
443 }
444
445 fd = open(COM[port].devicename, O_RDWR | O_NONBLOCK);
446 if (fd == -1) {
447 commerror = WinError();
448 return -1;
449 } else {
450 unknown[port] = SEGPTR_ALLOC(40);
451 bzero(unknown[port],40);
452 COM[port].fd = fd;
453 return fd;
454 }
455 }
456 else
457 if (!lstrncmpi32A(device,"LPT",3)) {
458 port = device[3] - '0';
459
460 if (!ValidLPTPort(port)) {
461 commerror = IE_BADID;
462 return -1;
463 }
464 if (LPT[port].fd) {
465 commerror = IE_OPEN;
466 return -1;
467 }
468
469 fd = open(LPT[port].devicename, O_RDWR | O_NONBLOCK, 0);
470 if (fd == -1) {
471 commerror = WinError();
472 return -1;
473 } else {
474 LPT[port].fd = fd;
475 return fd;
476 }
477 }
478 return 0;
479 }
480
481 /*****************************************************************************
482 * CloseComm (USER.207)
483 */
484 INT16 WINAPI CloseComm(INT16 fd)
485 {
486 int port;
487 TRACE(comm,"fd %d\n", fd);
488 if ((port = GetCommPort(fd)) !=-1) { /* [LW] */
489 SEGPTR_FREE(unknown[port]);
490 COM[port].fd = 0; /* my adaptation of RER's fix */
491 } else {
492 commerror = IE_BADID;
493 return -1;
494 }
495
496 if (close(fd) == -1) {
497 commerror = WinError();
498 return -1;
499 } else {
500 commerror = 0;
501 return 0;
502 }
503 }
504
505 /*****************************************************************************
506 * SetCommBreak (USER.210)
507 */
508 INT16 WINAPI SetCommBreak16(INT16 fd)
509 {
510 struct DosDeviceStruct *ptr;
511
512 TRACE(comm,"fd=%d\n", fd);
513 if ((ptr = GetDeviceStruct(fd)) == NULL) {
514 commerror = IE_BADID;
515 return -1;
516 }
517
518 ptr->suspended = 1;
519 commerror = 0;
520 return 0;
521 }
522
523 /*****************************************************************************
524 * SetCommBreak (KERNEL32.449)
525 */
526 BOOL32 WINAPI SetCommBreak32(INT32 fd)
527 {
528
529 struct DosDeviceStruct *ptr;
530
531 TRACE(comm,"fd=%d\n", fd);
532 if ((ptr = GetDeviceStruct(fd)) == NULL) {
533 commerror = IE_BADID;
534 return FALSE;
535 }
536
537 ptr->suspended = 1;
538 commerror = 0;
539 return TRUE;
540 }
541
542 /*****************************************************************************
543 * ClearCommBreak (USER.211)
544 */
545 INT16 WINAPI ClearCommBreak16(INT16 fd)
546 {
547 struct DosDeviceStruct *ptr;
548
549 TRACE(comm,"fd=%d\n", fd);
550 if ((ptr = GetDeviceStruct(fd)) == NULL) {
551 commerror = IE_BADID;
552 return -1;
553 }
554
555 ptr->suspended = 0;
556 commerror = 0;
557 return 0;
558 }
559
560 /*****************************************************************************
561 * ClearCommBreak (KERNEL32.20)
562 */
563 BOOL32 WINAPI ClearCommBreak32(INT32 fd)
564 {
565 struct DosDeviceStruct *ptr;
566
567 TRACE(comm,"fd=%d\n", fd);
568 if ((ptr = GetDeviceStruct(fd)) == NULL) {
569 commerror = IE_BADID;
570 return FALSE;
571 }
572
573 ptr->suspended = 0;
574 commerror = 0;
575 return TRUE;
576 }
577
578 /*****************************************************************************
579 * EscapeCommFunction (USER.214)
580 */
581 LONG WINAPI EscapeCommFunction16(UINT16 fd,UINT16 nFunction)
582 {
583 int max;
584 struct termios port;
585
586 TRACE(comm,"fd=%d, function=%d\n", fd, nFunction);
587 if (tcgetattr(fd,&port) == -1) {
588 commerror=WinError();
589 return -1;
590 }
591
592 switch (nFunction) {
593 case RESETDEV:
594 break;
595
596 case GETMAXCOM:
597 for (max = MAX_PORTS;!COM[max].devicename;max--)
598 ;
599 return max;
600 break;
601
602 case GETMAXLPT:
603 for (max = MAX_PORTS;!LPT[max].devicename;max--)
604 ;
605 return 0x80 + max;
606 break;
607
608 #ifdef TIOCM_DTR
609 case CLRDTR:
610 port.c_cflag &= TIOCM_DTR;
611 break;
612 #endif
613
614 #ifdef TIOCM_RTS
615 case CLRRTS:
616 port.c_cflag &= TIOCM_RTS;
617 break;
618 #endif
619
620 #ifdef CRTSCTS
621 case SETDTR:
622 port.c_cflag |= CRTSCTS;
623 break;
624
625 case SETRTS:
626 port.c_cflag |= CRTSCTS;
627 break;
628 #endif
629
630 case SETXOFF:
631 port.c_iflag |= IXOFF;
632 break;
633
634 case SETXON:
635 port.c_iflag |= IXON;
636 break;
637
638 default:
639 WARN(comm,"(fd=%d,nFunction=%d): Unknown function\n",
640 fd, nFunction);
641 break;
642 }
643
644 if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
645 commerror = WinError();
646 return -1;
647 } else {
648 commerror = 0;
649 return 0;
650 }
651 }
652
653 /*****************************************************************************
654 * EscapeCommFunction (KERNEL32.214)
655 */
656 BOOL32 WINAPI EscapeCommFunction32(INT32 fd,UINT32 nFunction)
657 {
658 struct termios port;
659 struct DosDeviceStruct *ptr;
660
661 TRACE(comm,"fd=%d, function=%d\n", fd, nFunction);
662 if (tcgetattr(fd,&port) == -1) {
663 commerror=WinError();
664 return FALSE;
665 }
666 if ((ptr = GetDeviceStruct(fd)) == NULL) {
667 commerror = IE_BADID;
668 return FALSE;
669 }
670
671 switch (nFunction) {
672 case RESETDEV:
673 break;
674
675 #ifdef TIOCM_DTR
676 case CLRDTR:
677 port.c_cflag &= TIOCM_DTR;
678 break;
679 #endif
680
681 #ifdef TIOCM_RTS
682 case CLRRTS:
683 port.c_cflag &= TIOCM_RTS;
684 break;
685 #endif
686
687 #ifdef CRTSCTS
688 case SETDTR:
689 port.c_cflag |= CRTSCTS;
690 break;
691
692 case SETRTS:
693 port.c_cflag |= CRTSCTS;
694 break;
695 #endif
696
697 case SETXOFF:
698 port.c_iflag |= IXOFF;
699 break;
700
701 case SETXON:
702 port.c_iflag |= IXON;
703 break;
704 case SETBREAK:
705 ptr->suspended = 1;
706 break;
707 case CLRBREAK:
708 ptr->suspended = 0;
709 break;
710 default:
711 WARN(comm,"(fd=%d,nFunction=%d): Unknown function\n",
712 fd, nFunction);
713 break;
714 }
715
716 if (tcsetattr(fd, TCSADRAIN, &port) == -1) {
717 commerror = WinError();
718 return FALSE;
719 } else {
720 commerror = 0;
721 return TRUE;
722 }
723 }
724
725 /*****************************************************************************
726 * FlushComm (USER.215)
727 */
728 INT16 WINAPI FlushComm(INT16 fd,INT16 fnQueue)
729 {
730 int queue;
731
732 TRACE(comm,"fd=%d, queue=%d\n", fd, fnQueue);
733 switch (fnQueue) {
734 case 0: queue = TCOFLUSH;
735 break;
736 case 1: queue = TCIFLUSH;
737 break;
738 default:WARN(comm,"(fd=%d,fnQueue=%d):Unknown queue\n",
739 fd, fnQueue);
740 return -1;
741 }
742 if (tcflush(fd, queue)) {
743 commerror = WinError();
744 return -1;
745 } else {
746 commerror = 0;
747 return 0;
748 }
749 }
750
751 /********************************************************************
752 * PurgeComm (KERNEL32.557)
753 */
754 BOOL32 WINAPI PurgeComm( HANDLE32 hFile, DWORD flags)
755 {
756 FIXME(comm, "(%08x %08lx) unimplemented stub\n",
757 hFile, flags);
758 return 0;
759 }
760
761 /********************************************************************
762 * GetCommError (USER.203)
763 */
764 INT16 WINAPI GetCommError(INT16 fd,LPCOMSTAT lpStat)
765 {
766 int temperror;
767 unsigned long cnt;
768 int rc;
769
770 if (lpStat) {
771 lpStat->status = 0;
772
773 rc = ioctl(fd, TIOCOUTQ, &cnt);
774 if (rc) WARN(comm, "Error !\n");
775 lpStat->cbOutQue = cnt;
776
777 rc = ioctl(fd, TIOCINQ, &cnt);
778 if (rc) WARN(comm, "Error !\n");
779 lpStat->cbInQue = cnt;
780
781 TRACE(comm, "fd %d, error %d, lpStat %d %d %d\n",
782 fd, commerror, lpStat->status, lpStat->cbInQue,
783 lpStat->cbOutQue);
784 }
785 else
786 TRACE(comm, "fd %d, error %d, lpStat NULL\n",
787 fd, commerror);
788
789 /*
790 * [RER] I have no idea what the following is trying to accomplish.
791 * [RER] It is certainly not what the reference manual suggests.
792 */
793 temperror = commerror;
794 commerror = 0;
795 return(temperror);
796 }
797
798 /*****************************************************************************
799 * ClearCommError (KERNEL32.21)
800 */
801 BOOL32 WINAPI ClearCommError(INT32 fd,LPDWORD errors,LPCOMSTAT lpStat)
802 {
803 int temperror;
804
805 TRACE(comm, "fd %d (current error %d)\n",
806 fd, commerror);
807 temperror = commerror;
808 commerror = 0;
809 return TRUE;
810 }
811
812 /*****************************************************************************
813 * SetCommEventMask (USER.208)
814 */
815 SEGPTR WINAPI SetCommEventMask(INT16 fd,UINT16 fuEvtMask)
816 {
817 unsigned char *stol;
818 int act;
819 int repid;
820 unsigned int mstat;
821 TRACE(comm,"fd %d,mask %d\n",fd,fuEvtMask);
822 eventmask |= fuEvtMask;
823 if ((act = GetCommPort(fd)) == -1) {
824 WARN(comm," fd %d not comm port\n",act);
825 return NULL;}
826 stol = unknown[act];
827 stol += msr;
828 repid = ioctl(fd,TIOCMGET,&mstat);
829 TRACE(comm, " ioctl %d, msr %x at %p %p\n",repid,mstat,stol,unknown[act]);
830 if ((mstat&TIOCM_CAR)) {*stol |= 0x80;}
831 else {*stol &=0x7f;}
832 TRACE(comm," modem dcd construct %x\n",*stol);
833 return SEGPTR_GET(unknown[act]);
834 }
835
836 /*****************************************************************************
837 * GetCommEventMask (USER.209)
838 */
839 UINT16 WINAPI GetCommEventMask(INT16 fd,UINT16 fnEvtClear)
840 {
841 int events = 0;
842
843 TRACE(comm, "fd %d, mask %d\n", fd, fnEvtClear);
844
845 /*
846 * Determine if any characters are available
847 */
848 if (fnEvtClear & EV_RXCHAR)
849 {
850 int rc;
851 unsigned long cnt;
852
853 rc = ioctl(fd, TIOCINQ, &cnt);
854 if (cnt) events |= EV_RXCHAR;
855
856 TRACE(comm, "rxchar %ld\n", cnt);
857 }
858
859 /*
860 * There are other events that need to be checked for
861 */
862 /* TODO */
863
864 TRACE(comm, "return events %d\n", events);
865 return events;
866
867 /*
868 * [RER] The following was gibberish
869 */
870 #if 0
871 tempmask = eventmask;
872 eventmask &= ~fnEvtClear;
873 return eventmask;
874 #endif
875 }
876
877 /*****************************************************************************
878 * SetupComm (KERNEL32.676)
879 */
880 BOOL32 WINAPI SetupComm( HANDLE32 hFile, DWORD insize, DWORD outsize)
881 {
882 FIXME(comm, "insize %ld outsize %ld unimplemented stub\n", insize, outsize);
883 return FALSE;
884 }
885
886 /*****************************************************************************
887 * GetCommMask (KERNEL32.156)
888 */
889 BOOL32 WINAPI GetCommMask(INT32 fd,LPDWORD evtmask)
890 {
891 TRACE(comm, "fd %d, mask %p\n", fd, evtmask);
892 *evtmask = eventmask;
893 return TRUE;
894 }
895
896 /*****************************************************************************
897 * SetCommMask (KERNEL32.451)
898 */
899 BOOL32 WINAPI SetCommMask(INT32 fd,DWORD evtmask)
900 {
901 TRACE(comm, "fd %d, mask %lx\n", fd, evtmask);
902 eventmask = evtmask;
903 return TRUE;
904 }
905
906 /*****************************************************************************
907 * SetCommState16 (USER.201)
908 */
909 INT16 WINAPI SetCommState16(LPDCB16 lpdcb)
910 {
911 struct termios port;
912 struct DosDeviceStruct *ptr;
913
914 TRACE(comm, "fd %d, ptr %p\n", lpdcb->Id, lpdcb);
915 if (tcgetattr(lpdcb->Id, &port) == -1) {
916 commerror = WinError();
917 return -1;
918 }
919
920 port.c_cc[VMIN] = 0;
921 port.c_cc[VTIME] = 1;
922
923 #ifdef IMAXBEL
924 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
925 #else
926 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
927 #endif
928 port.c_iflag |= (IGNBRK);
929
930 port.c_oflag &= ~(OPOST);
931
932 port.c_cflag &= ~(HUPCL);
933 port.c_cflag |= CLOCAL | CREAD;
934
935 port.c_lflag &= ~(ICANON|ECHO|ISIG);
936 port.c_lflag |= NOFLSH;
937
938 if ((ptr = GetDeviceStruct(lpdcb->Id)) == NULL) {
939 commerror = IE_BADID;
940 return -1;
941 }
942 if (ptr->baudrate > 0)
943 lpdcb->BaudRate = ptr->baudrate;
944 TRACE(comm,"baudrate %d\n",lpdcb->BaudRate);
945 #ifdef CBAUD
946 port.c_cflag &= ~CBAUD;
947 switch (lpdcb->BaudRate) {
948 case 110:
949 case CBR_110:
950 port.c_cflag |= B110;
951 break;
952 case 300:
953 case CBR_300:
954 port.c_cflag |= B300;
955 break;
956 case 600:
957 case CBR_600:
958 port.c_cflag |= B600;
959 break;
960 case 1200:
961 case CBR_1200:
962 port.c_cflag |= B1200;
963 break;
964 case 2400:
965 case CBR_2400:
966 port.c_cflag |= B2400;
967 break;
968 case 4800:
969 case CBR_4800:
970 port.c_cflag |= B4800;
971 break;
972 case 9600:
973 case CBR_9600:
974 port.c_cflag |= B9600;
975 break;
976 case 19200:
977 case CBR_19200:
978 port.c_cflag |= B19200;
979 break;
980 case 38400:
981 case CBR_38400:
982 port.c_cflag |= B38400;
983 break;
984 case 57600:
985 port.c_cflag |= B57600;
986 break;
987 case 57601:
988 port.c_cflag |= B115200;
989 break;
990 default:
991 commerror = IE_BAUDRATE;
992 return -1;
993 }
994 #elif !defined(__EMX__)
995 switch (lpdcb->BaudRate) {
996 case 110:
997 case CBR_110:
998 port.c_ospeed = B110;
999 break;
1000 case 300:
1001 case CBR_300:
1002 port.c_ospeed = B300;
1003 break;
1004 case 600:
1005 case CBR_600:
1006 port.c_ospeed = B600;
1007 break;
1008 case 1200:
1009 case CBR_1200:
1010 port.c_ospeed = B1200;
1011 break;
1012 case 2400:
1013 case CBR_2400:
1014 port.c_ospeed = B2400;
1015 break;
1016 case 4800:
1017 case CBR_4800:
1018 port.c_ospeed = B4800;
1019 break;
1020 case 9600:
1021 case CBR_9600:
1022 port.c_ospeed = B9600;
1023 break;
1024 case 19200:
1025 case CBR_19200:
1026 port.c_ospeed = B19200;
1027 break;
1028 case 38400:
1029 case CBR_38400:
1030 port.c_ospeed = B38400;
1031 break;
1032 default:
1033 commerror = IE_BAUDRATE;
1034 return -1;
1035 }
1036 port.c_ispeed = port.c_ospeed;
1037 #endif
1038 TRACE(comm,"bytesize %d\n",lpdcb->ByteSize);
1039 port.c_cflag &= ~CSIZE;
1040 switch (lpdcb->ByteSize) {
1041 case 5:
1042 port.c_cflag |= CS5;
1043 break;
1044 case 6:
1045 port.c_cflag |= CS6;
1046 break;
1047 case 7:
1048 port.c_cflag |= CS7;
1049 break;
1050 case 8:
1051 port.c_cflag |= CS8;
1052 break;
1053 default:
1054 commerror = IE_BYTESIZE;
1055 return -1;
1056 }
1057
1058 TRACE(comm,"parity %d\n",lpdcb->Parity);
1059 port.c_cflag &= ~(PARENB | PARODD);
1060 if (lpdcb->fParity)
1061 switch (lpdcb->Parity) {
1062 case NOPARITY:
1063 port.c_iflag &= ~INPCK;
1064 break;
1065 case ODDPARITY:
1066 port.c_cflag |= (PARENB | PARODD);
1067 port.c_iflag |= INPCK;
1068 break;
1069 case EVENPARITY:
1070 port.c_cflag |= PARENB;
1071 port.c_iflag |= INPCK;
1072 break;
1073 default:
1074 commerror = IE_BYTESIZE;
1075 return -1;
1076 }
1077
1078
1079 TRACE(comm,"stopbits %d\n",lpdcb->StopBits);
1080
1081 switch (lpdcb->StopBits) {
1082 case ONESTOPBIT:
1083 port.c_cflag &= ~CSTOPB;
1084 break;
1085 case TWOSTOPBITS:
1086 port.c_cflag |= CSTOPB;
1087 break;
1088 default:
1089 commerror = IE_BYTESIZE;
1090 return -1;
1091 }
1092 #ifdef CRTSCTS
1093
1094 if (lpdcb->fDtrflow || lpdcb->fRtsflow || lpdcb->fOutxCtsFlow)
1095 port.c_cflag |= CRTSCTS;
1096
1097 if (lpdcb->fDtrDisable)
1098 port.c_cflag &= ~CRTSCTS;
1099 #endif
1100 if (lpdcb->fInX)
1101 port.c_iflag |= IXON;
1102 else
1103 port.c_iflag &= ~IXON;
1104 if (lpdcb->fOutX)
1105 port.c_iflag |= IXOFF;
1106 else
1107 port.c_iflag &= ~IXOFF;
1108
1109 if (tcsetattr(lpdcb->Id, TCSADRAIN, &port) == -1) {
1110 commerror = WinError();
1111 return FALSE;
1112 } else {
1113 commerror = 0;
1114 return 0;
1115 }
1116 }
1117
1118 /*****************************************************************************
1119 * SetCommState32 (KERNEL32.452)
1120 */
1121 BOOL32 WINAPI SetCommState32(INT32 fd,LPDCB32 lpdcb)
1122 {
1123 struct termios port;
1124 struct DosDeviceStruct *ptr;
1125
1126 TRACE(comm,"fd %d, ptr %p\n",fd,lpdcb);
1127 if (tcgetattr(fd,&port) == -1) {
1128 commerror = WinError();
1129 return FALSE;
1130 }
1131
1132 port.c_cc[VMIN] = 0;
1133 port.c_cc[VTIME] = 1;
1134
1135 #ifdef IMAXBEL
1136 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR|IMAXBEL);
1137 #else
1138 port.c_iflag &= ~(ISTRIP|BRKINT|IGNCR|ICRNL|INLCR);
1139 #endif
1140 port.c_iflag |= (IGNBRK);
1141
1142 port.c_oflag &= ~(OPOST);
1143
1144 port.c_cflag &= ~(HUPCL);
1145 port.c_cflag |= CLOCAL | CREAD;
1146
1147 port.c_lflag &= ~(ICANON|ECHO|ISIG);
1148 port.c_lflag |= NOFLSH;
1149
1150 if ((ptr = GetDeviceStruct(fd)) == NULL) {
1151 commerror = IE_BADID;
1152 return FALSE;
1153 }
1154 if (ptr->baudrate > 0)
1155 lpdcb->BaudRate = ptr->baudrate;
1156 TRACE(comm,"baudrate %ld\n",lpdcb->BaudRate);
1157 #ifdef CBAUD
1158 port.c_cflag &= ~CBAUD;
1159 switch (lpdcb->BaudRate) {
1160 case 110:
1161 case CBR_110:
1162 port.c_cflag |= B110;
1163 break;
1164 case 300:
1165 case CBR_300:
1166 port.c_cflag |= B300;
1167 break;
1168 case 600:
1169 case CBR_600:
1170 port.c_cflag |= B600;
1171 break;
1172 case 1200:
1173 case CBR_1200:
1174 port.c_cflag |= B1200;
1175 break;
1176 case 2400:
1177 case CBR_2400:
1178 port.c_cflag |= B2400;
1179 break;
1180 case 4800:
1181 case CBR_4800:
1182 port.c_cflag |= B4800;
1183 break;
1184 case 9600:
1185 case CBR_9600:
1186 port.c_cflag |= B9600;
1187 break;
1188 case 19200:
1189 case CBR_19200:
1190 port.c_cflag |= B19200;
1191 break;
1192 case 38400:
1193 case CBR_38400:
1194 port.c_cflag |= B38400;
1195 break;
1196 default:
1197 commerror = IE_BAUDRATE;
1198 return FALSE;
1199 }
1200 #elif !defined(__EMX__)
1201 switch (lpdcb->BaudRate) {
1202 case 110:
1203 case CBR_110:
1204 port.c_ospeed = B110;
1205 break;
1206 case 300:
1207 case CBR_300:
1208 port.c_ospeed = B300;
1209 break;
1210 case 600:
1211 case CBR_600:
1212 port.c_ospeed = B600;
1213 break;
1214 case 1200:
1215 case CBR_1200:
1216 port.c_ospeed = B1200;
1217 break;
1218 case 2400:
1219 case CBR_2400:
1220 port.c_ospeed = B2400;
1221 break;
1222 case 4800:
1223 case CBR_4800:
1224 port.c_ospeed = B4800;
1225 break;
1226 case 9600:
1227 case CBR_9600:
1228 port.c_ospeed = B9600;
1229 break;
1230 case 19200:
1231 case CBR_19200:
1232 port.c_ospeed = B19200;
1233 break;
1234 case 38400:
1235 case CBR_38400:
1236 port.c_ospeed = B38400;
1237 break;
1238 default:
1239 commerror = IE_BAUDRATE;
1240 return FALSE;
1241 }
1242 port.c_ispeed = port.c_ospeed;
1243 #endif
1244 TRACE(comm,"bytesize %d\n",lpdcb->ByteSize);
1245 port.c_cflag &= ~CSIZE;
1246 switch (lpdcb->ByteSize) {
1247 case 5:
1248 port.c_cflag |= CS5;
1249 break;
1250 case 6:
1251 port.c_cflag |= CS6;
1252 break;
1253 case 7:
1254 port.c_cflag |= CS7;
1255 break;
1256 case 8:
1257 port.c_cflag |= CS8;
1258 break;
1259 default:
1260 commerror = IE_BYTESIZE;
1261 return FALSE;
1262 }
1263
1264 TRACE(comm,"parity %d\n",lpdcb->Parity);
1265 port.c_cflag &= ~(PARENB | PARODD);
1266 if (lpdcb->fParity)
1267 switch (lpdcb->Parity) {
1268 case NOPARITY:
1269 port.c_iflag &= ~INPCK;
1270 break;
1271 case ODDPARITY:
1272 port.c_cflag |= (PARENB | PARODD);
1273 port.c_iflag |= INPCK;
1274 break;
1275 case EVENPARITY:
1276 port.c_cflag |= PARENB;
1277 port.c_iflag |= INPCK;
1278 break;
1279 default:
1280 commerror = IE_BYTESIZE;
1281 return FALSE;
1282 }
1283
1284
1285 TRACE(comm,"stopbits %d\n",lpdcb->StopBits);
1286 switch (lpdcb->StopBits) {
1287 case ONESTOPBIT:
1288 port.c_cflag &= ~CSTOPB;
1289 break;
1290 case TWOSTOPBITS:
1291 port.c_cflag |= CSTOPB;
1292 break;
1293 default:
1294 commerror = IE_BYTESIZE;
1295 return FALSE;
1296 }
1297 #ifdef CRTSCTS
1298 if ( lpdcb->fOutxCtsFlow ||
1299 lpdcb->fDtrControl == DTR_CONTROL_ENABLE||
1300 lpdcb->fRtsControl == RTS_CONTROL_ENABLE
1301 )
1302 port.c_cflag |= CRTSCTS;
1303 if (lpdcb->fDtrControl == DTR_CONTROL_DISABLE)
1304 port.c_cflag &= ~CRTSCTS;
1305
1306 #endif
1307 if (lpdcb->fInX)
1308 port.c_iflag |= IXON;
1309 else
1310 port.c_iflag &= ~IXON;
1311 if (lpdcb->fOutX)
1312 port.c_iflag |= IXOFF;
1313 else
1314 port.c_iflag &= ~IXOFF;
1315
1316 if (tcsetattr(fd,TCSADRAIN,&port)==-1) {
1317 commerror = WinError();
1318 return FALSE;
1319 } else {
1320 commerror = 0;
1321 return TRUE;
1322 }
1323 }
1324
1325
1326 /*****************************************************************************
1327 * GetCommState (USER.202)
1328 */
1329 INT16 WINAPI GetCommState16(INT16 fd, LPDCB16 lpdcb)
1330 {
1331 struct termios port;
1332
1333 TRACE(comm,"fd %d, ptr %p\n", fd, lpdcb);
1334 if (tcgetattr(fd, &port) == -1) {
1335 commerror = WinError();
1336 return -1;
1337 }
1338 lpdcb->Id = fd;
1339 #ifndef __EMX__
1340 #ifdef CBAUD
1341 switch (port.c_cflag & CBAUD) {
1342 #else
1343 switch (port.c_ospeed) {
1344 #endif
1345 case B110:
1346 lpdcb->BaudRate = 110;
1347 break;
1348 case B300:
1349 lpdcb->BaudRate = 300;
1350 break;
1351 case B600:
1352 lpdcb->BaudRate = 600;
1353 break;
1354 case B1200:
1355 lpdcb->BaudRate = 1200;
1356 break;
1357 case B2400:
1358 lpdcb->BaudRate = 2400;
1359 break;
1360 case B4800:
1361 lpdcb->BaudRate = 4800;
1362 break;
1363 case B9600:
1364 lpdcb->BaudRate = 9600;
1365 break;
1366 case B19200:
1367 lpdcb->BaudRate = 19200;
1368 break;
1369 case B38400:
1370 lpdcb->BaudRate = 38400;
1371 break;
1372 case B57600:
1373 lpdcb->BaudRate = 57600;
1374 break;
1375 case B115200:
1376 lpdcb->BaudRate = 57601;
1377 break;
1378 }
1379 #endif
1380 switch (port.c_cflag & CSIZE) {
1381 case CS5:
1382 lpdcb->ByteSize = 5;
1383 break;
1384 case CS6:
1385 lpdcb->ByteSize = 6;
1386 break;
1387 case CS7:
1388 lpdcb->ByteSize = 7;
1389 break;
1390 case CS8:
1391 lpdcb->ByteSize = 8;
1392 break;
1393 }
1394
1395 switch (port.c_cflag & ~(PARENB | PARODD)) {
1396 case 0:
1397 lpdcb->fParity = NOPARITY;
1398 break;
1399 case PARENB:
1400 lpdcb->fParity = EVENPARITY;
1401 break;
1402 case (PARENB | PARODD):
1403 lpdcb->fParity = ODDPARITY;
1404 break;
1405 }
1406
1407 if (port.c_cflag & CSTOPB)
1408 lpdcb->StopBits = TWOSTOPBITS;
1409 else
1410 lpdcb->StopBits = ONESTOPBIT;
1411
1412 lpdcb->RlsTimeout = 50;
1413 lpdcb->CtsTimeout = 50;
1414 lpdcb->DsrTimeout = 50;
1415 lpdcb->fNull = 0;
1416 lpdcb->fChEvt = 0;
1417 lpdcb->fBinary = 1;
1418 lpdcb->fDtrDisable = 0;
1419
1420 #ifdef CRTSCTS
1421
1422 if (port.c_cflag & CRTSCTS) {
1423 lpdcb->fDtrflow = 1;
1424 lpdcb->fRtsflow = 1;
1425 lpdcb->fOutxCtsFlow = 1;
1426 lpdcb->fOutxDsrFlow = 1;
1427 } else
1428 #endif
1429 lpdcb->fDtrDisable = 1;
1430
1431 if (port.c_iflag & IXON)
1432 lpdcb->fInX = 1;
1433 else
1434 lpdcb->fInX = 0;
1435
1436 if (port.c_iflag & IXOFF)
1437 lpdcb->fOutX = 1;
1438 else
1439 lpdcb->fOutX = 0;
1440 /*
1441 lpdcb->XonChar =
1442 lpdcb->XoffChar =
1443 */
1444 lpdcb->XonLim = 10;
1445 lpdcb->XoffLim = 10;
1446
1447 commerror = 0;
1448 return 0;
1449 }
1450
1451 /*****************************************************************************
1452 * GetCommState (KERNEL32.159)
1453 */
1454 BOOL32 WINAPI GetCommState32(INT32 fd, LPDCB32 lpdcb)
1455 {
1456 struct termios port;
1457
1458 TRACE(comm,"fd %d, ptr %p\n", fd, lpdcb);
1459 if (GetDeviceStruct(fd) == NULL) return FALSE;
1460 if (tcgetattr(fd, &port) == -1) {
1461 commerror = WinError();
1462 return FALSE;
1463 }
1464 #ifndef __EMX__
1465 #ifdef CBAUD
1466 switch (port.c_cflag & CBAUD) {
1467 #else
1468 switch (port.c_ospeed) {
1469 #endif
1470 case B110:
1471 lpdcb->BaudRate = 110;
1472 break;
1473 case B300:
1474 lpdcb->BaudRate = 300;
1475 break;
1476 case B600:
1477 lpdcb->BaudRate = 600;
1478 break;
1479 case B1200:
1480 lpdcb->BaudRate = 1200;
1481 break;
1482 case B2400:
1483 lpdcb->BaudRate = 2400;
1484 break;
1485 case B4800:
1486 lpdcb->BaudRate = 4800;
1487 break;
1488 case B9600:
1489 lpdcb->BaudRate = 9600;
1490 break;
1491 case B19200:
1492 lpdcb->BaudRate = 19200;
1493 break;
1494 case B38400:
1495 lpdcb->BaudRate = 38400;
1496 break;
1497 }
1498 #endif
1499 switch (port.c_cflag & CSIZE) {
1500 case CS5:
1501 lpdcb->ByteSize = 5;
1502 break;
1503 case CS6:
1504 lpdcb->ByteSize = 6;
1505 break;
1506 case CS7:
1507 lpdcb->ByteSize = 7;
1508 break;
1509 case CS8:
1510 lpdcb->ByteSize = 8;
1511 break;
1512 }
1513
1514 switch (port.c_cflag & ~(PARENB | PARODD)) {
1515 case 0:
1516 lpdcb->fParity = NOPARITY;
1517 break;
1518 case PARENB:
1519 lpdcb->fParity = EVENPARITY;
1520 break;
1521 case (PARENB | PARODD):
1522 lpdcb->fParity = ODDPARITY;
1523 break;
1524 }
1525
1526 if (port.c_cflag & CSTOPB)
1527 lpdcb->StopBits = TWOSTOPBITS;
1528 else
1529 lpdcb->StopBits = ONESTOPBIT;
1530
1531 lpdcb->fNull = 0;
1532 lpdcb->fBinary = 1;
1533
1534 #ifdef CRTSCTS
1535
1536 if (port.c_cflag & CRTSCTS) {
1537 lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
1538 lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
1539 lpdcb->fOutxCtsFlow = 1;
1540 lpdcb->fOutxDsrFlow = 1;
1541 } else
1542 #endif
1543 {
1544 lpdcb->fDtrControl = DTR_CONTROL_DISABLE;
1545 lpdcb->fRtsControl = RTS_CONTROL_DISABLE;
1546 }
1547 if (port.c_iflag & IXON)
1548 lpdcb->fInX = 1;
1549 else
1550 lpdcb->fInX = 0;
1551
1552 if (port.c_iflag & IXOFF)
1553 lpdcb->fOutX = 1;
1554 else
1555 lpdcb->fOutX = 0;
1556 /*
1557 lpdcb->XonChar =
1558 lpdcb->XoffChar =
1559 */
1560 lpdcb->XonLim = 10;
1561 lpdcb->XoffLim = 10;
1562
1563 commerror = 0;
1564 return TRUE;
1565 }
1566
1567 /*****************************************************************************
1568 * TransmitCommChar (USER.206)
1569 */
1570 INT16 WINAPI TransmitCommChar16(INT16 fd,CHAR chTransmit)
1571 {
1572 struct DosDeviceStruct *ptr;
1573
1574 TRACE(comm, "fd %d, data %d \n", fd, chTransmit);
1575 if ((ptr = GetDeviceStruct(fd)) == NULL) {
1576 commerror = IE_BADID;
1577 return -1;
1578 }
1579
1580 if (ptr->suspended) {
1581 commerror = IE_HARDWARE;
1582 return -1;
1583 }
1584
1585 if (write(fd, (void *) &chTransmit, 1) == -1) {
1586 commerror = WinError();
1587 return -1;
1588 } else {
1589 commerror = 0;
1590 return 0;
1591 }
1592 }
1593
1594 /*****************************************************************************
1595 * TransmitCommChar (KERNEL32.535)
1596 */
1597 BOOL32 WINAPI TransmitCommChar32(INT32 fd,CHAR chTransmit)
1598 {
1599 struct DosDeviceStruct *ptr;
1600
1601 TRACE(comm,"(%d,'%c')\n",fd,chTransmit);
1602 if ((ptr = GetDeviceStruct(fd)) == NULL) {
1603 commerror = IE_BADID;
1604 return FALSE;
1605 }
1606
1607 if (ptr->suspended) {
1608 commerror = IE_HARDWARE;
1609 return FALSE;
1610 }
1611 if (write(fd, (void *) &chTransmit, 1) == -1) {
1612 commerror = WinError();
1613 return FALSE;
1614 } else {
1615 commerror = 0;
1616 return TRUE;
1617 }
1618 }
1619
1620 /*****************************************************************************
1621 * UngetCommChar (USER.212)
1622 */
1623 INT16 WINAPI UngetCommChar(INT16 fd,CHAR chUnget)
1624 {
1625 struct DosDeviceStruct *ptr;
1626
1627 TRACE(comm,"fd %d (char %d)\n", fd, chUnget);
1628 if ((ptr = GetDeviceStruct(fd)) == NULL) {
1629 commerror = IE_BADID;
1630 return -1;
1631 }
1632
1633 if (ptr->suspended) {
1634 commerror = IE_HARDWARE;
1635 return -1;
1636 }
1637
1638 ptr->unget = 1;
1639 ptr->unget_byte = chUnget;
1640 commerror = 0;
1641 return 0;
1642 }
1643
1644 /*****************************************************************************
1645 * ReadComm (USER.204)
1646 */
1647 INT16 WINAPI ReadComm(INT16 fd,LPSTR lpvBuf,INT16 cbRead)
1648 {
1649 int status, length;
1650 struct DosDeviceStruct *ptr;
1651
1652 TRACE(comm, "fd %d, ptr %p, length %d\n", fd, lpvBuf, cbRead);
1653 if ((ptr = GetDeviceStruct(fd)) == NULL) {
1654 commerror = IE_BADID;
1655 return -1;
1656 }
1657
1658 if (ptr->suspended) {
1659 commerror = IE_HARDWARE;
1660 return -1;
1661 }
1662
1663 if (ptr->unget) {
1664 *lpvBuf = ptr->unget_byte;
1665 lpvBuf++;
1666 ptr->unget = 0;
1667
1668 length = 1;
1669 } else
1670 length = 0;
1671
1672 status = read(fd, (void *) lpvBuf, cbRead);
1673
1674 if (status == -1) {
1675 if (errno != EAGAIN) {
1676 commerror = WinError();
1677 return -1 - length;
1678 } else {
1679 commerror = 0;
1680 return length;
1681 }
1682 } else {
1683 TRACE(comm,"%*s\n", length+status, lpvBuf);
1684 commerror = 0;
1685 return length + status;
1686 }
1687 }
1688
1689 /*****************************************************************************
1690 * WriteComm (USER.205)
1691 */
1692 INT16 WINAPI WriteComm(INT16 fd, LPSTR lpvBuf, INT16 cbWrite)
1693 {
1694 int length;
1695 struct DosDeviceStruct *ptr;
1696
1697 TRACE(comm,"fd %d, ptr %p, length %d\n",
1698 fd, lpvBuf, cbWrite);
1699 if ((ptr = GetDeviceStruct(fd)) == NULL) {
1700 commerror = IE_BADID;
1701 return -1;
1702 }
1703
1704 if (ptr->suspended) {
1705 commerror = IE_HARDWARE;
1706 return -1;
1707 }
1708
1709 TRACE(comm,"%*s\n", cbWrite, lpvBuf );
1710 length = write(fd, (void *) lpvBuf, cbWrite);
1711
1712 if (length == -1) {
1713 commerror = WinError();
1714 return -1;
1715 } else {
1716 commerror = 0;
1717 return length;
1718 }
1719 }
1720
1721
1722 /*****************************************************************************
1723 * GetCommTimeouts (KERNEL32.160)
1724 */
1725 BOOL32 WINAPI GetCommTimeouts(INT32 fd,LPCOMMTIMEOUTS lptimeouts)
1726 {
1727 FIXME(comm,"(%x,%p):stub.\n",fd,lptimeouts);
1728 return TRUE;
1729 }
1730
1731 /*****************************************************************************
1732 * SetCommTimeouts (KERNEL32.453)
1733 */
1734 BOOL32 WINAPI SetCommTimeouts(INT32 fd,LPCOMMTIMEOUTS lptimeouts) {
1735 FIXME(comm,"(%x,%p):stub.\n",fd,lptimeouts);
1736 return TRUE;
1737 }
1738
1739 /***********************************************************************
1740 * EnableCommNotification (USER.246)
1741 */
1742 BOOL16 WINAPI EnableCommNotification( INT16 fd, HWND16 hwnd,
1743 INT16 cbWriteNotify, INT16 cbOutQueue )
1744 {
1745 FIXME(comm, "(%d, %x, %d, %d):stub.\n", fd, hwnd, cbWriteNotify, cbOutQueue);
1746 return TRUE;
1747 }
1748
Windows API implementation