home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 10 / Fresh_Fish_10_2352.bin / new / comm / tcp / netinput / source / netinputd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-24  |  6.0 KB  |  245 lines
  1. /*
  2. ** $VER: netinput.c 1.3 (24 Jul 1995)(14 Jul 1995)
  3. **
  4. ** AMIGA netinput server code
  5. **
  6. ** (C) Copyright 1995 Marius Gröger
  7. **     All Rights Reserved
  8. **
  9. ** $HISTORY:
  10. **
  11. ** 24 Jul 1995 : 001.003 :  added "default:" in main loop switch()
  12. **                          return status was broken
  13. ** 14 Jul 1995 : 001.002 :  some code cleanup
  14. ** 06 Mar 1995 : 001.001 :  version id added
  15. ** 05 Mar 1995 : 001.000 :  created
  16. */
  17.  
  18. #define DEBUG 0
  19.  
  20. /*F*/ /* includes */
  21. #include <NETINCLUDE:sys/types.h>
  22. #include <NETINCLUDE:sys/stat.h>
  23. #include <NETINCLUDE:stdio.h>
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26. #include <fcntl.h>
  27. #include <errno.h>
  28. #include <string.h>
  29. #include <clib/netlib_protos.h>
  30. #include <netdb.h>
  31.  
  32. #include <clib/dos_protos.h>
  33. #include <pragmas/dos_pragmas.h>
  34.  
  35. #include <clib/exec_protos.h>
  36. #include <pragmas/exec_sysbase_pragmas.h>
  37.  
  38. #include <exec/memory.h>
  39. #include <exec/io.h>
  40. #include <exec/interrupts.h>
  41.  
  42. #include <devices/input.h>
  43. #include <devices/inputevent.h>
  44.  
  45. #include "netinput.h"
  46. #include "unixsem.h"
  47. #include "compiler.h"
  48. #include "debug.h"
  49.  
  50. /*E*/
  51. /*F*/ /* global data */
  52. extern struct Library *SocketBase, *DOSBase;
  53.  
  54. typedef struct GlobalData
  55. {
  56.    struct Library   *gd_SysBase,
  57.                     *gd_UtilityBase,
  58.                     *gd_DOSBase;
  59.    struct MsgPort   *gd_IPort;
  60.    struct IOStdReq  *gd_IReq;
  61.    UBYTE             gd_ProgramName[100];
  62.    ULONG             gd_Flags;
  63.    int               gd_Socket;
  64.    struct Task      *gd_We;
  65.    struct foPacket   gd_Request;
  66. } *GD;
  67.  
  68. #ifdef __SASC
  69.      /*
  70.      ** redirect all shared library bases to our device base.
  71.      */
  72. #  define SysBase      gd->gd_SysBase
  73. #  define DOSBase      gd->gd_DOSBase
  74. #  define UtilityBase  gd->gd_UtilityBase
  75.      /*
  76.      ** This macro declares a local variable which temporary gets
  77.      ** SysBase directly from AbsExecBase.
  78.      */
  79. #  define LOCALSYSBASE struct { void *gd_SysBase; } *gd = (void*)0x4
  80. #else
  81. #  error Please define library bases for your compiler
  82. #endif
  83.  
  84. /*E*/
  85.  
  86. /*F*/ /* revision */
  87. #define VERSION 37
  88. #define REVISION 2
  89. #define DATE "24.07.95"
  90. #define VERS "netinputd 37.2"
  91. #define VSTRING "netinputd 37.2 (24.07.95)"
  92. #define VERSTAG "\0$VER: netinputd 37.2 (24.07.95)"
  93. const STATIC UBYTE version[]=VERSTAG;
  94. /*E*/
  95.  
  96. /*F*/ /* private symbols */
  97. static VOID freeall(GD gd);
  98. static BOOL openall(GD gd);
  99. static GD creategd(VOID);
  100. static BOOL getrequest(GD gd);
  101. /*E*/
  102. /*F*/ /* exported symbols */
  103. extern int main(VOID);
  104. /*E*/
  105.  
  106. /*F*/ static VOID freeall(GD gd)
  107. {
  108.    if (gd->gd_IReq)
  109.    {
  110.       if (gd->gd_IReq->io_Device) CloseDevice((struct IORequest*)gd->gd_IReq);
  111.       DeleteIORequest(gd->gd_IReq);
  112.    }
  113.    if (gd->gd_IPort) DeleteMsgPort(gd->gd_IPort);
  114.    if (DOSBase) CloseLibrary(DOSBase);
  115.    if (UtilityBase) CloseLibrary(UtilityBase);
  116.    FreeVec(gd);
  117. }
  118. /*E*/
  119. /*F*/ static BOOL openall(GD gd)
  120. {
  121.    BOOL rv = FALSE;
  122.  
  123.    gd->gd_We = FindTask(NULL);
  124.  
  125.    d(("opening dos.library\n"));
  126.    if (DOSBase = OpenLibrary("dos.library", 37))
  127.    {
  128.       d(("opening utility.library\n"));
  129.       if (UtilityBase = OpenLibrary("utility.library", 37))
  130.       {
  131.          d(("creating msg port\n"));
  132.          if (gd->gd_IPort = CreateMsgPort())
  133.          {
  134.             d(("creating io request\n"));
  135.             if (gd->gd_IReq = CreateIORequest(gd->gd_IPort, sizeof(struct IOStdReq)))
  136.             {
  137.                d(("opening input.device\n"));
  138.                if (!OpenDevice("input.device",0,(struct IORequest*)gd->gd_IReq, 0))
  139.                {
  140.                   rv = TRUE;
  141.                }
  142.             }
  143.          }
  144.       }
  145.    }
  146.  
  147.    return rv;
  148. }
  149. /*E*/
  150. /*F*/ static GD creategd(VOID)
  151. {
  152.    GD new;
  153.    LOCALSYSBASE;
  154.  
  155.    new = AllocVec(sizeof(struct GlobalData), MEMF_ANY | MEMF_CLEAR);
  156.    new->gd_SysBase = SysBase;
  157.  
  158.    return new;
  159. }
  160. /*E*/
  161.  
  162. /*F*/ static BOOL getrequest(GD gd)
  163. {
  164.    int l;
  165.  
  166.    l = recv((LONG)gd->gd_Socket, (UBYTE*)&gd->gd_Request, sizeof(struct foPacket), 0);
  167.    d(("recv(%ld) = %ld bytes\n",sizeof(struct foPacket), l));
  168.    return (BOOL)(l == sizeof(struct foPacket));
  169. }
  170. /*E*/
  171.  
  172. /*F*/ extern int main(VOID)
  173. {
  174.    int rc = RETURN_FAIL;
  175.    GD gd;
  176.  
  177.    if (gd = creategd())
  178.    {
  179.       d(("gd at %lx\n",gd));
  180.  
  181.       if (openall(gd))
  182.       {
  183.          GetProgramName(gd->gd_ProgramName, sizeof(gd->gd_ProgramName));
  184.  
  185.          gd->gd_Socket = init_inet_daemon();
  186.          if (gd->gd_Socket >= 0)
  187.          {
  188.             BOOL running = TRUE;
  189.  
  190.             while(running)
  191.             {
  192.                if (getrequest(gd))
  193.                {
  194.                   switch(gd->gd_Request.Type)
  195.                   {
  196.                      case FOPT_Event:
  197.                      {
  198.                         struct InputEvent event;
  199.                         if (recv((LONG)gd->gd_Socket, (UBYTE*)&event, sizeof(struct InputEvent), 0) == sizeof(struct InputEvent))
  200.                         {
  201.                            //d(("received input event %lx %lx %lx\n",event.ie_Class,event.ie_Code,event.ie_Qualifier));
  202.                            gd->gd_IReq->io_Command = IND_WRITEEVENT;
  203.                            gd->gd_IReq->io_Data = (APTR)&event;
  204.                            gd->gd_IReq->io_Length = sizeof(struct InputEvent);
  205.                            event.ie_NextEvent = NULL;
  206.                            DoIO((struct IORequest*)gd->gd_IReq);
  207.                         }
  208.                         else
  209.                         {
  210.                            d(("couldn't receive input event\n"));
  211.                         }
  212.                      }
  213.                      break;
  214.  
  215.                      case FOPT_Finish:
  216.                         d(("finnish\n"));
  217.                         running = FALSE;
  218.                         rc = RETURN_OK;
  219.                      break;
  220.  
  221.                      default:
  222.                         d(("bad command 0x%08lx\n", gd->gd_Request.Type));
  223.                         running = FALSE;
  224.                      break;
  225.                   }
  226.  
  227.                }
  228.                else
  229.                {
  230.                   /* recv() didn't work properly */
  231.                   running = FALSE;
  232.                }
  233.             }
  234.          }
  235.       }
  236.  
  237.       freeall(gd);
  238.    }
  239.  
  240.    d(("returning rc=%ld\n",rc));
  241.    return rc;
  242. }
  243. /*E*/
  244.  
  245.