internal void SendResponse(ITransportHeaders headers, Stream contentStream)
{
// bail out if the original request was OneWay (means the client doesn't even
// want or expect to receive responses or error messages)
if (_bOneWayRequest)
{
return;
}
// build up headers and send
ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
// output preamble and version
WritePreambleAndVersion(headerStream);
// output opcode
WriteUInt16(TcpOperations.Reply, headerStream);
// output content length delimiter
WriteUInt16(TcpContentDelimiter.ContentLength, headerStream);
WriteInt32((int)contentStream.Length, headerStream);
// No status code header is needed because if we're in this code path
// the data transfer succeeded as far as the transport protocol is
// concerned (and the success status code is optional).
WriteHeaders(headers, headerStream);
headerStream.WriteTo(NetStream);
headerStream.Close();
StreamHelper.CopyStream(contentStream, NetStream);
contentStream.Close();
}
internal void SendRequest(IMessage msg, ITransportHeaders headers, Stream contentStream)
{
IMethodCallMessage message = (IMethodCallMessage)msg;
int length = (int)contentStream.Length;
string uri = message.Uri;
this._bOneWayRequest = RemotingServices.IsOneWay(message.MethodBase);
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
if (!this._bOneWayRequest)
{
base.WriteUInt16(0, outputStream);
}
else
{
base.WriteUInt16(1, outputStream);
}
base.WriteUInt16(0, outputStream);
base.WriteInt32(length, outputStream);
base.WriteUInt16(4, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(uri, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
StreamHelper.CopyStream(contentStream, base.NetStream);
contentStream.Close();
}
public Stream GetRequestStream(IMessage msg, int contentLength, ITransportHeaders headers)
{
IMethodCallMessage message = (IMethodCallMessage)msg;
string uri = message.Uri;
this._bOneWayRequest = RemotingServices.IsOneWay(message.MethodBase);
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
if (!this._bOneWayRequest)
{
base.WriteUInt16(0, outputStream);
}
else
{
base.WriteUInt16(1, outputStream);
}
base.WriteUInt16(0, outputStream);
base.WriteInt32(contentLength, outputStream);
base.WriteUInt16(4, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(uri, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
this._requestStream = base.NetStream;
return(this._requestStream);
}
public Stream GetResponseStream(string statusCode, string reasonPhrase, ITransportHeaders headers)
{
bool flag = false;
bool flag2 = false;
int length = 0;
object obj2 = headers["__HttpStatusCode"];
string str = headers["__HttpReasonPhrase"] as string;
if (obj2 != null)
{
statusCode = obj2.ToString();
}
if (str != null)
{
reasonPhrase = str;
}
if (!this.CanServiceAnotherRequest())
{
headers["Connection"] = "Close";
}
object obj3 = headers["Content-Length"];
if (obj3 != null)
{
flag = true;
if (obj3 is int)
{
length = (int)obj3;
}
else
{
length = Convert.ToInt32(obj3, CultureInfo.InvariantCulture);
}
}
flag2 = this.AllowChunkedResponse && !flag;
if (flag2)
{
headers["Transfer-Encoding"] = "chunked";
}
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WriteResponseFirstLine(statusCode, reasonPhrase, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
if (flag2)
{
this._responseStream = new HttpChunkedResponseStream(base.NetStream);
}
else
{
this._responseStream = new HttpFixedLengthResponseStream(base.NetStream, length);
}
return(this._responseStream);
}
public void SendResponse(ITransportHeaders headers, Stream contentStream)
{
if (!this._bOneWayRequest)
{
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
base.WriteUInt16(2, outputStream);
base.WriteUInt16(0, outputStream);
base.WriteInt32((int)contentStream.Length, outputStream);
base.WriteHeaders(headers, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
StreamHelper.CopyStream(contentStream, base.NetStream);
contentStream.Close();
}
}
internal void SendRequest(IMessage msg, ITransportHeaders headers, Stream contentStream)
{
// Request is written just like a response
// we can reuse the same code
IMethodCallMessage mcm = (IMethodCallMessage)msg;
int contentLength = (int)contentStream.Length;
String uri = mcm.Uri;
_bOneWayRequest = RemotingServices.IsOneWay(mcm.MethodBase);
ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
// output preamble and version
WritePreambleAndVersion(headerStream);
// output opcode
if (!_bOneWayRequest)
{
WriteUInt16(TcpOperations.Request, headerStream);
}
else
{
WriteUInt16(TcpOperations.OneWayRequest, headerStream);
}
// output content delimiter style
WriteUInt16(TcpContentDelimiter.ContentLength, headerStream);
WriteInt32(contentLength, headerStream);
// output request uri
WriteUInt16(TcpHeaders.RequestUri, headerStream);
WriteByte(TcpHeaderFormat.CountedString, headerStream);
WriteCountedString(uri, headerStream);
// output rest of headers
WriteHeaders(headers, headerStream);
headerStream.WriteTo(NetStream);
headerStream.Close();
StreamHelper.CopyStream(contentStream, NetStream);
contentStream.Close();
}
} // ReadHeaders
public Stream GetRequestStream(IMessage msg, int contentLength,
ITransportHeaders headers)
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
String uri = mcm.Uri;
_bOneWayRequest = RemotingServices.IsOneWay(mcm.MethodBase);
ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
// output preamble and version
WritePreambleAndVersion(headerStream);
// output opcode
if (!_bOneWayRequest)
{
WriteUInt16(TcpOperations.Request, headerStream);
}
else
{
WriteUInt16(TcpOperations.OneWayRequest, headerStream);
}
// output content delimiter style
WriteUInt16(TcpContentDelimiter.ContentLength, headerStream);
WriteInt32(contentLength, headerStream);
// output request uri
WriteUInt16(TcpHeaders.RequestUri, headerStream);
WriteByte(TcpHeaderFormat.CountedString, headerStream);
WriteCountedString(uri, headerStream);
// output rest of headers
WriteHeaders(headers, headerStream);
headerStream.WriteTo(NetStream);
headerStream.Close();
_requestStream = NetStream;
return(_requestStream);
} // GetRequestStream
} // PrepareForNewRequest
protected override void SendErrorMessageIfPossible(Exception e)
{
// bail out if the original request was OneWay (means the client doesn't even
// want or expect to receive responses or error messages)
if (_bOneWayRequest)
{
return;
}
// build up headers and send
ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
// output preamble and version
WritePreambleAndVersion(headerStream);
// output opcode
WriteUInt16(TcpOperations.Reply, headerStream);
// output content length delimiter (0-length stream)
WriteUInt16(TcpContentDelimiter.ContentLength, headerStream);
WriteInt32(0, headerStream);
// output status code and reason
WriteUInt16(TcpHeaders.StatusCode, headerStream);
WriteByte(TcpHeaderFormat.UInt16, headerStream);
WriteUInt16(TcpStatusCode.GenericError, headerStream);
// we purposely don't include the stack trace to avoid giving
// out too much information for security purposes.
WriteUInt16(TcpHeaders.StatusPhrase, headerStream);
WriteByte(TcpHeaderFormat.CountedString, headerStream);
WriteCountedString(e.ToString(), headerStream);
// indicate that we are about to close the connection
WriteUInt16(TcpHeaders.CloseConnection, headerStream);
WriteByte(TcpHeaderFormat.Void, headerStream);
// end of headers
WriteUInt16(TcpHeaders.EndOfHeaders, headerStream);
headerStream.WriteTo(NetStream);
headerStream.Close();
}
public void SendErrorResponse(string e, bool bCloseConnection)
{
if (!this._bOneWayRequest)
{
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
base.WriteUInt16(2, outputStream);
base.WriteUInt16(0, outputStream);
base.WriteInt32(0, outputStream);
base.WriteUInt16(2, outputStream);
base.WriteByte(3, outputStream);
base.WriteUInt16(1, outputStream);
base.WriteUInt16(3, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(e, outputStream);
base.WriteUInt16(5, outputStream);
base.WriteByte(0, outputStream);
base.WriteUInt16(0, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
}
}
protected override void SendErrorMessageIfPossible(Exception e)
{
if (!this._bOneWayRequest)
{
ChunkedMemoryStream outputStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
base.WritePreambleAndVersion(outputStream);
base.WriteUInt16(2, outputStream);
base.WriteUInt16(0, outputStream);
base.WriteInt32(0, outputStream);
base.WriteUInt16(2, outputStream);
base.WriteByte(3, outputStream);
base.WriteUInt16(1, outputStream);
base.WriteUInt16(3, outputStream);
base.WriteByte(1, outputStream);
base.WriteCountedString(e.ToString(), outputStream);
base.WriteUInt16(5, outputStream);
base.WriteByte(0, outputStream);
base.WriteUInt16(0, outputStream);
outputStream.WriteTo(base.NetStream);
outputStream.Close();
}
}
} // GetRequestStream
public Stream GetResponseStream(String statusCode, String reasonPhrase,
ITransportHeaders headers)
{
bool contentLengthPresent = false;
bool useChunkedEncoding = false;
int contentLength = 0;
// check for custom user status code and reason phrase
Object userStatusCode = headers["__HttpStatusCode"]; // someone might have stored an int
String userReasonPhrase = headers["__HttpReasonPhrase"] as String;
if (userStatusCode != null)
{
statusCode = userStatusCode.ToString();
}
if (userReasonPhrase != null)
{
reasonPhrase = userReasonPhrase;
}
// see if we can handle any more requests on this socket
if (!CanServiceAnotherRequest())
{
headers["Connection"] = "Close";
}
// check for content length
Object contentLengthEntry = headers["Content-Length"];
if (contentLengthEntry != null)
{
contentLengthPresent = true;
if (contentLengthEntry is int)
{
contentLength = (int)contentLengthEntry;
}
else
{
contentLength = Convert.ToInt32(contentLengthEntry);
}
}
// see if we are going to use chunked-encoding
useChunkedEncoding = AllowChunkedResponse && !contentLengthPresent;
if (useChunkedEncoding)
{
headers["Transfer-Encoding"] = "chunked";
}
// write headers to stream
ChunkedMemoryStream headerStream = new ChunkedMemoryStream(CoreChannel.BufferPool);
WriteResponseFirstLine(statusCode, reasonPhrase, headerStream);
WriteHeaders(headers, headerStream);
headerStream.WriteTo(NetStream);
headerStream.Close();
// return stream ready for content
if (useChunkedEncoding)
{
_responseStream = new HttpChunkedResponseStream(NetStream);
}
else
{
_responseStream = new HttpFixedLengthResponseStream(NetStream, contentLength);
}
return(_responseStream);
} // GetResponseStream
