Miroirs/xwords
1
0
Fork 0
mirror of git://xwords.git.sourceforge.net/gitroot/xwords/xwords synced 2024-12-28 09:58:30 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
xwords/xwords4/relay/cref.cpp

1248 lines
34 KiB
C++
Raw Normal View History

first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
/* -*-mode: C; fill-column: 78; c-basic-offset: 4; -*- */
add mutexes; general improvements
2005-03-25 03:59:44 +01:00
/*
up copyright
2009-07-30 14:54:17 +02:00
* Copyright 2005-2009 by Eric House (xwords@eehouse.org). All rights
* reserved.
add mutexes; general improvements
2005-03-25 03:59:44 +01:00
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
#include <string>
#include <map>
#include <assert.h>
add mutexes; general improvements
2005-03-25 03:59:44 +01:00
#include <pthread.h>
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
#include <netinet/in.h>
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
#include <stdarg.h>
include stdio.h for freebsd
2006-03-21 05:05:33 +01:00
#include <stdio.h>
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
#include <string.h>
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
#include "cref.h"
#include "xwrelay.h"
add mutexes; general improvements
2005-03-25 03:59:44 +01:00
#include "mlock.h"
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
#include "tpool.h"
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
#include "states.h"
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
#include "timermgr.h"
#include "configs.h"
#include "crefmgr.h"
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
#include "permid.h"
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
using namespace std;
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
/*****************************************************************************
* SocketsIterator class
*****************************************************************************/
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
SocketsIterator::SocketsIterator( SocketMap::iterator iter,
SocketMap::iterator end,
Assign 0 not NULL to pthread variables.
2009-07-31 14:43:04 +02:00
pthread_mutex_t* mutex )
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
: m_iter( iter )
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
, m_end( end )
Assign 0 not NULL to pthread variables.
2009-07-31 14:43:04 +02:00
, m_mutex( mutex )
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
{
}
SocketsIterator::~SocketsIterator()
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
{
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
pthread_mutex_unlock( m_mutex );
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
}
int
SocketsIterator::Next()
{
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
int socket = 0;
if ( m_iter != m_end ) {
socket = m_iter->first;
++m_iter;
}
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
return socket;
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
}
/*****************************************************************************
* CookieRef class
*****************************************************************************/
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
#define ASSERT_LOCKED() \
assert( m_locking_thread == pthread_self() )
void
CookieRef::ReInit( const char* cookie, const char* connName, CookieID id )
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
{
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
m_cookie = cookie==NULL?"":cookie;
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
m_connName = connName==NULL?"":connName;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
m_cookieID = id;
m_totalSent = 0;
m_curState = XWS_INITED;
m_nextHostID = HOST_ID_SERVER;
variable name change only (for clarity)
2009-08-13 14:59:55 +02:00
m_nPlayersSought = 0;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
m_nPlayersHere = 0;
Assign 0 not NULL to pthread variables.
2009-07-31 14:43:04 +02:00
m_locking_thread = 0;
track per-cref lifetime and display it via http
2009-07-28 07:41:15 +02:00
m_starttime = uptime();
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
m_gameFull = false;
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
m_nHostMsgs = 0;
Remove on case where HandleEvents was being called recursively and creating unexpected state transitions; add assert to catch any future recursion.
2009-11-09 06:30:42 +01:00
m_in_handleEvents = false;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
Change config class from having a method for every configurable value to returing values for string keys so adding a new config doesn't mean modifying that class. Then add new config for addr passed to bind so relay can be run to accept http connections from remote machines.
2009-03-02 02:50:14 +01:00
RelayConfigs::GetConfigs()->GetValueFor( "HEARTBEAT", &m_heatbeat );
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
logf( XW_LOGINFO, "initing cref for cookie %s, connName %s",
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
m_cookie.c_str(), m_connName.c_str() );
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
}
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
CookieRef::CookieRef( const char* cookie, const char* connName, CookieID id )
{
pthread_mutex_init( &m_mutex, NULL );
ReInit( cookie, connName, id );
}
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
CookieRef::~CookieRef()
{
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
cancelAllConnectedTimer();
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
/* get rid of any sockets still contained */
XWThreadPool* tPool = XWThreadPool::GetTPool();
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
int socket = iter->m_socket;
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
tPool->CloseSocket( socket );
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
m_sockets.erase( iter );
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
}
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
logf( XW_LOGINFO,
"CookieRef for %d being deleted; sent %d bytes over lifetime",
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
m_cookieID, m_totalSent );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
} /* ~CookieRef */
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
void
CookieRef::Clear(void)
{
m_cookie = "";
m_connName = "";
m_cookieID = 0;
m_eventQueue.clear();
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
if ( 0 < m_nHostMsgs ) {
unsigned int ii;
for ( ii = 0; ii < sizeof(m_hostMsgQueues)/sizeof(m_hostMsgQueues[0]);++ii){
m_hostMsgQueues[ii].clear();
}
/* m_nHostMsgs will get cleared in ReInit */
}
} /* Clear */
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
bool
CookieRef::Lock( void )
{
bool success = true;
pthread_mutex_lock( &m_mutex );
/* We get here possibly after having been blocked on the mutex for a
while. This cref may no longer be live. If it's not, unlock and
return. */
assert( m_locking_thread == 0 );
m_locking_thread = pthread_self();
if ( notInUse() ) {
Assign 0 not NULL to pthread variables.
2009-07-31 14:43:04 +02:00
logf( XW_LOGINFO, "%s: not locking %p because not in use", __func__,
this );
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
success = false;
Assign 0 not NULL to pthread variables.
2009-07-31 14:43:04 +02:00
m_locking_thread = 0;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
pthread_mutex_unlock( &m_mutex );
}
return success;
} /* CookieRef::Lock */
void
CookieRef::Unlock() {
assert( m_locking_thread == pthread_self() );
Assign 0 not NULL to pthread variables.
2009-07-31 14:43:04 +02:00
m_locking_thread = 0;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
pthread_mutex_unlock( &m_mutex );
}
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
bool
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
CookieRef::_Connect( int socket, HostID hid, int nPlayersH, int nPlayersS,
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
int seed )
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
{
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
bool connected = false;
Attempt to detect connections that are duplicates by checking if that socket is already in a connection. This doesn't seem to always work, and I may be leaking cref instances when it does, so needs debugging still.
2009-02-01 17:00:20 +01:00
if ( CRefMgr::Get()->Associate( socket, this ) ) {
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
if ( hid == HOST_ID_NONE ) {
shorten column headings; don't assign cid until game is full.
2009-09-17 05:42:12 +02:00
logf( XW_LOGINFO, "%s: Waiting to assign host id", __func__ );
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
} else {
logf( XW_LOGINFO, "NOT assigned host id; why?" );
}
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
pushConnectEvent( socket, hid, nPlayersH, nPlayersS, seed );
Attempt to detect connections that are duplicates by checking if that socket is already in a connection. This doesn't seem to always work, and I may be leaking cref instances when it does, so needs debugging still.
2009-02-01 17:00:20 +01:00
handleEvents();
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
connected = HasSocket_locked( socket );
Attempt to detect connections that are duplicates by checking if that socket is already in a connection. This doesn't seem to always work, and I may be leaking cref instances when it does, so needs debugging still.
2009-02-01 17:00:20 +01:00
} else {
logf( XW_LOGINFO, "dropping connect event; already connected" );
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
}
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
return connected;
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
}
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
CookieRef::_Reconnect( int socket, HostID hid, int nPlayersH, int nPlayersS,
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
int seed )
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
{
Attempt to detect connections that are duplicates by checking if that socket is already in a connection. This doesn't seem to always work, and I may be leaking cref instances when it does, so needs debugging still.
2009-02-01 17:00:20 +01:00
(void)CRefMgr::Get()->Associate( socket, this );
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
pushReconnectEvent( socket, hid, nPlayersH, nPlayersS, seed );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
handleEvents();
}
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
void
CookieRef::_Disconnect( int socket, HostID hostID )
{
Attempt to detect connections that are duplicates by checking if that socket is already in a connection. This doesn't seem to always work, and I may be leaking cref instances when it does, so needs debugging still.
2009-02-01 17:00:20 +01:00
logf( XW_LOGINFO, "%s(socket=%d, hostID=%d)", __func__, socket, hostID );
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
CRefMgr::Get()->Disassociate( socket, this );
CRefEvent evt;
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
evt.type = XWE_DISCONN;
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
evt.u.discon.socket = socket;
evt.u.discon.srcID = hostID;
m_eventQueue.push_back( evt );
handleEvents();
}
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
void
CookieRef::_Shutdown()
{
CRefEvent evt;
evt.type = XWE_SHUTDOWN;
m_eventQueue.push_back( evt );
handleEvents();
} /* _Shutdown */
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
int
CookieRef::SocketForHost( HostID dest )
{
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
int socket = -1;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::const_iterator iter;
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
assert( dest != 0 ); /* don't use as lookup before assigned */
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_hostID == dest ) {
socket = iter->m_socket;
break;
}
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
}
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
logf( XW_LOGVERBOSE0, "returning socket=%d for hostid=%x", socket, dest );
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
return socket;
}
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
/* The idea here is: have we never seen the XW_ST_ALLCONNECTED state. This
needs to include any states reachable from XW_ST_ALLCONNECTED from which
recovery back to XW_ST_ALLCONNECTED is possible. This is used to decide
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
whether to admit a connection based on its cookie -- whether that coookie
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
should join an existing cref or get a new one? */
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
bool
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
CookieRef::NeverFullyConnected()
{
rename state to take up less space in browser; add number of respawns to status display.
2009-07-29 06:25:21 +02:00
return m_curState != XWS_ALLCONND
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
&& m_curState != XWS_MISSING;
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
}
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
bool
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
CookieRef::GameOpen( const char* cookie, bool isNew,
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
bool* alreadyHere )
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
{
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
bool accept = false;
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
*alreadyHere = false;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
/* First, do we have room. Second, are we missing this guy? */
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
if ( isNew && m_gameFull ) {
/* do nothing; reject */
logf( XW_LOGINFO, "reject: game for %s is full", cookie );
} else if ( m_curState != XWS_INITED
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
&& m_curState != XWS_WAITGUESTS
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
&& m_curState != XWS_MISSING ) {
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
/* do nothing; reject */
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
logf( XW_LOGINFO, "reject: bad state %s", stateString(m_curState) );
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
} else {
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
accept = true;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
}
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
/* Error to connect if cookie doesn't match. */
if ( accept && !!cookie && 0 != strcmp( cookie, Cookie() ) ) {
logf( XW_LOGERROR, "%s: not accepting b/c cookie mismatch: %s vs %s",
__func__, cookie, Cookie() );
accept = false;
}
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
return accept;
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
} /* GameOpen */
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
void
CookieRef::notifyDisconn( const CRefEvent* evt )
{
int socket = evt->u.disnote.socket;
when one device is disconnected for heartbeat, tell others it's going away.
2005-09-03 17:41:17 +02:00
unsigned char buf[] = {
XWRELAY_DISCONNECT_YOU,
evt->u.disnote.why
};
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
send_with_length( socket, buf, sizeof(buf), true );
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
} /* notifyDisconn */
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
void
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
CookieRef::removeSocket( int socket )
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
{
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
logf( XW_LOGINFO, "%s(socket=%d)", __func__, socket );
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
int count;
{
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
count = m_sockets.size();
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
if ( count > 0 ) {
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_socket == socket ) {
m_sockets.erase(iter);
--count;
break;
}
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
}
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
} else {
logf( XW_LOGERROR, "%s: no socket %d to remove", __func__, socket );
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
}
}
add mutexes; general improvements
2005-03-25 03:59:44 +01:00
if ( count == 0 ) {
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
pushLastSocketGoneEvent();
add mutexes; general improvements
2005-03-25 03:59:44 +01:00
}
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
} /* removeSocket */
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
bool
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
CookieRef::HasSocket( int socket )
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
{
bool result = Lock();
if ( result ) {
result = HasSocket_locked( socket );
Unlock();
}
return result;
}
bool
CookieRef::HasSocket_locked( int socket )
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
{
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
bool found = false;
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_socket == socket ) {
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
found = true;
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
break;
}
}
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
return found;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
} /* HasSocket_locked */
first checked in. primative, but works.
2005-03-19 23:14:27 +01:00
Make cooperation in a heartbeat scheme a compile-time option. This is meant to allow comms to take over heartbeats.
2007-11-19 00:38:56 +01:00
#ifdef RELAY_HEARTBEAT
heartbeats: send to clients in connection response; note when heartbeat and other messages arrive; and periodically reap sockets that haven't been active in long enough.
2005-06-23 06:26:44 +02:00
void
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
CookieRef::_HandleHeartbeat( HostID id, int socket )
heartbeats: send to clients in connection response; note when heartbeat and other messages arrive; and periodically reap sockets that haven't been active in long enough.
2005-06-23 06:26:44 +02:00
{
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
pushHeartbeatEvent( id, socket );
handleEvents();
} /* HandleHeartbeat */
void
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
CookieRef::_CheckHeartbeats( time_t now )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
logf( XW_LOGINFO, "%s", __func__ );
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
time_t last = iter->m_lastHeartbeat;
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
if ( (now - last) > GetHeartbeat() ) {
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
pushHeartFailedEvent( iter->m_socket );
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
}
}
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
handleEvents();
} /* CheckHeartbeats */
Make cooperation in a heartbeat scheme a compile-time option. This is meant to allow comms to take over heartbeats.
2007-11-19 00:38:56 +01:00
#endif
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
CookieRef::_Forward( HostID src, HostID dest, unsigned char* buf, int buflen )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
pushForwardEvent( src, dest, buf, buflen );
handleEvents();
} /* Forward */
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
CookieRef::_Remove( int socket )
{
pushRemoveSocketEvent( socket );
handleEvents();
} /* Forward */
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
CookieRef::pushConnectEvent( int socket, HostID srcID,
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
int nPlayersH, int nPlayersS,
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
int seed )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
CRefEvent evt;
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
evt.type = nPlayersS == 0? XWE_GUESTCONNECT : XWE_HOSTCONNECT;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
evt.u.con.socket = socket;
evt.u.con.srcID = srcID;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
evt.u.con.nPlayersH = nPlayersH;
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
evt.u.con.nPlayersS = nPlayersS;
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
evt.u.con.seed = seed;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( evt );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
} /* pushConnectEvent */
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
CookieRef::pushReconnectEvent( int socket, HostID srcID, int nPlayersH,
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
int nPlayersS, int seed )
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
{
CRefEvent evt;
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
evt.type = XWE_RECONNECT;
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
evt.u.con.socket = socket;
evt.u.con.srcID = srcID;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
evt.u.con.nPlayersH = nPlayersH;
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
evt.u.con.nPlayersS = nPlayersS;
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
evt.u.con.seed = seed;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( evt );
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
} /* pushReconnectEvent */
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
Make cooperation in a heartbeat scheme a compile-time option. This is meant to allow comms to take over heartbeats.
2007-11-19 00:38:56 +01:00
#ifdef RELAY_HEARTBEAT
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
CookieRef::pushHeartbeatEvent( HostID id, int socket )
{
CRefEvent evt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
evt.type = XWE_HEARTRCVD;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
evt.u.heart.id = id;
evt.u.heart.socket = socket;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( evt );
}
void
CookieRef::pushHeartFailedEvent( int socket )
{
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
logf( XW_LOGINFO, "%s", __func__ );
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
CRefEvent evt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
evt.type = XWE_HEARTFAILED;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
evt.u.heart.socket = socket;
m_eventQueue.push_back( evt );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
}
Make cooperation in a heartbeat scheme a compile-time option. This is meant to allow comms to take over heartbeats.
2007-11-19 00:38:56 +01:00
#endif
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
CookieRef::pushForwardEvent( HostID src, HostID dest,
unsigned char* buf, int buflen )
{
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
logf( XW_LOGVERBOSE1, "pushForwardEvent: %d -> %d", src, dest );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
CRefEvent evt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
evt.type = XWE_FORWARDMSG;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
evt.u.fwd.src = src;
evt.u.fwd.dest = dest;
evt.u.fwd.buf = buf;
evt.u.fwd.buflen = buflen;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( evt );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
}
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
CookieRef::pushRemoveSocketEvent( int socket )
{
CRefEvent evt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
evt.type = XWE_REMOVESOCKET;
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
evt.u.rmsock.socket = socket;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( evt );
}
void
CookieRef::pushNotifyDisconEvent( int socket, XWREASON why )
{
CRefEvent evt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
evt.type = XWE_NOTIFYDISCON;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
evt.u.disnote.socket = socket;
evt.u.disnote.why = why;
m_eventQueue.push_back( evt );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
void
CookieRef::pushLastSocketGoneEvent()
{
CRefEvent evt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
evt.type = XWE_NOMORESOCKETS;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( evt );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
void
CookieRef::checkHaveRoom( const CRefEvent* evt )
{
CRefEvent newEvt;
assert ( m_nPlayersSought > 0 );
if ( m_nPlayersSought < m_nPlayersHere + evt->u.con.nPlayersH ) {
newEvt.type = XWE_TOO_MANY;
newEvt.u.rmsock.socket = evt->u.con.socket;
} else {
newEvt = *evt;
newEvt.type = XWE_HAVE_ROOM;
}
m_eventQueue.push_back( newEvt );
}
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
CookieRef::handleEvents()
{
Remove on case where HandleEvents was being called recursively and creating unexpected state transitions; add assert to catch any future recursion.
2009-11-09 06:30:42 +01:00
assert( !m_in_handleEvents );
m_in_handleEvents = true;
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
/* Assumption: has mutex!!!! */
while ( m_eventQueue.size () > 0 ) {
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
XW_RELAY_STATE nextState;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
CRefEvent evt = m_eventQueue.front();
m_eventQueue.pop_front();
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
XW_RELAY_ACTION takeAction;
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
if ( getFromTable( m_curState, evt.type, &takeAction, &nextState ) ) {
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
initialize mutex before using; fixes a hang since could never aquire lock. (This bug has always been there, but didn't matter before; maybe pthreads changed.) Comment out self-spawning stuff until can fix df-transfer problems. Other minor changes around logging.
2007-02-06 06:52:22 +01:00
logf( XW_LOGINFO, "%s: %s -> %s on evt %s, act=%s", __func__,
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
stateString(m_curState), stateString(nextState),
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
eventString(evt.type), actString(takeAction) );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
switch( takeAction ) {
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
case XWA_CHECK_HAVE_ROOM:
checkHaveRoom( &evt );
break;
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
case XWA_SEND_HOST_RSP:
case XWA_SEND_GUEST_RSP:
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_SEND_1ST_RERSP:
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
if ( increasePlayerCounts( &evt, false ) ) {
setAllConnectedTimer();
sendResponse( &evt, takeAction != XWA_SEND_1ST_RERSP );
}
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_SEND_RERSP:
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
if ( increasePlayerCounts( &evt, true ) ) {
sendResponse( &evt, false );
sendAnyStored( &evt );
}
break;
case XWA_SEND_NO_ROOM:
send_denied( &evt, XWRELAY_ERROR_NO_ROOM );
removeSocket( evt.u.rmsock.socket );
break;
case XWA_SEND_DUP_ROOM:
send_denied( &evt, XWRELAY_ERROR_DUP_ROOM );
removeSocket( evt.u.rmsock.socket );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
break;
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
case XWA_SEND_TOO_MANY:
send_denied( &evt, XWRELAY_ERROR_TOO_MANY );
removeSocket( evt.u.rmsock.socket );
break;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_FWD:
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
forward_or_store( &evt );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_TIMERDISCONN:
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
disconnectSockets( 0, XWRELAY_ERROR_TIMEOUT );
break;
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
case XWA_SHUTDOWN:
disconnectSockets( 0, XWRELAY_ERROR_SHUTDOWN );
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_HEARTDISCONN:
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
notifyOthers( evt.u.heart.socket, XWRELAY_DISCONNECT_OTHER,
XWRELAY_ERROR_HEART_OTHER );
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
setAllConnectedTimer();
reducePlayerCounts( evt.u.discon.socket );
when one device is disconnected for heartbeat, tell others it's going away.
2005-09-03 17:41:17 +02:00
disconnectSockets( evt.u.heart.socket,
XWRELAY_ERROR_HEART_YOU );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_DISCONNECT:
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
setAllConnectedTimer();
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
reducePlayerCounts( evt.u.discon.socket );
Send notification when device disconnnects without closing socket (in addition to the existing one sent when a socket is closed).
2009-09-20 20:47:47 +02:00
notifyOthers( evt.u.discon.socket, XWRELAY_DISCONNECT_OTHER,
XWRELAY_ERROR_OTHER_DISCON );
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
removeSocket( evt.u.discon.socket );
/* Don't notify. This is a normal part of a game ending. */
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_NOTEHEART:
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
noteHeartbeat( &evt );
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_NOTIFYDISCON:
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
notifyDisconn( &evt );
break;
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
case XWA_REMOVESOCK_2:
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
setAllConnectedTimer();
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
/* fallthru */
case XWA_REMOVESOCK_1:
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
reducePlayerCounts( evt.u.rmsock.socket );
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
if ( XWA_REMOVESOCK_2 == takeAction ) {
notifyOthers( evt.u.rmsock.socket, XWRELAY_DISCONNECT_OTHER,
XWRELAY_ERROR_LOST_OTHER );
}
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
removeSocket( evt.u.rmsock.socket );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_SENDALLHERE:
cancel all-connected timer when all are connected
2005-10-15 18:35:18 +02:00
cancelAllConnectedTimer();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
assignHostIds();
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
assignConnName();
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
sendAllHere( true );
break;
case XWA_SNDALLHERE_2:
sendAllHere( false );
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
break;
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
case XWA_NOTE_EMPTY:
Remove on case where HandleEvents was being called recursively and creating unexpected state transitions; add assert to catch any future recursion.
2009-11-09 06:30:42 +01:00
cancelAllConnectedTimer();
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
if ( 0 == count_msgs_stored() ) {
CRefEvent evt;
evt.type = XWE_NOMOREMSGS;
m_eventQueue.push_back( evt );
}
break;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
case XWA_NONE:
fix bug where client connecting before server would result in attempt to forward packet to host not yet available. Drop such packets now.
2005-08-02 06:57:13 +02:00
/* nothing to do for these */
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
break;
default:
assert(0);
break;
}
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
m_curState = nextState;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
}
}
Remove on case where HandleEvents was being called recursively and creating unexpected state transitions; add assert to catch any future recursion.
2009-11-09 06:30:42 +01:00
m_in_handleEvents = false;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
} /* handleEvents */
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
bool
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
CookieRef::send_with_length( int socket, unsigned char* buf, int bufLen,
bool cascade )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
bool failed = false;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
if ( send_with_length_unsafe( socket, buf, bufLen ) ) {
RecordSent( bufLen, socket );
} else {
failed = true;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
}
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
if ( failed && cascade ) {
Remove on case where HandleEvents was being called recursively and creating unexpected state transitions; add assert to catch any future recursion.
2009-11-09 06:30:42 +01:00
pushRemoveSocketEvent( socket );
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
XWThreadPool::GetTPool()->CloseSocket( socket );
}
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
return !failed;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
} /* send_with_length */
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
static void
putNetShort( unsigned char** bufpp, unsigned short s )
{
s = htons( s );
memcpy( *bufpp, &s, sizeof(s) );
*bufpp += sizeof(s);
}
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
void
CookieRef::store_message( HostID dest, const unsigned char* buf,
unsigned int len )
{
logf( XW_LOGVERBOSE0, "%s: storing msg size %d for dest %d", __func__,
len, dest );
assert( dest > 0 );
--dest; // 1-based
MsgBuffer* entry = new MsgBuffer( buf, buf+len );
assert( dest < sizeof(m_hostMsgQueues)/sizeof(m_hostMsgQueues[0]) );
m_hostMsgQueues[dest].push_back( entry );
++m_nHostMsgs;
}
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
void
CookieRef::send_stored_messages( HostID dest, int socket )
{
assert( dest > 0 );
logf( XW_LOGVERBOSE0, "%s(dest=%d)", __func__, dest );
--dest; // 0 is invalid value
assert( dest < sizeof(m_hostMsgQueues)/sizeof(m_hostMsgQueues[0]) );
assert( -1 != socket );
MsgBufQueue& mqueue = m_hostMsgQueues[dest];
while ( mqueue.size() > 0 ) {
assert( m_nHostMsgs > 0 );
// send_with_length will call _Remove if it fails to send. So
// need to check on presence of socket each time through! No,
// the break below takes care of that.
MsgBufQueue::iterator iter = mqueue.begin();
logf( XW_LOGVERBOSE0, "%s: sending stored msg (len=%d)",
__func__, (*iter)->size() );
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
if ( ! send_with_length( socket, &((**iter)[0]), (*iter)->size(),
true ) ) {
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
break;
}
mqueue.erase( iter );
delete *iter;
--m_nHostMsgs;
}
} /* send_stored_messages */
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
bool
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
CookieRef::increasePlayerCounts( const CRefEvent* evt, bool reconn )
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
{
int nPlayersH = evt->u.con.nPlayersH;
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
int nPlayersS = evt->u.con.nPlayersS;
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
int socket = evt->u.con.socket;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
HostID hid = evt->u.con.srcID;
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
int seed = evt->u.con.seed;
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
CRefEvent newevt;
bool addHost = true;
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
assert( hid <= 4 );
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
newevt.type = XWE_NONE;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
logf( XW_LOGINFO, "%s: hid=%d, nPlayersH=%d, "
"nPlayersS=%d", __func__, hid, nPlayersH, nPlayersS );
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
ASSERT_LOCKED();
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
/* Add the players provided by this [re]connect event to the cref after
performing sanity checks. If this is an initial connect, then the host
should be added first. If it's a recon, any order is possible. In no
circumstances should the number of players present exceed the number
sought (if known.) Currently some of this stuff is asserted. Instead
when bad values are seen the sender should be notified then
disconnencted. On the host side the error message should probably
recommend a new game as things must be pretty f*cked up. Or somebody's
mucking with me. */
if ( reconn ) {
if ( nPlayersS > 0 ) {
assert( 0 == m_nPlayersSought );
m_nPlayersSought = nPlayersS;
}
m_nPlayersHere += nPlayersH;
assert( 0 == m_nPlayersSought || m_nPlayersHere <= m_nPlayersSought );
if ( m_nPlayersHere == m_nPlayersSought ) {
newevt.type = XWE_ALLHERE;
} else {
newevt.type = XWE_SOMEMISSING;
}
} else if ( nPlayersS > 0 ) { /* a host; init values */
assert( m_nPlayersSought == 0 );
assert( m_nPlayersHere == 0 );
m_nPlayersHere = nPlayersH;
m_nPlayersSought = nPlayersS;
} else { /* a guest */
assert( reconn || m_nPlayersSought != 0 ); /* host better be here */
if ( m_nPlayersSought < m_nPlayersHere + nPlayersH ) { /* too many;
reject */
newevt.type = XWE_TOO_MANY;
addHost = false;
} else {
m_nPlayersHere += nPlayersH;
if ( m_nPlayersHere == m_nPlayersSought ) { /* complete! */
newevt.type = XWE_ALLHERE;
m_gameFull = true;
} else {
newevt.type = XWE_SOMEMISSING;
}
}
}
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
if ( newevt.type != XWE_NONE ) {
m_eventQueue.push_back( newevt );
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
}
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
if ( addHost ) {
/* first add the rec here, whether it'll stay for not */
logf( XW_LOGINFO, "%s: remembering pair: hostid=%x, "
"socket=%d (size=%d)",
__func__, hid, socket, m_sockets.size());
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
HostRec hr( hid, socket, nPlayersH, nPlayersS, seed );
m_sockets.push_back( hr );
logf( XW_LOGVERBOSE1, "%s: here=%d; total=%d", __func__,
m_nPlayersHere, m_nPlayersSought );
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
}
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
return addHost;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
} /* increasePlayerCounts */
void
CookieRef::reducePlayerCounts( int socket )
{
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
logf( XW_LOGVERBOSE1, "reducePlayerCounts on socket %d", socket );
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_socket == socket ) {
if ( iter->m_hostID == HOST_ID_SERVER ) {
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
m_nPlayersSought -= iter->m_nPlayersS;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
} else {
change varible names; remove instance variable than can be on the stack.
2009-11-01 02:38:03 +01:00
assert( iter->m_nPlayersS == 0 );
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
}
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
m_nPlayersHere -= iter->m_nPlayersH;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
variable name change only (for clarity)
2009-08-13 14:59:55 +02:00
logf( XW_LOGVERBOSE1, "reducePlayerCounts: m_nPlayersHere=%d; m_nPlayersSought=%d",
m_nPlayersHere, m_nPlayersSought );
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
break;
}
}
} /* reducePlayerCounts */
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
CookieRef::setAllConnectedTimer()
{
time_t inHowLong;
Don't require a timeout waiting for a game to connect initially, and make no timeout the default.
2009-12-27 19:17:24 +01:00
if ( RelayConfigs::GetConfigs()->GetValueFor( "ALLCONN", &inHowLong ) ) {
TimerMgr::GetTimerMgr()->SetTimer( inHowLong,
s_checkAllConnected, this, 0 );
}
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
void
CookieRef::cancelAllConnectedTimer()
{
capitalize public methods on timermgr (no code change)
2005-10-15 17:49:22 +02:00
TimerMgr::GetTimerMgr()->ClearTimer( s_checkAllConnected, this );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
replace int with bool where appropriate; fix to compile with newer g++
2008-12-30 06:13:30 +01:00
CookieRef::sendResponse( const CRefEvent* evt, bool initial )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
int socket = evt->u.con.socket;
/* Now send the response */
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
unsigned char buf[1 /* cmd */
+ sizeof(short) /* heartbeat */
+ sizeof(short) /* total here */
+ sizeof(short) /* total expected */
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
];
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
unsigned char* bufp = buf;
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
*bufp++ = initial ? XWRELAY_CONNECT_RESP : XWRELAY_RECONNECT_RESP;
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
putNetShort( &bufp, GetHeartbeat() );
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
*bufp++ = GetPlayersSought();
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
*bufp++ = GetPlayersHere();
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
send_with_length( socket, buf, bufp - buf, true );
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
logf( XW_LOGVERBOSE0, "sent %s", cmdToStr( XWRELAY_Cmd(buf[0]) ) );
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
} /* sendResponse */
void
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
CookieRef::sendAnyStored( const CRefEvent* evt )
{
HostID dest = evt->u.con.srcID;
if ( HOST_ID_NONE != dest ) {
send_stored_messages( dest, evt->u.con.socket );
}
}
void
CookieRef::forward_or_store( const CRefEvent* evt )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
unsigned char* buf = evt->u.fwd.buf;
int buflen = evt->u.fwd.buflen;
HostID dest = evt->u.fwd.dest;
int destSocket = SocketForHost( dest );
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
/* This is an ugly hack!!!! */
*buf = XWRELAY_MSG_FROMRELAY;
if ( (destSocket == -1)
|| !send_with_length( destSocket, buf, buflen, true ) ) {
store_message( dest, buf, buflen );
}
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
/* also note that we've heard from src recently */
Make cooperation in a heartbeat scheme a compile-time option. This is meant to allow comms to take over heartbeats.
2007-11-19 00:38:56 +01:00
#ifdef RELAY_HEARTBEAT
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
HostID src = evt->u.fwd.src;
pushHeartbeatEvent( src, SocketForHost(src) );
Make cooperation in a heartbeat scheme a compile-time option. This is meant to allow comms to take over heartbeats.
2007-11-19 00:38:56 +01:00
#endif
Add limited support for store-and-forward (where limitations include that all devices must be connected initially and that it's all memory based so a crash wipes stored messages.) Accept messages for forwarding when in the MISSING state, not just the ALLHERE state. Store messages that can't be sent now, and send any that have accumulated when a host reconnects. When a cref loses its last connection, keep it around unless it has no messages stored (as will be the case when a game ends.)
2009-11-08 22:35:39 +01:00
} /* forward_or_store */
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
void
CookieRef::send_denied( const CRefEvent* evt, XWREASON why )
{
denyConnection( evt->u.con.socket, why );
}
when one device is disconnected for heartbeat, tell others it's going away.
2005-09-03 17:41:17 +02:00
void
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
CookieRef::send_msg( int socket, HostID id, XWRelayMsg msg, XWREASON why,
bool cascade )
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
{
unsigned char buf[10];
short tmp;
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
unsigned int len = 0;
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
buf[len++] = msg;
switch ( msg ) {
case XWRELAY_DISCONNECT_OTHER:
buf[len++] = why;
tmp = htons( id );
memcpy( &buf[len], &tmp, 2 );
len += 2;
break;
default:
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
logf( XW_LOGINFO, "not handling message %d", msg );
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
assert(0);
}
Don't use unitialized variables (thanks valgrind :-)
2009-04-05 20:47:45 +02:00
assert( len <= sizeof(buf) );
Include number of games played in html output; don't report closed sockets found while reporting closed sockets (to avoid deadlock); remove sockets from crefmgr's map when closing them so new connections using same (re-used) socket aren't treated as belonging to open games.
2009-07-06 03:50:51 +02:00
send_with_length( socket, buf, len, cascade );
generate XWRELAY_OTHERCONNECT message
2005-09-03 20:35:34 +02:00
} /* send_msg */
void
CookieRef::notifyOthers( int socket, XWRelayMsg msg, XWREASON why )
when one device is disconnected for heartbeat, tell others it's going away.
2005-09-03 17:41:17 +02:00
{
assert( socket != 0 );
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
int other = iter->m_socket;
when one device is disconnected for heartbeat, tell others it's going away.
2005-09-03 17:41:17 +02:00
if ( other != socket ) {
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
send_msg( other, iter->m_hostID, msg, why, false );
when one device is disconnected for heartbeat, tell others it's going away.
2005-09-03 17:41:17 +02:00
}
}
} /* notifyOthers */
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
void
CookieRef::moveSockets( void )
{
ASSERT_LOCKED();
vector<int> sockets;
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
sockets.push_back( iter->m_socket );
}
CRefMgr::Get()->MoveSockets( sockets, this );
}
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
void
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
CookieRef::sendAllHere( bool initial )
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
{
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
unsigned char buf[1 + 1 /* hostID */
+ sizeof(CookieID)
+ 1 + MAX_CONNNAME_LEN];
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
unsigned char* bufp = buf;
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
unsigned char* idLoc;
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
When guest connects, check if providing too many players before reponding to connection request so that we just deny the request (with new error code) rather than revoking it later.
2009-12-14 05:10:23 +01:00
*bufp++ = initial? XWRELAY_ALLHERE : XWRELAY_ALLBACK;
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
idLoc = bufp++; /* space for hostId, remembering address */
Make it possible for multiple games to connect using the same room name. All new connections are stored together, and after each connection an attempt is made to build one complete game with a host and however many guests. All remaining devices are moved into a new pending record in the same state, and the completed game is treated as always. Seems to work, though nearly 20% of linux instances are failing to connect the relay run from the new test script samename.sh. Need to figure out why. Also added logging of seed and connname to comms.c since games launched together can no longer be certain to connect on the relay. This allows the test script to identify joined games from their logs and detect success or failure. This checkin changes the relay protocol, so relay and clients will both need to be upgraded.
2009-11-02 02:01:47 +01:00
putNetShort( &bufp, GetCookieID() );
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
const char* connName = ConnName();
assert( !!connName && connName[0] );
int len = strlen( connName );
assert( len < MAX_CONNNAME_LEN );
*bufp++ = (char)len;
memcpy( bufp, connName, len );
bufp += len;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter = m_sockets.begin();
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
while ( iter != m_sockets.end() ) {
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
logf( XW_LOGINFO, "%s: sending to hostid %d", __func__,
iter->m_hostID );
*idLoc = iter->m_hostID; /* write in this target's hostId */
Fix bug where device quitting one game to start another with same cookie winds up connecting to the old game -- by flagging a cref as full and no longer accepting connections without connNames even when in the MISSING state. Required a protocol changes so that devices get their connNames as early as possible.
2009-09-14 03:55:03 +02:00
send_with_length( iter->m_socket, buf, bufp-buf, true );
New scheme for accepting and limiting reconnections. Now device must send player counts, local and expected. Based on these the relay accepts connections, declares the game full and ready for message forwarding, and decides whether to accept a reconnect.
2005-10-02 17:39:38 +02:00
++iter;
}
} /* sendAllHere */
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
void
CookieRef::assignHostIds( void )
{
ASSERT_LOCKED();
HostID nextId = HOST_ID_SERVER;
unsigned int bits = 0;
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_hostID != HOST_ID_NONE ) {
bits |= 1 << iter->m_hostID;
}
}
assert( (bits & (1 << HOST_ID_SERVER)) != 0 );
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_hostID == HOST_ID_NONE ) {
while ( ((1 << nextId) & bits) != 0 ) {
++nextId;
}
iter->m_hostID = nextId++; /* ++: don't reuse */
}
}
}
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
#define CONNNAME_DELIM ' ' /* ' ' so will wrap in browser */
/* Does my seed belong as part of existing connName */
bool
CookieRef::SeedBelongs( int gameSeed )
{
bool belongs = false;
const char* ptr = ConnName();
const char* end = ptr + strlen(ptr);
assert( '\0' != ptr[0] );
char buf[5];
snprintf( buf, sizeof(buf), "%.4X", gameSeed );
for ( ; *ptr != CONNNAME_DELIM && ptr < end; ptr += 4 ) {
if ( 0 == strncmp( ptr, buf, 4 ) ) {
belongs = true;
break;
}
}
return belongs;
} /* SeedBelongs */
/* does my connName provide a home for seeds already in this connName-less
ref? */
bool
CookieRef::SeedsBelong( const char* connName )
{
bool found = true;
assert( !m_connName[0] );
const char* delim = strchr( connName, CONNNAME_DELIM );
assert( !!delim );
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
char buf[5];
snprintf( buf, sizeof(buf), "%.4X", iter->m_seed );
const char* match = strstr( connName, buf );
if ( !match || match > delim ) {
found = false;
break;
}
}
return found;
} /* SeedsBelong */
void
CookieRef::assignConnName( void )
{
if ( '\0' == ConnName()[0] ) {
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
char buf[5];
snprintf( buf, sizeof(buf), "%.4X", iter->m_seed );
m_connName += buf;
}
m_connName += CONNNAME_DELIM + PermID::GetNextUniqueID();
logf( XW_LOGINFO, "%s: assigning name: %s", __func__, ConnName() );
} else {
logf( XW_LOGINFO, "%s: already named: %s", __func__, ConnName() );
}
}
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
CookieRef::disconnectSockets( int socket, XWREASON why )
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
{
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
if ( socket == 0 ) {
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
assert( iter->m_socket != 0 );
disconnectSockets( iter->m_socket, why );
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
}
} else {
pushNotifyDisconEvent( socket, why );
pushRemoveSocketEvent( socket );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
} /* disconnectSockets */
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
void
CookieRef::noteHeartbeat( const CRefEvent* evt )
{
int socket = evt->u.heart.socket;
HostID id = evt->u.heart.id;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( iter->m_hostID == id ) {
break;
}
}
Add and handle disconnect message so a device can reuse its socket for a new game.
2005-09-05 17:50:49 +02:00
if ( iter == m_sockets.end() ) {
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
logf( XW_LOGERROR, "no socket for HostID %x", id );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
} else {
heartbeats: send to clients in connection response; note when heartbeat and other messages arrive; and periodically reap sockets that haven't been active in long enough.
2005-06-23 06:26:44 +02:00
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
int second_socket = iter->m_socket;
if ( second_socket == socket ) {
logf( XW_LOGVERBOSE1, "upping m_lastHeartbeat from %d to %d",
iter->m_lastHeartbeat, uptime() );
iter->m_lastHeartbeat = uptime();
} else {
/* PENDING If the message came on an unexpected socket, kill the
connection. An attack is the most likely explanation. But:
now it's happening after a crash and clients reconnect. */
Modify state machine and return new error codes to force host to connect first, guests second, with clear error messages if the order's wrong. This seems to make it simpler for users to get a connection right. Code holding multiple games worth of hosts and guests in a cref is gone.
2009-12-04 09:03:27 +01:00
logf( XW_LOGERROR, "wrong socket record for HostID %x; wanted %d, "
"found %d", id, socket, second_socket );
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
}
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
move to using a formal table-driven state machine for each game (cref object). While it makes things more complex at this point, it should make it easier in the long run to add error handling, timeouts, etc.
2005-07-06 00:05:37 +02:00
} /* noteHeartbeat */
heartbeats: send to clients in connection response; note when heartbeat and other messages arrive; and periodically reap sockets that haven't been active in long enough.
2005-06-23 06:26:44 +02:00
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
/* timer callback */
/* static */ void
CookieRef::s_checkAllConnected( void* closure )
{
/* Need to ensure */
CookieRef* self = (CookieRef*)closure;
SafeCref scr(self);
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
scr.CheckAllConnected();
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
}
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
void
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
CookieRef::_CheckAllConnected()
{
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
logf( XW_LOGVERBOSE0, "%s", __func__ );
comment out internal mutexes: shouldn't be needed now that only one thread at a time is given access to a cref instance.
2005-09-14 07:15:27 +02:00
/* MutexLock ml( &m_EventsMutex ); */
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
CRefEvent newEvt;
rename states so can format to 80 cols; add log level param. No change to functionality in this checkin.
2005-10-02 18:08:42 +02:00
newEvt.type = XWE_CONNTIMER;
Send disconnect events with error codes on heartbeat and connect timer failures; change how state machine handles heartbeats: only put events into the machine when there's a failure.
2005-09-03 08:55:08 +02:00
m_eventQueue.push_back( newEvt );
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
handleEvents();
}
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
void
CookieRef::logf( XW_LogLevel level, const char* format, ... )
{
char buf[256];
int len;
in web console list hosts present rather than just the count
2009-02-28 20:35:32 +01:00
len = snprintf( buf, sizeof(buf), "cid:%d ", m_cookieID );
add _Shutdown(); override logf() to tag with cookieid; make logs less verbose.
2005-10-30 06:20:31 +01:00
va_list ap;
va_start( ap, format );
vsnprintf( buf + len, sizeof(buf) - len, format, ap );
va_end(ap);
::logf( level, buf );
}
loads of changes: get settings from config file; remove sockets and kill crefs via state machine, and protect access to a cref so it can die without another thread being in it; do timers via timeout to poll() rather than interrupt (and integrate into state machine); detect when all players are present and change state so new connections on that cookie will get a new cref.
2005-09-02 08:56:34 +02:00
void
CookieRef::_PrintCookieInfo( string& out )
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
{
cleanup ctrl printing; repeat most recent command; cleanup internal names.
2005-10-16 03:19:25 +02:00
out += "Cookie=";
out += Cookie();
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
out += "\n";
cleanup ctrl printing; repeat most recent command; cleanup internal names.
2005-10-16 03:19:25 +02:00
out += "connName=";
rename Cookie to Invite, a change that may change. Rename everywhere in clients but not in relay where cookie is too pervasive. (There are no code changes in this checkin.)
2009-09-14 05:11:11 +02:00
char buf[MAX_CONNNAME_LEN+MAX_INVITE_LEN];
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
cleanup ctrl printing; repeat most recent command; cleanup internal names.
2005-10-16 03:19:25 +02:00
snprintf( buf, sizeof(buf), "%s\n", ConnName() );
make transmitted vars smaller where possible; new relay identifying scheme where cookie is used only to connect, and is replaced for reconnects by a relay-generated name that's supposed to be unique across all games on all relays and includes a hostname read in from config file; relay assign non-servers' hostIDs.
2005-10-01 18:33:45 +02:00
out += buf;
send notice when a socket closes. This seems to be resulting in dups.
2005-09-04 22:37:42 +02:00
cleanup ctrl printing; repeat most recent command; cleanup internal names.
2005-10-16 03:19:25 +02:00
snprintf( buf, sizeof(buf), "id=%d\n", GetCookieID() );
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
out += buf;
cleanup ctrl printing; repeat most recent command; cleanup internal names.
2005-10-16 03:19:25 +02:00
snprintf( buf, sizeof(buf), "Bytes sent=%d\n", m_totalSent );
out += buf;
variable name change only (for clarity)
2009-08-13 14:59:55 +02:00
snprintf( buf, sizeof(buf), "Total players=%d\n", m_nPlayersSought );
cleanup ctrl printing; repeat most recent command; cleanup internal names.
2005-10-16 03:19:25 +02:00
out += buf;
snprintf( buf, sizeof(buf), "Players here=%d\n", m_nPlayersHere );
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
out += buf;
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
snprintf( buf, sizeof(buf), "State=%s\n", stateString( m_curState ) );
out += buf;
/* Timer state: how long since last heartbeat; how long til disconn timer
fires. */
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
/* n messages */
/* open since when */
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
snprintf( buf, sizeof(buf), "Hosts connected=%d; cur time = %ld\n",
rename now() as uptime(); drop NTHREADS to 1 for now; include time of server boot in connName and keep counter in memory rather than a file.
2009-03-10 13:52:17 +01:00
m_sockets.size(), uptime() );
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
out += buf;
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
snprintf( buf, sizeof(buf), " HostID=%d; socket=%d;last hbeat=%ld\n",
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
iter->m_hostID, iter->m_socket,
iter->m_lastHeartbeat );
Set a disconn timer when somebody leaves to make it parallel with case where somebody never shows up; print more info about cref state to ctrl port.
2005-10-19 05:44:55 +02:00
out += buf;
}
lots of little changes; cleanup and support ctrl functions
2005-04-20 14:13:20 +02:00
} /* PrintCookieInfo */
in web console list hosts present rather than just the count
2009-02-28 20:35:32 +01:00
void
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
CookieRef::_FormatHostInfo( string* hostIds, string* seeds, string* addrs )
in web console list hosts present rather than just the count
2009-02-28 20:35:32 +01:00
{
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
ASSERT_LOCKED();
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
vector<HostRec>::iterator iter;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
for ( iter = m_sockets.begin(); iter != m_sockets.end(); ++iter ) {
if ( !!hostIds ) {
char buf[8];
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
snprintf( buf, sizeof(buf), "%d ", iter->m_hostID );
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
*hostIds += buf;
}
Address problems matching [re]connections to games: first, go back to setting connName when all in a game are present. Second, have every host include in connections a random number. That number is made part of the connName and in general used to test whether a host belongs in a particular game. Add this "seed" to web interface. Means new versions for relay protocol and game stream format. Latter is handled correctly so older games can be opened.
2009-09-26 16:37:49 +02:00
if ( !!seeds ) {
char buf[6];
snprintf( buf, sizeof(buf), "%.4X ", iter->m_seed );
*seeds += buf;
}
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
if ( !!addrs ) {
Fix problems reconnecting hosts where some but not all received the ALLHERE message and connName: change relay protocol so cookie is included in RECONNECT message, and hostIDs are not assigned until ALLHERE, and change host-to-game matching to use connName first but fall back to cookie. This fixes nearly all cases failing to reconnect after relay goes down.
2009-08-21 14:00:09 +02:00
int s = iter->m_socket;
Fix crashes resulting from deleting cref instances in one thread while another wanted to operate on them. The root problem is that you can't dispose of a mutex while somebody's blocking on it. So now the locking mutexes live inside the cref class. When the lock owner realizes the cref needs to die, it sets a flag and it's moved to a recycled list. A thread blocking on the mutex will then get it, but checks the flag and releases it immediately if it's being recycled. (Also improve the http interface a bit.) With these changes I've run 31K (and counting) games against the relay without a crash or deadlock (using sim_real.sh.) The main problem that remains is that sometimes two games using the same cookie wind up with two crefs (and so never connect.)
2009-07-28 07:15:26 +02:00
struct sockaddr_in name;
socklen_t siz = sizeof(name);
if ( 0 == getpeername( s, (struct sockaddr*)&name, &siz) ) {
char buf[32] = {0};
snprintf( buf, sizeof(buf), "%s ", inet_ntoa(name.sin_addr) );
*addrs += buf;
}
}
in web console list hosts present rather than just the count
2009-02-28 20:35:32 +01:00
}
}
Reference in a new issue Copy permalink