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