| static private GetResourceString ( String key ) : String | ||
| key | String | |
| 리턴 | String | |
public override void WriteByte(byte value)
{
if (this._bClosed)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (this._chunks == null)
{
this._chunks = this.AllocateMemoryChunk();
this._writeChunk = this._chunks;
this._writeOffset = 0;
}
byte[] buffer = this._writeChunk.Buffer;
int length = buffer.Length;
if (this._writeOffset == length)
{
this._writeChunk.Next = this.AllocateMemoryChunk();
this._writeChunk = this._writeChunk.Next;
this._writeOffset = 0;
buffer = this._writeChunk.Buffer;
length = buffer.Length;
}
buffer[this._writeOffset++] = value;
}
private static void AsyncCopyStreamReadCallback(IAsyncResult iar)
{
AsyncCopyStreamResult asyncState = (AsyncCopyStreamResult)iar.AsyncState;
try
{
int bytesRead = asyncState.Source.EndRead(iar);
if (bytesRead == 0)
{
asyncState.SetComplete(null, null);
}
else
{
if (bytesRead < 0)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
AsyncCopyWriteHelper(asyncState, bytesRead);
}
}
catch (Exception exception)
{
asyncState.SetComplete(null, exception);
}
}
public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
IMessage retMsg;
try
{
// serialize message
ITransportHeaders headers;
Stream requestStream;
SerializeMessage(mcm, out headers, out requestStream);
// process message
ClientChannelSinkStack sinkStack = new ClientChannelSinkStack(replySink);
sinkStack.Push(this, mcm);
_nextSink.AsyncProcessRequest(sinkStack, msg, headers, requestStream);
}
catch (Exception e)
{
retMsg = new ReturnMessage(e, mcm);
if (replySink != null)
{
replySink.SyncProcessMessage(retMsg);
}
}
catch {
retMsg = new ReturnMessage(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")), mcm);
if (replySink != null)
{
replySink.SyncProcessMessage(retMsg);
}
}
return(null);
} // AsyncProcessMessage
private static void AsyncCopyReadHelper(AsyncCopyStreamResult streamState)
{
if (streamState.AsyncRead)
{
byte[] buffer = streamState.Buffer;
streamState.Source.BeginRead(buffer, 0, buffer.Length, _asyncCopyStreamReadCallback, streamState);
}
else
{
byte[] buffer2 = streamState.Buffer;
int bytesRead = streamState.Source.Read(buffer2, 0, buffer2.Length);
if (bytesRead == 0)
{
streamState.SetComplete(null, null);
}
else
{
if (bytesRead < 0)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
AsyncCopyWriteHelper(streamState, bytesRead);
}
}
}
} // BufferCopy
internal static IAsyncResult BeginAsyncCopyStream(
Stream source, Stream target,
bool asyncRead, bool asyncWrite,
bool closeSource, bool closeTarget,
AsyncCallback callback, Object state)
{
AsyncCopyStreamResult streamState = new AsyncCopyStreamResult(callback, state);
byte[] buffer = CoreChannel.BufferPool.GetBuffer();
streamState.Source = source;
streamState.Target = target;
streamState.Buffer = buffer;
streamState.AsyncRead = asyncRead;
streamState.AsyncWrite = asyncWrite;
streamState.CloseSource = closeSource;
streamState.CloseTarget = closeTarget;
try
{
AsyncCopyReadHelper(streamState);
}
catch (Exception e)
{
streamState.SetComplete(null, e);
}
catch {
streamState.SetComplete(null, new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
return(streamState);
} // BeginAsyncCopyStream
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
IMessage retMsg;
try
{
// serialize message
ITransportHeaders headers;
Stream requestStream;
SerializeMessage(mcm, out headers, out requestStream);
// process message
Stream returnStream;
ITransportHeaders returnHeaders;
_nextSink.ProcessMessage(msg, headers, requestStream,
out returnHeaders, out returnStream);
if (returnHeaders == null)
{
throw new ArgumentNullException("returnHeaders");
}
// deserialize stream
retMsg = DeserializeMessage(mcm, returnHeaders, returnStream);
}
catch (Exception e)
{
retMsg = new ReturnMessage(e, mcm);
}
catch {
retMsg = new ReturnMessage(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")), mcm);
}
return(retMsg);
} // SyncProcessMessage
} // AsyncCopyWriteHelper
private static void AsyncCopyStreamReadCallback(IAsyncResult iar)
{
AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
try
{
Stream source = state.Source;
int bytesRead = source.EndRead(iar);
if (bytesRead == 0)
{
state.SetComplete(null, null);
}
else
if (bytesRead < 0)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
else
{
AsyncCopyWriteHelper(state, bytesRead);
}
}
catch (Exception e)
{
state.SetComplete(null, e);
}
catch {
state.SetComplete(null, new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
} // AsyncCopyStreamReadCallback
} // ToArray
// write remainder of this stream to another stream
public virtual void WriteTo(Stream stream)
{
if (_bClosed)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (_readChunk == null)
{
if (_chunks == null)
{
return;
}
_readChunk = _chunks;
_readOffset = 0;
}
byte[] chunkBuffer = _readChunk.Buffer;
int chunkSize = chunkBuffer.Length;
if (_readChunk.Next == null)
{
chunkSize = _writeOffset;
}
// following code mirrors Read() logic (_readChunk/_readOffset should
// point just past last byte of last chunk when done)
for (;;) // loop until end of chunks is found
{
if (_readOffset == chunkSize)
{
// exit if no more chunks are currently available
if (_readChunk.Next == null)
{
break;
}
_readChunk = _readChunk.Next;
_readOffset = 0;
chunkBuffer = _readChunk.Buffer;
chunkSize = chunkBuffer.Length;
if (_readChunk.Next == null)
{
chunkSize = _writeOffset;
}
}
int writeCount = chunkSize - _readOffset;
stream.Write(chunkBuffer, _readOffset, writeCount);
_readOffset = chunkSize;
}
} // WriteTo
} // EndAsyncCopyStream
private static void AsyncCopyReadHelper(AsyncCopyStreamResult streamState)
{
// There is no try-catch here because the calling method always has a try-catch.
if (streamState.AsyncRead)
{
byte[] buffer = streamState.Buffer;
streamState.Source.BeginRead(buffer, 0, buffer.Length, _asyncCopyStreamReadCallback, streamState);
}
else
{
byte[] buffer = streamState.Buffer;
int bytesRead = streamState.Source.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
{
streamState.SetComplete(null, null);
}
else
if (bytesRead < 0)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
}
else
{
AsyncCopyWriteHelper(streamState, bytesRead);
}
}
} // AsyncCopyReadHelper
public override void Write(byte[] buffer, int offset, int count)
{
if (this._bClosed)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (this._chunks == null)
{
this._chunks = this.AllocateMemoryChunk();
this._writeChunk = this._chunks;
this._writeOffset = 0;
}
byte[] dst = this._writeChunk.Buffer;
int length = dst.Length;
while (count > 0)
{
if (this._writeOffset == length)
{
this._writeChunk.Next = this.AllocateMemoryChunk();
this._writeChunk = this._writeChunk.Next;
this._writeOffset = 0;
dst = this._writeChunk.Buffer;
length = dst.Length;
}
int num2 = Math.Min(count, length - this._writeOffset);
Buffer.BlockCopy(buffer, offset, dst, this._writeOffset, num2);
offset += num2;
count -= num2;
this._writeOffset += num2;
}
}
} // Write
public override void WriteByte(byte value)
{
if (_bClosed)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (_chunks == null)
{
_chunks = AllocateMemoryChunk();
_writeChunk = _chunks;
_writeOffset = 0;
}
byte[] chunkBuffer = _writeChunk.Buffer;
int chunkSize = chunkBuffer.Length;
if (_writeOffset == chunkSize)
{
// allocate a new chunk if the current one is full
_writeChunk.Next = AllocateMemoryChunk();
_writeChunk = _writeChunk.Next;
_writeOffset = 0;
chunkBuffer = _writeChunk.Buffer;
chunkSize = chunkBuffer.Length;
}
chunkBuffer[_writeOffset++] = value;
} // WriteByte
private Header[] GetChannelHeaders(ITransportHeaders requestHeaders, out string soapActionToVerify)
{
string str3;
string str4;
soapActionToVerify = null;
string uRI = (string)requestHeaders["__RequestUri"];
string uri = (string)requestHeaders["SOAPAction"];
if (uri == null)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_SoapActionMissing"));
}
uri = HttpEncodingHelper.DecodeUri(uri);
soapActionToVerify = uri;
if (!SoapServices.GetTypeAndMethodNameFromSoapAction(uri, out str3, out str4))
{
Type serverTypeForUri = RemotingServices.GetServerTypeForUri(uRI);
if (serverTypeForUri == null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_TypeNotFoundFromUri"), new object[] { uRI }));
}
str3 = "clr:" + serverTypeForUri.FullName + ", " + serverTypeForUri.Assembly.GetName().Name;
}
else
{
str3 = "clr:" + str3;
}
int num = 2;
Header[] headerArray = new Header[num];
headerArray[0] = new Header("__Uri", uRI);
headerArray[1] = new Header("__TypeName", str3);
return(headerArray);
}
} // Position
public override long Seek(long offset, SeekOrigin origin)
{
if (_bClosed)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
switch (origin)
{
case SeekOrigin.Begin:
Position = offset;
break;
case SeekOrigin.Current:
Position = Position + offset;
break;
case SeekOrigin.End:
Position = Length + offset;
break;
}
return(Position);
} // Seek
} // Flush
public override int Read(byte[] buffer, int offset, int count)
{
if (_bClosed)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (_readChunk == null)
{
if (_chunks == null)
{
return(0);
}
_readChunk = _chunks;
_readOffset = 0;
}
byte[] chunkBuffer = _readChunk.Buffer;
int chunkSize = chunkBuffer.Length;
if (_readChunk.Next == null)
{
chunkSize = _writeOffset;
}
int bytesRead = 0;
while (count > 0)
{
if (_readOffset == chunkSize)
{
// exit if no more chunks are currently available
if (_readChunk.Next == null)
{
break;
}
_readChunk = _readChunk.Next;
_readOffset = 0;
chunkBuffer = _readChunk.Buffer;
chunkSize = chunkBuffer.Length;
if (_readChunk.Next == null)
{
chunkSize = _writeOffset;
}
}
int readCount = Math.Min(count, chunkSize - _readOffset);
Buffer.BlockCopy(chunkBuffer, _readOffset, buffer, offset, readCount);
offset += readCount;
count -= readCount;
_readOffset += readCount;
bytesRead += readCount;
}
return(bytesRead);
} // Read
protected byte[] ReadToByte(byte b, ValidateByteDelegate validator)
{
byte[] dest = null;
if (this._dataCount == 0)
{
this.BufferMoreData();
}
int num = this._dataOffset + this._dataCount;
int srcOffset = this._dataOffset;
int index = srcOffset;
bool flag = false;
while (!flag)
{
bool flag2 = index == num;
flag = !flag2 && (this._dataBuffer[index] == b);
if (((validator != null) && !flag2) && (!flag && !validator(this._dataBuffer[index])))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Http_InvalidDataReceived"));
}
if (flag2 || flag)
{
int count = index - srcOffset;
if (dest == null)
{
dest = new byte[count];
StreamHelper.BufferCopy(this._dataBuffer, srcOffset, dest, 0, count);
}
else
{
int length = dest.Length;
byte[] buffer2 = new byte[length + count];
StreamHelper.BufferCopy(dest, 0, buffer2, 0, length);
StreamHelper.BufferCopy(this._dataBuffer, srcOffset, buffer2, length, count);
dest = buffer2;
}
this._dataOffset += count;
this._dataCount -= count;
if (flag2)
{
this.BufferMoreData();
num = this._dataOffset + this._dataCount;
srcOffset = this._dataOffset;
index = srcOffset;
}
else if (flag)
{
this._dataOffset++;
this._dataCount--;
}
}
else
{
index++;
}
}
return(dest);
}
} // VerifyNoProviderData
internal static void ReportUnknownProviderConfigProperty(String providerTypeName,
String propertyName)
{
throw new RemotingException(
String.Format(
CoreChannel.GetResourceString(
"Remoting_Providers_Config_UnknownProperty"),
providerTypeName, propertyName));
} // ReportUnknownProviderConfigProperty
private int ReadFromSocket(byte[] buffer, int offset, int count)
{
int num = this.NetStream.Read(buffer, offset, count);
if (num <= 0)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Socket_UnderlyingSocketClosed"));
}
return(num);
}
} // CollectChannelDataFromServerSinkProviders
// called by providers that aren't expecting custom provider data
internal static void VerifyNoProviderData(String providerTypeName, ICollection providerData)
{
if ((providerData != null) && (providerData.Count > 0))
{
throw new RemotingException(
String.Format(
CoreChannel.GetResourceString(
"Remoting_Providers_Config_NotExpectingProviderData"),
providerTypeName));
}
} // VerifyNoProviderData
} // Properties
// Helper method for analyzing headers
private Header[] GetChannelHeaders(ITransportHeaders requestHeaders,
out String soapActionToVerify)
{
soapActionToVerify = null;
// transport sink removes any channel specific information
String objectURI = (String)requestHeaders[CommonTransportKeys.RequestUri];
// see if a unique SOAPAction is present (if more than one SOAPAction is present some
// scenarios won't work, but one-many soap action to method base relationships are
// for interop scenarios only)
String soapAction = (String)requestHeaders["SOAPAction"];
if (soapAction == null)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_SoapActionMissing"));
}
soapAction = HttpEncodingHelper.DecodeUri(soapAction);
soapActionToVerify = soapAction;
String typeName, methodName;
if (!SoapServices.GetTypeAndMethodNameFromSoapAction(soapAction, out typeName, out methodName))
{
// This means there are multiple methods for this soap action, so we will have to
// settle for the type based off of the uri.
Type type = RemotingServices.GetServerTypeForUri(objectURI);
if (type == null)
{
throw new RemotingException(
String.Format(
CultureInfo.CurrentCulture, CoreChannel.GetResourceString(
"Remoting_TypeNotFoundFromUri"), objectURI));
}
// @todo: This throws away the version, culture and public key token
typeName = "clr:" + type.FullName + ", " + type.Assembly.GetName().Name;
}
else
{
typeName = "clr:" + typeName;
}
// Create a new header array and pass it back.
int headerLen = 2;
Header[] h = new Header[headerLen];
h[0] = new Header("__Uri", objectURI);
h[1] = new Header("__TypeName", typeName);
return(h);
} // GetChannelHeaders
public override int Read(byte[] buffer, int offset, int count)
{
if (this._bClosed)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (this._readChunk == null)
{
if (this._chunks == null)
{
return(0);
}
this._readChunk = this._chunks;
this._readOffset = 0;
}
byte[] src = this._readChunk.Buffer;
int length = src.Length;
if (this._readChunk.Next == null)
{
length = this._writeOffset;
}
int num2 = 0;
while (count > 0)
{
if (this._readOffset == length)
{
if (this._readChunk.Next == null)
{
return(num2);
}
this._readChunk = this._readChunk.Next;
this._readOffset = 0;
src = this._readChunk.Buffer;
length = src.Length;
if (this._readChunk.Next == null)
{
length = this._writeOffset;
}
}
int num3 = Math.Min(count, length - this._readOffset);
Buffer.BlockCopy(src, this._readOffset, buffer, offset, num3);
offset += num3;
count -= num3;
this._readOffset += num3;
num2 += num3;
}
return(num2);
}
} // DataArrivedCallbackState
public void BeginReadMessage()
{
bool bProcessNow = false;
try
{
if (_requestQueue != null)
{
_requestQueue.ScheduleMoreWorkIfNeeded();
}
PrepareForNewMessage();
if (_dataCount == 0)
{
_beginReadAsyncResult =
NetStream.BeginRead(_dataBuffer, 0, _dataBufferSize,
_beginReadCallback, null);
}
else
{
// just queue the request if we already have some data
// (note: we intentionally don't call the callback directly to avoid
// overflowing the stack if we service a bunch of calls)
bProcessNow = true;
}
}
catch (Exception e)
{
CloseOnFatalError(e);
}
catch {
CloseOnFatalError(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
if (bProcessNow)
{
if (_requestQueue != null)
{
_requestQueue.ProcessNextRequest(this);
}
else
{
ProcessRequestNow();
}
_beginReadAsyncResult = null;
}
} // BeginReadMessage
public virtual void WriteTo(Stream stream)
{
if (this._bClosed)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (this._readChunk == null)
{
if (this._chunks == null)
{
return;
}
this._readChunk = this._chunks;
this._readOffset = 0;
}
byte[] buffer = this._readChunk.Buffer;
int length = buffer.Length;
if (this._readChunk.Next == null)
{
length = this._writeOffset;
}
while (true)
{
if (this._readOffset == length)
{
if (this._readChunk.Next == null)
{
return;
}
this._readChunk = this._readChunk.Next;
this._readOffset = 0;
buffer = this._readChunk.Buffer;
length = buffer.Length;
if (this._readChunk.Next == null)
{
length = this._writeOffset;
}
}
int count = length - this._readOffset;
stream.Write(buffer, this._readOffset, count);
this._readOffset = length;
}
}
} // Read
public override int ReadByte()
{
if (_bClosed)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (_readChunk == null)
{
if (_chunks == null)
{
return(0);
}
_readChunk = _chunks;
_readOffset = 0;
}
byte[] chunkBuffer = _readChunk.Buffer;
int chunkSize = chunkBuffer.Length;
if (_readChunk.Next == null)
{
chunkSize = _writeOffset;
}
if (_readOffset == chunkSize)
{
// exit if no more chunks are currently available
if (_readChunk.Next == null)
{
return(-1);
}
_readChunk = _readChunk.Next;
_readOffset = 0;
chunkBuffer = _readChunk.Buffer;
chunkSize = chunkBuffer.Length;
if (_readChunk.Next == null)
{
chunkSize = _writeOffset;
}
}
return(chunkBuffer[_readOffset++]);
} // ReadByte
} // AsyncCopyStreamReadCallback
private static void AsyncCopyStreamWriteCallback(IAsyncResult iar)
{
AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
try
{
state.Target.EndWrite(iar);
AsyncCopyReadHelper(state);
}
catch (Exception e)
{
state.SetComplete(null, e);
}
catch {
state.SetComplete(null, new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
} // AsyncCopyStreamWriteCallback
} // CloseOnFatalError
// Called when the SocketHandler is pulled off the pending request queue.
internal void ProcessRequestNow()
{
try
{
WaitCallback waitCallback = _dataArrivedCallback;
if (waitCallback != null)
{
waitCallback(this);
}
}
catch (Exception e)
{
CloseOnFatalError(e);
}
catch
{
CloseOnFatalError(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
} // ProcessRequestNow
} // BeginReadMessage
public void BeginReadMessageCallback(IAsyncResult ar)
{
bool bProcessRequest = false;
// data has been buffered; proceed to call provided callback
try
{
_beginReadAsyncResult = null;
_dataOffset = 0;
_dataCount = NetStream.EndRead(ar);
if (_dataCount <= 0)
{
// socket has been closed
Close();
}
else
{
bProcessRequest = true;
}
}
catch (Exception e)
{
CloseOnFatalError(e);
}
catch {
CloseOnFatalError(new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
}
if (bProcessRequest)
{
if (_requestQueue != null)
{
_requestQueue.ProcessNextRequest(this);
}
else
{
ProcessRequestNow();
}
}
} // BeginReadMessageCallback
public override int ReadByte()
{
if (this._bClosed)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (this._readChunk == null)
{
if (this._chunks == null)
{
return(0);
}
this._readChunk = this._chunks;
this._readOffset = 0;
}
byte[] buffer = this._readChunk.Buffer;
int length = buffer.Length;
if (this._readChunk.Next == null)
{
length = this._writeOffset;
}
if (this._readOffset == length)
{
if (this._readChunk.Next == null)
{
return(-1);
}
this._readChunk = this._readChunk.Next;
this._readOffset = 0;
buffer = this._readChunk.Buffer;
length = buffer.Length;
if (this._readChunk.Next == null)
{
length = this._writeOffset;
}
}
return(buffer[this._readOffset++]);
}
internal void SetComplete(Object returnValue, Exception exception)
{
_returnValue = returnValue;
_exception = exception;
CleanupOnComplete();
_bIsComplete = true;
try
{
if (_manualResetEvent != null)
{
_manualResetEvent.Set();
}
}
catch (Exception e)
{
if (_exception == null)
{
_exception = e;
}
}
catch {
if (_exception == null)
{
_exception = new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException"));
}
}
// invoke the callback
if (_asyncCallback != null)
{
_asyncCallback(this);
}
} // SetComplete
} // ReadByte
public override void Write(byte[] buffer, int offset, int count)
{
if (_bClosed)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Stream_StreamIsClosed"));
}
if (_chunks == null)
{
_chunks = AllocateMemoryChunk();
_writeChunk = _chunks;
_writeOffset = 0;
}
byte[] chunkBuffer = _writeChunk.Buffer;
int chunkSize = chunkBuffer.Length;
while (count > 0)
{
if (_writeOffset == chunkSize)
{
// allocate a new chunk if the current one is full
_writeChunk.Next = AllocateMemoryChunk();
_writeChunk = _writeChunk.Next;
_writeOffset = 0;
chunkBuffer = _writeChunk.Buffer;
chunkSize = chunkBuffer.Length;
}
int copyCount = Math.Min(count, chunkSize - _writeOffset);
Buffer.BlockCopy(buffer, offset, chunkBuffer, _writeOffset, copyCount);
offset += copyCount;
count -= copyCount;
_writeOffset += copyCount;
}
} // Write
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders, Stream requestStream,
out IMessage responseMsg, out ITransportHeaders responseHeaders,
out Stream responseStream)
{
if (requestMsg != null)
{
// The message has already been deserialized so delegate to the next sink.
return(_nextSink.ProcessMessage(
sinkStack,
requestMsg, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream));
}
if (requestHeaders == null)
{
throw new ArgumentNullException("requestHeaders");
}
BaseTransportHeaders wkRequestHeaders = requestHeaders as BaseTransportHeaders;
ServerProcessing processing;
responseHeaders = null;
responseStream = null;
String verb = null;
String contentType = null;
bool bCanServiceRequest = true;
// determine the content type
String contentTypeHeader = null;
if (wkRequestHeaders != null)
{
contentTypeHeader = wkRequestHeaders.ContentType;
}
else
{
contentTypeHeader = requestHeaders["Content-Type"] as String;
}
if (contentTypeHeader != null)
{
String charsetValue;
HttpChannelHelper.ParseContentType(contentTypeHeader,
out contentType, out charsetValue);
}
// check to see if Content-Type matches
if ((contentType != null) &&
(String.CompareOrdinal(contentType, CoreChannel.BinaryMimeType) != 0))
{
bCanServiceRequest = false;
}
// check for http specific verbs
if (_protocol == Protocol.Http)
{
verb = (String)requestHeaders["__RequestVerb"];
if (!verb.Equals("POST") && !verb.Equals("M-POST"))
{
bCanServiceRequest = false;
}
}
// either delegate or return an error message if we can't service the request
if (!bCanServiceRequest)
{
// delegate to next sink if available
if (_nextSink != null)
{
return(_nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream,
out responseMsg, out responseHeaders, out responseStream));
}
else
{
// send back an error message
if (_protocol == Protocol.Http)
{
// return a client bad request error
responseHeaders = new TransportHeaders();
responseHeaders["__HttpStatusCode"] = "400";
responseHeaders["__HttpReasonPhrase"] = "Bad Request";
responseStream = null;
responseMsg = null;
return(ServerProcessing.Complete);
}
else
{
// The transport sink will catch this and do something here.
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_Channels_InvalidRequestFormat"));
}
}
}
try
{
String objectUri = null;
bool bIsCustomErrorEnabled = true;
object oIsCustomErrorEnabled = requestHeaders["__CustomErrorsEnabled"];
if (oIsCustomErrorEnabled != null && oIsCustomErrorEnabled is bool)
{
bIsCustomErrorEnabled = (bool)oIsCustomErrorEnabled;
}
CallContext.SetData("__CustomErrorsEnabled", bIsCustomErrorEnabled);
if (wkRequestHeaders != null)
{
objectUri = wkRequestHeaders.RequestUri;
}
else
{
objectUri = (String)requestHeaders[CommonTransportKeys.RequestUri];
}
if (objectUri != lastUri && RemotingServices.GetServerTypeForUri(objectUri) == null)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_ChnlSink_UriNotPublished"));
}
else
{
lastUri = objectUri;
}
PermissionSet currentPermissionSet = null;
if (this.TypeFilterLevel != TypeFilterLevel.Full)
{
currentPermissionSet = new PermissionSet(PermissionState.None);
currentPermissionSet.SetPermission(new SecurityPermission(SecurityPermissionFlag.SerializationFormatter));
}
try {
if (currentPermissionSet != null)
{
currentPermissionSet.PermitOnly();
}
// Deserialize Request - Stream to IMessage
requestMsg = CoreChannel.DeserializeBinaryRequestMessage(objectUri, requestStream, _strictBinding, this.TypeFilterLevel);
}
finally {
if (currentPermissionSet != null)
{
CodeAccessPermission.RevertPermitOnly();
}
}
requestStream.Close();
if (requestMsg == null)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage"));
}
// Dispatch Call
sinkStack.Push(this, null);
processing =
_nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
// make sure that responseStream is null
if (responseStream != null)
{
throw new RemotingException(
CoreChannel.GetResourceString("Remoting_ChnlSink_WantNullResponseStream"));
}
switch (processing)
{
case ServerProcessing.Complete:
{
if (responseMsg == null)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_DispatchMessage"));
}
sinkStack.Pop(this);
SerializeResponse(sinkStack, responseMsg,
ref responseHeaders, out responseStream);
break;
} // case ServerProcessing.Complete
case ServerProcessing.OneWay:
{
sinkStack.Pop(this);
break;
} // case ServerProcessing.OneWay:
case ServerProcessing.Async:
{
sinkStack.Store(this, null);
break;
} // case ServerProcessing.Async
} // switch (processing)
}
catch (Exception e)
{
processing = ServerProcessing.Complete;
responseMsg = new ReturnMessage(e, (IMethodCallMessage)(requestMsg == null?new ErrorMessage():requestMsg));
//
CallContext.SetData("__ClientIsClr", true);
responseStream = (MemoryStream)CoreChannel.SerializeBinaryMessage(responseMsg, _includeVersioning);
CallContext.FreeNamedDataSlot("__ClientIsClr");
responseStream.Position = 0;
responseHeaders = new TransportHeaders();
if (_protocol == Protocol.Http)
{
responseHeaders["Content-Type"] = CoreChannel.BinaryMimeType;
}
}
finally{
CallContext.FreeNamedDataSlot("__CustomErrorsEnabled");
}
return(processing);
} // ProcessMessage
