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

Revert "Revert "Move stray globals to networking state""

Browse Source 
This reverts commit a796f1ce58975a640e6b843067645db304b503f7.
This commit is contained in:
twinaphex 2021-11-05 18:55:55 +01:00
parent ac1f6ab599
commit 3bc6dd97d9
6 changed files with 191 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
menu/cbs/menu_cbs_ok.c
View File

@ -82,9 +82,6 @@
#ifdef HAVE_NETWORKING
#include "../../network/netplay/netplay.h"
/* TODO/FIXME - we can't ifdef netplay_discovery.h because of these pesky globals 'netplay_room_count' and 'netplay_room_list' - let's please get rid of them */
#include "../../network/netplay/netplay_discovery.h"
#include "../../wifi/wifi_driver.h"
#endif
@ -5703,43 +5700,44 @@ static int action_ok_netplay_connect_room(const char *path,
const char *label, unsigned type, size_t idx, size_t entry_idx)
{
char tmp_hostname[4115];
unsigned room_index = type - MENU_SETTINGS_NETPLAY_ROOMS_START;
net_driver_state_t *net_st = networking_state_get_ptr();
unsigned room_index = type - MENU_SETTINGS_NETPLAY_ROOMS_START;
tmp_hostname[0] = '\0';
if (room_index >= (unsigned)netplay_room_count)
if (room_index >= (unsigned)net_st->room_count)
return menu_cbs_exit();
tmp_hostname[0] = '\0';
if (netplay_driver_ctl(RARCH_NETPLAY_CTL_IS_DATA_INITED, NULL))
generic_action_ok_command(CMD_EVENT_NETPLAY_DEINIT);
netplay_driver_ctl(RARCH_NETPLAY_CTL_ENABLE_CLIENT, NULL);
if (netplay_room_list[room_index].host_method == NETPLAY_HOST_METHOD_MITM)
if (net_st->room_list[room_index].host_method == NETPLAY_HOST_METHOD_MITM)
snprintf(tmp_hostname,
sizeof(tmp_hostname),
"%s|%d",
netplay_room_list[room_index].mitm_address,
netplay_room_list[room_index].mitm_port);
net_st->room_list[room_index].mitm_address,
net_st->room_list[room_index].mitm_port);
else
snprintf(tmp_hostname,
sizeof(tmp_hostname),
"%s|%d",
netplay_room_list[room_index].address,
netplay_room_list[room_index].port);
net_st->room_list[room_index].address,
net_st->room_list[room_index].port);
#if 0
RARCH_LOG("[lobby] connecting to: %s with game: %s/%08x\n",
tmp_hostname,
netplay_room_list[room_index].gamename,
netplay_room_list[room_index].gamecrc);
net_st->room_list[room_index].gamename,
net_st->room_list[room_index].gamecrc);
#endif
task_push_netplay_crc_scan(
netplay_room_list[room_index].gamecrc,
netplay_room_list[room_index].gamename,
net_st->room_list[room_index].gamecrc,
net_st->room_list[room_index].gamename,
tmp_hostname,
netplay_room_list[room_index].corename,
netplay_room_list[room_index].subsystem_name);
net_st->room_list[room_index].corename,
net_st->room_list[room_index].subsystem_name);
return 0;
}
@ -5834,7 +5832,7 @@ static void netplay_refresh_rooms_cb(retro_task_t *task,
const char *label = NULL;
unsigned menu_type = 0;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
net_driver_state_t *net_st = networking_state_get_ptr();
http_transfer_data_t *data = (http_transfer_data_t*)task_data;
menu_entries_get_last_stack(&path, &label, &menu_type, &enum_idx, NULL);
@ -5860,7 +5858,7 @@ static void netplay_refresh_rooms_cb(retro_task_t *task,
STRLEN_CONST("registry.lpl")))
{
if (string_is_empty(data->data))
netplay_room_count = 0;
net_st->room_count = 0;
else
{
char s[PATH_MAX_LENGTH];
@ -5878,63 +5876,63 @@ static void netplay_refresh_rooms_cb(retro_task_t *task,
netplay_rooms_parse(data->data);
if (netplay_room_list)
free(netplay_room_list);
if (net_st->room_list)
free(net_st->room_list);
/* TODO/FIXME - right now, a LAN and non-LAN netplay session might appear
* in the same list. If both entries are available, we want to show only
* the LAN one. */
netplay_room_count = netplay_rooms_get_count();
netplay_room_list = (struct netplay_room*)
calloc(netplay_room_count + lan_room_count,
net_st->room_count = netplay_rooms_get_count();
net_st->room_list = (struct netplay_room*)
calloc(net_st->room_count + lan_room_count,
sizeof(struct netplay_room));
for (i = 0; i < (unsigned)netplay_room_count; i++)
memcpy(&netplay_room_list[i], netplay_room_get(i), sizeof(netplay_room_list[i]));
for (i = 0; i < (unsigned)net_st->room_count; i++)
memcpy(&net_st->room_list[i], netplay_room_get(i), sizeof(net_st->room_list[i]));
if (lan_room_count != 0)
{
for (i = netplay_room_count; i < (unsigned)(netplay_room_count + lan_room_count); i++)
for (i = net_st->room_count; i < (unsigned)(net_st->room_count + lan_room_count); i++)
{
struct netplay_host *host = &lan_hosts->hosts[j++];
strlcpy(netplay_room_list[i].nickname,
strlcpy(net_st->room_list[i].nickname,
host->nick,
sizeof(netplay_room_list[i].nickname));
sizeof(net_st->room_list[i].nickname));
strlcpy(netplay_room_list[i].address,
strlcpy(net_st->room_list[i].address,
host->address,
INET6_ADDRSTRLEN);
strlcpy(netplay_room_list[i].corename,
strlcpy(net_st->room_list[i].corename,
host->core,
sizeof(netplay_room_list[i].corename));
strlcpy(netplay_room_list[i].retroarch_version,
sizeof(net_st->room_list[i].corename));
strlcpy(net_st->room_list[i].retroarch_version,
host->retroarch_version,
sizeof(netplay_room_list[i].retroarch_version));
strlcpy(netplay_room_list[i].coreversion,
sizeof(net_st->room_list[i].retroarch_version));
strlcpy(net_st->room_list[i].coreversion,
host->core_version,
sizeof(netplay_room_list[i].coreversion));
strlcpy(netplay_room_list[i].gamename,
sizeof(net_st->room_list[i].coreversion));
strlcpy(net_st->room_list[i].gamename,
host->content,
sizeof(netplay_room_list[i].gamename));
strlcpy(netplay_room_list[i].frontend,
sizeof(net_st->room_list[i].gamename));
strlcpy(net_st->room_list[i].frontend,
host->frontend,
sizeof(netplay_room_list[i].frontend));
strlcpy(netplay_room_list[i].subsystem_name,
sizeof(net_st->room_list[i].frontend));
strlcpy(net_st->room_list[i].subsystem_name,
host->subsystem_name,
sizeof(netplay_room_list[i].subsystem_name));
sizeof(net_st->room_list[i].subsystem_name));
netplay_room_list[i].port = host->port;
netplay_room_list[i].gamecrc = host->content_crc;
netplay_room_list[i].timestamp = 0;
netplay_room_list[i].lan = true;
net_st->room_list[i].port = host->port;
net_st->room_list[i].gamecrc = host->content_crc;
net_st->room_list[i].timestamp = 0;
net_st->room_list[i].lan = true;
snprintf(s, sizeof(s),
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NETPLAY_ROOM_NICKNAME),
netplay_room_list[i].nickname);
net_st->room_list[i].nickname);
}
netplay_room_count += lan_room_count;
net_st->room_count += lan_room_count;
}
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);

35
menu/cbs/menu_cbs_sublabel.c
View File

@ -1322,26 +1322,27 @@ static int action_bind_sublabel_netplay_room(
const char *label, const char *path,
char *s, size_t len)
{
uint32_t gamecrc = 0;
const char *ra_version = NULL;
const char *corename = NULL;
const char *gamename = NULL;
const char *core_ver = NULL;
const char *frontend = NULL;
const char *na = NULL;
const char *subsystem = NULL;
unsigned room_index = type - MENU_SETTINGS_NETPLAY_ROOMS_START;
uint32_t gamecrc = 0;
const char *ra_version = NULL;
const char *corename = NULL;
const char *gamename = NULL;
const char *core_ver = NULL;
const char *frontend = NULL;
const char *na = NULL;
const char *subsystem = NULL;
net_driver_state_t *net_st = networking_state_get_ptr();
unsigned room_index = type - MENU_SETTINGS_NETPLAY_ROOMS_START;
if (room_index >= (unsigned)netplay_room_count)
if (room_index >= (unsigned)net_st->room_count)
return menu_cbs_exit();
ra_version = netplay_room_list[room_index].retroarch_version;
corename = netplay_room_list[room_index].corename;
gamename = netplay_room_list[room_index].gamename;
core_ver = netplay_room_list[room_index].coreversion;
gamecrc = netplay_room_list[room_index].gamecrc;
frontend = netplay_room_list[room_index].frontend;
subsystem = netplay_room_list[room_index].subsystem_name;
ra_version = net_st->room_list[room_index].retroarch_version;
corename = net_st->room_list[room_index].corename;
gamename = net_st->room_list[room_index].gamename;
core_ver = net_st->room_list[room_index].coreversion;
gamecrc = net_st->room_list[room_index].gamecrc;
frontend = net_st->room_list[room_index].frontend;
subsystem = net_st->room_list[room_index].subsystem_name;
na = msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE);
if (string_is_empty(subsystem) || string_is_equal(subsystem,

33
menu/menu_displaylist.c
View File

@ -9636,6 +9636,7 @@ unsigned menu_displaylist_netplay_refresh_rooms(file_list_t *list)
char s[8300];
int i = 0;
unsigned count = 0;
net_driver_state_t *net_st = networking_state_get_ptr();
s[0] = '\0';
@ -9681,15 +9682,15 @@ unsigned menu_displaylist_netplay_refresh_rooms(file_list_t *list)
MENU_SETTING_ACTION, 0, 0))
count++;
if (netplay_room_count != 0)
if (net_st->room_count != 0)
{
for (i = 0; i < netplay_room_count; i++)
for (i = 0; i < net_st->room_count; i++)
{
char country[PATH_MAX_LENGTH];
if (*netplay_room_list[i].country)
if (*net_st->room_list[i].country)
snprintf(country, sizeof(country),
"(%s)", netplay_room_list[i].country);
"(%s)", net_st->room_list[i].country);
/* Uncomment this to debug mismatched room parameters*/
#if 0
@ -9702,23 +9703,25 @@ unsigned menu_displaylist_netplay_refresh_rooms(file_list_t *list)
"Game: %s\n"
"Game CRC: %08x\n"
"Timestamp: %d\n", room_data->elems[j + 6].data,
netplay_room_list[i].nickname,
netplay_room_list[i].address,
netplay_room_list[i].port,
netplay_room_list[i].corename,
netplay_room_list[i].coreversion,
netplay_room_list[i].gamename,
netplay_room_list[i].gamecrc,
netplay_room_list[i].timestamp);
net_st->room_list[i].nickname,
net_st->room_list[i].address,
net_st->room_list[i].port,
net_st->room_list[i].corename,
net_st->room_list[i].coreversion,
net_st->room_list[i].gamename,
net_st->room_list[i].gamecrc,
net_st->room_list[i].timestamp);
#endif
snprintf(s, sizeof(s), "%s: %s%s",
netplay_room_list[i].lan
net_st->room_list[i].lan
? msg_hash_to_str(MSG_LOCAL)
: (netplay_room_list[i].host_method == NETPLAY_HOST_METHOD_MITM
: (net_st->room_list[i].host_method
== NETPLAY_HOST_METHOD_MITM
? msg_hash_to_str(MSG_INTERNET_RELAY)
: msg_hash_to_str(MSG_INTERNET)),
netplay_room_list[i].nickname, country);
net_st->room_list[i].nickname,
country);
if (menu_entries_append_enum(list,
s,

22
network/netplay/netplay.h
View File

@ -81,6 +81,24 @@ enum rarch_netplay_share_analog_preference
typedef struct netplay netplay_t;
#ifdef HAVE_NETPLAYDISCOVERY
struct ad_packet
{
uint32_t header;
uint32_t protocol_version;
uint32_t port;
char address[NETPLAY_HOST_STR_LEN];
char retroarch_version[NETPLAY_HOST_STR_LEN];
char nick[NETPLAY_HOST_STR_LEN];
char frontend[NETPLAY_HOST_STR_LEN];
char core[NETPLAY_HOST_STR_LEN];
char core_version[NETPLAY_HOST_STR_LEN];
char content[NETPLAY_HOST_LONGSTR_LEN];
char content_crc[NETPLAY_HOST_STR_LEN];
char subsystem_name[NETPLAY_HOST_STR_LEN];
};
#endif
typedef struct mitm_server
{
const char *name;
@ -124,13 +142,17 @@ typedef struct
netplay_t *data; /* Used while Netplay is running */
struct netplay_room host_room; /* ptr alignment */
netplay_t *handshake_password;
struct netplay_room *room_list;
/* List of discovered hosts */
struct netplay_host_list discovered_hosts;
#ifdef HAVE_NETPLAYDISCOVERY
size_t discovered_hosts_allocated;
#endif
int room_count;
int reannounce;
unsigned server_port_deferred;
/* Packet buffer for advertisement and responses */
struct ad_packet ad_packet_buffer; /* uint32_t alignment */
uint16_t mapping[RETROK_LAST];
char server_address_deferred[512];
/* Only used before init_netplay */

4
network/netplay/netplay_discovery.h
View File

@ -73,8 +73,4 @@ void deinit_netplay_discovery(void);
bool netplay_discovery_driver_ctl(enum rarch_netplay_discovery_ctl_state state, void *data);
#endif
/* TODO/FIXME - globals */
extern struct netplay_room *netplay_room_list;
extern int netplay_room_count;
#endif

164
network/netplay/netplay_frontend.c
View File

@ -135,36 +135,13 @@ struct info_buf_s
char core_version[NETPLAY_NICK_LEN];
};
#ifdef HAVE_NETPLAYDISCOVERY
struct ad_packet
{
uint32_t header;
uint32_t protocol_version;
uint32_t port;
char address[NETPLAY_HOST_STR_LEN];
char retroarch_version[NETPLAY_HOST_STR_LEN];
char nick[NETPLAY_HOST_STR_LEN];
char frontend[NETPLAY_HOST_STR_LEN];
char core[NETPLAY_HOST_STR_LEN];
char core_version[NETPLAY_HOST_STR_LEN];
char content[NETPLAY_HOST_LONGSTR_LEN];
char content_crc[NETPLAY_HOST_STR_LEN];
char subsystem_name[NETPLAY_HOST_STR_LEN];
};
#endif
/* TODO/FIXME - globals */
struct netplay_room *netplay_room_list = NULL;
int netplay_room_count = 0;
static unsigned long simple_rand_next = 1;
static unsigned long simple_rand_next = 1;
#ifdef HAVE_NETPLAYDISCOVERY
/* LAN discovery sockets */
static int lan_ad_server_fd = -1;
static int lan_ad_client_fd = -1;
/* Packet buffer for advertisement and responses */
static struct ad_packet ad_packet_buffer;
#endif
/* The mapping of keys from netplay (network) to libretro (host) */
@ -235,18 +212,18 @@ static bool netplay_lan_ad_client(void)
/* Somebody queried, so check that it's valid */
addr_size = sizeof(their_addr);
if (recvfrom(lan_ad_client_fd, (char*)&ad_packet_buffer,
if (recvfrom(lan_ad_client_fd, (char*)&net_st->ad_packet_buffer,
sizeof(struct ad_packet), 0, &their_addr, &addr_size) >=
(ssize_t) sizeof(struct ad_packet))
{
struct netplay_host *host = NULL;
/* Make sure it's a valid response */
if (memcmp((void *) &ad_packet_buffer, "RANS", 4))
if (memcmp((void *) &net_st->ad_packet_buffer, "RANS", 4))
continue;
/* For this version */
if (ntohl(ad_packet_buffer.protocol_version)
if (ntohl(net_st->ad_packet_buffer.protocol_version)
!= NETPLAY_PROTOCOL_VERSION)
continue;
@ -257,7 +234,7 @@ static bool netplay_lan_ad_client(void)
RARCH_WARN ("[Discovery] Using IPv4 for discovery\n");
sin = (struct sockaddr_in *) &their_addr;
sin->sin_port = htons(ntohl(ad_packet_buffer.port));
sin->sin_port = htons(ntohl(net_st->ad_packet_buffer.port));
}
#ifdef HAVE_INET6
@ -266,7 +243,7 @@ static bool netplay_lan_ad_client(void)
struct sockaddr_in6 *sin6 = NULL;
RARCH_WARN ("[Discovery] Using IPv6 for discovery\n");
sin6 = (struct sockaddr_in6 *) &their_addr;
sin6->sin6_port = htons(ad_packet_buffer.port);
sin6->sin6_port = htons(net_st->ad_packet_buffer.port);
}
#endif
@ -309,24 +286,35 @@ static bool netplay_lan_ad_client(void)
host->addr = their_addr;
host->addrlen = addr_size;
host->port = ntohl(ad_packet_buffer.port);
host->port = ntohl(net_st->ad_packet_buffer.port);
strlcpy(host->address, ad_packet_buffer.address, NETPLAY_HOST_STR_LEN);
strlcpy(host->nick, ad_packet_buffer.nick, NETPLAY_HOST_STR_LEN);
strlcpy(host->core, ad_packet_buffer.core, NETPLAY_HOST_STR_LEN);
strlcpy(host->retroarch_version, ad_packet_buffer.retroarch_version,
NETPLAY_HOST_STR_LEN);
strlcpy(host->core_version, ad_packet_buffer.core_version,
NETPLAY_HOST_STR_LEN);
strlcpy(host->content, ad_packet_buffer.content,
NETPLAY_HOST_LONGSTR_LEN);
strlcpy(host->subsystem_name, ad_packet_buffer.subsystem_name,
NETPLAY_HOST_LONGSTR_LEN);
strlcpy(host->frontend, ad_packet_buffer.frontend,
NETPLAY_HOST_STR_LEN);
strlcpy(host->address,
net_st->ad_packet_buffer.address,
NETPLAY_HOST_STR_LEN);
strlcpy(host->nick,
net_st->ad_packet_buffer.nick,
NETPLAY_HOST_STR_LEN);
strlcpy(host->core,
net_st->ad_packet_buffer.core,
NETPLAY_HOST_STR_LEN);
strlcpy(host->retroarch_version,
net_st->ad_packet_buffer.retroarch_version,
NETPLAY_HOST_STR_LEN);
strlcpy(host->core_version,
net_st->ad_packet_buffer.core_version,
NETPLAY_HOST_STR_LEN);
strlcpy(host->content,
net_st->ad_packet_buffer.content,
NETPLAY_HOST_LONGSTR_LEN);
strlcpy(host->subsystem_name,
net_st->ad_packet_buffer.subsystem_name,
NETPLAY_HOST_LONGSTR_LEN);
strlcpy(host->frontend,
net_st->ad_packet_buffer.frontend,
NETPLAY_HOST_STR_LEN);
host->content_crc =
atoi(ad_packet_buffer.content_crc);
atoi(net_st->ad_packet_buffer.content_crc);
host->nick[NETPLAY_HOST_STR_LEN-1] =
host->core[NETPLAY_HOST_STR_LEN-1] =
host->core_version[NETPLAY_HOST_STR_LEN-1] =
@ -413,16 +401,18 @@ bool netplay_discovery_driver_ctl(
#endif
/* Put together the request */
memcpy((void *) &ad_packet_buffer, "RANQ", 4);
ad_packet_buffer.protocol_version = htonl(NETPLAY_PROTOCOL_VERSION);
memcpy((void *)&net_st->ad_packet_buffer, "RANQ", 4);
net_st->ad_packet_buffer.protocol_version = htonl(NETPLAY_PROTOCOL_VERSION);
for (k = 0; k < (unsigned)interfaces.size; k++)
{
strlcpy(ad_packet_buffer.address, interfaces.entries[k].host,
NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.address,
interfaces.entries[k].host,
NETPLAY_HOST_STR_LEN);
/* And send it off */
ret = (int)sendto(lan_ad_client_fd, (const char *) &ad_packet_buffer,
ret = (int)sendto(lan_ad_client_fd, (const char *)
&net_st->ad_packet_buffer,
sizeof(struct ad_packet), 0, addr->ai_addr, addr->ai_addrlen);
if (ret < (ssize_t) (2*sizeof(uint32_t)))
RARCH_WARN("[Discovery] Failed to send netplay discovery query (error: %d)\n", errno);
@ -495,6 +485,7 @@ bool netplay_lan_ad_server(netplay_t *netplay)
unsigned k = 0;
struct addrinfo *our_addr, hints = {0};
struct string_list *subsystem = path_get_subsystem_list();
net_driver_state_t *net_st = &networking_driver_st;
interfaces.entries = NULL;
interfaces.size = 0;
@ -525,7 +516,8 @@ bool netplay_lan_ad_server(netplay_t *netplay)
/* Somebody queried, so check that it's valid */
addr_size = sizeof(their_addr);
ret = (int)recvfrom(lan_ad_server_fd, (char*)&ad_packet_buffer,
ret = (int)recvfrom(lan_ad_server_fd, (char*)
&net_st->ad_packet_buffer,
sizeof(struct ad_packet), 0, &their_addr, &addr_size);
if (ret >= (ssize_t) (2 * sizeof(uint32_t)))
{
@ -533,22 +525,24 @@ bool netplay_lan_ad_server(netplay_t *netplay)
uint32_t content_crc = 0;
/* Make sure it's a valid query */
if (memcmp((void *) &ad_packet_buffer, "RANQ", 4))
if (memcmp((void *) &net_st->ad_packet_buffer, "RANQ", 4))
{
RARCH_LOG("[Discovery] Invalid query\n");
continue;
}
/* For this version */
if (ntohl(ad_packet_buffer.protocol_version) !=
if (ntohl(net_st->ad_packet_buffer.protocol_version) !=
NETPLAY_PROTOCOL_VERSION)
{
RARCH_LOG("[Discovery] Invalid protocol version\n");
continue;
}
if (!string_is_empty(ad_packet_buffer.address))
strlcpy(reply_addr, ad_packet_buffer.address, NETPLAY_HOST_STR_LEN);
if (!string_is_empty(net_st->ad_packet_buffer.address))
strlcpy(reply_addr,
net_st->ad_packet_buffer.address,
NETPLAY_HOST_STR_LEN);
for (k = 0; k < interfaces.size; k++)
{
@ -579,8 +573,9 @@ bool netplay_lan_ad_server(netplay_t *netplay)
buf[0] = '\0';
content_crc = content_get_crc();
memset(&ad_packet_buffer, 0, sizeof(struct ad_packet));
memcpy(&ad_packet_buffer, "RANS", 4);
memset(&net_st->ad_packet_buffer,
0, sizeof(struct ad_packet));
memcpy(&net_st->ad_packet_buffer, "RANS", 4);
if (subsystem)
{
@ -592,41 +587,52 @@ bool netplay_lan_ad_server(netplay_t *netplay)
if (i < subsystem->size - 1)
strlcat(buf, "|", NETPLAY_HOST_LONGSTR_LEN);
}
strlcpy(ad_packet_buffer.content, buf,
strlcpy(net_st->ad_packet_buffer.content, buf,
NETPLAY_HOST_LONGSTR_LEN);
strlcpy(ad_packet_buffer.subsystem_name, path_get(RARCH_PATH_SUBSYSTEM),
NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.subsystem_name,
path_get(RARCH_PATH_SUBSYSTEM),
NETPLAY_HOST_STR_LEN);
}
else
{
strlcpy(ad_packet_buffer.content, !string_is_empty(
strlcpy(net_st->ad_packet_buffer.content,
!string_is_empty(
path_basename(path_get(RARCH_PATH_BASENAME)))
? path_basename(path_get(RARCH_PATH_BASENAME)) : "N/A",
? path_basename(path_get(RARCH_PATH_BASENAME))
: "N/A",
NETPLAY_HOST_LONGSTR_LEN);
strlcpy(ad_packet_buffer.subsystem_name, "N/A", NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.subsystem_name,
"N/A",
NETPLAY_HOST_STR_LEN);
}
strlcpy(ad_packet_buffer.address, interfaces.entries[k].host,
NETPLAY_HOST_STR_LEN);
ad_packet_buffer.protocol_version =
strlcpy(net_st->ad_packet_buffer.address,
interfaces.entries[k].host,
NETPLAY_HOST_STR_LEN);
net_st->ad_packet_buffer.protocol_version =
htonl(NETPLAY_PROTOCOL_VERSION);
ad_packet_buffer.port = htonl(netplay->tcp_port);
strlcpy(ad_packet_buffer.retroarch_version, PACKAGE_VERSION,
NETPLAY_HOST_STR_LEN);
strlcpy(ad_packet_buffer.nick, netplay->nick, NETPLAY_HOST_STR_LEN);
strlcpy(ad_packet_buffer.frontend, frontend, NETPLAY_HOST_STR_LEN);
net_st->ad_packet_buffer.port = htonl(netplay->tcp_port);
strlcpy(net_st->ad_packet_buffer.retroarch_version,
PACKAGE_VERSION,
NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.nick,
netplay->nick, NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.frontend,
frontend, NETPLAY_HOST_STR_LEN);
if (info)
{
strlcpy(ad_packet_buffer.core, info->library_name,
NETPLAY_HOST_STR_LEN);
strlcpy(ad_packet_buffer.core_version, info->library_version,
NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.core,
info->library_name,
NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.core_version,
info->library_version,
NETPLAY_HOST_STR_LEN);
}
snprintf(s, sizeof(s), "%ld", (long)content_crc);
strlcpy(ad_packet_buffer.content_crc, s,
NETPLAY_HOST_STR_LEN);
strlcpy(net_st->ad_packet_buffer.content_crc, s,
NETPLAY_HOST_STR_LEN);
/* Build up the destination address*/
snprintf(port_str, 6, "%hu", ntohs(((struct sockaddr_in*)(&their_addr))->sin_port));
@ -636,8 +642,10 @@ bool netplay_lan_ad_server(netplay_t *netplay)
RARCH_LOG ("[Discovery] Sending reply to %s \n", reply_addr);
/* And send it */
sendto(lan_ad_server_fd, (const char*)&ad_packet_buffer,
sizeof(struct ad_packet), 0, our_addr->ai_addr, our_addr->ai_addrlen);
sendto(lan_ad_server_fd,
(const char*)&net_st->ad_packet_buffer,
sizeof(struct ad_packet),
0, our_addr->ai_addr, our_addr->ai_addrlen);
freeaddrinfo_retro(our_addr);
}
else