BOOL CaNodeConnectData::Matched (CaNodeConnectData* pObj, MatchObjectFlag nFlag)
{
if (nFlag == MATCHED_NAME)
{
return (pObj->GetName().CompareNoCase (GetName()) == 0);
}
else
{
BOOL bOk = FALSE;
if (pObj->GetNodeName().CompareNoCase (GetNodeName()) != 0)
return FALSE;
if (pObj->GetName().CompareNoCase (GetName()) != 0) // IP
return FALSE;
if (pObj->GetProtocol().CompareNoCase (GetProtocol()) != 0)
return FALSE;
if (pObj->GetListenAddress().CompareNoCase (GetListenAddress()) != 0)
return FALSE;
if (pObj->IsConnectionPrivate() != IsConnectionPrivate())
return FALSE;
return TRUE;
}
//
// Need the implementation ?
ASSERT (FALSE);
return FALSE;
}
int main(int argc, char **argv)
{
// Log arguments
std::string args;
if (argc != 0) {
for (int i = 0; i < argc; i++) {
if (i != 0) {
args += " ";
}
args += argv[i];
}
} else {
args = "<none>";
}
RLOG() << "Arguments: " << args.c_str();
// Seed random number generator
srand((int)base::GetTickCount());
// Root of the pack cache
std::string rootdir = ParseString(argc, argv, "--missionpack_dir");
std::string packdir = rootdir + "/pack";
std::string indexfile = rootdir + "/index";
std::string modfile = rootdir + "/modlist";
std::string badwordsfile = rootdir + "/badwords";
// Initialize the level info cache from the index so the server knows
// the latest and greatest mission packs.
wi::PackManager packm(packdir.c_str());
packm.WatchIndex(indexfile.c_str());
wi::LevelInfoCache cache(packm);
// Submit main pack and packs from the index
wi::NoCachePackFileReader pakr;
if (pakr.Push(NULL, ParseString(argc, argv, "--htdata").c_str())) {
wi::PackId packid;
memset(&packid, 0, sizeof(packid));
packid.id = PACKID_MAIN;
cache.Submit(pakr, packid);
pakr.Pop();
}
cache.SubmitIndex(indexfile);
if (cache.empty()) {
RLOG() << "cache is empty!";
exit(1);
}
// Set up StatsPoster
base::SocketAddress stats_address(ParseString(argc, argv,
"--stats_address").c_str());
std::string stats_path(ParseString(argc, argv, "--stats_path"));
wi::StatsPoster stats(stats_address, stats_path);
// Set up the server
dword server_id = ParseDword(argc, argv, "--server_id");
bool checksync = FindArg(argc, argv, "--checksync");
RLOG() << "Sync checking turned " << (checksync ? "ON." : "OFF.");
std::string log_file = ParseString(argc, argv, "--log_file");
wi::XMsgLog *xmsglog = NULL;
if (log_file.size() != 0) {
xmsglog = new wi::XMsgLog(log_file);
}
int max_players = ParseInteger(argc, argv, "--max_players",
kcConnectedPlayersMax);
int max_rooms = ParseInteger(argc, argv, "--max_rooms", kcRoomsMax);
int max_games_per_room = ParseInteger(argc, argv, "--max_games_per_room",
kcGamesPerRoomMax);
int max_players_per_room = ParseInteger(argc, argv,
"--max_players_per_room", kcPlayersPerRoomMax);
wi::Server server(stats, xmsglog, cache, server_id, checksync,
max_rooms, max_games_per_room, max_players_per_room,
max_players, modfile, badwordsfile);
base::SocketAddress listen_address = GetListenAddress(argc, argv);
if (!server.Listen(listen_address)) {
printf("Server failed to start.\n");
return 1;
}
listen_address = server.listen_address();
// Create default rooms
dword result;
server.lobby().NewRoom(NULL, "Main", "", wi::kroomidMain,
wi::kfRmPermanent | wi::kfRmLocked, &result);
server.lobby().NewRoom(NULL, "Main / Registered", "", wi::kroomidRegistered,
wi::kfRmPermanent | wi::kfRmRegisteredOnly | wi::kfRmLocked,
&result);
server.lobby().NewRoom(NULL, "Main / Unmoderated", "",
wi::kroomidUnmoderated,
wi::kfRmPermanent | wi::kfRmLocked | wi::kfRmUnmoderated,
&result);
// Get the public_address. This is the address that gets sent in
// ServerInfo. For example in AWS, the internal "private" ip
// is not the same as the public one. If this is not present,
// use the listen_address.
base::SocketAddress public_address;
std::string public_address_str = ParseString(argc, argv, "--public_address");
if (public_address_str.size() != 0) {
public_address = base::SocketAddress(public_address_str.c_str());
} else {
public_address = listen_address;
}
// Start up ServerInfoUpdater
std::string server_info_path(ParseString(argc, argv, "--server_info_path"));
std::string server_name(ParseString(argc, argv, "--server_name"));
std::string server_location(ParseString(argc, argv, "--server_location"));
std::string server_type(ParseString(argc, argv, "--server_type"));
std::string server_info_extra(ParseString(argc, argv, "--server_info_extra"));
dword expires = ParseDword(argc, argv, "--server_info_expires", 60 * 5);
wi::ServerInfoUpdater updater(server, stats_address, server_info_path,
server_id, server_name, server_location, server_type,
public_address, server_info_extra, expires);
server.SetUpdater(&updater);
// Pump messages and wait for network i/o
base::Thread::RunLoop();
return 0;
}
