private void ValidateSessionsAsync()
{
ThreadPool.QueueUserWorkItem(async(object o) =>
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
var localSessions = server.GetSessions().Where(s => s.SessionId > 0 && (s.ConnectionState == Cassia.ConnectionState.Active));
var messages = await _msgReader.GetAllMessages();
if (messages.Count(m => m.Command.Type == WinGuard.Domain.Enumaretions.ClientCommandType.LOGOUT) > 0 &&
localSessions.Any(s => messages.Any(m => m.Command.ClientIdentifier == s.SessionId.ToString())))
{
foreach (var session in localSessions.Where(s => messages.Any(m => m.Command.ClientIdentifier == s.SessionId.ToString())))
{
session.Logoff();
}
return;
}
foreach (ITerminalServicesSession session in localSessions)
{
await _authService.Login(_encryptService.EncryptMessage(session.SessionId.ToString()),
_encryptService.EncryptMessage(session.UserName));
}
}
});
}
public Response Get()
{
var response = new Response();
try
{
using (var server = new TerminalServicesManager().GetLocalServer())
{
server.Open();
var sessions = server.GetSessions()
.Where(s => !string.IsNullOrEmpty(s.UserName))
.Select(s => new
{
Id = s.SessionId,
User = s.DomainName + @"\" + s.UserName,
LoginDate = s.LoginTime?.ToString("g"),
State = s.ConnectionState.ToString()
});
response.Data = sessions;
return(response);
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
response.AddErrorNotification(ex.Message, ex.StackTrace);
return(response);
}
}
private void SearchActiveSessions(LogFileParser.foundElementInfo [] selectedUserPCs, string selectedUser)
{
ITerminalServicesManager manager = new TerminalServicesManager();
for (int i = 0; i < selectedUserPCs.Length; i++)
{
try {
Ping ping = new Ping();
PingOptions pingOptions = new PingOptions();
pingOptions.DontFragment = true;
string data = "fff";
byte[] buffer = Encoding.ASCII.GetBytes(data);
PingReply reply = ping.Send(selectedUserPCs[i].name, 120, buffer, pingOptions);
if (reply.Status == IPStatus.Success)
{
using (ITerminalServer server = manager.GetRemoteServer(selectedUserPCs[i].name)) {
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserName.ToLower() == selectedUser.ToLower() && session.ConnectionState == ConnectionState.Active)
{
selectedUserPCs[i].name = "->" + selectedUserPCs[i].name + "<-";
}
}
}
}
} catch { }
}
}
public Response GetUserSesssions()
{
var response = new Response();
try
{
var manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
var sessions = server.GetSessions()
.Where(s => !string.IsNullOrEmpty(s.UserName))
.Select(s => new
{
User = s.DomainName + @"\" + s.UserName,
LoginDate = s.LoginTime?.ToString("g"),
State = s.ConnectionState.ToString()
});
response.Data = sessions;
return(response);
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
response.Status = Status.Error;
response.Notifications.Add(new Notification
{
Message = ex.Message,
MessageDetail = ex.StackTrace,
Status = Status.Error
});
return(response);
}
}
private static int GetUserSessionId(string username)
{
try
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account == null)
{
continue;
}
var userName = account.Value.Split('\\')[1];
if (userName.ToLower().Equals(username.ToLower()))
{
return(session.SessionId);
}
}
}
return(-1);
}
catch (Exception)
{
return(-1);
}
}
public static List <ITerminalServicesSession> GetList()
{
List <ITerminalServicesSession> session_list = new List <ITerminalServicesSession>();
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
// skip the SYSTEM session
if (session.SessionId == 0)
{
continue;
}
// if there is no username the session is special accounts
if (session.UserName == String.Empty)
{
continue;
}
session_list.Add(session);
}
}
return(session_list);
}
public static void killProcess(string computerName, int PID)
{
if (ping(computerName))
{
ITerminalServer server = new TerminalServicesManager().GetRemoteServer(computerName);
server.Open();
server.GetProcess(PID).Kill();
}
}
public static void LogSessionData(Guid currentServiceRunGuid, int sessionId, SessionTrackingEvents sessionTrackingEvent, string reason, bool logAllExistingSessions = false)
{
using (ITerminalServer server = new TerminalServicesManager().GetLocalServer())
{
SessionTracking sessionTracking = null;
if (!File.Exists(GlobalSettings.DataFilePath))
{
sessionTracking = new SessionTracking();
sessionTracking.SessionTrackingParamsList = new List <SessionTrackingParams>();
File.Create(GlobalSettings.DataFilePath).Close();
Utility.SerializeObjectToFile <SessionTracking>(sessionTracking, GlobalSettings.DataFilePath);
}
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions().Where(o => o.LoginTime.HasValue))
{
if (logAllExistingSessions || session.SessionId == sessionId)
{
SessionTrackingParams sessionTrackingParams = new SessionTrackingParams()
{
ServiceRunGuid = currentServiceRunGuid,
SessionId = session.SessionId,
LogonDT = session.LoginTime.HasValue ? session.LoginTime.Value : DateTime.MinValue,
EventDT = DateTime.Now,
UserAccount = (session.UserAccount != null && session.UserAccount.Value != null ? session.UserAccount.Value : String.Empty),
Event = Enum.GetName(typeof(SessionTrackingEvents), sessionTrackingEvent),
Reason = reason
};
string sessionTrackingParamsSerialized = Utility.SerializeObject <SessionTrackingParams>(sessionTrackingParams);
// Faster and not-so-clean way to write XML node to the end of the serialized List<SessionTrackingParams>,
// cleaner way would be to deserialize, add node and serialize whole list which might contain hundreds of records, but it would
// possibly be much slower in case of large file.
string text = File.ReadAllText(GlobalSettings.DataFilePath);
if (text.Contains("</SessionTrackingParamsList>"))
{
text = text.Replace(
"</SessionTrackingParamsList>",
sessionTrackingParamsSerialized + Environment.NewLine + "</SessionTrackingParamsList>");
}
else
{
text = text.Replace(
"<SessionTrackingParamsList />",
"<SessionTrackingParamsList>" + Environment.NewLine + sessionTrackingParamsSerialized + Environment.NewLine + "</SessionTrackingParamsList>");
}
File.WriteAllText(GlobalSettings.DataFilePath, text);
if (!logAllExistingSessions)
{
break;
}
}
}
server.Close();
}
}
static void CheckBackupTime(object sender, System.Timers.ElapsedEventArgs e)
{
if ((int)DateTime.Now.DayOfWeek != Settings.Default.backupday)
{
return;
}
backupTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, (int)Settings.Default.backuphour, (int)Settings.Default.backupminute, 0);
if (backupTime > DateTime.Now)
{
if ((int)(backupTime - DateTime.Now).TotalMinutes <= Settings.Default.startcheck)
{
foreach (var session in activeusers)
{
if (!Notifications.ContainsKey(session.SessionId))
{
SendMessage(session.SessionId, Settings.Default.alert1box.Replace("{time}", backupTime.ToString("HH:mm")));
Notifications.Add(session.SessionId, DateTime.Now);
}
else
{
if ((DateTime.Now - Notifications[session.SessionId]).TotalMinutes >= (int)Settings.Default.alert_interval)
{
SendMessage(session.SessionId, Settings.Default.alert1box.Replace("{time}", backupTime.ToString("HH:mm")));
Notifications[session.SessionId] = DateTime.Now;
}
}
}
}
}
else
{
if (backupTime < startuptime)
{
FinishedBackups.Add(backupTime);
return;
}
if (!FinishedBackups.Contains(backupTime))
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
KillParusWithNotifiction(session);
}
}
if (Settings.Default.backupauto && Application.OpenForms.OfType <BackupWindow>().Count() == 0)
{
bwindow = new BackupWindow();
bwindow.ShowDialog();
}
}
}
}
public static void killProcess(string computerName, string processName)
{
try {
if (ping(computerName))
{
ITerminalServer server = new TerminalServicesManager().GetRemoteServer(computerName);
server.Open();
server.GetProcesses().First(p => p.ProcessName == processName).Kill();
}
} catch { }
}
private void initServer()
{
try
{
ITerminalServicesManager manager = new TerminalServicesManager();
server = manager.GetLocalServer();
server.Open();
}
catch (Exception)
{
Console.WriteLine("[Error] no se ha podido identificar el terminal server.");
}
}
public static List <ITerminalServicesProcess> getComputerProcess(string computerName)
{
if (ping(computerName))
{
ITerminalServer server = new TerminalServicesManager().GetRemoteServer(computerName);
server.Open();
List <ITerminalServicesProcess> processes = server.GetProcesses().ToList();
return(processes);
}
else
{
return(new List <ITerminalServicesProcess>());
}
}
private ITerminalServer GetServer()
{
var mgr = new TerminalServicesManager();
if (string.IsNullOrWhiteSpace(ComputerName))
{
// Local Machine
return(mgr.GetLocalServer());
}
else
{
// Remote Machine
return(mgr.GetRemoteServer(ComputerName));
}
}
public static void killAnotherCopyOfProgram()
{
ITerminalServer server = new TerminalServicesManager().GetLocalServer();
server.Open();
var procs = server.GetProcesses().Where(
el => el.ProcessName.Equals("rPCSMT.exe") &&
Process.GetCurrentProcess().Id != el.ProcessId
);
foreach (var proc in procs)
{
proc.Kill();
}
}
static void Main(string[] args)
{
var manager = new TerminalServicesManager();
using (var server = manager.GetRemoteServer("server"))
{
server.Open();
foreach (var session in server.GetSessions())
{
if (session.ConnectionState == ConnectionState.Active)
{
Console.WriteLine(session.ClientName);
}
}
}
}
private void LoadTSUsers()
{
try
{
listTSUser.Clear();
TerminalServicesManager tsManager = new TerminalServicesManager();
string[] massHosts = new string[] { "TS1", "TS2", "TS3", "TS4", "TS5", "TS6", "TS7" };
foreach (var host in massHosts)
{
using (ITerminalServer server = tsManager.GetRemoteServer(host))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
TSUser user = new TSUser()
{
DomainName = session.DomainName,
PCName = session.ClientName,
TSName = host,
UserName = session.UserName,
ConnectionState = session.ConnectionState.ToString(),
WindowStationName = session.WindowStationName,
UserAccount = account.ToString(),
};
Dispatcher.Invoke((Action)(() =>
{
listTSUser.Add(user);
}));
}
}
}
}
foreach (var user in listTSUser)
{
user.ClientIPAddress = (from i in listPcIPAndPcName where i.PcName.ToLower() == user.PCName.ToLower() select i.PcIP).FirstOrDefault();
}
}
catch (Exception ex)
{
Bindings.StatusBarText = ex.Message;
}
}
public static void Main(string[] args)
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer("your-server-name"))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
Console.WriteLine(account);
}
}
}
}
public static bool SendMessage(string message)
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(ServerIPAddress))
{
server.Open();
var session = server.GetSessions().Where(x => x.UserName == UserNameOnServer).FirstOrDefault();
if (session != null)
{
var response = session.MessageBox(message, "Message for user", RemoteMessageBoxButtons.YesNo,
RemoteMessageBoxIcon.Question, RemoteMessageBoxDefaultButton.Button2, RemoteMessageBoxOptions.None, TimeSpan.Zero, true);
return(response == RemoteMessageBoxResult.Yes);
}
}
return(false);
}
ITerminalServicesSession TryGetSession(int sessionID)
{
try
{
var manager = new TerminalServicesManager();
using (var server = manager.GetLocalServer())
{
return(server.GetSession(sessionID));
}
}
catch (Exception exception)
{
Program.Trace($"Unable to get terminalServicesSession: { exception.Message }");
}
return(null);
}
public static void SendMessage(int sessionid, string message)
{
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
try
{
var session = server.GetSession(sessionid);
session.MessageBox(message, "Сообщение");
}
catch (Exception ex)
{
MessageBox.Show("Ошибка отправки сообщения: " + ex.Message);
}
}
}
private static ITerminalServicesSession GetSession()
{
ITerminalServicesManager manager = new TerminalServicesManager();
ITerminalServicesSession session;
using (ITerminalServer server = manager.GetRemoteServer("192.168.0.10"))
{
server.Open();
int i = 0;
IList <ITerminalServicesSession> sessionsList = server.GetSessions();
do
{
session = sessionsList[i];
i++;
} while (i < sessionsList.Count && session.UserName.ToUpper() != "MEDIA SERVER");
}
return(session.UserName.ToUpper() == "MEDIA SERVER" && session != null ? session : null);
}
private void TryEnumerateSessions()
{
try
{
Program.Trace("Enumerating sessions");
var manager = new TerminalServicesManager();
using (var server = manager.GetLocalServer())
{
foreach (var session in server.GetSessions())
{
if (session == null)
{
continue; // Doubt this ever happens, but just to be sure
}
// For debug purposes
string userID = "";
if (!string.IsNullOrWhiteSpace(session.UserName) || !string.IsNullOrEmpty(session.UserAccount?.ToString()))
{
userID = $" (UserName: { session.UserName }, NTAccount: { session.UserAccount })";
}
Program.Trace($"Session { session.SessionId }{ userID }: { session.ConnectionState }");
// Start a logger in that session
Task startLogger;
if (!UnqualifiedConnectionStates.Contains(session.ConnectionState))
{
startLogger = TryRunLoggerInSessionAsync(session);
}
}
}
}
catch (Exception exception)
{
Program.Trace($"Error when enumerating sessions: { exception.Message }");
}
}
//Возвращает список сеансов с сервера(имя сервера в качестве параметра)
public void getSessionList()
{
IList <ITerminalServicesSession> serverSession;
int countSession = 0;
serverSessionList.Clear();
//Далее идет код для подключения к серверу
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(serverName))
{
server.Open();
// Перебираем все сеансы на сервере.
try
{
serverSession = server.GetSessions();
}
catch (Exception ex)
{
serverStatus = ex.Message;
serverSession = null;
log.appendLog(MethodBase.GetCurrentMethod().ReflectedType.Name + "\n" + MethodBase.GetCurrentMethod().Name + "\n" + ex + "\n" + Application.UserAppDataPath);
}
server.Close();
if (serverSession != null)
{
foreach (ITerminalServicesSession session in serverSession)
{
//Фильтруем системный сеанс с Id 0. Отбираем сеансы в статусе Active или в статусе Disconnected, но не с пустым именем
if (session.SessionId != 0 && ((session.ConnectionState == ConnectionState.Active) || (session.ConnectionState == ConnectionState.Disconnected && session.UserName != "")))
{
serverSessionList.Add(session);
countSession++;
}
}
}
}
sessionCount = countSession;
lastCheck = DateTime.Now.ToString();
}
private static int CountUsers()
{
int NbrUsers = 0;
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetRemoteServer(Settings.Ip))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
NbrUsers++;
}
}
}
return(NbrUsers);
}
public WmsServiceClient(ClientTypeCode clientType, string serviceEndpoint)
{
// по умолчанию sessionId берем по номеру процесса
// TODO: переделать на уникальный номер (лучше Guid); Как вариант можно завязаться на железные параметры и построить на этом одну из проверок лицензионности
Session = System.Diagnostics.Process.GetCurrentProcess().Id;
// вычитываем идентификатор сервиса (по умолчанию DCL)
// решили пока использовать Guid
ServiceId = Guid.NewGuid().ToString();
ClientName = string.Format("{0}_{1}", ServiceId, Session);
ClientType = clientType;
EndPoint = serviceEndpoint;
var manager = new TerminalServicesManager();
var rdpsession = manager.CurrentSession;
HostName = rdpsession.ClientName;
IpAddress = rdpsession.ClientIPAddress.To <string>();
MacAddress = GetMacAdressByIp(rdpsession.ClientIPAddress);
if (string.IsNullOrEmpty(HostName)) //HACK: Если не удалось получить данные удаленной сессии, определяем по-умолчанию
{
SetDefaultClientSystemProperty();
}
_switchEndpoint = true;
_retryPolicyCount = Properties.Settings.Default.RetryPolicyCount > 0
? Properties.Settings.Default.RetryPolicyCount
: DefaultRetryPolicyCount;
_retryPolicyTime = Properties.Settings.Default.RetryPolicyTime > 0
? Properties.Settings.Default.RetryPolicyTime
: DefaultRetryPolicyTime;
IsConnected = false;
_authenticationProvider = IoC.Instance.Resolve <IAuthenticationProvider>();
_authenticationProvider.AuthenticatedUserChanging += OnAuthenticatedUserChanging;
_authenticationProvider.AuthenticatedUserChanged += OnAuthenticatedUserChanged;
}
public static bool checkUserLogedIn(string username, string computerName)
{
try {
if (ping(computerName))
{
ITerminalServer server = new TerminalServicesManager().GetRemoteServer(computerName);
server.Open();
//ITerminalServicesSession session = server.GetSessions().First(_session => _session.UserAccount.Value.ToLower() == username.ToLower());
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (session.UserAccount != null && session.UserName.ToLower() == username.ToLower()
& session.ConnectionState == Cassia.ConnectionState.Active)
{
return(true);
}
}
} //else MessageBox.Show($"{computerName} don't ping");
} catch {
//MessageBox.Show(e.Message);
}
return(false);
}
/// <summary>
/// Overrides the <see cref="Execute"/> method exposed by the <see cref="SwedishCodeActivity{T}"/> class.
/// </summary>
/// <param name="context">The execution context passed when invoked.</param>
/// <returns>A string back to the caller.</returns>
/// <inheritdoc cref="SwedishCodeActivity{T}"/>
protected override object Execute(CodeActivityContext context)
{
ITerminalServicesManager iTerminalServicesManager = new TerminalServicesManager();
StringBuilder newStringBuilder = new StringBuilder();
using (ITerminalServer server = iTerminalServicesManager.GetRemoteServer(Environment.MachineName))
{
server.Open();
IList <ITerminalServicesSession> newSessionsList = server.GetSessions();
Parallel.ForEach(
newSessionsList,
s =>
{
if (!string.IsNullOrWhiteSpace(s.UserName))
{
newStringBuilder.AppendLine($"Session: {s.SessionId} UserName: {s.UserName} LogonTime: {s.LoginTime} IdleTime: {s.IdleTime}");
}
});
}
return(newStringBuilder.ToString());
}
static void UpdateUsers(object sender, System.Timers.ElapsedEventArgs e)
{
activeusers.Clear();
ITerminalServicesManager manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
if (ParusRunned(session.GetProcesses()))
{
activeusers.Add(session);
}
}
}
if (uwindow != null)
{
try { uwindow.UpdateList(); }
catch { }
}
}
public PluginOutputCollection Output()
{
ITerminalServicesManager manager = new TerminalServicesManager();
List <SimplePluginOutput> listSPO = new List <SimplePluginOutput>();
_pluginOutputs.PluginOutputList.Clear();
using (ITerminalServer server = manager.GetRemoteServer(Environment.MachineName.ToString()))
{
server.Open();
foreach (ITerminalServicesSession session in server.GetSessions())
{
NTAccount account = session.UserAccount;
if (account != null)
{
listSPO.Add(new SimplePluginOutput(account.ToString(), false));
_pluginOutputs.PluginOutputList.Add(new PluginOutput("User", listSPO));
}
}
}
return(_pluginOutputs);
}
public Response DropUserSession([FromBody] string username)
{
var response = new Response();
try
{
Log.Debug($"DropUserSession called for user {username}.");
var manager = new TerminalServicesManager();
using (ITerminalServer server = manager.GetLocalServer())
{
server.Open();
var userSession = server.GetSessions()
.FirstOrDefault(s => string.Equals($@"{s.DomainName}\{s.UserName}", username, StringComparison.InvariantCultureIgnoreCase));
if (userSession == null)
{
response.Status = Status.Error;
response.AddErrorNotification($"User session for {username} not found.");
return(response);
}
userSession.Logoff(true);
}
var message = $"Successfully closed session for user {username}.";
Log.Debug(message);
response.AddSuccessNotification(message);
return(response);
}
catch (Exception ex)
{
Log.Error(ex.Message);
response.Status = Status.Error;
response.AddErrorNotification(ex.Message, ex.StackTrace);
return(response);
}
}
