private void ensureOnlyOne()
{
var pipeName = $"{this.GetType().FullName}.{winServiceInstaller.ServiceName}";
try
{
var serverStream = createNewNamedPipedServerStream(pipeName);
AsyncCallback ac = null;
ac = ar =>
{
showForm();
serverStream.Close();
serverStream = createNewNamedPipedServerStream(pipeName);
serverStream.BeginWaitForConnection(ac, null);
};
serverStream.BeginWaitForConnection(ac, null);
}
catch
{
try
{
var clientStream = new NamedPipeClientStream(pipeName);
clientStream.Connect();
clientStream.Close();
}
finally
{
this.DialogResult = DialogResult.Cancel;
this.Close();
Environment.Exit(0);
}
}
}
public ClientDirectStream(string name)
{
// this type exists so that consumer doesn't need to care about all these arguments/flags to get good performance
_name = name;
_pipe = new NamedPipeClientStream(serverName: ".", pipeName: name, direction: PipeDirection.Out);
_stream = new BufferedStream(_pipe, BUFFERSIZE);
}
static void Main(string[] args)
{
if (args.Length < 3)
return;
var pipe = new NamedPipeClientStream(args[2].Substring(9, args[2].Length - 9));
pipe.Connect();
var reader = new StreamReader(pipe);
while(true)
{
if(reader.ReadLine().StartsWith("c:getPlatforms", StringComparison.InvariantCulture))
{
WriteNumber(pipe, -3085);
WriteNumber(pipe, 0);
WriteNumber(pipe, 0);
WriteNumber(pipe, 1);
WriteNumber(pipe, 0);
WriteNumber(pipe, 2);
WriteNumber(pipe, 8);
WriteNumber(pipe, 1);
WriteNumber(pipe, 1);
WriteNumber(pipe, 2);
WriteNumber(pipe, 10);
WriteNumber(pipe, 0);
WriteNumber(pipe, 0);
}
}
}
public void StartListening(Action<string> messageRecieved)
{
Task.Factory.StartNew(() =>
{
while (true)
{
try
{
using (
var pipe = new NamedPipeClientStream(".", "htmlbackground", PipeDirection.In,
PipeOptions.Asynchronous))
{
pipe.Connect(500);
if (pipe.IsConnected)
{
using (var streamReader = new StreamReader(pipe))
{
var message = streamReader.ReadToEnd();
if (messageRecieved != null)
{
// invoke the message received action
messageRecieved(message);
}
}
}
}
}
catch (TimeoutException)
{
}
}
}, TaskCreationOptions.LongRunning);
}
static void Main(string[] args)
{
using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".",
"testpipe",
PipeDirection.InOut))
{
// Connect to the pipe or wait until the pipe is available.
Console.Write("Attempting to connect to pipe...");
pipeClient.Connect();
Console.WriteLine("Connected to pipe.");
Console.WriteLine("There are currently {0} pipe server instances open.",
pipeClient.NumberOfServerInstances);
while (pipeClient.IsConnected)
{
using (StreamReader sr = new StreamReader(pipeClient))
{
// Display the read text to the console
string temp;
while ((temp = sr.ReadLine()) != null)
{
Console.WriteLine("Received from server: {0}", temp);
}
}
}
}
Console.Write("Press Enter to continue...");
Console.ReadLine();
}
public void CheckUnenrolledHostShouldRemoved()
{
CredentialReceiver.instance.Init();
ServerListHelper.instance.Init();
DatabaseManager.CreateNewConnection(dbName);
IXenConnection connection = DatabaseManager.ConnectionFor(dbName);
Session _session = DatabaseManager.ConnectionFor(dbName).Session;
DatabaseManager.ConnectionFor(dbName).LoadCache(_session);
Dictionary<string, string> config = cleanStack();
connection.LoadCache(_session);
int conSize = ServerListHelper.instance.GetServerList().Count;
NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", HealthCheckSettings.HEALTH_CHECK_PIPE, PipeDirection.Out);
pipeClient.Connect();
string credential = EncryptionUtils.ProtectForLocalMachine(String.Join(SEPARATOR.ToString(), new[] { connection.Hostname, connection.Username, connection.Password }));
pipeClient.Write(Encoding.UTF8.GetBytes(credential), 0, credential.Length);
pipeClient.Close();
System.Threading.Thread.Sleep(1000);
List<ServerInfo> con = ServerListHelper.instance.GetServerList();
Assert.IsTrue(con.Count == conSize + 1);
//1. If XenServer has not enroll, lock will not been set.
config = cleanStack();
config[HealthCheckSettings.STATUS] = "false";
Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
Assert.IsFalse(RequestUploadTask.Request(connection, _session));
con = ServerListHelper.instance.GetServerList();
Assert.IsTrue(con.Count == conSize);
CredentialReceiver.instance.UnInit();
}
public void Connect(string pipeName, string serverName = ".", int timeout = 2000)
{
NamedPipeClientStream pipeStream = null;
try
{
pipeStream = new NamedPipeClientStream(serverName, pipeName, PipeDirection.InOut,
PipeOptions.Asynchronous, TokenImpersonationLevel.Impersonation);
pipeStream.Connect(timeout);
using (var stringStream = new StringStream(pipeStream))
{
if (OnConnected != null)
{
OnConnected(stringStream);
}
}
}
catch (Exception exception)
{
if (OnErrorOcurred != null)
{
OnErrorOcurred(exception);
}
}
finally
{
if (pipeStream != null && pipeStream.IsConnected)
{
pipeStream.Flush();
pipeStream.Close();
}
}
}
public static bool SendCommandToCore(string machine, string command)
{
NamedPipeClientStream pipeClient =
new NamedPipeClientStream(machine, Kernel.MBCLIENT_MUTEX_ID,
PipeDirection.Out, PipeOptions.None);
StreamWriter sw = new StreamWriter(pipeClient);
try
{
pipeClient.Connect(2000);
}
catch (TimeoutException)
{
Logger.ReportWarning("Unable to send command to core (may not be running).");
return false;
}
try
{
sw.AutoFlush = true;
sw.WriteLine(command);
pipeClient.Flush();
pipeClient.Close();
}
catch (Exception e)
{
Logger.ReportException("Error sending commmand to core", e);
return false;
}
return true;
}
private void Run()
{
foreach (var message in _messages.GetConsumingEnumerable())
{
try
{
var pipe = new NamedPipeClientStream(".", _pipeName, PipeDirection.Out, PipeOptions.Asynchronous);
try
{
pipe.Connect(0);
}
catch (TimeoutException)
{
continue;
}
using (var writer = new StreamWriter(pipe))
{
writer.WriteLine(message);
}
}
catch (Exception ex)
{
// TODO: Something?
continue;
}
}
}
public void Start()
{
this.serialPort =
new SerialPort(
CurrentSettings.ComPort,
CurrentSettings.BaudRate,
CurrentSettings.Parity,
CurrentSettings.DataBits,
CurrentSettings.StopBits)
{
RtsEnable = true,
DtrEnable = true,
Encoding = Encoding.UTF8
};
this.namedPipe =
new NamedPipeClientStream(
CurrentSettings.MachineName,
CurrentSettings.NamedPipe,
PipeDirection.InOut,
PipeOptions.Asynchronous);
this.portForwarder = new Thread(this.PortForwarder);
portForwarder.Start();
IsStarted = true;
}
private byte[] readMessage(NamedPipeClientStream client)
{
byte[] message = new byte[0];
_offset = 0;
_current = new List<byte>();
while (true)
{
var i = client.ReadByte();
if (i == -1)
{
_offset = 0;
return new byte[0];
}
if (i == 0)
{
var buffer = new byte[_offset];
Array.Copy(_bytes, buffer, _offset);
_current.AddRange(buffer);
message = _current.ToArray();
_current = new List<byte>();
_offset = 0;
break;
}
_bytes[_offset] = Convert.ToByte(i);
_offset++;
if (_offset == _bytes.Length)
{
_current.AddRange(_bytes);
_offset = 0;
}
}
return message;
}
public Sockets(DataTable dtSockets, Main.SockInfo sinfo, NamedPipeClientStream pout)
{
int i;
InitializeComponent();
pipeOut = pout;
foreach (DataRow drow in dtSockets.Rows)
{
i = dgridSockets.Rows.Add();
dgridSockets.Rows[i].Cells["socket"].Value = ((int)drow["socket"]).ToString("X4");
if (drow["proto"].ToString() != String.Empty)
dgridSockets.Rows[i].Cells["proto"].Value = sinfo.proto((int)drow["proto"]);
if (drow["fam"].ToString() != String.Empty)
if (((int)drow["fam"] >= 0) && ((int)drow["fam"] <= sinfo.afamily.Length - 1))
dgridSockets.Rows[i].Cells["fam"].Value = sinfo.afamily[(int)drow["fam"]];
if (drow["type"].ToString() != String.Empty)
if (((int)drow["type"] >= 0) && ((int)drow["type"] <= sinfo.atype.Length - 1))
dgridSockets.Rows[i].Cells["type"].Value = sinfo.atype[(int)drow["type"]];
if (drow["lastapi"].ToString() != String.Empty)
dgridSockets.Rows[i].Cells["lastapi"].Value = sinfo.api((int)drow["lastapi"]);
if (drow["lastmsg"].ToString() != String.Empty)
dgridSockets.Rows[i].Cells["lastmsg"].Value = sinfo.msg((int) drow["lastmsg"]);
dgridSockets.Rows[i].Cells["local"].Value = drow["local"].ToString();
dgridSockets.Rows[i].Cells["remote"].Value = drow["remote"].ToString();
}
}
/// <summary>
/// Sends message to all remote listeners
/// </summary>
/// <param name="data">Message data</param>
protected override void SendMessage(byte[] data)
{
foreach (var pipeConfiguration in _clientPipesConfiguration)
{
using (var namedPipeClient = new NamedPipeClientStream(
pipeConfiguration.ServerName, pipeConfiguration.Name))
{
try
{
_log.DebugFormat("Send message to {0}\\{1}",
pipeConfiguration.ServerName, pipeConfiguration.Name);
if (!ConnectToPipe(namedPipeClient))
{
_log.WarnFormat("Couldn't connect to pipe {0}\\{1}",
pipeConfiguration.ServerName, pipeConfiguration.Name);
continue;
}
namedPipeClient.Write(data, 0, data.Length);
}
catch (IOException ex)
{
_log.Warn("Exception while sending a message", ex);
}
}
}
}
private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
var p = UtilityProgram.CallWithAdmin("--download-packages", mod);
Regex r = new Regex(@"(\d{1,3})% (\d+/\d+ bytes)");
NamedPipeClientStream pipe = new NamedPipeClientStream(".", "OpenRA.Utility", PipeDirection.In);
pipe.Connect();
using (var response = new StreamReader(pipe))
{
while (!p.HasExited)
{
string s = response.ReadLine();
if (Util.IsError(ref s))
{
e.Cancel = true;
e.Result = s;
return;
}
if (!r.IsMatch(s)) continue;
var m = r.Match(s);
backgroundWorker1.ReportProgress(int.Parse(m.Groups[1].Value), m.Groups[2].Value);
}
}
}
public void Close()
{
Console.WriteLine(string.Format("closing pipe server {0}...", PipeName));
m_closing = true;
//emulate new client connected to resume listener thread
using (NamedPipeClientStream fakeClient = new NamedPipeClientStream(".", PipeName, PipeDirection.In))
{
try
{
fakeClient.Connect(100);
fakeClient.Close();
}
catch
{
//server was stopped already
}
}
if (m_listenerThread != null && m_listenerThread.IsAlive)
{
if (!m_listenerThread.Join(5000))
{
m_listenerThread.Abort();
}
}
m_listenerThread = null;
Console.WriteLine(string.Format("disconnecting clients from pipe {0}...", PipeName));
while (m_pipeStreams.Count > 0)
{
DisconnectClient(m_pipeStreams[0]);
}
Console.WriteLine(string.Format("Pipe server {0} stopped OK", PipeName));
}
/// <summary>
/// Calls method with one parameter and result. Deserializes parameter and serialize result.
/// </summary>
/// <param name="type">Type containing method</param>
/// <param name="methodName">Name of method to call</param>
/// <param name="pipeName">Name of pipe to pass parameter and result</param>
static void InvokeFunc(Type type, string methodName, string pipeName)
{
using (var pipe = new NamedPipeClientStream(pipeName))
{
pipe.Connect();
var formatter = new BinaryFormatter();
ProcessThreadParams pars;
var lengthBytes = new byte[4];
pipe.Read(lengthBytes, 0, 4);
var length = BitConverter.ToInt32(lengthBytes, 0);
var inmemory = new MemoryStream(length);
var buf = new byte[1024];
while (length != 0)
{
var red = pipe.Read(buf, 0, buf.Length);
inmemory.Write(buf, 0, red);
length -= red;
}
inmemory.Position = 0;
try
{
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
{
return type.Assembly;
};
pars = (ProcessThreadParams)formatter.Deserialize(inmemory);
var method = type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance, null, pars.Types, null);
if (method == null) throw new InvalidOperationException("Method is not found: " + methodName);
if (pars.Pipe != null)
{
var auxPipe = new NamedPipeClientStream(pars.Pipe);
auxPipe.Connect();
for (int i = 0; i < pars.Parameters.Length; i++)
if (pars.Parameters[i] is PipeParameter) pars.Parameters[i] = auxPipe;
}
object result = method.Invoke(pars.Target, pars.Parameters);
var outmemory = new MemoryStream();
formatter.Serialize(outmemory, ProcessThreadResult.Successeded(result));
outmemory.WriteTo(pipe);
}
catch (TargetInvocationException e)
{
formatter.Serialize(pipe, ProcessThreadResult.Exception(e.InnerException));
throw e.InnerException;
}
catch (Exception e)
{
formatter.Serialize(pipe, ProcessThreadResult.Exception(e));
throw;
}
}
}
public override void evaluate()
{
try
{
if ((bool)pinInfo["trigger"].value.data && lastInput != pinInfo["trigger"].value.data)
{
myPipe = new NamedPipeClientStream(".", "lavalamp winamp control", PipeDirection.InOut,
PipeOptions.None);
myPipe.Connect(500);
StreamWriter myWriter = new StreamWriter(myPipe);
myWriter.AutoFlush = true;
myWriter.Write(Cmd);
myPipe.Close();
}
lastInput = pinInfo["trigger"].value;
}
catch (ObjectDisposedException)
{
// todo - add option to ignore errors / errored state / etc
MessageBox.Show("Unable to contact winamp. Is it running? Is the plugin installed OK?");
}
catch (IOException)
{
// todo - add option to ignore errors / errored state / etc
MessageBox.Show("Unable to contact winamp. Is it running? Is the plugin installed OK?");
}
catch (System.TimeoutException)
{
MessageBox.Show("Unable to contact winamp. Is it running? Is the plugin installed OK?");
}
}
public static void SendMessage(String optionVal)
{
using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "RipplePipe", PipeDirection.Out, PipeOptions.Asynchronous))
{
try
{
pipeClient.Connect(2000);
}
catch (Exception)
{
//Try once more
try
{
pipeClient.Connect(5000);
}
catch (Exception ex)
{
RippleCommonUtilities.LoggingHelper.LogTrace(1, "Went wrong in Send Message at Screen side {0}", ex.Message);
return;
}
}
//Connected to the server or floor application
using (StreamWriter sw = new StreamWriter(pipeClient))
{
sw.Write(optionVal);
}
}
}
private void client()
{
System.IO.Pipes.NamedPipeClientStream pipeClient = new System.IO.Pipes.NamedPipeClientStream(".", "testpipe", System.IO.Pipes.PipeDirection.InOut, System.IO.Pipes.PipeOptions.None);
if (pipeClient.IsConnected != true)
{
pipeClient.Connect();
}
StreamReader sr = new StreamReader(pipeClient);
StreamWriter sw = new StreamWriter(pipeClient);
string temp;
temp = sr.ReadLine();
if (temp == "Waiting")
{
try
{
sw.WriteLine("Test Message");
sw.Flush();
pipeClient.Close();
}
catch (Exception ex) { throw ex; }
}
}
public string getMessage()
{
NamedPipeClientStream pipe_client =
new NamedPipeClientStream(".", pipe_name, PipeDirection.InOut);
try
{
Console.WriteLine("connect");
pipe_client.Connect();
Console.WriteLine("connect--e");
}
catch (InvalidOperationException e)
{
Console.WriteLine("InvalidOperationException" + e);
}
StreamReader sr = new StreamReader(pipe_client);
string message;
while ((message = sr.ReadLine()) != null)
{
Console.WriteLine(message);
}
return "hoge";
}
private static void SendCommand(string sContent)
{
string sProgramName = ConfigurationManager.AppSettings["dstProgramName"];
using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", sProgramName,
PipeDirection.Out,
PipeOptions.None))
{
Console.WriteLine("Attempting to connect to pipe...");
try
{
pipeClient.Connect(1000);
}
catch
{
Console.WriteLine("The Pipe server must be started in order to send data to it.");
return;
}
Console.WriteLine("Connected to pipe.");
using (StreamWriter sw = new StreamWriter(pipeClient))
{
sw.Write(sContent);
}
}
}
public bool TryConnectToNamedPipeWithSpinWait(int timeoutMs, CancellationToken cancellationToken)
{
using (var pipeStream = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous))
{
return BuildServerConnection.TryConnectToNamedPipeWithSpinWait(pipeStream, timeoutMs, cancellationToken);
}
}
static void Main()
{
ClearModifierKeys();
var args = Environment.GetCommandLineArgs();
var multi = args.Any(arg => arg == "-multi");
if ((multi) || (mutex.WaitOne(TimeSpan.Zero, true)))
{
var app = new App();
if (!multi)
SetupPipeWait(app);
app.Run();
if (!multi)
mutex.ReleaseMutex();
return;
}
// Server already exists; connect and send command line
var pipeClient = new NamedPipeClientStream(".", IPCName, PipeDirection.InOut);
pipeClient.Connect();
var buf = Coder.StringToBytes(string.Join(" ", args.Skip(1).Select(arg => $"\"{arg.Replace(@"""", @"""""")}\"")), Coder.CodePage.UTF8);
var size = BitConverter.GetBytes(buf.Length);
pipeClient.Write(size, 0, size.Length);
pipeClient.Write(buf, 0, buf.Length);
}
private static void PipesWriter(string pipeName)
{
try
{
using (var pipeWriter = new NamedPipeClientStream("TheRocks", pipeName, PipeDirection.Out))
{
pipeWriter.Connect();
WriteLine("writer connected");
bool completed = false;
while (!completed)
{
string input = ReadLine();
if (input == "bye") completed = true;
byte[] buffer = Encoding.UTF8.GetBytes(input);
pipeWriter.Write(buffer, 0, buffer.Length);
}
}
WriteLine("completed writing");
}
catch (Exception ex)
{
WriteLine(ex.Message);
}
}
public static Task<bool> SendMessageToServer(string pipeName, string message)
{
return Task.Run(() =>
{
try
{
using (var pipe = new NamedPipeClientStream(".", pipeName, PipeDirection.Out))
{
pipe.Connect(1000);
using (var stream = new StreamWriter(pipe))
{
stream.Write(message);
stream.Flush();
}
}
return true;
}
catch (TimeoutException)
{
}
catch (Exception exc)
{
Log.Debug(string.Format("Sending message on: {0}", pipeName), exc);
}
return false;
});
}
public DxDeviceCtrl()
{
KeybdPipeSwCollection=new Collection<StreamWriter>();
var id = 0;
bool failed = false;
for (id = 0; false == failed; ++id)
{
var KeybdPipe = new NamedPipeClientStream(".", "DxKeybdPipe" + id.ToString(), PipeDirection.Out);
try
{
KeybdPipe.Connect(50);
if (true == KeybdPipe.IsConnected)
{
var KeybdPipeSW = new StreamWriter(KeybdPipe);
KeybdPipeSW.AutoFlush = true;
KeybdPipeSwCollection.Add(KeybdPipeSW);
}
else
{
failed = true;
}
}
catch (Exception )
{
failed = true;
}
}
}
static void Main()
{
using (Mutex mutex = new Mutex(false, @"Global\simpledlnaguilock")) {
#if !DEBUG
if (!mutex.WaitOne(0, false)) {
using (var pipe = new NamedPipeClientStream(".", "simpledlnagui", PipeDirection.Out)) {
try {
pipe.Connect(10000);
pipe.WriteByte(1);
}
catch (Exception) {
}
return;
}
}
GC.Collect();
#endif
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
using (var main = new FormMain()) {
try {
Application.Run(main);
}
catch (Exception ex) {
log4net.LogManager.GetLogger(typeof(Program)).Fatal("Encountered fatal unhandled exception", ex);
throw;
}
}
}
}
public static void SendMessage(String optionVal)
{
using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "RipplePipe", PipeDirection.Out, PipeOptions.Asynchronous))
{
try
{
pipeClient.Connect(2000);
}
catch (Exception)
{
//Try once more
try
{
pipeClient.Connect(5000);
}
catch (Exception)
{
return;
}
}
//Connected to the server or floor application
using (StreamWriter sw = new StreamWriter(pipeClient))
{
sw.Write(optionVal);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NamedPipeCommunicationChannel" /> class.
/// </summary>
/// <param name="endPoint">The end point.</param>
/// <param name="pipeStream">An existing pipe stream or <c>null</c> to create client.</param>
public NamedPipeCommunicationChannel(NamedPipeEndPoint endPoint, PipeStream pipeStream = null)
{
_endPoint = endPoint;
if (pipeStream != null) _pipeStream = pipeStream;
else
{
var client = new NamedPipeClientStream(".", endPoint.Name, PipeDirection.InOut, PipeOptions.Asynchronous | PipeOptions.WriteThrough);
// connect overload with timeout is extremely processor intensive
int elapsed = 0, connectionTimeout = endPoint.ConnectionTimeout * 1000;
CONNECT:
try
{
client.Connect(0);
}
catch (TimeoutException)
{
Thread.Sleep(CONNECT_ATTEMPT_INTERVAL_MS);
if (endPoint.ConnectionTimeout != Timeout.Infinite && (elapsed += CONNECT_ATTEMPT_INTERVAL_MS) > connectionTimeout)
throw new TimeoutException("The host failed to connect. Timeout occurred.");
goto CONNECT;
}
_pipeStream = client;
}
_buffer = new byte[ReceiveBufferSize];
_syncLock = new object();
}
static int Main(string[] args)
{
if (args.Length != 1)
{
return 1;
}
var pipeName = args[0];
//Console.WriteLine(nameof(pipeName) + " = " + pipeName);
using (var pipeClient = new NamedPipeClientStream(pipeName))
{
pipeClient.Connect();
// Receive meta data first.
var messageTypeCommunicator = new CodeShardCommunicator<Type>(pipeClient);
var messageType = messageTypeCommunicator.Receive();
var entryPointCommunicator = new CodeShardCommunicator<object>(pipeClient);
var entryPointInstance = entryPointCommunicator.Receive();
// Get run method for the hosted user code.
var entryPointType = entryPointInstance.GetType();
var expectedInterfaceType = typeof(ICodeShardEntryPoint<>).MakeGenericType(messageType);
var runMethodInfo = expectedInterfaceType.GetMethods()[0];
// Create communicator instance for the hosted user code.
var communicatorType = typeof(CodeShardCommunicator<>).MakeGenericType(messageType);
var communicatorInstance = Activator.CreateInstance(communicatorType, pipeClient);
runMethodInfo.Invoke(entryPointInstance, new object[] { communicatorInstance });
}
return 0;
}
public void ThreadStartClient(object obj)
{
// Ensure that we only start the client after the server has created the pipe
ManualResetEvent SyncClientServer = (ManualResetEvent)obj;
// Only continue after the server was created -- otherwise we just fail badly
// SyncClientServer.WaitOne();
using (NamedPipeClientStream pipeStream = new NamedPipeClientStream(pipeName))
{
// The connect function will indefinately wait for the pipe to become available
// If that is not acceptable specify a maximum waiting time (in ms)
pipeStream.Connect(5000);
//Console.WriteLine("[Client] Pipe connection established");
using (StreamWriter sw = new StreamWriter(pipeStream))
{
////sw.AutoFlush = true;
if (Environment.GetCommandLineArgs().Length >= 2)
{
string fname = Environment.GetCommandLineArgs()[1];
sw.WriteLine(fname);
sw.Flush();
}
}
}
}
/// <summary>
/// After registering at least ApplicationStarts, call this method to ensure this instance is the single instance.
/// If this instance is the first (single) instance, the ApplicationStarts event will be triggered.
/// If this instance is not the first (single) instance, the application will be terminated immediately.
/// </summary>
public void RunSingleInstance()
{
// get information from the mutex if we're the first/single instance.
bool owned = false;
mutex = new Mutex(false, "Global\\{" + id.ToString() + "}", out owned);
if (owned) // we "own" the mutex, meaning we're the first instance
{
// inform the application to begin startup
if (ApplicationStarts != null)
{
ApplicationStarts(this, new EventArgs());
}
// prepare a named pipe to receive data from subsequent start attempts
ListenNamedPipe();
}
else // In this case, we're a subsequent instance.
{
// Connect to the named pipe, if able, to signal the original instance that subsequent startup has been attempted
// This could be extended to send actual data to the original instance
try
{
var np = new System.IO.Pipes.NamedPipeClientStream(".", id.ToString(), PipeDirection.Out);
np.Connect(0);
np.Dispose();
}
catch { }
// Regardless, shut down immediately
Application.Current.Shutdown();
}
}
// .ctor with existing handle
public UnixNamedPipeClient(NamedPipeClientStream owner, SafePipeHandle safePipeHandle)
{
this.owner = owner;
this.handle = safePipeHandle;
// FIXME: dunno how is_async could be filled.
}
