static bool get_info(netplay_t *netplay)
{
unsigned sram_size;
uint32_t header[3];
const void *sram = NULL;
global_t *global = global_get_ptr();
if (!socket_receive_all_blocking(netplay->fd, header, sizeof(header)))
{
RARCH_ERR("Failed to receive header from client.\n");
return false;
}
if (global->content_crc != ntohl(header[0]))
{
RARCH_ERR("Content CRC32s differ. Cannot use different games.\n");
return false;
}
if (implementation_magic_value() != ntohl(header[1]))
{
RARCH_ERR("Implementations differ, make sure you're using exact same libretro implementations and RetroArch version.\n");
return false;
}
if (core.retro_get_memory_size(RETRO_MEMORY_SAVE_RAM) != ntohl(header[2]))
{
RARCH_ERR("Content SRAM sizes do not correspond.\n");
return false;
}
if (!get_nickname(netplay, netplay->fd))
{
RARCH_ERR("Failed to get nickname from client.\n");
return false;
}
/* Send SRAM data to our User 2. */
sram = core.retro_get_memory_data(RETRO_MEMORY_SAVE_RAM);
sram_size = core.retro_get_memory_size(RETRO_MEMORY_SAVE_RAM);
if (!socket_send_all_blocking(netplay->fd, sram, sram_size))
{
RARCH_ERR("Failed to send SRAM data to client.\n");
return false;
}
if (!send_nickname(netplay, netplay->fd))
{
RARCH_ERR("Failed to send nickname to client.\n");
return false;
}
#ifndef HAVE_SOCKET_LEGACY
log_connection(&netplay->other_addr, 0, netplay->other_nick);
#endif
return true;
}
static bool get_info_spectate(netplay_t *netplay)
{
size_t save_state_size, size;
void *buf = NULL;
uint32_t header[4] = {0};
char msg[512] = {0};
bool ret = true;
if (!send_nickname(netplay, netplay->fd))
{
RARCH_ERR("Failed to send nickname to host.\n");
return false;
}
if (!get_nickname(netplay, netplay->fd))
{
RARCH_ERR("Failed to receive nickname from host.\n");
return false;
}
snprintf(msg, sizeof(msg), "Connected to \"%s\"", netplay->other_nick);
rarch_main_msg_queue_push(msg, 1, 180, false);
RARCH_LOG("%s\n", msg);
if (!socket_receive_all_blocking(netplay->fd, header, sizeof(header)))
{
RARCH_ERR("Cannot get header from host.\n");
return false;
}
save_state_size = core.retro_serialize_size();
if (!bsv_parse_header(header, implementation_magic_value()))
{
RARCH_ERR("Received invalid BSV header from host.\n");
return false;
}
buf = malloc(save_state_size);
if (!buf)
return false;
size = save_state_size;
if (!socket_receive_all_blocking(netplay->fd, buf, size))
{
RARCH_ERR("Failed to receive save state from host.\n");
free(buf);
return false;
}
if (save_state_size)
ret = core.retro_unserialize(buf, save_state_size);
free(buf);
return ret;
}
static bool get_info(netplay_t *handle)
{
uint32_t header[3];
if (!recv_all(handle->fd, header, sizeof(header)))
{
RARCH_ERR("Failed to receive header from client.\n");
return false;
}
if (g_extern.cart_crc != ntohl(header[0]))
{
RARCH_ERR("Cart CRC32s differ. Cannot use different games.\n");
return false;
}
if (implementation_magic_value() != ntohl(header[1]))
{
RARCH_ERR("Implementations differ, make sure you're using exact same libretro implementations and RetroArch version.\n");
return false;
}
if (pretro_get_memory_size(RETRO_MEMORY_SAVE_RAM) != ntohl(header[2]))
{
RARCH_ERR("Cartridge SRAM sizes do not correspond.\n");
return false;
}
if (!get_nickname(handle, handle->fd))
{
RARCH_ERR("Failed to get nickname from client.\n");
return false;
}
// Send SRAM data to our Player 2.
const void *sram = pretro_get_memory_data(RETRO_MEMORY_SAVE_RAM);
unsigned sram_size = pretro_get_memory_size(RETRO_MEMORY_SAVE_RAM);
if (!send_all(handle->fd, sram, sram_size))
{
RARCH_ERR("Failed to send SRAM data to client.\n");
return false;
}
if (!send_nickname(handle, handle->fd))
{
RARCH_ERR("Failed to send nickname to client.\n");
return false;
}
#ifndef HAVE_SOCKET_LEGACY
log_connection(&handle->other_addr, 0, handle->other_nick);
#endif
return true;
}
static bool get_info_spectate(netplay_t *handle)
{
if (!send_nickname(handle, handle->fd))
{
RARCH_ERR("Failed to send nickname to host.\n");
return false;
}
if (!get_nickname(handle, handle->fd))
{
RARCH_ERR("Failed to receive nickname from host.\n");
return false;
}
char msg[512];
snprintf(msg, sizeof(msg), "Connected to \"%s\"", handle->other_nick);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
RARCH_LOG("%s\n", msg);
uint32_t header[4];
if (!recv_all(handle->fd, header, sizeof(header)))
{
RARCH_ERR("Cannot get header from host.\n");
return false;
}
size_t save_state_size = pretro_serialize_size();
if (!bsv_parse_header(header, implementation_magic_value()))
{
RARCH_ERR("Received invalid BSV header from host.\n");
return false;
}
void *buf = malloc(save_state_size);
if (!buf)
return false;
size_t size = save_state_size;
if (!recv_all(handle->fd, buf, size))
{
RARCH_ERR("Failed to receive save state from host.\n");
free(buf);
return false;
}
bool ret = true;
if (save_state_size)
ret = pretro_unserialize(buf, save_state_size);
free(buf);
return ret;
}
static bool send_info(netplay_t *netplay)
{
unsigned sram_size;
char msg[512] = {0};
void *sram = NULL;
uint32_t header[3] = {0};
global_t *global = global_get_ptr();
header[0] = htonl(global->content_crc);
header[1] = htonl(implementation_magic_value());
header[2] = htonl(core.retro_get_memory_size(RETRO_MEMORY_SAVE_RAM));
if (!socket_send_all_blocking(netplay->fd, header, sizeof(header)))
return false;
if (!send_nickname(netplay, netplay->fd))
{
RARCH_ERR("Failed to send nick to host.\n");
return false;
}
/* Get SRAM data from User 1. */
sram = core.retro_get_memory_data(RETRO_MEMORY_SAVE_RAM);
sram_size = core.retro_get_memory_size(RETRO_MEMORY_SAVE_RAM);
if (!socket_receive_all_blocking(netplay->fd, sram, sram_size))
{
RARCH_ERR("Failed to receive SRAM data from host.\n");
return false;
}
if (!get_nickname(netplay, netplay->fd))
{
RARCH_ERR("Failed to receive nick from host.\n");
return false;
}
snprintf(msg, sizeof(msg), "Connected to: \"%s\"", netplay->other_nick);
RARCH_LOG("%s\n", msg);
rarch_main_msg_queue_push(msg, 1, 180, false);
return true;
}
static bool send_info(netplay_t *handle)
{
uint32_t header[3] = {
htonl(g_extern.cart_crc),
htonl(implementation_magic_value()),
htonl(pretro_get_memory_size(RETRO_MEMORY_SAVE_RAM))
};
if (!send_all(handle->fd, header, sizeof(header)))
return false;
if (!send_nickname(handle, handle->fd))
{
RARCH_ERR("Failed to send nick to host.\n");
return false;
}
// Get SRAM data from Player 1.
void *sram = pretro_get_memory_data(RETRO_MEMORY_SAVE_RAM);
unsigned sram_size = pretro_get_memory_size(RETRO_MEMORY_SAVE_RAM);
if (!recv_all(handle->fd, sram, sram_size))
{
RARCH_ERR("Failed to receive SRAM data from host.\n");
return false;
}
if (!get_nickname(handle, handle->fd))
{
RARCH_ERR("Failed to receive nick from host.\n");
return false;
}
char msg[512];
snprintf(msg, sizeof(msg), "Connected to: \"%s\"", handle->other_nick);
RARCH_LOG("%s\n", msg);
msg_queue_push(g_extern.msg_queue, msg, 1, 180);
return true;
}
int irc_login(socket)
{
printf(".:. Registration process... .:.\n");
send_user_info(socket);
send_nickname(socket);
}
static void netplay_pre_frame_spectate(netplay_t *handle)
{
unsigned i;
if (handle->spectate_client)
return;
fd_set fds;
FD_ZERO(&fds);
FD_SET(handle->fd, &fds);
struct timeval tmp_tv = {0};
if (select(handle->fd + 1, &fds, NULL, NULL, &tmp_tv) <= 0)
return;
if (!FD_ISSET(handle->fd, &fds))
return;
struct sockaddr_storage their_addr;
socklen_t addr_size = sizeof(their_addr);
int new_fd = accept(handle->fd, (struct sockaddr*)&their_addr, &addr_size);
if (new_fd < 0)
{
RARCH_ERR("Failed to accept incoming spectator.\n");
return;
}
int index = -1;
for (i = 0; i < MAX_SPECTATORS; i++)
{
if (handle->spectate_fds[i] == -1)
{
index = i;
break;
}
}
// No vacant client streams :(
if (index == -1)
{
close(new_fd);
return;
}
if (!get_nickname(handle, new_fd))
{
RARCH_ERR("Failed to get nickname from client.\n");
close(new_fd);
return;
}
if (!send_nickname(handle, new_fd))
{
RARCH_ERR("Failed to send nickname to client.\n");
close(new_fd);
return;
}
size_t header_size;
uint32_t *header = bsv_header_generate(&header_size, implementation_magic_value());
if (!header)
{
RARCH_ERR("Failed to generate BSV header.\n");
close(new_fd);
return;
}
int bufsize = header_size;
setsockopt(new_fd, SOL_SOCKET, SO_SNDBUF, CONST_CAST &bufsize, sizeof(int));
if (!send_all(new_fd, header, header_size))
{
RARCH_ERR("Failed to send header to client.\n");
close(new_fd);
free(header);
return;
}
free(header);
handle->spectate_fds[index] = new_fd;
#ifndef HAVE_SOCKET_LEGACY
log_connection(&their_addr, index, handle->other_nick);
#endif
}
int main(int argc, char *argv[]) {
int sockfd, portno;
struct sockaddr_in serv_addr;
struct hostent *server;
if (argc != 2) {
printf("Usage: client <filename>");
exit(0);
}
FILE *address_file = fopen(argv[1], "r");
// Get address of the form www.example.com:1234
fgets(buffer, BUFFER_SIZE, address_file);
char *str = strdup(buffer);
char *web_address = strsep(&str, ":");
size_t port_number = atoi(strsep(&str, ":"));
// Get nickname and strip newlines.
fgets(buffer, BUFFER_SIZE, address_file);
char nickname[64];
strtok(buffer, "\n");
strcpy(nickname, buffer);
// Get username and strip newlines.
fgets(buffer, BUFFER_SIZE, address_file);
char username[64];
strtok(buffer, "\n");
strcpy(username, buffer);
// Get realname and strip newlines
fgets(buffer, BUFFER_SIZE, address_file);
char realname[64];
strtok(buffer, "\n");
strcpy(realname, buffer);
fclose(address_file);
// Connect to server
// This is based off of the C socket tutorial at
// http://www.linuxhowtos.org/C_C++/socket.htm
portno = port_number;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
server = gethostbyname(web_address);
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
error("ERROR connecting");
send_nickname(nickname, sockfd);
send_username(username, realname, sockfd);
// listen_to_server(sockfd);
while(1) {
read_lines(sockfd);
}
close(sockfd);
return 0;
}