home *** CD-ROM | disk | FTP | other *** search
/ D!Zone (Collector's Edition) / D_ZONE_CD.ISO / programs / editors / ser4_src / sersetup.c < prev    next >
C/C++ Source or Header  |  1994-12-06  |  24KB  |  1,152 lines
  1. // sersetup.c
  2.  
  3. #include "sersetup.h"
  4. #include "DoomNet.h"
  5. #include <time.h>
  6.  
  7. extern    que_t        inque, outque;
  8.  
  9. void jump_start( void );
  10. void GetUart (void);
  11. extern int     uart;
  12.  
  13. int            usemodem;
  14.  
  15.  
  16. void ModemCommand (char *str);
  17. int ModemResponse (char *resp);
  18. void configure (void);
  19. void reset_counters (void);
  20.  
  21. time_t starttime = 0;
  22. time_t endtime = 0;
  23. time_t playtime = 0;
  24.  
  25. char init1 [256+1];
  26. char init2 [256+1];
  27. char hangup [256+1];
  28. char config [256+1];
  29. char devparm [256+1];
  30. unsigned long baud = 9600;
  31. char dial [256+1];
  32. int comport = 1;
  33. int irq = -1;
  34. int uart = -1;
  35. int vector = -1;
  36. int loadgame = -1;
  37. int episode = -1;
  38. int map = -1;
  39. int skill = -1;
  40. int deathmatch = 0;
  41. int pulsedial = 0;
  42. int player = 0;
  43. int nomonsters = 0;
  44. int respawn = 0;
  45.  
  46. /* showReadStats() counters. */
  47. unsigned long writeBufferOverruns       = 0;
  48. unsigned long bytesRead                 = 0;
  49. unsigned long packetsRead               = 0;
  50. unsigned long largestReadPacket         = 0;
  51. unsigned long smallestReadPacket        = 0xFFFFFFFFl;
  52. unsigned long readBufferOverruns        = 0;
  53. unsigned long totalReadPacketBytes      = 0;
  54. unsigned long oversizeReadPackets       = 0;
  55. unsigned long largestOversizeReadPacket = 0;
  56. unsigned long overReadPacketLen         = 0;
  57.  
  58. /* showWriteStats() counters. */
  59. unsigned long bytesWritten               = 0;
  60. unsigned long packetsWrite               = 0;
  61. unsigned long largestWritePacket         = 0;
  62. unsigned long smallestWritePacket        = 0xFFFFFFFFl;
  63. unsigned long totalWritePacketBytes      = 0;
  64. unsigned long oversizeWritePackets       = 0;
  65. unsigned long largestOversizeWritePacket = 0;
  66.  
  67. /* showUartErrors() counters. */
  68. unsigned long numBreak          = 0;
  69. unsigned long numFramingError   = 0;
  70. unsigned long numParityError    = 0;
  71. unsigned long numOverrunError   = 0;
  72. unsigned long numTxInterrupts   = 0;
  73. unsigned long numRxInterrupts   = 0;
  74.  
  75.  
  76. void showReadStats()
  77. {
  78.     if ( smallestReadPacket == 0xFFFFFFFFl )
  79.         smallestReadPacket = 0;
  80.  
  81.     printf ("Read statistics:\n");
  82.  
  83.     printf ("%9lu Largest packet      %9lu Smallest packet\n",
  84.                 largestReadPacket, smallestReadPacket);
  85.  
  86.     printf ("%9lu Oversize packets    %9lu Largest oversize packet\n",
  87.                 oversizeReadPackets, largestOversizeReadPacket);
  88.  
  89.     printf ("%9lu Total packets       %9lu Buffer overruns\n",
  90.                 packetsRead, readBufferOverruns);
  91.  
  92.     printf ("%9lu Total bytes         %9.1f Average bytes/minute\n",
  93.                 totalReadPacketBytes,
  94.                 starttime == 0 || playtime == 0 ? 0 :
  95.                     (float) totalReadPacketBytes / (float) ((float) playtime / 60));
  96.  
  97.     printf ("%9lu Receive interrupts  %9.1f Average bytes/interrupt\n",
  98.         numRxInterrupts,
  99.         numRxInterrupts == 0 ? 0 :
  100.             (float) totalReadPacketBytes / (float) numRxInterrupts);
  101.  
  102.     printf ("\n");
  103. }
  104.  
  105.  
  106.  
  107. void showWriteStats()
  108. {
  109.     if ( smallestWritePacket == 0xFFFFFFFFl )
  110.         smallestWritePacket = 0;
  111.  
  112.     printf ("Write statistics:\n");
  113.  
  114.     printf ("%9lu Largest packet      %9lu Smallest packet\n",
  115.                 largestWritePacket, smallestWritePacket);
  116.  
  117.     printf ("%9lu Oversize packets    %9lu Largest oversize packet\n",
  118.                 oversizeWritePackets, largestOversizeWritePacket);
  119.  
  120.     printf ("%9lu Total packets       %9lu Buffer overruns\n",
  121.                 packetsWrite, writeBufferOverruns);
  122.  
  123.     printf ("%9lu Total bytes         %9.1f Average bytes/minute\n",
  124.                 totalWritePacketBytes,
  125.                 starttime == 0 || playtime == 0 ? 0 :
  126.                     (float) totalWritePacketBytes / (float) ((float) playtime / 60));
  127.  
  128.     printf ("%9lu Transmit interrupts %9.1f Average bytes/interrupt\n",
  129.         numTxInterrupts,
  130.         numTxInterrupts == 0 ? 0 :
  131.             (float) totalWritePacketBytes / (float) numTxInterrupts);
  132.  
  133.     printf ("\n");
  134. }
  135.  
  136. void showUartErrors()
  137. {
  138.     puts ("UART line status");
  139.  
  140.     printf ("%9lu Breaks detected     %9lu Framing errors\n",
  141.         numBreak, numFramingError);
  142.     printf ("%9lu Parity errors       %9lu Overrun errors\n",
  143.         numParityError, numOverrunError);
  144. }
  145.  
  146. /*
  147. ================
  148. =
  149. = write_buffer
  150. =
  151. ================
  152. */
  153.  
  154. void write_buffer( char *buffer, unsigned int count )
  155. {
  156. // if this would overrun the buffer, throw everything else out
  157.     if (outque.size + count > QUESIZE)
  158.     {
  159.         ++writeBufferOverruns;
  160.         outque.tail = outque.head;
  161.         outque.size = 0;
  162.     }
  163.  
  164.    write_bytes (buffer, count);
  165.  
  166.     if ( INPUT( uart + LINE_STATUS_REGISTER ) & 0x40)
  167.         jump_start();
  168. }
  169.  
  170.  
  171. void hangup_modem (void)
  172. {
  173.     printf ("\n");
  174.     printf ("\nDropping DTR\n");
  175.     OUTPUT( uart + MODEM_CONTROL_REGISTER
  176.         , INPUT( uart + MODEM_CONTROL_REGISTER ) & ~MCR_DTR );
  177.     delay (1250);
  178.     OUTPUT( uart + MODEM_CONTROL_REGISTER
  179.         , INPUT( uart + MODEM_CONTROL_REGISTER ) | MCR_DTR );
  180.     ModemCommand("+++");
  181.     delay (1250);
  182.     if (hangup [0] != EOS)
  183.         ModemCommand(hangup);
  184.     else
  185.     {
  186.         printf ("Warning: No HANGUP= string in MODEM.CFG file. Using default.\n");
  187.         ModemCommand("ATH0");
  188.     }
  189.     delay (1250);
  190.     while (read_byte () != -1)
  191.     ;
  192. }
  193.  
  194.  
  195. /*
  196. =================
  197. =
  198. = Error
  199. =
  200. = For abnormal program terminations
  201. =
  202. =================
  203. */
  204.  
  205. void Error (char *error, ...)
  206. {
  207.     va_list argptr;
  208.  
  209.     if (usemodem)
  210.         hangup_modem ();
  211.  
  212.     ShutdownPort ();
  213.  
  214.     if (vectorishooked)
  215.         setvect (doomcom.intnum,olddoomvect);
  216.  
  217.     if (error)
  218.     {
  219.         va_start (argptr,error);
  220.         vprintf (error,argptr);
  221.         va_end (argptr);
  222.         printf ("\n\n");
  223.     //    exit (1);
  224.     }
  225.  
  226.     //    printf ("Clean exit from SERSETUP\n");
  227.  
  228.     exit (error != (char *) NULL);
  229. }
  230.  
  231.  
  232. /*
  233. ================
  234. =
  235. = ReadPacket
  236. =
  237. ================
  238. */
  239.  
  240. #define MAXPACKET    512
  241. #define    FRAMECHAR    0x70
  242.  
  243. char    packet[MAXPACKET];
  244. int        packetlen;
  245. int        inescape;
  246. int        newpacket;
  247.  
  248. boolean ReadPacket (void)
  249. {
  250.     int    c;
  251.  
  252. // if the buffer has overflowed, throw everything out
  253.  
  254.     if (inque.size > QUESIZE - 4)    // check for buffer overflow
  255.     {
  256.         ++readBufferOverruns;           /* Count read overruns */
  257.         inque.tail = inque.head;
  258.         inque.size = 0;
  259.         newpacket = true;
  260.         return false;
  261.     }
  262.  
  263.     if (newpacket)
  264.     {
  265.         packetlen = 0;
  266.         newpacket = 0;
  267.         overReadPacketLen = 0;
  268.     }
  269.  
  270.     do
  271.     {
  272.         if ((c = read_byte ()) < 0)
  273.             return false;      // haven't read a complete packet
  274.         if (inescape)
  275.         {
  276.             inescape = false;
  277.             if (c!=FRAMECHAR)
  278.             {
  279.                 newpacket = 1;
  280.  
  281.                 ++packetsRead;  /* Count packets read */
  282.  
  283.                 if ( packetlen > largestReadPacket ) /* Track largest packet */
  284.                     largestReadPacket = packetlen;
  285.  
  286.                 if ( packetlen < smallestReadPacket ) /* Track smallest packet */
  287.                     smallestReadPacket = packetlen;
  288.  
  289.                 totalReadPacketBytes += packetlen;    /* Count total packet bytes */
  290.  
  291.                 return true;    // got a good packet
  292.             }
  293.         }
  294.         else if (c==FRAMECHAR)
  295.         {
  296.             inescape = true;
  297.             continue;            // don't know yet if it is a terminator
  298.         }                        // or a literal FRAMECHAR
  299.  
  300.         if (packetlen >= MAXPACKET)
  301.         {
  302.             ++overReadPacketLen;            /* Keep track of size of oversize packet */
  303.             oversizeReadPackets++;        /* Count oversize packets */
  304.  
  305.             if ( overReadPacketLen > largestOversizeReadPacket )
  306.                 largestOversizeReadPacket = overReadPacketLen;
  307.  
  308.             continue;            // oversize packet
  309.         }
  310.  
  311.         packet[packetlen] = c;
  312.         packetlen++;
  313.     } while (1);
  314.  
  315. }
  316.  
  317.  
  318. /*
  319. =============
  320. =
  321. = WritePacket
  322. =
  323. =============
  324. */
  325.  
  326.  
  327.  
  328. void WritePacket (char *buffer, int len)
  329. {
  330.     int        b;
  331.     char    static localbuffer[MAXPACKET*2+2];
  332.  
  333.     b = 0;
  334.     if (len > MAXPACKET)
  335.     {
  336.         ++oversizeWritePackets;         /* Count oversize write packets */
  337.         if ( len > largestOversizeWritePacket )
  338.             ++largestOversizeWritePacket;
  339.  
  340.         return;
  341.     }
  342.  
  343.     if ( len > largestWritePacket )
  344.         largestWritePacket = len;
  345.  
  346.     if ( len < smallestWritePacket )
  347.         smallestWritePacket = len;
  348.  
  349.     totalWritePacketBytes += len;
  350.  
  351.     ++packetsWrite;
  352.  
  353.     while (len--)
  354.     {
  355.         if (*buffer == FRAMECHAR)
  356.             localbuffer[b++] = FRAMECHAR;    // escape it for literal
  357.         localbuffer[b++] = *buffer++;
  358.     }
  359.  
  360.     localbuffer[b++] = FRAMECHAR;
  361.     localbuffer[b++] = 0;
  362.  
  363.     write_buffer (localbuffer, b);
  364. }
  365.  
  366.  
  367. /*
  368. =============
  369. =
  370. = NetISR
  371. =
  372. =============
  373. */
  374.  
  375. void interrupt NetISR (void)
  376. {
  377.     if (doomcom.command == CMD_SEND)
  378.     {
  379. //I_ColorBlack (0,0,63);
  380.         WritePacket ((char *)&doomcom.data, doomcom.datalength);
  381.     }
  382.     else if (doomcom.comman