/*--------------------------------------------------------------------------
Save the apps list to disk.
(Called at quit time to provide quick info on next startup).
--------------------------------------------------------------------------*/
dp_result_t /* status */
dp_freezeAppsList(
dp_t *dp) /* Owner of apps table */
{
FILE* fp;
dp_result_t err = dp_RES_OK;
precondition(dp != NULL);
precondition(dp->dpio != NULL);
DPRINT(("dp_freezeAppsList:\n"));
if (!dp->apps || (dptab_tableSize(dp->apps) == 0)) {
DPRINT(("dptab_table_freeze: table has no entry\n"));
return dp_RES_OK;
}
/* Get the file */
fp = fopen(APPS_CACHE_FILE, "wb");
if (fp == NULL) {
DPRINT(("dp_freezeAppsList: can't open %s, errno %d\n", APPS_CACHE_FILE, errno));
return dp_RES_FULL;
}
/* Write the info (either NULL or a table) */
if(dp->apps != NULL) {
char c = 1;
if(fwrite(&c, sizeof(char), 1, fp) != 1) {
fclose(fp);
DPRINT(("dp_freezeAppsList: can't write %s, errno %d\n", APPS_CACHE_FILE, errno));
return dp_RES_FULL;
}
err = dptab_table_freeze(dp->apps, dp->dpio, fp);
DPRINT(("dp_freezeAppsList: fp now at %ld\n", ftell(fp)));
} else {
char c = 0;
if(fwrite(&c, sizeof(char), 1, fp) != 1) {
fclose(fp);
DPRINT(("dp_freezeAppsList: can't write %s, errno %d\n", APPS_CACHE_FILE, errno));
return dp_RES_FULL;
}
}
/* Finish the file */
fclose(fp);
DPRINT(("dp_freezeAppsList: returning err:%d\n", err));
return err;
}
/*------------------------------------------------------------------------
Start or stop monitoring the given object table for changes.
Initially, and on any change to the given table, a dp_objectDelta_packet_t
is generated and placed in a queue for retrieval with dpReceive.
See anet.h for the definition of dp_objectDelta_packet_t.
When called with monitor=TRUE, a burst of messages are generated giving
the initial contents of the table.
When called with monitor=FALSE, no more messages of that sort will
be generated, although there may still be some in the queue; you can
call dpReceive until it returns empty to flush these out if desired.
The key argument is a variable-length binary string that indicates
what objects to start or stop monitoring.
To start or stop monitoring sessions, use
keylen=1, key[0] = dp_KEY_SESSIONS
To stop monitoring servers, use
keylen=1, key[0] = dp_KEY_SERVERPINGS,
To start monitoring servers, use
keylen=3;
key[0] = dp_KEY_SERVERPINGS,
key[1] = (char) dpGETSHORT_FIRSTBYTE(sessiontype);
key[2] = (char) dpGETSHORT_SECONDBYTE(sessiontype);
To monitor players, use
char key[dp_MAX_KEYLEN+1];
key[0] = dp_KEY_PLAYERS;
dpGetSessionId(dp, &sess, &key[1], &keylen);
keylen++;
To request that latencies be included in player deltas for the current
session, use
keylen = 1, key[0] = dp_KEY_PLAYER_LATENCIES;
The latency in milliseconds will be placed in the latency field of
the object delta packet.
The frequency of latency measurements is influenced by the intervals
set with dpSetPingIntervals.
Deltas are synthesized locally and do not load the network.
Note: keylen will be dp_MAX_KEYLEN+1 when requesting player deltas
in IPX sessions!
------------------------------------------------------------------------*/
DP_API dp_result_t DP_APIX dpRequestObjectDeltas(
dp_t *dp,
int monitor, /* TRUE to start, FALSE to stop */
const char *key,
int keylen)
{
dp_result_t err;
precondition(dp);
precondition(key);
precondition((keylen > 0) && (keylen <= dp_KEY_MAXLEN+1));
DPRINT(("dpRequestObjectDeltas(,%d,%s)\n",
monitor, key2a(key, keylen)));
switch (key[0]) {
case dp_KEY_SESSIONS:
if (keylen != 1) {
DPRINT(("dpRequestObjectDeltas: sessions: can't specify session type yet\n"));
return dp_RES_BAD;
}
if (dp->monitor_object_sessions && monitor)
return dp_RES_ALREADY;
/* Cause dp_sessions_cb to generate new messages */
dp->monitor_object_sessions = monitor;
if (monitor) {
dptab_table_t *sesstab;
int i;
/* enumerate the existing sessions */
/* If we're a standalone master, enum the mysessions table */
if (bIAmStandaloneMaster(dp))
sesstab = dp->mysessions;
else
sesstab = dp->sessions;
DPRINT(("dpRequestObjectDeltas: table size %d\n", dptab_tableSize(sesstab)));
for (i=0; i<dptab_tableSize(sesstab); i++) {
char *s;
dp_session_t sess;
size_t len;
char subkey[dptab_KEY_MAXLEN];
int subkeylen;
err = dptab_get_byindex(sesstab, i, (void **)&s, &len, subkey, &subkeylen);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: bug?\n"));
dp_assertValid(dp);
break;
}
/* Must unpack when retrieving records from dptab */
dp_unpack_session(dp, subkey, subkeylen, s, len, &sess);
err = dpSendObjectDelta(dp, dp_RES_CREATED, (dp_object_t *) &sess, sesstab, subkey, subkeylen);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: can't send object delta, err:%d\n", err));
}
}
}
return dp_RES_OK;
break;
case dp_KEY_SERVERPINGS:
if (dp->monitor_object_servers && monitor) return dp_RES_ALREADY;
/* Cause dpHandleServerPingResponsePacket to generate new messages */
dp->monitor_object_servers = monitor;
dp->serverping_interval = dp->dpio->clocksPerSec;
dp->next_serverping = dp->now;
dp->serverping_rx_count = 0;
dp->serverping_rx_count_old = 0;
if (monitor) {
int i;
if (keylen != 3) {
DPRINT(("dpRequestObjectDeltas: must specify session type.\n"));
return dp_RES_BAD;
}
dp->monitor_object_servers_sessType = dpMAKESHORT(key[1], key[2]);
DPRINT(("dpRequestObjectDeltas: servers_sessType %d\n",dp->monitor_object_servers_sessType));
/* enumerate the existing servers */
for (i=0; i<dptab_tableSize(dp->serverpings); i++) {
dp_serverInfo_t *server;
size_t len;
char subkey[dptab_KEY_MAXLEN];
int subkeylen;
err = dptab_get_byindex(dp->serverpings, i, (void **)&server, &len, subkey, &subkeylen);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: bug?\n"));
dp_assertValid(dp);
break;
}
err = dpSendObjectDelta(dp, dp_RES_CREATED, (dp_object_t *) server, dp->serverpings, subkey, subkeylen);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: can't send object delta, err:%d\n", err));
}
}
}
return dp_RES_OK;
break;
case dp_KEY_PLAYERS:
{
dp_session_t sDesc;
void *rplayers_context;
dp_rplayers_enumEx_context_t rpecontext;
size_t slen;
dptab_table_t *rplayers;
char pkey[3];
int pkeylen;
precondition(keylen == dp->dpio->myAdrLen + 3);
pkeylen = 0;
pkey[pkeylen++] = dp_KEY_PLAYERS;
pkey[pkeylen++] = key[dp->dpio->myAdrLen+1];
pkey[pkeylen++] = key[dp->dpio->myAdrLen+2];
rplayers_context = NULL;
if ((rplayers = dptab_getTable(dp->dt, pkey, pkeylen)))
rplayers_context = dptab_getTableContext(rplayers, dp_rplayers_cb);
if (!monitor) {
/* caller no longer wants object delta messages for this table */
if (!rplayers_context)
return dp_RES_ALREADY;
dptab_clearTableCallback(rplayers, dp_rplayers_cb);
/* bug: should cancel subscription if remote */
return dp_RES_OK;
}
/* caller wants to start getting object delta messages for this table */
if (rplayers_context)
return dp_RES_ALREADY;
slen = sizeof(sDesc);
err = dpGetSessionDescById(dp, key+1, &sDesc, &slen);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: dpGetSessionById returns %d\n", err));
return err;
}
rpecontext.dp = dp;
rpecontext.tab = rplayers;
err = dpEnumPlayersEx(dp, &sDesc, dp_rplayers_enumEx_cb, &rpecontext, 0);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: dpEnumPlayers returns %d\n", err));
return err;
}
rplayers = dptab_getTable(dp->dt, pkey, pkeylen);
assert(rplayers);
err = dptab_setTableCallback(rplayers, dp_rplayers_cb, dp);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: dptab_setTableCallback returns %d\n", err));
return err;
}
return dp_RES_OK;
}
break;
case dp_KEY_PLAYER_LATENCIES:
if (keylen != 1) {
DPRINT(("dpRequestObjectDeltas: player_latencies: bad keylen:%d != 1\n", keylen));
return dp_RES_BAD;
}
dp->monitor_player_latencies = (monitor) ? TRUE : FALSE;
return dp_RES_OK;
break;
case dp_KEY_SCORES:
/* For the moment, only allow the default session type */
if (keylen != 1) {
DPRINT(("dpRequestObjectDeltas: scores: can't specify session type yet\n"));
return dp_RES_BAD;
}
err = dpscore_client_subscribe(dp, dp->defaultSessionType);
if (err != dp_RES_OK) {
DPRINT(("dpRequestObjectDeltas: dpscore_client_subscribe returns err:%d\n", err));
return dp_RES_BUG;
}
return dp_RES_OK;
break;
default:
;
}
DPRINT(("dpRequestObjectDeltas: unknown request\n"));
return dp_RES_BAD;
}
