home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / terminal / term / extras / source / term-source.lha / termRemember.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-26  |  8.8 KB  |  473 lines
  1. /*
  2. **    termRemember.c
  3. **
  4. **    Login learn routines
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10.     /* How many characters to remember. */
  11.  
  12. #define REMEMBER_OUT    40
  13. #define REMEMBER_IN    256
  14.  
  15.     /* Yet another node variant. */
  16.  
  17. struct RecordNode
  18. {
  19.     struct Node    Node;
  20.     struct timeval    Time;
  21. };
  22.  
  23.     /* What type of text was recorded. */
  24.  
  25. enum    {    RECORD_OUTPUT,RECORD_INPUT };
  26.  
  27.     /* The last ten bytes received. */
  28.  
  29. STATIC UBYTE         RememberOutputData[2 * REMEMBER_OUT + 10];
  30. STATIC WORD         RememberOutputSize;
  31.  
  32.     /* The last 256 bytes sent. */
  33.  
  34. STATIC UBYTE         RememberInputData[2 * REMEMBER_IN + 10];
  35. STATIC WORD         RememberInputSize;
  36.  
  37.     /* The name of the BBS we are currently recording for. */
  38.  
  39. STATIC UBYTE         RecordName[50];
  40.  
  41.     /* Recorded lines. */
  42.  
  43. STATIC struct List    *RecordList;
  44. STATIC LONG         RecordCount;
  45.  
  46.     /* Auxilary data. */
  47.  
  48. STATIC STRPTR         RecordAuxBuffer;
  49.  
  50.     /* Start of recording. */
  51.  
  52. STATIC struct timeval     RecordTime;
  53.  
  54.     /* FinishRecord():
  55.      *
  56.      *    Finish the recording process, store the
  57.      *    recorded data in a file.
  58.      */
  59.  
  60. VOID
  61. FinishRecord()
  62. {
  63.     if(RecordCount)
  64.     {
  65.         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  66.         struct FileRequester    *FileRequest;
  67.  
  68.         BlockWindows();
  69.  
  70.         Recording = RecordingLine = FALSE;
  71.  
  72.         Status = STATUS_READY;
  73.  
  74.         if(RecordName[0])
  75.             strcpy(DummyBuffer,RecordName);
  76.         else
  77.         {
  78.             strcpy(DummyBuffer,LocaleString(MSG_SCREENPANEL_UNKNOWN_TXT));
  79.  
  80.             strcpy(RecordName,DummyBuffer);
  81.         }
  82.  
  83.         FixName(DummyBuffer);
  84.  
  85.         DummyBuffer[27] = 0;
  86.  
  87.         strcat(DummyBuffer,".term");
  88.  
  89.         if(FileRequest = GetFile(Window,LocaleString(MSG_SAVE_RECORDED_FILE_TXT),"",DummyBuffer,DummyBuffer,"#?.(term|rexx)",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_GAD),TRUE))
  90.         {
  91.             BPTR        FileHandle;
  92.             LONG        Error = 0;
  93.             struct timeval    Delta = { 0,0 };
  94.  
  95.             if(FileHandle = Open(DummyBuffer,MODE_NEWFILE))
  96.             {
  97.                 SetIoErr(0);
  98.  
  99.                 if(FPrintf(FileHandle,LocaleString(MSG_RECORDFILE_HEADER_TXT),RecordName) < 1)
  100.                     Error = IoErr();
  101.  
  102.                 if(!Error)
  103.                 {
  104.                     struct RecordNode *Node = (struct RecordNode *)RecordList -> lh_Head;
  105.  
  106.                     while(Node -> Node . ln_Succ && !Error)
  107.                     {
  108.                         if(Delta . tv_secs != Node -> Time . tv_secs)
  109.                         {
  110.                             LONG Secs;
  111.  
  112.                             Secs = (3 * Node -> Time . tv_secs) / 2 + (3 * Node -> Time . tv_micro) / 2000000;
  113.  
  114.                             SetIoErr(0);
  115.  
  116.                             if(FPrintf(FileHandle,"TIMEOUT %ld\n",Secs) < 1)
  117.                             {
  118.                                 Error = IoErr();
  119.  
  120.                                 break;
  121.                             }
  122.                             else
  123.                                 Delta = Node -> Time;
  124.                         }
  125.  
  126.                         SetIoErr(0);
  127.  
  128.                         if(Node -> Node . ln_Type == RECORD_OUTPUT)
  129.                         {
  130.                             if(FPrintf(FileHandle,"WAIT TEXT \"%s\"\n",Node -> Node . ln_Name) < 1)
  131.                                 Error = IoErr();
  132.                         }
  133.                         else
  134.                         {
  135.                             if(FPrintf(FileHandle,"SEND TEXT \"%s\"\n\n",Node -> Node . ln_Name) < 1)
  136.                                 Error = IoErr();
  137.                         }
  138.  
  139.                         Node = (struct RecordNode *)Node -> Node. ln_Succ;
  140.                     }
  141.                 }
  142.  
  143.                 Close(FileHandle);
  144.  
  145.                 ObtainSemaphore(&PatternSemaphore);
  146.  
  147.                 if(ChosenEntry)
  148.                 {
  149.                     if(MyEasyRequest(Window,LocaleString(MSG_USE_AS_LOGIN_SCRIPT_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),ChosenEntry -> Header -> Name))
  150.                     {
  151.                         if(!ChosenEntry -> Config -> CommandConfig)
  152.                         {
  153.                             if(!CreateConfigEntry(ChosenEntry -> Config,PREF_COMMAND))
  154.                                 ShowError(Window,ERR_NO_MEM,NULL,NULL);
  155.                         }
  156.  
  157.                         if(ChosenEntry -> Config -> CommandConfig)
  158.                         {
  159.                             PhonebookChanged = TRUE;
  160.  
  161.                             SPrintf(ChosenEntry -> Config -> CommandConfig -> LoginMacro,"\\a %s",DummyBuffer);
  162.                         }
  163.                     }
  164.                 }
  165.  
  166.                 ReleaseSemaphore(&PatternSemaphore);
  167.             }
  168.             else
  169.                 Error = IoErr();
  170.  
  171.             if(!Error && Config -> MiscConfig -> CreateIcons && IconBase)
  172.             {
  173.                 struct DiskObject *Icon;
  174.  
  175.                 if(!(Icon = GetDiskObject("ENV:def_term")))
  176.                 {
  177.                     if(!(Icon = GetDiskObject("ENV:def_rexx")))
  178.                     {
  179.                         if(Icon = GetDefDiskObject(WBPROJECT))
  180.                             Icon -> do_DefaultTool = "RX";
  181.                     }
  182.                 }
  183.  
  184.                 if(Icon)
  185.                 {
  186.                     Icon -> do_CurrentX = Icon -> do_CurrentY = NO_ICON_POSITION;
  187.  
  188.                     PutDiskObject(DummyBuffer,Icon);
  189.  
  190.                     FreeDiskObject(Icon);
  191.                 }
  192.             }
  193.  
  194.             if(Error)
  195.                 ShowError(Window,ERR_SAVE_ERROR,Error,DummyBuffer);
  196.  
  197.             FreeAslRequest(FileRequest);
  198.         }
  199.  
  200.         DeleteRecord();
  201.  
  202.         ReleaseWindows();
  203.     }
  204. }
  205.  
  206.     /* CreateRecord(STRPTR BBSName):
  207.      *
  208.      *    Start recording incoming and outgoing text.
  209.      */
  210.  
  211. BOOLEAN __regargs
  212. CreateRecord(STRPTR BBSName)
  213. {
  214.     DeleteRecord();
  215.  
  216.     if(RecordList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  217.     {
  218.         if(RecordAuxBuffer = (STRPTR)AllocVecPooled(1024,MEMF_ANY))
  219.         {
  220.             strcpy(RecordName,BBSName);
  221.  
  222.             NewList(RecordList);
  223.  
  224.             TimeRequest -> tr_node . io_Command = TR_GETSYSTIME;
  225.  
  226.             DoIO(TimeRequest);
  227.  
  228.             RecordTime = TimeRequest -> tr_time;
  229.  
  230.             return(TRUE);
  231.         }
  232.  
  233.         FreeVecPooled(RecordList);
  234.  
  235.         RecordList = NULL;
  236.     }
  237.  
  238.     return(FALSE);
  239. }
  240.  
  241.     /* DeleteRecord():
  242.      *
  243.      *    Stop recording, free auxilary buffers.
  244.      */
  245.  
  246. VOID
  247. DeleteRecord()
  248. {
  249.     if(RecordAuxBuffer)
  250.     {
  251.         FreeVecPooled(RecordAuxBuffer);
  252.  
  253.         RecordAuxBuffer = NULL;
  254.     }
  255.  
  256.     if(RecordList)
  257.     {
  258.         DeleteList(RecordList);
  259.  
  260.         RecordList = NULL;
  261.     }
  262.  
  263.     RecordCount = 0;
  264. }
  265.  
  266.     /* RememberResetOutput():
  267.      *
  268.      *    Reset output monitoring.
  269.      */
  270.  
  271. VOID
  272. RememberResetOutput()
  273. {
  274.     RememberOutputSize = 0;
  275. }
  276.  
  277.     /* RememberOutputText(register STRPTR String,register LONG Size):
  278.      *
  279.      *    Remember the last ten characters received.
  280.      */
  281.  
  282. VOID __regargs
  283. RememberOutputText(register STRPTR String,register LONG Size)
  284. {
  285.     if(Size >= REMEMBER_OUT)
  286.     {
  287.         CopyMem(String + Size - REMEMBER_OUT,RememberOutputData,REMEMBER_OUT);
  288.  
  289.         RememberOutputSize = REMEMBER_OUT;
  290.     }
  291.     else
  292.     {
  293.         if(RememberOutputSize + Size > REMEMBER_OUT)
  294.         {
  295.             LONG Delta = RememberOutputSize + Size - REMEMBER_OUT,i;
  296.  
  297.             for(i = 0 ; i < RememberOutputSize - Delta ; i++)
  298.                 RememberOutputData[i] = RememberOutputData[Delta + i];
  299.  
  300.             while(i < REMEMBER_OUT)
  301.                 RememberOutputData[i++] = *String++;
  302.  
  303.             RememberOutputSize = REMEMBER_OUT;
  304.         }
  305.         else
  306.         {
  307.             CopyMem(String,&RememberOutputData[RememberOutputSize],Size);
  308.  
  309.             RememberOutputSize += Size;
  310.         }
  311.     }
  312. }
  313.  
  314.     /* RememberResetInput():
  315.      *
  316.      *    Reset input monitoring.
  317.      */
  318.  
  319. VOID
  320. RememberResetInput()
  321. {
  322.     RememberInputSize = 0;
  323. }
  324.  
  325.     /* RememberInputText(register STRPTR String,register LONG Size):
  326.      *
  327.      *    Remember the last 256 characters sent.
  328.      */
  329.  
  330. VOID __regargs
  331. RememberInputText(register STRPTR String,register LONG Size)
  332. {
  333.     if(Size >= REMEMBER_IN)
  334.     {
  335.         CopyMem(String + Size - REMEMBER_IN,RememberInputData,REMEMBER_IN);
  336.  
  337.         RememberInputSize = REMEMBER_IN;
  338.     }
  339.     else
  340.     {
  341.         if(RememberInputSize + Size > REMEMBER_IN)
  342.         {
  343.             LONG Delta = RememberInputSize + Size - REMEMBER_IN,i;
  344.  
  345.             for(i = 0 ; i < RememberInputSize - Delta ; i++)
  346.                 RememberInputData[i] = RememberInputData[Delta + i];
  347.  
  348.             while(i < REMEMBER_IN)
  349.                 RememberInputData[i++] = *String++;
  350.  
  351.             RememberInputSize = REMEMBER_IN;
  352.         }
  353.         else
  354.         {
  355.             CopyMem(String,&RememberInputData[RememberInputSize],Size);
  356.  
  357.             RememberInputSize += Size;
  358.         }
  359.     }
  360. }
  361.  
  362.     /* DoubleQuotes(STRPTR Source,LONG Len):
  363.      *
  364.      *    Double all double-quotes in the input string
  365.      *    in order to avoid trouble with the ARexx
  366.      *    parser.
  367.      */
  368.  
  369. STATIC VOID __regargs
  370. DoubleQuotes(STRPTR Source,LONG Len)
  371. {
  372.     STRPTR    Dest = RecordAuxBuffer;
  373.     LONG    i,Count = 0;
  374.  
  375.     for(i = 0 ; i < Len ; i++)
  376.     {
  377.         if(Source[i] == '\"')
  378.         {
  379.             *Dest++ = '\"';
  380.  
  381.             Count++;
  382.         }
  383.  
  384.         *Dest++ = Source[i];
  385.     }
  386.  
  387.     if(Count)
  388.     {
  389.         *Dest = 0;
  390.  
  391.         strcpy(Source,RecordAuxBuffer);
  392.     }
  393. }
  394.  
  395.     /* RememberSpill():
  396.      *
  397.      *    `Spill' the collected text, put it into the list.
  398.      */
  399.  
  400. VOID
  401. RememberSpill()
  402. {
  403.     if(RecordList)
  404.     {
  405.         struct RecordNode    *Node;
  406.         struct timeval         Delta;
  407.  
  408.             /* Calculate the difference in time
  409.              * between the last line stored and this
  410.              * line getting stored.
  411.              */
  412.  
  413.         TimeRequest -> tr_node . io_Command = TR_GETSYSTIME;
  414.  
  415.         DoIO(TimeRequest);
  416.  
  417.         Delta = TimeRequest -> tr_time;
  418.  
  419.         SubTime(&Delta,&RecordTime);
  420.  
  421.         RecordTime = TimeRequest -> tr_time;
  422.  
  423.         if(!Delta . tv_secs)
  424.             Delta . tv_secs = 1;
  425.  
  426.         Delta . tv_micro = 0;
  427.  
  428.         if(RememberOutputSize)
  429.         {
  430.             DoubleQuotes(RememberOutputData,RememberOutputSize);
  431.  
  432.             TranslateBack(RememberOutputData,RememberOutputSize,RecordAuxBuffer);
  433.  
  434.             if(Node = (struct RecordNode *)AllocVecPooled(sizeof(struct RecordNode) + strlen(RecordAuxBuffer) + 1,MEMF_ANY))
  435.             {
  436.                 Node -> Node . ln_Name = (STRPTR)(Node + 1);
  437.                 Node -> Node . ln_Type = RECORD_OUTPUT;
  438.  
  439.                 strcpy(Node -> Node . ln_Name,RecordAuxBuffer);
  440.  
  441.                 Node -> Time = Delta;
  442.  
  443.                 AddTail(RecordList,(struct Node *)Node);
  444.  
  445.                 RecordCount++;
  446.             }
  447.         }
  448.  
  449.         if(RememberInputSize)
  450.         {
  451.             DoubleQuotes(RememberInputData,RememberInputSize);
  452.  
  453.             TranslateBack(RememberInputData,RememberInputSize,RecordAuxBuffer);
  454.  
  455.             if(Node = (struct RecordNode *)AllocVecPooled(sizeof(struct RecordNode) + strlen(RecordAuxBuffer) + 1,MEMF_ANY))
  456.             {
  457.                 Node -> Node . ln_Name = (STRPTR)(Node + 1);
  458.                 Node -> Node . ln_Type = RECORD_INPUT;
  459.  
  460.                 strcpy(Node -> Node . ln_Name,RecordAuxBuffer);
  461.  
  462.                 Node -> Time = Delta;
  463.  
  464.                 AddTail(RecordList,(struct Node *)Node);
  465.  
  466.                 RecordCount++;
  467.             }
  468.         }
  469.     }
  470.  
  471.     RememberOutputSize = RememberInputSize = 0;
  472. }
  473.