internal override void SendStopSignal() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignal, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), "stopsignal" }); base.CloseAsync(); this.stdInWriter.WriteLine(OutOfProcessUtils.CreateSignalPacket(base.powershellInstanceId)); this.signalTimeOutTimer.Start(); }
private void SendData(byte[] data, DataPriorityType priorityType) { BaseClientTransportManager.tracer.WriteLine("Command sending data of size : {0}", new object[] { data.Length }); byte[] buffer = data; bool flag = true; if (commandSendRedirect != null) { object[] objArray3 = new object[2]; objArray3[1] = buffer; object[] args = objArray3; flag = (bool)commandSendRedirect.DynamicInvoke(args); buffer = (byte[])args[0]; } if (flag) { using (WSManNativeApi.WSManData data2 = new WSManNativeApi.WSManData(buffer)) { PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputEx, PSOpcode.Send, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), data2.BufferLength.ToString(CultureInfo.InvariantCulture) }); lock (base.syncObject) { if (base.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Session TM: Transport manager is closed. So returning", new object[0]); } else { this.sendToRemoteCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdSendCallback); WSManNativeApi.WSManSendShellInputEx(this.wsManShellOperationHandle, this.wsManCmdOperationHandle, 0, (priorityType == DataPriorityType.Default) ? "stdin" : "pr", data2, (IntPtr)this.sendToRemoteCompleted, ref this.wsManSendOperationHandle); } } } } }
internal override void CloseAsync() { bool flag = false; lock (base.syncObject) { if (base.isClosed) { return; } base.isClosed = true; if (this.stdInWriter == null) { flag = true; } } base.CloseAsync(); if (!flag) { PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseShell, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString() }); this._tracer.WriteMessage(string.Concat(new object[] { "OutOfProcessClientSessionTransportManager.CloseAsync, when sending close session packet, progress command count should be zero, current cmd count: ", this.cmdTransportManagers.Count, ", RunSpacePool Id : ", base.RunspacePoolInstanceId })); this.stdInWriter.WriteLine(OutOfProcessUtils.CreateClosePacket(Guid.Empty)); this.closeTimeOutTimer.Start(); } else { base.RaiseCloseCompleted(); } }
internal void OnRemoteCmdSignalCompleted() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignalCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); this.StopSignalTimerAndDecrementOperations(); if (!base.isClosed) { base.EnqueueAndStartProcessingThread(null, null, true); } }
private static void OnRemoteCmdDataReceived(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data) { BaseClientTransportManager.tracer.WriteLine("Remote Command DataReceived callback.", new object[0]); long cmdTMId = 0L; WSManClientCommandTransportManager cmdTransportManager = null; if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId)) { BaseClientTransportManager.tracer.WriteLine("Unable to find a transport manager for the given command context {0}.", new object[] { cmdTMId }); } else if (!shellOperationHandle.Equals(cmdTransportManager.wsManShellOperationHandle) || !commandOperationHandle.Equals(cmdTransportManager.wsManCmdOperationHandle)) { BaseClientTransportManager.tracer.WriteLine("CmdReceive callback: ShellOperationHandles are not the same as the Receive is initiated with", new object[0]); PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.CommandReceiveExFailed); TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.ReceiveCommandOutputEx); cmdTransportManager.ProcessWSManTransportError(eventArgs); } else { cmdTransportManager.ClearReceiveOrSendResources(flags, false); if (cmdTransportManager.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]); } else { if (IntPtr.Zero != error) { WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error); if (errorStruct.errorCode != 0) { BaseClientTransportManager.tracer.WriteLine("CmdReceive callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail }); TransportErrorOccuredEventArgs args2 = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.ReceiveCommandOutputEx, RemotingErrorIdStrings.CommandReceiveExCallBackError, new object[] { errorStruct.errorDetail }); cmdTransportManager.ProcessWSManTransportError(args2); return; } } if (flags == 0x2000) { cmdTransportManager.isDisconnectedOnInvoke = true; cmdTransportManager.RaiseDelayStreamProcessedEvent(); } else { WSManNativeApi.WSManReceiveDataResult result = WSManNativeApi.WSManReceiveDataResult.UnMarshal(data); if (result.data != null) { BaseClientTransportManager.tracer.WriteLine("Cmd Received Data : {0}", new object[] { result.data.Length }); object[] args = new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString(), result.data.Length.ToString(CultureInfo.InvariantCulture) }; PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputExCallbackReceived, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args); cmdTransportManager.ProcessRawData(result.data, result.stream); } } } } }
private static void OnRemoteCmdSignalCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data) { BaseClientTransportManager.tracer.WriteLine("Signal Completed callback received.", new object[0]); long cmdTMId = 0L; WSManClientCommandTransportManager cmdTransportManager = null; if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId)) { BaseClientTransportManager.tracer.WriteLine("Unable to find a transport manager for the given command context {0}.", new object[] { cmdTMId }); } else { PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignalCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString() }); if (!shellOperationHandle.Equals(cmdTransportManager.wsManShellOperationHandle) || !commandOperationHandle.Equals(cmdTransportManager.wsManCmdOperationHandle)) { BaseClientTransportManager.tracer.WriteLine("Cmd Signal callback: ShellOperationHandles are not the same as the signal is initiated with", new object[0]); PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.CommandSendExFailed); TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.CommandInputEx); cmdTransportManager.ProcessWSManTransportError(eventArgs); } else { if (IntPtr.Zero != cmdTransportManager.cmdSignalOperationHandle) { WSManNativeApi.WSManCloseOperation(cmdTransportManager.cmdSignalOperationHandle, 0); cmdTransportManager.cmdSignalOperationHandle = IntPtr.Zero; } if (cmdTransportManager.signalCmdCompleted != null) { cmdTransportManager.signalCmdCompleted.Dispose(); cmdTransportManager.signalCmdCompleted = null; } if (cmdTransportManager.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]); } else { if (IntPtr.Zero != error) { WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error); if (errorStruct.errorCode != 0) { BaseClientTransportManager.tracer.WriteLine("Cmd Signal callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail }); TransportErrorOccuredEventArgs args2 = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.CommandInputEx, RemotingErrorIdStrings.CommandSendExCallBackError, new object[] { WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(errorStruct.errorDetail) }); cmdTransportManager.ProcessWSManTransportError(args2); return; } } cmdTransportManager.EnqueueAndStartProcessingThread(null, null, true); } } } }
private void SendData(byte[] data, DataPriorityType priorityType) { object[] args = new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), data.Length.ToString(CultureInfo.InvariantCulture) }; PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputEx, PSOpcode.Send, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args); lock (base.syncObject) { if (!base.isClosed) { this.stdInWriter.WriteLine(OutOfProcessUtils.CreateDataPacket(data, priorityType, base.powershellInstanceId)); } } }
internal void OnRemoteCmdSendCompleted() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputExCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); lock (base.syncObject) { if (base.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]); return; } } this.SendOneItem(); }
internal void OnRemoteCmdDataReceived(byte[] rawData, string stream) { object[] args = new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), rawData.Length.ToString(CultureInfo.InvariantCulture) }; PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputExCallbackReceived, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args); if (base.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Command TM: Transport manager is closed. So returning", new object[0]); } else { this.ProcessRawData(rawData, stream); } }
internal override void CreateAsync() { byte[] firstArgument = base.serializedPipeline.ReadOrRegisterCallback(null); if (firstArgument == null) { firstArgument = new byte[0]; } bool flag = true; if (commandCodeSendRedirect != null) { object[] objArray2 = new object[2]; objArray2[1] = firstArgument; object[] objArray = objArray2; flag = (bool)commandCodeSendRedirect.DynamicInvoke(objArray); firstArgument = (byte[])objArray[0]; } if (!flag) { return; } WSManNativeApi.WSManCommandArgSet set = new WSManNativeApi.WSManCommandArgSet(firstArgument); this.cmdContextId = GetNextCmdTMHandleId(); AddCmdTransportManager(this.cmdContextId, this); PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateCommand, PSOpcode.Connect, PSTask.CreateRunspace, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); this.createCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdCreateCallback); this.createCmdCompletedGCHandle = GCHandle.Alloc(this.createCmdCompleted); this.reconnectCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdReconnectCallback); using (set) { lock (base.syncObject) { if (!base.isClosed) { WSManNativeApi.WSManRunShellCommandEx(this.wsManShellOperationHandle, 0, base.PowershellInstanceId.ToString().ToUpper(CultureInfo.InvariantCulture), ((this.cmdLine == null) || (this.cmdLine.Length == 0)) ? " " : ((this.cmdLine.Length <= 0x100) ? this.cmdLine : this.cmdLine.Substring(0, 0xff)), (IntPtr)set, IntPtr.Zero, (IntPtr)this.createCmdCompleted, ref this.wsManCmdOperationHandle); BaseClientTransportManager.tracer.WriteLine("Started cmd with command context : {0} Operation context: {1}", new object[] { this.cmdContextId, this.wsManCmdOperationHandle }); } } } if (this.wsManCmdOperationHandle == IntPtr.Zero) { PSRemotingTransportException e = new PSRemotingTransportException(RemotingErrorIdStrings.RunShellCommandExFailed); TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.RunShellCommandEx); this.ProcessWSManTransportError(eventArgs); } }
internal override void CloseAsync() { lock (base.syncObject) { if (base.isClosed) { return; } base.isClosed = true; } base.CloseAsync(); PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommand, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); if (this.stdInWriter != null) { this.stdInWriter.WriteLine(OutOfProcessUtils.CreateClosePacket(base.powershellInstanceId)); } }
internal void OnDataAvailableCallback(RemoteDataObject <PSObject> remoteObject) { PSEtwLog.LogAnalyticInformational(PSEventId.TransportReceivedObject, PSOpcode.Open, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { remoteObject.RunspacePoolId.ToString(), remoteObject.PowerShellId.ToString(), (int)remoteObject.Destination, (int)remoteObject.DataType, (int)remoteObject.TargetInterface }); this.PowerShellGuidObserver.SafeInvoke(remoteObject.PowerShellId, EventArgs.Empty); RemoteDataEventArgs eventArgs = new RemoteDataEventArgs(remoteObject); if (remoteObject.DataType == RemotingDataType.RunspacePoolStateInfo) { System.Diagnostics.Debug.WriteLine("RunspacePool State Opened Received"); Thread.Sleep(800); //HACK: Delay reception in local mode... TODO: Find why!!! cannot have a Wait somewhere _slowed = true; } this.DataReceived.SafeInvoke <RemoteDataEventArgs>(this, eventArgs); }
internal override void SendStopSignal() { lock (base.syncObject) { if (!base.isClosed) { if (!this.isCreateCallbackReceived) { this.isStopSignalPending = true; } else { this.isStopSignalPending = false; BaseClientTransportManager.tracer.WriteLine("Sending stop signal with command context: {0} Operation Context {1}", new object[] { this.cmdContextId, this.wsManCmdOperationHandle }); PSEtwLog.LogAnalyticInformational(PSEventId.WSManSignal, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString(), StopSignal }); this.signalCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdSignalCallback); WSManNativeApi.WSManSignalShellEx(this.wsManShellOperationHandle, this.wsManCmdOperationHandle, 0, StopSignal, (IntPtr)this.signalCmdCompleted, ref this.cmdSignalOperationHandle); } } } }
private static void OnCloseCmdCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data) { BaseClientTransportManager.tracer.WriteLine("OnCloseCmdCompleted callback received for operation context {0}", new object[] { commandOperationHandle }); long cmdTMId = 0L; WSManClientCommandTransportManager cmdTransportManager = null; if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId)) { BaseClientTransportManager.tracer.WriteLine("OnCloseCmdCompleted: Unable to find a transport manager for the command context {0}.", new object[] { cmdTMId }); } else { BaseClientTransportManager.tracer.WriteLine(string.Format(CultureInfo.InvariantCulture, "Close completed callback received for command: {0}", new object[] { cmdTransportManager.cmdContextId }), new object[0]); PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommandCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString() }); if (cmdTransportManager.isDisconnectPending) { cmdTransportManager.RaiseReadyForDisconnect(); } cmdTransportManager.RaiseCloseCompleted(); } }
internal override void StartReceivingData() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputEx, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); this.shouldStartReceivingData = false; lock (base.syncObject) { if (base.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Session TM: Transport manager is closed. So returning", new object[0]); } else if (base.receiveDataInitiated) { BaseClientTransportManager.tracer.WriteLine("Client Session TM: Command ReceiveData has already been called.", new object[0]); } else { base.receiveDataInitiated = true; this.receivedFromRemote = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdReceiveCallback); WSManNativeApi.WSManReceiveShellOutputEx(this.wsManShellOperationHandle, this.wsManCmdOperationHandle, base.startInDisconnectedMode ? 0x10 : 0, (IntPtr)WSManClientSessionTransportManager.wsManApiStaticData.OutputStreamSet, (IntPtr)this.receivedFromRemote, ref this.wsManRecieveOperationHandle); } } }
private void OnDataPacketReceived(byte[] rawData, string stream, Guid psGuid) { string str = "stdout"; if (stream.Equals(DataPriorityType.PromptResponse.ToString(), StringComparison.OrdinalIgnoreCase)) { str = "pr"; } if (psGuid == Guid.Empty) { object[] args = new object[] { base.RunspacePoolInstanceId.ToString(), Guid.Empty.ToString(), rawData.Length.ToString(CultureInfo.InvariantCulture) }; PSEtwLog.LogAnalyticInformational(PSEventId.WSManReceiveShellOutputExCallbackReceived, PSOpcode.Receive, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args); base.ProcessRawData(rawData, str); } else { OutOfProcessClientCommandTransportManager commandTransportManager = this.GetCommandTransportManager(psGuid); if (commandTransportManager != null) { commandTransportManager.OnRemoteCmdDataReceived(rawData, str); } } }
internal override void CloseAsync() { BaseClientTransportManager.tracer.WriteLine("Closing command with command context: {0} Operation Context {1}", new object[] { this.cmdContextId, this.wsManCmdOperationHandle }); bool flag = false; lock (base.syncObject) { if (base.isClosed) { return; } base.isClosed = true; if (IntPtr.Zero == this.wsManCmdOperationHandle) { flag = true; } } base.CloseAsync(); if (!flag) { PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommand, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); this.closeCmdCompleted = new WSManNativeApi.WSManShellAsync(new IntPtr(this.cmdContextId), cmdCloseCallback); WSManNativeApi.WSManCloseCommand(this.wsManCmdOperationHandle, 0, (IntPtr)this.closeCmdCompleted); } else { try { base.RaiseCloseCompleted(); } finally { RemoveCmdTransportManager(this.cmdContextId); } } }
internal override void CreateAsync() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateCommand, PSOpcode.Connect, PSTask.CreateRunspace, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); this.stdInWriter.WriteLine(OutOfProcessUtils.CreateCommandPacket(base.powershellInstanceId)); }
private static void OnCreateCmdCompleted(IntPtr operationContext, int flags, IntPtr error, IntPtr shellOperationHandle, IntPtr commandOperationHandle, IntPtr operationHandle, IntPtr data) { BaseClientTransportManager.tracer.WriteLine("OnCreateCmdCompleted callback received", new object[0]); long cmdTMId = 0L; WSManClientCommandTransportManager cmdTransportManager = null; if (!TryGetCmdTransportManager(operationContext, out cmdTransportManager, out cmdTMId)) { BaseClientTransportManager.tracer.WriteLine("OnCreateCmdCompleted: Unable to find a transport manager for the command context {0}.", new object[] { cmdTMId }); } else { PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateCommandCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { cmdTransportManager.RunspacePoolInstanceId.ToString(), cmdTransportManager.powershellInstanceId.ToString() }); if (cmdTransportManager.createCmdCompleted != null) { cmdTransportManager.createCmdCompletedGCHandle.Free(); cmdTransportManager.createCmdCompleted.Dispose(); cmdTransportManager.createCmdCompleted = null; } cmdTransportManager.wsManCmdOperationHandle = commandOperationHandle; if (IntPtr.Zero != error) { WSManNativeApi.WSManError errorStruct = WSManNativeApi.WSManError.UnMarshal(error); if (errorStruct.errorCode != 0) { BaseClientTransportManager.tracer.WriteLine("OnCreateCmdCompleted callback: WSMan reported an error: {0}", new object[] { errorStruct.errorDetail }); TransportErrorOccuredEventArgs eventArgs = WSManTransportManagerUtils.ConstructTransportErrorEventArgs(WSManClientSessionTransportManager.wsManApiStaticData.WSManAPIHandle, null, errorStruct, TransportMethodEnum.RunShellCommandEx, RemotingErrorIdStrings.RunShellCommandExCallBackError, new object[] { WSManTransportManagerUtils.ParseEscapeWSManErrorMessage(errorStruct.errorDetail) }); cmdTransportManager.ProcessWSManTransportError(eventArgs); return; } } lock (cmdTransportManager.syncObject) { cmdTransportManager.isCreateCallbackReceived = true; if (cmdTransportManager.isClosed) { BaseClientTransportManager.tracer.WriteLine("Client Session TM: Transport manager is closed. So returning", new object[0]); if (cmdTransportManager.isDisconnectPending) { cmdTransportManager.RaiseReadyForDisconnect(); } } else if (cmdTransportManager.isDisconnectPending) { cmdTransportManager.RaiseReadyForDisconnect(); } else { if (cmdTransportManager.serializedPipeline.Length == 0L) { cmdTransportManager.shouldStartReceivingData = true; } cmdTransportManager.SendOneItem(); if (cmdTransportManager.isStopSignalPending) { cmdTransportManager.SendStopSignal(); } } } } }
private void OnRemoteSessionSendCompleted() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManSendShellInputExCallbackReceived, PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), Guid.Empty.ToString() }); this.SendOneItem(); }
internal void OnCloseCmdCompleted() { PSEtwLog.LogAnalyticInformational(PSEventId.WSManCloseCommandCallbackReceived, PSOpcode.Disconnect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString(), this.powershellInstanceId.ToString() }); base.RaiseCloseCompleted(); }
internal override void CreateAsync() { if (this.connectionInfo != null) { this._processInstance = this.connectionInfo.Process ?? new PowerShellProcessInstance(this.connectionInfo.PSVersion, this.connectionInfo.Credential, this.connectionInfo.InitializationScript, this.connectionInfo.RunAs32); if (this.connectionInfo.Process != null) { this._processCreated = false; } } PSEtwLog.LogAnalyticInformational(PSEventId.WSManCreateShell, PSOpcode.Connect, PSTask.CreateRunspace, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, new object[] { base.RunspacePoolInstanceId.ToString() }); try { lock (base.syncObject) { if (base.isClosed) { return; } this.serverProcess = this._processInstance.Process; if (this._processInstance.RunspacePool != null) { this._processInstance.RunspacePool.Close(); this._processInstance.RunspacePool.Dispose(); } this.stdInWriter = this._processInstance.StdInWriter; this.serverProcess.OutputDataReceived += new DataReceivedEventHandler(this.OnOutputDataReceived); this.serverProcess.ErrorDataReceived += new DataReceivedEventHandler(this.OnErrorDataReceived); this.serverProcess.Exited += new EventHandler(this.OnExited); this._processInstance.Start(); if (this.stdInWriter != null) { this.serverProcess.CancelErrorRead(); this.serverProcess.CancelOutputRead(); } this.serverProcess.BeginOutputReadLine(); this.serverProcess.BeginErrorReadLine(); this.stdInWriter = new OutOfProcessTextWriter(this.serverProcess.StandardInput); this._processInstance.StdInWriter = this.stdInWriter; } } catch (Win32Exception exception) { PSRemotingTransportException e = new PSRemotingTransportException(exception, RemotingErrorIdStrings.IPCExceptionLaunchingProcess, new object[] { exception.Message }) { ErrorCode = exception.ErrorCode }; TransportErrorOccuredEventArgs eventArgs = new TransportErrorOccuredEventArgs(e, TransportMethodEnum.CreateShellEx); this.RaiseErrorHandler(eventArgs); return; } catch (Exception exception3) { CommandProcessorBase.CheckForSevereException(exception3); PSRemotingTransportException exception4 = new PSRemotingTransportException(PSRemotingErrorId.IPCExceptionLaunchingProcess, RemotingErrorIdStrings.IPCExceptionLaunchingProcess, new object[] { exception3.Message }); TransportErrorOccuredEventArgs args2 = new TransportErrorOccuredEventArgs(exception4, TransportMethodEnum.CreateShellEx); this.RaiseErrorHandler(args2); return; } this.SendOneItem(); }
/// <summary> /// Report session context to WSMan..this will let WSMan send ACK to /// client and client can send data. /// </summary> internal void ReportContext() { int result = 0; bool isRegisterWaitForSingleObjectFailed = false; lock (_syncObject) { if (true == isClosed) { return; } if (!isContextReported) { isContextReported = true; PSEtwLog.LogAnalyticInformational(PSEventId.ReportContext, PSOpcode.Connect, PSTask.None, PSKeyword.ManagedPlugin | PSKeyword.UseAlwaysAnalytic, creationRequestDetails.ToString(), creationRequestDetails.ToString()); //RACE TO BE FIXED - As soon as this API is called, WinRM service will send CommandResponse back and Signal is expected anytime // If Signal comes and executes before registering the notification handle, cleanup will be messed result = WSManNativeApi.WSManPluginReportContext(creationRequestDetails.unmanagedHandle, 0, creationRequestDetails.unmanagedHandle); if (Platform.IsWindows && (WSManPluginConstants.ExitCodeSuccess == result)) { registeredShutdownNotification = 1; // Wrap the provided handle so it can be passed to the registration function SafeWaitHandle safeWaitHandle = new SafeWaitHandle(creationRequestDetails.shutdownNotificationHandle, false); // Owned by WinRM EventWaitHandle eventWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset); ClrFacade.SetSafeWaitHandle(eventWaitHandle, safeWaitHandle); // Register shutdown notification handle this.registeredShutDownWaitHandle = ThreadPool.RegisterWaitForSingleObject( eventWaitHandle, new WaitOrTimerCallback(WSManPluginManagedEntryWrapper.PSPluginOperationShutdownCallback), shutDownContext, -1, // INFINITE true); // TODO: Do I need to worry not being able to set missing WT_TRANSFER_IMPERSONATION? if (null == this.registeredShutDownWaitHandle) { isRegisterWaitForSingleObjectFailed = true; registeredShutdownNotification = 0; } } } } if ((WSManPluginConstants.ExitCodeSuccess != result) || (isRegisterWaitForSingleObjectFailed)) { string errorMessage; if (isRegisterWaitForSingleObjectFailed) { errorMessage = StringUtil.Format(RemotingErrorIdStrings.WSManPluginShutdownRegistrationFailed); } else { errorMessage = StringUtil.Format(RemotingErrorIdStrings.WSManPluginReportContextFailed); } // Report error and close the session Exception mgdException = new InvalidOperationException(errorMessage); Close(mgdException); } }
private void OnDataAvailable(byte[] dataToSend, bool isEndFragment) { object[] args = new object[] { this.runpacePoolInstanceId.ToString(), this.powerShellInstanceId.ToString(), dataToSend.Length.ToString(CultureInfo.InvariantCulture), (int)this.dataType, (int)this.targetInterface }; PSEtwLog.LogAnalyticInformational(PSEventId.ServerSendData, PSOpcode.Send, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic, args); this.SendDataToClient(dataToSend, isEndFragment & this.shouldFlushData, this.reportAsPending, isEndFragment); }