reactos/apps/tests/oskittcp/tcptest.cpp

   1 #include <list>
   2 #include <string>
   3 extern "C" {
   4 #include <stdio.h>
   5 #include <oskittcp.h>
   6 #include <windows.h>
   7 #include <winsock2.h>
   8 };
   9
  10 #undef malloc
  11 #undef free
  12
  13 unsigned long TCP_IPIdentification;
  14
  15 #define MAX_DG_SIZE 0x10000
  16 #define TI_DbgPrint(x,y) printf y
  17
  18 std::list<std::string> output_packets;
  19
  20 typedef struct _CONNECTION_ENDPOINT {
  21     OSK_UINT State;
  22 } CONNECTION_ENDPOINT, *PCONNECTION_ENDPOINT;
  23
  24 int TCPSocketState(void *ClientData,
  25                    void *WhichSocket,
  26                    void *WhichConnection,
  27                    OSK_UINT NewState ) {
  28     PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)WhichConnection;
  29     PLIST_ENTRY Entry;
  30
  31     TI_DbgPrint(MID_TRACE,("Called: NewState %x\n", NewState));
  32
  33     if( !Connection ) {
  34         TI_DbgPrint(MID_TRACE,("Socket closing.\n"));
  35         return 0;
  36     }
  37
  38     if( (NewState & SEL_CONNECT) &&
  39         !(Connection->State & SEL_CONNECT) ) {
  40     } else if( (NewState & SEL_READ) || (NewState & SEL_FIN) ) {
  41     }
  42
  43     return 0;
  44 }
  45
  46 #define STRINGIFY(x) #x
  47
  48 int TCPPacketSend(void *ClientData, OSK_PCHAR data, OSK_UINT len ) {
  49     output_packets.push_back( std::string( (char *)data, (int)len ) );
  50     return 0;
  51 }
  52
  53 struct ifaddr *TCPFindInterface( void *ClientData,
  54                                  OSK_UINT AddrType,
  55                                  OSK_UINT FindType,
  56                                  struct sockaddr *ReqAddr ) {
  57     return NULL;
  58 }
  59
  60 void *TCPMalloc( void *ClientData,
  61                  OSK_UINT Bytes, OSK_PCHAR File, OSK_UINT Line ) {
  62     return malloc( Bytes );
  63 }
  64
  65 void TCPFree( void *ClientData,
  66               void *data, OSK_PCHAR File, OSK_UINT Line ) {
  67     free( data );
  68 }
  69
  70 int TCPSleep( void *ClientData, void *token, int priority, char *msg,
  71               int tmio ) {
  72 #if 0
  73     PSLEEPING_THREAD SleepingThread;
  74
  75     TI_DbgPrint(MID_TRACE,
  76                 ("Called TSLEEP: tok = %x, pri = %d, wmesg = %s, tmio = %x\n",
  77                  token, priority, msg, tmio));
  78
  79     SleepingThread = ExAllocatePool( NonPagedPool, sizeof( *SleepingThread ) );
  80     if( SleepingThread ) {
  81         KeInitializeEvent( &SleepingThread->Event, NotificationEvent, FALSE );
  82         SleepingThread->SleepToken = token;
  83
  84         ExAcquireFastMutex( &SleepingThreadsLock );
  85         InsertTailList( &SleepingThreadsList, &SleepingThread->Entry );
  86         ExReleaseFastMutex( &SleepingThreadsLock );
  87
  88         TI_DbgPrint(MID_TRACE,("Waiting on %x\n", token));
  89         KeWaitForSingleObject( &SleepingThread->Event,
  90                                WrSuspended,
  91                                KernelMode,
  92                                TRUE,
  93                                NULL );
  94
  95         ExAcquireFastMutex( &SleepingThreadsLock );
  96         RemoveEntryList( &SleepingThread->Entry );
  97         ExReleaseFastMutex( &SleepingThreadsLock );
  98
  99         ExFreePool( SleepingThread );
 100     }
 101     TI_DbgPrint(MID_TRACE,("Waiting finished: %x\n", token));
 102 #endif
 103     return 0;
 104 }
 105
 106 void TCPWakeup( void *ClientData, void *token ) {
 107 #if 0
 108     PLIST_ENTRY Entry;
 109     PSLEEPING_THREAD SleepingThread;
 110
 111     ExAcquireFastMutex( &SleepingThreadsLock );
 112     Entry = SleepingThreadsList.Flink;
 113     while( Entry != &SleepingThreadsList ) {
 114         SleepingThread = CONTAINING_RECORD(Entry, SLEEPING_THREAD, Entry);
 115         TI_DbgPrint(MID_TRACE,("Sleeper @ %x\n", SleepingThread));
 116         if( SleepingThread->SleepToken == token ) {
 117             TI_DbgPrint(MID_TRACE,("Setting event to wake %x\n", token));
 118             KeSetEvent( &SleepingThread->Event, IO_NETWORK_INCREMENT, FALSE );
 119         }
 120         Entry = Entry->Flink;
 121     }
 122     ExReleaseFastMutex( &SleepingThreadsLock );
 123 #endif
 124 }
 125
 126 OSKITTCP_EVENT_HANDLERS EventHandlers = {
 127     NULL,
 128     TCPSocketState,
 129     TCPPacketSend,
 130     TCPFindInterface,
 131     TCPMalloc,
 132     TCPFree,
 133     TCPSleep,
 134     TCPWakeup
 135 };
 136
 137 int main( int argc, char **argv ) {
 138     int asock = INVALID_SOCKET, selret, dgrecv, fromsize, err, port = 5000;
 139     char datagram[MAX_DG_SIZE];
 140     struct fd_set readf;
 141     struct timeval tv;
 142     struct sockaddr_in addr_from = { AF_INET };
 143     std::list<std::string>::iterator i;
 144
 145     if( argc > 1 ) port = atoi(argv[1]);
 146
 147     RegisterOskitTCPEventHandlers( &EventHandlers );
 148     InitOskitTCP();
 149
 150     asock = socket( AF_INET, SOCK_DGRAM, 0 );
 151
 152     addr_from.sin_port = htons( port );
 153
 154     if( bind( asock, (struct sockaddr *)&addr_from, sizeof( addr_from ) ) ) {
 155         printf( "Bind error\n" );
 156         return 0;
 157     }
 158
 159     while( true ) {
 160         FD_ZERO( &readf );
 161         FD_SET( asock, &readf );
 162         tv.tv_sec = 0;
 163         tv.tv_usec = 10000;
 164         selret = select( asock + 1, &readf, NULL, NULL, &tv );
 165
 166         if( FD_ISSET( asock, &readf ) ) {
 167             fromsize = sizeof( addr_from );
 168             dgrecv = recvfrom( asock, datagram, sizeof(datagram), 0,
 169                                (struct sockaddr *)&addr_from, &fromsize );
 170
 171             if( dgrecv > 0 ) {
 172                 OskitTCPReceiveDatagram( (unsigned char *)datagram,
 173                                          dgrecv, 20 );
 174                 if( err != 0 )
 175                     printf( "OskitTCPReceiveDatagram: %d\n", err );
 176             }
 177         }
 178
 179         TimerOskitTCP();
 180
 181         for( i = output_packets.begin(); i != output_packets.end(); i++ ) {
 182             err = sendto( asock, i->c_str(), i->size(), 0,
 183                           (struct sockaddr *)&addr_from, sizeof(addr_from) );
 184
 185             if( err != 0 )
 186                 printf( "sendto: %d\n", err );
 187         }
 188
 189         output_packets.clear();
 190     }
 191 }