private static void ValidateSshServer(SshServer server)
{
if (server.SshPort <= 0)
{
throw new ValidateException("SshPort", "You need a SSH port!");
}
if (string.IsNullOrEmpty(server.SshUsername))
{
throw new ValidateException("SshUsername", "You need a username!");
}
if (string.IsNullOrEmpty(server.SshPassword) && (server.SshKeyFileName == null || !server.SshKeyFileName.Any()))
{
throw new ValidateException("SshPassword", "You need at least a password or a key file!");
}
if (server.SshUsername == "root")
{
throw new ValidateException("SshUsername", "Dont use root here!");
}
try
{
RconStatic.AuthenticateOnTheSshServer(server);
}
catch (CommandException e)
{
throw new ValidateException("Id", e.Message);
}
}
public bool SaveBlackListEntry(PavlovServer server, List <ServerBans> NewBlackListContent)
{
var blacklistArray = NewBlackListContent.Select(x => x.SteamId).ToArray();
RconStatic.WriteFile(server.SshServer, server.ServerFolderPath + FilePaths.BanList, blacklistArray, _notifyService);
return(true);
}
public async Task <IActionResult> StopAndTakeAway(string apiKey, int sshServerId, int pavlovServerId)
{
if (!HasAccess(apiKey))
{
return(BadRequest("No AuthKey set or wrong auth key!"));
}
var sshServer = await _sshServerSerivce.FindOne(sshServerId);
var pavlovServer = await _pavlovServerService.FindOne(pavlovServerId);
if (sshServer == null)
{
return(BadRequest("The ssh server does not exist!"));
}
if (!sshServer.IsForHosting)
{
return(BadRequest("The ssh server ist not for hosting!"));
}
await RconStatic.SystemDStop(pavlovServer, _pavlovServerService);
pavlovServer.OldOwner = pavlovServer.Owner;
pavlovServer.Owner = null;
await _pavlovServerService.Upsert(pavlovServer);
return(Ok());
}
public async Task <IActionResult> GetServerLog(int serverId)
{
if (!await RightsHandler.HasRightsToThisPavlovServer(HttpContext.User,
await _userservice.getUserFromCp(HttpContext.User), serverId, _service, _pavlovServerService))
{
return(Forbid());
}
var server = await _pavlovServerService.FindOne(serverId);
try
{
var connectionResult = await RconStatic.GetServerLog(server, _pavlovServerService);
if (connectionResult.Success)
{
var replace = connectionResult.answer.Replace("\n", "<br/>");
return(View("ServerLogs", replace));
}
else
{
return(BadRequest("Coud not get data:" + connectionResult.errors));
}
}
catch (CommandException e)
{
return(BadRequest(e.Message));
}
}
private async Task <bool> SaveToFile(PavlovServer pavlovServer, List <string> steamIds)
{
var lines = steamIds.Select(steamIdentity => steamIdentity).ToList();
RconStatic.WriteFile(pavlovServer.SshServer, pavlovServer.ServerFolderPath + FilePaths.ModList, lines.ToArray(),
_notifyService);
return(true);
}
private async Task <PavlovServer> HasToStop(PavlovServer pavlovServer, bool hasToStop, bool root)
{
if (hasToStop)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("stop server again!", LogEventLevel.Verbose,
_notifyService);
await RconStatic.SystemDStop(pavlovServer, this);
pavlovServer = await GetServerServiceState(pavlovServer);
}
return(pavlovServer);
}
public async Task <IActionResult> StopSystemdService(int serverId)
{
if (!await RightsHandler.HasRightsToThisPavlovServer(HttpContext.User,
await _userservice.getUserFromCp(HttpContext.User), serverId, _service, _pavlovServerService))
{
return(Forbid());
}
var server = await _pavlovServerService.FindOne(serverId);
try
{
await RconStatic.SystemDStop(server, _pavlovServerService);
}
catch (CommandException e)
{
return(BadRequest(e.Message));
}
return(RedirectToAction("Index", "SshServer"));
}
public async Task DeleteAllUnsedMapsFromAllServers()
{
var servers = await _sshServerSerivce.FindAll();
foreach (var server in servers)
{
foreach (var signleServer in server.PavlovServers)
{
try
{
RconStatic.DeleteUnusedMaps(signleServer,
(await _serverSelectedMapService.FindAllFrom(signleServer)).ToList());
}
catch (Exception e)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify(e.Message, LogEventLevel.Verbose, _notifyService);
// ingore for now
}
}
}
}
public async Task <IActionResult> UpdatePavlovServer(int serverId)
{
if (!await RightsHandler.HasRightsToThisPavlovServer(HttpContext.User,
await _userservice.getUserFromCp(HttpContext.User), serverId, _service, _pavlovServerService))
{
return(Forbid());
}
var server = await _pavlovServerService.FindOne(serverId);
var result = "";
try
{
result = await RconStatic.UpdateInstallPavlovServer(server, _pavlovServerService);
}
catch (CommandException e)
{
return(BadRequest(e.Message));
}
return(new ObjectResult(result));
}
/// <summary>
/// </summary>
/// <param name="pavlovServer"></param>
/// <param name="rconService"></param>
/// <returns></returns>
public async Task <PavlovServer> GetServerServiceState(PavlovServer pavlovServer)
{
var state = await RconStatic.SystemDCheckState(pavlovServer, _notifyService);
// state can be: active, inactive,disabled
if (state == "active")
{
pavlovServer.ServerServiceState = ServerServiceState.active;
}
else if (state == "inactive")
{
pavlovServer.ServerServiceState = ServerServiceState.inactive;
}
else if (state == "disabled")
{
pavlovServer.ServerServiceState = ServerServiceState.disabled;
}
else
{
pavlovServer.ServerServiceState = ServerServiceState.none;
}
return(pavlovServer);
}
public async Task <ConnectionResult> StartMatchWithAuth(RconService.AuthType authType,
PavlovServer server,
Match match)
{
var connectionInfo = RconStatic.ConnectionInfoInternal(server.SshServer, authType, out var result);
using var clientSsh = new SshClient(connectionInfo);
using var clientSftp = new SftpClient(connectionInfo);
try
{
var listOfSteamIdentietiesWhichCanPlay = match.MatchTeam0SelectedSteamIdentities;
listOfSteamIdentietiesWhichCanPlay.AddRange(match.MatchTeam1SelectedSteamIdentities);
var list = new List <string>();
if (listOfSteamIdentietiesWhichCanPlay.Count <= 0 && match.MatchSelectedSteamIdentities.Count <= 0)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("There are no team members so no match will start!",
LogEventLevel.Fatal, _notifyService, result);
return(result);
}
if (match.MatchSelectedSteamIdentities.Count > 0)
{
list = match.MatchSelectedSteamIdentities
.Select(x => Strings.Trim(x.SteamIdentityId)).ToList();
}
else if (listOfSteamIdentietiesWhichCanPlay.Count > 0)
{
list = listOfSteamIdentietiesWhichCanPlay.Select(x => Strings.Trim(x.SteamIdentityId)).ToList();
}
list = list.Distinct().ToList();
//GetAllAdminsForTheMatch
var mods = new List <string>();
//Todo what if the match is not team based? there are no mods or admins?
mods = listOfSteamIdentietiesWhichCanPlay.Where(x => x.OverWriteRole == "Mod" || x.OverWriteRole == "Admin").Select(x => x.SteamIdentityId).ToList();
//Write whitelist and set server settings
RconStatic.WriteFile(server.SshServer,
server.ServerFolderPath + FilePaths.WhiteList,
list.ToArray(), _notifyService);
RconStatic.WriteFile(server.SshServer,
server.ServerFolderPath + FilePaths.ModList,
mods.ToArray(), _notifyService);
RconStatic.WriteFile(server.SshServer,
server.ServerFolderPath + FilePaths.BanList,
Array.Empty <string>(), _notifyService);
var oldSettings = new PavlovServerGameIni();
oldSettings.ReadFromFile(server, _notifyService);
var serverSettings = new PavlovServerGameIni
{
bEnabled = true,
ServerName = match.Name,
MaxPlayers = match.PlayerSlots,
bSecured = true,
bCustomServer = true,
bWhitelist = true,
RefreshListTime = 120,
LimitedAmmoType = 0,
TickRate = 90,
TimeLimit = match.TimeLimit,
Password = "",
BalanceTableURL = "",
bVerboseLogging = true,
bCompetitive = true,
MapRotation = new List <PavlovServerGameIniMap>
{
new()
{
MapLabel = match.MapId,
GameMode = match.GameMode
}
},
ApiKey = oldSettings.ApiKey
};
var map = await _mapsService.FindOne(match.MapId.Replace("UGC", ""));
serverSettings.SaveToFile(server, new[]
{
new ServerSelectedMap()
{
Map = map,
GameMode = match.GameMode
}
}, _notifyService);
await RconStatic.SystemDStart(server, _pavlovServerService);
//StartWatchServiceForThisMatch
match.Status = Status.StartetWaitingForPlayer;
await Upsert(match);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start backgroundjob", LogEventLevel.Verbose,
_notifyService);
BackgroundJob.Enqueue(
() => MatchInspector(match.Id)); // ChecjServerState
}
public async Task RemovePavlovServerFromDisk(
PavlovServerViewModel server, bool ignoreMostExceptions)
{
//Todo AuthError??
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start remove server!", LogEventLevel.Verbose,
_notifyService);
string result = "";
//start server and stop server to get Saved folder etc.
if (ignoreMostExceptions)
{
try
{
await RconStatic.SystemDStop(server, _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
await RconStatic.SystemDStop(server, _pavlovServerService);
}
if (ignoreMostExceptions)
{
try
{
await RconStatic.RemovePath(server, server.ServerFolderPath, _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
await RconStatic.RemovePath(server, server.ServerFolderPath, _pavlovServerService);
}
server.SshServer = await FindOne(server.sshServerId);
if (server.SshServer == null)
{
throw new CommandException("Could not get the sshServer!");
}
var oldSSHcrid = new SshServer
{
SshPassphrase = server.SshServer.SshPassphrase,
SshUsername = server.SshServer.SshUsername,
SshPassword = server.SshServer.SshPassword,
SshKeyFileName = server.SshServer.SshKeyFileName
};
server.SshServer.SshPassphrase = server.SshPassphraseRoot;
server.SshServer.SshUsername = server.SshUsernameRoot;
server.SshServer.SshPassword = server.SshPasswordRoot;
if (server.SshKeyFileNameForm != null)
{
await using var ms = new MemoryStream();
await server.SshKeyFileNameForm.CopyToAsync(ms);
var fileBytes = ms.ToArray();
server.SshKeyFileNameRoot = fileBytes;
// act on the Base64 data
}
server.SshServer.SshKeyFileName = server.SshKeyFileNameRoot;
server.SshServer.NotRootSshUsername = oldSSHcrid.SshUsername;
if (ignoreMostExceptions)
{
try
{
await RconStatic.RemovePath(server,
"/etc/systemd/system/" + server.ServerSystemdServiceName + ".service", _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
await RconStatic.RemovePath(server,
"/etc/systemd/system/" + server.ServerSystemdServiceName + ".service", _pavlovServerService);
}
//Remove the server from the sudoers file
var sudoersPathParent = "/etc/sudoers.d";
var sudoersPath = sudoersPathParent + "/pavlovRconWebserverManagement";
var removed = true;
if (ignoreMostExceptions)
{
try
{
removed = RconStatic.RemoveServerLineToSudoersFile(server, _notifyService, sudoersPath, _pavlovServerService);
}
catch (CommandException)
{
//ignore
}
}
else
{
removed = RconStatic.RemoveServerLineToSudoersFile(server, _notifyService, sudoersPath, _pavlovServerService);
}
if (removed)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("server line removed from sudoers file!",
LogEventLevel.Verbose, _notifyService);
}
else
{
//means that the lines still is in the file!!!
var error =
"Could not remove the server line from sudoers file!";
DataBaseLogger.LogToDatabaseAndResultPlusNotify(error, LogEventLevel.Fatal, _notifyService);
if (!ignoreMostExceptions)
{
throw new CommandException(error);
}
}
//Handle the presets an newer systemd
if (ignoreMostExceptions)
{
try
{
RconStatic.AddLineToNewerSystemDsIfNeeded(server, _notifyService, true);
}
catch (CommandException)
{
//ignore
}
}
else
{
RconStatic.AddLineToNewerSystemDsIfNeeded(server, _notifyService, true);
}
DataBaseLogger.LogToDatabaseAndResultPlusNotify(result, LogEventLevel.Verbose, _notifyService);
}
/// <summary>
/// Return back if the server should forceStop
/// </summary>
/// <param name="server"></param>
/// <param name="match"></param>
/// <returns></returns>
/// <exception cref="CommandException"></exception>
public async Task <bool> SShTunnelGetAllInfoFromPavlovServer(PavlovServer server, Match match = null)
{
var result = RconStatic.StartClient(server, out var client);
var costumesToSet = new Dictionary <string, string>();
try
{
client.Connect();
if (client.IsConnected)
{
var nextFreePort = RconStatic.GetAvailablePort();
var portToForward = nextFreePort;
var portForwarded = new ForwardedPortLocal("127.0.0.1", (uint)portToForward, "127.0.0.1",
(uint)server.TelnetPort);
client.AddForwardedPort(portForwarded);
portForwarded.Start();
using (var client2 = new Client("127.0.0.1", portToForward, new CancellationToken()))
{
if (client2.IsConnected)
{
var password = await client2.ReadAsync(TimeSpan.FromMilliseconds(2000));
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Answer: " + password,
LogEventLevel.Verbose, _notifyService);
if (password.ToLower().Contains("password"))
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("start sending password!",
LogEventLevel.Verbose, _notifyService);
await client2.WriteLine(server.TelnetPassword);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("did send password and wait for auth",
LogEventLevel.Verbose, _notifyService);
var auth = await client2.ReadAsync(TimeSpan.FromMilliseconds(2000));
DataBaseLogger.LogToDatabaseAndResultPlusNotify("waited for auth get : " + auth,
LogEventLevel.Verbose, _notifyService);
if (auth.ToLower().Contains("authenticated=1"))
{
// it is authetificated
var commandOne = "RefreshList";
var singleCommandResult1 =
await RconStatic.SingleCommandResult(client2, commandOne);
var playersList =
JsonConvert.DeserializeObject <PlayerListClass>(singleCommandResult1);
var steamIds = playersList?.PlayerList.Select(x => x.UniqueId);
//Inspect PlayerList
var commands = new List <string>();
if (steamIds != null)
{
foreach (var steamId in steamIds)
{
commands.Add("InspectPlayer " + steamId);
}
}
var playerListRaw = new List <string>();
foreach (var command in commands)
{
var commandResult = await RconStatic.SingleCommandResult(client2, command);
playerListRaw.Add(commandResult);
}
var playerListJson = string.Join(",", playerListRaw);
playerListJson = "[" + playerListJson + "]";
var finsihedPlayerList = new List <PlayerModelExtended>();
var tmpPlayers = JsonConvert.DeserializeObject <List <PlayerModelExtendedRconModel> >(
playerListJson, new JsonSerializerSettings {
CheckAdditionalContent = false
});
var steamIdentities = (await _steamIdentityService.FindAll()).ToList();
if (tmpPlayers != null)
{
foreach (var player in tmpPlayers)
{
player.PlayerInfo.Username = player.PlayerInfo.PlayerName;
var identity =
steamIdentities?.FirstOrDefault(x =>
x.Id == player.PlayerInfo.UniqueId);
if (identity != null && (identity.Costume != "None" ||
!string.IsNullOrEmpty(identity.Costume)))
{
if (server.Shack)
{
costumesToSet.Add(identity.OculusId, identity.Costume);
}
else
{
costumesToSet.Add(identity.Id, identity.Costume);
}
}
}
finsihedPlayerList = tmpPlayers.Select(x => x.PlayerInfo).ToList();
}
var pavlovServerPlayerList = finsihedPlayerList.Select(x =>
{
var player = new PavlovServerPlayer();
player.Username = x.Username;
player.UniqueId = x.UniqueId;
player.KDA = x.KDA;
player.Cash = x.Cash;
player.TeamId = x.TeamId;
player.Score = x.Score;
player.ServerId = server.Id;
return(player);
}).ToList();
var oldServerInfo = await _pavlovServerInfoService.FindServer(server.Id);
//Todo maybe check if we lost a player its possible that we need that if allstats after the end of a match doesent give back all the player if some had a disconnect
await _pavlovServerPlayerService.Upsert(pavlovServerPlayerList, server.Id);
await _pavlovServerPlayerHistoryService.Upsert(pavlovServerPlayerList.Select(x =>
{
var history = new PavlovServerPlayerHistory();
history.Username = x.Username;
history.UniqueId = x.UniqueId;
history.PlayerName = x.PlayerName;
history.KDA = x.KDA;
history.Cash = x.Cash;
history.TeamId = x.TeamId;
history.Score = x.Score;
history.ServerId = x.ServerId;
history.date = DateTime.Now;
return(history);
}).ToList(), server.Id, 1);
var singleCommandResultTwo =
await RconStatic.SingleCommandResult(client2, "ServerInfo");
var tmp = JsonConvert.DeserializeObject <ServerInfoViewModel>(
singleCommandResultTwo.Replace("\"\"", "\"ServerInfo\""));
if (tmp == null || tmp.ServerInfo == null)
{
return(false);
}
if (!string.IsNullOrEmpty(tmp.ServerInfo.GameMode))
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Got the server info for the server: " + server.Name + "\n " +
singleCommandResultTwo, LogEventLevel.Verbose, _notifyService);
}
tmp.ServerId = server.Id;
var map = await _mapsService.FindOne(tmp.ServerInfo.MapLabel.Replace("UGC", ""));
if (map != null)
{
tmp.ServerInfo.MapPictureLink = map.ImageUrl;
}
//Check of next round
bool nextRound = oldServerInfo != null && oldServerInfo.MapLabel != tmp.ServerInfo.MapLabel;
if (!nextRound && oldServerInfo != null && match is { Status : Status.OnGoing }) // more checks cause in a match the map is only one and will not trigger the first try
{
var gotResult1 = int.TryParse(oldServerInfo.Team0Score, out var oldTeam0Score);
var gotResult2 = int.TryParse(oldServerInfo.Team1Score, out var oldTeam1Score);
var gotResult3 = int.TryParse(tmp.ServerInfo.Team0Score, out var newTeam0Score);
var gotResult4 = int.TryParse(tmp.ServerInfo.Team1Score, out var newTeam1Score);
if (gotResult1 && gotResult2 && gotResult3 && gotResult4 && (
oldTeam0Score > newTeam0Score ||
oldTeam1Score > newTeam1Score)
)
{
nextRound = true;
}
}
var round = oldServerInfo?.Round ?? 0;
if (nextRound)
{
if (round == 999)
{
round = 0; // reset value that's why you have to use the nextRound bool down from here to know if its the next round
}
round++;
}
if (match is { Status : Status.OnGoing } && nextRound)
public virtual async Task <PavlovServer> ValidatePavlovServer(PavlovServer pavlovServer, bool root)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("start validate", LogEventLevel.Verbose, _notifyService);
var hasToStop = false;
await IsValidOnly(pavlovServer);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("try to start service", LogEventLevel.Verbose,
_notifyService);
//try if the service realy exist
try
{
pavlovServer = await GetServerServiceState(pavlovServer);
if (pavlovServer.ServerServiceState != ServerServiceState.active)
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("has to start", LogEventLevel.Verbose,
_notifyService);
hasToStop = true;
//the problem is here for the validating part if it has to start the service first it has problems
await RconStatic.SystemDStart(pavlovServer, this);
pavlovServer = await GetServerServiceState(pavlovServer);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("state = " + pavlovServer.ServerServiceState,
LogEventLevel.Verbose, _notifyService);
}
}
catch (CommandException e)
{
throw new ValidateException(e.Message);
}
DataBaseLogger.LogToDatabaseAndResultPlusNotify("try to send serverinfo", LogEventLevel.Verbose,
_notifyService);
//try to send Command ServerInfo
try
{
await RconStatic.SendCommandSShTunnel(pavlovServer, "ServerInfo", _notifyService);
}
catch (CommandException e)
{
await HasToStop(pavlovServer, hasToStop, root);
throw new ValidateException(e.Message);
}
//try if the user have rights to delete maps cache
try
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("delete unused maps", LogEventLevel.Verbose,
_notifyService);
RconStatic.DeleteUnusedMaps(pavlovServer,
(await _serverSelectedMapService.FindAllFrom(pavlovServer)).ToList());
}
catch (CommandException e)
{
await HasToStop(pavlovServer, hasToStop, root);
throw new ValidateException(e.Message);
}
if (!string.IsNullOrEmpty(pavlovServer.SshServer.ShackMapsPath))
{
try
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("check if ShackMapsPath exist!", LogEventLevel.Verbose,
_notifyService);
RconStatic.DoesPathExist(pavlovServer, pavlovServer.SshServer.ShackMapsPath, _notifyService);
}
catch (CommandException e)
{
await HasToStop(pavlovServer, hasToStop, root);
throw new ValidateException("ShackMapsPath does not exist: " + pavlovServer.SshServer.ShackMapsPath + "additional info:" + e.Message);
}
}
await HasToStop(pavlovServer, hasToStop, root);
return(pavlovServer);
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="reservedFor"></param>
/// <exception cref="CommandExceptionCreateServerDuplicate"></exception>
public async Task CreatePavlovServer(PavlovServerViewModel server, string reservedFor = "")
{
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start creting server", LogEventLevel.Verbose,
_notifyService);
//Check stuff
var exist = RconStatic.DoesPathExist(server, server.ServerFolderPath, _notifyService);
if (exist)
{
throw new CommandExceptionCreateServerDuplicate("ServerFolderPath already exist!");
}
exist = RconStatic.DoesPathExist(server,
"/etc/systemd/system/" + server.ServerSystemdServiceName + ".service", _notifyService);
if (exist)
{
throw new CommandExceptionCreateServerDuplicate("Systemd Service already exist!");
}
var portsUsed = (await FindAll()).Where(x => x.SshServer.Id == server.SshServer.Id)
.FirstOrDefault(x => x.ServerPort == server.ServerPort || x.TelnetPort == server.TelnetPort);
if (portsUsed != null)
{
if (portsUsed.ServerPort == server.ServerPort)
{
throw new CommandExceptionCreateServerDuplicate("The server port is already used!");
}
if (portsUsed.TelnetPort == server.TelnetPort)
{
throw new CommandExceptionCreateServerDuplicate("The telnet port is already used!");
}
}
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start Install pavlovserver", LogEventLevel.Verbose,
_notifyService);
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Username used befor changed to root: " + server.SshServer.SshUsername, LogEventLevel.Verbose,
_notifyService);
await RconStatic.UpdateInstallPavlovServer(server, this);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start Install pavlovserver service",
LogEventLevel.Verbose, _notifyService);
var oldSSHcrid = new SshServer
{
SshPassphrase = server.SshServer.SshPassphrase,
SshUsername = server.SshServer.SshUsername,
SshPassword = server.SshServer.SshPassword,
SshKeyFileName = server.SshServer.SshKeyFileName
};
server.SshServer.SshPassphrase = server.SshPassphraseRoot;
server.SshServer.SshUsername = server.SshUsernameRoot;
server.SshServer.SshPassword = server.SshPasswordRoot;
server.SshServer.SshKeyFileName = server.SshKeyFileNameRoot;
server.SshServer.NotRootSshUsername = oldSSHcrid.SshUsername;
try
{
await RconStatic.InstallPavlovServerService(server, _notifyService);
}
catch (CommandException e)
{
//If crash inside here the user login is still root. If the root login is bad this will fail to remove the server afterwards
OverwrideTheNormalSSHLoginData(server, oldSSHcrid);
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Could not install service while creating the pavlov server -> " + e.Message, LogEventLevel.Verbose, _notifyService);
throw;
}
OverwrideTheNormalSSHLoginData(server, oldSSHcrid);
DataBaseLogger.LogToDatabaseAndResultPlusNotify(
"Username used after override old infos: " + server.SshServer.SshUsername, LogEventLevel.Verbose,
_notifyService);
//start server and stop server to get Saved folder etc.
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Start after install", LogEventLevel.Verbose,
_notifyService);
await RconStatic.SystemDStart(server, this);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("stop after install", LogEventLevel.Verbose,
_notifyService);
await RconStatic.SystemDStop(server, this);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("Try to save game ini", LogEventLevel.Verbose,
_notifyService);
var pavlovServerGameIni = new PavlovServerGameIni();
DataBaseLogger.LogToDatabaseAndResultPlusNotify("created Ini", LogEventLevel.Verbose, _notifyService);
var selectedMaps = await _serverSelectedMapService.FindAllFrom(server);
DataBaseLogger.LogToDatabaseAndResultPlusNotify("found maps", LogEventLevel.Verbose, _notifyService);
pavlovServerGameIni.ServerName = server.Name;
pavlovServerGameIni.SaveToFile(server, selectedMaps, _notifyService);
//also create rcon settings
DataBaseLogger.LogToDatabaseAndResultPlusNotify("write rcon file", LogEventLevel.Verbose,
_notifyService);
var lines = new List <string>
{
"Password="******"Port=" + server.TelnetPort
};
RconStatic.WriteFile(server.SshServer, server.ServerFolderPath + FilePaths.RconSettings,
lines.ToArray(), _notifyService);
}
public async Task <IActionResult> SendCommandMulti(int server, string command, string[] players, string value = "")
{
var singleServer = await _pavlovServerService.FindOne(server);
var servers = await GiveServerWhichTheUserHasRightsTo();
LiteDbUser user;
user = await _userservice.getUserFromCp(HttpContext.User);
if (!servers.Select(x => x.Id).Contains(singleServer.Id))
{
return(Forbid());
}
var isMod = await RightsHandler.IsModOnTheServer(_serverSelectedModsService, singleServer, user.Id);
var commands = await RightsHandler.GetAllowCommands(new RconViewModel(), HttpContext.User, _userservice, isMod, singleServer, user);
var contains = false;
foreach (var singleCommand in commands)
{
if (command.Contains(singleCommand))
{
contains = true;
}
}
if (contains != true)
{
return(Forbid());
}
if (command.StartsWith("GodMode"))
{
command = "Slap";
value = "-2147000000";
}
if (command.StartsWith("CustomPlayer") || command.StartsWith("Custom"))
{
if (command.StartsWith("CustomPlayer"))
{
var count = value.Count(x => x == ' ');
if (count == 1)
{
var pieces = value.Split(new[] { ' ' }, 2);
command = pieces[0];
value = pieces[1];
}
}
else
{
command = command.Substring(7);
}
}
var responses = Array.Empty <string>();
try
{
var commandsList = new List <string>();
foreach (var player in players)
{
if (value == null)
{
commandsList.Add(command + " " + player);
}
else
{
commandsList.Add(command + " " + player + " " + value);
}
}
responses = await RconStatic.SShTunnelMultipleCommands(singleServer, commandsList.ToArray(), _toastifyService);
}
catch (CommandException e)
{
return(BadRequest(e.Message));
}
if (string.IsNullOrEmpty(string.Join(";", responses)))
{
return(BadRequest("The response was empty!"));
}
var commandsResulsts = new List <string>();
try
{
foreach (var response in responses)
{
var tmp = JsonConvert.DeserializeObject <MinimumRconResultObject>(response, new JsonSerializerSettings {
CheckAdditionalContent = false
});
var o = (Newtonsoft.Json.Linq.JObject)JsonConvert.DeserializeObject(response);
var value3 = o.Property("")?.Value;
var value2 = o.Property(tmp.Command)?.Value;
if (tmp != null && (value3 is { HasValues: false } || value2 is { HasValues: false }))
