home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 200-299 / ff294.lzh / DNet / amiga / dnet / sernet.c < prev    next >
C/C++ Source or Header  |  1989-12-11  |  7KB  |  403 lines
  1.  
  2. /*
  3.  *  SERNET.C
  4.  *
  5.  *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  6.  *
  7.  *  NetWork device interface.
  8.  */
  9.  
  10. #include "dnet.h"
  11.  
  12. IOSER *NetAbortRead();
  13. void NetWaitWrite();
  14. void SaveState();
  15. void RestoreState();
  16. void NetSerialOff();
  17. void NetSerialOn();
  18.  
  19.  
  20.  
  21. static IOSER Iosw;
  22. static ubyte IoswIP;
  23. static ubyte LastWasWrite;
  24.  
  25. static ubyte IosrIP;
  26. static ubyte RBuf[MAXPACKET*2];     /*    Recv Buf.            */
  27.  
  28. static IOSER *CNet;            /*    control-req (synchro)       */
  29. static IOSER *RNet;            /*    read-request            */
  30. static ubyte SerialIsOpen;        /*    serial device is open         */
  31. static ubyte RecvEnabled = 1;
  32. static char *DevName;
  33. static long UnitNum;
  34.  
  35. void
  36. NetOpen(iosink, devname, unitnum, pbaud)
  37. PORT *iosink;
  38. char *devname;
  39. long *pbaud;
  40. {
  41.     IOSER ios;
  42.     long baud = *pbaud;
  43.  
  44.     DevName = devname;
  45.     UnitNum = unitnum;
  46.  
  47.     printf("netopen %s %d\n", devname, unitnum);
  48.  
  49.     BZero(&ios, sizeof(ios));
  50.     ios.io_CtlChar = 0x11130102;
  51.     ios.io_SerFlags = SERF_SHARED|SERF_XDISABLED|SERF_RAD_BOOGIE;
  52.     if (OpenDevice(devname, unitnum, (IOR *)&ios, 0))
  53.     dneterror(devname);
  54.     ios.IOSer.io_Message.mn_ReplyPort = iosink;
  55.     SerialIsOpen = 1;
  56.  
  57.     RNet = (IOSER *)AllocMem(sizeof(IOSER), MEMF_PUBLIC);
  58.     CNet = (IOSER *)AllocMem(sizeof(IOSER), MEMF_PUBLIC);
  59.     *RNet = ios;
  60.     *CNet = ios;
  61.  
  62.     {
  63.     IOSER *ioc = CNet;
  64.  
  65.     ioc->IOSer.io_Command = SDCMD_QUERY;
  66.     DoIO((IOR *)ioc);
  67.  
  68.     if (Getty == 0) {
  69.         ioc->IOSer.io_Command = SDCMD_SETPARAMS;
  70.         ioc->io_SerFlags = SERF_SHARED|SERF_XDISABLED|SERF_RAD_BOOGIE;
  71.         ioc->io_ExtFlags = 0;
  72.         ioc->io_ReadLen = ioc->io_WriteLen = 8;
  73.         ioc->io_CtlChar = 0x01020304;
  74.  
  75.         if (baud)
  76.         ioc->io_Baud = baud;
  77.  
  78.         switch(Protocol) {
  79.         case 0:
  80.         break;
  81.         case 1:    /*  xon-xoff    */
  82.         Mode7 = 1;
  83.         ioc->io_SerFlags &= ~SERF_XDISABLED;
  84.         break;
  85.         case 2:
  86.         ioc->io_SerFlags |= SERF_7WIRE;
  87.         break;
  88.         }
  89.  
  90.         *pbaud = Baud = ioc->io_Baud;
  91.         if (DoIO((IOR *)ioc) != 0)
  92.         dneterror("Unable to set serial parameters");
  93.     }
  94.     }
  95.  
  96.     RNet->IOSer.io_Command = CMD_READ;
  97.     RNet->IOSer.io_Message.mn_Node.ln_Name = (char *)RNET_REQ;
  98.  
  99.     CNet->IOSer.io_Command = CMD_WRITE;
  100.     CNet->IOSer.io_Message.mn_Node.ln_Name = (char *)WNET_REQ;
  101.  
  102.     Iosw = *CNet;
  103.  
  104.     CNet->IOSer.io_Message.mn_Node.ln_Name = (char *)CNET_REQ;
  105.  
  106.     puts("net open");
  107. }
  108.  
  109. /*
  110.  *  Closedown the network.
  111.  */
  112.  
  113. void
  114. NetClose()
  115. {
  116.     NetAbortRead();
  117.     NetWaitWrite();
  118.     if (SerialIsOpen)
  119.     CloseDevice((IOR *)RNet);
  120.     if (RNet)
  121.     FreeMem(RNet, sizeof(IOSER));
  122.     if (CNet)
  123.     FreeMem(CNet, sizeof(IOSER));
  124.     SerialIsOpen = 0;
  125.     RNet = CNet = NULL;
  126. }
  127.  
  128. /*
  129.  *  NETCLWRITE()
  130.  *
  131.  *  Clear write request which was GetMsg()'d in DNET.C instead of
  132.  *  WaitIO()'d here.
  133.  */
  134.  
  135. void
  136. NetClWrite(ior)
  137. IOSER *ior;
  138. {
  139.     if (ior == &Iosw)
  140.     IoswIP = 0;
  141. }
  142.  
  143. void
  144. NetWrite(buf, bytes)
  145. ubyte *buf;
  146. int bytes;
  147. {
  148.     if (PDebug) {
  149.     short i;
  150.  
  151.     LastWasWrite = 1;
  152.     printf("WRITE %03x Bytes:", bytes);
  153.     for (i = 0; i < bytes; ++i)
  154.         printf(" %02x", buf[i]);
  155.     printf("\n");
  156.     }
  157.  
  158.     if (!SerialIsOpen)
  159.     return;
  160.  
  161.     if (IoswIP) {
  162.     WaitIO((IOR *)&Iosw);
  163.     IoswIP = 0;
  164.     }
  165.  
  166.     if (bytes) {
  167.     Iosw.IOSer.io_Message.mn_Node.ln_Name = (char *)WNET_REQ;
  168.     Iosw.IOSer.io_Data = (APTR)buf;
  169.     Iosw.IOSer.io_Length = bytes;
  170.     SendIO((IOR *)&Iosw);
  171.     IoswIP = 1;
  172.     }
  173.     fixsignal(Iosw.IOSer.io_Message.mn_ReplyPort);
  174. }
  175.  
  176. void
  177. NetBreak()
  178. {
  179.     if (SerialIsOpen) {
  180.     CNet->IOSer.io_Command = SDCMD_BREAK;
  181.     DoIO((IOR *)CNet);
  182.     fixsignal(Iosw.IOSer.io_Message.mn_ReplyPort);
  183.     }
  184. }
  185.  
  186. /*
  187.  *  NETREADY()
  188.  *
  189.  *  Using the specified inactive request, return the # bytes ready and
  190.  *  the carrier status.
  191.  */
  192.  
  193. NetReady()
  194. {
  195.     long n = 0;
  196.  
  197.     if (SerialIsOpen && RecvEnabled) {
  198.     CNet->IOSer.io_Command = SDCMD_QUERY;
  199.     if (DoIO((IOR *)CNet) == 0)
  200.         n = CNet->IOSer.io_Actual;
  201.     Cd = !(CNet->io_Status & (1 << 5));
  202.     }
  203.     return(n);
  204. }
  205.  
  206. /*
  207.  *  SetBaudRate()
  208.  */
  209.  
  210. SetBaudRate(baud)
  211. long baud;
  212. {
  213.     long result;
  214.  
  215.     if (Getty)
  216.     return(0);
  217.     if (TOBaud == 0)
  218.     SetTimeouts(baud);
  219.     if (CNet)
  220.     CNet->io_Baud = baud;
  221.     if (!SerialIsOpen)
  222.     return(1);
  223.     SaveState();
  224.     CNet->IOSer.io_Command = SDCMD_SETPARAMS;
  225.     result = DoIO((IOR *)CNet);
  226.     RestoreState();
  227.  
  228.     if (result)
  229.     printf("Unable to set baud rate to %d\n", baud);
  230.  
  231.     if (!result && PDebug)
  232.     printf("Baud rate set to %d\n", baud);
  233.  
  234.     return(0);  /*  don't abort whether we can or not   */
  235. }
  236.  
  237. /*
  238.  *  Assumes CNet holds current settings
  239.  */
  240.  
  241. void
  242. DropDTR()
  243. {
  244.     if (SerialIsOpen) {     /*  only if serial.device currently open    */
  245.     NetSerialOff();
  246.     Delay(50*4);
  247.     NetSerialOn();
  248.     }
  249. }
  250.  
  251. IOSER *
  252. NetAbortRead()
  253. {
  254.     if (IosrIP) {
  255.     if (SerialIsOpen && RecvEnabled) {
  256.         AbortIO((IOR *)RNet);
  257.         WaitIO((IOR *)RNet);
  258.     }
  259.     IosrIP = 0;
  260.     }
  261.     return(RNet);
  262. }
  263.  
  264. /*
  265.  *  NetStartRead(bytes)
  266.  */
  267.  
  268. static long  SaveLen;
  269.  
  270. void
  271. NetStartRead(len)
  272. long len;
  273. {
  274.     if (len > sizeof(RBuf))
  275.     len = sizeof(RBuf);
  276.  
  277.     if (SerialIsOpen && RecvEnabled) {
  278.     if (IosrIP)
  279.         NetAbortRead();
  280.     RNet->IOSer.io_Data = (APTR)RBuf;
  281.     SaveLen = RNet->IOSer.io_Length = len;
  282.     SendIO((IOR *)RNet);
  283.     } else {
  284.     SaveLen = len;
  285.     RNet->IOSer.io_Actual = 0;
  286.     }
  287.     IosrIP = 1;
  288. }
  289.  
  290. IOSER *
  291. NetReadReady()
  292. {
  293.     return((IOSER *)CheckIO((IOR *)RNet));
  294. }
  295.  
  296. NetReadReturned(pptr)
  297. ubyte **pptr;
  298. {
  299.     long bytes = 0;
  300.  
  301.     IosrIP = 0;
  302.  
  303.     bytes = RNet->IOSer.io_Actual;
  304.     *pptr = RBuf;
  305.  
  306.     if (PDebug) {
  307.     short i = 0;
  308.     if (LastWasWrite) {
  309.         LastWasWrite = 0;
  310.         printf("READ: ");
  311.     }
  312.     for (i = 0; i < bytes; ++i)
  313.         printf("%02x ", RBuf[i]);
  314.     fflush(stdout);
  315.     }
  316.     return(bytes);
  317. }
  318.  
  319. void
  320. NetWaitWrite()
  321. {
  322.     if (IoswIP) {
  323.     WaitIO((IOR *)&Iosw);
  324.     IoswIP = 0;
  325.     fixsignal(Iosw.IOSer.io_Message.mn_ReplyPort);
  326.     }
  327. }
  328.  
  329. static char SaveIosrIP;
  330.  
  331. void
  332. SaveState()
  333. {
  334.     if (SaveIosrIP = IosrIP)
  335.     NetAbortRead();
  336.     NetWaitWrite();
  337. }
  338.  
  339. void
  340. RestoreState()
  341. {
  342.     if (SaveIosrIP)
  343.     NetStartRead(SaveLen);
  344. }
  345.  
  346. void
  347. NetRecvOff()
  348. {
  349.     if (RecvEnabled) {
  350.     SaveState();
  351.     RecvEnabled = 0;
  352.     }
  353. }
  354.  
  355. void
  356. NetRecvOn()
  357. {
  358.     if (!RecvEnabled) {
  359.     RecvEnabled = 1;
  360.     RestoreState();
  361.     }
  362. }
  363.  
  364. void
  365. NetSerialOff()
  366. {
  367.     if (SerialIsOpen) {
  368.     SaveState();            /*  make sure no requests pending   */
  369.     CloseDevice((IOR *)RNet);   /*  close the device                */
  370.     SerialIsOpen = 0;
  371.     }
  372. }
  373.  
  374. void
  375. NetSerialOn()
  376. {
  377.     if (!SerialIsOpen) {
  378.     if (OpenDevice(DevName, UnitNum, (IOR *)RNet, 0))      /* OH HELL! */
  379.         return;
  380.  
  381.     /*
  382.      *  Fix the Device / Unit fields and restore the previous
  383.      *  modes.
  384.      */
  385.  
  386.     SerialIsOpen = 1;
  387.     Iosw.IOSer.io_Device = RNet->IOSer.io_Device;
  388.     Iosw.IOSer.io_Unit   = RNet->IOSer.io_Unit;
  389.  
  390.     CNet->IOSer.io_Device = RNet->IOSer.io_Device;
  391.     CNet->IOSer.io_Unit   = RNet->IOSer.io_Unit;
  392.  
  393.     RNet->IOSer.io_Command = CMD_READ;
  394.                 /*  restore params            */
  395.     CNet->IOSer.io_Command = SDCMD_SETPARAMS;
  396.     CNet->io_SerFlags = SERF_SHARED|SERF_XDISABLED|SERF_RAD_BOOGIE;
  397.     DoIO((IOR *)CNet);
  398.     RestoreState();         /*  restore pending read req.       */
  399.     }
  400.     return;
  401. }
  402.  
  403.