Changeset 7611 for code/branches/masterserver/src/modules

Timestamp:

Nov 3, 2010, 4:20:02 PM (14 years ago)

Author:

smerkli

Message:

Communication channel now working both ways, doxygen documentation added, renamed files to convention, re-wrote the client part object-oriented and non-blocking

Location:

code/branches/masterserver/src/modules/masterserver

Files:

• MasterServer.cc (moved) (moved from code/branches/masterserver/src/modules/masterserver/MasterServer.cpp) (9 diffs)
• MasterServer.h (modified) (1 diff)
• MasterServerComm.cc (moved) (moved from code/branches/masterserver/src/modules/masterserver/TestClient.cpp) (3 diffs)
• MasterServerComm.h (added)
• PeerList.cc (moved) (moved from code/branches/masterserver/src/modules/masterserver/PeerList.cpp)
• ServerList.cc (moved) (moved from code/branches/masterserver/src/modules/masterserver/ServerList.cpp)

code/branches/masterserver/src/modules/masterserver/MasterServer.cc

@@ -40 +40 @@
   /* connect event */
   int 
-  eventConnect( ENetEvent *event )
+  MasterServer::eventConnect( ENetEvent *event )
   { /* check for bad parameters */
     if( !event )
-    { fprintf( stderr, "No event given.\n" );
+    { COUT(2) << "MasterServer::eventConnect: No event given.\n" ;
       return -1;
     }
 
+    /* convert address to string. */
+    char *addrconv = (char *) calloc( 50, 1 );
+    enet_address_get_host_ip( &(event->peer->address), addrconv, 49 );
+
     /* output debug info */
-    printf( "A new client connected from %x:%u.\n", 
-        (event->peer->address.host),
-        event->peer->address.port );
+    COUT(4) << "A new client connected from " 
+      << addrconv 
+      << " on port " 
+      << event->peer->address.port << "\n";
 
     /* game server or client connection? */
@@ -61 +66 @@
     /* add to client list */
 
-    /* NOTE this seems to be some weird snipped from the tutorial as peer.data
-     * is a uint_32 of some kind and hence shouldn't be assigned a c string? :S 
-     */
-    /* Store any relevant client information here. */
-    /* event->peer->data = "Client information"; */
-    /* /NOTE */
+    /* store string form of address here */
+    event->peer->data = addrconv; 
+
+    /* all fine. */
     return 0;
   }
@@ -72 +75 @@
   /* disconnect event */
   int 
-  eventDisconnect( ENetEvent *event )
+  MasterServer::eventDisconnect( ENetEvent *event )
   { /* check for bad parameters */
     if( !event )
-    { fprintf( stderr, "No event given.\n" );
+    { COUT(2) << "No event given.\n";
       return -1;
     }
 
     /* output that the disconnect happened, to be removed at a later time. */
-    printf( "%s disconnected.\n", (char*)event->peer->data );
+    COUT(4) << (char*)event->peer->data << " disconnected.\n";
 
     /* remove the server from the list it belongs to */
 
     /* Reset the peer's client information. */
-    event->peer->data = NULL;
+    if( event->peer->data ) free( event->peer->data );
     return 0;
   }
@@ -91 +94 @@
   /* data event */
   int 
-  eventData( ENetEvent *event )
+  MasterServer::eventData( ENetEvent *event )
   { /* output what's in the packet (to be removed later) */
-    if( !event || !(event->packet) || !(event->peer) || !(event->channelID) )
-    { fprintf( stderr, "No complete event given.\n" );
+    if( !event || !(event->packet) || !(event->peer) )
+    { COUT(2) << "No complete event given.\n";
       return -1;
     }
-
+     
+    /* generate address in readable form */
+    char *addrconv = (char *) calloc( 50, 1 );
+    enet_address_get_host_ip( &(event->peer->address), addrconv, 49 );
+
+    /* DEBUG */
     /* output debug info about the data that has come, to be removed */
-    //printf( "A packet of length %u containing %s was received from %s on channel %u.\n",
-    //event->packet->dataLength,
-    //event->packet->data,
-    //event->peer->data,
-    //event->channelID );
+    COUT(4) << "A packet of length" 
+      << event->packet->dataLength
+      << " containing "
+      << event->packet->data
+      << " was received from "
+      << addrconv 
+      << " on channel "
+      << event->channelID << "\n";
+
+    /* send some packet back for testing */
+    /* TESTING */
+
+    /* Create a reliable reply of size 7 containing "reply\0" */
+    ENetPacket * reply = enet_packet_create ("reply", 
+        strlen ("reply") + 1, 
+        ENET_PACKET_FLAG_RELIABLE);
+
+    /* Send the reply to the peer over channel id 0. */
+    enet_peer_send( event->peer, 0, reply );
+
+    /* One could just use enet_host_service() instead. */
+    enet_host_flush( this->server );
+
+    /* /TESTING */
 
     /* game server or client connection? */
@@ -115 +142 @@
     /* and send reply */
 
+    /* delete addrconv */
+    if( addrconv ) free( addrconv );
+
     /* Clean up the packet now that we're done using it. */
     enet_packet_destroy( event->packet );
@@ -120 +150 @@
   }
 
+
   /**** MAIN ROUTINE *****/
   int 
   MasterServer::run()
   {
-    COUT(0) << "omg, i got baschtl'd!\n";
-
     /***** ENTER MAIN LOOP *****/
     ENetEvent *event = (ENetEvent *)calloc(sizeof(ENetEvent), sizeof(char));
     if( event == NULL )
-    { fprintf( stderr, "Could not create ENetEvent structure, exiting.\n" );
-      exit( EXIT_FAILURE );
-    }
+    { 
+      COUT(1) << "Could not create ENetEvent structure, exiting.\n";
+      exit( EXIT_FAILURE );
+    }
+
+    /* tell people we're now initialized and blocking. */
+    COUT(0) << "MasterServer initialized, waiting for connections.\n";
 
     /* create an iterator for the loop */
-    while( enet_host_service( this->server, event, 1000 ) > 0 )
+    while( enet_host_service( this->server, event, 1000 ) >= 0 )
     { /* check what type of event it is and react accordingly */
       switch (event->type)
@@ -163 +196 @@
     /***** INITIALIZE NETWORKING *****/
     if( enet_initialize () != 0)
-    { fprintf( stderr, "An error occurred while initializing ENet.\n");
+    { COUT(1) << "An error occurred while initializing ENet.\n";
       exit( EXIT_FAILURE );
     }
@@ -181 +214 @@
     /* see if creation worked */
     if( !this->server )
-    { fprintf( stderr, 
-        "An error occurred while trying to create an ENet server host.\n" );
-    exit( EXIT_FAILURE );
-    }
-
-    /***** INITIALIZE GAME SERVER LIST *****/
+    { COUT(1) << 
+        "An error occurred while trying to create an ENet server host.\n";
+      exit( EXIT_FAILURE );
+    }
+
+    /***** INITIALIZE GAME SERVER AND PEER LISTS *****/
     this->mainlist = new ServerList();
-    if( this->mainlist == NULL )
-    { fprintf( stderr, "Error creating server list.\n" );
-      exit( EXIT_FAILURE );
-    }
-
-    /***** INITIALIZE PEER LIST *****/
     this->peers = new PeerList();
+    if( this->mainlist == NULL || this->peers == NULL )
+    { COUT(1) << "Error creating server or peer list.\n";
+      exit( EXIT_FAILURE );
+    }
 
     /* run the main method */
@@ -207 +238 @@
     enet_host_destroy( this->server );
 
+    /* free all used memory */
     /* clear the list of connected game servers */
     /* clear the list of connected game clients */
 
-    /* free all used memory */
-
   }
 

code/branches/masterserver/src/modules/masterserver/MasterServer.h

@@ -68 +68 @@
     
     private:
+      /* methods */
+      int eventConnect( ENetEvent *event );
+      int eventDisconnect( ENetEvent *event );
+      int eventData( ENetEvent *event );
+
+      /* members */
       ENetAddress address;
       ENetHost *server;
       ServerList *mainlist;
       PeerList *peers;
+
+      /* main routine */
       int run();
 

code/branches/masterserver/src/modules/masterserver/MasterServerComm.cc

@@ -31 +31 @@
 #include <cstring>
 #include <enet/enet.h>
+#include "MasterServerComm.h"
 
-int main( int argc, char *argv[] )
+MasterServerComm::MasterServerComm()
 {
   /* initialize Enet */
   if (enet_initialize () != 0)
   { fprintf (stderr, "An error occurred while initializing ENet.\n");
-    return EXIT_FAILURE;
+    exit(EXIT_FAILURE);
   }
   atexit (enet_deinitialize);
 
-  /* client handle */
-  ENetHost *client;
 
   /* initiate the client */
-  client = enet_host_create( NULL /* create a client host */,
+  this->client = enet_host_create( NULL /* create a client host */,
       1,
       2, /* allow up 2 channels to be used, 0 and 1 */
@@ -52 +51 @@
 
   /* see if it worked */
-  if (client == NULL)
+  if (this->client == NULL)
   { fprintf (stderr, 
       "An error occurred while trying to create an ENet client host.\n");
     exit (EXIT_FAILURE);
   }
+}
 
-  ENetAddress address;
-  ENetEvent event;
-  ENetPeer *peer;
+MasterServerComm::~MasterServerComm()
+{
+  enet_host_destroy(this->client);
+}
 
-  /* Connect to some.server.net:1234. */
-  enet_address_set_host (& address, argv[1] );
-  address.port = 1234;
+int 
+MasterServerComm::connect( char *address, unsigned int port )
+{
+  /* Connect to address:port. */
+  enet_address_set_host( &this->address, address );
+  this->address.port = port;
 
   /* Initiate the connection, allocating the two channels 0 and 1. */
-  peer = enet_host_connect(client, &address, 2, 0);    
+  this->peer = enet_host_connect(this->client, &this->address, 2, 0);    
 
-  if (peer == NULL )
+  if (this->peer == NULL )
   { fprintf( stderr, 
         "No available peers for initiating an ENet connection.\n");
@@ -75 +79 @@
   }
 
-  /* Wait up to 5 seconds for the connection attempt to succeed. */
-  if (enet_host_service (client, & event, 5000) > 0 &&
-      event.type == ENET_EVENT_TYPE_CONNECT)
-  { fprintf( stdout, "Connection to some.server.net:1234 succeeded." ); 
-    char *theinput = (char *)calloc( 100,1 );
-    while( true )
-    { 
-      fgets( theinput, 90, stdin );
-      if( !strncmp( theinput, "quit", 4 ) )
-        break;
-
-      /* send the data to the friend */
-      /* Create a reliable packet of size 7 containing "packet\0" */
-      ENetPacket * packet = enet_packet_create( theinput, 
-          strlen( theinput ) + 1, 
-          ENET_PACKET_FLAG_RELIABLE);
-
-      /* Send the packet to the peer over channel id 0. */
-      enet_peer_send (peer, 0, packet);
-
-      /* One could just use enet_host_service() instead. */
-      enet_host_flush( client );
-      if( packet ) free( packet );
-    }
-  }
+  /* Wait up to 2 seconds for the connection attempt to succeed. */
+  if (enet_host_service (this->client, &this->event, 2000) > 0 &&
+      this->event.type == ENET_EVENT_TYPE_CONNECT )
+    fprintf( stdout, "Connection to server succeeded." );
   else
   {
-    /* Either the 5 seconds are up or a disconnect event was */
-    /* received. Reset the peer in the event the 5 seconds   */
-    /* had run out without any significant event.            */
-    enet_peer_reset (peer);
-    fprintf( stdout, "Connection to some.server.net:1234 failed." );
+    enet_peer_reset (this->peer);
+    fprintf( stdout, "Connection to %s failed.", address );
     exit(EXIT_FAILURE);
   }
 
-  enet_host_destroy(client);
+  return 0;
 }
+
+int 
+MasterServerComm::pollForReply( int (*callback)( char*, ENetEvent* ) )
+{ 
+  if( enet_host_service( this->client, &this->event, 100 ) >= 0 )
+  { 
+    char *addrconv = NULL;
+    /* check what type of event it is and react accordingly */
+    switch (this->event.type)
+    { /* new connection, not supposed to happen. */
+      case ENET_EVENT_TYPE_CONNECT: break;
+
+      /* disconnect */
+      case ENET_EVENT_TYPE_DISCONNECT: 
+        /* ?? */ break;
+
+        /* incoming data */
+      case ENET_EVENT_TYPE_RECEIVE: 
+        addrconv = (char *) calloc( 50, 1 );
+        enet_address_get_host_ip( &(this->event.peer->address), addrconv, 49 );
+
+        /* DEBUG */
+        printf( "A packet of length %u containing %s was "
+          "received from %s on channel %u.\n",
+          this->event.packet->dataLength,
+          this->event.packet->data,
+          addrconv,
+          this->event.channelID );
+        /* END DEBUG */
+
+        /* call the supplied callback, if any. */
+        if( (*callback) != NULL )
+          (*callback)( addrconv, &(this->event) );
+
+        enet_packet_destroy( event.packet );
+        if( addrconv ) free( addrconv );
+        break;
+      default: break;
+    }
+  }
+  
+  return 0;
+}
+
+int 
+MasterServerComm::sendRequest( char *data )
+{
+  /* send the data to the friend */
+  /* Create a reliable packet of size 7 containing "packet\0" */
+  ENetPacket * packet = enet_packet_create( data, 
+      strlen( data ) + 1, 
+      ENET_PACKET_FLAG_RELIABLE);
+
+  /* Send the packet to the peer over channel id 0. */
+  enet_peer_send (this->peer, 0, packet);
+
+  /* One could just use enet_host_service() instead. */
+  enet_host_flush( this->client );
+  if( packet ) free( packet );
+}
+
+/* sample callback to output debugging info. */
+int callb( char *addr, ENetEvent *ev )
+{ 
+  printf( "A packet of length %u containing %s was "
+      "received from %s on channel %u.\n",
+      ev->packet->dataLength,
+      ev->packet->data,
+      addr,
+      ev->channelID );
+  return 0;
+}
+
+/* small testing implementation */
+int
+main( int argc, char *argv[] )
+{
+  /* setup object and connect */
+  MasterServerComm msc = MasterServerComm();
+  msc.connect( argv[1], 1234 );
+  
+  /* send some data and poll for replies */
+  char *theinput = (char *)calloc( 100,1 );
+  while( true )
+  { 
+    fgets( theinput, 90, stdin );
+    if( !strncmp( theinput, "quit", 4 ) )
+      break;
+
+    msc.sendRequest( theinput );
+    msc.pollForReply( &callb );
+  }
+
+}