예제 #1
0
파일: Network.cpp 프로젝트: 8102/QNetSoul
Network::Network(QObject* parent)
  : QObject(parent), _options(NULL), _handShakingStep(0),
    _port(3128), _retries(0)
{
  this->_ns = dynamic_cast<QNetsoul*>(parent);
  if (this->_ns)
    {
      this->_reconnectionTimer.setSingleShot(true);
      QObject::connect(&this->_reconnectionTimer, SIGNAL(timeout()),
                       this->_ns, SLOT(reconnect()));
      QObject::connect(&this->_socket, SIGNAL(readyRead()),
                       SLOT(processPackets()));
      QObject::connect(&this->_socket,
                       SIGNAL(stateChanged(QAbstractSocket::SocketState)),
                       this->_ns,
                       SLOT(updateWidgets(QAbstractSocket::SocketState)));
      QObject::connect(&this->_socket,
                       SIGNAL(stateChanged(QAbstractSocket::SocketState)),
                       this,
                       SLOT(handleSocketState(QAbstractSocket::SocketState)));
      QObject::connect(&this->_socket,
                       SIGNAL(error(QAbstractSocket::SocketError)),
                       SLOT(handleSocketError(QAbstractSocket::SocketError)));
    }
  else
    qFatal("Network constructor: parent must be a QNetsoul instance !");
  this->_socket.setProxy(QNetworkProxy::NoProxy);
}
예제 #2
0
//
// void step()
// Last modified: 27Aug2006
//
// Processes packets received and updates the state of the cell,
// which is then broadcast within the neighborhood of the cell.
//
// Returns:     <none>
// Parameters:  <none>
//
void Cell::step()
{
    if (processPackets())
    {
        updateState();
        sendStateToNbrs();
    }
    Robot::step();
}   // step()
예제 #3
0
int main(int argc, char *argv[])
{
  MLENV env;
  MLINK link;
  int   ierr;

  ierr = PetscInitialize(&argc, &argv, NULL, help);if (ierr) return(ierr);
  ierr = setupConnection(&env, &link, "192.168.119.1", MATHEMATICA_LINK_CONNECT);CHKERRQ(ierr);
  ierr = processPackets(link);CHKERRQ(ierr);
  ierr = cleanupConnection(env, link);CHKERRQ(ierr);
  ierr = PetscFinalize();
  return(ierr);
}
예제 #4
0
void DataBus::Server::processReceivedPacket(Client *client)
{
    // Check client
    if (client == 0)
    {
        // Error, null pointer
        return;
    }

    // Find client in the list
    int index = m_clients.indexOf(client);

    if (index < 0)
    {
        // Error, client was not found
        return;
    }

    // Process received packet from a client
    processPackets(client);
}
Robot* Robot::auctioningStep()
{
    Robot* answer = NULL;
    processPackets();


    updateDistanceTraveled();

    if(auctionStepCount>0)
    {
        auctionStepCount++;
    }else{

        if(AUTONOMOUS_INIT)
        {
            if(auctionStepCount==0)
            {
                answer = this;
                //cout << "Robot["<<ID<<"] is going to hold an auction."<<endl;
            }
        }
    }
    return answer;
}
예제 #6
0
파일: packet.cpp 프로젝트: xbackupx/showeqx
////////////////////////////////////////////////////
// Constructor
EQPacket::EQPacket(const QString& worldopcodesxml,
		   const QString& zoneopcodesxml,
		   uint16_t arqSeqGiveUp, 
		   QString device,
		   QString ip,
		   QString mac_address,
		   bool realtime,
		   bool sessionTrackingFlag,
		   bool recordPackets,
		   int playbackPackets,
		   int8_t playbackSpeed, 
		   QObject * parent, const char *name)
  : QObject (parent, name),
    m_packetCapture(NULL),
    m_vPacket(NULL),
    m_timer(NULL),
    m_busy_decoding(false),
    m_arqSeqGiveUp(arqSeqGiveUp),
    m_device(device),
    m_ip(ip),
    m_mac(mac_address),
    m_realtime(realtime),
    m_session_tracking(sessionTrackingFlag),
    m_recordPackets(recordPackets),
    m_playbackPackets(playbackPackets),
    m_playbackSpeed(playbackSpeed)
{
  // create the packet type db
  m_packetTypeDB = new EQPacketTypeDB();

#ifdef PACKET_OPCODEDB_DIAG
  m_packetTypeDB->list();
#endif

  // create the world opcode db (with hash size of 29)
  m_worldOPCodeDB = new EQPacketOPCodeDB(29);

  // load the world opcode db
  if (!m_worldOPCodeDB->load(*m_packetTypeDB, worldopcodesxml))
    seqFatal("Error loading '%s'!", (const char*)worldopcodesxml);
  
#ifdef PACKET_OPCODEDB_DIAG
  m_worldOPCodeDB->list();
#endif

  //m_worldOPCodeDB->save("/tmp/worldopcodes.xml");

  // create the zone opcode db (with hash size of 211)
  m_zoneOPCodeDB = new EQPacketOPCodeDB(211);
  
  // load the zone opcode db
  if (!m_zoneOPCodeDB->load(*m_packetTypeDB, zoneopcodesxml))
    seqFatal("Error loading '%s'!", (const char*)zoneopcodesxml);

#ifdef PACKET_OPCODEDB_DIAG
  m_zoneOPCodeDB->list();
#endif

  //m_zoneOPCodeDB->save("/tmp/zoneopcodes.xml");
  
  // Setup the data streams

  // Setup client -> world stream
  m_client2WorldStream = new EQPacketStream(client2world, DIR_Client, 
					    m_arqSeqGiveUp, *m_worldOPCodeDB,
					    this, "client2world");
  connectStream(m_client2WorldStream);

  // Setup world -> client stream
  m_world2ClientStream = new EQPacketStream(world2client, DIR_Server,
					    m_arqSeqGiveUp, *m_worldOPCodeDB,
					    this, "world2client");
  connectStream(m_world2ClientStream);

  // Setup client -> zone stream
  m_client2ZoneStream = new EQPacketStream(client2zone, DIR_Client,
					  m_arqSeqGiveUp, *m_zoneOPCodeDB,
					  this, "client2zone");
  connectStream(m_client2ZoneStream);

  // Setup zone -> client stream
  m_zone2ClientStream = new EQPacketStream(zone2client, DIR_Server,
					   m_arqSeqGiveUp, *m_zoneOPCodeDB,
					   this, "zone2client");
  connectStream(m_zone2ClientStream);

  // Initialize convenient streams array
  m_streams[client2world] = m_client2WorldStream;
  m_streams[world2client] = m_world2ClientStream;
  m_streams[client2zone] = m_client2ZoneStream;
  m_streams[zone2client] = m_zone2ClientStream;

  // no client/server ports yet
  m_clientPort = 0;
  m_serverPort = 0;
  
  struct hostent *he;
  struct in_addr  ia;
  if (m_ip.isEmpty() && m_mac.isEmpty())
    seqFatal("No address specified");
  
  if (!m_ip.isEmpty())
  {
    /* Substitute "special" IP which is interpreted 
       to set up a different filter for picking up new sessions */
    
    if (m_ip == "auto")
      inet_aton (AUTOMATIC_CLIENT_IP, &ia);
    else if (inet_aton (m_ip, &ia) == 0)
    {
      he = gethostbyname(m_ip);
      if (!he)
	seqFatal("Invalid address; %s", (const char*)m_ip);

      memcpy (&ia, he->h_addr_list[0], he->h_length);
    }
    m_client_addr = ia.s_addr;
    m_ip = inet_ntoa(ia);
    
    if (m_ip ==  AUTOMATIC_CLIENT_IP)
    {
      m_detectingClient = true;
      seqInfo("Listening for first client seen.");
    }
    else
    {
      m_detectingClient = false;
      seqInfo("Listening for client: %s",
	      (const char*)m_ip);
    }
  }
  
  if (m_playbackPackets == PLAYBACK_OFF)
  {
    // create the pcap object and initialize, either with MAC or IP
    m_packetCapture = new PacketCaptureThread();
    if (m_mac.length() == 17)
      m_packetCapture->start(m_device, 
			     m_mac, 
			     m_realtime, MAC_ADDRESS_TYPE );
    else
      m_packetCapture->start(m_device,
			     m_ip, 
			     m_realtime, IP_ADDRESS_TYPE );
    emit filterChanged();
  }
  else if (m_playbackPackets == PLAYBACK_FORMAT_TCPDUMP)
  {
    // Create the pcap object and initialize with the file input given
    m_packetCapture = new PacketCaptureThread();

    const char* filename = 
      pSEQPrefs->getPrefString("Filename", "VPacket");

    m_packetCapture->startOffline(filename, m_playbackSpeed);
    seqInfo("Playing back packets from '%s' at speed '%d'", 
      filename, m_playbackSpeed);
  }

  // Flag session tracking properly on streams
  session_tracking(sessionTrackingFlag);

  // if running setuid root, then give up root access, since the PacketCapture
  // is the only thing that needed it.
  if ((geteuid() == 0) && (getuid() != geteuid()))
    setuid(getuid()); 

  /* Create timer object */
  m_timer = new QTimer (this);
  
  if (m_playbackPackets == PLAYBACK_OFF || 
          m_playbackPackets == PLAYBACK_FORMAT_TCPDUMP)
  {
    // Normal pcap packet handler
    connect (m_timer, SIGNAL (timeout ()), this, SLOT (processPackets ()));
  }
  else
  {
    // Special internal playback handler
    connect (m_timer, SIGNAL (timeout ()), this, SLOT (processPlaybackPackets ()));
  }
  
  /* setup VPacket */
  m_vPacket = NULL;
  
  QString section = "VPacket";
  // First param to VPacket is the filename
  // Second param is playback speed:  0 = fast as poss, 1 = 1X, 2 = 2X etc
  if (pSEQPrefs->isPreference("Filename", section))
  {
    const char *filename = pSEQPrefs->getPrefString("Filename", section);
    
    if (m_recordPackets)
    {
      m_vPacket = new VPacket(filename, 1, true);
      // Must appear befire next call to getPrefString, which uses a static string
      seqInfo("Recording packets to '%s' for future playback", filename);
      
      if (pSEQPrefs->getPrefBool("FlushPackets", section))
	m_vPacket->setFlushPacket(true);
    }
    else if (m_playbackPackets == PLAYBACK_FORMAT_SEQ)
    {
      m_vPacket = new VPacket(filename, 1, false);
      m_vPacket->setCompressTime(pSEQPrefs->getPrefInt("CompressTime", section, 0));
      m_vPacket->setPlaybackSpeed(m_playbackSpeed);
      
      seqInfo("Playing back packets from '%s' at speed '%d'", filename,
	     
	     m_playbackSpeed);
    }
  }
  else
  {
    m_recordPackets = 0;
    m_playbackPackets = PLAYBACK_OFF;
  }
}
예제 #7
0
파일: packet.cpp 프로젝트: xbackupx/showeqx
////////////////////////////////////////////////////
// Constructor
EQPacket::EQPacket (QObject * parent, const char *name)
  : QObject (parent, name),
    m_packetCapture(NULL),
    m_vPacket(NULL),
    m_timer(NULL),
    m_busy_decoding(false)
{
  // Setup the data streams

  // Setup client -> world stream
  m_client2WorldStream = new EQPacketStream(client2world, DIR_CLIENT, 
					    showeq_params->arqSeqGiveUp,
					    this, "client2world");
  connect(m_client2WorldStream, 
	  SIGNAL(rawPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(rawWorldPacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_client2WorldStream, 
	  SIGNAL(decodedPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(decodedWorldPacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_client2WorldStream, 
	  SIGNAL(dispatchData(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SLOT(dispatchWorldData(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_client2WorldStream, 
	  SIGNAL(cacheSize(int, int)),
	  this,
	  SIGNAL(cacheSize(int, int)));
  connect(m_client2WorldStream, 
	  SIGNAL(seqReceive(int, int)),
	  this,
	  SIGNAL(seqReceive(int, int)));
  connect(m_client2WorldStream, 
	  SIGNAL(seqExpect(int, int)),
	  this,
	  SIGNAL(seqExpect(int, int)));
  connect(m_client2WorldStream, 
	  SIGNAL(numPacket(int, int)),
	  this,
	  SIGNAL(numPacket(int, int)));
  
  // Setup world -> client stream
  m_world2ClientStream = new EQPacketStream(world2client, DIR_SERVER,
					    showeq_params->arqSeqGiveUp,
					    this, "world2client");
  connect(m_world2ClientStream, 
	  SIGNAL(rawPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(rawWorldPacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_world2ClientStream, 

 	  SIGNAL(decodedPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(decodedWorldPacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_world2ClientStream, 
	  SIGNAL(dispatchData(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SLOT(dispatchWorldData(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_world2ClientStream, 
	  SIGNAL(cacheSize(int, int)),
	  this,
	  SIGNAL(cacheSize(int, int)));
  connect(m_world2ClientStream, 
	  SIGNAL(seqReceive(int, int)),
	  this,
	  SIGNAL(seqReceive(int, int)));
  connect(m_world2ClientStream, 
	  SIGNAL(seqExpect(int, int)),
	  this,
	  SIGNAL(seqExpect(int, int)));
  connect(m_world2ClientStream, 
	  SIGNAL(numPacket(int, int)),
	  this,
	  SIGNAL(numPacket(int, int)));

  // Setup client -> zone stream
  m_client2ZoneStream = new EQPacketStream(client2zone, DIR_CLIENT,
					  showeq_params->arqSeqGiveUp,
					  this, "client2zone");
  connect(m_client2ZoneStream, 
	  SIGNAL(rawPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(rawZonePacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_client2ZoneStream, 
	  SIGNAL(decodedPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(decodedZonePacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_client2ZoneStream, 
	  SIGNAL(dispatchData(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SLOT(dispatchZoneData(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_client2ZoneStream, 
	  SIGNAL(cacheSize(int, int)),
	  this,
	  SIGNAL(cacheSize(int, int)));
  connect(m_client2ZoneStream, 
	  SIGNAL(seqReceive(int, int)),
	  this,
	  SIGNAL(seqReceive(int, int)));
  connect(m_client2ZoneStream, 
	  SIGNAL(seqExpect(int, int)),
	  this,
	  SIGNAL(seqExpect(int, int)));
  connect(m_client2ZoneStream, 
	  SIGNAL(numPacket(int, int)),
	  this,
	  SIGNAL(numPacket(int, int)));

  // Setup zone -> client stream
  m_zone2ClientStream = new EQPacketStream(zone2client, DIR_SERVER,
					   showeq_params->arqSeqGiveUp,
					   this, "zone2client");
  connect(m_zone2ClientStream, 
	  SIGNAL(rawPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(rawZonePacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_zone2ClientStream, 
	  SIGNAL(decodedPacket(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SIGNAL(decodedZonePacket(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_zone2ClientStream, 
	  SIGNAL(dispatchData(const uint8_t*, size_t, uint8_t, uint16_t)),
	  this,
	  SLOT(dispatchZoneData(const uint8_t*, size_t, uint8_t, uint16_t)));
  connect(m_zone2ClientStream, 
	  SIGNAL(cacheSize(int, int)),
	  this,
	  SIGNAL(cacheSize(int, int)));
  connect(m_zone2ClientStream, 
	  SIGNAL(seqReceive(int, int)),
	  this,
	  SIGNAL(seqReceive(int, int)));
  connect(m_zone2ClientStream, 
	  SIGNAL(seqExpect(int, int)),
	  this,
	  SIGNAL(seqExpect(int, int)));
  connect(m_zone2ClientStream, 
	  SIGNAL(numPacket(int, int)),
	  this,
	  SIGNAL(numPacket(int, int)));
  // Zone to client stream specific signals (session tracking non-sense)
  connect(m_zone2ClientStream, 
	  SIGNAL(sessionTrackingChanged(uint8_t)),
	  this,
	  SIGNAL(sessionTrackingChanged(uint8_t)));
  connect(m_zone2ClientStream, 
	  SIGNAL(lockOnClient(in_port_t, in_port_t)),
	  this,
	  SLOT(lockOnClient(in_port_t, in_port_t)));
  connect(m_zone2ClientStream, 
	  SIGNAL(closing()),
	  this,
	  SLOT(closeStream()));

  // Initialize convenient streams array
  m_streams[client2world] = m_client2WorldStream;
  m_streams[world2client] = m_world2ClientStream;
  m_streams[client2zone] = m_client2ZoneStream;
  m_streams[zone2client] = m_zone2ClientStream;

  // no client/server ports yet
  m_clientPort = 0;
  m_serverPort = 0;
  
  struct hostent *he;
  struct in_addr  ia;
  if (showeq_params->ip.isEmpty() && showeq_params->mac_address.isEmpty())
  {
    printf ("No address specified\n");
    exit(0);
  }
  
  if (!showeq_params->ip.isEmpty())
  {
    /* Substitute "special" IP which is interpreted 
       to set up a different filter for picking up new sessions */
    
    if (showeq_params->ip == "auto")
      inet_aton (AUTOMATIC_CLIENT_IP, &ia);
    else if (inet_aton (showeq_params->ip, &ia) == 0)
    {
      he = gethostbyname(showeq_params->ip);
      if (!he)
      {
	printf ("Invalid address; %s\n", (const char*)showeq_params->ip);
	exit (0);
      }
      memcpy (&ia, he->h_addr_list[0], he->h_length);
    }
    m_client_addr = ia.s_addr;
    showeq_params->ip = inet_ntoa(ia);
    
    if (showeq_params->ip ==  AUTOMATIC_CLIENT_IP)
    {
      m_detectingClient = true;
      printf("Listening for first client seen.\n");
    }
    else
    {
      m_detectingClient = false;
      printf("Listening for client: %s\n",
	     (const char*)showeq_params->ip);
    }
  }
  
  if (!showeq_params->playbackpackets)
  {
    // create the pcap object and initialize, either with MAC or IP
    m_packetCapture = new PacketCaptureThread();
    if (showeq_params->mac_address.length() == 17)
      m_packetCapture->start(showeq_params->device, 
			     showeq_params->mac_address, 
			     showeq_params->realtime, MAC_ADDRESS_TYPE );
    else
      m_packetCapture->start(showeq_params->device,
			     showeq_params->ip, 
			     showeq_params->realtime, IP_ADDRESS_TYPE );
    emit filterChanged();
  }
  
  /* Create timer object */
  m_timer = new QTimer (this);
  
  if (!showeq_params->playbackpackets)
    connect (m_timer, SIGNAL (timeout ()), this, SLOT (processPackets ()));
  else
    connect (m_timer, SIGNAL (timeout ()), this, SLOT (processPlaybackPackets ()));
  
  /* setup VPacket */
  m_vPacket = NULL;
  
  QString section = "VPacket";
  // First param to VPacket is the filename
  // Second param is playback speed:  0 = fast as poss, 1 = 1X, 2 = 2X etc
  if (pSEQPrefs->isPreference("Filename", section))
  {
    const char *filename = pSEQPrefs->getPrefString("Filename", section);
    
    if (showeq_params->recordpackets)
    {
      m_vPacket = new VPacket(filename, 1, true);
      // Must appear befire next call to getPrefString, which uses a static string
      printf("Recording packets to '%s' for future playback\n", filename);
      
      if (pSEQPrefs->getPrefString("FlushPackets", section))
	m_vPacket->setFlushPacket(true);
    }
    else if (showeq_params->playbackpackets)
    {
      m_vPacket = new VPacket(filename, 1, false);
      m_vPacket->setCompressTime(pSEQPrefs->getPrefInt("CompressTime", section, 0));
      m_vPacket->setPlaybackSpeed(showeq_params->playbackspeed);
      
      printf("Playing back packets from '%s' at speed '%d'\n", filename,
	     
	     showeq_params->playbackspeed);
    }
  }
  else
  {
    showeq_params->recordpackets = 0;
    showeq_params->playbackpackets = 0;
  }
}
예제 #8
0
/* =============================================================================
 * main
 * =============================================================================
 */
MAIN(argc, argv)
{
    GOTO_REAL();

    /*
     * Initialization
     */

    parseArgs(argc, (char** const)argv);
    long numThread = global_params[PARAM_THREAD];
    SIM_GET_NUM_CPU(numThread);
    TM_STARTUP(numThread);
    P_MEMORY_STARTUP(numThread);
    thread_startup(numThread);

    long percentAttack = global_params[PARAM_ATTACK];
    long maxDataLength = global_params[PARAM_LENGTH];
    long numFlow       = global_params[PARAM_NUM];
    long randomSeed    = global_params[PARAM_SEED];
    printf("Percent attack  = %li\n", percentAttack);
    printf("Max data length = %li\n", maxDataLength);
    printf("Num flow        = %li\n", numFlow);
    printf("Random seed     = %li\n", randomSeed);

    dictionary_t* dictionaryPtr = dictionary_alloc();
    assert(dictionaryPtr);
    stream_t* streamPtr = stream_alloc(percentAttack);
    assert(streamPtr);
    long numAttack = stream_generate(streamPtr,
                                     dictionaryPtr,
                                     numFlow,
                                     randomSeed,
                                     maxDataLength);
    printf("Num attack      = %li\n", numAttack);

    decoder_t* decoderPtr = decoder_alloc();
    assert(decoderPtr);

    vector_t** errorVectors = (vector_t**)malloc(numThread * sizeof(vector_t*));
    assert(errorVectors);
    long i;
    for (i = 0; i < numThread; i++) {
        vector_t* errorVectorPtr = vector_alloc(numFlow);
        assert(errorVectorPtr);
        errorVectors[i] = errorVectorPtr;
    }

    arg_t arg;
    arg.streamPtr    = streamPtr;
    arg.decoderPtr   = decoderPtr;
    arg.errorVectors = errorVectors;

    /*
     * Run transactions
     */

    TIMER_T startTime;
    TIMER_READ(startTime);
    GOTO_SIM();
#ifdef OTM
#pragma omp parallel
    {
        processPackets((void*)&arg);
    }
    
#else
    thread_start(processPackets, (void*)&arg);
#endif
    GOTO_REAL();
    TIMER_T stopTime;
    TIMER_READ(stopTime);
    printf("\nTime = %lf\n", TIMER_DIFF_SECONDS(startTime, stopTime));

    /*
     * Check solution
     */

    /*long numFound = 0;
    for (i = 0; i < numThread; i++) {
        vector_t* errorVectorPtr = errorVectors[i];
        long e;
        long numError = vector_getSize(errorVectorPtr);
        numFound += numError;
        for (e = 0; e < numError; e++) {
            long flowId = (long)vector_at(errorVectorPtr, e);
            bool_t status = stream_isAttack(streamPtr, flowId);
            assert(status);
        }
    }*/
    /*printf("Num found       = %li\n", numFound);
    assert(numFound == numAttack);*/

    /*
     * Clean up
     */

    for (i = 0; i < numThread; i++) {
        vector_free(errorVectors[i]);
    }
    free(errorVectors);
    decoder_free(decoderPtr);
    stream_free(streamPtr);
    dictionary_free(dictionaryPtr);

    TM_SHUTDOWN();
    P_MEMORY_SHUTDOWN();

    GOTO_SIM();

    thread_shutdown();

    MAIN_RETURN(0);
}
예제 #9
0
void Lobby::timepass()
{
	processPackets();
}