internal unsafe IAsyncResult BeginRead(byte[] data, int offset, int size, AsyncCallback callback, object state)
{
bool flag;
PipeAsyncResult ar = new PipeAsyncResult(callback);
NativeOverlapped *lpOverlapped = new Overlapped(0, 0, IntPtr.Zero, ar).UnsafePack(IOCallback, data);
ar._overlapped = lpOverlapped;
fixed(byte *numRef = data)
{
flag = NativePipe.ReadFile(this._handle, numRef + offset, size, IntPtr.Zero, lpOverlapped);
}
if (!flag)
{
int errorCode = Marshal.GetLastWin32Error();
if (errorCode == 0x6dL)
{
ar.CallUserCallback();
return(ar);
}
if (errorCode != 0x3e5L)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ReadFailure"), new object[] { GetMessage(errorCode) }));
}
}
return(ar);
}
internal static IpcPort Create(string portName, CommonSecurityDescriptor securityDescriptor, bool exclusive)
{
SECURITY_ATTRIBUTES security_attributes;
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
throw new NotSupportedException(CoreChannel.GetResourceString("Remoting_Ipc_Win9x"));
}
PipeHandle handle = null;
string lpName = @"\\.\pipe\" + portName;
security_attributes = new SECURITY_ATTRIBUTES {
nLength = Marshal.SizeOf(security_attributes)
};
byte[] binaryForm = null;
if (securityDescriptor == null)
{
securityDescriptor = s_securityDescriptor;
}
binaryForm = new byte[securityDescriptor.BinaryLength];
securityDescriptor.GetBinaryForm(binaryForm, 0);
GCHandle handle2 = GCHandle.Alloc(binaryForm, GCHandleType.Pinned);
security_attributes.lpSecurityDescriptor = Marshal.UnsafeAddrOfPinnedArrayElement(binaryForm, 0);
handle = NativePipe.CreateNamedPipe(lpName, (uint)(0x40000003 | (exclusive ? 0x80000 : 0)), 0, 0xff, 0x2000, 0x2000, uint.MaxValue, security_attributes);
handle2.Free();
if (handle.Handle.ToInt32() == -1)
{
int errorCode = Marshal.GetLastWin32Error();
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_CreateIpcFailed"), new object[] { GetMessage(errorCode) }));
}
return(new IpcPort(portName, handle));
}
public bool WaitForConnect()
{
// Wait for clients to connect
bool status = NativePipe.ConnectNamedPipe(_handle, null);
return(status ? true : (Marshal.GetLastWin32Error() == NativePipe.ERROR_PIPE_CONNECTED));
}
internal static IpcPort Connect(String portName, bool secure, TokenImpersonationLevel impersonationLevel, int timeout)
{
string pipeName = prefix + portName;
uint impersonation = NativePipe.SECURITY_SQOS_PRESENT;
// convert the impersonation Level to the correct flag
if (secure)
{
switch (impersonationLevel)
{
case TokenImpersonationLevel.None:
impersonation = NativePipe.SECURITY_SQOS_PRESENT;
break;
case TokenImpersonationLevel.Identification:
impersonation = NativePipe.SECURITY_SQOS_PRESENT | NativePipe.SECURITY_IDENTIFICATION;
break;
case TokenImpersonationLevel.Impersonation:
impersonation = NativePipe.SECURITY_SQOS_PRESENT | NativePipe.SECURITY_IMPERSONATION;
break;
case TokenImpersonationLevel.Delegation:
impersonation = NativePipe.SECURITY_SQOS_PRESENT | NativePipe.SECURITY_DELEGATION;
break;
}
}
while (true)
{
// Invoke CreateFile with the pipeName to open a client side connection
PipeHandle handle = NativePipe.CreateFile(pipeName,
NativePipe.GENERIC_READ | NativePipe.GENERIC_WRITE,
NativePipe.FILE_SHARE_READ |
NativePipe.FILE_SHARE_WRITE,
IntPtr.Zero,
NativePipe.OPEN_EXISTING,
NativePipe.FILE_ATTRIBUTE_NORMAL |
NativePipe.FILE_FLAG_OVERLAPPED |
impersonation,
IntPtr.Zero);
if (handle.Handle.ToInt32() != NativePipe.INVALID_HANDLE_VALUE)
{
return(new IpcPort(portName, handle));
}
int error = Marshal.GetLastWin32Error();
if (error != NativePipe.ERROR_PIPE_BUSY)
{
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ConnectIpcFailed"), GetMessage(error)));
}
if (!NativePipe.WaitNamedPipe(pipeName, timeout))
{
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_Busy"), GetMessage(error)));
}
}
}
internal void ImpersonateClient()
{
if (!NativePipe.ImpersonateNamedPipeClient(this._handle))
{
int errorCode = Marshal.GetLastWin32Error();
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ImpersonationFailed"), new object[] { GetMessage(errorCode) }));
}
}
public bool WaitForConnect()
{
if (!NativePipe.ConnectNamedPipe(this._handle, null))
{
return(Marshal.GetLastWin32Error() == 0x217L);
}
return(true);
}
internal void ImpersonateClient()
{
bool status = NativePipe.ImpersonateNamedPipeClient(_handle);
if (!status)
{
int error = Marshal.GetLastWin32Error();
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ImpersonationFailed"), GetMessage(error)));
}
}
internal static string GetMessage(int errorCode)
{
StringBuilder lpBuffer = new StringBuilder(0x200);
if (NativePipe.FormatMessage(0x3200, NativePipe.NULL, errorCode, 0, lpBuffer, lpBuffer.Capacity, NativePipe.NULL) != 0)
{
return(lpBuffer.ToString());
}
return(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_UnknownError_Num"), new object[] { errorCode.ToString(CultureInfo.InvariantCulture) }));
}
internal static IpcPort Create(String portName, CommonSecurityDescriptor securityDescriptor, bool exclusive)
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
throw new NotSupportedException(CoreChannel.GetResourceString("Remoting_Ipc_Win9x"));
}
PipeHandle handle = null;
// Add the prefix to the portName
string pipeName = prefix + portName;
SECURITY_ATTRIBUTES attr = new SECURITY_ATTRIBUTES();
attr.nLength = (int)Marshal.SizeOf(attr);
byte[] sd = null;
// If no securityDescriptor was set by the user use the default
if (securityDescriptor == null)
{
securityDescriptor = s_securityDescriptor;
}
sd = new byte[securityDescriptor.BinaryLength];
// Get the binary form of the descriptor
securityDescriptor.GetBinaryForm(sd, 0);
GCHandle pinningHandle = GCHandle.Alloc(sd, GCHandleType.Pinned);
// get the address of the security descriptor
attr.lpSecurityDescriptor = Marshal.UnsafeAddrOfPinnedArrayElement(sd, 0);
// Create the named pipe with the appropriate name
handle = NativePipe.CreateNamedPipe(pipeName,
NativePipe.PIPE_ACCESS_DUPLEX | NativePipe.FILE_FLAG_OVERLAPPED
| (exclusive ? NativePipe.FILE_FLAG_FIRST_PIPE_INSTANCE : 0x0), // Or exclusive flag
NativePipe.PIPE_TYPE_BYTE | NativePipe.PIPE_READMODE_BYTE | NativePipe.PIPE_WAIT,
NativePipe.PIPE_UNLIMITED_INSTANCES,
8192,
8192,
NativePipe.NMPWAIT_WAIT_FOREVER,
attr);
pinningHandle.Free();
if (handle.Handle.ToInt32() == NativePipe.INVALID_HANDLE_VALUE)
{
int error = Marshal.GetLastWin32Error();
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_CreateIpcFailed"), GetMessage(error)));
}
return(new IpcPort(portName, handle));
}
internal unsafe void Write(byte[] data, int offset, int size)
{
int lpNumberOfBytesWritten = 0;
bool flag = false;
fixed(byte *numRef = data)
{
flag = NativePipe.WriteFile(this._handle, numRef + offset, size, ref lpNumberOfBytesWritten, IntPtr.Zero);
}
if (!flag)
{
int errorCode = Marshal.GetLastWin32Error();
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_WriteFailure"), new object[] { GetMessage(errorCode) }));
}
}
internal unsafe int Read(byte[] data, int offset, int length)
{
bool flag = false;
int lpNumberOfBytesRead = 0;
fixed(byte *numRef = data)
{
flag = NativePipe.ReadFile(this._handle, numRef + offset, length, ref lpNumberOfBytesRead, IntPtr.Zero);
}
if (!flag)
{
int errorCode = Marshal.GetLastWin32Error();
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ReadFailure"), new object[] { GetMessage(errorCode) }));
}
return(lpNumberOfBytesRead);
}
internal unsafe void Write(byte[] data, int offset, int size)
{
int numBytesWritten = 0;
bool status = false;
// pin the buffer and write data
fixed(byte *p = data)
{
status = NativePipe.WriteFile(_handle, p + offset, size, ref numBytesWritten, IntPtr.Zero);
}
if (!status)
{
int error = Marshal.GetLastWin32Error();
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_WriteFailure"), GetMessage(error)));
}
}
internal static IpcPort Connect(string portName, bool secure, TokenImpersonationLevel impersonationLevel, int timeout)
{
string lpFileName = @"\\.\pipe\" + portName;
uint num = 0x100000;
if (secure)
{
switch (impersonationLevel)
{
case TokenImpersonationLevel.None:
num = 0x100000;
break;
case TokenImpersonationLevel.Identification:
num = 0x110000;
break;
case TokenImpersonationLevel.Impersonation:
num = 0x120000;
break;
case TokenImpersonationLevel.Delegation:
num = 0x130000;
break;
}
}
while (true)
{
PipeHandle handle = NativePipe.CreateFile(lpFileName, 0xc0000000, 3, IntPtr.Zero, 3, 0x40000080 | num, IntPtr.Zero);
if (handle.Handle.ToInt32() != -1)
{
return(new IpcPort(portName, handle));
}
int errorCode = Marshal.GetLastWin32Error();
if (errorCode != 0xe7L)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ConnectIpcFailed"), new object[] { GetMessage(errorCode) }));
}
if (!NativePipe.WaitNamedPipe(lpFileName, timeout))
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_Busy"), new object[] { GetMessage(errorCode) }));
}
}
}
// Gets an error message for a Win32 error code.
internal static String GetMessage(int errorCode)
{
StringBuilder sb = new StringBuilder(512);
int result = NativePipe.FormatMessage(NativePipe.FORMAT_MESSAGE_IGNORE_INSERTS |
NativePipe.FORMAT_MESSAGE_FROM_SYSTEM | NativePipe.FORMAT_MESSAGE_ARGUMENT_ARRAY,
NativePipe.NULL, errorCode, 0, sb, sb.Capacity, NativePipe.NULL);
if (result != 0)
{
// result is the # of characters copied to the StringBuilder on NT,
// but on Win9x, it appears to be the number of MBCS bytes.
// Just give up and return the String as-is...
String s = sb.ToString();
return(s);
}
else
{
return(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_UnknownError_Num"), errorCode.ToString(CultureInfo.InvariantCulture)));
}
}
internal unsafe int Read(byte[] data, int offset, int length)
{
bool status = false;
int numBytesRead = 0;
fixed(byte *p = data)
{
status = NativePipe.ReadFile(_handle, p + offset, length, ref numBytesRead, IntPtr.Zero);
}
if (!status)
{
int error = Marshal.GetLastWin32Error();
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ReadFailure"), GetMessage(error)));
}
else
{
return(numBytesRead);
}
}
internal unsafe IAsyncResult BeginRead(byte[] data, int offset, int size, AsyncCallback callback, object state)
{
PipeAsyncResult asyncResult = new PipeAsyncResult(callback);
// Create a managed overlapped class
// We will set the file offsets later
Overlapped overlapped = new Overlapped(0, 0, IntPtr.Zero, asyncResult);
// Pack the Overlapped class, and store it in the async result
NativeOverlapped *intOverlapped;
intOverlapped = overlapped.UnsafePack(IOCallback, data);
asyncResult._overlapped = intOverlapped;
bool status;
// pin the buffer and read data with overlapped
fixed(byte *p = data)
{
status = NativePipe.ReadFile(_handle, p + offset, size, IntPtr.Zero, intOverlapped);
}
if (!status)
{
int error = Marshal.GetLastWin32Error();
// For pipes, when they hit EOF, they will come here.
if (error == NativePipe.ERROR_BROKEN_PIPE)
{
// Not an error, but EOF. AsyncFSCallback will NOT be
// called. Call the user callback here.
asyncResult.CallUserCallback();
// EndRead will free the Overlapped struct correctly.
}
else if (error != NativePipe.ERROR_IO_PENDING)
{
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Ipc_ReadFailure"), GetMessage(error)));
}
}
return(asyncResult);
}
internal void ServiceRequest(object state)
{
IpcServerHandler handler = (IpcServerHandler)state;
ITransportHeaders requestHeaders = handler.ReadHeaders();
Stream requestStream = handler.GetRequestStream();
requestHeaders["__CustomErrorsEnabled"] = false;
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, handler);
IMessage responseMsg = null;
ITransportHeaders responseHeaders = null;
Stream responseStream = null;
WindowsIdentity current = null;
IPrincipal currentPrincipal = null;
bool flag = false;
bool flag2 = false;
ServerProcessing complete = ServerProcessing.Complete;
try
{
if (this._secure)
{
handler.Port.ImpersonateClient();
currentPrincipal = Thread.CurrentPrincipal;
flag2 = true;
flag = true;
current = WindowsIdentity.GetCurrent();
if (!this._impersonate)
{
NativePipe.RevertToSelf();
Thread.CurrentPrincipal = new GenericPrincipal(current, null);
flag = false;
}
else
{
if ((current.ImpersonationLevel != TokenImpersonationLevel.Impersonation) && (current.ImpersonationLevel != TokenImpersonationLevel.Delegation))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Ipc_TokenImpersonationFailure"));
}
Thread.CurrentPrincipal = new WindowsPrincipal(current);
}
}
complete = this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream);
}
catch (Exception exception)
{
handler.CloseOnFatalError(exception);
}
finally
{
if (flag2)
{
Thread.CurrentPrincipal = currentPrincipal;
}
if (flag)
{
NativePipe.RevertToSelf();
flag = false;
}
}
switch (complete)
{
case ServerProcessing.Complete:
sinkStack.Pop(this);
handler.SendResponse(responseHeaders, responseStream);
break;
case ServerProcessing.OneWay:
handler.SendResponse(responseHeaders, responseStream);
break;
case ServerProcessing.Async:
sinkStack.StoreAndDispatch(this, handler);
break;
}
if (complete != ServerProcessing.Async)
{
handler.BeginReadMessage();
}
}
internal void ServiceRequest(Object state)
{
IpcServerHandler ipcServerHandler = (IpcServerHandler)state;
// Read the headers from the stream, using the header size in the message
ITransportHeaders headers = ipcServerHandler.ReadHeaders();
// Get the request Stream
Stream requestStream = ipcServerHandler.GetRequestStream();
// customErrors should be disabled, since we are on the same machine
headers["__CustomErrorsEnabled"] = false;
// process request
ServerChannelSinkStack sinkStack = new ServerChannelSinkStack();
sinkStack.Push(this, ipcServerHandler);
IMessage responseMessage = null;
ITransportHeaders responseHeaders = null;
Stream responseStream = null;
WindowsIdentity identity = null;
IPrincipal oldPrincipal = null;
bool impersonated = false;
bool principalChanged = false;
ServerProcessing processing = ServerProcessing.Complete;
try{
if (_secure)
{
IpcPort port = ipcServerHandler.Port;
port.ImpersonateClient();
oldPrincipal = Thread.CurrentPrincipal;
principalChanged = true;
impersonated = true;
identity = WindowsIdentity.GetCurrent();
// If the authentication mode is to identify callers only revert the impersonation immediately
if (!_impersonate)
{
NativePipe.RevertToSelf();
Thread.CurrentPrincipal = new GenericPrincipal(identity, null);
impersonated = false;
}
else
{
if (identity.ImpersonationLevel == TokenImpersonationLevel.Impersonation ||
identity.ImpersonationLevel == TokenImpersonationLevel.Delegation)
{
// Set the current principal
Thread.CurrentPrincipal = new WindowsPrincipal(identity);
}
else
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Ipc_TokenImpersonationFailure"));
}
}
}
processing =
_nextSink.ProcessMessage(sinkStack, null, headers, requestStream,
out responseMessage,
out responseHeaders, out responseStream);
}
catch (Exception e) {
ipcServerHandler.CloseOnFatalError(e);
}
finally{
// Revert the principal if we had changed the principal
if (principalChanged)
{
Thread.CurrentPrincipal = oldPrincipal;
}
// Revert the impersonation if we had impersonated
if (impersonated)
{
NativePipe.RevertToSelf();
impersonated = false;
}
}
// handle response
switch (processing)
{
case ServerProcessing.Complete:
{
// Send the response. Call completed synchronously.
sinkStack.Pop(this);
// Send the response back to the client
ipcServerHandler.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
// No response needed, but the following method will make sure that
// we send at least a skeleton reply if the incoming request was
// not marked OneWayRequest (client/server metadata could be out of
// [....]).
ipcServerHandler.SendResponse(responseHeaders, responseStream);
break;
} // case ServerProcessing.OneWay
case ServerProcessing.Async:
{
sinkStack.StoreAndDispatch(this, ipcServerHandler);
break;
} // case ServerProcessing.Async
} // switch (processing)
// Start waiting for the next request
if (processing != ServerProcessing.Async)
{
ipcServerHandler.BeginReadMessage();
}
} // ServiceRequest
protected override bool ReleaseHandle()
{
return(NativePipe.CloseHandle(base.handle) != 0);
}
