home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / tterm_src.lzh / io.c < prev    next >
Text File  |  1996-03-04  |  28KB  |  1,074 lines
  1. /*********************************************************************
  2. io.c
  3. *********************************************************************/
  4. #include "common.h"
  5. #include "io.h"
  6.  
  7. void
  8.     (*T_PutC)(int),
  9.     (*TrOn)(void),(*TrOff)(void),
  10.     (*OldTrOn)(void),(*OldTrOff)(void),
  11.     RTS_TrOn(void),RTS_TrOff(void),
  12.     X_TrOn(void),X_TrOff(void),
  13.     TrDoNothing(void);
  14.  
  15. static int t_enable=0;      /* set if RTS enabled */
  16. static int readoff;         /* turn off read when this many waiting */
  17. static int readon;          /* turn back on when less than this many */
  18.  
  19. extern u_char filterbyte;
  20.  
  21. /*********************************************************************
  22. signal TRAP function
  23.     rewritten to handle keyboard (KBD_SIG) and sio (SER_SIG) signals
  24.     now uses _os_intercept() [JSC]
  25. *********************************************************************/
  26. void trap(signal)
  27. int signal;
  28. {
  29. switch(signal)
  30.     {
  31.     case SER_SIG:
  32.         g_sigmodem++;
  33.         break;
  34.     case KBD_SIG:
  35.         g_sigkb++;
  36.         break;
  37. /*    case SIGQUIT:       /* ^E (debugging only) */
  38.         cleanup();
  39.         exit (signal);
  40.     case RESETTIMED:
  41.         g_sigreset++;
  42.         break;
  43.     default:            /* default is ignore */
  44.         break;
  45.     }
  46. _os_rte();
  47. }
  48.  
  49. /*********************************************************************
  50. RELEASE the MODEM SIGNALs - this is necessary so a program invoked from
  51.     a child shell will be able to use the modem port.
  52. *********************************************************************/
  53. ReleaseModemSignal()
  54. {
  55. _os_ss_relea(mp);
  56. }
  57.  
  58. /*********************************************************************
  59. WAIT for a SERIAL event - returns remaining tick count
  60. *********************************************************************/
  61. WaitSerial(seconds)
  62. int seconds;            /* sleep this long (0 == forever) */
  63. {
  64. u_int snooze=g_tickrate * seconds;
  65. signal_code wakeup;
  66.  
  67. g_sigmodem=0;
  68. g_sigkb=0;
  69.  
  70. _os_sigmask(1);                /* */
  71. _os_ss_sendsig(mp,SER_SIG);     /* set modem signal */
  72. _os_ss_sendsig(0,KBD_SIG);      /* set keyboard signal */
  73.  
  74. TSleep(snooze,sigl);            /* sleep (also unmasks interupts) */
  75. return snooze;
  76. }
  77.  
  78. /*********************************************************************
  79. return MODEM ready READY status
  80. *********************************************************************/
  81. ModemReady()
  82. {
  83. FlushSerial();
  84. return (oncall > 0 ? oncall : 0);
  85. }
  86.  
  87. /*********************************************************************
  88. return TERMinal data READY - returns g_sigkb
  89. *********************************************************************/
  90. TermReady()
  91. {
  92. return g_sigkb;
  93. }
  94.  
  95. /*********************************************************************
  96. MODem SETUP - returns zero or error number on error
  97. *********************************************************************/
  98. int modsetup(mport)
  99. char *mport;
  100. {
  101. u_int32 size;
  102.  
  103. #ifdef _MPF68K
  104.     u_int32 scf_size = sizeof(struct scf_opt);
  105. #endif
  106. #ifdef _MPF386
  107.     u_int32 scf_size = sizeof(struct scf_path_opts);
  108.     u_int32 lu_size = sizeof(struct scf_lu_opts);
  109. #endif
  110.  
  111. /* allocate ring buffer for incoming serial data */
  112. serialbuff=malloc(RINGBUFF);
  113. if(serialbuff == 0)
  114.     return errno;
  115. ResetInputBuffer();
  116. oncall = 0;
  117.  
  118. /* open a path to the modem */
  119. errno=_os_open(mport,FAM_READ | FAM_WRITE,&mp);
  120. if(errno)
  121.     {
  122.     fprintf(stderr,"Unable to open %s\n",mport);
  123.     return errno;
  124.     }
  125.  
  126. readoff=RINGBUFF-2048;
  127. readon=0;
  128.  
  129. /* set path options */
  130. #ifdef _MPF68K
  131.     _os_gs_popt(mp,&scf_size,&oldmod);  /* get the pd_ stuff */
  132.     newmod=oldmod;                      /* save it */
  133.     FixMPath(&newmod);
  134.     _os_ss_popt(mp,scf_size,&newmod);
  135.     cur_baud = oldmod.pd_bau;
  136. #endif
  137.  
  138. #ifdef _MPF386
  139.     _os_gs_popt(mp,&scf_size,&oldmod);  /* get the pd_ stuff */
  140.     newmod=oldmod;                      /* save it */
  141.     FixMPath(&newmod);
  142.     _os_ss_popt(mp,scf_size,&newmod);
  143.  
  144.     _os_gs_luopt(mp,&lu_size,&oldvmod);  /* get the v_ stuff */
  145.     newvmod=oldvmod;
  146.     FixMPath1(&newvmod);                /* fix the v_ stuff */
  147.     _os_ss_luopt(mp,lu_siz,&newvmod);   /* set the v_ stuff */
  148.     
  149.     cur_baud = oldvmod.v_baud;
  150. #endif
  151.  
  152. /* check for RTS handshake */
  153. errno=_os_ss_enrts(mp);
  154. if(errno)
  155.     return errno;
  156. else
  157.     {
  158.     TrOn=RTS_TrOn;
  159.     TrOff=RTS_TrOff;
  160.     t_enable=1;         /* modem enabled */
  161.     }
  162.  
  163. FlushSerial();      /* get any leftover junk */
  164. ResetInputBuffer(); /* reset buffer */
  165. oncall=0;
  166. return 0;
  167. }
  168.  
  169. /*********************************************************************
  170. TERMinal SETUP
  171. *********************************************************************/
  172. termsetup()
  173. {
  174. #ifdef _MPF386
  175.     u_int32 scf_size = sizeof(struct scf_path_opts);
  176. #else  /* _OSK  */
  177.     u_int32 scf_size = sizeof(struct scf_opt);
  178. #endif
  179.  
  180. screenbuff=malloc(SBUFFSIZE);
  181. if(screenbuff == 0)
  182.     return 1;
  183. screenptr=screenbuff;
  184. screenwait=0;
  185.  
  186. if(find_tcent() != 0)               /* iniz termcap stuff   */
  187.     return 1;
  188. _os_gs_popt(0,&scf_size,&oldterm);
  189. newterm=oldterm;
  190. FixTPath(&newterm);
  191. raw_io();
  192. return 0;
  193. }
  194.  
  195. /*********************************************************************
  196. CLEAR the LINE of any junk
  197. *********************************************************************/
  198. ClearLine()
  199. {
  200. while(FlushSerial())
  201.     WaitSerial(1);
  202. ResetInputBuffer();
  203. oncall = 0;
  204. }
  205.  
  206. /*********************************************************************
  207. COOKed term IO - for getting filenames and such
  208. *********************************************************************/
  209. cook_io()
  210. {
  211. #ifdef _MPF68K
  212.     u_int32 scf_size = sizeof(struct scf_opt);
  213. #endif
  214. #ifdef _MPF386
  215.     u_int32 scf_size = sizeof(struct scf_path_opts);
  216. #endif
  217.  
  218. sig_off();
  219. _os_ss_popt(0,scf_size,&oldterm);
  220. }
  221.  
  222. /*********************************************************************
  223. RAW term IO - for as-is data to/from term 
  224. *********************************************************************/
  225. raw_io()
  226. {
  227. #ifdef _MPF68K
  228.     u_int32 scf_size = sizeof(struct scf_opt);
  229. #endif
  230. #ifdef _MPF386
  231.     u_int32 scf_size = sizeof(struct scf_path_opts);
  232. #endif
  233.         
  234. _os_ss_popt(0,scf_size, &newterm);
  235. sig_on();
  236. }
  237.  
  238. /*********************************************************************
  239. CLEANUP after ourself and make sure file are closed, term is restored
  240.     etc.
  241. *********************************************************************/
  242. cleanup()
  243. {
  244. #ifdef _MPF68K
  245.     u_int32 scf_size=sizeof(struct scf_opt);
  246. #endif
  247. #ifdef _MPF386
  248.     u_int32 scf_size=sizeof(struct scf_path_opts);
  249.     u_int32 lu_size=sizeof(struct lu_path_opts);
  250. #endif
  251.  
  252. sig_off();
  253. t_puts(SE);
  254. t_puts("\n");
  255. close_file();            /* Close any capture buffer that is opened */
  256. UnloadTransfer();       /* unlink from transfer program */
  257.  
  258. _os_ss_popt(mp,scf_size, &oldmod);
  259. _os_ss_popt(0,scf_size, &oldterm);
  260.  
  261. #ifdef _MPF386
  262.     _os_ss_luopt(mp,lu_opt,&oldvmod);
  263. #endif
  264.  
  265. ReleaseModemSignal();
  266. _os_close(mp);          /* don't forget this */
  267. }
  268.  
  269. /*********************************************************************
  270. FIND the TC ENTry - sets up all the termcap stuff
  271.     return 0 if everything ok else retune number of errors
  272. *********************************************************************/
  273. find_tcent()
  274. {
  275. extern char tmp[];
  276. extern char *mport;
  277. int rtnval,cntr;
  278. char        *p, *crtname;
  279.  
  280. if ((crtname = getenv("TERM")) == NULL)
  281.     {
  282.     t_puts("Environment variable TERM not defined!\n");
  283.     return 1;
  284.     }
  285.  
  286. if ((temp_buf = (char *) malloc(1024)) == NULL)
  287.     {
  288.     t_puts("Can't malloc room for termcap buffer!\n");
  289.     return 1;
  290.     }
  291.  
  292. if (tgetent(temp_buf, crtname) <= 0)
  293.     {
  294.     sprintf(tmp,"\nUNKNOWN Terminal Type %s!", crtname);
  295.     t_puts(tmp);
  296.     return 1;
  297.     }
  298.  
  299. if ((tcbuf=(char *) malloc(strlen(temp_buf))) == NULL)
  300.     {
  301.     t_puts("Can't malloc room for termcap info!\n");
  302.     return 1;
  303.     }
  304.  
  305. #define BUFFADDR &tcbuf
  306. rtnval = 0;
  307.  
  308. /* clear the screen */
  309. CL = tgetstr("cl",BUFFADDR); rtnval += check(p,"cl");
  310. /* cursor motion */
  311. CM = tgetstr("cm",BUFFADDR); rtnval += check(p,"cm");
  312. /* start reverse video */
  313. SO = tgetstr("so",BUFFADDR); rtnval += check(p,"so");
  314. /* end reverse video */
  315. SE = tgetstr("se",BUFFADDR); rtnval += check(p,"se");
  316.  
  317. /* get the function key defs [SC] */
  318. cntr = 0;
  319. p = tgetstr("k1",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k1");
  320. p = tgetstr("k2",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k2");
  321. p = tgetstr("k3",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k3");
  322. p = tgetstr("k4",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k4");
  323. p = tgetstr("k5",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k5");
  324. p = tgetstr("k6",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k6");
  325. p = tgetstr("k7",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k7");
  326. p = tgetstr("k8",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k8");
  327. p = tgetstr("k9",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k9");
  328. p = tgetstr("k0",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"k0");
  329. p = tgetstr("F1",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"F1");
  330. p = tgetstr("F2",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"F2");
  331.  
  332. /* get the arrow keys - these need to be hashed and preserved so we
  333.     can send he correct sequence to the host [SC] */
  334.     
  335. p = tgetstr("ku",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"ku");
  336. KU = UP_ARROW;
  337. p = tgetstr("kd",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"kd");
  338. KD = DOWN_ARROW;
  339. p = tgetstr("kl",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"kl");
  340. KL = LEFT_ARROW;
  341. p = tgetstr("kr",BUFFADDR); makehash(p,cntr++); rtnval += check(p,"kr");
  342. KR = RIGHT_ARROW; 
  343.  
  344.     /*
  345.      * Termcap needs PC, BC, and UP, for certain terminal
  346.      * types.   ++SrT
  347.      *
  348.      * PC, BC, and UP are already defined in the OS9/6809 version of the
  349.      * termcap library, so not needed here [MDG].
  350.      */
  351.  
  352.     p = tgetstr("pc",BUFFADDR);
  353.     PC_ = p ? *p : 0;
  354.     BC = tgetstr("le",BUFFADDR);
  355.     UP = tgetstr("up",BUFFADDR);
  356.     AC = tgetstr("ac",BUFFADDR);
  357.     rtnval += check(BC, "le");
  358.     rtnval += check(UP, "up");
  359.  
  360.     free(temp_buf);
  361.  
  362.     if (AC)
  363.        linegfx(AC);
  364.     else
  365.         default_linegfx();
  366.  
  367. return rtnval;
  368. }
  369.  
  370. /*********************************************************************
  371. MAKE a termcap entry a HASHed entry in keycodes
  372. *********************************************************************/
  373. makehash(char *entry,int offset)
  374. {
  375. u_int32 kp = 0;
  376.  
  377. while(*entry)
  378.     {
  379.     kp <<= HASHIFT;
  380.     kp += *entry++;
  381.     }
  382. keycodes[offset] = kp;
  383. }
  384.  
  385. /*********************************************************************
  386. get the LINE GraFiX characters
  387. *********************************************************************/
  388. linegfx(ac)
  389. char   *ac;
  390. {
  391. int flag;
  392.     
  393. flag = 0;
  394.     
  395. while(*ac)
  396.     {
  397.     switch(*ac)
  398.         {
  399.         case '1':
  400.             SetGlyph(*++ac,0);
  401.             break;
  402.         case ':':
  403.             flag+=SetGlyph(*++ac,1);
  404.             break;
  405.         case ';':
  406.             flag+=SetGlyph(*++ac,2);
  407.             break;
  408.         case '<':
  409.             flag+=SetGlyph(*++ac,3);
  410.             break;
  411.         case 'H':
  412.             flag+=SetGlyph(*++ac,4);
  413.             break;
  414.         case 'I':
  415.             flag+=SetGlyph(*++ac,5);
  416.             break;
  417.         case 'M':
  418.             flag+=SetGlyph(*++ac,6);
  419.             break;
  420.         default:    break;
  421.         }
  422.     ac++;
  423.     }
  424.     if(flag < 6)
  425.        default_linegfx();
  426. }
  427.  
  428. /*********************************************************************
  429. SET a GLYPH value if necessary returns 1 if set 0 if not
  430. *********************************************************************/
  431. SetGlyph(value,offset)
  432. unsigned char value;
  433. int offset;
  434. {
  435. if(glyph[offset])       /* if already set */
  436.     return 0;
  437. glyph[offset] = (value | 0x80);
  438. return 1;
  439. }
  440.  
  441. /*********************************************************************
  442. set the DEFAULT LINE GraFiX characters
  443. *********************************************************************/
  444. default_linegfx()
  445. {
  446. glyph[0] = defglyph[0];
  447. glyph[1] = defglyph[1];
  448. glyph[2] = defglyph[2];
  449. glyph[3] = defglyph[3];
  450. glyph[4] = defglyph[4];
  451. glyph[5] = defglyph[5];
  452. glyph[6] = defglyph[6];
  453. }
  454.  
  455.  
  456. /*********************************************************************
  457. Modem PUT String
  458. *********************************************************************/
  459. m_puts(s)
  460. register char  *s;
  461. {
  462. u_int32 size=strlen(s);
  463.  
  464. _os_write(mp,s,&size);
  465. }
  466.  
  467. /*********************************************************************
  468. Modem PUT Character
  469. *********************************************************************/
  470. m_putc(c)
  471. int  c;
  472. {
  473. u_int32 size=1;
  474. u_char khar = c;
  475.  
  476. if(c > 256)
  477.     return 0;
  478. _os_write(mp,&khar,&size);
  479. }
  480.  
  481. /*********************************************************************
  482. Modem GET a Character
  483. *********************************************************************/
  484. int m_getc()
  485. {
  486. FlushSerial();
  487. if(oncall <= 0)
  488.     return 0;
  489.  
  490. if (serialread >= serialend)    /* check for buffer wrap */
  491.     serialread = serialbuff;
  492. oncall--;
  493.  
  494. return *serialread++;
  495. }
  496.  
  497. /*********************************************************************
  498. FLUSH the SERIAL input buffer
  499.     this routine will read the incoming stream until it's empty
  500. **********************************************************************/
  501. int FlushSerial()
  502. {
  503. u_int32 waiting;
  504. u_int32 toread;
  505. int tally = 0;
  506.  
  507. if(oncall < readon)
  508.     TurnModemOn();
  509. while(_os_gs_ready(mp,&waiting) == 0)   /* get number of waiting characters */
  510.     {
  511.     tally = 0;          /* DON'T TAKE THIS OUT! */
  512.     
  513.     if((serialput+waiting) > serialend)     /* if read will overrun buffer */
  514.         {
  515.         toread=serialend-serialput;             /* get maximum read */
  516.         if(_os_read(mp,serialput,&toread) != 0)
  517.             continue;
  518.         waiting -= toread;
  519.         serialput = serialbuff;                 /* wrap input pointer */
  520.         tally+=toread;
  521.         }
  522.     if(waiting > 0)         /* if still characters to read */
  523.         {
  524.         if(_os_read(mp,serialput,&waiting) != 0)
  525.             continue;
  526.         serialput += waiting;
  527.         tally+=waiting;
  528.         }
  529.     oncall+=tally;
  530.     if(oncall >= readoff)
  531.         TurnModemOff();
  532.     }
  533.  
  534. return tally;
  535. }
  536.  
  537. /*********************************************************************
  538. TURN the MODEM OFF
  539. *********************************************************************/
  540. TurnModemOff()
  541. {
  542. if(t_enable)        /* only bother if modem is currently enabled */
  543.     {
  544.     TrOff();
  545.     TrOn=TrOff=TrDoNothing; /* set both to do nothing */
  546.  
  547.     readon=oncall-2048;     /* flush down 2K */
  548.     if(readon < 1)          /* better not happen! */
  549.         readon=1;
  550.     t_enable=0;
  551.     }
  552. }
  553.  
  554. /*********************************************************************
  555. TURN the MODEM ON
  556. *********************************************************************/
  557. TurnModemOn()
  558. {
  559. if(!t_enable)   /* only if currently disabled */
  560.     {
  561.     TrOn=RTS_TrOn;  /* restore flowcontrol */
  562.     TrOff=RTS_TrOff;    
  563.     readon=0;
  564.     TrOn();         /* restore flow */
  565.     t_enable=1;
  566.     }
  567. }
  568.                             
  569.                                         
  570. /*********************************************************************
  571. RESET the INPUT BUFFER
  572. *********************************************************************/
  573. void ResetInputBuffer()
  574. {
  575. serialread=serialput=serialbuff;
  576. serialend=serialbuff+RINGBUFF-2;
  577. }
  578.  
  579. /*********************************************************************
  580. TRanfer control DO NOTHING module - used at near buffer full
  581. *********************************************************************/
  582. void TrDoNothing() { }
  583.  
  584. /*********************************************************************
  585. RTS TRanss OFF
  586. *********************************************************************/
  587. void RTS_TrOff()
  588. {
  589. _os_ss_dsrts(mp);
  590. }
  591.  
  592. /*********************************************************************
  593. RTS TRans ON
  594. *********************************************************************/
  595. void RTS_TrOn()
  596. {
  597. _os_ss_enrts(mp);
  598. }
  599.  
  600. /*********************************************************************
  601. Send a string to the terminal
  602. *********************************************************************/
  603. t_puts(s)
  604. register char  *s;
  605. {
  606. u_int32 size=strlen(s);
  607. while(size--)
  608.     ToScreen(*s++);
  609. }
  610.  
  611. /*********************************************************************
  612. Terminal PRINT function - does not go to the capture file
  613. *********************************************************************/
  614. tprint(char *s)
  615. {
  616. u_int32 size = strlen(s);
  617. _os_write(1,s,&size);
  618. }
  619.  
  620. /*********************************************************************
  621. write a character TO the SCREEN
  622. *********************************************************************/
  623. void ToScreen(int c)
  624. {
  625. u_int32 size;
  626.  
  627. if(c > 255)
  628.     return;
  629. c &= filterbyte;
  630. /* save character */
  631. *screenptr++=c;
  632. screenwait++;
  633. if(capflg)
  634.     dskout(c);
  635.  
  636. if(oncall == 0 || c == LF || screenwait >= SBUFFSIZE)
  637.     {
  638.     TrOff();
  639.     size=screenwait;
  640.     _os_write(1,screenbuff,&size);      /* */
  641.     if(capflg)
  642.         dskout(-1);                     /* flush buffer */
  643.     screenptr=screenbuff;
  644.     screenwait=0;
  645.     TrOn();
  646.     }
  647. }
  648.  
  649. /**********************************************************************
  650. read the INput KEY sequence
  651. **********************************************************************/
  652. int inkey()
  653. {
  654. u_int32 size=1;
  655. static unsigned char ch;
  656. unsigned int kp,keys=0;
  657.  
  658. g_sigkb=0;
  659.  
  660. if(ch==0)
  661.     _os_read(0,&ch,&size);
  662. kp=ch;
  663. if(kp>0x1F)                 /* if not control */
  664.     {
  665.     ch=0;
  666.     sig_on();
  667.     return kp;               /* send it back as is */
  668.     }
  669. keys<<=HASHIFT;
  670. keys+=kp;
  671.  
  672. #if 0
  673. if(keys == metachar)        /* if 2-key sequence start */
  674.    {
  675.    size = 1;
  676.    _os_read(0,&ch,&size);
  677.    kp=ch;
  678.    keys<<=HASHIFT;
  679.    keys+=kp;
  680.    }
  681. #endif
  682.  
  683. while(delay())
  684.    {
  685.    size = 1;
  686.    _os_read(0,&ch,&size); 
  687.    kp=ch;
  688.    if(kp == 0x1B)           /* if new sequence start */
  689.         {
  690.         sig_on();
  691.         return keys;
  692.         }
  693.  
  694.    keys<<=HASHIFT;
  695.    keys+=kp;
  696.    }
  697. ch=0;
  698. sig_on();
  699. return keys;
  700. }
  701.  
  702. /**********************************************************************
  703. Key Press DELAY necessary for slow terminals
  704.    returns 1 if data ready
  705.    cycles a maximum if 6 times before assuming no more data to read
  706. **********************************************************************/
  707. int delay()
  708. {
  709. register int cntr;
  710. u_int32 count;
  711. signal_code signal;
  712.  
  713. for(cntr=0;cntr<6;cntr++)
  714.     {
  715.     if(_os_gs_ready(0,&count) == 0)
  716.         return 1;
  717.     count = 2;
  718.     TSleep(count,signal);
  719.     }
  720. return 0;
  721. }
  722.  
  723. /*********************************************************************
  724. EAT any stuff at the TERMINAL
  725. *********************************************************************/
  726. eatterminal()
  727. {
  728. u_int32 n;
  729. char cleaner[32];
  730.  
  731. if(_os_gs_ready(0,&n) == 0)
  732.     _os_read(0,cleaner,&n);
  733. }
  734.  
  735. /*********************************************************************
  736. Terminal GET String
  737. *********************************************************************/
  738. t_gets(s,n)
  739. char *s;
  740. u_int32 n;
  741. {
  742. ReleaseModemSignal();
  743. cook_io();
  744. if(_os_readln(0,s,&n) == 0)
  745.     s[n-1] = '\0';
  746. raw_io();
  747. eatterminal();
  748. }
  749.  
  750. /*********************************************************************
  751. READ with a single character TIMED out
  752. *********************************************************************/
  753. ReadTimed(tmax)
  754. int tmax;
  755. {
  756. FlushSerial();
  757. if(serialread == serialput)     /* if nothing in buffer */
  758.     {
  759.     if(WaitSerial(tmax) == 0)   /* and nothing arrives */
  760.         return -1;
  761.     if(g_sigmodem == 0)         /* or woke up for the wrong reason */
  762.         return -1;
  763.     }
  764. return (m_getc());
  765. }
  766.  
  767. /*
  768.  * interface to the CIS B protocol package for aborting a file transfer
  769.  * this routine will eat all terminal input except ESC a
  770.  */
  771.  
  772. want_abort()
  773.     {
  774.     static int  seen_esc = FALSE;
  775.     int         c;
  776.  
  777.     if (g_sigkb > 0)
  778.        if ((c = inkey()) == ESC)
  779.           seen_esc = TRUE;
  780.        else
  781.           if (seen_esc)
  782.              {
  783.              if ((c == 'A') || (c == 'a'))
  784.                 {
  785.                 seen_esc = FALSE;
  786.                 return (TRUE);
  787.                 }
  788.              if ((c == 'Q') || (c == 'q'))
  789.                 {
  790.                 cleanup();
  791.                 exit (0);
  792.                 }
  793.              }
  794.  
  795.     return (FALSE);
  796.     }
  797.  
  798. /*
  799.  * Baud rate routines
  800.  */
  801.  
  802. get_baud(code)
  803. int   code;
  804. {
  805. return (baud_table[code]);
  806. }
  807.  
  808.  
  809. /*********************************************************************
  810. GET the BAUD string - return baud rate string or "???" if unknown
  811. *********************************************************************/
  812. char *GetBaud()
  813. {
  814. int   i;
  815.  
  816. for (i = 0; i < BDTB_SIZ; ++i)
  817.     {
  818.     if (cur_baud == baud_codes[i])
  819.         return baud_string[i];
  820.     }
  821. return "???";
  822. }
  823.  
  824. show_at(x, y, fmt, arg1, arg2, arg3)
  825. int    x, y;          /* x, y coord on screen    */
  826. char   *fmt;          /* a printf format string  */
  827. int    arg1, arg2, arg3; /* args for format srting  */
  828.     {
  829.     char  buf[132];
  830.  
  831.     t_puts(tgoto(CM, x, y));
  832.     sprintf(buf, fmt, arg1, arg2, arg3);
  833.     t_puts(buf);
  834.     }
  835.  
  836. show_at1(x, y, fmt)
  837. int    x, y;          /* x, y coord on screen    */
  838. char   *fmt;          /* a printf format string  */
  839. /* int    arg1, arg2, arg3; /* args for format srting  */
  840.     {
  841.     char  buf[132];
  842.  
  843.     t_puts(tgoto(CM, x, y));
  844.     sprintf(buf, fmt);
  845.     t_puts(buf);
  846.     }
  847.  
  848. /*********************************************************************
  849. SHOW a BOX - 
  850.     Characters have been changed to glyphs in this function
  851.     Ed Gresick rewrote this and I rewrote his rewrite [JSC]
  852. *********************************************************************/
  853. show_box(x1, x2, y1, y2)
  854. int      x1, x2, y1, y2;
  855. {
  856. char buf1[80], buf2[80], buf3[80];
  857. char *p;
  858. int j;
  859.  
  860. for (p = buf2, j = 0; j < 80; ++j)
  861.     *p++ = ' ';          /* middle rows */
  862.  
  863. for (p = buf1, j = 0; j < 80; ++j)
  864.     *p++ = glyph[6];             /* top row */
  865.  
  866. for (p = buf3, j = 0; j < 80; ++j)
  867.     *p++ = glyph[6];             /* bottom row */
  868.  
  869. buf1[0] = glyph[5];    /* upper left hand corner */
  870. buf1[x2 - x1] = glyph[2];    /* upper right hand corner  */
  871. buf1[x2 - x1 + 1] = '\0';
  872. buf2[0] = glyph[1];    /* edges */
  873. buf2[x2 - x1] = glyph[1];
  874. buf2[x2 - x1 + 1] = '\0';
  875. buf3[0] = glyph[4];             /* lower left hand corner  */
  876. buf3[x2 - x1] = glyph[3];
  877. buf3[x2 - x1 + 1] = '\0';   /* lower right hand corner  */
  878.  
  879. t_puts(CL);          /* start with clean screen */
  880. /*   t_puts(SO);          /* turn on inverse video */
  881. show_at1(x1, y1, buf1);        /* top row of box */
  882. for (j = y1 + 1; j < y2; ++j)
  883.     show_at1(x1, j, buf2);      /* middle rows of box */
  884. show_at1(x1, y2, buf3);        /* bottom row of box */
  885. }
  886.  
  887. /*  New function by [EG] - I changed this to return a 0 if OK a 1 if 
  888.     entry is missing this lets the program check for _all_ entries
  889.     before exiting [SC] */
  890. static check(char *p, char *parm)
  891. {
  892.     if (p == 0) {
  893.        t_puts("Termcap entry - '"); t_puts(parm);
  894.        t_puts("' missing!\n");
  895.        return 1;
  896.     }
  897. return 0;
  898. }
  899.  
  900. /*********************************************************************
  901. EXTRACT teh ring buffer SIZE if passed as an option
  902. *********************************************************************/
  903. ExtractSize(s)
  904. char *s;
  905. {
  906. return RINGBUFF;        /* maybe someday */
  907. }
  908.  
  909. /*********************************************************************
  910. FIX the Modem PATH options so they work for us
  911. *********************************************************************/
  912. FixMPath(pd)
  913. #ifdef _MPF386
  914.     struct scf_path_opts *pd;
  915. #else
  916.     struct scf_opt *pd;
  917. #endif
  918. {
  919. #ifdef _MPF386
  920.     pd->pd_eorch =
  921.     pd->pd_eofch =
  922.     pd->pd_tabch =
  923.     pd->pd_bellch =
  924.     pd->pd_bspch =
  925.     pd->pd_case =
  926.     pd->pd_backsp =
  927.     pd->pd_delete =
  928.     pd->pd_echo =
  929.     pd->pd_alf =
  930.     pd->pd_pause =
  931.     pd->pd_nulls =
  932.     pd->pd_page =
  933.     pd->pd_tabsiz =
  934.     pd->pd_insm = 0;
  935. /*     pd->v_xoff = 0;   */
  936. #endif
  937.  
  938. #ifdef _MPF68K
  939. /*  pd->pd_dtp;         /* device type */
  940.     pd->pd_upc=0;         /* case (0=both, 1=upper only) */
  941.     pd->pd_bso=0;         /* backsp (0=bse, 1=bse,sp,bse) */
  942.     pd->pd_dlo=0;         /* delete (0=bse over line, 1=crlf) */
  943.     pd->pd_eko=0;         /* echo (0=no echo) */
  944.     pd->pd_alf=0;         /* autolf (0=no auto lf) */
  945.     pd->pd_nul=0;         /* end of line null count */
  946.     pd->pd_pau=0;         /* pause (0=no end of page pause)
  947.     pd->pd_pag=0;         /* lines per page */
  948.     pd->pd_bsp=0;         /* backspace character */
  949.     pd->pd_del=0;         /* delete line character */
  950.     pd->pd_eor=0;         /* end of record char (read only) */
  951.     pd->pd_eof=0;         /* end of file char */
  952.     pd->pd_rpr=0;         /* reprint line char */
  953.     pd->pd_dup=0;         /* dup last line char */
  954.     pd->pd_psc=0;         /* pause char */
  955.     pd->pd_int=0;         /* kbd intr char (ctl c) */
  956.     pd->pd_qut=0;         /* kbd quit char (ctl q) */
  957.     pd->pd_bse=0;         /* backspace echo character */
  958.     pd->pd_ovf=0;         /* line overflow char (bell) */
  959.     pd->pd_par=0;         /* parity code */
  960. /*    pd->pd_bau;           /* acia baud rate (color computer) */
  961. /*    pd->pd_d2p;           /* dev2 output name offset */
  962.     pd->pd_xon=0;         /* x-on char */
  963.     pd->pd_xoff=0;        /* x-off char */
  964.     pd->pd_Tab=0;         /* Tab character (0=none) */
  965.     pd->pd_Tabs=0;        /* Tab field size */
  966. /*    pd->pd_tbl;           /* Device table addr (copy) */
  967. /*    pd->pd_Col;           /* current column number */
  968. /*    pd->pd_err;           /* most recent I/O error status */
  969. /*    pd->pd_scfres2[61];   /* reserved for SCF usage */
  970. /*    pd->pd_gfmucm[32];    /* reserved for GFM/UCM usage */
  971. #endif
  972. }
  973.  
  974. /*********************************************************************
  975. special FIX Modem PATH for lu_opts under OS9/x86
  976. *********************************************************************/
  977. #ifdef _MPF386
  978. static FixMPath1(p)
  979. struct scf_lu_opts *p;
  980. {
  981.     p->v_intr =
  982.     p->v_quit =
  983.     p->v_psch =
  984.     p->v_xon =
  985.     p->v_xoff = 0;
  986. }
  987. #endif
  988.  
  989. /*********************************************************************
  990. FIX the Terminal PATH options
  991. *********************************************************************/
  992. FixTPath(pd)
  993. #ifdef _MPF386
  994.     struct scf_path_opts *pd;
  995. #else
  996.     struct scf_opt *pd;
  997. #endif
  998. {
  999. #ifdef _MPF386
  1000.     pd->pd_eorch =
  1001.     pd->pd_eofch =
  1002.     pd->pd_tabch =
  1003.     pd->pd_bellch =
  1004.     pd->pd_bspch =
  1005.     pd->pd_case =
  1006.     pd->pd_backsp =
  1007.     pd->pd_delete =
  1008.     pd->pd_echo =
  1009.     pd->pd_alf =
  1010.     pd->pd_pause =
  1011.     pd->pd_nulls =
  1012.     pd->pd_page =
  1013.     pd->pd_tabsiz =
  1014.     pd->pd_insm = 0;
  1015. /*     pd->v_xoff = 0;   */
  1016. #endif
  1017.  
  1018. #ifdef _MPF68K
  1019. /*  pd->pd_dtp;         /* device type */
  1020.     pd->pd_upc=0;         /* case (0=both, 1=upper only) */
  1021.     pd->pd_bso=0;         /* backsp (0=bse, 1=bse,sp,bse) */
  1022.     pd->pd_dlo=0;         /* delete (0=bse over line, 1=crlf) */
  1023.     pd->pd_eko=0;         /* echo (0=no echo) */
  1024.     pd->pd_alf=0;         /* autolf (0=no auto lf) */
  1025.     pd->pd_nul=0;         /* end of line null count */
  1026.     pd->pd_pau=0;         /* pause (0=no end of page pause)
  1027.     pd->pd_pag=0;         /* lines per page */
  1028.     pd->pd_bsp=0;         /* backspace character */
  1029.     pd->pd_del=0;         /* delete line character */
  1030.     pd->pd_eor=0;         /* end of record char (read only) */
  1031.     pd->pd_eof=0;         /* end of file char */
  1032.     pd->pd_rpr=0;         /* reprint line char */
  1033.     pd->pd_dup=0;         /* dup last line char */
  1034.     pd->pd_psc=0;         /* pause char */
  1035.     pd->pd_int=0;         /* kbd intr char (ctl C) */
  1036. #ifndef DEBUG
  1037.     pd->pd_qut=0;         /* kbd quit char (ctl E) */
  1038. #endif
  1039.     pd->pd_bse=0;         /* backspace echo character */
  1040.     pd->pd_ovf=0;         /* line overflow char (bell) */
  1041.     pd->pd_par=0;         /* parity code */
  1042. /*    pd->pd_bau;           /* acia baud rate (color computer) */
  1043. /*    pd->pd_d2p;           /* dev2 output name offset */
  1044.     pd->pd_xon=0;         /* x-on char */
  1045.     pd->pd_xoff=0;        /* x-off char */
  1046.     pd->pd_Tab=0;         /* Tab character (0=none) */
  1047.     pd->pd_Tabs=0;        /* Tab field size */
  1048. /*    pd->pd_tbl;           /* Device table addr (copy) */
  1049. /*    pd->pd_Col;           /* current column number */
  1050. /*    pd->pd_err;           /* most recent I/O error status */
  1051. /*    pd->pd_scfres2[61];   /* reserved for SCF usage */
  1052. /*    pd->pd_gfmucm[32];    /* reserved for GFM/UCM usage */
  1053. #endif
  1054. }
  1055.  
  1056. /*********************************************************************
  1057. special FIXPATH for lu_opts under OS9/x86
  1058. *********************************************************************/
  1059. #ifdef _MPF386
  1060. static fixpath1(p)
  1061. struct scf_lu_opts *p;
  1062. {
  1063.     p->v_intr =
  1064. #ifndef DEBUG
  1065.     p->v_quit =
  1066. #endif
  1067.     p->v_psch =
  1068.     p->v_xon =
  1069.     p->v_xoff = 0;
  1070. }
  1071. #endif
  1072.  
  1073.  
  1074.