![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to riolib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / rio|
Return to riolib.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / rio |
1.1 root 1: /* RIOLIB.C */
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: /* Remote communications Input/Output Library for OS/2 and Win32 */
6:
7: #define RIOLIB_VER 100
8:
9: #ifdef __OS2__
10: #define INCL_DOSDEVICES
11: #define INCL_DOSDEVIOCTL
12: #define INCL_DOS
13: #include <os2.h>
14:
15: #else // Win32
16:
17: #include <windows.h>
18: #endif
19:
20: #include <time.h>
21: #include <stdio.h>
22: #include <fcntl.h>
23: #include <string.h>
24: #include <process.h>
25: #include "riolib.h"
26: #include "riodefs.h"
27:
28: int rio_handle=-1;
29:
30: int rio_abort=0,rio_aborted=0;
31: int inbufbot,inbuftop;
32: int outbufbot,outbuftop;
33: char inbuf[RIO_INCOM_BUFLEN];
34: char outbuf[RIO_OUTCOM_BUFLEN];
35:
36: /****************************************************************************/
37: /* OS/2 Specific */
38: /****************************************************************************/
39:
40: #ifdef __OS2__
41:
42: HEV rio_sem;
43:
44: typedef struct { /* Packet for Get/Set Device Control Block Parms */
45:
46: ushort wr_timeout;
47: ushort rd_timeout;
48: uchar flags1;
49: uchar flags2;
50: uchar flags3;
51: uchar err_char;
52: uchar brk_char;
53: uchar xon_char;
54: uchar xoff_char;
55:
56: } async_dcb_t;
57:
58: typedef struct { /* Parameter Packet for Extended Set Bit Rate */
59:
60: ulong rate;
61: uchar frac;
62:
63: } setrate_t;
64:
65: typedef struct { /* Data Packet for Extended Query Bit Rate */
66:
67: ulong cur_rate;
68: uchar cur_rate_frac;
69: ulong min_rate;
70: uchar min_rate_frac;
71: ulong max_rate;
72: uchar max_rate_frac;
73:
74: } getrate_t;
75:
76: typedef struct { /* Data Packet for Query Number of Chars Queue */
77:
78: ushort cur,
79: max;
80:
81: } getqueue_t;
82:
83: typedef struct { /* Parameter Packet for Set Modem Control Signals */
84:
85: uchar on;
86: uchar off;
87:
88: } setmdmctrl_t;
89:
90: typedef struct { /* Parameter Packet for Set Line Characteristics */
91:
92: uchar data;
93: uchar parity;
94: uchar stop;
95:
96: } setline_t;
97:
98: #else
99:
100: /****************************************************************************/
101: /* Win32 Specific */
102: /****************************************************************************/
103:
104: HANDLE rio_event;
105:
106: #endif
107:
108: /************************************************************************/
109: /* Opens COM port, ignoring IRQ argument */
110: /* Returns 0 on no error */
111: /************************************************************************/
112: int rioini(int com, int unused)
113: {
114: char str[64];
115: #ifdef __OS2__
116: async_dcb_t async_dcb;
117: #else // Win32
118: DCB dcb;
119: COMMTIMEOUTS timeouts;
120: #endif
121:
122: #ifdef __WATOMC__
123: char *stack;
124: #endif
125:
126: inbufbot=inbuftop=outbufbot=outbuftop=0; /* clear our i/o buffers */
127:
128: if(!com) { /* Close port */
129: if(rio_handle>=0) {
130: #ifdef __OS2__
131: close(rio_handle);
132: rio_handle=-1; /* signal outcom_thread() to end */
133: DosPostEventSem(rio_sem);
134: #else // Win32
135: CloseHandle((HANDLE)rio_handle);
136: rio_handle=-1;
137: SetEvent(rio_event);
138: #endif
139: return(0); }
140: return(-2); }
141:
142: sprintf(str,"COM%u",com);
143: #ifdef __OS2__
144: if(rio_handle==-1) { /* Not already opened */
145: if((rio_handle=open(str,O_RDWR|O_BINARY,0))==-1)
146: return(-1); }
147: #else // Win32
148: if(rio_handle==-1) { /* Not already opened */
149: if((rio_handle=(int)CreateFile(str
150: ,GENERIC_READ|GENERIC_WRITE /* Access */
151: ,0 /* Share mode */
152: ,NULL /* Security attributes */
153: ,OPEN_EXISTING /* Create access */
154: ,FILE_ATTRIBUTE_NORMAL /* File attributes */
155: ,NULL /* Template */
156: ))==(int)INVALID_HANDLE_VALUE)
157: return(-1); }
158: #endif
159:
160: #ifdef __OS2__
161:
162: if(DosDevIOCtl(rio_handle
163: ,IOCTL_ASYNC, 0x73 /* Query Device Control Block (DCB) Parms */
164: ,NULL
165: ,0
166: ,NULL
167: ,&async_dcb
168: ,sizeof(async_dcb)
169: ,NULL))
170: return(-6);
171:
172: async_dcb.flags2&=~(1<<1); /* Disable Automatic Recv XON/XOFF flow ctrl */
173: /* Extended Hardware Buffering (16550 FIFO) */
174: if(async_dcb.flags3&((1<<4)|(1<<3))) { /* Supported */
175: async_dcb.flags3&=~((1<<3)|(1<<6)|(1<<5)); /* Set to 1 char trgr lvl */
176: async_dcb.flags3|=((1<<4)|(1<<7)); } /* Set to 16 char tx buf */
177: async_dcb.flags3|=((1<<2)|(1<<1)); /* No-Wait read timeout */
178: async_dcb.flags3&=~(1<<0); /* Normal write timeout */
179: async_dcb.wr_timeout=499; /* 5 seconds? */
180: DosDevIOCtl(rio_handle
181: ,IOCTL_ASYNC, 0x53 /* Set Device Control Block (DCB) Parms */
182: ,(void *)&async_dcb
183: ,sizeof(async_dcb)
184: ,NULL
185: ,NULL
186: ,0
187: ,NULL);
188:
189: if(DosCreateEventSem(NULL,&rio_sem,0,0))
190: return(-5);
191:
192: #else // Win32
193:
194: if(GetCommState((HANDLE)rio_handle,&dcb)!=TRUE)
195: return(-6);
196:
197: dcb.fBinary=1; // No EOF check
198: dcb.fDtrControl=DTR_CONTROL_ENABLE;
199: dcb.fDsrSensitivity=FALSE;
200: dcb.fOutX=0; // No Xon/Xoff out
201: dcb.fInX=0; // No Xon/Xoff in
202: dcb.fErrorChar=FALSE; // No character replacement
203: dcb.fNull=0; // No null stripping
204: dcb.fAbortOnError=0; // Continue to communicate even if error detected
205:
206: SetCommState((HANDLE)rio_handle,&dcb);
207:
208: if(GetCommTimeouts((HANDLE)rio_handle,&timeouts)!=TRUE)
209: return(-7);
210:
211: timeouts.ReadIntervalTimeout=MAXDWORD;
212: timeouts.ReadTotalTimeoutMultiplier=0;
213: timeouts.ReadTotalTimeoutConstant=0; // No-wait read timeout
214: timeouts.WriteTotalTimeoutMultiplier=0;
215: timeouts.WriteTotalTimeoutConstant=5000; // 5 seconds
216: SetCommTimeouts((HANDLE)rio_handle,&timeouts);
217:
218: SetupComm((HANDLE)rio_handle,4096,4096); /* Init Rx and Tx buffer sizes */
219:
220: if((rio_event=CreateEvent(NULL /* Security attributes */
221: ,TRUE /* Manual reset */
222: ,FALSE /* Non-signaled by default */
223: ,NULL /* Event name */
224: ))==NULL)
225: return(-5);
226:
227: #endif
228:
229: #ifdef __WATCOMC__
230: stack=malloc(RIO_OUTCOM_STACK);
231: if(stack==NULL)
232: return(-4);
233: if(_beginthread(outcom_thread,stack,RIO_OUTCOM_STKLEN,NULL)==-1)
234: return(-3);
235: #else
236: if(_beginthread(outcom_thread,RIO_OUTCOM_STKLEN,NULL)==(ulong)-1)
237: return(-3);
238: #endif
239:
240:
241: return(0);
242: }
243:
244: /************************************************************************/
245: /* Raise or lower DTR */
246: /* If onoff is 0, drop and exit, 1 raise and exit, >1 drop and wait */
247: /* up to x seconds for DCD to drop, return 0 on success, 1 on failure */
248: /************************************************************************/
249: int dtr(char onoff)
250: {
251: #ifdef __OS2__
252: setmdmctrl_t setmdmctrl;
253: ulong start;
254: ushort w;
255: uchar c;
256:
257: if(onoff==1) {
258: setmdmctrl.on=1;
259: setmdmctrl.off=0xff; }
260: else {
261: setmdmctrl.on=0;
262: setmdmctrl.off=0xfe; }
263:
264: DosDevIOCtl(rio_handle, IOCTL_ASYNC, 0x46 /* Set Modem Ctrl Signals */
265: ,&setmdmctrl
266: ,sizeof(setmdmctrl)
267: ,NULL
268: ,&w
269: ,sizeof(short)
270: ,NULL);
271:
272: if(onoff<=1)
273: return(0);
274:
275: start=time(NULL);
276: while(time(NULL)-start<=onoff) {
277: DosDevIOCtl(rio_handle
278: ,IOCTL_ASYNC, 0x67 /* Get Modem Input Signals */
279: ,NULL
280: ,0
281: ,NULL
282: ,&c
283: ,1
284: ,NULL);
285: if(!(c&DCD)) /* DCD is low */
286: return(0);
287: DosSleep(1); }
288:
289: #else // Win32
290:
291: ulong l,start;
292:
293: if(onoff==1)
294: EscapeCommFunction((HANDLE)rio_handle,SETDTR);
295: else
296: EscapeCommFunction((HANDLE)rio_handle,CLRDTR);
297:
298: if(onoff<=1)
299: return(0);
300:
301: start=time(NULL);
302: while(time(NULL)-start<=onoff) {
303: GetCommModemStatus((HANDLE)rio_handle,&l);
304: if(!(l&MS_RLSD_ON)) // DCD is low
305: return(0);
306: Sleep(1000); }
307:
308: #endif
309:
310: return(1); /* Dropping DTR failed to lower DCD */
311: }
312:
313:
314:
315: /************************************************************************/
316: /* Returns the current DTE rate of the currently open COM port */
317: /************************************************************************/
318: long rio_getbaud(void)
319: {
320: #ifdef __OS2__
321: getrate_t getrate;
322:
323: if(DosDevIOCtl(rio_handle, IOCTL_ASYNC, 0x63 /* Extended Query Bit Rate */
324: ,NULL
325: ,0
326: ,NULL
327: ,&getrate
328: ,sizeof(getrate)
329: ,NULL)==0)
330: return(getrate.cur_rate);
331:
332: #else // Win32
333:
334: DCB dcb;
335:
336: if(GetCommState((HANDLE)rio_handle,&dcb)==TRUE) {
337: switch(dcb.BaudRate) {
338: case CBR_110:
339: return(110);
340: case CBR_300:
341: return(300);
342: case CBR_600:
343: return(600);
344: case CBR_1200:
345: return(1200);
346: case CBR_2400:
347: return(2400);
348: case CBR_4800:
349: return(4800);
350: case CBR_9600:
351: return(9600);
352: case CBR_14400:
353: return(14400);
354: case CBR_19200:
355: return(19200);
356: case CBR_38400:
357: return(38400);
358: case CBR_56000:
359: return(56000);
360: case CBR_57600:
361: return(57600);
362: case CBR_115200:
363: return(115200);
364: case CBR_128000:
365: return(128000);
366: case CBR_256000:
367: return(256000);
368: default:
369: return(dcb.BaudRate); } }
370:
371: #endif
372:
373: return(-1); // Error
374: }
375:
376:
377: /************************************************************************/
378: /* Sets the current DTE rate */
379: /* Returns 0 on success */
380: /************************************************************************/
381: int setbaud(int rate)
382: {
383: #ifdef __OS2__
384: setrate_t setrate;
385: APIRET ret;
386:
387: setrate.rate=rate;
388: setrate.frac=0;
389:
390: ret=DosDevIOCtl(rio_handle, IOCTL_ASYNC, 0x43 /* Extended Set Bit Rate */
391: ,&setrate
392: ,sizeof(setrate)
393: ,NULL
394: ,NULL
395: ,0
396: ,NULL);
397:
398: if(ret)
399: return(ret);
400:
401: if(rio_getbaud()!=rate) /* Make sure it actually changed rates */
402: return(-1);
403:
404: #else // Win32
405:
406: DCB dcb;
407:
408: if(GetCommState((HANDLE)rio_handle,&dcb)!=TRUE)
409: return(-1);
410: dcb.BaudRate=rate;
411: if(SetCommState((HANDLE)rio_handle,&dcb)!=TRUE)
412: return(-1);
413:
414: #endif
415:
416: return(0);
417: }
418:
419: /************************************************************************/
420: /* Return next incoming character from COM port, NOINP if none avail. */
421: /* Uses a linear buffer. */
422: /************************************************************************/
423: int incom(void)
424: {
425: char c;
426:
427: if(inbufbot!=inbuftop) {
428: c=inbuf[inbufbot];
429: inbufbot++;
430: if(inbufbot==inbuftop)
431: inbufbot=inbuftop=0;
432: if(rio_abort && c==3) { /* Ctrl-C */
433: rio_aborted=1;
434: rioctl(IOFO);
435: return(NOINP); }
436: return(c); }
437:
438: inbufbot=0;
439: #ifdef __OS2__
440: inbuftop=read(rio_handle,inbuf,RIO_INCOM_BUFLEN);
441: #else // Win32
442: ReadFile((HANDLE)rio_handle,inbuf,RIO_INCOM_BUFLEN,(DWORD *)&inbuftop,NULL);
443: #endif
444: if(inbuftop<=0 || inbuftop>RIO_INCOM_BUFLEN) {
445: inbuftop=0;
446: return(NOINP); }
447: else
448: return(inbuf[inbufbot++]);
449: }
450:
451: /************************************************************************/
452: /* Return number of chars in our input buffer */
453: /************************************************************************/
454: int inbufcnt(void)
455: {
456: return(inbuftop-inbufbot);
457: }
458:
459: /************************************************************************/
460: /* Place a character into outbound buffer, return TXBOF on buffer */
461: /* overflow, 0 on success. */
462: /************************************************************************/
463: int outcom(int ch)
464: {
465: int i=outbuftop+1;
466:
467: if(i==RIO_OUTCOM_BUFLEN)
468: i=0;
469: if(i==outbufbot)
470: return(TXBOF);
471: outbuf[outbuftop++]=ch;
472: if(outbuftop==RIO_OUTCOM_BUFLEN)
473: outbuftop=0;
474: #ifdef __OS2__
475: DosPostEventSem(rio_sem); // Enable output
476: #else // Win32
477: SetEvent(rio_event);
478: #endif
479: return(0);
480: }
481:
482: /************************************************************************/
483: /************************************************************************/
484: void outcom_thread(void *unused)
485: {
486: int i,top;
487: ulong l;
488:
489: while(rio_handle>=0) {
490: if(outbufbot==outbuftop) {
491: #ifdef __OS2__
492: DosResetEventSem(rio_sem,&l);
493: DosWaitEventSem(rio_sem,10000); /* every 10 seconds */
494: #else // Win32
495: ResetEvent(rio_event);
496: WaitForSingleObject(rio_event,10000);
497: #endif
498: continue; }
499: top=outbuftop;
500: if(top<outbufbot)
501: i=RIO_OUTCOM_BUFLEN-outbufbot;
502: else
503: i=top-outbufbot;
504: #ifdef __OS2__
505: i=write(rio_handle,outbuf+outbufbot,i);
506: #else // Win32
507: WriteFile((HANDLE)rio_handle,outbuf+outbufbot,i,(DWORD *)&i,NULL);
508: #endif
509: if(i>0 && i<=RIO_OUTCOM_BUFLEN-outbufbot)
510: outbufbot+=i;
511: if(outbufbot==RIO_OUTCOM_BUFLEN)
512: outbufbot=0; }
513: _endthread();
514: }
515:
516: /************************************************************************/
517: /* Return number of chars in our output buffer */
518: /************************************************************************/
519: int outbufcnt(void)
520: {
521: if(outbuftop>=outbufbot)
522: return(outbuftop-outbufbot);
523: return(outbuftop+(RIO_OUTCOM_BUFLEN-outbufbot));
524: }
525:
526: /************************************************************************/
527: /************************************************************************/
528: int rio_getstate(void)
529: {
530: #ifdef __OS2__
531: uchar c;
532: ushort state=0,w;
533: getqueue_t getqueue;
534:
535: if(rio_abort && !rio_aborted) {
536: DosDevIOCtl(rio_handle
537: ,IOCTL_ASYNC, 0x68 /* Query # of chars in rx queue */
538: ,NULL
539: ,0
540: ,NULL
541: ,&getqueue
542: ,sizeof(getqueue)
543: ,NULL);
544: if(getqueue.cur && read(rio_handle,&c,1)==1) {
545: if(c==3) { /* ctrl-c */
546: rio_aborted=1;
547: rioctl(IOFO); }
548: else
549: if(inbuftop<RIO_INCOM_BUFLEN) /* don't overflow input buffer */
550: inbuf[inbuftop++]=c; } }
551:
552: if(rio_aborted)
553: state|=ABORT;
554:
555: #if 0 // just to see if things speed up
556: DosDevIOCtl(rio_handle
557: ,IOCTL_ASYNC, 0x6D /* Query COM Error */
558: ,NULL
559: ,0
560: ,NULL
561: ,&w
562: ,sizeof(short)
563: ,NULL);
564: state|=w&0xf; /* FERR|PERR|OVRR|RXLOST */
565: #endif
566:
567: DosDevIOCtl(rio_handle
568: ,IOCTL_ASYNC, 0x67 /* Query Modem Input Signals */
569: ,NULL
570: ,0
571: ,NULL
572: ,&c
573: ,sizeof(char)
574: ,NULL);
575: state|=c&0xf0; /* DCD|RI|DSR|CTS */
576:
577: #else // Win32
578:
579: uchar c;
580: ushort state=0;
581: int i;
582: ulong l;
583: COMSTAT comstat;
584:
585: if(rio_abort && !rio_aborted) {
586: ClearCommError((HANDLE)rio_handle,&l,&comstat);
587: if(comstat.cbInQue) {
588: ReadFile((HANDLE)rio_handle,&c,1,(DWORD *)&i,NULL);
589: if(i==1) {
590: if(c==3) { /* Ctrl-C */
591: rio_aborted=1;
592: rioctl(IOFO); }
593: else
594: if(inbuftop<RIO_INCOM_BUFLEN) /* don't overflow input buffer */
595: inbuf[inbuftop++]=c; } } }
596:
597: GetCommModemStatus((HANDLE)rio_handle,(DWORD *)&state); /* DCD|RI|DSR|CTS */
598: if(rio_aborted)
599: state|=ABORT;
600:
601: #endif
602:
603: return(state);
604: }
605:
606:
607: /************************************************************************/
608: /************************************************************************/
609: int rioctl(ushort action)
610: {
611: #ifdef __OS2__
612: async_dcb_t async_dcb;
613: getqueue_t getqueue;
614: setline_t setline;
615: #else // Win32
616: COMMPROP commprop;
617: COMSTAT comstat;
618: DCB dcb;
619: ulong l;
620: #endif
621: uchar c;
622: ushort mode,w;
623: clock_t start;
624:
625: switch(action) {
626: case GVERS: /* Get version */
627: return(RIOLIB_VER);
628: case GUART: /* Get UART I/O address, not available */
629: return(0xffff);
630: case GIRQN: /* Get IRQ number, not available */
631: return((int)rio_handle);
632: case GBAUD: /* Get current bit rate */
633: return(rio_getbaud());
634: case RXBC: /* Get receive buffer count */
635: #ifndef __OS2__ // Win32
636: ClearCommError((HANDLE)rio_handle,&l,&comstat);
637: return(comstat.cbInQue+inbufcnt());
638: #endif
639: /* Fall-through if OS/2 */
640: case RXBS: /* Get receive buffer size */
641: #ifdef __OS2__
642: DosDevIOCtl(rio_handle
643: ,IOCTL_ASYNC, 0x68 /* Query # of chars in rx queue */
644: ,NULL
645: ,0
646: ,NULL
647: ,&getqueue
648: ,sizeof(getqueue)
649: ,NULL);
650: if(action==RXBC)
651: return(getqueue.cur+inbufcnt());
652: /* RXBS */
653: return(getqueue.max+RIO_INCOM_BUFLEN);
654: #else
655: GetCommProperties((HANDLE)rio_handle,&commprop);
656: return(commprop.dwCurrentRxQueue+RIO_INCOM_BUFLEN);
657: #endif
658: case TXBC: /* Get transmit buffer count */
659: #ifndef __OS2__ // Win32
660: ClearCommError((HANDLE)rio_handle,&l,&comstat);
661: return(comstat.cbOutQue+outbufcnt());
662: #endif
663: /* Fall-through if OS/2 */
664: case TXBS: /* Get transmit buffer size */
665: case TXBF: /* Get transmit buffer free space */
666: #ifdef __OS2__
667: DosDevIOCtl(rio_handle
668: ,IOCTL_ASYNC, 0x69 /* Query # of chars in tx queue */
669: ,NULL
670: ,0
671: ,NULL
672: ,&getqueue
673: ,sizeof(getqueue)
674: ,NULL);
675: if(action==TXBC)
676: return(getqueue.cur+outbufcnt());
677: else if(action==TXBS)
678: return(getqueue.max+RIO_OUTCOM_BUFLEN);
679: /* TXBF */
680: return((getqueue.max-getqueue.cur)+(RIO_OUTCOM_BUFLEN-outbufcnt()));
681: #else
682: GetCommProperties((HANDLE)rio_handle,&commprop);
683: if(action==TXBS)
684: return(commprop.dwCurrentTxQueue+RIO_OUTCOM_BUFLEN);
685: /* TXBF */
686: ClearCommError((HANDLE)rio_handle,&l,&comstat);
687: return((commprop.dwCurrentTxQueue-comstat.cbOutQue)
688: +(RIO_OUTCOM_BUFLEN-outbufcnt()));
689: #endif
690: case IOSTATE:
691: return(rio_getstate());
692: case IOFI: /* Flush input buffer */
693: case IOFO: /* Flush output buffer */
694: case IOFB: /* Flush both buffers */
695: #ifdef __OS2__
696: c=0;
697: if((action&IOFI)==IOFI) {
698: DosDevIOCtl(rio_handle
699: ,IOCTL_GENERAL, DEV_FLUSHINPUT
700: ,&c
701: ,sizeof(char)
702: ,NULL
703: ,&w
704: ,sizeof(short)
705: ,NULL);
706: inbufbot=inbuftop=0;
707: } /* Clear our input buffer too */
708: c=0;
709: if((action&IOFO)==IOFO) {
710: DosDevIOCtl(rio_handle
711: ,IOCTL_GENERAL, DEV_FLUSHOUTPUT
712: ,&c
713: ,sizeof(char)
714: ,NULL
715: ,&w
716: ,sizeof(short)
717: ,NULL);
718: outbufbot=outbuftop=0;
719: } /* Clear our output buffer too */
720: #else // Win32
721: l=0;
722: if((action&IOFI)==IOFI)
723: l|=(PURGE_RXABORT|PURGE_RXCLEAR);
724: if((action&IOFO)==IOFO)
725: l|=(PURGE_TXABORT|PURGE_TXCLEAR);
726: PurgeComm((HANDLE)rio_handle,l);
727: #endif
728: return(rio_getstate());
729: case LFN81:
730: case LFE71:
731: #ifdef __OS2__
732: setline.stop=0; /* 1 stop bit */
733: if(action==LFN81) {
734: setline.data=8;
735: setline.parity=0; } /* No parity */
736: else {
737: setline.data=7;
738: setline.parity=2; } /* Even parity */
739: DosDevIOCtl(rio_handle
740: ,IOCTL_ASYNC, 0x42 /* Set Line Characteristics */
741: ,&setline
742: ,sizeof(setline)
743: ,NULL
744: ,NULL
745: ,0
746: ,NULL);
747: #else // Win32
748: GetCommState((HANDLE)rio_handle,&dcb);
749: if(action==LFN81) {
750: dcb.Parity=NOPARITY;
751: dcb.ByteSize=8;
752: dcb.StopBits=ONESTOPBIT; }
753: else {
754: dcb.Parity=EVENPARITY;
755: dcb.ByteSize=7;
756: dcb.StopBits=ONESTOPBIT; }
757: SetCommState((HANDLE)rio_handle,&dcb);
758: #endif
759: return(0);
760: case FIFOCTL:
761: #ifdef __OS2__
762: DosDevIOCtl(rio_handle
763: ,IOCTL_ASYNC, 0x73 /* Query Device Control Block (DCB) Parms */
764: ,NULL
765: ,0
766: ,NULL
767: ,&async_dcb
768: ,sizeof(async_dcb)
769: ,NULL);
770:
771: /* Extended Hardware Buffering (16550 FIFO) */
772: if(async_dcb.flags3&(1<<4)) { /* Supported */
773: c=0xc0;
774: if(async_dcb.flags3&(1<<7))
775: c|=0x0c;
776: return(c); }
777: #else // Win32
778: // Not supported under Win32?
779: #endif
780: return(0);
781: }
782:
783: if((action&0xff)<=IOCM) { /* Get/Set/Clear mode */
784: mode=0;
785:
786: #ifdef __OS2__
787: DosDevIOCtl(rio_handle
788: ,IOCTL_ASYNC, 0x73 /* Query Device Control Block (DCB) Parms */
789: ,NULL
790: ,0
791: ,NULL
792: ,&async_dcb
793: ,sizeof(async_dcb)
794: ,NULL);
795: if(async_dcb.flags1&(1<<3)) /* Output CTS handshaking */
796: mode|=CTSCK;
797: if(async_dcb.flags2&(1<<0)) /* Automatic Xmit Control Flow Xon/Xoff */
798: mode|=PAUSE;
799: if(async_dcb.flags2&(1<<7) /* RTS Input handshaking */
800: && !(async_dcb.flags2&(1<<6)))
801: mode|=RTSCK;
802: if(rio_abort)
803: mode|=ABORT;
804:
805: if(action==IOMODE)
806: return(mode);
807:
808: if((action&0xff)==IOCM) /* Clear mode */
809: mode&=~(action&0xff00);
810: else /* Set mode */
811: mode|=(action&0xff00);
812:
813: if(mode&CTSCK)
814: async_dcb.flags1|=(1<<3);
815: else
816: async_dcb.flags1&=~(1<<3);
817: if(mode&PAUSE) {
818: async_dcb.flags2|=(1<<0); /* xmit flow control */
819: async_dcb.xon_char=17; /* Ctrl-Q */
820: async_dcb.xoff_char=19; } /* Ctrl-S */
821: else
822: async_dcb.flags2&=~(1<<0);
823: if(mode&RTSCK) {
824: async_dcb.flags2|=(1<<7);
825: async_dcb.flags2&=~(1<<6); }
826: else
827: async_dcb.flags2&=~((1<<7)|(1<<6));
828: if(mode&ABORT)
829: rio_abort=1;
830: else
831: rio_abort=0;
832:
833: DosDevIOCtl(rio_handle
834: ,IOCTL_ASYNC, 0x53 /* Set Device Control Block (DCB) Parms */
835: ,&async_dcb
836: ,sizeof(async_dcb)
837: ,NULL
838: ,NULL
839: ,0
840: ,NULL);
841:
842: #else // Win32
843:
844: GetCommState((HANDLE)rio_handle,&dcb);
845: if(dcb.fOutxCtsFlow)
846: mode|=CTSCK;
847: if(dcb.fOutX)
848: mode|=PAUSE;
849: if(dcb.fRtsControl==RTS_CONTROL_HANDSHAKE)
850: mode|=RTSCK;
851:
852: if(rio_abort)
853: mode|=ABORT;
854:
855: if(action==IOMODE)
856: return(mode);
857:
858: if((action&0xff)==IOCM) /* Clear mode */
859: mode&=~(action&0xff00);
860: else /* Set mode */
861: mode|=(action&0xff00);
862:
863: if(mode&CTSCK)
864: dcb.fOutxCtsFlow=1;
865: else
866: dcb.fOutxCtsFlow=0;
867: if(mode&PAUSE) {
868: dcb.fOutX=1;
869: dcb.XonChar=17; /* Ctrl-Q */
870: dcb.XoffChar=19; } /* Ctrl-S */
871: else
872: dcb.fOutX=0;
873: if(mode&RTSCK)
874: dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
875: else
876: dcb.fRtsControl=RTS_CONTROL_ENABLE;
877: if(mode&ABORT)
878: rio_abort=1;
879: else
880: rio_abort=0;
881:
882: SetCommState((HANDLE)rio_handle,&dcb);
883:
884: #endif
885:
886: return(mode); }
887:
888: if((action&0xff)==IOSS) { /* Set state */
889:
890: if(action&ABORT)
891: rio_aborted=1;
892:
893: #ifdef __OS2__
894: if(action&PAUSE)
895: DosDevIOCtl(rio_handle
896: ,IOCTL_ASYNC, 0x47 /* Behave as if XOFF Received */
897: ,NULL
898: ,0
899: ,NULL
900: ,&w
901: ,sizeof(short)
902: ,NULL);
903: #else // Win32
904: if(action&PAUSE)
905: EscapeCommFunction((HANDLE)rio_handle,SETXOFF);
906: #endif
907:
908: return(rio_getstate()); }
909:
910: if((action&0xff)==IOCS) { /* Clear state */
911:
912: if(action&ABORT)
913: rio_aborted=0;
914:
915: #ifdef __OS2__
916: if(action&PAUSE)
917: DosDevIOCtl(rio_handle
918: ,IOCTL_ASYNC, 0x48 /* Behave as if XON Received */
919: ,NULL
920: ,0
921: ,NULL
922: ,&w
923: ,sizeof(short)
924: ,NULL);
925: #else // Win32
926: if(action&PAUSE)
927: EscapeCommFunction((HANDLE)rio_handle,SETXON);
928: #endif
929: return(rio_getstate()); }
930:
931: if((action&0xff)==TXSYNC) { /* Synchronize transmition */
932: c=action>>8; /* Number of seconds */
933: w=110+(c*1000); /* Number of milliseconds */
934: start=clock();
935: while(clock()-start<w) {
936: if(!outbufcnt()) {
937: #ifdef __OS2__
938: DosDevIOCtl(rio_handle
939: ,IOCTL_ASYNC, 0x69 /* Query # of chars in tx queue */
940: ,NULL
941: ,0
942: ,NULL
943: ,&getqueue
944: ,sizeof(getqueue)
945: ,NULL);
946: if(getqueue.cur==0) /* Empty outbound queue */
947: return(0);
948: #else // Win32
949: ClearCommError((HANDLE)rio_handle,&l,&comstat);
950: if(comstat.cbOutQue==0) /* Empty outbound queue */
951: return(0);
952: #endif
953: }
954: #ifdef __OS2__
955: DosSleep(1);
956: #else // Win32
957: Sleep(1);
958: #endif
959: }
960: return(1); }
961:
962: return(0);
963: }
964:
965: /* End of file */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.