Tools/NetTest/vfs_shim.c

   1 /*
   2  * Acess2 Networking Test Suite (NetTest)
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * vfs_shim.c
   6  * - VFS Layer Emulation
   7  */
   8 #include <vfs.h>
   9 #include <vfs_int.h>
  10 #include <events.h>
  11
  12 // === CODE ===
  13 int VFS_SelectNode(tVFS_Node *Node, int Type, tTime *Timeout, const char *Name)
  14 {
  15         tThread *us = Proc_GetCurThread();
  16
  17          int    ret = 0;
  18
  19         Threads_ClearEvent(THREAD_EVENT_VFS);
  20
  21         if( Type & VFS_SELECT_READ ) {
  22                 Node->ReadThreads = (void*)us;
  23                 if(Node->DataAvaliable) ret |= VFS_SELECT_READ;
  24         }
  25         if( Type & VFS_SELECT_WRITE ) {
  26                 Node->WriteThreads = (void*)us;
  27                 if(!Node->BufferFull)   ret |= VFS_SELECT_WRITE;
  28         }
  29         if( Type & VFS_SELECT_ERROR ) {
  30                 Node->ErrorThreads = (void*)us;
  31                 if(Node->ErrorOccurred) ret |= VFS_SELECT_ERROR;
  32         }
  33
  34         if( !ret )
  35         {
  36                 // TODO: Timeout
  37                 Threads_WaitEvents(THREAD_EVENT_VFS);
  38         }
  39
  40         if( Type & VFS_SELECT_READ ) {
  41                 Node->ReadThreads = NULL;
  42                 if(Node->DataAvaliable) ret |= VFS_SELECT_READ;
  43         }
  44         if( Type & VFS_SELECT_WRITE ) {
  45                 Node->WriteThreads = NULL;
  46                 if(!Node->BufferFull)   ret |= VFS_SELECT_WRITE;
  47         }
  48         if( Type & VFS_SELECT_ERROR ) {
  49                 Node->ErrorThreads = NULL;
  50                 if(Node->ErrorOccurred) ret |= VFS_SELECT_ERROR;
  51         }
  52         return ret;
  53 }
  54
  55 int VFS_MarkAvaliable(tVFS_Node *Node, BOOL bAvail)
  56 {
  57         Node->DataAvaliable = bAvail;
  58         if( Node->DataAvaliable && Node->ReadThreads )
  59                 Threads_PostEvent( (void*)Node->ReadThreads, THREAD_EVENT_VFS );
  60         return 0;
  61 }
  62
  63 int VFS_MarkError(tVFS_Node *Node, BOOL bError)
  64 {
  65         Node->ErrorOccurred = bError;
  66         if( Node->ErrorOccurred && Node->ErrorThreads )
  67                 Threads_PostEvent( (void*)Node->ErrorThreads, THREAD_EVENT_VFS );
  68         return 0;
  69 }
  70
  71 int VFS_MarkFull(tVFS_Node *Node, BOOL bError)
  72 {
  73         Node->BufferFull = bError;
  74         if( !Node->BufferFull && Node->WriteThreads )
  75                 Threads_PostEvent( (void*)Node->WriteThreads, THREAD_EVENT_VFS );
  76         return 0;
  77 }
  78
  79
  80 #if 0
  81 int VFS_Open(const char *Path, Uint Flags)
  82 {
  83         return -1;
  84 }
  85
  86 void VFS_Close(int FD)
  87 {
  88 }
  89 #endif
  90
  91 int VFS_AllocHandle(int bIsUser, tVFS_Node *Node, int Mode)
  92 {
  93         const int maxfd = *Threads_GetMaxFD();
  94         tVFS_Handle     *handles = *Threads_GetHandlesPtr();
  95         if( !handles ) {
  96                 handles = calloc( maxfd, sizeof(tVFS_Handle) );
  97                 *Threads_GetHandlesPtr() = handles;
  98         }
  99
 100         // TODO: Global handles
 101
 102         for( int i = 0; i < maxfd; i ++ )
 103         {
 104                 if( handles[i].Node == NULL ) {
 105                         handles[i].Node = Node;
 106                         handles[i].Mode = Mode;
 107                         return i;
 108                 }
 109         }
 110         return -1;
 111 }
 112
 113 tVFS_Handle *VFS_GetHandle(int FD)
 114 {
 115         const int maxfd = *Threads_GetMaxFD();
 116         tVFS_Handle     *handles = *Threads_GetHandlesPtr();
 117         if( !handles )
 118                 return NULL;
 119
 120         if( FD < 0 || FD >= maxfd )
 121                 return NULL;
 122
 123         return &handles[FD];
 124 }