/// <summary>
/// Create global events necessary for handshaking with the parent
/// </summary>
/// <param name="nodeNumber"></param>
/// <returns>True if events created successfully and false otherwise</returns>
private static bool CreateGlobalEvents(int nodeNumber)
{
bool createdNew;
if (NativeMethods.IsUserAdministrator())
{
EventWaitHandleSecurity mSec = new EventWaitHandleSecurity();
// Add a rule that grants the access only to admins and systems
mSec.SetSecurityDescriptorSddlForm(NativeMethods.ADMINONLYSDDL);
// Create an initiation event to allow the parent side to prove to the child that we have the same level of privilege as it does.
// this is done by having the parent set this event which means it needs to have administrative permissions to do so.
globalInitiateActivationEvent = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeInitiateActivationEventName(nodeNumber), out createdNew, mSec);
}
else
{
// Create an initiation event to allow the parent side to prove to the child that we have the same level of privilege as it does.
// this is done by having the parent set this event which means it has atleast the same permissions as the child process
globalInitiateActivationEvent = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeInitiateActivationEventName(nodeNumber), out createdNew);
}
// This process must be the creator of the event to prevent squating by a lower privilaged attacker
if (!createdNew)
{
return(false);
}
// Informs the parent process that the child process has been created.
globalNodeActive = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeActiveEventName(nodeNumber));
globalNodeActive.Set();
// Indicate to the parent process, this node is currently is ready to start to recieve requests
globalNodeInUse = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeInUseEventName(nodeNumber));
// Used by the parent process to inform the child process to shutdown due to the child process
// not recieving the initialization command.
globalNodeErrorShutdown = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeErrorShutdownEventName(nodeNumber));
// Inform the parent process the node has started its communication threads.
globalNodeActivate = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeActivedEventName(nodeNumber));
return(true);
}
/// <summary>
/// This function establishes communication with a node given an index. If a node
/// is not running it is launched.
/// </summary>
private void InitializeNode(int nodeIndex)
{
bool nodeConnected = false;
int restartCount = 0;
try
{
IncreaseActiveNodeCount();
while (!nodeConnected && restartCount < maximumNodeRestartCount)
{
if (!checkIfNodeActive(nodeData[nodeIndex].NodeNumber))
{
// Attempt to launch a new node process
LaunchNode(nodeIndex);
// If we could not launch the node there is no reason to continue
if (nodeData[nodeIndex].CommunicationFailed)
{
break;
}
}
if (checkIfNodeActive(nodeData[nodeIndex].NodeNumber))
{
nodeData[nodeIndex].SharedMemoryToNode.Reset();
nodeData[nodeIndex].SharedMemoryFromNode.Reset();
// Activate the initiation event to prove to the child that we have the same level of privilege as it does. This operation will not fail because each privilege level creates
// events in different namespaces
EventWaitHandle nodeInitiateActivationEvent = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeInitiateActivationEventName(nodeData[nodeIndex].NodeNumber));
nodeInitiateActivationEvent.Set();
nodeInitiateActivationEvent.Close();
// Wait for node to indicate that it is activated
EventWaitHandle nodeActivatedEvent = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeActivedEventName(nodeData[nodeIndex].NodeNumber));
nodeActivatedEvent.WaitOne(initializationTimeout, false);
nodeActivatedEvent.Close();
// Looked in Environment.cs the IDictionary is a HashTable
IDictionary variableDictionary = Environment.GetEnvironmentVariables();
Hashtable environmentVariablesTable = new Hashtable(variableDictionary);
LocalCallDescriptorForInitializeNode callDescriptorInit =
new LocalCallDescriptorForInitializeNode(environmentVariablesTable, nodeLoggers.ToArray(), nodeData[nodeIndex].NodeId, parentGlobalProperties, toolsetSearchLocations, Process.GetCurrentProcess().Id, startupDirectory);
nodeData[nodeIndex].NodeCommandQueue.Enqueue(callDescriptorInit);
EventWaitHandle nodeInUseEvent = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeInUseEventName(nodeData[nodeIndex].NodeNumber));
// Wait for node to indicate that it is ready. The node may time out and exit, between
// when we check that it is active and before the initialization messages reaches it.
// In that rare case we have to restart the node.
if (nodeInUseEvent.WaitOne(initializationTimeout, false))
{
UpdateSettings(nodeIndex);
nodeConnected = true;
}
nodeInUseEvent.Close();
// If the node is still active and has not replied to the initialization message it must
// be in bad state - try to get that node to exit
if (!nodeConnected && checkIfNodeActive(nodeData[nodeIndex].NodeNumber))
{
EventWaitHandle nodeShutdownEvent = new EventWaitHandle(false, EventResetMode.ManualReset, LocalNodeProviderGlobalNames.NodeErrorShutdownEventName(nodeData[nodeIndex].NodeNumber));
nodeShutdownEvent.Set();
nodeShutdownEvent.Close();
restartCount = maximumNodeRestartCount;
}
restartCount++;
}
}
}
finally
{
// Make sure to decrement the active node count if the communication has failed
if (nodeConnected != true)
{
DecreaseActiveNodeCount(nodeData[nodeIndex].NodeId);
nodeData[nodeIndex].CommunicationFailed = true;
}
}
}