/// <summary> /// returns profiledir based on regkey /// </summary> /// <param name="sid"></param> /// <returns></returns> public static List <string> GetProfileDir(SecurityIdentifier sid) { List <string> ret = new List <string>(); //"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\S-1-5-21-534125731-1308685933-1530606844-1000}" using (RegistryKey key = Registry.LocalMachine.OpenSubKey(ROOT_PROFILE_KEY)) { if (key != null) { foreach (string keyName in key.GetSubKeyNames()) { if (keyName.Contains(sid.ToString())) //get the %SID% and %SID%.bak key { using (RegistryKey subKey = Registry.LocalMachine.OpenSubKey(string.Format("{0}\\{1}", ROOT_PROFILE_KEY, keyName))) { LibraryLogging.Info("ProfileList key found {0}", keyName); ret.Add(subKey.GetValue("ProfileImagePath", "", RegistryValueOptions.None).ToString()); } } } } else { LibraryLogging.Info("GetProfileDir key {0} not found", ROOT_PROFILE_KEY); } } return(ret); }
protected void HandlePipeConnection(BinaryReader reader, BinaryWriter writer, IDictionary <string, object> initialMessage) { try { // If we should announce with a specific message, do so if (initialMessage != null) { WriteMessage(writer, initialMessage); } // So long as our Func<> returns true, we keep going. When it returns false, // it is done and its time to closeup and look for another client. while (StreamAction(reader, writer)) { } } catch (IOException) { throw; } catch (Exception e) { LibraryLogging.Error("Error while using pipe connection: {0}", e); } }
/// <summary> /// sets user profile quota /// </summary> /// <param name="where">ROOTKEY hklm or hku</param> /// <param name="name">SubKey name</param> /// <param name="quota">if 0 means the profile quota GPO it will be deleted</param> /// <returns>false on error</returns> public static Boolean SetQuota(Abstractions.WindowsApi.pInvokes.structenums.RegistryLocation where, string name, uint quota) { LibraryLogging.Info("set Quota for {0}", name); try { using (RegistryKey key = Abstractions.WindowsApi.pInvokes.GetRegistryLocation(where).CreateSubKey(name + @"\Software\Microsoft\Windows\CurrentVersion\Policies\System")) { if (quota > 0) { key.SetValue("EnableProfileQuota", 1, RegistryValueKind.DWord); //key.SetValue("ProfileQuotaMessage", "You have exceeded your profile storage space. Before you can log off, you need to move some items from your profile to network or local storage.", RegistryValueKind.String); key.SetValue("MaxProfileSize", quota, RegistryValueKind.DWord); key.SetValue("IncludeRegInProQuota", 1, RegistryValueKind.DWord); key.SetValue("WarnUser", 1, RegistryValueKind.DWord); key.SetValue("WarnUserTimeout", 5, RegistryValueKind.DWord); } else { key.DeleteValue("EnableProfileQuota", false); key.DeleteValue("ProfileQuotaMessage", false); key.DeleteValue("MaxProfileSize", false); key.DeleteValue("IncludeRegInProQuota", false); key.DeleteValue("WarnUser", false); key.DeleteValue("WarnUserTimeout", false); } } } catch (Exception ex) { LibraryLogging.Error("Can't set profile quota for {0} Error:{1}", name, ex.Message); return(false); } return(true); }
/// <summary> /// remove users who are unknown to the system from the directory acl /// </summary> /// <param name="dir"></param> /// <returns></returns> public static Boolean RemoveAccRuleFromUnknownUser(string dir) { DirectoryInfo dInfo = new DirectoryInfo(dir); DirectorySecurity dSecurity = dInfo.GetAccessControl(); try { foreach (FileSystemAccessRule user in dSecurity.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount))) { //LibraryLogging.Debug("directory ACE user: {0}", user.IdentityReference.Value); if (user.IdentityReference.Value.StartsWith("S-1-5-21-")) { LibraryLogging.Debug("delete unknown directory ACE from {0} in {1}", user.IdentityReference.Value, dir); dSecurity.RemoveAccessRule(user); } } } catch (Exception ex) { LibraryLogging.Error("unable to RemoveAccRuleFromUnknownUser for {0} error {1}", dir, ex.Message); return(false); } return(true); }
private void DetachAbstractionsLibraryLogging() { LibraryLogging.RemoveListener(LibraryLogging.Level.Debug, m_abstractLogger.DebugFormat); LibraryLogging.RemoveListener(LibraryLogging.Level.Error, m_abstractLogger.ErrorFormat); LibraryLogging.RemoveListener(LibraryLogging.Level.Info, m_abstractLogger.InfoFormat); LibraryLogging.RemoveListener(LibraryLogging.Level.Warn, m_abstractLogger.WarnFormat); }
private void HookUpAbstractionsLibraryLogging() { LibraryLogging.AddListener(LibraryLogging.Level.Debug, m_abstractLogger.DebugFormat); LibraryLogging.AddListener(LibraryLogging.Level.Error, m_abstractLogger.ErrorFormat); LibraryLogging.AddListener(LibraryLogging.Level.Info, m_abstractLogger.InfoFormat); LibraryLogging.AddListener(LibraryLogging.Level.Warn, m_abstractLogger.WarnFormat); }
/// <summary> /// get UTC ntp time /// based on http://stackoverflow.com/questions/1193955/how-to-query-an-ntp-server-using-c /// </summary> /// <param name="FQDN">server address</param> /// <returns>DateTime, on error DateTime.MinValue</returns> public static DateTime GetNetworkTime(string[] FQDN) { DateTime RetVal = DateTime.MinValue; //time server for (uint x = 0; x < FQDN.Length; x++) { // NTP message size - 16 bytes of the digest (RFC 2030) Byte[] ntpData = new byte[48]; //Setting the Leap Indicator, Version Number and Mode values ntpData[0] = 0x1B; //LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode) try { IPAddress[] addresses = Dns.GetHostEntry(FQDN[x]).AddressList; //The UDP port number assigned to NTP is 123 IPEndPoint ipEndPoint = new IPEndPoint(addresses[0], 123); //NTP uses UDP Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); socket.ReceiveTimeout = 3 * 1000; socket.SendTimeout = 3 * 1000; socket.Connect(ipEndPoint); socket.Send(ntpData); socket.Receive(ntpData); socket.Close(); //Offset to get to the "Transmit Timestamp" field (time at which the reply //departed the server for the client, in 64-bit timestamp format." const byte serverReplyTime = 40; //Get the seconds part UInt64 intPart = BitConverter.ToUInt32(ntpData, serverReplyTime); //Get the seconds fraction UInt64 fractPart = BitConverter.ToUInt32(ntpData, serverReplyTime + 4); //Convert From big-endian to little-endian intPart = SwapEndianness(intPart); fractPart = SwapEndianness(fractPart); UInt64 milliseconds = (intPart * 1000) + ((fractPart * 1000) / 0x100000000L); //**UTC** time RetVal = (new DateTime(1900, 1, 1)).AddMilliseconds((Int64)milliseconds); break; } catch (Exception ex) { LibraryLogging.Error("get ntp {0} error:{1}", FQDN[x], ex); } } return(RetVal); }
private void ServerThread() { PipeSecurity security = new PipeSecurity(); using (WindowsIdentity myself = WindowsIdentity.GetCurrent()) { try { // Anyone can talk to us LibraryLogging.Debug("Setting PipeAccess R/W for world: {0}", Abstractions.Windows.Security.GetWellknownSID(WellKnownSidType.WorldSid)); security.AddAccessRule(new PipeAccessRule(Abstractions.Windows.Security.GetWellknownSID(WellKnownSidType.WorldSid), PipeAccessRights.ReadWrite, AccessControlType.Allow)); // But only we have full control (including the 'create' right, which allows us to be the server side of this equation) LibraryLogging.Debug("Setting PipeAccess FullControl for myself: {0}", WindowsIdentity.GetCurrent().Name); security.AddAccessRule(new PipeAccessRule(WindowsIdentity.GetCurrent().Owner, PipeAccessRights.FullControl, AccessControlType.Allow)); } catch (Exception e) { LibraryLogging.Error("Unable to set all pipe access rules, the security of the pGina service pipe is in an unknown state!: {0}", e); } } while (Running) { try { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream(Name, PipeDirection.InOut, MaxClients, PipeTransmissionMode.Byte, PipeOptions.WriteThrough, 0, 0, security, HandleInheritability.None)) { try { pipeServer.WaitForConnection(); } catch (Exception e) { LibraryLogging.Error("Error in server connection handler: {0}", e); continue; } // Handle this connection, note that we always expect client to initiate the // flow of messages, so we do not include an initial message HandlePipeConnection(pipeServer, null); } } catch (Exception e) { LibraryLogging.Error("Error while trying to open pipe server: {0}", e); Thread.Sleep(500); } } }
/// <summary> /// apply registry security settings to user profiles /// </summary> /// <param name="where"></param> /// <param name="keyname"></param> /// <param name="username"></param> /// <returns></returns> public static Boolean RegSec(pInvokes.structenums.RegistryLocation where, string keyname, string username) { try { IdentityReference UserIRef = new NTAccount(String.Format("{0}\\{1}", Environment.MachineName, username)); SecurityIdentifier UserSid = (SecurityIdentifier)UserIRef.Translate(typeof(SecurityIdentifier)); using (RegistryKey key = pInvokes.GetRegistryLocation(where).OpenSubKey(keyname, true)) { RegistrySecurity keySecurity = key.GetAccessControl(AccessControlSections.Access); string SDDL = keySecurity.GetSecurityDescriptorSddlForm(AccessControlSections.All); //LibraryLogging.Info(SDDL); foreach (RegistryAccessRule user in keySecurity.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount))) { //LibraryLogging.Info("registry ACE user: {0} {1} {2}", key.Name, user.InheritanceFlags.ToString(), user.IdentityReference.Value); if (user.IdentityReference.Value.StartsWith("S-1-5-21-") && !user.IdentityReference.Value.Equals(UserIRef.Value)) { //LibraryLogging.Info("mod registry ACE:{0} from unknown user:{1} to {2} {3} {4}", key.Name, user.IdentityReference.Value, username, user.RegistryRights.ToString(), user.AccessControlType.ToString()); SDDL = SDDL.Replace(user.IdentityReference.Value, UserSid.Value); //LibraryLogging.Info(SDDL); keySecurity.SetSecurityDescriptorSddlForm(SDDL); key.SetAccessControl(keySecurity); break; } } foreach (string subkey in key.GetSubKeyNames()) { if (!RegSec(where, keyname + "\\" + subkey, username)) { return(false); } } } } catch (SystemException ex) { LibraryLogging.Warn("RegSec:{0} Warning {1}", keyname, ex.Message); } catch (Exception ex) { LibraryLogging.Error("RegSec:{0} Error:{1}", keyname, ex.Message); return(false); } return(true); }
public static Boolean SetDirOwner(string dir, IdentityReference Account) { DirectoryInfo dInfo = new DirectoryInfo(dir); DirectorySecurity dSecurity = dInfo.GetAccessControl(); try { dSecurity.SetOwner(Account); dInfo.SetAccessControl(dSecurity); } catch (Exception ex) { LibraryLogging.Error("SetDirOwner unable to SetOwner for {0} error {1}", dir, ex.Message); return(false); } return(true); }
public static Boolean SetDirOwner(string dir, string Account) { DirectoryInfo dInfo = new DirectoryInfo(dir); DirectorySecurity dSecurity = dInfo.GetAccessControl(); IdentityReference User = new NTAccount(String.Format("{0}\\{1}", Environment.MachineName, Account)); try { dSecurity.SetOwner(User); dInfo.SetAccessControl(dSecurity); } catch (Exception ex) { LibraryLogging.Error("SetDirOwner unable to SetOwner for {0} error {1}", dir, ex.Message); return(false); } return(true); }
public void Start(Func <BinaryReader, BinaryWriter, bool> action, IDictionary <string, object> initialMessage, int timeout) { StreamAction = action; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", Name, PipeDirection.InOut, PipeOptions.WriteThrough, TokenImpersonationLevel.None, HandleInheritability.None)) { for (int x = 1; x <= 5; x++) { try { pipeClient.Connect(timeout); } catch (Exception e) { if (x == 5) { LibraryLogging.Error("Error connecting PipeClient: {0}", e); return; } Thread.Sleep(100); } } // Write the initial message to get the pumps running, // error handling to prevent a pipe error exception try { using (BinaryReader reader = new BinaryReader(pipeClient, Encoding.Unicode /*, true*/)) { using (BinaryWriter writer = new BinaryWriter(pipeClient, Encoding.Unicode /*, true*/)) { HandlePipeConnection(reader, writer, null); } } } catch (IOException) { LibraryLogging.Error("Error broken pipe connection"); Start(action, initialMessage, timeout); } } }
protected void HandlePipeConnection(PipeStream pipeStream, IDictionary <string, object> initialMessage) { // You think we'd scope these with using() right? They are IDisposable // after all... but nope, the implementation of these is such that // disposing of them also disposes the underlying stream. Leaving us // with a double (or triple if we close the pipeServer stream ourselves) // close. Yay. Instead we abandoned these to the GC knowing that they // are only wrappers anyway and have/use little/no resources of their own. BinaryReader reader = new BinaryReader(pipeStream, Encoding.Unicode); BinaryWriter writer = new BinaryWriter(pipeStream, Encoding.Unicode); try { // If we should announce with a specific message, do so if (initialMessage != null) { WriteMessage(writer, initialMessage); } // So long as our Func<> returns true, we keep going. When it returns false, // it is done and its time to closeup and look for another client. while (StreamAction(reader, writer)) { } } catch (Exception e) { LibraryLogging.Error("Error while using pipe connection: {0}", e); } try { pipeStream.Flush(); pipeStream.WaitForPipeDrain(); pipeStream.Close(); } catch (Exception e) { LibraryLogging.Error("Error while flushing/closing pipe connection: {0}", e); } }
/// <summary> /// return true if profile is temp. uses ProfileList State regkey /// </summary> /// <param name="sid"></param> /// <returns></returns> public static bool?IsProfileTemp(string sid) { try { using (RegistryKey key = Registry.LocalMachine.OpenSubKey(string.Format("{0}\\{1}", ROOT_PROFILE_KEY, sid))) { if (key != null) { object type = key.GetValue("State"); Profile_State value = 0; switch (key.GetValueKind("State")) { case RegistryValueKind.DWord: value = (Profile_State)type; break; case RegistryValueKind.QWord: value = (Profile_State)type; break; } if (value.HasFlag(Profile_State.Temporary_profile_loaded)) { return(true); } } else { LibraryLogging.Info("IsProfileTemp key {0}\\{1} not found", ROOT_PROFILE_KEY, sid); return(null); } } } catch (Exception ex) { LibraryLogging.Info("IsProfileTemp exception:{0}", ex.Message); return(null); } return(false); }
public static Boolean SetDirectorySecurity(string dir, string[] Account, FileSystemRights Rights, AccessControlType ControlType, InheritanceFlags Inherit, PropagationFlags Propagation) { DirectoryInfo dInfo = new DirectoryInfo(dir); DirectorySecurity dSecurity = dInfo.GetAccessControl(); try { foreach (string account in Account) { dSecurity.AddAccessRule(new FileSystemAccessRule(account, Rights, Inherit, Propagation, ControlType)); } dInfo.SetAccessControl(dSecurity); } catch (Exception ex) { LibraryLogging.Error("unable to SetDirectorySecurity for {0} error {1}", dir, ex.Message); return(false); } return(true); }
/// <summary> /// query for already set user profile quota /// </summary> /// <param name="where"></param> /// <param name="name"></param> /// <returns>true on already set</returns> public static Boolean QueryQuota(Abstractions.WindowsApi.pInvokes.structenums.RegistryLocation where, string name) { LibraryLogging.Info("query Quota for {0}", name); try { using (RegistryKey key = Abstractions.WindowsApi.pInvokes.GetRegistryLocation(where).OpenSubKey(name + @"\Software\Microsoft\Windows\CurrentVersion\Policies\System")) { if (key.GetValue("EnableProfileQuota") == null) { return(false); } } } catch (Exception ex) { LibraryLogging.Error("Can't get profile quota for {0} Error:{1}", name, ex.Message); return(false); } return(true); }
public void Start(Func <BinaryReader, BinaryWriter, bool> action, IDictionary <string, object> initialMessage, int timeout) { StreamAction = action; using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", Name, PipeDirection.InOut, PipeOptions.WriteThrough, TokenImpersonationLevel.None, HandleInheritability.None)) { try { pipeClient.Connect(timeout); } catch (Exception e) { LibraryLogging.Error("Error connecting PipeClient: {0}", e); return; } // Write the initial message to get the pumps running, // not in a try/catch so that errors bubble up HandlePipeConnection(pipeClient, initialMessage); } }
public static Boolean ReplaceDirectorySecurity(string dir, IdentityReference[] Account, FileSystemRights Rights, AccessControlType ControlType, InheritanceFlags Inherit, PropagationFlags Propagation) { DirectoryInfo dInfo = new DirectoryInfo(dir); DirectorySecurity dSecurity = new DirectorySecurity(); try { dSecurity.SetAccessRuleProtection(true, false); foreach (IdentityReference account in Account) { dSecurity.ResetAccessRule(new FileSystemAccessRule(account, Rights, Inherit, Propagation, ControlType)); } dInfo.SetAccessControl(dSecurity); } catch (Exception ex) { LibraryLogging.Error("unable to ReplaceDirectorySecurity for {0} error {1}", dir, ex.Message); return(false); } return(true); }
public static Boolean ReplaceFileSecurity(string File, string[] Account, FileSystemRights Rights, AccessControlType ControlType, InheritanceFlags Inherit, PropagationFlags Propagation) { FileInfo fInfo = new FileInfo(File); FileSecurity fSecurity = fInfo.GetAccessControl(); try { fSecurity.SetAccessRuleProtection(true, false); foreach (string account in Account) { fSecurity.ResetAccessRule(new FileSystemAccessRule(account, Rights, Inherit, Propagation, ControlType)); } fInfo.SetAccessControl(fSecurity); } catch (Exception ex) { LibraryLogging.Error("unable to ReplaceFileSecurity for {0} error {1}", File, ex.Message); return(false); } return(true); }
/// <summary> /// apply recursive attribute to directories and files /// </summary> /// <param name="dir"></param> /// <param name="attrib"></param> /// <returns></returns> public static Boolean SetRecDirAttrib(DirectoryInfo dir, FileAttributes attrib) { try { foreach (DirectoryInfo subDirPath in dir.GetDirectories()) { subDirPath.Attributes = attrib; SetRecDirAttrib(subDirPath, attrib); } foreach (FileInfo filePath in dir.GetFiles()) { filePath.Attributes = attrib; } } catch (Exception ex) { LibraryLogging.Error("Cant't set attrib {0} on {1} Error:{2}", attrib, dir, ex.Message); return(false); } return(true); }
/// <summary> /// does send a mail including the last 60 system-Event and application-Event lines /// plus the last 175 pgina logfile lines /// </summary> /// <param name="mailAddress"></param> /// <param name="smtpAddress"></param> /// <param name="username"></param> /// <param name="password"></param> /// <param name="subject"></param> /// <param name="body"></param> /// <param name="ssl"></param> /// <returns></returns> public static Boolean email(string[] mailAddress, string[] smtpAddress, string username, string password, string subject, string body, bool ssl) { Boolean ret = false; #region input checks if (mailAddress.Length == 0) { LibraryLogging.Error("can't send email: mailAddress.Length == 0"); return(false); } else { bool atleastonemail = false; foreach (string str in mailAddress) { if (!String.IsNullOrEmpty(str)) { atleastonemail = true; break; } } if (!atleastonemail) { LibraryLogging.Error("can't send email: mailAddress array is empty"); return(false); } } if (smtpAddress.Length == 0) { LibraryLogging.Error("can't send email: smtpAddress.Length == 0"); return(false); } else { bool atleastoneserver = false; foreach (string str in smtpAddress) { if (!String.IsNullOrEmpty(str)) { atleastoneserver = true; break; } } if (!atleastoneserver) { LibraryLogging.Error("can't send email: smtpAddress array is empty"); return(false); } } if (String.IsNullOrEmpty(subject)) { LibraryLogging.Error("can't send email: subject is empty"); } #endregion try { using (EventLog systemLog = new EventLog("System")) { body += "\n\n====================Eventlog System====================\n"; for (int x = systemLog.Entries.Count - 60; x < systemLog.Entries.Count; x++) { body += String.Format("{0:yyyy-MM-dd HH:mm:ss} {1} {2} {3}\n", systemLog.Entries[x].TimeGenerated, systemLog.Entries[x].EntryType, (UInt16)systemLog.Entries[x].InstanceId, systemLog.Entries[x].Message); } } using (EventLog application = new EventLog("Application")) { body += "\n\n====================Eventlog Application===============\n"; for (int x = application.Entries.Count - 60; x < application.Entries.Count; x++) { body += String.Format("{0:yyyy-MM-dd HH:mm:ss} {1} {2} {3}\n", application.Entries[x].TimeGenerated, application.Entries[x].EntryType, (UInt16)application.Entries[x].InstanceId, application.Entries[x].Message); } } } catch { } ServicePointManager.ServerCertificateValidationCallback = delegate(object s, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return(true); }; for (uint x = 0; x < smtpAddress.Length; x++) { string smtp = smtpAddress[x].Split(new char[] { ':' }).First(); int port = 465; if (String.Compare(smtp, smtpAddress[x].Split(new char[] { ':' }).Last()) != 0) { try { port = Convert.ToInt32(smtpAddress[x].Split(new char[] { ':' }).Last()); } catch (Exception ex) { LibraryLogging.Warn("unable to retrieve smtp port from {0} Error:{1}", smtpAddress[x], ex.Message); continue; } } using (SmtpClient client = new SmtpClient(smtp, port)) { client.EnableSsl = ssl; client.Timeout = Convert.ToInt32(new TimeSpan(0, 0, 30).TotalMilliseconds); if (!String.IsNullOrEmpty(username) && !String.IsNullOrEmpty(password)) { client.Credentials = new NetworkCredential(username, password); } for (uint y = 0; y < mailAddress.Length; y++) { if (mailAddress[y] == null) { continue; } try { // get the logfile string logfile = null; logfile = LogManager.GetRepository().GetAppenders().OfType <FileAppender>().Where(fa => fa.Name == "bigfile").Single().File; if (!String.IsNullOrEmpty(logfile)) { using (StreamReader log = new StreamReader(logfile, true)) { // read the last 50kbytes of the log if (log.BaseStream.Length > 50 * 1024) //50kbytes { log.BaseStream.Seek(50 * 1024 * -1, SeekOrigin.End); } string[] lastlines = log.ReadToEnd().Split('\n'); int line_count = 0; if (lastlines.Length > 175) { line_count = lastlines.Length - 176; } body += "\n\n====================Pgina log==========================\n"; for (; line_count < lastlines.Length; line_count++) { body += lastlines[line_count] + '\n'; } } } using (MailMessage message = new MailMessage(mailAddress[y], mailAddress[y], subject, body)) { client.Send(message); } mailAddress[y] = null; } catch (Exception ex) { LibraryLogging.Warn("Failed to send message \"{0}\" to:{1} port:{2} Error:{3}", subject, smtp, port, ex.Message); } } } if (mailAddress.All(k => string.IsNullOrEmpty(k))) { ret = true; break; } } return(ret); }
private void ServerThread() { PipeSecurity security = new PipeSecurity(); using (WindowsIdentity myself = WindowsIdentity.GetCurrent()) { try { // Anyone can talk to us LibraryLogging.Debug("Setting PipeAccess R/W for world: {0}", Abstractions.Windows.Security.GetWellknownSID(WellKnownSidType.WorldSid)); security.AddAccessRule(new PipeAccessRule(Abstractions.Windows.Security.GetWellknownSID(WellKnownSidType.WorldSid), PipeAccessRights.ReadWrite, AccessControlType.Allow)); // But only we have full control (including the 'create' right, which allows us to be the server side of this equation) LibraryLogging.Debug("Setting PipeAccess FullControl for myself: {0}", WindowsIdentity.GetCurrent().Name); security.AddAccessRule(new PipeAccessRule(WindowsIdentity.GetCurrent().Owner, PipeAccessRights.FullControl, AccessControlType.Allow)); } catch (Exception e) { LibraryLogging.Error("Unable to set all pipe access rules, the security of the pGina service pipe is in an unknown state!: {0}", e); } } while (Running) { try { using (NamedPipeServerStream pipeServer = new NamedPipeServerStream(Name, PipeDirection.InOut, MaxClients, PipeTransmissionMode.Byte, PipeOptions.WriteThrough, 0, 0, security, HandleInheritability.None)) { try { pipeServer.WaitForConnection(); } catch (Exception e) { LibraryLogging.Error("Error in server connection handler: {0}", e); continue; } // Handle this connection, note that we always expect client to initiate the // flow of messages, so we do not include an initial message using (BinaryReader reader = new BinaryReader(pipeServer, Encoding.Unicode /*, true*/)) { using (BinaryWriter writer = new BinaryWriter(pipeServer, Encoding.Unicode /*, true*/)) { HandlePipeConnection(reader, writer, null); } } } } catch (Exception e) { LibraryLogging.Error("Error while trying to open pipe server: {0}", e); if (Running) { dynamic s_settings = new Abstractions.Settings.DynamicSettings(); Abstractions.Windows.Networking.sendMail(s_settings.GetSettings(new string[] { "notify_pass" }), "", "", String.Format("pGina: PipeServer error {0}", Environment.MachineName), e.ToString()); } } } }