incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d3ff50918fda0ae0047596c1047e9b2b973ed37e
psopeeps-newserv/src/ProxyServer.cc
T
Martin Michelsen 091f3d4da4 improve proxy command documentation
2022-04-02 14:38:22 -07:00

1354 lines
54 KiB
C++
Raw Blame History

#include "ProxyServer.hh"
#include <arpa/inet.h>
#include <ctype.h>
#include <errno.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>
#include <event2/event.h>
#include <event2/listener.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <algorithm>
#include <iostream>
#include <phosg/Encoding.hh>
#include <phosg/Filesystem.hh>
#include <phosg/Network.hh>
#include <phosg/Random.hh>
#include <phosg/Strings.hh>
#include <phosg/Time.hh>
#include "PSOProtocol.hh"
#include "SendCommands.hh"
#include "ReceiveCommands.hh"
#include "ReceiveSubcommands.hh"
using namespace std;
static const uint32_t SESSION_TIMEOUT_USECS = 30000000; // 30 seconds
static void flush_and_free_bufferevent(struct bufferevent* bev) {
bufferevent_flush(bev, EV_READ | EV_WRITE, BEV_FINISHED);
bufferevent_free(bev);
}
ProxyServer::ProxyServer(
shared_ptr<struct event_base> base,
shared_ptr<ServerState> state)
: base(base),
state(state),
next_unlicensed_session_id(0xFF00000000000001) { }
void ProxyServer::listen(uint16_t port, GameVersion version,
const struct sockaddr_storage* default_destination) {
shared_ptr<ListeningSocket> socket_obj(new ListeningSocket(
this, port, version, default_destination));
auto l = this->listeners.emplace(port, socket_obj).first->second;
log(INFO, "[ProxyServer] Listening on TCP port %hu (%s) on fd %d",
port, name_for_version(version), static_cast<int>(l->fd));
}
ProxyServer::ListeningSocket::ListeningSocket(
ProxyServer* server,
uint16_t port,
GameVersion version,
const struct sockaddr_storage* default_destination)
: server(server),
port(port),
fd(::listen("", port, SOMAXCONN)),
listener(nullptr, evconnlistener_free),
version(version) {
if (!this->fd.is_open()) {
throw runtime_error("cannot listen on port");
}
this->listener.reset(evconnlistener_new(
this->server->base.get(),
&ProxyServer::ListeningSocket::dispatch_on_listen_accept,
this,
LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE,
0,
this->fd));
if (!listener) {
throw runtime_error("cannot create listener");
}
evconnlistener_set_error_cb(
this->listener.get(), &ProxyServer::ListeningSocket::dispatch_on_listen_error);
if (default_destination) {
this->default_destination = *default_destination;
} else {
this->default_destination.ss_family = 0;
}
}
void ProxyServer::ListeningSocket::dispatch_on_listen_accept(
struct evconnlistener*, evutil_socket_t fd, struct sockaddr*, int, void* ctx) {
reinterpret_cast<ListeningSocket*>(ctx)->on_listen_accept(fd);
}
void ProxyServer::ListeningSocket::dispatch_on_listen_error(
struct evconnlistener*, void* ctx) {
reinterpret_cast<ListeningSocket*>(ctx)->on_listen_error();
}
void ProxyServer::ListeningSocket::on_listen_accept(int fd) {
log(INFO, "[ProxyServer] Client connected on fd %d", fd);
auto* bev = bufferevent_socket_new(this->server->base.get(), fd,
BEV_OPT_CLOSE_ON_FREE | BEV_OPT_DEFER_CALLBACKS);
this->server->on_client_connect(bev, this->port, this->version,
(this->default_destination.ss_family == AF_INET) ? &this->default_destination : nullptr);
}
void ProxyServer::ListeningSocket::on_listen_error() {
int err = EVUTIL_SOCKET_ERROR();
log(ERROR, "[ProxyServer] Failure on listening socket %d: %d (%s)",
evconnlistener_get_fd(this->listener.get()),
err, evutil_socket_error_to_string(err));
event_base_loopexit(this->server->base.get(), nullptr);
}
void ProxyServer::connect_client(struct bufferevent* bev, uint16_t server_port) {
// Look up the listening socket for the given port, and use that game version.
// We don't support default-destination proxying for virtual connections (yet)
GameVersion version;
try {
version = this->listeners.at(server_port)->version;
} catch (const out_of_range&) {
log(INFO, "[ProxyServer] Virtual connection received on unregistered port %hu; closing it",
server_port);
flush_and_free_bufferevent(bev);
return;
}
log(INFO, "[ProxyServer] Client connected on virtual connection %p", bev);
this->on_client_connect(bev, server_port, version, nullptr);
}
void ProxyServer::on_client_connect(
struct bufferevent* bev,
uint16_t listen_port,
GameVersion version,
const struct sockaddr_storage* default_destination) {
// If a default destination exists for this client, create a linked session
// immediately and connect to the remote server. This creates a direct session
if (default_destination) {
uint64_t session_id = this->next_unlicensed_session_id++;
if (this->next_unlicensed_session_id == 0) {
this->next_unlicensed_session_id = 0xFF00000000000001;
}
auto emplace_ret = this->id_to_session.emplace(session_id, new LinkedSession(
this, session_id, listen_port, version, *default_destination));
if (!emplace_ret.second) {
throw logic_error("linked session already exists for unlicensed client");
}
auto session = emplace_ret.first->second;
log(INFO, "[ProxyServer/%08" PRIX64 "] Opened linked session", session->id);
session->resume(bev);
// If no default destination exists, create an unlinked session - we'll have
// to get the destination from the client's config, which we'll get via a 9E
// command soon
} else {
auto emplace_ret = this->bev_to_unlinked_session.emplace(bev, new UnlinkedSession(
this, bev, listen_port, version));
if (!emplace_ret.second) {
throw logic_error("stale unlinked session exists");
}
auto session = emplace_ret.first->second;
log(INFO, "[ProxyServer] Opened unlinked session");
switch (version) {
case GameVersion::PATCH:
throw logic_error("cannot create unlinked patch session");
case GameVersion::PC:
case GameVersion::GC: {
uint32_t server_key = random_object<uint32_t>();
uint32_t client_key = random_object<uint32_t>();
auto cmd = prepare_server_init_contents_dc_pc_gc(
false, server_key, client_key);
send_command(
session->bev.get(),
session->version,
session->crypt_out.get(),
0x02,
0,
&cmd,
sizeof(cmd),
"unlinked proxy client");
bufferevent_flush(session->bev.get(), EV_READ | EV_WRITE, BEV_FLUSH);
if (version == GameVersion::PC) {
session->crypt_out.reset(new PSOPCEncryption(server_key));
session->crypt_in.reset(new PSOPCEncryption(client_key));
} else {
session->crypt_out.reset(new PSOGCEncryption(server_key));
session->crypt_in.reset(new PSOGCEncryption(client_key));
}
break;
}
default:
throw logic_error("unsupported game version on proxy server");
}
}
}
ProxyServer::UnlinkedSession::UnlinkedSession(
ProxyServer* server, struct bufferevent* bev, uint16_t local_port, GameVersion version)
: server(server),
bev(bev, flush_and_free_bufferevent),
local_port(local_port),
version(version) {
bufferevent_setcb(this->bev.get(),
&UnlinkedSession::dispatch_on_client_input, nullptr,
&UnlinkedSession::dispatch_on_client_error, this);
bufferevent_enable(this->bev.get(), EV_READ | EV_WRITE);
}
void ProxyServer::UnlinkedSession::dispatch_on_client_input(
struct bufferevent*, void* ctx) {
reinterpret_cast<UnlinkedSession*>(ctx)->on_client_input();
}
void ProxyServer::UnlinkedSession::dispatch_on_client_error(
struct bufferevent*, short events, void* ctx) {
reinterpret_cast<UnlinkedSession*>(ctx)->on_client_error(events);
}
void ProxyServer::UnlinkedSession::on_client_input() {
bool should_close_unlinked_session = false;
shared_ptr<const License> license;
uint32_t sub_version = 0;
string character_name;
ClientConfig client_config;
for_each_received_command(this->bev.get(), this->version, this->crypt_in.get(),
[&](uint16_t command, uint32_t flag, const string& data) {
print_received_command(command, flag, data.data(), data.size(),
this->version, "unlinked proxy client");
if (this->version == GameVersion::PC) {
// We should only get a 9D while the session is unlinked; if we get
// anything else, disconnect
if (command != 0x9D) {
log(ERROR, "[ProxyServer] Received unexpected command %02hX", command);
should_close_unlinked_session = true;
} else if (data.size() < sizeof(C_Login_GC_9E) - 0x64) {
log(ERROR, "[ProxyServer] Login command is too small");
should_close_unlinked_session = true;
} else {
const auto* cmd = reinterpret_cast<const C_Login_GC_9E*>(data.data());
uint32_t serial_number = strtoul(cmd->serial_number.c_str(), nullptr, 16);
try {
license = this->server->state->license_manager->verify_pc(
serial_number, cmd->access_key.c_str(), nullptr);
sub_version = cmd->sub_version;
character_name = cmd->name;
client_config = cmd->client_config.cfg;
} catch (const exception& e) {
log(ERROR, "[ProxyServer] Unlinked client has no valid license");
should_close_unlinked_session = true;
}
}
} else if (this->version == GameVersion::GC) {
// We should only get a 9E while the session is unlinked; if we get
// anything else, disconnect
if (command != 0x9E) {
log(ERROR, "[ProxyServer] Received unexpected command %02hX", command);
should_close_unlinked_session = true;
} else if (data.size() < sizeof(C_Login_GC_9E) - 0x64) {
log(ERROR, "[ProxyServer] Login command is too small");
should_close_unlinked_session = true;
} else {
const auto* cmd = reinterpret_cast<const C_Login_GC_9E*>(data.data());
uint32_t serial_number = strtoul(cmd->serial_number.c_str(), nullptr, 16);
try {
license = this->server->state->license_manager->verify_gc(
serial_number, cmd->access_key.c_str(), nullptr);
sub_version = cmd->sub_version;
character_name = cmd->name;
client_config = cmd->client_config.cfg;
} catch (const exception& e) {
log(ERROR, "[ProxyServer] Unlinked client has no valid license");
should_close_unlinked_session = true;
}
}
} else {
throw logic_error("unsupported unlinked session version");
}
});
struct bufferevent* session_key = this->bev.get();
// If license is non-null, then the client has a password and can be connected
// to the remote lobby server.
if (license.get()) {
// At this point, we will always close the unlinked session, even if it
// doesn't get converted/merged to a linked session
should_close_unlinked_session = true;
// Look up the linked session for this license (if any)
shared_ptr<LinkedSession> session;
try {
session = this->server->id_to_session.at(license->serial_number);
log(INFO, "[ProxyServer/%08" PRIX64 "] Resuming linked session from unlinked session", session->id);
} catch (const out_of_range&) {
// If there's no open session for this license, then there must be a valid
// destination in the client config. If there is, open a new linked
// session and set its initial destination
if (client_config.magic != CLIENT_CONFIG_MAGIC) {
log(ERROR, "[ProxyServer] Client configuration is invalid; cannot open session");
} else {
session.reset(new LinkedSession(
this->server,
this->local_port,
this->version,
license,
client_config));
this->server->id_to_session.emplace(license->serial_number, session);
log(INFO, "[ProxyServer/%08" PRIX64 "] Opened licensed session for unlinked session", session->id);
}
}
if (session.get() && (session->version != this->version)) {
log(ERROR, "[ProxyServer/%08" PRIX64 "] Linked session has different game version",
session->id);
} else {
// Resume the linked session using the unlinked session
try {
session->resume(move(this->bev), this->crypt_in, this->crypt_out, sub_version, character_name);
this->crypt_in.reset();
this->crypt_out.reset();
} catch (const exception& e) {
log(ERROR, "[ProxyServer/%08" PRIX64 "] Failed to resume linked session: %s",
session->id, e.what());
}
}
}
if (should_close_unlinked_session) {
this->server->bev_to_unlinked_session.erase(session_key);
// At this point, (*this) is destroyed! We must be careful not to touch it.
}
}
void ProxyServer::UnlinkedSession::on_client_error(short events) {
if (events & BEV_EVENT_ERROR) {
int err = EVUTIL_SOCKET_ERROR();
log(WARNING, "[ProxyServer] Error %d (%s) in unlinked client stream", err,
evutil_socket_error_to_string(err));
}
if (events & (BEV_EVENT_ERROR | BEV_EVENT_EOF)) {
log(WARNING, "[ProxyServer] Unlinked client has disconnected");
this->server->bev_to_unlinked_session.erase(this->bev.get());
}
}
ProxyServer::LinkedSession::LinkedSession(
ProxyServer* server,
uint64_t id,
uint16_t local_port,
GameVersion version)
: server(server),
id(id),
timeout_event(event_new(this->server->base.get(), -1, EV_TIMEOUT,
&LinkedSession::dispatch_on_timeout, this), event_free),
license(nullptr),
client_bev(nullptr, flush_and_free_bufferevent),
server_bev(nullptr, flush_and_free_bufferevent),
local_port(local_port),
version(version),
sub_version(0), // This is set during resume()
guild_card_number(0),
suppress_newserv_commands(true),
enable_chat_filter(true),
enable_switch_assist(false),
save_files(false),
override_section_id(-1),
override_lobby_event(-1),
override_lobby_number(-1),
lobby_players(12),
lobby_client_id(0) { }
ProxyServer::LinkedSession::LinkedSession(
ProxyServer* server,
uint16_t local_port,
GameVersion version,
std::shared_ptr<const License> license,
const ClientConfig& newserv_client_config)
: LinkedSession(server, license->serial_number, local_port, version) {
this->license = license;
this->newserv_client_config = newserv_client_config;
memset(&this->next_destination, 0, sizeof(this->next_destination));
struct sockaddr_in* dest_sin = reinterpret_cast<struct sockaddr_in*>(&this->next_destination);
dest_sin->sin_family = AF_INET;
dest_sin->sin_port = htons(this->newserv_client_config.proxy_destination_port);
dest_sin->sin_addr.s_addr = htonl(this->newserv_client_config.proxy_destination_address);
}
ProxyServer::LinkedSession::LinkedSession(
ProxyServer* server,
uint64_t id,
uint16_t local_port,
GameVersion version,
const struct sockaddr_storage& destination)
: LinkedSession(server, id, local_port, version) {
this->next_destination = destination;
}
void ProxyServer::LinkedSession::resume(
std::unique_ptr<struct bufferevent, void(*)(struct bufferevent*)>&& client_bev,
std::shared_ptr<PSOEncryption> client_input_crypt,
std::shared_ptr<PSOEncryption> client_output_crypt,
uint32_t sub_version,
const string& character_name) {
if (this->client_bev.get()) {
throw runtime_error("client connection is already open for this session");
}
if (this->next_destination.ss_family != AF_INET) {
throw logic_error("attempted to resume an unlicensed linked session wihout destination set");
}
this->client_bev = move(client_bev);
bufferevent_setcb(this->client_bev.get(),
&ProxyServer::LinkedSession::dispatch_on_client_input, nullptr,
&ProxyServer::LinkedSession::dispatch_on_client_error, this);
bufferevent_enable(this->client_bev.get(), EV_READ | EV_WRITE);
this->client_input_crypt = client_input_crypt;
this->client_output_crypt = client_output_crypt;
this->sub_version = sub_version;
this->character_name = character_name;
this->server_input_crypt.reset();
this->server_output_crypt.reset();
this->saving_files.clear();
this->connect();
}
void ProxyServer::LinkedSession::resume(struct bufferevent* client_bev) {
if (this->client_bev.get()) {
throw runtime_error("client connection is already open for this session");
}
this->client_bev.reset(client_bev);
bufferevent_setcb(this->client_bev.get(),
&ProxyServer::LinkedSession::dispatch_on_client_input, nullptr,
&ProxyServer::LinkedSession::dispatch_on_client_error, this);
bufferevent_enable(this->client_bev.get(), EV_READ | EV_WRITE);
this->client_input_crypt.reset();
this->client_output_crypt.reset();
this->server_input_crypt.reset();
this->server_output_crypt.reset();
this->sub_version = 0;
this->character_name.clear();
this->saving_files.clear();
this->connect();
}
void ProxyServer::LinkedSession::connect() {
// Connect to the remote server. The command handlers will do the login steps
// and set up forwarding
this->server_bev.reset(bufferevent_socket_new(this->server->base.get(), -1,
BEV_OPT_CLOSE_ON_FREE | BEV_OPT_DEFER_CALLBACKS));
struct sockaddr_storage local_ss;
struct sockaddr_in* local_sin = reinterpret_cast<struct sockaddr_in*>(&local_ss);
memset(local_sin, 0, sizeof(*local_sin));
local_sin->sin_family = AF_INET;
const struct sockaddr_in* dest_sin = reinterpret_cast<const sockaddr_in*>(&this->next_destination);
if (dest_sin->sin_family != AF_INET) {
throw logic_error("ss not AF_INET");
}
local_sin->sin_port = dest_sin->sin_port;
local_sin->sin_addr.s_addr = dest_sin->sin_addr.s_addr;
string netloc_str = render_sockaddr_storage(local_ss);
log(INFO, "[ProxyServer/%08" PRIX64 "] Connecting to %s", this->id, netloc_str.c_str());
if (bufferevent_socket_connect(this->server_bev.get(),
reinterpret_cast<const sockaddr*>(local_sin), sizeof(*local_sin)) != 0) {
throw runtime_error(string_printf("failed to connect (%d)", EVUTIL_SOCKET_ERROR()));
}
bufferevent_setcb(this->server_bev.get(),
&ProxyServer::LinkedSession::dispatch_on_server_input, nullptr,
&ProxyServer::LinkedSession::dispatch_on_server_error, this);
bufferevent_enable(this->server_bev.get(), EV_READ | EV_WRITE);
// Cancel the session delete timeout
event_del(this->timeout_event.get());
}
ProxyServer::LinkedSession::SavingFile::SavingFile(
const std::string& basename,
const std::string& output_filename,
uint32_t remaining_bytes)
: basename(basename),
output_filename(output_filename),
remaining_bytes(remaining_bytes),
f(fopen_unique(this->output_filename, "wb")) { }
void ProxyServer::LinkedSession::dispatch_on_client_input(
struct bufferevent*, void* ctx) {
reinterpret_cast<LinkedSession*>(ctx)->on_client_input();
}
void ProxyServer::LinkedSession::dispatch_on_client_error(
struct bufferevent*, short events, void* ctx) {
reinterpret_cast<LinkedSession*>(ctx)->on_stream_error(events, false);
}
void ProxyServer::LinkedSession::dispatch_on_server_input(
struct bufferevent*, void* ctx) {
reinterpret_cast<LinkedSession*>(ctx)->on_server_input();
}
void ProxyServer::LinkedSession::dispatch_on_server_error(
struct bufferevent*, short events, void* ctx) {
reinterpret_cast<LinkedSession*>(ctx)->on_stream_error(events, true);
}
void ProxyServer::LinkedSession::dispatch_on_timeout(
evutil_socket_t, short, void* ctx) {
reinterpret_cast<LinkedSession*>(ctx)->on_timeout();
}
void ProxyServer::LinkedSession::on_timeout() {
log(INFO, "[ProxyServer/%08" PRIX64 "] Session timed out", this->id);
this->server->delete_session(this->id);
}
void ProxyServer::LinkedSession::on_stream_error(
short events, bool is_server_stream) {
if (events & BEV_EVENT_ERROR) {
int err = EVUTIL_SOCKET_ERROR();
log(WARNING, "[ProxyServer/%08" PRIX64 "] Error %d (%s) in %s stream",
this->id, err, evutil_socket_error_to_string(err),
is_server_stream ? "server" : "client");
}
if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
log(INFO, "[ProxyServer/%08" PRIX64 "] %s has disconnected",
this->id, is_server_stream ? "Server" : "Client");
this->disconnect();
}
}
void ProxyServer::LinkedSession::disconnect() {
// Forward the disconnection to the other end
this->server_bev.reset();
this->client_bev.reset();
// Disable encryption for the next connection
this->server_input_crypt.reset();
this->server_output_crypt.reset();
this->client_input_crypt.reset();
this->client_output_crypt.reset();
// Set a timeout to delete the session entirely (in case the client doesn't
// reconnect)
struct timeval tv = usecs_to_timeval(SESSION_TIMEOUT_USECS);
event_add(this->timeout_event.get(), &tv);
}
static void check_implemented_subcommand(uint64_t id, const string& data) {
if (data.size() < 4) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Received broadcast/target command with no contents", id);
} else {
if (!subcommand_is_implemented(data[0])) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Received subcommand %02hhX which is not implemented on the server",
id, data[0]);
}
}
}
void ProxyServer::LinkedSession::on_client_input() {
string name = string_printf("ProxySession:%08" PRIX64 ":client", this->id);
for_each_received_command(this->client_bev.get(), this->version, this->client_input_crypt.get(),
[&](uint16_t command, uint32_t flag, string& data) {
print_received_command(command, flag, data.data(), data.size(),
this->version, name.c_str());
bool should_forward = true;
switch (command) {
case 0x06:
if (this->version != GameVersion::GC) {
break;
}
if (data.size() < 12) {
break;
}
// If this chat message looks like a newserv chat command, suppress it
if (this->suppress_newserv_commands &&
(data[8] == '$' || (data[8] == '\t' && data[9] != 'C' && data[10] == '$'))) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Chat message appears to be a server command; dropping it",
this->id);
should_forward = false;
} else if (this->enable_chat_filter) {
// Turn all $ into \t and all # into \n
add_color_inplace(data.data() + 8, data.size() - 8);
}
break;
case 0x60:
case 0x62:
case 0x6C:
case 0x6D:
case 0xC9:
case 0xCB:
check_implemented_subcommand(this->id, data);
if (!data.empty() && (data[0] == 0x05) && (data[data.size() - 1] == 0x01) && this->enable_switch_assist) {
if (!this->last_switch_enabled_subcommand.empty()) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Switch assist: replaying previous enable subcommand",
this->id);
send_command(this->client_bev.get(), this->version,
this->client_output_crypt.get(), 0x60, 0x00,
this->last_switch_enabled_subcommand.data(),
this->last_switch_enabled_subcommand.size(), name.c_str());
}
this->last_switch_enabled_subcommand = data;
}
break;
case 0xA0: // Change ship
case 0xA1: { // Change block
if ((this->version == GameVersion::PATCH) || (this->version == GameVersion::BB)) {
break;
}
if (!this->license) {
break;
}
// These will take you back to the newserv main menu instead of the
// proxied service's menu
// Delete all the other players
for (size_t x = 0; x < this->lobby_players.size(); x++) {
if (this->lobby_players[x].guild_card_number == 0) {
continue;
}
uint8_t leaving_id = x;
uint8_t leader_id = this->lobby_client_id;
S_LeaveLobby_66_69 cmd = {leaving_id, leader_id, 0};
send_command(this->client_bev.get(), this->version,
this->client_output_crypt.get(), 0x69, leaving_id, &cmd,
sizeof(cmd), name.c_str());
}
// Restore the newserv client config, so the client gets its newserv
// guild card number back and the login server knows e.g. not to show
// the welcome message (if the appropriate flag is set)
S_UpdateClientConfig_DC_PC_GC_04 update_client_config_cmd = {
0x00010000,
this->license->serial_number,
this->newserv_client_config,
};
send_command(this->client_bev.get(), this->version,
this->client_output_crypt.get(), 0x04, 0x00,
&update_client_config_cmd, sizeof(update_client_config_cmd),
name.c_str());
static const vector<string> version_to_port_name({
"dc-login", "pc-login", "bb-patch", "gc-us3", "bb-login"});
const auto& port_name = version_to_port_name.at(static_cast<size_t>(
this->version));
S_Reconnect_19 reconnect_cmd = {
0, this->server->state->name_to_port_config.at(port_name)->port, 0};
// If the client is on a virtual connection, we can use any address
// here and they should be able to connect back to the game server. If
// the client is on a real connection, we'll use the sockname of the
// existing connection (like we do in the server 19 command handler).
int fd = bufferevent_getfd(this->client_bev.get());
if (fd < 0) {
struct sockaddr_in* dest_sin = reinterpret_cast<struct sockaddr_in*>(&this->next_destination);
if (dest_sin->sin_family != AF_INET) {
throw logic_error("ss not AF_INET");
}
reconnect_cmd.address.store_raw(dest_sin->sin_addr.s_addr);
} else {
struct sockaddr_storage sockname_ss;
socklen_t len = sizeof(sockname_ss);
getsockname(fd, reinterpret_cast<struct sockaddr*>(&sockname_ss), &len);
if (sockname_ss.ss_family != AF_INET) {
throw logic_error("existing connection is not ipv4");
}
struct sockaddr_in* sockname_sin = reinterpret_cast<struct sockaddr_in*>(
&sockname_ss);
reconnect_cmd.address.store_raw(sockname_sin->sin_addr.s_addr);
}
send_command(this->client_bev.get(), this->version,
this->client_output_crypt.get(), 0x19, 0x00, &reconnect_cmd,
sizeof(reconnect_cmd), name.c_str());
break;
}
}
if (should_forward) {
if (!this->client_bev.get()) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] No server is present; dropping command",
this->id);
} else {
// Note: we intentionally don't pass a name string here because we already
// printed the command above
send_command(this->server_bev.get(), this->version,
this->server_output_crypt.get(), command, flag,
data.data(), data.size());
}
}
});
}
void ProxyServer::LinkedSession::on_server_input() {
string name = string_printf("ProxySession:%08" PRIX64 ":server", this->id);
try {
for_each_received_command(this->server_bev.get(), this->version, this->server_input_crypt.get(),
[&](uint16_t command, uint32_t flag, string& data) {
print_received_command(command, flag, data.data(), data.size(),
this->version, name.c_str());
// In the case of server init commands, the client output crypt cannot
// be set until after we forwarwd the command to the client, hence this
// variable.
shared_ptr<PSOEncryption> new_client_output_crypt;
bool should_forward = true;
switch (command) {
case 0x02:
case 0x17: {
if (this->version == GameVersion::PATCH && command == 0x17) {
throw invalid_argument("patch server sent 17 server init");
}
if (this->version == GameVersion::BB) {
throw invalid_argument("console server init received on BB");
}
// Most servers don't include after_message or have a shorter
// after_message than newserv does, so don't require it
if (data.size() < offsetof(S_ServerInit_DC_PC_GC_02_17, after_message)) {
throw std::runtime_error("init encryption command is too small");
}
const auto* cmd = reinterpret_cast<const S_ServerInit_DC_PC_GC_02_17*>(
data.data());
if (!this->license) {
log(INFO, "[ProxyServer/%08" PRIX64 "] No license in linked session",
this->id);
if ((this->version == GameVersion::PC) || (this->version == GameVersion::PATCH)) {
this->server_input_crypt.reset(new PSOPCEncryption(cmd->server_key));
this->server_output_crypt.reset(new PSOPCEncryption(cmd->client_key));
this->client_input_crypt.reset(new PSOPCEncryption(cmd->client_key));
new_client_output_crypt.reset(new PSOPCEncryption(cmd->server_key));
} else if (this->version == GameVersion::GC) {
this->server_input_crypt.reset(new PSOGCEncryption(cmd->server_key));
this->server_output_crypt.reset(new PSOGCEncryption(cmd->client_key));
this->client_input_crypt.reset(new PSOGCEncryption(cmd->client_key));
new_client_output_crypt.reset(new PSOGCEncryption(cmd->server_key));
} else {
throw invalid_argument("unsupported version");
}
break;
} else {
log(INFO, "[ProxyServer/%08" PRIX64 "] Existing license in linked session",
this->id);
// This doesn't get forwarded to the client, so don't recreate the
// client's crypts
if (this->version == GameVersion::PATCH) {
throw logic_error("patch session is indirect");
} else if (this->version == GameVersion::PC) {
this->server_input_crypt.reset(new PSOPCEncryption(cmd->server_key));
this->server_output_crypt.reset(new PSOPCEncryption(cmd->client_key));
} else if (this->version == GameVersion::GC) {
this->server_input_crypt.reset(new PSOGCEncryption(cmd->server_key));
this->server_output_crypt.reset(new PSOGCEncryption(cmd->client_key));
} else {
throw invalid_argument("unsupported version");
}
should_forward = false;
// Respond with an appropriate login command. We don't let the
// client do this because it believes it already did (when it was
// in an unlinked session).
if (this->version == GameVersion::PC) {
C_Login_PC_9D cmd;
if (this->guild_card_number == 0) {
cmd.player_tag = 0xFFFF0000;
cmd.guild_card_number = 0xFFFFFFFF;
} else {
cmd.player_tag = 0x00010000;
cmd.guild_card_number = this->guild_card_number;
}
cmd.unused = 0xFFFFFFFFFFFF0000;
cmd.sub_version = this->sub_version;
cmd.unused2.data()[1] = 1;
cmd.serial_number = string_printf("%08" PRIX32 "",
this->license->serial_number);
cmd.access_key = this->license->access_key;
cmd.serial_number2 = cmd.serial_number;
cmd.access_key2 = cmd.access_key;
cmd.name = this->character_name;
send_command(this->server_bev.get(), this->version,
this->server_output_crypt.get(), 0x9D, 0, &cmd, sizeof(cmd),
name.c_str());
break;
} else if (this->version == GameVersion::GC) {
if (command == 0x17) {
C_VerifyLicense_GC_DB cmd;
cmd.serial_number = string_printf("%08" PRIX32 "",
this->license->serial_number);
cmd.access_key = this->license->access_key;
cmd.sub_version = this->sub_version;
cmd.serial_number2 = cmd.serial_number;
cmd.access_key2 = cmd.access_key;
cmd.password = this->license->gc_password;
send_command(this->server_bev.get(), this->version,
this->server_output_crypt.get(), 0xDB, 0, &cmd, sizeof(cmd),
name.c_str());
break;
}
} else {
throw logic_error("invalid game version in server init handler");
}
}
// If we get here, then:
// - The session has a license
// - The session's version is GC
// - The received command is 02, not 17
// The command should be handled like 9A at this point (we should
// send a 9E in response). GCC can't seem to understand this
// fallthrough label unless it's right here, so we can't put it in a
// more intuitive place (e.g. in an `else` above), unfortunately.
[[fallthrough]];
}
case 0x9A: {
if (!this->license) {
break;
}
if (this->version != GameVersion::GC) {
throw runtime_error("9A received in non-GC session");
}
should_forward = false;
C_LoginWithUnusedSpace_GC_9E cmd;
if (this->guild_card_number == 0) {
cmd.player_tag = 0xFFFF0000;
cmd.guild_card_number = 0xFFFFFFFF;
} else {
cmd.player_tag = 0x00010000;
cmd.guild_card_number = this->guild_card_number;
}
cmd.sub_version = this->sub_version;
cmd.unused2.data()[1] = 1;
cmd.serial_number = string_printf("%08" PRIX32 "",
this->license->serial_number);
cmd.access_key = this->license->access_key;
cmd.serial_number2 = cmd.serial_number;
cmd.access_key2 = cmd.access_key;
cmd.name = this->character_name;
cmd.client_config.data = this->remote_client_config_data;
// If there's a guild card number, a shorter 9E is sent that ends
// right after the client config data
send_command(
this->server_bev.get(),
this->version,
this->server_output_crypt.get(),
0x9E,
0x01,
&cmd,
sizeof(C_LoginWithUnusedSpace_GC_9E) - (this->guild_card_number ? sizeof(cmd.unused_space) : 0),
name.c_str());
break;
}
case 0x04: {
// Some servers send a short 04 command if they don't use all of the
// 0x20 bytes available. We should be prepared to handle that.
if (data.size() < offsetof(S_UpdateClientConfig_DC_PC_GC_04, cfg)) {
throw std::runtime_error("set security data command is too small");
}
bool had_guild_card_number = (this->guild_card_number != 0);
const auto* cmd = reinterpret_cast<const S_UpdateClientConfig_DC_PC_GC_04*>(data.data());
this->guild_card_number = cmd->guild_card_number;
log(INFO, "[ProxyServer/%08" PRIX64 "] Guild card number set to %" PRIX32,
this->id, this->guild_card_number);
// It seems the client ignores the length of the 04 command, and
// always copies 0x20 bytes to its config data. So if the server
// sends a short 04 command, part of the previous command ends up in
// the security data (usually part of the copyright string from the
// server init command). We simulate that bug here.
// If there was previously a guild card number, assume we got the
// lobby server init text instead of the port map init text.
memcpy(this->remote_client_config_data.data(),
had_guild_card_number
? "t Lobby Server. Copyright SEGA E"
: "t Port Map. Copyright SEGA Enter",
this->remote_client_config_data.bytes());
memcpy(this->remote_client_config_data.data(), &cmd->cfg,
min<size_t>(data.size() - sizeof(S_UpdateClientConfig_DC_PC_GC_04),
this->remote_client_config_data.bytes()));
// If the guild card number was not set, pretend (to the server)
// that this is the first 04 command the client has received. The
// client responds with a 96 (checksum) in that case.
if (!had_guild_card_number) {
// We don't actually have a client checksum, of course...
// hopefully just random data will do (probably no private servers
// check this at all)
le_uint64_t checksum = random_object<uint64_t>() & 0x0000FFFFFFFFFFFF;
send_command(this->server_bev.get(), this->version,
this->server_output_crypt.get(), 0x96, 0x00, &checksum,
sizeof(checksum), name.c_str());
}
break;
}
case 0x19: {
if (this->version == GameVersion::PATCH) {
break;
}
if (data.size() < sizeof(S_Reconnect_19)) {
throw std::runtime_error("reconnect command is too small");
}
auto* args = reinterpret_cast<S_Reconnect_19*>(data.data());
memset(&this->next_destination, 0, sizeof(this->next_destination));
struct sockaddr_in* sin = reinterpret_cast<struct sockaddr_in*>(
&this->next_destination);
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = args->address.load_raw();
sin->sin_port = htons(args->port);
if (!this->client_bev.get()) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Received reconnect command with no destination present",
this->id);
} else {
// If the client is on a virtual connection (fd < 0), only change
// the port (so we'll know which version to treat the next
// connection as). It's better to leave the address as-is so we
// can circumvent the Plus/Ep3 same-network-server check.
int fd = bufferevent_getfd(this->client_bev.get());
if (fd >= 0) {
struct sockaddr_storage sockname_ss;
socklen_t len = sizeof(sockname_ss);
getsockname(fd, reinterpret_cast<struct sockaddr*>(&sockname_ss), &len);
if (sockname_ss.ss_family != AF_INET) {
throw logic_error("existing connection is not ipv4");
}
struct sockaddr_in* sockname_sin = reinterpret_cast<struct sockaddr_in*>(
&sockname_ss);
args->address.store_raw(sockname_sin->sin_addr.s_addr);
args->port = ntohs(sockname_sin->sin_port);
} else {
args->port = this->local_port;
}
}
break;
}
case 0x1A:
case 0xD5: {
if (this->version != GameVersion::GC) {
break;
}
// If the client has the no-close-confirmation flag set in its
// newserv client config, send a fake confirmation to the remote
// server immediately.
if (this->newserv_client_config.flags & Client::Flag::NO_MESSAGE_BOX_CLOSE_CONFIRMATION) {
send_command(this->server_bev.get(), this->version,
this->server_output_crypt.get(), 0xD6, 0x00, "", 0,
name.c_str());
}
break;
}
case 0x60:
case 0x62:
case 0x6C:
case 0x6D:
case 0xC9:
case 0xCB:
check_implemented_subcommand(this->id, data);
break;
case 0x44:
case 0xA6: {
if (this->version != GameVersion::GC) {
break;
}
if (!this->save_files) {
break;
}
bool is_download_quest = (command == 0xA6);
if (data.size() < sizeof(S_OpenFile_PC_GC_44_A6)) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Open file command is too small; skipping file",
this->id);
break;
}
const auto* cmd = reinterpret_cast<const S_OpenFile_PC_GC_44_A6*>(data.data());
string output_filename = string_printf("%s.%s.%" PRIu64,
cmd->filename.c_str(),
is_download_quest ? "download" : "online", now());
for (size_t x = 0; x < output_filename.size(); x++) {
if (output_filename[x] < 0x20 || output_filename[x] > 0x7E || output_filename[x] == '/') {
output_filename[x] = '_';
}
}
if (output_filename[0] == '.') {
output_filename[0] = '_';
}
SavingFile sf(cmd->filename, output_filename, cmd->file_size);
this->saving_files.emplace(cmd->filename, move(sf));
log(INFO, "[ProxyServer/%08" PRIX64 "] Opened file %s",
this->id, output_filename.c_str());
break;
}
case 0x13:
case 0xA7: {
if (this->version != GameVersion::GC) {
break;
}
if (!this->save_files) {
break;
}
if (data.size() < sizeof(S_WriteFile_13_A7)) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Write file command is too small",
this->id);
break;
}
const auto* cmd = reinterpret_cast<const S_WriteFile_13_A7*>(data.data());
SavingFile* sf = nullptr;
try {
sf = &this->saving_files.at(cmd->filename);
} catch (const out_of_range&) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Received data for non-open file %s",
this->id, cmd->filename.c_str());
break;
}
size_t bytes_to_write = cmd->data_size;
if (bytes_to_write > 0x400) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Chunk data size is invalid; truncating to 0x400",
this->id);
bytes_to_write = 0x400;
}
log(INFO, "[ProxyServer/%08" PRIX64 "] Writing %zu bytes to %s",
this->id, bytes_to_write,
sf->output_filename.c_str());
fwritex(sf->f.get(), cmd->data, bytes_to_write);
if (bytes_to_write > sf->remaining_bytes) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Chunk size extends beyond original file size; file may be truncated",
this->id);
sf->remaining_bytes = 0;
} else {
sf->remaining_bytes -= bytes_to_write;
}
if (sf->remaining_bytes == 0) {
log(INFO, "[ProxyServer/%08" PRIX64 "] File %s is complete",
this->id, sf->output_filename.c_str());
this->saving_files.erase(cmd->filename);
}
break;
}
case 0xB8: {
if (this->version != GameVersion::GC) {
break;
}
if (!this->save_files) {
break;
}
if (data.size() < 4) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Card list data size is too small; skipping file",
this->id);
break;
}
StringReader r(data);
size_t size = r.get_u32l();
if (r.remaining() < size) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Card list data size extends beyond end of command; skipping file",
this->id);
break;
}
string output_filename = string_printf("cardupdate.mnr.%" PRIu64, now());
save_file(output_filename, r.read(size));
log(INFO, "[ProxyServer/%08" PRIX64 "] Wrote %zu bytes to %s",
this->id, size, output_filename.c_str());
break;
}
case 0x67: // join lobby
if (this->version != GameVersion::GC) {
break;
}
this->lobby_players.clear();
this->lobby_players.resize(12);
log(WARNING, "[ProxyServer/%08" PRIX64 "] Cleared lobby players",
this->id);
// This command can cause the client to no longer send D6 responses
// when 1A/D5 large message boxes are closed. newserv keeps track of
// this behavior in the client config, so if it happens during a
// proxy session, update the client config that we'll restore if the
// client uses the change ship or change block command.
if (this->newserv_client_config.flags & Client::Flag::NO_MESSAGE_BOX_CLOSE_CONFIRMATION_AFTER_LOBBY_JOIN) {
this->newserv_client_config.flags |= Client::Flag::NO_MESSAGE_BOX_CLOSE_CONFIRMATION;
}
[[fallthrough]];
case 0x65: // other player joined game
case 0x68: { // other player joined lobby
if (this->version != GameVersion::GC) {
break;
}
size_t expected_size = offsetof(S_JoinLobby_GC_65_67_68, entries) + sizeof(S_JoinLobby_GC_65_67_68::Entry) * flag;
if (data.size() < expected_size) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Lobby join command is incorrect size (expected 0x%zX bytes, received 0x%zX bytes)",
this->id, expected_size, data.size());
} else {
auto* cmd = reinterpret_cast<S_JoinLobby_GC_65_67_68*>(data.data());
this->lobby_client_id = cmd->client_id;
for (size_t x = 0; x < flag; x++) {
size_t index = cmd->entries[x].lobby_data.client_id;
if (index >= this->lobby_players.size()) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Ignoring invalid player index %zu at position %zu",
this->id, index, x);
} else {
this->lobby_players[index].guild_card_number = cmd->entries[x].lobby_data.guild_card;
this->lobby_players[index].name = cmd->entries[x].disp.name;
log(INFO, "[ProxyServer/%08" PRIX64 "] Added lobby player: (%zu) %" PRIu32 " %s",
this->id, index,
this->lobby_players[index].guild_card_number,
this->lobby_players[index].name.c_str());
}
}
if (this->override_lobby_event >= 0) {
cmd->event = this->override_lobby_event;
}
if (this->override_lobby_number >= 0) {
cmd->lobby_number = this->override_lobby_number;
}
}
break;
}
case 0x64: { // join game
if (this->version != GameVersion::GC) {
break;
}
// We don't need to clear lobby_players here because we always
// overwrite all 4 entries in this case
this->lobby_players.resize(4);
log(WARNING, "[ProxyServer/%08" PRIX64 "] Cleared lobby players",
this->id);
const size_t expected_size = offsetof(S_JoinGame_GC_64, players_ep3);
const size_t ep3_expected_size = sizeof(S_JoinGame_GC_64);
if (data.size() < expected_size) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Game join command is incorrect size (expected 0x%zX bytes, received 0x%zX bytes)",
this->id, expected_size, data.size());
} else {
auto* cmd = reinterpret_cast<S_JoinGame_GC_64*>(data.data());
this->lobby_client_id = cmd->client_id;
for (size_t x = 0; x < flag; x++) {
this->lobby_players[x].guild_card_number = cmd->lobby_data[x].guild_card;
if (data.size() >= ep3_expected_size) {
this->lobby_players[x].name = cmd->players_ep3[x].disp.name;
} else {
this->lobby_players[x].name.clear();
}
log(INFO, "[ProxyServer/%08" PRIX64 "] Added lobby player: (%zu) %" PRIu32 " %s",
this->id, x,
this->lobby_players[x].guild_card_number,
this->lobby_players[x].name.c_str());
}
if (this->override_section_id >= 0) {
cmd->section_id = this->override_section_id;
}
if (this->override_lobby_event >= 0) {
cmd->event = this->override_lobby_event;
}
}
break;
}
case 0x66:
case 0x69: {
if (this->version != GameVersion::GC) {
break;
}
if (data.size() < sizeof(S_LeaveLobby_66_69)) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Lobby leave command is incorrect size",
this->id);
} else {
const auto* cmd = reinterpret_cast<const S_LeaveLobby_66_69*>(data.data());
size_t index = cmd->client_id;
if (index >= this->lobby_players.size()) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Lobby leave command references missing position",
this->id);
} else {
this->lobby_players[index].guild_card_number = 0;
this->lobby_players[index].name.clear();
log(INFO, "[ProxyServer/%08" PRIX64 "] Removed lobby player (%zu)",
this->id, index);
}
}
break;
}
}
if (should_forward) {
if (!this->client_bev.get()) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] No client is present; dropping command",
this->id);
} else {
// Note: we intentionally don't pass name_str here because we already
// printed the command above
send_command(this->client_bev.get(), this->version,
this->client_output_crypt.get(), command, flag,
data.data(), data.size());
}
}
if (new_client_output_crypt.get()) {
this->client_output_crypt = new_client_output_crypt;
}
});
} catch (const exception& e) {
log(ERROR, "[ProxyServer/%08" PRIX64 "] Failed to process server command: %s",
this->id, e.what());
this->disconnect();
}
}
void ProxyServer::LinkedSession::send_to_end(
const void* data, size_t size, bool to_server) {
size_t header_size = PSOCommandHeader::header_size(this->version);
if (size < header_size) {
throw runtime_error("command is too small for header");
}
if (size & 3) {
throw runtime_error("command size is not a multiple of 4");
}
const auto* header = reinterpret_cast<const PSOCommandHeader*>(data);
string name = string_printf("ProxySession:%08" PRIX64 ":shell:%s",
this->id, to_server ? "server" : "client");
send_command(
to_server ? this->server_bev.get() : this->client_bev.get(),
this->version,
to_server ? this->server_output_crypt.get() : this->client_output_crypt.get(),
header->command(this->version),
header->flag(this->version),
reinterpret_cast<const uint8_t*>(data) + header_size,
size - header_size,
name.c_str());
}
void ProxyServer::LinkedSession::send_to_end(const string& data, bool to_server) {
this->send_to_end(data.data(), data.size(), to_server);
}
shared_ptr<ProxyServer::LinkedSession> ProxyServer::get_session() {
if (this->id_to_session.empty()) {
throw runtime_error("no sessions exist");
}
if (this->id_to_session.size() > 1) {
throw runtime_error("multiple sessions exist");
}
return this->id_to_session.begin()->second;
}
std::shared_ptr<ProxyServer::LinkedSession> ProxyServer::create_licensed_session(
std::shared_ptr<const License> l, uint16_t local_port, GameVersion version,
const ClientConfig& newserv_client_config) {
shared_ptr<LinkedSession> session(new LinkedSession(
this, local_port, version, l, newserv_client_config));
auto emplace_ret = this->id_to_session.emplace(session->id, session);
if (!emplace_ret.second) {
throw runtime_error("session already exists for this license");
}
log(INFO, "[ProxyServer/%08" PRIX64 "] Opening licensed session", session->id);
return emplace_ret.first->second;
}
void ProxyServer::delete_session(uint64_t id) {
if (this->id_to_session.erase(id)) {
log(WARNING, "[ProxyServer/%08" PRIX64 "] Closed session", id);
}
}
Reference in New Issue View Git Blame Copy Permalink