home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Fax / AVMA&GPFax-V1,33Sources.LHA / generic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-19  |  9.1 KB  |  378 lines
  1. #include <fcntl.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <clib/exec_protos.h>
  5. #include <clib/dos_protos.h>
  6. #include <stdlib.h>
  7. #include <time.h>
  8.  
  9.  
  10. #include "serial_proto.h"
  11. #include "timer_proto.h"
  12. #include "callback_proto.h"
  13. #include "debug_proto.h"
  14. #include "simplerexx.h"
  15.  
  16. char lastError[128];
  17.  
  18. char serialName[100];
  19. int unitNumber;
  20. int globalAborted = 0;
  21.  
  22. extern char portNameToLoad[];
  23. char arexxPortName[41];
  24.  
  25. extern AREXXCONTEXT OutgoingRexx;
  26.  
  27. extern struct CallBack initCallBack;
  28.  
  29. struct CallBack globalCallBack;
  30.  
  31. #define serialRecBufLen 1024
  32.  
  33. extern struct SerialData *sld;
  34. extern struct timerequest* tr;
  35. extern struct timerequest* tr2;
  36.  
  37. char* serialError(int e) {
  38.   switch (e) {
  39.   case 1 : return "Device busy";
  40.   case 2 : return "Baud mismatch";
  41.   case 4 : return "Couldn't allocate buffer";
  42.   case 5 : return "Invalid parameter";
  43.   case 6 : return "Line error";
  44.   case 9 : return "Parity error";
  45.   case 11 : return "Timer error";
  46.   case 12 : return "Buffer overflow";
  47.   case 13 : return "No DSR";
  48.   case 15 : return "Break detected";
  49.   default: return "Unknown";
  50.   }
  51. }
  52.  
  53. enum ReturnStatus waitForCharactersOrTimeout(char* buf, int max, int* actual, int time, struct CallBack* cb);
  54.  
  55. enum ReturnStatus waitForCharacters(char* buf, int max, int* actual, struct CallBack* cb);
  56.  
  57. enum ReturnStatus timerCallBack(void) {
  58.   return TimedOut;
  59. }
  60.  
  61. /* PRIVATE */
  62. /* Internal buffer for our readChar() function to speed up access */
  63. __far static char internalBuffer[serialRecBufLen];
  64. static int readPosition = 0;
  65. static int readCount = 0;
  66.  
  67. void flushBuffers() {
  68.   ClearSer(sld); /* serial buffer flush */
  69.   readPosition = readCount = 0; /* internal buffer flush */
  70. }
  71.  
  72. extern int faxHardwareHandshaking;
  73.  
  74. void setReceiveSerialParms(void) {
  75.   if (!faxHardwareHandshaking) {
  76.     ChangeData(sld, 19200, 8, 1, (ULONG) SERF_SHARED | SERF_XDISABLED, serialRecBufLen);
  77.   }
  78. }
  79.  
  80. void setSendSerialParms(void) {
  81.   if (!faxHardwareHandshaking) {
  82.     setSerialParms(19200);
  83.   }
  84. }
  85.  
  86. enum ReturnStatus setSerialParms(int speed) {
  87.   char temp[32];
  88.   if (faxHardwareHandshaking) {
  89.     if (ChangeData(sld,speed,8,1, (ULONG)SERF_SHARED | SERF_XDISABLED | SERF_7WIRE, serialRecBufLen)) {
  90.       /* 7wire handshaking during playback */
  91.       debugString("Couldn't change serial parameters", "setSerialParms");
  92.       mainError(lastError);
  93.       return Error;
  94.     }
  95.     sprintf(temp, "Serial: %d, 7 wire", speed);
  96.   } else {
  97.     if (ChangeData(sld,speed,8,1, (ULONG)SERF_SHARED, serialRecBufLen)) {
  98.       /* xon/xoff */
  99.       debugString("Couldn't change serial parameters", "setSerialParms");
  100.       return Error;
  101.     }
  102.     sprintf(temp, "Serial: %d, xon/xoff", speed);
  103.   }
  104.   mainError(temp);
  105.   return Normal;
  106. }
  107.  
  108. int writeToSerial(char* s, int len) {
  109.   WriteSer(sld, s, len);
  110.   return len;
  111. }
  112.  
  113. /* Promises to tell us if there's something to process */
  114. int hasChar(void) {
  115.   if (readPosition < readCount) return 1;
  116.   if (SerBuffer(sld)) return 1;
  117.   return 0;
  118. }
  119.  
  120. /* WARNING:  this is only safe if you did a readChar() AND you got a character !!! */
  121. void unReadChar(void) {
  122.   readPosition--;
  123. }
  124.  
  125. /* timeout is in tenths of a second, unlike in voice.c! */
  126. enum ReturnStatus readChar(char* c, int timeout, struct CallBack* cb) {
  127.   /* This is a buffered 1 character read function to make access to the
  128.      serial port slightly more efficient */
  129.   enum ReturnStatus status;
  130.  
  131.   if (readPosition < readCount) {
  132.     /* There's still something to read from our internal buffer */
  133.     *c = internalBuffer[readPosition];
  134.     readPosition++;
  135.     return Normal;
  136.   }
  137.  
  138.   if (timeout < 1) {
  139.     return TimedOut;
  140.   }
  141.  
  142.   readPosition = 0;
  143.   status = waitForCharactersOrTimeout(internalBuffer, sizeof(internalBuffer), &readCount,
  144.                  timeout, cb);
  145.   if (status != Normal) return status;
  146.  
  147.   *c = internalBuffer[readPosition];
  148.   readPosition++;
  149.  
  150.   return Normal;
  151. }
  152.  
  153. /* this builds on a simpler waitForCharacters function using callbacks */
  154. /* time is in tenths of a second! */
  155. enum ReturnStatus waitForCharactersOrTimeout(char* buf, int max, int* actual, int time, struct CallBack* cb) {
  156.   enum ReturnStatus status;
  157.   ULONG timerSignal = TimerSignal(tr2);
  158.  
  159.   addCallBack(cb, timerSignal, timerCallBack); /* register the timersignal as something
  160.                           that can "break" the function we're
  161.                           about to call */
  162.   
  163.   /* start our timer */
  164.   StartTimer(tr2, time / 10, (time % 10) * 100000);
  165.  
  166.   status = waitForCharacters(buf, max, actual, cb);
  167.  
  168.   /* clean up our timer */
  169.   EndTimer(tr2);
  170.  
  171.   deleteCallBack(cb); /* kill off the callback we added */
  172.  
  173.   return status;
  174. }
  175.  
  176. enum ReturnStatus waitForCharacters(char* buf, int max, int* actual, struct CallBack* cb) {
  177.   ULONG mask, signals;
  178.   int numCharacters;
  179.   int error;
  180.  
  181.   enum ReturnStatus status = Normal;
  182.  
  183.   ULONG serialSignal = SerialSignal(sld);
  184.   ULONG externalSignals = callBackSignals(cb);
  185.  
  186.   mask = externalSignals | serialSignal;
  187.  
  188.  
  189.   RecvSer(sld, buf, 1); /* start a serial request for 1 character */
  190.  
  191.   while (1) {
  192.     signals = Wait(mask); /* start waiting */
  193.  
  194.     if (signals & serialSignal) {
  195.       /* the wait was broken because of some serial data in the serial port */
  196.       error = WaitSer(sld); /* performs a getmessage and stuff to end an io operation neatly */
  197.       if (error) {
  198.     sprintf(lastError, "EFax: serial port: %s", serialError(error));
  199.     mainError(lastError);
  200.     buf[0] = 'Q';
  201.     *actual = 1;
  202.     return Normal;
  203.       }
  204.  
  205.       numCharacters = SerBuffer(sld);
  206.  
  207. #ifdef DELAYWANTED
  208.       if (!(numCharacters > (serialRecBufLen / 2))) {
  209.     Delay(5); /* give the modem some time to send stuff to the serial
  210.              port */
  211.  
  212.     /* now we want to get as many characters as possible without overflowing
  213.        the buffer */
  214.     numCharacters = SerBuffer(sld);
  215.       }
  216. #endif
  217.  
  218.       if (numCharacters > max - 1) numCharacters = max - 1;
  219.       
  220.       if (numCharacters > 0) {
  221.     long actualNumCharacters = 0;
  222.     error = ReadSer(sld, &buf[1], numCharacters, &actualNumCharacters);
  223.     if (error) {
  224.       sprintf(lastError, "EFax: Serial Port: %s req=%d,actual=%d,rem=%d", serialError(error), numCharacters, actualNumCharacters, SerBuffer(sld));
  225.       mainError(lastError);
  226.     }
  227.     if (actualNumCharacters > numCharacters) {
  228.       mainError("actualNumCharacters > numCharacters!  Bug!");
  229.     } else {
  230.       numCharacters = actualNumCharacters;
  231.     }
  232.       }
  233.       *actual = numCharacters + 1;
  234.       return Normal;
  235.     } else {
  236.       /* it wasn't the serial port that sent us a signal */
  237.       status = processCallBack(cb, signals);
  238.       /* if one of the callback things says we should get out, let's get out! */
  239.       if (status != Normal) {
  240.     AbortSer(sld);
  241.     WaitWaitSer(sld);
  242.     *actual = 0;
  243.     return status;
  244.       }
  245.     }
  246.   }
  247.  
  248.   strcpy(lastError, "FATAL ERROR");
  249.   return Error;
  250. }
  251.  
  252. enum ReturnStatus waitForTimeout(int seconds, int microseconds, struct CallBack* cb) {
  253.   enum ReturnStatus status = Normal;
  254.   ULONG timerSignal = TimerSignal(tr2);
  255.   ULONG signals;
  256.  
  257.   addCallBack(cb, timerSignal, timerCallBack); /* register the timersignal as something
  258.                           that can "break" the function we're
  259.                           about to call */
  260.   
  261.   /* start our timer */
  262.   StartTimer(tr2, seconds, microseconds);
  263.  
  264.   while (status == Normal) {
  265.     signals = Wait(callBackSignals(cb));
  266.     status = processCallBack(cb, signals);
  267.   }
  268.  
  269.   /* clean up our timer */
  270.   EndTimer(tr2);
  271.  
  272.   deleteCallBack(cb); /* kill off the callback we added */
  273.  
  274.   return status;
  275. }
  276.  
  277. void releaseResources(void) {
  278.   if (sld) {
  279.     CloseSerial(sld);
  280.   }
  281.   if (tr) DeleteTimer(tr);
  282.   if (tr2) DeleteTimer(tr2);
  283.   FreeARexx(OutgoingRexx);
  284.  
  285.   deleteCallBack(&globalCallBack);
  286. }
  287.  
  288. int processAbortArexxMessage(void) {
  289.   int retVal = 0;
  290.   /* arexx stuff */
  291.   char* argument;
  292.  
  293.   char command[100];
  294.  
  295.   char* error = 0;
  296.   char* result = 0;
  297.   long errorLevel = 0;
  298.   
  299.   struct RexxMsg* rmsg;
  300.  
  301.   while (rmsg = GetARexxMsg(OutgoingRexx)) {
  302.     if (rmsg == REXX_RETURN_ERROR) {
  303.       continue;
  304.     }
  305.  
  306.     error = 0;
  307.     result = 0;
  308.     errorLevel = 0;
  309.     
  310.     /* parse the message we were passed */
  311.     argument = stptok(ARG0(rmsg), command, 100, " ,");
  312.     if (*argument) argument++;
  313.     strupr(command);
  314.  
  315.     if (stricmp("ABORT", command) == 0) {
  316.       retVal = 1;
  317.     } else {
  318.       errorLevel = 20;
  319.       error = "EFax is working";
  320.     }
  321.     
  322.     if (error) {
  323.       SetARexxLastError(OutgoingRexx,rmsg,error);
  324.     }
  325.     ReplyARexxMsg(OutgoingRexx,rmsg,result,errorLevel);
  326.   }
  327.  
  328.   return retVal;
  329. }
  330.  
  331. enum ReturnStatus signalDetectedCallBack(void) {
  332.   int aborted = processAbortArexxMessage();
  333.  
  334.   if (aborted) {
  335.     globalAborted = 1;
  336.     return TimedOut;
  337.   } else {
  338.     return Normal;
  339.   }
  340. }
  341.  
  342. void allocateResources(void) {
  343.   tr = PrepareTimer();
  344.   if (!tr) {
  345.     mainError("Cannot open timer");
  346.     exit(5);
  347.   }
  348.   tr2 = PrepareTimer();
  349.   if (!tr2) {
  350.     mainError("Cannot open timer");
  351.     exit(5);
  352.   }
  353.  
  354.   sld = OpenSerial(serialName, unitNumber, SERF_SHARED);
  355.   if (!sld) {
  356.     mainError("Serial port could not be opened!");
  357.     exit(5);
  358.   }
  359.  
  360.   /* set initial serial parameters */
  361.   if (setSerialParms(19200) != Normal) {
  362.     mainError("Couldn't set required serial parameters");
  363.     exit(5);
  364.   }
  365.  
  366.   sprintf(arexxPortName, "%sF", portNameToLoad);
  367.  
  368.   OutgoingRexx = InitARexxSingleApp(arexxPortName, "avm");
  369.   if (!OutgoingRexx) {
  370.     mainError("Couldn't open outgoing rexx port");
  371.     exit(5);
  372.   }
  373.  
  374.   globalCallBack = initCallBack;
  375.   addCallBack(&globalCallBack, ARexxSignal(OutgoingRexx), signalDetectedCallBack);
  376. }
  377.  
  378.