home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 038.lha / Hardcopy.c < prev    next >
C/C++ Source or Header  |  1987-05-16  |  15KB  |  565 lines
  1. /*
  2.  *  HARCOPY.C    copy CLI output to file as well as window.
  3.  *
  4.  *  By Davide P. Cervone, Copywrite (c) 1987
  5.  *
  6.  *  Based heavily on a source by Phillip Lindsay, (c) 1987 Commodore-Amiga, Inc.
  7.  *  You may use this source as long as this copywrite notice is left intact.
  8.  */
  9.  
  10. #include <exec/types.h>
  11. #include <exec/ports.h>
  12. #include <exec/semaphores.h>
  13. #include <libraries/dos.h>
  14. #include <libraries/dosextens.h>
  15. #include <stdio.h>
  16.  
  17. #ifdef MANX
  18. #include <functions.h>
  19. #endif
  20.  
  21. /*
  22.  *  AmigaDOS uses task signal bit 8 for message signaling
  23.  */
  24.  
  25. #define ONE          1L
  26. #define DOS_SIGNAL   8
  27. #define DOS_MASK     (ONE<<DOS_SIGNAL)
  28.  
  29.  
  30. /*
  31.  *  Cast a pointer to become a structure pointer
  32.  */
  33.  
  34. #define PTR(x,p)     ((struct x *)(p))
  35.  
  36.  
  37. /*
  38.  *  AmigaDOS packet types we're interested in viewing
  39.  */
  40.  
  41. #define _ACTION_READ              82L
  42. #define _ACTION_WRITE             87L
  43.  
  44.  
  45. /*
  46.  *  Short-hand for the parts of the DosPacket
  47.  */
  48.  
  49. #define ARG1    pkt->dp_Arg1
  50. #define ARG2    pkt->dp_Arg2
  51. #define RES1    pkt->dp_Res1
  52.  
  53.  
  54. /*
  55.  *  Program functions
  56.  */
  57.  
  58. #define SHOW_USAGE       0
  59. #define START_HARDCOPY   1
  60. #define DO_MONITOR       2
  61. #define END_HARDCOPY     3
  62.  
  63.  
  64. /*
  65.  *  External routines and variables
  66.  */
  67.  
  68. extern LONG AllocSignal(), Wait();
  69. extern struct FileHandle *Open();
  70. extern struct Message *PacketWait(), *GetMsg();
  71. extern struct Process *FindTask();
  72. extern struct DosLibrary *DOSBase;
  73. extern void GetDateTime();
  74.  
  75.  
  76. /*
  77.  *  Our own variables
  78.  */
  79.  
  80. static char *version   = "HARDCOPY v1.0, 4/25/87";
  81. static char *copywrite = "Copywrite (c) 1987 by Davide P. Cervone";
  82.  
  83. struct MsgPort         *thePort;        /* the port we will be monitoring */
  84. struct Process         *myProcess;      /* pointer to our own process */
  85. struct Process         *ChosenProcess;  /* the process we are monitoring */
  86. ULONG                  WaitMask;        /* the task signal mask */
  87. struct SignalSemaphore CanReturn = {0}; /* coordinates PacketWait */
  88. struct Message         *theMessage;     /* the message we received */
  89. APTR                   OldPktWait;      /* the old pr_PktWait routine */
  90. APTR                   OldUserData;     /* tc_UserData for monitored task */
  91.  
  92.  
  93. #ifdef MANX
  94.    LONG PWait();        /* this is the ASM stub that calls PacketWait() */
  95. #else
  96.    #define PWait   PacketWait
  97. #endif
  98.  
  99. #ifndef MANX
  100.    Ctrl_C()             /* Control-C Trap routine for Lattice */
  101.    {
  102.       return(0);
  103.    }
  104. #endif
  105.  
  106.  
  107. /*
  108.  *  PacketWait()
  109.  *
  110.  *  This is the routine placed in the pr_PktWait field of the monitored
  111.  *  precess.  It is run asynchronously by the monitored process, and is
  112.  *  called whenever AmigaDOS does a taskwait().  PacketWait() waits for
  113.  *  a message to come in and then signals the monitoring task that one has
  114.  *  arrived.  It then attempts to obtain the semaphore, which will not be
  115.  *  released by the monitoring process until it is finished printing the 
  116.  *  contents of the packet.
  117.  */
  118.  
  119. struct Message *PacketWait()
  120. {
  121. #ifdef MANX
  122.    /*
  123.     *  if MANX, make sure we can see our data
  124.     */
  125.    geta4();
  126. #endif
  127.  
  128.    SetSignal(FALSE,DOS_MASK);
  129.  
  130.    while(!(theMessage = GetMsg(thePort)))  Wait(DOS_MASK);
  131.  
  132.    Signal(myProcess,WaitMask);
  133.    ObtainSemaphore(&CanReturn);
  134.    ReleaseSemaphore(&CanReturn);
  135.  
  136.    return(theMessage);
  137. } 
  138.  
  139.  
  140. /*
  141.  *  printBUF()
  142.  *
  143.  *  Prints a buffer to stdout.
  144.  */
  145.  
  146. void printBUF(buf,len)
  147. char *buf;
  148. int len;
  149. {
  150.    short i;
  151.    char outbuf[81];
  152.  
  153.    while (len > 0)
  154.    {
  155.       for (i=0; i<80 && len>0; i++,len--) outbuf[i] = *buf++;
  156.       outbuf[i] = '\0';
  157.       printf("%s",outbuf);
  158.    }
  159. }
  160.  
  161.  
  162. /*
  163.  *  PrintPkt()
  164.  *
  165.  *  For READ and WRITE packets to/from the CON: window, print the buffer
  166.  *  to stdout.  We recognize CON: packets because ARG1 is zero (this is
  167.  *  a real kludge, but it seems to work, except we get an extra ENDCLI 
  168.  *  if you run HARDCOPY, then EMACS, then spawn a new CLI, then type ENDCLI
  169.  *  to get back to EMACS.  Can't figure that one out).
  170.  */
  171.  
  172. void PrintPkt(pkt)
  173. struct DosPacket *pkt;
  174. {
  175.    switch(pkt->dp_Type)
  176.    {
  177.       case _ACTION_READ:
  178.          if (ARG1 == 0) printBUF(ARG2,RES1);
  179.          break;
  180.  
  181.       case _ACTION_WRITE:
  182.          if (ARG1 == 0) printBUF(ARG2,RES1);
  183.          break;
  184.  
  185.       default:      /* Ignore anything else */
  186.          break;
  187.    }
  188. }
  189.  
  190.  
  191. /*
  192.  *  GetFunction()
  193.  *
  194.  *  Check the command-line arguments to see that they are valid.
  195.  *  The legal possibilities are:
  196.  *
  197.  *      TO <filename>       To begin HARDCOPY to a file
  198.  *      END                 To end the HARDCOPY session
  199.  *      MONITOR <procID>    To begin menitoring the process pointed to by
  200.  *                          <procID>.
  201.  */
  202.  
  203. GetFunction(argc,argv)
  204. int argc;
  205. char *argv[];
  206. {
  207.    int function = SHOW_USAGE;
  208.  
  209.    if (argc == 3 && stricmp(argv[1],"TO") == 0)       function = START_HARDCOPY;
  210.    else if (argc == 3 && strcmp(argv[1],"MONITOR") == 0 &&
  211.            sscanf(argv[2],"%x",&ChosenProcess) == 1)  function = DO_MONITOR;
  212.    else if (argc == 2 && stricmp(argv[1],"END") == 0) function = END_HARDCOPY;
  213.    return(function);
  214. }
  215.  
  216.  
  217. /*
  218.  *  SetupSignal()
  219.  *
  220.  *  Allocate a signal to use for our inter-task communication, and
  221.  *  set up the mask for using it.
  222.  */
  223.  
  224. void SetupSignal(theSignal)
  225. LONG *theSignal;
  226. {
  227.    *theSignal = AllocSignal(-ONE);
  228.    if (*theSignal == -ONE)
  229.    {
  230.       printf("Can't Allocate a Task Signal.\n");
  231.       exit(10);
  232.    }
  233.    WaitMask = (ONE << (*theSignal));
  234. }
  235.  
  236.  
  237. /*
  238.  *  SetupProcess()
  239.  *
  240.  *  Copy the process' name, and get its Message port.  Set our priority
  241.  *  higher than the monitored process so we will be able to react to its
  242.  *  signals, then set the pr_PktWait field to our PacketWiat() routine so
  243.  *  that we will be signalled when it receives a packet (save the old 
  244.  *  pr_PktWait so we can put it back when we're through).  Set the tc_UserData
  245.  *  field of the monitored processes Task structure to point to us, so that
  246.  *  the monitored process can signal us when it wants us to stop hardcopying.
  247.  *  Finally, send a signal to the monitored process to show that we are ready
  248.  *  to monitor it.
  249.  */
  250.  
  251. void SetupProcess(theProcess,name)
  252. struct Process *theProcess;
  253. char *name;
  254. {
  255.    strcpy(name,theProcess->pr_Task.tc_Node.ln_Name);
  256.    thePort = &theProcess->pr_MsgPort;
  257.  
  258.    Forbid();
  259.    SetTaskPri(myProcess,(ULONG)(theProcess->pr_Task.tc_Node.ln_Pri + 1)); 
  260.    OldPktWait = theProcess->pr_PktWait;
  261.    theProcess->pr_PktWait = (APTR) PWait;
  262.    OldUserData = PTR(Task,theProcess)->tc_UserData;
  263.    PTR(Task,theProcess)->tc_UserData = (APTR) myProcess;
  264.    Permit();
  265.    Signal(theProcess,SIGBREAKF_CTRL_C);
  266. }
  267.  
  268.  
  269. /*
  270.  *  MonitorProcess()
  271.  *
  272.  *  Wait for the monitored process to receive a message (our PacketWait()
  273.  *  function signals us via theSignal when it has received a message), then
  274.  *  print out the contents of the message.  A semaphore is used to coordinate
  275.  *  this routine with the PacketWait() routine (which is run asynchonously
  276.  *  by the monitored process).  Phillip Lindsay says "there are probably a
  277.  *  hundred better was of doing this.  I just went with the first one [that]
  278.  *  came to mind."  I couldn't think of a better one, so I still use it.
  279.  *  Since our process is running at a higher priority than the monitored one,
  280.  *  we should obtain the semaphore first.  The other process will block until
  281.  *  we release it (when we are done printing the contents).
  282.  */
  283.  
  284. void MonitorProcess(name,theSignal)
  285. char *name;
  286. ULONG theSignal;
  287. {
  288.    ULONG signals;
  289.    struct DosPacket *thePacket;
  290.  
  291.    do 
  292.    {
  293.       signals = Wait(SIGBREAKF_CTRL_C | WaitMask); 
  294.       ObtainSemaphore(&CanReturn); 
  295.       if (signals & WaitMask)
  296.       {
  297.          /*
  298.           *  PacketWait() signalled us so print the message it put in
  299.           *  theMessage.
  300.           */
  301.          thePacket = PTR(DosPacket,theMessage->mn_Node.ln_Name);
  302.          PrintPkt(thePacket);
  303.       }
  304.       ReleaseSemaphore(&CanReturn);
  305.    } while(!(signals & SIGBREAKF_CTRL_C)); 
  306. }
  307.  
  308.  
  309. /*
  310.  *  ClenUpProcess()
  311.  *
  312.  *  Put everything back the way we found it, except that the monitored process
  313.  *  is still running our code...
  314.  */
  315.  
  316. void CleanUpProcess(theProcess)
  317. struct Process *theProcess;
  318. {
  319.    Forbid();
  320.    theProcess->pr_PktWait = OldPktWait;
  321.    PTR(Task,theProcess)->tc_UserData = OldUserData;
  322.    Permit();
  323.    SetTaskPri(myProcess,0L);
  324. }
  325.  
  326.  
  327. /*
  328.  *  DoMonitor()
  329.  *
  330.  *  Get a signal for our PacketWait code to use to signal us when a packet is
  331.  *  ready for us to look at.  Get a semaphore so that we can make the 
  332.  *  PacketWait() routine wait for us to finish with the packet before it
  333.  *  returns the message to the monitored process.  Set up the process so 
  334.  *  that it includes our PacketWait() code.
  335.  *
  336.  *  Monitor the packet traffic, and print the I/O to the monitored CLI.
  337.  *  We wait for a signal from the PacketWait() routine, or for a 
  338.  *  CTRL-C.
  339.  *
  340.  *  When we get a CTRL-C, we are done monitoring, so we remove our
  341.  *  PacketWait() code, but the monitored process may still be in our 
  342.  *  waiting code, so we wait for a CTRL-E to verify that we are free to
  343.  *  die (and remove the PacketWait code from memory).
  344.  */
  345.  
  346. void DoMonitor()
  347. {
  348.    LONG TaskSignal;
  349.    UBYTE ProcessName[81];
  350.    
  351.    myProcess = FindTask(NULL);
  352.    if (ChosenProcess != NULL)
  353.    {
  354.       #ifndef MANX
  355.          onbreak(&Ctrl_C);    /* Turn off CTRL-C for Lattice:  we do our own */
  356.       #endif
  357.  
  358.       SetupSignal(&TaskSignal);
  359.       InitSemaphore(&CanReturn);
  360.       SetupProcess(ChosenProcess,ProcessName);
  361.    
  362.       MonitorProcess(ProcessName,TaskSignal);
  363.       
  364.       CleanUpProcess(ChosenProcess);
  365.       Wait(SIGBREAKF_CTRL_E);
  366.       FreeSignal(TaskSignal);
  367.    }
  368. }
  369.  
  370.  
  371. /*
  372.  *  StartHardCopy()
  373.  *
  374.  *  Creates the process that monitors the current process via a call to
  375.  *  Execute().  We execute a RUN command that runs HARDCOPY MONITOR and
  376.  *  passes a pointer to the current process as a parameter.  When HARDCOPY
  377.  *  starts as the remote process, it looks up this parameter and monitors
  378.  *  that process.  The output for HARDCOPY is re-directed to the file
  379.  *  that the user specified in the initial call to HARDCOPY.
  380.  *
  381.  *  The spawned process will signal us with a CTRL-C when it is set up, 
  382.  *  so wait for that signal.  Finally, print out a message; this will
  383.  *  appear as the first thing in the output file.
  384.  */
  385.  
  386. void StartHardCopy(file)
  387. char *file;
  388. {
  389.    char cmd[200],time[19];
  390.    #define COMMAND "RUN <NIL: >NIL: HARDCOPY <NIL: >\"%s\" MONITOR 0x%X"
  391.  
  392.    sprintf(cmd,COMMAND,file,FindTask(NULL));
  393.    if (!Execute(cmd,NULL,NULL))
  394.    {
  395.       printf("Can't create HARDCOPY process\n");
  396.     } else {
  397.       #ifndef MANX
  398.          onbreak(&Ctrl_C);  /* Turn off CTRL-C for Lattice:  we do our own */
  399.       #endif
  400.       printf("Waiting for HARDCOPY monitor to start ...\n");
  401.       printf("[Press CTRL-E if any errors are reported]\n");
  402.       if (Wait(SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_E) == SIGBREAKF_CTRL_E)
  403.       {
  404.          printf("\nUser signalled abort!\n\n");
  405.          printf("To remove an unwanted HARDCOPY monitor process, first try\n");
  406.          printf("giving the command HARDCOPY END.  If that doesn't work,\n");
  407.          printf("use STATUS to identify the process, and then use the BREAK\n");
  408.          printf("command to send a CTRL-C and then a CTRL-E to the HARDCOPY\n");
  409.          printf("monitor process.\n\n");
  410.       } else {
  411.          GetDateTime(time);
  412.          printf("\nHARDCOPY v1.0 recorded on %s to file \"%s\"\n",
  413.             time,file);
  414.          printf("To end the HARDCOPY session and close the file, ");
  415.          printf("type HARDCOPY END\n\n");
  416.       }
  417.    }
  418. }
  419.  
  420.  
  421. /*
  422.  *  EndHardCopy()
  423.  *
  424.  *  Sends a CTRL-C and a CTRL-E to the monitoring HARDCOPY process, which 
  425.  *  tell it to de-install the PacketWait() routine, and then die.  The
  426.  *  monitoring process has stored its address in the UserData field of
  427.  *  our process' Task structure, so we know were to send the signals.
  428.  */
  429.  
  430. void EndHardCopy()
  431. {
  432.    struct Process *MonitoringProcess;
  433.  
  434.    myProcess = FindTask(NULL);
  435.    MonitoringProcess = PTR(Process,PTR(Task,myProcess)->tc_UserData);
  436.    if (MonitoringProcess == NULL)
  437.    {
  438.       printf("No HARDCOPY process in progress\n");
  439.    } else {
  440.       Signal(MonitoringProcess,SIGBREAKF_CTRL_C);
  441.       printf("HARDCOPY output complete.\n");
  442.       Signal(MonitoringProcess,SIGBREAKF_CTRL_E);
  443.    }
  444. }
  445.  
  446. void main(argc,argv)
  447. int argc;
  448. char *argv[];
  449. {
  450.    ChosenProcess = NULL;
  451.    switch(GetFunction(argc,argv))
  452.    {
  453.       case SHOW_USAGE:
  454.          printf("Usage:  HARDCOPY TO <file>\n");
  455.          printf("   or:  HARDCOPY END\n");
  456.          break;
  457.  
  458.       case START_HARDCOPY:
  459.          StartHardCopy(argv[2]);
  460.          break;
  461.  
  462.       case DO_MONITOR:
  463.          DoMonitor();
  464.          break;
  465.  
  466.       case END_HARDCOPY:
  467.          EndHardCopy();
  468.          break;
  469.    }
  470. }
  471.  
  472.  
  473. /*
  474.  *  GetStrTime(time,date)
  475.  *
  476.  *  translates the DateStamp stored in "date" into a character string and 
  477.  *  copies it into the character string pointed to by "time", which should be 
  478.  *  at least 19 characters long.  GetStrTime properly accounts for leap years
  479.  *  every four years.  Every four centuries, however, a leap day is supposed
  480.  *  to be skipped.  AmigaDOS does not correctly interpret these non-leap
  481.  *  centuries, hence neither does GetStrTime.  In the event that AmigaDOS is 
  482.  *  ever corrected to fix this bug, you can remove the comment delimiters from
  483.  *  the line in GetStrTime that implements non-leap centuries.  Unfortunately,
  484.  *  the year 2000 is a non-leap century, hence this bug may actually
  485.  *  come into play (if anyone still has Amigas in 14 years).
  486.  */
  487.  
  488. static int
  489.    DaysIn[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
  490.  
  491. static char
  492.    *NameOf[] = {"", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  493.                     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  494.  
  495. #define CENTURY             (100 YEARS + 25 LEAPDAYS)
  496. #define FOURCENTURIES       (400 YEARS + 99 LEAPDAYS)
  497. #define FOURYEARS           (4 YEARS + 1 LEAPDAY)
  498. #define LEAPYEAR            (1 YEARS + 1 LEAPDAY)
  499. #define LEAPDAYS
  500. #define LEAPDAY
  501. #define YEARS               * 365
  502. #define YEAR                365
  503. #define FEBDAYS             59          /* days until the end of February */
  504.  
  505. void GetStrTime(time,date)
  506. char time[19];             /* storage area for the return value */
  507. struct DateStamp *date;    /* the DateStamp to convert */
  508. {
  509.    int year,month,day,hour,minute,second;
  510.  
  511.    day = date->ds_Days + 78 YEARS + 20 LEAPDAYS;
  512. /* day += (day - FEBDAYS - CENTURY + FOURCENTURIES) / FOURCENTURIES; */
  513.    year = 4 * (day/FOURYEARS) + 1900;
  514.    day %= FOURYEARS;
  515.    day += (day - FEBDAYS - 1 LEAPDAY) / YEAR;
  516.    year += day / LEAPYEAR;
  517.    day %= LEAPYEAR;
  518.  
  519.    for (month=1; day >= DaysIn[month]; month++);
  520.    day = day - DaysIn[month-1] + 1;
  521.  
  522.    hour   = date->ds_Minute / 60;
  523.    minute = date->ds_Minute - hour*60;
  524.    second = date->ds_Tick / TICKS_PER_SECOND;
  525.  
  526.    sprintf(time,"%02d-%3s-%02d %02d:%02d:%02d",
  527.       day,NameOf[month],(year % 100),hour,minute,second);
  528. }
  529.  
  530.  
  531. /*
  532.  *  GetDateTime(str)
  533.  *
  534.  *  Uses GetStrTime() to get the current date and time as a string.
  535.  *  "str" must be at least 19 characters long.  See GetStrTime for
  536.  *  more information.
  537.  */
  538.  
  539. void GetDateTime(str)
  540. char *str;
  541. {
  542.    struct DateStamp date;
  543.  
  544.    DateStamp(&date);
  545.    GetStrTime(str,&date);
  546. }
  547.  
  548.  
  549. /*
  550.  *  This code stub has been known to save lives... 
  551.  */
  552.  
  553. #if MANX        
  554. #asm
  555.         XREF _PacketWait
  556.  
  557.         XDEF _PWait
  558. _PWait:
  559.         movem.l a2/a3/a4,-(sp)
  560.         jsr _PacketWait
  561.         movem.l (sp)+,a2/a3/a4
  562.         rts
  563. #endasm
  564. #endif
  565.