home *** CD-ROM | disk | FTP | other *** search
/ Beijing Paradise BBS Backup / PARADISE.ISO / software / BBSDOORW / PPL4C11.ZIP / MODEM_IO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-18  |  6.7 KB  |  293 lines
  1. /*** MODEM_IO.C ***/
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <ctype.h>
  7. #include <conio.h>
  8. #include "pcl4c.h"
  9. #include "ascii.h"
  10. #include "modem_io.h"
  11. #include "term_io.h"
  12. #include "win_io.h"
  13.  
  14. #define FALSE 0
  15. #define TRUE !FALSE
  16. #define ONE_SECOND 18
  17.  
  18. /* NOTE: Requires AT COMMAND SET for all functions in this file */
  19.  
  20. static int  Debug = FALSE;
  21.  
  22. static int  LastPort;         /* last port referenced */
  23.  
  24. static char MatchString[80];  /* ModemWaitFor() match string */
  25. static int  MatchLength= 0;   /* string length */
  26. static int  MatchCount = 0;   /* # sub-strings */
  27. static struct
  28.   {char *Start;               /* ptr to 1st char of string */
  29.    char *Ptr;                 /* working ptr */
  30.   } MatchList[10];
  31.  
  32. char Temp[120];
  33.  
  34. /*** PRIVATE functions ***/
  35.  
  36. static int BreakTest(void)
  37. {/* User BREAK ? */
  38.  if(SioBrkKey()||kbhit())
  39.     {WinPutString(SCR_WIN,"User BREAK\n");
  40.      return(TRUE);
  41.     }
  42.  return(FALSE);
  43. }
  44.  
  45. void MatchInit(char *S)
  46. {int  i;
  47.  char C;
  48.  char *Ptr;
  49.  MatchCount = 0;
  50.  strncpy(MatchString,S,80);
  51.  MatchLength = strlen(MatchString);
  52.  Ptr = MatchString;
  53.  MatchList[MatchCount].Start = Ptr;
  54.  MatchList[MatchCount++].Ptr = Ptr;
  55.  while(*Ptr)
  56.    {if(*Ptr=='|')
  57.       {/* mark start of next string */
  58.        MatchList[MatchCount].Start = Ptr + 1;
  59.        MatchList[MatchCount++].Ptr = Ptr + 1;
  60.       }
  61.     Ptr++;
  62.    }
  63. }
  64.  
  65. void MatchUpper(void)
  66. {int i;
  67.  char *Ptr;
  68.  Ptr = MatchString;
  69.  for(i=0;i<MatchLength;i++)
  70.    {*Ptr = toupper(*Ptr);
  71.     Ptr++;
  72.    }
  73. }
  74.  
  75. int MatchChar(char C)
  76. {int  i;
  77.  char *Ptr;
  78.  char *Start;
  79.  /* consider each string in turn */
  80.  for(i=0;i<MatchCount;i++)
  81.    {Ptr = MatchList[i].Ptr;
  82.     Start = MatchList[i].Start;
  83.     if(*Ptr==C)
  84.       {/* char C matches */
  85. #if 0
  86. sprintf(Temp,"<%c:%d:%d>",C,i,(Ptr-Start));
  87. WinPutString(SCR_WIN,Temp);
  88. #endif
  89.        Ptr++;
  90.        if((*Ptr=='|')||(*Ptr=='\0'))
  91.          {MatchList[i].Ptr = Start;
  92. #if 0
  93. sprintf(Temp,"<<%d>>",i);
  94. WinPutString(SCR_WIN,Temp);
  95. #endif
  96.           return i;
  97.          }
  98.        else MatchList[i].Ptr = Ptr;
  99.       }
  100.     else
  101.       {/* char C does NOT match */
  102.        MatchList[i].Ptr = Start;
  103.        /* look again if was not 1st char  */
  104.        if(Ptr!=Start) i--;
  105.       }
  106.    }
  107.  return -1;
  108. }
  109.  
  110. /*** PUBLIC functions ***/
  111.  
  112. /* echos incoming to screen */
  113.  
  114. void ModemEcho(int Port,int Echo)
  115. {int rc;
  116.  long Time;
  117.  Time = SioTimer();
  118.  while(SioTimer() < Time+(long)Echo)
  119.    {rc = CharGet(Port,1);
  120.     if(rc>=0) WinPutChar(SCR_WIN,(char)rc);
  121.    }
  122. }
  123.  
  124. /* send string to modem & get echo */
  125.  
  126. int ModemSendTo(
  127.   int  Port,       /* port to talk to */
  128.   int  Pace,       /* inter-char delay */
  129.   char *String)    /* string to send to modem */
  130. {int i, rc;
  131.  char c;
  132.  int Code;
  133.  long Time;
  134.  if(Debug)
  135.    {sprintf(Temp," [Sending '%s'] ",String);
  136.     WinPutString(SCR_WIN,Temp);
  137.    }
  138.  for(i=0;i<strlen(String);)
  139.     {/* User BREAK ? */
  140.      if(BreakTest()) return(FALSE);
  141.      /* delay <Pace> tics */
  142.      if(Pace>0) SioDelay(Pace);
  143.      /* fetch character */
  144.      c = String[i++];
  145.      switch(c)
  146.         {case '^':
  147.             /* next char is control char */
  148.             c = String[i++] - '@';
  149.             break;
  150.          case '!':
  151.             /* replace ! with carriage return */
  152.             c = CR;
  153.             break;
  154.          case '~':
  155.             /* delay 1/2 second */
  156.             SioDelay(ONE_SECOND/2);
  157.             c = ' ';
  158.             break;
  159.          case ' ':
  160.             /* delay 1/4 second */
  161.             SioDelay(ONE_SECOND/4);
  162.             c = ' ';
  163.             break;
  164.         } /* end switch */
  165.      /* transmit as 7 bit ASCII character */
  166.      CharPut(Port,(char)(0x7f & c));
  167.     }
  168.  return(TRUE);
  169. } /* end SendTo */
  170.  
  171. /* wait for 'String' */
  172.  
  173. /* NOTES:
  174. **  (1)  Will return NULL if no match, else '0' if 1st, '2' if 2nd, etc.
  175. **       where String = "<1st substr>|<2nd substr>| ..."
  176. **  (2)  Example call: ModemWaitFor(COM1,180,FALSE,"more ?|Menu:");
  177. */
  178.  
  179. char ModemWaitFor(
  180.   int  Port,       /* Port to talk to */
  181.   int  Tics,       /* wait in tics for string */
  182.   int  CaseFlag,   /* TRUE = case sensitive compares */
  183.   char *String)    /* string to wait for */
  184. {int i, k;
  185.  int rc;
  186.  char C;
  187.  int Code;
  188.  long Time;
  189.  /* wait for string */
  190.  Time = SioTimer();
  191.  MatchInit(String);
  192.  if(!CaseFlag) MatchUpper();
  193.  if(Debug)
  194.    {sprintf(Temp," [Awaiting '%s'] ",String);
  195.     WinPutString(SCR_WIN,Temp);
  196.    }
  197.  while(SioTimer()<(Time+(long)Tics))
  198.    {/* User BREAK ? */
  199.     if(BreakTest()) return(FALSE);
  200.     /* wait for next character */
  201.     Code = CharGet(Port,1);
  202.     if(Code<-1) return(FALSE);
  203.     if(Code>=0)
  204.       {/* echo char */
  205.        WinPutChar(SCR_WIN,(char)Code);
  206.        /* case sensitive ? */
  207.        if(CaseFlag) C = (char)Code;
  208.        else C = toupper( (char)Code );
  209.        /* does char match ? */
  210.        rc = MatchChar(C);
  211.        if(rc>=0) return ('0' + rc);
  212.       }
  213.    } /* end for(i) */
  214.  return 0;
  215. }
  216.  
  217. /* enter command state */
  218.  
  219. /* NOTE: assumes escape char = '+' & guard time = 1 sec */
  220.  
  221. void ModemCmdState(int Port)
  222. {int i;
  223.  /* delay a bit over 1 second */
  224.  SioDelay(ONE_SECOND+ONE_SECOND/4);
  225.  /* send Escape Code exactly 3 times */
  226.  for(i=0;i<3;i++)
  227.     {CharPut(Port,'+');
  228.      SioDelay(ONE_SECOND/4);
  229.     }
  230.  /* delay again */
  231.  SioDelay(ONE_SECOND+ONE_SECOND/4);
  232. } /* end ModemCmdState */
  233.  
  234. /* hangup phone (in command state) */
  235.  
  236. void ModemHangup(int Port)
  237. {/* enter command state */
  238.  ModemCmdState(Port);
  239.  /* hangup ! */
  240.  ModemSendTo(Port,4,"!AT!");
  241.  ModemEcho(Port,10);
  242.  ModemSendTo(Port,4,"ATH0!");
  243. } /* end Hangup */
  244.  
  245. /* wait for continuous quiet (no incoming serial data) */
  246.  
  247. int ModemQuiet(
  248.   int  Port,       /* Port to talk to */
  249.   int  Tics)       /* # tics quiet required */
  250. {int i;
  251.  int Code;
  252.  long CharTime;
  253.  /* set up */
  254.  CharTime = SioTimer();
  255.  while(1)
  256.    {/* User BREAK ? */
  257.     if(BreakTest())
  258.       {
  259.        return(FALSE);
  260.       }
  261.     /* wait for next character */
  262.     Code = CharGet(Port,1);
  263.     if(Code<-1) return(FALSE);
  264.     if(Code>=0)
  265.       {CharTime = SioTimer();
  266.        WinPutChar(SCR_WIN,(char)Code);
  267.       }
  268.     else
  269.       {/* ==-1, timed out */
  270.        if(SioTimer() >= CharTime+(long)Tics) return TRUE;
  271.       }
  272.    } /* end while */
  273. }
  274.  
  275. void ModemDump(void)
  276. {int i;
  277.  sprintf(Temp,"WAITFOR: Count=%d Length=%d \n",
  278.    MatchCount,MatchLength);
  279.  WinPutString(SCR_WIN,Temp);
  280.  sprintf(Temp,"   String= [0x%x] '%s'\n",MatchString,MatchString);
  281.  WinPutString(SCR_WIN,Temp);
  282.  for(i=0;i<10;i++)
  283.    {if(MatchList[i].Start==NULL) break;
  284.     sprintf(Temp,"   Start=0x%x Ptr=0x%x\n",MatchList[i].Start,MatchList[i].Ptr);
  285.     WinPutString(SCR_WIN,Temp);
  286.    }
  287. }
  288.  
  289. void ModemDebug(void)
  290. {Debug = TRUE;
  291.  WinPutString(SCR_WIN,"[DEBUG]");
  292. }
  293.