mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-01 04:20:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

(Netplay) Support for gathering client info and kicking

Browse Source 
Client info and kicking (by the host) is now implemented through netplay_driver_ctl and can be used by future features.
This commit is contained in:
Cthulhu-throwaway 2022-05-13 22:28:52 -03:00
parent e9914d6605
commit 6d96df0e49
3 changed files with 292 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
network/netplay/netplay.h
View File

@ -2,7 +2,7 @@
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis * Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2016-2017 - Gregor Richards * Copyright (C) 2016-2017 - Gregor Richards
* Copyright (C) 2021-2021 - Roberto V. Rampim * Copyright (C) 2021-2022 - Roberto V. Rampim
* *
* RetroArch is free software: you can redistribute it and/or modify it under the terms * RetroArch 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 Found- * of the GNU General Public License as published by the Free Software Found-
@ -58,6 +58,7 @@ enum rarch_netplay_ctl_state
RARCH_NETPLAY_CTL_ENABLE_SERVER, RARCH_NETPLAY_CTL_ENABLE_SERVER,
RARCH_NETPLAY_CTL_ENABLE_CLIENT, RARCH_NETPLAY_CTL_ENABLE_CLIENT,
RARCH_NETPLAY_CTL_DISABLE, RARCH_NETPLAY_CTL_DISABLE,
RARCH_NETPLAY_CTL_REFRESH_CLIENT_INFO,
RARCH_NETPLAY_CTL_IS_ENABLED, RARCH_NETPLAY_CTL_IS_ENABLED,
RARCH_NETPLAY_CTL_IS_REPLAYING, RARCH_NETPLAY_CTL_IS_REPLAYING,
RARCH_NETPLAY_CTL_IS_SERVER, RARCH_NETPLAY_CTL_IS_SERVER,
@ -73,7 +74,31 @@ enum rarch_netplay_ctl_state
RARCH_NETPLAY_CTL_DISCONNECT, RARCH_NETPLAY_CTL_DISCONNECT,
RARCH_NETPLAY_CTL_FINISHED_NAT_TRAVERSAL, RARCH_NETPLAY_CTL_FINISHED_NAT_TRAVERSAL,
RARCH_NETPLAY_CTL_DESYNC_PUSH, RARCH_NETPLAY_CTL_DESYNC_PUSH,
RARCH_NETPLAY_CTL_DESYNC_POP RARCH_NETPLAY_CTL_DESYNC_POP,
RARCH_NETPLAY_CTL_KICK_CLIENT
};
/* The current status of a connection */
enum rarch_netplay_connection_mode
{
NETPLAY_CONNECTION_NONE = 0,
NETPLAY_CONNECTION_DELAYED_DISCONNECT,
/* The connection is dead, but data
is still waiting to be forwarded */
/* Initialization: */
NETPLAY_CONNECTION_INIT, /* Waiting for header */
NETPLAY_CONNECTION_PRE_NICK, /* Waiting for nick */
NETPLAY_CONNECTION_PRE_PASSWORD, /* Waiting for password */
NETPLAY_CONNECTION_PRE_INFO, /* Waiting for core/content info */
NETPLAY_CONNECTION_PRE_SYNC, /* Waiting for sync */
/* Ready: */
NETPLAY_CONNECTION_CONNECTED, /* Modes above this are connected */
NETPLAY_CONNECTION_SPECTATING, /* Spectator mode */
NETPLAY_CONNECTION_SLAVE, /* Playing in slave mode */
NETPLAY_CONNECTION_PLAYING /* Normal ready state */
}; };
/* Preferences for sharing digital devices */ /* Preferences for sharing digital devices */
@ -115,6 +140,14 @@ enum rarch_netplay_discovery_ctl_state
typedef struct netplay netplay_t; typedef struct netplay netplay_t;
typedef struct netplay_client_info
{
int32_t ping;
int id;
enum rarch_netplay_connection_mode mode;
char name[NETPLAY_NICK_LEN];
} netplay_client_info_t;
struct ad_packet struct ad_packet
{ {
uint32_t header; uint32_t header;
@ -237,8 +270,10 @@ typedef struct
struct netplay_rooms *rooms_data; struct netplay_rooms *rooms_data;
/* Used while Netplay is running */ /* Used while Netplay is running */
netplay_t *data; netplay_t *data;
netplay_client_info_t *client_info;
/* Chat messages */ /* Chat messages */
struct netplay_chat *chat; struct netplay_chat *chat;
size_t client_info_count;
#ifdef HAVE_NETPLAYDISCOVERY #ifdef HAVE_NETPLAYDISCOVERY
size_t discovered_hosts_allocated; size_t discovered_hosts_allocated;
/* LAN discovery sockets */ /* LAN discovery sockets */

351
network/netplay/netplay_frontend.c
View File

@ -6045,7 +6045,14 @@ static bool netplay_get_cmd(netplay_t *netplay,
break; break;
case NETPLAY_CMD_PING_REQUEST: case NETPLAY_CMD_PING_REQUEST:
answer_ping(netplay, connection); {
answer_ping(netplay, connection);
/* If we are the server,
we should request our own ping after answering. */
if (netplay->is_server)
request_ping(netplay, connection);
}
break; break;
case NETPLAY_CMD_PING_RESPONSE: case NETPLAY_CMD_PING_RESPONSE:
@ -8480,6 +8487,94 @@ failure:
return false; return false;
} }
static size_t retrieve_client_info(netplay_t *netplay, netplay_client_info_t *buf)
{
size_t i, j = 0;
for (i = 0; i < netplay->connections_size; i++)
{
struct netplay_connection *conn = &netplay->connections[i];
/* We only want info from already connected clients. */
if (conn->active && conn->mode >= NETPLAY_CONNECTION_CONNECTED)
{
netplay_client_info_t *info = &buf[j++];
info->id = (int)i;
strlcpy(info->name, conn->nick, sizeof(info->name));
info->mode = conn->mode;
info->ping = conn->ping;
}
}
return j;
}
static bool kick_client_by_id(netplay_t *netplay, int client_id)
{
struct netplay_connection *connection = NULL;
/* Make sure the id is valid. */
if ((size_t)client_id >= netplay->connections_size)
return false;
connection = &netplay->connections[client_id];
/* We can only kick connected clients. */
if (!connection->active || connection->mode < NETPLAY_CONNECTION_CONNECTED)
return false;
netplay_hangup(netplay, connection);
return true;
}
static bool kick_client_by_name(netplay_t *netplay, const char *client_name)
{
size_t i;
/* Find the connection with the name we want. */
for (i = 0; i < netplay->connections_size; i++)
{
struct netplay_connection *connection = &netplay->connections[i];
/* We can only kick connected clients. */
if (!connection->active || connection->mode < NETPLAY_CONNECTION_CONNECTED)
continue;
/* Kick the first client with a matched name. */
if (string_is_equal(client_name, connection->nick))
{
netplay_hangup(netplay, connection);
return true;
}
}
return false;
}
static bool kick_client_by_id_and_name(netplay_t *netplay,
int client_id, const char *client_name)
{
struct netplay_connection *connection = NULL;
/* Make sure the id is valid. */
if ((size_t)client_id >= netplay->connections_size)
return false;
connection = &netplay->connections[client_id];
/* We can only kick connected clients. */
if (!connection->active || connection->mode < NETPLAY_CONNECTION_CONNECTED)
return false;
/* Make sure the name matches. */
if (!string_is_equal(client_name, connection->nick))
return false;
netplay_hangup(netplay, connection);
return true;
}
/** /**
* netplay_driver_ctl * netplay_driver_ctl
* *
@ -8487,157 +8582,219 @@ failure:
*/ */
bool netplay_driver_ctl(enum rarch_netplay_ctl_state state, void *data) bool netplay_driver_ctl(enum rarch_netplay_ctl_state state, void *data)
{ {
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
net_driver_state_t *net_st = &networking_driver_st; net_driver_state_t *net_st = &networking_driver_st;
netplay_t *netplay = net_st->data; netplay_t *netplay = net_st->data;
bool ret = true; bool ret = true;
if (net_st->in_netplay) if (net_st->in_netplay)
return true; return true;
net_st->in_netplay = true; net_st->in_netplay = true;
if (!netplay)
{
switch (state)
{
case RARCH_NETPLAY_CTL_ENABLE_SERVER:
net_st->netplay_enabled = true;
net_st->netplay_is_client = false;
goto done;
case RARCH_NETPLAY_CTL_ENABLE_CLIENT:
net_st->netplay_enabled = true;
net_st->netplay_is_client = true;
break;
case RARCH_NETPLAY_CTL_DISABLE:
net_st->netplay_enabled = false;
#ifdef HAVE_PRESENCE
{
presence_userdata_t userdata;
userdata.status = PRESENCE_NETPLAY_NETPLAY_STOPPED;
command_event(CMD_EVENT_PRESENCE_UPDATE, &userdata);
}
#endif
goto done;
case RARCH_NETPLAY_CTL_IS_ENABLED:
ret = net_st->netplay_enabled;
goto done;
case RARCH_NETPLAY_CTL_IS_REPLAYING:
case RARCH_NETPLAY_CTL_IS_DATA_INITED:
ret = false;
goto done;
case RARCH_NETPLAY_CTL_IS_SERVER:
ret = net_st->netplay_enabled
&& !net_st->netplay_is_client;
goto done;
case RARCH_NETPLAY_CTL_IS_CONNECTED:
ret = false;
goto done;
case RARCH_NETPLAY_CTL_IS_SPECTATING:
case RARCH_NETPLAY_CTL_IS_PLAYING:
ret = false;
goto done;
default:
goto done;
}
}
switch (state) switch (state)
{ {
case RARCH_NETPLAY_CTL_ENABLE_SERVER: case RARCH_NETPLAY_CTL_ENABLE_SERVER:
if (netplay)
{
ret = false;
break;
}
net_st->netplay_enabled = true;
net_st->netplay_is_client = false;
break;
case RARCH_NETPLAY_CTL_ENABLE_CLIENT: case RARCH_NETPLAY_CTL_ENABLE_CLIENT:
case RARCH_NETPLAY_CTL_IS_DATA_INITED: if (netplay)
goto done; {
ret = false;
break;
}
net_st->netplay_enabled = true;
net_st->netplay_is_client = true;
break;
case RARCH_NETPLAY_CTL_DISABLE: case RARCH_NETPLAY_CTL_DISABLE:
ret = false; if (netplay)
goto done; {
ret = false;
break;
}
net_st->netplay_enabled = false;
#ifdef HAVE_PRESENCE
{
presence_userdata_t userdata;
userdata.status = PRESENCE_NETPLAY_NETPLAY_STOPPED;
command_event(CMD_EVENT_PRESENCE_UPDATE, &userdata);
}
#endif
break;
case RARCH_NETPLAY_CTL_REFRESH_CLIENT_INFO:
if (!netplay)
{
ret = false;
break;
}
if (!net_st->client_info)
{
net_st->client_info = (netplay_client_info_t*)calloc(
MAX_CLIENTS, sizeof(*net_st->client_info));
if (!net_st->client_info)
{
ret = false;
break;
}
}
net_st->client_info_count = retrieve_client_info(netplay,
net_st->client_info);
break;
case RARCH_NETPLAY_CTL_IS_ENABLED: case RARCH_NETPLAY_CTL_IS_ENABLED:
goto done; ret = net_st->netplay_enabled;
break;
case RARCH_NETPLAY_CTL_IS_DATA_INITED:
ret = netplay != NULL;
break;
case RARCH_NETPLAY_CTL_IS_REPLAYING: case RARCH_NETPLAY_CTL_IS_REPLAYING:
ret = netplay->is_replay; ret = netplay && netplay->is_replay;
goto done; break;
case RARCH_NETPLAY_CTL_IS_SERVER: case RARCH_NETPLAY_CTL_IS_SERVER:
ret = net_st->netplay_enabled ret = net_st->netplay_enabled && !net_st->netplay_is_client;
&& !net_st->netplay_is_client; break;
goto done;
case RARCH_NETPLAY_CTL_IS_CONNECTED: case RARCH_NETPLAY_CTL_IS_CONNECTED:
ret = netplay->is_connected; ret = netplay && netplay->is_connected;
goto done; break;
case RARCH_NETPLAY_CTL_IS_SPECTATING: case RARCH_NETPLAY_CTL_IS_SPECTATING:
ret = netplay->self_mode == NETPLAY_CONNECTION_SPECTATING; ret = netplay &&
(netplay->self_mode == NETPLAY_CONNECTION_SPECTATING);
break; break;
case RARCH_NETPLAY_CTL_IS_PLAYING: case RARCH_NETPLAY_CTL_IS_PLAYING:
ret = netplay->self_mode == NETPLAY_CONNECTION_PLAYING || ret = netplay &&
netplay->self_mode == NETPLAY_CONNECTION_SLAVE; (netplay->self_mode == NETPLAY_CONNECTION_PLAYING ||
netplay->self_mode == NETPLAY_CONNECTION_SLAVE);
break; break;
case RARCH_NETPLAY_CTL_POST_FRAME: case RARCH_NETPLAY_CTL_POST_FRAME:
if (!netplay)
break;
netplay_post_frame(netplay); netplay_post_frame(netplay);
/* If we're disconnected, deinitialize */ /* If we're disconnected, deinitialize */
if (!netplay->is_server && !netplay->connections[0].active) if (!netplay->is_server && !netplay->connections[0].active)
netplay_disconnect(netplay); netplay_disconnect(netplay);
break; break;
case RARCH_NETPLAY_CTL_PRE_FRAME: case RARCH_NETPLAY_CTL_PRE_FRAME:
ret = netplay_pre_frame( if (netplay)
ret = netplay_pre_frame(
settings->bools.netplay_public_announce, settings->bools.netplay_public_announce,
netplay->mitm_pending != NULL, netplay->mitm_pending != NULL,
netplay); netplay);
goto done; break;
case RARCH_NETPLAY_CTL_GAME_WATCH: case RARCH_NETPLAY_CTL_GAME_WATCH:
netplay_toggle_play_spectate(netplay); if (netplay)
netplay_toggle_play_spectate(netplay);
else
ret = false;
break; break;
case RARCH_NETPLAY_CTL_PLAYER_CHAT: case RARCH_NETPLAY_CTL_PLAYER_CHAT:
netplay_input_chat(netplay); if (netplay)
netplay_input_chat(netplay);
else
ret = false;
break; break;
case RARCH_NETPLAY_CTL_ALLOW_PAUSE: case RARCH_NETPLAY_CTL_ALLOW_PAUSE:
ret = netplay->allow_pausing; ret = !netplay || netplay->allow_pausing;
break; break;
case RARCH_NETPLAY_CTL_PAUSE: case RARCH_NETPLAY_CTL_PAUSE:
if (netplay->local_paused != true) if (netplay && !netplay->local_paused)
netplay_frontend_paused(netplay, true); netplay_frontend_paused(netplay, true);
break; break;
case RARCH_NETPLAY_CTL_UNPAUSE: case RARCH_NETPLAY_CTL_UNPAUSE:
if (netplay->local_paused != false) if (netplay && netplay->local_paused)
netplay_frontend_paused(netplay, false); netplay_frontend_paused(netplay, false);
break; break;
case RARCH_NETPLAY_CTL_LOAD_SAVESTATE: case RARCH_NETPLAY_CTL_LOAD_SAVESTATE:
netplay_load_savestate(netplay, (retro_ctx_serialize_info_t*)data, true); if (netplay)
netplay_load_savestate(netplay,
(retro_ctx_serialize_info_t*)data, true);
break; break;
case RARCH_NETPLAY_CTL_RESET: case RARCH_NETPLAY_CTL_RESET:
netplay_core_reset(netplay); if (netplay)
netplay_core_reset(netplay);
break; break;
case RARCH_NETPLAY_CTL_DISCONNECT: case RARCH_NETPLAY_CTL_DISCONNECT:
ret = true;
if (netplay) if (netplay)
netplay_disconnect(netplay); netplay_disconnect(netplay);
goto done; else
case RARCH_NETPLAY_CTL_FINISHED_NAT_TRAVERSAL: ret = false;
netplay_announce_nat_traversal(netplay);
goto done;
case RARCH_NETPLAY_CTL_DESYNC_PUSH:
netplay->desync++;
break; break;
case RARCH_NETPLAY_CTL_FINISHED_NAT_TRAVERSAL:
if (netplay)
netplay_announce_nat_traversal(netplay);
break;
case RARCH_NETPLAY_CTL_DESYNC_PUSH:
if (netplay)
netplay->desync++;
break;
case RARCH_NETPLAY_CTL_DESYNC_POP: case RARCH_NETPLAY_CTL_DESYNC_POP:
if (netplay->desync) if (netplay && netplay->desync)
{ {
netplay->desync--; if (!(--netplay->desync))
if (!netplay->desync)
netplay_load_savestate(netplay, NULL, true); netplay_load_savestate(netplay, NULL, true);
} }
break; break;
default:
case RARCH_NETPLAY_CTL_KICK_CLIENT:
/* Only the server should be able to kick others. */
if (netplay && netplay->is_server)
{
netplay_client_info_t *client = (netplay_client_info_t*)data;
if (!client)
{
ret = false;
break;
}
if (client->id >= 0 && !string_is_empty(client->name))
ret = kick_client_by_id_and_name(netplay,
client->id, client->name);
else if (client->id >= 0)
ret = kick_client_by_id(netplay, client->id);
else if (!string_is_empty(client->name))
ret = kick_client_by_name(netplay, client->name);
else
ret = false;
}
else
{
ret = false;
}
break;
case RARCH_NETPLAY_CTL_NONE: case RARCH_NETPLAY_CTL_NONE:
default:
ret = false; ret = false;
break;
} }
done:
net_st->in_netplay = false; net_st->in_netplay = false;
return ret; return ret;
} }

25
network/netplay/netplay_private.h
View File

@ -2,7 +2,7 @@
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis * Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2016-2017 - Gregor Richards * Copyright (C) 2016-2017 - Gregor Richards
* Copyright (C) 2021-2021 - Roberto V. Rampim * Copyright (C) 2021-2022 - Roberto V. Rampim
* *
* RetroArch is free software: you can redistribute it and/or modify it under the terms * RetroArch 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 Found- * of the GNU General Public License as published by the Free Software Found-
@ -246,29 +246,6 @@ enum rarch_netplay_share_preference
NETPLAY_SHARE_ANALOG_AVERAGE = 0x40 NETPLAY_SHARE_ANALOG_AVERAGE = 0x40
}; };
/* The current status of a connection */
enum rarch_netplay_connection_mode
{
NETPLAY_CONNECTION_NONE = 0,
NETPLAY_CONNECTION_DELAYED_DISCONNECT,
/* The connection is dead, but data
is still waiting to be forwarded */
/* Initialization: */
NETPLAY_CONNECTION_INIT, /* Waiting for header */
NETPLAY_CONNECTION_PRE_NICK, /* Waiting for nick */
NETPLAY_CONNECTION_PRE_PASSWORD, /* Waiting for password */
NETPLAY_CONNECTION_PRE_INFO, /* Waiting for core/content info */
NETPLAY_CONNECTION_PRE_SYNC, /* Waiting for sync */
/* Ready: */
NETPLAY_CONNECTION_CONNECTED, /* Modes above this are connected */
NETPLAY_CONNECTION_SPECTATING, /* Spectator mode */
NETPLAY_CONNECTION_SLAVE, /* Playing in slave mode */
NETPLAY_CONNECTION_PLAYING /* Normal ready state */
};
enum rarch_netplay_stall_reason enum rarch_netplay_stall_reason
{ {
NETPLAY_STALL_NONE = 0, NETPLAY_STALL_NONE = 0,