ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Nits

This commit is contained in:
libretroadmin 2023-08-30 06:36:38 +02:00
parent 688f76f81d
commit 94accbb6ef
2 changed files with 107 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
menu/menu_displaylist.c
View File

@ -1752,14 +1752,13 @@ static unsigned menu_displaylist_parse_system_info(file_list_t *list)
count++; count++;
/* CPU Architecture */ /* CPU Architecture */
frontend_driver_get_cpu_architecture_str(tmp, sizeof(tmp));
_len = strlcpy(entry, _len = strlcpy(entry,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CPU_ARCHITECTURE), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CPU_ARCHITECTURE),
sizeof(entry)); sizeof(entry));
entry[ _len] = ':'; entry[ _len] = ':';
entry[++_len] = ' '; entry[++_len] = ' ';
entry[++_len] = '\0'; entry[++_len] = '\0';
strlcpy(entry + _len, tmp, sizeof(entry) - _len); frontend_driver_get_cpu_architecture_str(entry + _len, sizeof(entry) - _len);
if (menu_entries_append(list, entry, "", if (menu_entries_append(list, entry, "",
MENU_ENUM_LABEL_CPU_ARCHITECTURE, MENU_SETTINGS_CORE_INFO_NONE, MENU_ENUM_LABEL_CPU_ARCHITECTURE, MENU_SETTINGS_CORE_INFO_NONE,
0, 0, NULL)) 0, 0, NULL))

228
network/netplay/netplay_frontend.c
View File

@ -584,9 +584,9 @@ static bool netplay_lan_ad_server(netplay_t *netplay)
if (subsystem && subsystem->size > 0) if (subsystem && subsystem->size > 0)
{ {
unsigned i; unsigned i = 0;
for (i = 0;;) for (;;)
{ {
strlcat(ad_packet_buffer.content, strlcat(ad_packet_buffer.content,
path_basename(subsystem->elems[i].data), path_basename(subsystem->elems[i].data),
@ -1678,6 +1678,7 @@ static bool clear_framebuffer(netplay_t *netplay)
netplay->server_ptr = i; netplay->server_ptr = i;
} }
} }
for (i = 0; i < MAX_CLIENTS; i++) for (i = 0; i < MAX_CLIENTS; i++)
{ {
netplay->read_ptr[i] = netplay->self_ptr; netplay->read_ptr[i] = netplay->self_ptr;
@ -1783,21 +1784,22 @@ static bool netplay_handshake_pre_sync(netplay_t *netplay,
return false; return false;
/* Get the client-controller mapping */ /* Get the client-controller mapping */
netplay->connected_players = netplay->connected_players =
netplay->connected_slaves = netplay->connected_slaves =
netplay->self_devices = 0; netplay->self_devices = 0;
for (i = 0; i < MAX_CLIENTS; i++) for (i = 0; i < MAX_CLIENTS; i++)
netplay->client_devices[i] = 0; netplay->client_devices[i] = 0;
for (i = 0; i < MAX_INPUT_DEVICES; i++) for (i = 0; i < MAX_INPUT_DEVICES; i++)
{ {
uint32_t device; uint32_t device;
RECV(&device, sizeof(device)) RECV(&device, sizeof(device))
return false; return false;
device = ntohl(device); device = ntohl(device);
netplay->device_clients[i] = device; netplay->device_clients[i] = device;
netplay->connected_players |= device; netplay->connected_players |= device;
for (j = 0; j < MAX_CLIENTS; j++) for (j = 0; j < MAX_CLIENTS; j++)
{ {
if (device & (1<<j)) if (device & (1<<j))
@ -2031,9 +2033,12 @@ bool netplay_delta_frame_ready(netplay_t *netplay, struct delta_frame *delta,
clear_input(delta->real_input[i]); clear_input(delta->real_input[i]);
clear_input(delta->simulated_input[i]); clear_input(delta->simulated_input[i]);
} }
delta->have_local = false; delta->have_local = false;
for (i = 0; i < MAX_CLIENTS; i++) for (i = 0; i < MAX_CLIENTS; i++)
delta->have_real[i] = false; delta->have_real[i] = false;
return true; return true;
} }
@ -2976,6 +2981,7 @@ static bool netplay_resolve_input(netplay_t *netplay,
/* Resolve this client-device */ /* Resolve this client-device */
simstate = netplay_input_state_for( simstate = netplay_input_state_for(
&simframe->real_input[device], client, dsize, false, true); &simframe->real_input[device], client, dsize, false, true);
if (!simstate) if (!simstate)
{ {
/* Don't already have this input, so must /* Don't already have this input, so must
@ -4480,11 +4486,11 @@ static uint8_t netplay_settings_share_mode(
} }
/** /**
* announce_play_spectate * netplay_announce_play_spectate
* *
* Announce a play or spectate mode change * Announce a play or spectate mode change
*/ */
static void announce_play_spectate(netplay_t *netplay, static void netplay_announce_play_spectate(netplay_t *netplay,
const char *nick, const char *nick,
enum rarch_netplay_connection_mode mode, uint32_t devices, enum rarch_netplay_connection_mode mode, uint32_t devices,
int32_t ping, uint32_t client_num) int32_t ping, uint32_t client_num)
@ -4592,11 +4598,11 @@ static void announce_play_spectate(netplay_t *netplay,
} }
/** /**
* handle_play_spectate * netplay_handle_play_spectate
* *
* Handle a play or spectate request * Handle a play or spectate request
*/ */
static void handle_play_spectate(netplay_t *netplay, static void netplay_handle_play_spectate(netplay_t *netplay,
uint32_t client_num, struct netplay_connection *connection, uint32_t client_num, struct netplay_connection *connection,
uint32_t cmd, uint32_t cmd_size, uint32_t *in_payload) uint32_t cmd, uint32_t cmd_size, uint32_t *in_payload)
{ {
@ -4640,7 +4646,7 @@ static void handle_play_spectate(netplay_t *netplay,
netplay_send_raw_cmd(netplay, connection, netplay_send_raw_cmd(netplay, connection,
NETPLAY_CMD_MODE, &payload, sizeof(payload)); NETPLAY_CMD_MODE, &payload, sizeof(payload));
announce_play_spectate(netplay, connection->nick, netplay_announce_play_spectate(netplay, connection->nick,
NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num); NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num);
} }
else else
@ -4651,7 +4657,7 @@ static void handle_play_spectate(netplay_t *netplay,
netplay->self_devices = 0; netplay->self_devices = 0;
netplay->self_mode = NETPLAY_CONNECTION_SPECTATING; netplay->self_mode = NETPLAY_CONNECTION_SPECTATING;
announce_play_spectate(netplay, NULL, netplay_announce_play_spectate(netplay, NULL,
NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num); NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num);
/* It was the server, so tell everyone else */ /* It was the server, so tell everyone else */
@ -4686,11 +4692,9 @@ static void handle_play_spectate(netplay_t *netplay,
share_mode &= ~NETPLAY_SHARE_NO_PREFERENCE; share_mode &= ~NETPLAY_SHARE_NO_PREFERENCE;
} }
/* No device needs to be assigned with netpacket interface */
if (netplay->modus == NETPLAY_MODUS_CORE_PACKET_INTERFACE) if (netplay->modus == NETPLAY_MODUS_CORE_PACKET_INTERFACE)
{
/* no device needs to be assigned with netpacket interface */
devices = 0; devices = 0;
}
else if (devices) else if (devices)
{ {
/* Make sure the devices are available and/or shareable */ /* Make sure the devices are available and/or shareable */
@ -4758,11 +4762,11 @@ static void handle_play_spectate(netplay_t *netplay,
} }
if (i >= MAX_INPUT_DEVICES) if (i >= MAX_INPUT_DEVICES)
{ {
if (netplay->config_devices[1] == RETRO_DEVICE_NONE && /* No device free and no device specifically asked for,
netplay->device_share_modes[0] && share_mode) but only one device, so share it */
if ( netplay->config_devices[1] == RETRO_DEVICE_NONE
&& netplay->device_share_modes[0] && share_mode)
{ {
/* No device free and no device specifically asked for,
but only one device, so share it */
i = 0; i = 0;
devices = 1; devices = 1;
} }
@ -4815,20 +4819,18 @@ static void handle_play_spectate(netplay_t *netplay,
bool slave = false; bool slave = false;
settings_t *settings = config_get_ptr(); settings_t *settings = config_get_ptr();
if (settings->bools.netplay_allow_slaves) /* Slave mode unused when core uses netpacket interface */
if ( settings->bools.netplay_allow_slaves
&& netplay->modus != NETPLAY_MODUS_CORE_PACKET_INTERFACE)
{ {
/* Slave mode unused when core uses netpacket interface */ if (settings->bools.netplay_require_slaves)
if (netplay->modus == NETPLAY_MODUS_CORE_PACKET_INTERFACE) slave = true;
slave = false; else if (mode & NETPLAY_CMD_PLAY_BIT_SLAVE)
else if (settings->bools.netplay_require_slaves)
slave = true; slave = true;
else
slave = (mode & NETPLAY_CMD_PLAY_BIT_SLAVE) ?
true : false;
} }
/* They start at the next frame */ /* They start at the next frame */
netplay->read_ptr[client_num] = NEXT_PTR(netplay->self_ptr); netplay->read_ptr[client_num] = NEXT_PTR(netplay->self_ptr);
netplay->read_frame_count[client_num] = netplay->read_frame_count[client_num] =
netplay->self_frame_count + 1; netplay->self_frame_count + 1;
@ -4867,7 +4869,7 @@ static void handle_play_spectate(netplay_t *netplay,
netplay_send_raw_cmd(netplay, connection, netplay_send_raw_cmd(netplay, connection,
NETPLAY_CMD_MODE, &payload, sizeof(payload)); NETPLAY_CMD_MODE, &payload, sizeof(payload));
announce_play_spectate(netplay, connection->nick, netplay_announce_play_spectate(netplay, connection->nick,
connection->mode, devices, connection->ping, client_num); connection->mode, devices, connection->ping, client_num);
} }
else else
@ -4885,7 +4887,7 @@ static void handle_play_spectate(netplay_t *netplay,
netplay->self_devices = devices; netplay->self_devices = devices;
netplay->self_mode = NETPLAY_CONNECTION_PLAYING; netplay->self_mode = NETPLAY_CONNECTION_PLAYING;
announce_play_spectate(netplay, NULL, netplay_announce_play_spectate(netplay, NULL,
netplay->self_mode, devices, -1, client_num); netplay->self_mode, devices, -1, client_num);
} }
@ -4921,10 +4923,9 @@ bool netplay_cmd_mode(netplay_t *netplay,
case NETPLAY_CONNECTION_SPECTATING: case NETPLAY_CONNECTION_SPECTATING:
cmd = NETPLAY_CMD_SPECTATE; cmd = NETPLAY_CMD_SPECTATE;
break; break;
case NETPLAY_CONNECTION_SLAVE: case NETPLAY_CONNECTION_SLAVE:
buf = NETPLAY_CMD_PLAY_BIT_SLAVE; buf = NETPLAY_CMD_PLAY_BIT_SLAVE;
/* no break */ /* fallthrough */
case NETPLAY_CONNECTION_PLAYING: case NETPLAY_CONNECTION_PLAYING:
{ {
uint32_t i; uint32_t i;
@ -4945,8 +4946,7 @@ bool netplay_cmd_mode(netplay_t *netplay,
buf |= 1 << i; buf |= 1 << i;
} }
buf = htonl(buf); buf = htonl(buf);
cmd = NETPLAY_CMD_PLAY; cmd = NETPLAY_CMD_PLAY;
cmd_size = sizeof(buf); cmd_size = sizeof(buf);
payload = &buf; payload = &buf;
@ -4959,8 +4959,7 @@ bool netplay_cmd_mode(netplay_t *netplay,
if (netplay->is_server) if (netplay->is_server)
{ {
handle_play_spectate(netplay, 0, NULL, cmd, cmd_size, payload); netplay_handle_play_spectate(netplay, 0, NULL, cmd, cmd_size, payload);
return true; return true;
} }
@ -4968,7 +4967,7 @@ bool netplay_cmd_mode(netplay_t *netplay,
cmd, payload, cmd_size); cmd, payload, cmd_size);
} }
static void relay_chat(netplay_t *netplay, const char *nick, const char *msg) static void netplay_relay_chat(netplay_t *netplay, const char *nick, const char *msg)
{ {
size_t i; size_t i;
char data[NETPLAY_NICK_LEN + NETPLAY_CHAT_MAX_SIZE]; char data[NETPLAY_NICK_LEN + NETPLAY_CHAT_MAX_SIZE];
@ -4998,7 +4997,7 @@ static void relay_chat(netplay_t *netplay, const char *nick, const char *msg)
/* We don't flush. Chat is not time essential. */ /* We don't flush. Chat is not time essential. */
} }
static void show_chat(netplay_t *netplay, const char *nick, const char *msg) static void netplay_show_chat(netplay_t *netplay, const char *nick, const char *msg)
{ {
char formatted_chat[NETPLAY_CHAT_MAX_SIZE]; char formatted_chat[NETPLAY_CHAT_MAX_SIZE];
@ -5037,7 +5036,7 @@ static void show_chat(netplay_t *netplay, const char *nick, const char *msg)
} }
#ifdef HAVE_MENU #ifdef HAVE_MENU
static bool chat_check(netplay_t *netplay) static bool netplay_chat_check(netplay_t *netplay)
{ {
if (!netplay) if (!netplay)
return false; return false;
@ -5086,7 +5085,7 @@ static bool chat_check(netplay_t *netplay)
return false; return false;
} }
static void send_chat(void *userdata, const char *line) static void netplay_send_chat(void *userdata, const char *line)
{ {
char msg[NETPLAY_CHAT_MAX_SIZE]; char msg[NETPLAY_CHAT_MAX_SIZE];
net_driver_state_t *net_st = &networking_driver_st; net_driver_state_t *net_st = &networking_driver_st;
@ -5094,7 +5093,8 @@ static void send_chat(void *userdata, const char *line)
/* We perform the same checks, /* We perform the same checks,
just in case something has changed. */ just in case something has changed. */
if (!string_is_empty(line) && chat_check(netplay)) if ( !string_is_empty(line)
&& netplay_chat_check(netplay))
{ {
/* Truncate line to NETPLAY_CHAT_MAX_SIZE. */ /* Truncate line to NETPLAY_CHAT_MAX_SIZE. */
strlcpy(msg, line, sizeof(msg)); strlcpy(msg, line, sizeof(msg));
@ -5102,8 +5102,8 @@ static void send_chat(void *userdata, const char *line)
/* For servers, we need to relay it ourselves. */ /* For servers, we need to relay it ourselves. */
if (netplay->is_server) if (netplay->is_server)
{ {
relay_chat(netplay, netplay->nick, msg); netplay_relay_chat(netplay, netplay->nick, msg);
show_chat(netplay, netplay->nick, msg); netplay_show_chat(netplay, netplay->nick, msg);
} }
/* For clients, we just send it to the server. */ /* For clients, we just send it to the server. */
else else
@ -5125,7 +5125,7 @@ static void send_chat(void *userdata, const char *line)
static void netplay_input_chat(netplay_t *netplay) static void netplay_input_chat(netplay_t *netplay)
{ {
#ifdef HAVE_MENU #ifdef HAVE_MENU
if (chat_check(netplay)) if (netplay_chat_check(netplay))
{ {
menu_input_ctx_line_t chat_input = {0}; menu_input_ctx_line_t chat_input = {0};
@ -5133,7 +5133,7 @@ static void netplay_input_chat(netplay_t *netplay)
chat_input.label = msg_hash_to_str(MSG_NETPLAY_ENTER_CHAT); chat_input.label = msg_hash_to_str(MSG_NETPLAY_ENTER_CHAT);
chat_input.label_setting = "no_setting"; chat_input.label_setting = "no_setting";
chat_input.cb = send_chat; chat_input.cb = netplay_send_chat;
menu_input_dialog_start(&chat_input); menu_input_dialog_start(&chat_input);
} }
@ -5141,11 +5141,11 @@ static void netplay_input_chat(netplay_t *netplay)
} }
/** /**
* handle_chat * netplay_handle_chat
* *
* Handle a received chat message * Handle a received chat message
*/ */
static bool handle_chat(netplay_t *netplay, static bool netplay_handle_chat(netplay_t *netplay,
struct netplay_connection *connection, struct netplay_connection *connection,
const char *nick, const char *msg) const char *nick, const char *msg)
{ {
@ -5162,18 +5162,17 @@ static bool handle_chat(netplay_t *netplay,
if (netplay->is_server) if (netplay->is_server)
{ {
/* Only playing clients can send chat. */ /* Only playing clients can send chat. */
if (connection->mode != NETPLAY_CONNECTION_PLAYING && if ( connection->mode != NETPLAY_CONNECTION_PLAYING
connection->mode != NETPLAY_CONNECTION_SLAVE) && connection->mode != NETPLAY_CONNECTION_SLAVE)
return false; return false;
netplay_relay_chat(netplay, nick, msg);
relay_chat(netplay, nick, msg);
} }
/* If we still got a message even though we are not playing, /* If we still got a message even though we are not playing,
ignore it! */ ignore it! */
if (netplay->self_mode == NETPLAY_CONNECTION_PLAYING || if ( netplay->self_mode == NETPLAY_CONNECTION_PLAYING
netplay->self_mode == NETPLAY_CONNECTION_SLAVE) || netplay->self_mode == NETPLAY_CONNECTION_SLAVE)
show_chat(netplay, nick, msg); netplay_show_chat(netplay, nick, msg);
return true; return true;
} }
@ -5181,7 +5180,7 @@ static bool handle_chat(netplay_t *netplay,
return false; return false;
} }
static void request_ping(netplay_t *netplay, static void netplay_request_ping(netplay_t *netplay,
struct netplay_connection *connection) struct netplay_connection *connection)
{ {
if ( (!(connection->flags & NETPLAY_CONN_FLAG_ACTIVE)) if ( (!(connection->flags & NETPLAY_CONN_FLAG_ACTIVE))
@ -5204,7 +5203,7 @@ static void request_ping(netplay_t *netplay,
} }
} }
static void answer_ping(netplay_t *netplay, static void netplay_answer_ping(netplay_t *netplay,
struct netplay_connection *connection) struct netplay_connection *connection)
{ {
if (netplay_send_raw_cmd(netplay, connection, NETPLAY_CMD_PING_RESPONSE, if (netplay_send_raw_cmd(netplay, connection, NETPLAY_CMD_PING_RESPONSE,
@ -5283,8 +5282,8 @@ static bool netplay_get_cmd(netplay_t *netplay,
if (netplay->is_server) if (netplay->is_server)
{ {
/* Ignore the claimed client #, must be this client */ /* Ignore the claimed client #, must be this client */
if (connection->mode != NETPLAY_CONNECTION_PLAYING && if ( connection->mode != NETPLAY_CONNECTION_PLAYING
connection->mode != NETPLAY_CONNECTION_SLAVE) && connection->mode != NETPLAY_CONNECTION_SLAVE)
{ {
RARCH_ERR("[Netplay] Netplay input from non-participating player.\n"); RARCH_ERR("[Netplay] Netplay input from non-participating player.\n");
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
@ -5352,16 +5351,16 @@ static bool netplay_get_cmd(netplay_t *netplay,
if (!(devices & (1<<device))) if (!(devices & (1<<device)))
continue; continue;
dsize = netplay_expected_input_size(netplay, 1 << device); dsize = netplay_expected_input_size(netplay, 1 << device);
istate = netplay_input_state_for(&dframe->real_input[device], istate = netplay_input_state_for(&dframe->real_input[device],
client_num, dsize, client_num, dsize,
false /* Must be false because of slave-mode clients */, false /* Must be false because of slave-mode clients */,
false); false);
/* Catastrophe! */
if (!istate) if (!istate)
{
/* Catastrophe! */
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
}
RECV(istate->data, dsize*sizeof(uint32_t)) RECV(istate->data, dsize*sizeof(uint32_t))
return false; return false;
for (di = 0; di < dsize; di++) for (di = 0; di < dsize; di++)
@ -5388,7 +5387,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
/* If this was server data, advance our server pointer too */ /* If this was server data, advance our server pointer too */
if (!netplay->is_server && client_num == 0) if (!netplay->is_server && client_num == 0)
{ {
netplay->server_ptr = netplay->read_ptr[0]; netplay->server_ptr = netplay->read_ptr[0];
netplay->server_frame_count = netplay->read_frame_count[0]; netplay->server_frame_count = netplay->read_frame_count[0];
} }
@ -5479,7 +5478,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
client_num = (uint32_t)(connection - netplay->connections + 1); client_num = (uint32_t)(connection - netplay->connections + 1);
handle_play_spectate(netplay, client_num, connection, netplay_handle_play_spectate(netplay, client_num, connection,
cmd, 0, NULL); cmd, 0, NULL);
break; break;
} }
@ -5501,8 +5500,8 @@ static bool netplay_get_cmd(netplay_t *netplay,
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
} }
if (connection->mode == NETPLAY_CONNECTION_PLAYING || if ( connection->mode == NETPLAY_CONNECTION_PLAYING
connection->mode == NETPLAY_CONNECTION_SLAVE) || connection->mode == NETPLAY_CONNECTION_SLAVE)
{ {
/* They were confused */ /* They were confused */
RARCH_ERR("[Netplay] NETPLAY_CMD_PLAY from client already playing.\n"); RARCH_ERR("[Netplay] NETPLAY_CMD_PLAY from client already playing.\n");
@ -5535,7 +5534,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
client_num = (uint32_t)(connection - netplay->connections + 1); client_num = (uint32_t)(connection - netplay->connections + 1);
handle_play_spectate(netplay, client_num, connection, netplay_handle_play_spectate(netplay, client_num, connection,
cmd, cmd_size, &payload); cmd, cmd_size, &payload);
break; break;
} }
@ -5647,15 +5646,15 @@ static bool netplay_get_cmd(netplay_t *netplay,
netplay_input_state_t istate; netplay_input_state_t istate;
if (!(devices & (1<<device))) if (!(devices & (1<<device)))
continue; continue;
dsize = netplay_expected_input_size(netplay, 1 << device); dsize = netplay_expected_input_size(netplay, 1 << device);
istate = netplay_input_state_for( istate = netplay_input_state_for(
&dframe->real_input[device], client_num, dsize, &dframe->real_input[device], client_num, dsize,
false, false); false, false);
if (!istate) if (!istate)
continue; continue;
memset(istate->data, 0, dsize*sizeof(uint32_t)); memset(istate->data, 0, dsize * sizeof(uint32_t));
} }
dframe->have_local = true; dframe->have_local = true;
dframe->have_real[client_num] = true; dframe->have_real[client_num] = true;
send_input_frame(netplay, dframe, connection, NULL, client_num, false); send_input_frame(netplay, dframe, connection, NULL, client_num, false);
if (dframe->frame == netplay->self_frame_count) break; if (dframe->frame == netplay->self_frame_count) break;
@ -5692,7 +5691,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
} }
/* Announce it */ /* Announce it */
announce_play_spectate(netplay, NULL, netplay->self_mode, devices, netplay_announce_play_spectate(netplay, NULL, netplay->self_mode, devices,
connection->ping, client_num); connection->ping, client_num);
#ifdef DEBUG_NETPLAY_STEPS #ifdef DEBUG_NETPLAY_STEPS
@ -5721,14 +5720,14 @@ static bool netplay_get_cmd(netplay_t *netplay,
if (mode & NETPLAY_CMD_MODE_BIT_PLAYING) if (mode & NETPLAY_CMD_MODE_BIT_PLAYING)
{ {
/* When a core uses the netpacket interface this is OK */ /* When a core uses the netpacket interface this is OK */
if (frame != netplay->server_frame_count if ( frame != netplay->server_frame_count
&& netplay->modus != NETPLAY_MODUS_CORE_PACKET_INTERFACE) && netplay->modus != NETPLAY_MODUS_CORE_PACKET_INTERFACE)
{ {
RARCH_ERR("[Netplay] Received mode change out of order.\n"); RARCH_ERR("[Netplay] Received mode change out of order.\n");
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
} }
netplay->connected_players |= (1<<client_num); netplay->connected_players |= (1 << client_num);
netplay->client_devices[client_num] = devices; netplay->client_devices[client_num] = devices;
for (device = 0; device < MAX_INPUT_DEVICES; device++) for (device = 0; device < MAX_INPUT_DEVICES; device++)
if (devices & (1<<device)) if (devices & (1<<device))
@ -5738,7 +5737,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
netplay->read_frame_count[client_num] = netplay->server_frame_count; netplay->read_frame_count[client_num] = netplay->server_frame_count;
/* Announce it */ /* Announce it */
announce_play_spectate(netplay, nick, NETPLAY_CONNECTION_PLAYING, devices, -1, client_num); netplay_announce_play_spectate(netplay, nick, NETPLAY_CONNECTION_PLAYING, devices, -1, client_num);
#ifdef DEBUG_NETPLAY_STEPS #ifdef DEBUG_NETPLAY_STEPS
RARCH_LOG("[Netplay] Received mode change %u->%u\n", client_num, devices); RARCH_LOG("[Netplay] Received mode change %u->%u\n", client_num, devices);
@ -5747,13 +5746,13 @@ static bool netplay_get_cmd(netplay_t *netplay,
} }
else else
{ {
netplay->connected_players &= ~(1<<client_num); netplay->connected_players &= ~(1 << client_num);
netplay->client_devices[client_num] = 0; netplay->client_devices[client_num] = 0;
for (device = 0; device < MAX_INPUT_DEVICES; device++) for (device = 0; device < MAX_INPUT_DEVICES; device++)
netplay->device_clients[device] &= ~(1<<client_num); netplay->device_clients[device] &= ~(1 << client_num);
/* Announce it */ /* Announce it */
announce_play_spectate(netplay, nick, NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num); netplay_announce_play_spectate(netplay, nick, NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num);
#ifdef DEBUG_NETPLAY_STEPS #ifdef DEBUG_NETPLAY_STEPS
RARCH_LOG("[Netplay] Received mode change %u->spectator\n", client_num); RARCH_LOG("[Netplay] Received mode change %u->spectator\n", client_num);
@ -5863,11 +5862,9 @@ static bool netplay_get_cmd(netplay_t *netplay,
if (buffer[1] != local_crc) if (buffer[1] != local_crc)
netplay_cmd_request_savestate(netplay); netplay_cmd_request_savestate(netplay);
} }
/* We'll have to check it when we catch up */
else else
{
/* We'll have to check it when we catch up */
netplay->buffer[tmp_ptr].crc = buffer[1]; netplay->buffer[tmp_ptr].crc = buffer[1];
}
break; break;
} }
@ -6103,8 +6100,8 @@ static bool netplay_get_cmd(netplay_t *netplay,
* then we'll end up never reading the input for read_frame_count itself, * then we'll end up never reading the input for read_frame_count itself,
* which will make the other side unhappy. */ * which will make the other side unhappy. */
netplay->run_ptr = PREV_PTR(reset_ptr); netplay->run_ptr = PREV_PTR(reset_ptr);
netplay->run_frame_count = reset_frame_count - 1; netplay->run_frame_count = reset_frame_count - 1;
if (frame > netplay->self_frame_count) if (frame > netplay->self_frame_count)
{ {
@ -6281,12 +6278,10 @@ static bool netplay_get_cmd(netplay_t *netplay,
netplay_send_cmd_netpacket(netplay, i, netplay_send_cmd_netpacket(netplay, i,
buf, cmd_size, incoming_client_id, false); buf, cmd_size, incoming_client_id, false);
} }
/* Relay unless target is the host or the incoming client */
else if (pkt_client_id && pkt_client_id != incoming_client_id) else if (pkt_client_id && pkt_client_id != incoming_client_id)
{
/* relay unless target is the host or the incoming client */
netplay_send_cmd_netpacket(netplay, pkt_client_id-1, netplay_send_cmd_netpacket(netplay, pkt_client_id-1,
buf, cmd_size, incoming_client_id, false); buf, cmd_size, incoming_client_id, false);
}
} }
break; break;
} }
@ -6331,7 +6326,7 @@ static bool netplay_get_cmd(netplay_t *netplay,
return false; return false;
message[recvd] = '\0'; message[recvd] = '\0';
if (!handle_chat(netplay, connection, nickname, message)) if (!netplay_handle_chat(netplay, connection, nickname, message))
{ {
RARCH_ERR("[Netplay] NETPLAY_CMD_PLAYER_CHAT with invalid message or from an invalid peer.\n"); RARCH_ERR("[Netplay] NETPLAY_CMD_PLAYER_CHAT with invalid message or from an invalid peer.\n");
return netplay_cmd_nak(netplay, connection); return netplay_cmd_nak(netplay, connection);
@ -6340,14 +6335,12 @@ static bool netplay_get_cmd(netplay_t *netplay,
break; break;
case NETPLAY_CMD_PING_REQUEST: case NETPLAY_CMD_PING_REQUEST:
{ netplay_answer_ping(netplay, connection);
answer_ping(netplay, connection);
/* If we are the server, /* If we are the server,
we should request our own ping after answering. */ we should request our own ping after answering. */
if (netplay->is_server) if (netplay->is_server)
request_ping(netplay, connection); netplay_request_ping(netplay, connection);
}
break; break;
case NETPLAY_CMD_PING_RESPONSE: case NETPLAY_CMD_PING_RESPONSE:
@ -6515,15 +6508,13 @@ static void netplay_handle_slaves(netplay_t *netplay)
istate_in = oframe->real_input[device]; istate_in = oframe->real_input[device];
while (istate_in && istate_in->client_num != client_num) while (istate_in && istate_in->client_num != client_num)
istate_in = istate_in->next; istate_in = istate_in->next;
/* Start with blank input */
if (!istate_in) if (!istate_in)
{
/* Start with blank input */
netplay_input_state_for(&frame->real_input[device], netplay_input_state_for(&frame->real_input[device],
client_num, client_num,
netplay_expected_input_size(netplay, 1 << device), true, netplay_expected_input_size(netplay, 1 << device), true,
false); false);
}
else else
{ {
/* Copy the previous input */ /* Copy the previous input */
@ -6569,14 +6560,12 @@ static void netplay_announce_nat_traversal(netplay_t *netplay,
{ {
char msg[512]; char msg[512];
char host[256], port[6]; char host[256], port[6];
size_t _len = strlcpy(msg, msg_hash_to_str(MSG_PUBLIC_ADDRESS), sizeof(msg));
if (!getnameinfo_retro((struct sockaddr*)addr, sizeof(*addr), if (!getnameinfo_retro((struct sockaddr*)addr, sizeof(*addr),
host, sizeof(host), port, sizeof(port), host, sizeof(host), port, sizeof(port),
NI_NUMERICHOST | NI_NUMERICSERV)) NI_NUMERICHOST | NI_NUMERICSERV))
snprintf(msg, sizeof(msg), "%s: %s:%s", snprintf(msg + _len, sizeof(msg) - _len, ": %s:%s", host, port);
msg_hash_to_str(MSG_PUBLIC_ADDRESS), host, port);
else
strlcpy(msg, msg_hash_to_str(MSG_PUBLIC_ADDRESS), sizeof(msg));
RARCH_LOG("[Netplay] %s\n", msg); RARCH_LOG("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, false, NULL, runloop_msg_queue_push(msg, 1, 180, false, NULL,
@ -6585,7 +6574,6 @@ static void netplay_announce_nat_traversal(netplay_t *netplay,
else else
{ {
const char *msg = msg_hash_to_str(MSG_PRIVATE_OR_SHARED_ADDRESS); const char *msg = msg_hash_to_str(MSG_PRIVATE_OR_SHARED_ADDRESS);
RARCH_WARN("[Netplay] %s\n", msg); RARCH_WARN("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 600, false, NULL, runloop_msg_queue_push(msg, 1, 600, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO); MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
@ -6594,7 +6582,6 @@ static void netplay_announce_nat_traversal(netplay_t *netplay,
else else
{ {
const char *msg = msg_hash_to_str(MSG_UPNP_FAILED); const char *msg = msg_hash_to_str(MSG_UPNP_FAILED);
RARCH_ERR("[Netplay] %s\n", msg); RARCH_ERR("[Netplay] %s\n", msg);
runloop_msg_queue_push(msg, 1, 180, false, NULL, runloop_msg_queue_push(msg, 1, 180, false, NULL,
MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO); MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
@ -6617,7 +6604,6 @@ static void netplay_init_nat_traversal(netplay_t *netplay)
static void netplay_deinit_nat_traversal(void) static void netplay_deinit_nat_traversal(void)
{ {
net_driver_state_t *net_st = &networking_driver_st; net_driver_state_t *net_st = &networking_driver_st;
task_push_netplay_nat_close(&net_st->nat_traversal_request); task_push_netplay_nat_close(&net_st->nat_traversal_request);
} }
@ -7289,10 +7275,12 @@ static void netplay_send_savestate(netplay_t *netplay,
|| (connection->compression_supported != cx)) || (connection->compression_supported != cx))
continue; continue;
if (!netplay_send(&connection->send_packet_buffer, connection->fd, header, if ( !netplay_send(&connection->send_packet_buffer,
sizeof(header)) || connection->fd, header,
!netplay_send(&connection->send_packet_buffer, connection->fd, sizeof(header))
netplay->zbuffer, wn)) || !netplay_send(&connection->send_packet_buffer,
connection->fd,
netplay->zbuffer, wn))
netplay_hangup(netplay, connection); netplay_hangup(netplay, connection);
} }
} }
@ -7508,7 +7496,7 @@ static void netplay_toggle_play_spectate(netplay_t *netplay)
netplay->self_mode = NETPLAY_CONNECTION_SPECTATING; netplay->self_mode = NETPLAY_CONNECTION_SPECTATING;
announce_play_spectate(netplay, NULL, netplay_announce_play_spectate(netplay, NULL,
NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num); NETPLAY_CONNECTION_SPECTATING, 0, -1, client_num);
} }
@ -8257,10 +8245,9 @@ static void netplay_announce(netplay_t *netplay)
if (subsystem && subsystem->size > 0) if (subsystem && subsystem->size > 0)
{ {
unsigned i; unsigned i = 0;
buf[0] = '\0';
buf[0] = '\0'; for (;;)
for (i = 0;;)
{ {
strlcat(buf, path_basename(subsystem->elems[i].data), strlcat(buf, path_basename(subsystem->elems[i].data),
sizeof(host_room->gamename)); sizeof(host_room->gamename));
@ -8457,14 +8444,12 @@ static bool netplay_mitm_query(const char *handle)
else else
{ {
char query[256]; char query[256];
size_t _len = strlcpy(query, FILE_PATH_LOBBY_LIBRETRO_URL "tunnel?name=",
snprintf(query, sizeof(query), sizeof(query));
FILE_PATH_LOBBY_LIBRETRO_URL "tunnel?name=%s", handle); strlcpy(query + _len, handle, sizeof(query) - _len);
if (!task_push_http_transfer(query, true, NULL, if (!task_push_http_transfer(query, true, NULL,
netplay_mitm_query_cb, NULL)) netplay_mitm_query_cb, NULL))
return false; return false;
/* Make sure we've the tunnel address before continuing. */ /* Make sure we've the tunnel address before continuing. */
task_queue_wait(NULL, NULL); task_queue_wait(NULL, NULL);
} }
@ -8579,8 +8564,7 @@ static bool netplay_pre_frame(netplay_t *netplay)
if (ctime >= netplay->next_ping) if (ctime >= netplay->next_ping)
{ {
request_ping(netplay, &netplay->connections[0]); netplay_request_ping(netplay, &netplay->connections[0]);
netplay->next_ping = ctime + NETPLAY_PING_TIME; netplay->next_ping = ctime + NETPLAY_PING_TIME;
} }
} }
@ -9567,7 +9551,6 @@ static void gfx_widget_netplay_chat_frame(void *data, void *userdata)
size_t i; size_t i;
char formatted_nick[NETPLAY_CHAT_MAX_SIZE]; char formatted_nick[NETPLAY_CHAT_MAX_SIZE];
char formatted_msg[NETPLAY_CHAT_MAX_SIZE]; char formatted_msg[NETPLAY_CHAT_MAX_SIZE];
size_t formatted_nick_len;
int formatted_nick_width; int formatted_nick_width;
video_frame_info_t *video_info = (video_frame_info_t*)data; video_frame_info_t *video_info = (video_frame_info_t*)data;
dispgfx_widget_t *p_dispwidget = (dispgfx_widget_t*)userdata; dispgfx_widget_t *p_dispwidget = (dispgfx_widget_t*)userdata;
@ -9583,6 +9566,7 @@ static void gfx_widget_netplay_chat_frame(void *data, void *userdata)
for (i = 0; i < ARRAY_SIZE(chat_buffer->messages); i++) for (i = 0; i < ARRAY_SIZE(chat_buffer->messages); i++)
{ {
size_t formatted_nick_len;
uint8_t alpha = chat_buffer->messages[i].alpha; uint8_t alpha = chat_buffer->messages[i].alpha;
const char *nick = chat_buffer->messages[i].nick; const char *nick = chat_buffer->messages[i].nick;
const char *msg = chat_buffer->messages[i].msg; const char *msg = chat_buffer->messages[i].msg;