public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream responseStream)
{
ContextWithId ctx = (ContextWithId) state;
WriteOut (ctx.Context, headers, responseStream);
ctx.Context.Response.Close ();
}
public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
object state,
IMessage msg,
ITransportHeaders headers)
{
return null;
}
public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
object state,
IMessage msg,
ITransportHeaders headers)
{
throw new NotImplementedException();
}
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack_in,
object state_in,
IMessage message_in,
ITransportHeaders headers_in,
Stream stream_in
) {
#if DEBUG
Console.WriteLine("compression sink: AsyncProcessResponse...");
#endif
bool _hasBeenCompressed = (bool)state_in;
if (_hasBeenCompressed) {
#region compress...
headers_in[CompressionHelper.X_COMPRESS] = "1";
stream_in = CompressionHelper.GetCompressedStreamCopy(
stream_in
);
#endregion
} else {
if (this.mustdo_) {
throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-compressed communications not allowed!\n\n");
}
}
sinkStack_in.AsyncProcessResponse(
message_in,
headers_in,
stream_in
);
}
public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack,
object state,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
throw new NotSupportedException (); // Never called
}
public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream responseStream)
{
ClientConnection connection = (ClientConnection)state;
NetworkStream stream = new NetworkStream (connection.Client);
UnixMessageIO.SendMessageStream (stream, responseStream, headers, connection.Buffer);
stream.Flush ();
stream.Close ();
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack
, object state
, IMessage msg
, ITransportHeaders headers
, Stream stream)
{
SerializeResponseMessage(sinkStack, msg, ref headers, ref stream);
sinkStack.AsyncProcessResponse(msg, headers, stream);
}
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
HttpServerSocketHandler handler = (HttpServerSocketHandler) state;
if (handler.AllowChunkedResponse)
{
return handler.GetResponseStream("200", "OK", headers);
}
return null;
}
/// <summary></summary>
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack,
Object state,
IMessage message,
ITransportHeaders headers,
Stream stream)
{
SetClientIpAddressDataHelper(headers);
sinkStack.AsyncProcessResponse(message, headers, stream);
}
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack,
object state,
IMessage msg,
ITransportHeaders headers,
Stream stream)
{
// Send the response to the client.
sinkStack.AsyncProcessResponse(msg, headers, stream);
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
ClientState cs = state as ClientState;
if (cs != null && cs.clientCompressed) {
// compress the shits
stream = CompressionHelper.CompressStream(stream);
headers[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag;
}
sinkStack.AsyncProcessResponse(msg, headers, stream);
}
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack,
Object state,
IMessage message,
ITransportHeaders headers,
Stream stream)
{
IPAddress ip = headers[CommonTransportKeys.IPAddress] as IPAddress;
CallContext.SetData("ClientIPAddress", ip);
sinkStack.AsyncProcessResponse(message, headers, stream);
}
public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
IMessage message, ITransportHeaders headers, Stream stream)
{
ITransportHeaders responseHeaders = new TransportHeaders();
if (sinkStack != null) stream = sinkStack.GetResponseStream (message, responseHeaders);
if (stream == null) stream = new MemoryStream();
_binaryCore.Serializer.Serialize (stream, message, null);
if (stream is MemoryStream) stream.Position = 0;
sinkStack.AsyncProcessResponse (message, responseHeaders, stream);
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
HttpServerSocketHandler handler = null;
handler = (HttpServerSocketHandler) state;
handler.SendResponse(stream, "200", "OK", headers);
if (handler.CanServiceAnotherRequest())
{
handler.BeginReadMessage();
}
else
{
handler.Close();
}
}
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage responseMsg, ITransportHeaders responseHeaders)
{
// parameters validation
if (responseHeaders == null)
throw new ArgumentNullException("responseHeaders");
IMethodReturnMessage methodReturn = responseMsg as IMethodReturnMessage;
if (methodReturn == null)
throw new NotSupportedException();
IConnection connection = state as IConnection;
if (connection == null)
throw new NotSupportedException();
// return stream for writing response
return connection.GetResponseStream(methodReturn, responseHeaders);
}
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack_in,
object state_in,
IMessage message_in,
ITransportHeaders headers_in,
Stream stream_in
) {
CallContext.SetData(
"ClientIPAddress",
((IPAddress)headers_in[CommonTransportKeys.IPAddress]).ToString()
);
sinkStack_in.AsyncProcessResponse(
message_in,
headers_in,
stream_in
);
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage responseMsg, ITransportHeaders responseHeaders, Stream responseStream)
{
// parameters validation
if (sinkStack == null)
throw new ArgumentNullException("sinkStack");
if (responseHeaders == null)
throw new ArgumentNullException("responseHeaders");
if (responseStream == null)
throw new ArgumentNullException("responseStream");
var methodReturn = responseMsg as IMethodReturnMessage;
if (methodReturn == null)
throw new NotSupportedException();
// serialize response
_formatter.SerializeResponse(methodReturn, responseHeaders, responseStream);
// process response asynchronously
sinkStack.AsyncProcessResponse(responseMsg, responseHeaders, responseStream);
}
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack_in,
object state_in,
IMessage message_in,
ITransportHeaders headers_in,
Stream stream_in
) {
#if DEBUG
Console.WriteLine("encryption sink: AsyncProcessResponse");
#endif
bool _hasBeenEncrypted
= (state_in != null)
? ((StateStruct)state_in).isEncripted
: false
;
if (_hasBeenEncrypted) {
#region encrypt...
headers_in[EncryptionHelper.X_ENCRYPT] = "1";
stream_in
= EncryptionHelper.Encrypt(
stream_in,
true,
keyspath_,
((StateStruct)state_in).ClientID
);
#endregion
} else {
if (mustdo_) {
throw new Exception("\n\n\t\tyour activity is being logged!\n\n\t\tun-encrypted communications not allowed!\n\n");
}
}
sinkStack_in.AsyncProcessResponse(
message_in,
headers_in,
stream_in
);
}
} // AsyncProcessResponse
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers)
{
// We never push ourselves to the sink stack, so this won't be called.
throw new NotSupportedException();
} // GetResponseStream
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers)
{
return(null); // do not force a use of a response-stream, delegate descision to other sinks
}
System.IO.Stream IServerChannelSink.GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, System.Runtime.Remoting.Messaging.IMessage msg, ITransportHeaders headers)
{
return(nextSink.GetResponseStream(sinkStack, state, msg, headers));
}
/*
public void StartListening()
{
ConnectionManager.StartListening(_port);
}
*/
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, System.IO.Stream stream)
{
ChannelMessage req = (ChannelMessage) state;
ChannelMessage reply = new ChannelMessage(req.From,req.ID,headers,stream);
ConnectionManager.SendMessage(reply);
}
/// <summary>
/// Gibt den Antwort-Datenstrom zurück.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="state">Optionale Statusinformationen</param>
/// <param name="msg">Remoting-Nachricht</param>
/// <param name="headers">Header-Informationen</param>
/// <returns>Antwort-Datenstrom</returns>
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
// Immer null zurückgeben
return(null);
}
public virtual System.IO.Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, System.Runtime.Remoting.Messaging.IMessage msg, ITransportHeaders headers)
{
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage message, ITransportHeaders headers, Stream stream)
{
object obj1 = headers["__IPAddress"];
sinkStack.AsyncProcessResponse(message, headers, stream);
}
} // ProcessMessage
/// <include file='doc\BinaryFormatterSinks.uex' path='docs/doc[@for="BinaryServerFormatterSink.AsyncProcessResponse"]/*' />
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
SerializeResponse(sinkStack, msg, ref headers, out stream);
sinkStack.AsyncProcessResponse(msg, headers, stream);
} // AsyncProcessResponse
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
}
} // AsyncProcessResponse
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers)
{
// We always want a stream to read from.
return null;
} // GetResponseStream
// </Snippet3>
public void AsyncProcessResponse(IServerResponseChannelSinkStack myServerChannelSinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
}
} // AsyncProcessResponse
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers)
{
// We always want a stream to read from.
return(null);
} // GetResponseStream
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
throw new NotSupportedException();
}
public System.IO.Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
return(_sink.GetResponseStream(sinkStack, state, msg, headers));
}
public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
ITransportHeaders responseHeaders = new TransportHeaders();
if(sinkStack != null) stream = sinkStack.GetResponseStream(msg, responseHeaders);
if(stream == null) stream = new MemoryStream();
SoapMessageFormatter soapMsgFormatter = (SoapMessageFormatter)state;
SoapMessage soapMessage = (SoapMessage) soapMsgFormatter.BuildSoapMessageFromMethodResponse((IMethodReturnMessage)msg, out responseHeaders);
_soapCore.Serializer.Serialize(stream, soapMessage, null);
if(stream is MemoryStream) stream.Position = 0;
sinkStack.AsyncProcessResponse (msg, responseHeaders, stream);
}
private void GenerateSdl(SdlType sdlType, IServerResponseChannelSinkStack sinkStack, ITransportHeaders requestHeaders, ITransportHeaders responseHeaders, out Stream outputStream)
{
if (!this.MetadataEnabled)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_MetadataNotEnabled"));
}
string uri = requestHeaders["__RequestUri"] as string;
string objectUriFromRequestUri = HttpChannelHelper.GetObjectUriFromRequestUri(uri);
if (!this.RemoteApplicationMetadataEnabled && (string.Compare(objectUriFromRequestUri, "RemoteApplicationMetadata.rem", StringComparison.OrdinalIgnoreCase) == 0))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_RemoteApplicationMetadataNotEnabled"));
}
string hostName = (string) requestHeaders["Host"];
if (hostName != null)
{
int index = hostName.IndexOf(':');
if (index != -1)
{
hostName = hostName.Substring(0, index);
}
}
string channelUri = SetupUrlBashingForIisIfNecessary(hostName);
ServiceType[] serviceTypes = null;
if (string.Compare(objectUriFromRequestUri, "RemoteApplicationMetadata.rem", StringComparison.OrdinalIgnoreCase) == 0)
{
ActivatedServiceTypeEntry[] registeredActivatedServiceTypes = RemotingConfiguration.GetRegisteredActivatedServiceTypes();
WellKnownServiceTypeEntry[] registeredWellKnownServiceTypes = RemotingConfiguration.GetRegisteredWellKnownServiceTypes();
int num2 = 0;
if (registeredActivatedServiceTypes != null)
{
num2 += registeredActivatedServiceTypes.Length;
}
if (registeredWellKnownServiceTypes != null)
{
num2 += registeredWellKnownServiceTypes.Length;
}
serviceTypes = new ServiceType[num2];
int num3 = 0;
if (registeredActivatedServiceTypes != null)
{
foreach (ActivatedServiceTypeEntry entry in registeredActivatedServiceTypes)
{
serviceTypes[num3++] = new ServiceType(entry.ObjectType, null);
}
}
if (registeredWellKnownServiceTypes != null)
{
foreach (WellKnownServiceTypeEntry entry2 in registeredWellKnownServiceTypes)
{
string url = this._receiver.GetUrlsForUri(entry2.ObjectUri)[0];
if (channelUri != null)
{
url = HttpChannelHelper.ReplaceChannelUriWithThisString(url, channelUri);
}
else if (hostName != null)
{
url = HttpChannelHelper.ReplaceMachineNameWithThisString(url, hostName);
}
serviceTypes[num3++] = new ServiceType(entry2.ObjectType, url);
}
}
}
else
{
Type serverTypeForUri = RemotingServices.GetServerTypeForUri(objectUriFromRequestUri);
if (serverTypeForUri == null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, "Object with uri '{0}' does not exist at server.", new object[] { objectUriFromRequestUri }));
}
string str6 = this._receiver.GetUrlsForUri(objectUriFromRequestUri)[0];
if (channelUri != null)
{
str6 = HttpChannelHelper.ReplaceChannelUriWithThisString(str6, channelUri);
}
else if (hostName != null)
{
str6 = HttpChannelHelper.ReplaceMachineNameWithThisString(str6, hostName);
}
serviceTypes = new ServiceType[] { new ServiceType(serverTypeForUri, str6) };
}
responseHeaders["Content-Type"] = "text/xml";
bool flag = false;
outputStream = sinkStack.GetResponseStream(null, responseHeaders);
if (outputStream == null)
{
outputStream = new MemoryStream(0x400);
flag = true;
}
MetaData.ConvertTypesToSchemaToStream(serviceTypes, sdlType, outputStream);
if (flag)
{
outputStream.Position = 0L;
}
}
private void SerializeResponse(IServerResponseChannelSinkStack sinkStack,
IMessage msg, ref ITransportHeaders headers,
out Stream stream)
{
BaseTransportHeaders responseHeaders = new BaseTransportHeaders();
if (headers != null)
{
// copy old headers into new headers
foreach (DictionaryEntry entry in headers)
{
responseHeaders[entry.Key] = entry.Value;
}
}
headers = responseHeaders;
if (_protocol == Protocol.Http)
{
responseHeaders.ContentType = CoreChannel.BinaryMimeType;
}
bool bMemStream = false;
stream = sinkStack.GetResponseStream(msg, headers);
if (stream == null)
{
stream = new ChunkedMemoryStream(CoreChannel.BufferPool);
bMemStream = true;
}
bool bBashUrl = CoreChannel.SetupUrlBashingForIisSslIfNecessary();
try
{
CallContext.SetData("__ClientIsClr", true);
CoreChannel.SerializeBinaryMessage(msg, stream, _includeVersioning);
}
finally
{
CallContext.FreeNamedDataSlot("__ClientIsClr");
CoreChannel.CleanupUrlBashingForIisSslIfNecessary(bBashUrl);
}
if (bMemStream)
stream.Position = 0;
} // SerializeResponse
/// <summary>
/// Fordert die Verarbeitung der Antwortnachricht von dieser Senke an, wenn die Anfragenachricht asynchron verarbeitet wurde.
/// </summary>
/// <param name="sinkStack">Senkenstapel</param>
/// <param name="state">Zustand</param>
/// <param name="msg">antwort-Nachricht</param>
/// <param name="headers">Antwort-Header</param>
/// <param name="stream">Antwort-Datenstrom</param>
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
// Antwortnachtenverarbeitung der verbleibenden Senken im Stapel aufrufen
sinkStack.AsyncProcessResponse(msg, headers, stream);
}
public Stream GetResponseStream(
IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
//not implemented, since only formatter sink need to call this method
return(null);
}
} // ShouldIntercept
private void GenerateSdl(SdlType sdlType,
IServerResponseChannelSinkStack sinkStack,
ITransportHeaders requestHeaders,
ITransportHeaders responseHeaders,
out Stream outputStream)
{
String requestUri = requestHeaders[CommonTransportKeys.RequestUri] as String;
String objectUri = HttpChannelHelper.GetObjectUriFromRequestUri(requestUri);
// If the host header is present, we will use this in the generated uri's
String hostName = (String)requestHeaders["Host"];
if (hostName != null)
{
// filter out port number if present
int index = hostName.IndexOf(':');
if (index != -1)
{
hostName = hostName.Substring(0, index);
}
}
ServiceType[] types = null;
if (String.Compare(objectUri, "RemoteApplicationMetadata.rem", true, CultureInfo.InvariantCulture) == 0)
{
// get the service description for all registered service types
ActivatedServiceTypeEntry[] activatedTypes =
RemotingConfiguration.GetRegisteredActivatedServiceTypes();
WellKnownServiceTypeEntry[] wellKnownTypes =
RemotingConfiguration.GetRegisteredWellKnownServiceTypes();
// determine total number of types
int typeCount = 0;
if (activatedTypes != null)
{
typeCount += activatedTypes.Length;
}
if (wellKnownTypes != null)
{
typeCount += wellKnownTypes.Length;
}
types = new ServiceType[typeCount];
// collect data
int co = 0;
if (activatedTypes != null)
{
foreach (ActivatedServiceTypeEntry entry in activatedTypes)
{
types[co++] = new ServiceType(entry.ObjectType, null);
}
}
if (wellKnownTypes != null)
{
foreach (WellKnownServiceTypeEntry entry in wellKnownTypes)
{
String[] urls = _receiver.GetUrlsForUri(entry.ObjectUri);
String url = urls[0];
if (hostName != null)
{
url = HttpChannelHelper.ReplaceMachineNameWithThisString(url, hostName);
}
types[co++] = new ServiceType(entry.ObjectType, url);
}
}
InternalRemotingServices.RemotingAssert(co == typeCount, "Not all types were processed.");
}
else
{
// get the service description for a particular object
Type objectType = RemotingServices.GetServerTypeForUri(objectUri);
if (objectType == null)
{
throw new RemotingException(
String.Format(
"Object with uri '{0}' does not exist at server.",
objectUri));
}
String[] urls = _receiver.GetUrlsForUri(objectUri);
String url = urls[0];
if (hostName != null)
{
url = HttpChannelHelper.ReplaceMachineNameWithThisString(url, hostName);
}
types = new ServiceType[1];
types[0] = new ServiceType(objectType, url);
}
responseHeaders["Content-Type"] = "text/xml";
bool bMemStream = false;
outputStream = sinkStack.GetResponseStream(null, responseHeaders);
if (outputStream == null)
{
outputStream = new MemoryStream(1024);
bMemStream = true;
}
MetaData.ConvertTypesToSchemaToStream(types, sdlType, outputStream);
if (bMemStream)
{
outputStream.Position = 0;
}
} // GenerateXmlForUri
/// <summary>
/// Requests processing from the current sink of the response from a method call sent asynchronously.
/// </summary>
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack,
object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
throw new Exception("EncryptionServerSink does not support AsyncProcessResponse");
}
public virtual void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, System.Runtime.Remoting.Messaging.IMessage msg, ITransportHeaders headers, System.IO.Stream stream)
{
}
} // ProcessMessage
/// <include file='doc\SdlChannelSink.uex' path='docs/doc[@for="SdlChannelSink.AsyncProcessResponse"]/*' />
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
// We don't need to implement this because we never push ourselves to the sink
// stack.
} // AsyncProcessResponse
void IServerChannelSink.AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, System.Runtime.Remoting.Messaging.IMessage msg, ITransportHeaders headers, System.IO.Stream stream)
{
nextSink.AsyncProcessResponse(sinkStack, state, msg, headers, stream);
}
} // ProcessMessage
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
// We never push ourselves to the sink stack, so this won't be called.
throw new NotSupportedException();
} // AsyncProcessResponse
public Stream GetResponseStream(
IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers)
{
// it's not possible to directly access the stream
return null;
}
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
throw new NotSupportedException();
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
IpcServerHandler ipcServerHandler = null;
ipcServerHandler = (IpcServerHandler)state;
// send the response
ipcServerHandler.SendResponse(headers, stream);
//if (streamManager.CanServiceAnotherRequest())
// streamManager.BeginReadMessage();
//else
// streamManager.Close();
} // AsyncProcessResponse
} // AsyncProcessResponse
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers)
{
// We don't need to implement this because we never push ourselves
// to the sink stack.
throw new NotSupportedException();
} // GetResponseStream
} // ProcessMessage
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
// We don't need to implement this because we never push ourselves to the sink
// stack.
} // AsyncProcessResponse
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
// перенаправляем вызов следующему приемнику в цепи
sinkStack.AsyncProcessResponse(msg, headers, stream);
}
} // ShouldIntercept
private void GenerateSdl(SdlType sdlType,
IServerResponseChannelSinkStack sinkStack,
ITransportHeaders requestHeaders,
ITransportHeaders responseHeaders,
out Stream outputStream)
{
if (!MetadataEnabled)
throw new RemotingException(CoreChannel.GetResourceString("Remoting_MetadataNotEnabled"));
String requestUri = requestHeaders[CommonTransportKeys.RequestUri] as String;
String objectUri = HttpChannelHelper.GetObjectUriFromRequestUri(requestUri);
if (!RemoteApplicationMetadataEnabled &&
(String.Compare(objectUri, "RemoteApplicationMetadata.rem", StringComparison.OrdinalIgnoreCase) == 0))
throw new RemotingException(CoreChannel.GetResourceString("Remoting_RemoteApplicationMetadataNotEnabled"));
// If the host header is present, we will use this in the generated uri's
String hostName = (String)requestHeaders["Host"];
if (hostName != null)
{
// filter out port number if present
int index = hostName.IndexOf(':');
if (index != -1)
hostName = hostName.Substring(0, index);
}
ServiceType[] types = null;
if (String.Compare(objectUri, "RemoteApplicationMetadata.rem", StringComparison.OrdinalIgnoreCase) == 0)
{
// get the service description for all registered service types
ActivatedServiceTypeEntry[] activatedTypes =
RemotingConfiguration.GetRegisteredActivatedServiceTypes();
WellKnownServiceTypeEntry[] wellKnownTypes =
RemotingConfiguration.GetRegisteredWellKnownServiceTypes();
// determine total number of types
int typeCount = 0;
if (activatedTypes != null)
typeCount += activatedTypes.Length;
if (wellKnownTypes != null)
typeCount += wellKnownTypes.Length;
types = new ServiceType[typeCount];
// collect data
int co = 0;
if (activatedTypes != null)
{
foreach (ActivatedServiceTypeEntry entry in activatedTypes)
{
types[co++] = new ServiceType(entry.ObjectType, null);
}
}
if (wellKnownTypes != null)
{
foreach (WellKnownServiceTypeEntry entry in wellKnownTypes)
{
String[] urls = _receiver.GetUrlsForUri(entry.ObjectUri);
String url = urls[0];
if (hostName != null)
url = HttpChannelHelper.ReplaceMachineNameWithThisString(url, hostName);
types[co++] = new ServiceType(entry.ObjectType, url);
}
}
InternalRemotingServices.RemotingAssert(co == typeCount, "Not all types were processed.");
}
else
{
// get the service description for a particular object
Type objectType = RemotingServices.GetServerTypeForUri(objectUri);
if (objectType == null)
{
throw new RemotingException(
String.Format(
CultureInfo.CurrentCulture, "Object with uri '{0}' does not exist at server.",
objectUri));
}
String[] urls = _receiver.GetUrlsForUri(objectUri);
String url = urls[0];
if (hostName != null)
url = HttpChannelHelper.ReplaceMachineNameWithThisString(url, hostName);
types = new ServiceType[1];
types[0] = new ServiceType(objectType, url);
}
responseHeaders["Content-Type"] = "text/xml";
bool bMemStream = false;
outputStream = sinkStack.GetResponseStream(null, responseHeaders);
if (outputStream == null)
{
outputStream = new MemoryStream(1024);
bMemStream = true;
}
MetaData.ConvertTypesToSchemaToStream(types, sdlType, outputStream);
if (bMemStream)
outputStream.Position = 0;
} // GenerateXmlForUri
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers)
{
return(null);
}
Stream IServerChannelSink.GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers)
{
return(next.GetResponseStream(sinkStack, state, msg, headers));
}
public void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers, Stream stream)
{
sinkStack.AsyncProcessResponse(msg, headers, stream);
}
public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers)
{
// this method shouldn't be called
throw new NotSupportedException ();
}
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state,
IMessage msg, ITransportHeaders headers)
{
// this method shouldn't be called
throw new NotSupportedException();
}
public Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, Object state,
IMessage msg, ITransportHeaders headers)
{
// This should never get called since we're the last in the chain, and never
// push ourselves to the sink stack.
throw new NotSupportedException();
} // GetResponseStream
public void AsyncProcessResponse(
IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream)
{
throw new RemotingException("AsyncProcessRequest is not enabled yet");
}
