void Init(IServerChannelSinkProvider serverSinkProvider)
{
if (serverSinkProvider == null)
{
serverSinkProvider = new UnixBinaryServerFormatterSinkProvider();
}
// Gets channel data from the chain of channel providers
channel_data = new ChannelDataStore(null);
IServerChannelSinkProvider provider = serverSinkProvider;
while (provider != null)
{
provider.GetChannelData(channel_data);
provider = provider.Next;
}
// Creates the sink chain that will process all incoming messages
IServerChannelSink next_sink = ChannelServices.CreateServerChannelSinkChain(serverSinkProvider, this);
sink = new UnixServerTransportSink(next_sink);
StartListening(null);
}
private void InitializeWithFormatters(IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)
{
ClientSinkProvider = clientSinkProvider = clientSinkProvider ?? new BinaryClientFormatterSinkProvider();
serverSinkProvider = serverSinkProvider ?? new BinaryServerFormatterSinkProvider {
TypeFilterLevel = TypeFilterLevel.Full
};
// add our client sink provider to the end of ClientSinkProvider chain
while (clientSinkProvider.Next != null)
{
clientSinkProvider = clientSinkProvider.Next;
}
clientSinkProvider.Next = new NullClientChannelSink.Provider();
// collect channel data
var provider = serverSinkProvider;
while (provider.Next != null)
{
provider.GetChannelData(ChannelDataStore);
provider = provider.Next;
}
// create server sink chain
var nextSink = ChannelServices.CreateServerChannelSinkChain(serverSinkProvider, this);
ServerSink = new NullServerChannelSink(nextSink);
}
internal void InitProviders(IServerChannelSinkProvider serverProviderChain)
{
_listener = null;
_event = new AutoResetEvent(false);
_data = new ChannelDataStore(null);
_data.ChannelUris = new String[1];
_data.ChannelUris[0] = ChannelScheme + "://" + m_pipeName;
_serverSinkProvider = serverProviderChain;
// Create the default sink chain if one was not passed in
if (_serverSinkProvider == null)
{
_serverSinkProvider = CreateDefaultServerProviderChain();
}
;
// Collect the rest of the channel data:
IServerChannelSinkProvider provider = _serverSinkProvider;
while (provider != null)
{
provider.GetChannelData(_data);
provider = provider.Next;
}
IServerChannelSink next = ChannelServices.CreateServerChannelSinkChain(_serverSinkProvider, this);
_transportSink = new PipeServerTransportSink(next);
StartListening(null);
}
private void SetupChannel()
{
this._channelData = new ChannelDataStore(null);
if (this._port > 0)
{
string channelUri = this.GetChannelUri();
this._channelData.ChannelUris = new string[] { channelUri };
this._wantsToListen = false;
}
if (this._sinkProvider == null)
{
this._sinkProvider = this.CreateDefaultServerProviderChain();
}
CoreChannel.CollectChannelDataFromServerSinkProviders(this._channelData, this._sinkProvider);
this._sinkChain = ChannelServices.CreateServerChannelSinkChain(this._sinkProvider, this);
this._transportSink = new HttpServerTransportSink(this._sinkChain);
base.SinksWithProperties = this._sinkChain;
if (this._port >= 0)
{
this._tcpListener = new ExclusiveTcpListener(this._bindToAddr, this._port);
ThreadStart start = new ThreadStart(this.Listen);
this._listenerThread = new Thread(start);
this._listenerThread.IsBackground = true;
this.StartListening(null);
}
}
private void SetupChannel()
{
if (this.authSet && !this._secure)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_AuthenticationConfigServer"));
}
this._channelData = new ChannelDataStore(null);
if (this._port > 0)
{
this._channelData.ChannelUris = new string[] { this.GetChannelUri() };
}
if (this._sinkProvider == null)
{
this._sinkProvider = this.CreateDefaultServerProviderChain();
}
CoreChannel.CollectChannelDataFromServerSinkProviders(this._channelData, this._sinkProvider);
IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(this._sinkProvider, this);
this._transportSink = new TcpServerTransportSink(nextSink, this._impersonate);
this._acceptSocketCallback = new AsyncCallback(this.AcceptSocketCallbackHelper);
if (this._port >= 0)
{
this._tcpListener = new ExclusiveTcpListener(this._bindToAddr, this._port);
this.StartListening(null);
}
}
void Init(IServerChannelSinkProvider provider)
{
if (provider == null)
{
provider = new SimpleServerFormatterSinkProvider();
}
IServerChannelSink next_sink = ChannelServices.CreateServerChannelSinkChain(provider, this);
host = Dns.GetHostByName(Dns.GetHostName()).HostName;
string [] uris = null;
if (port != 0)
{
uris = new String [1];
uris [0] = GetChannelUri();
}
channel_data = new ChannelDataStore(uris);;
sink = new SimpleServerTransportSink(next_sink);
listener = new TcpListener(port);
StartListening(null);
}
void Init(IServerChannelSinkProvider serverSinkProvider)
{
if (serverSinkProvider == null)
{
serverSinkProvider = new BinaryServerFormatterSinkProvider();
}
if (host == null)
{
if (useIpAddress)
{
if (!bindAddress.Equals(IPAddress.Any))
{
host = bindAddress.ToString();
}
else
{
IPHostEntry he = Dns.Resolve(Dns.GetHostName());
if (he.AddressList.Length == 0)
{
throw new RemotingException("IP address could not be determined for this host");
}
AddressFamily addressFamily = (Socket.SupportsIPv4) ? AddressFamily.InterNetwork : AddressFamily.InterNetworkV6;
IPAddress addr = GetMachineAddress(he, addressFamily);
if (addr != null)
{
host = addr.ToString();
}
else
{
host = he.AddressList [0].ToString();
}
}
}
else
{
host = Dns.GetHostByName(Dns.GetHostName()).HostName;
}
}
// Gets channel data from the chain of channel providers
channel_data = new ChannelDataStore(null);
IServerChannelSinkProvider provider = serverSinkProvider;
while (provider != null)
{
provider.GetChannelData(channel_data);
provider = provider.Next;
}
// Creates the sink chain that will process all incoming messages
IServerChannelSink next_sink = ChannelServices.CreateServerChannelSinkChain(serverSinkProvider, this);
sink = new TcpServerTransportSink(next_sink);
StartListening(null);
}
/// <summary>
/// Creates a server channel.
/// </summary>
/// <param name="properties">The channel properties.</param>
/// <param name="provider">The sink provider.</param>
public IpcServerChannel(IDictionary properties, IServerChannelSinkProvider provider)
{
bool impersonate = false;
if (properties != null)
{
foreach (DictionaryEntry e in properties)
{
switch ((string)e.Key)
{
case "name":
channelName = (string)e.Value;
break;
case "priority":
channelPriority = Convert.ToInt32(e.Value);
break;
case "portName":
portName = (string)e.Value;
if (!IpcChannelHelper.IsValidPipeName(portName))
{
throw new ArgumentException("Invalid pipe name.", "portName");
}
break;
case "impersonate":
impersonate = Boolean.Parse((string)e.Value);
break;
}
}
}
if (portName == null)
{
portName = Guid.NewGuid().ToString("N");
}
serverProvider = provider;
if (serverProvider == null)
{
serverProvider = new BinaryServerFormatterSinkProvider();
}
dataStore = new ChannelDataStore(
new string[] { IpcChannelHelper.SchemeStart + portName }
);
PopulateChannelData(dataStore, serverProvider);
sink = new IpcServerChannelSink(
ChannelServices.CreateServerChannelSinkChain(serverProvider, this),
portName,
impersonate
);
StartListening(null);
}
private void Init(IServerChannelSinkProvider serverSinkProvider)
{
if (serverSinkProvider == null)
{
serverSinkProvider = new UnixBinaryServerFormatterSinkProvider();
}
this.channel_data = new ChannelDataStore(null);
for (IServerChannelSinkProvider i = serverSinkProvider; i != null; i = i.Next)
{
i.GetChannelData(this.channel_data);
}
this.sink = new UnixServerTransportSink(ChannelServices.CreateServerChannelSinkChain(serverSinkProvider, this));
this.StartListening(null);
}
public BidirTcpServerChannel(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)
{
_name = (String)properties["name"];
if (_name == null)
{
_name = "BidirTcpServer";
}
_port = int.Parse((String)properties["port"]);
String[] urls = { this.GetURLBase() };
// needed for CAOs!
_channelData = new ChannelDataStore(urls);
String IPAddress = Helper.GetIPAddress();
if (serverSinkProvider == null)
{
serverSinkProvider = new BinaryServerFormatterSinkProvider();
}
if (_clientProvider == null)
{
_clientProvider = new BinaryClientFormatterSinkProvider();
}
_sinkProvider = serverSinkProvider;
// collect channel data from all providers
IServerChannelSinkProvider provider = _sinkProvider;
while (provider != null)
{
provider.GetChannelData(_channelData);
provider = provider.Next;
}
// create the sink chain
IServerChannelSink snk =
ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this);
// add the BidirTcpServerTransportSink as a first element to the chain
_transportSink = new BidirTcpServerTransportSink(snk, _port, IPAddress);
MessageHandler.RegisterServer(_transportSink, Helper.GetIPAddress() + ":" + _port);
MessageHandler.RegisterServer(_transportSink, Helper.GetMyGUID().ToString());
// start to listen
this.StartListening(null);
}
/// <summary>
/// Constructs an instance of the BasicChannelWithSecurity class.
/// </summary>
/// <param name="properties">Channel properties.</param>
protected void InitializeInstance(IDictionary properties)
{
// properties
if (properties == null)
{
this._properties = new Hashtable();
}
else
{
this._properties = properties;
}
this.ReadSettings(properties);
// create default client formatter sink
if (this._iClientChannelSinkProvider == null)
{
this._iClientChannelSinkProvider = new BinaryClientFormatterSinkProvider();
}
// connect client sink provider to the end
IClientChannelSinkProvider currentProvider = this._iClientChannelSinkProvider;
while (currentProvider.Next != null)
{
currentProvider = currentProvider.Next;
}
currentProvider.Next = new GenuineTcpClientTransportSinkProvider(this.ITransportContext);
// create default server formatter sink
if (this._iServerChannelSinkProvider == null)
{
this._iServerChannelSinkProvider = GenuineUtility.GetDefaultServerSinkChain();
}
// collect sink providers' cookies
IServerChannelSinkProvider sinkProvider = this._iServerChannelSinkProvider;
while (sinkProvider != null)
{
sinkProvider.GetChannelData((IChannelDataStore)this.ChannelData);
sinkProvider = sinkProvider.Next;
}
// register channel sink
this._iServerChannelSink = new GenuineUniversalServerTransportSink(this, ChannelServices.CreateServerChannelSinkChain(this._iServerChannelSinkProvider, this),
this.ITransportContext);
}
void SetupServerSinkChain(IServerChannelSinkProvider providerChain)
{
// collect channel data
var provider = providerChain;
while (provider != null)
{
provider.GetChannelData(ChannelDataStore);
provider = provider.Next;
}
// setup server sink chain
var next = ChannelServices.CreateServerChannelSinkChain(providerChain, this);
ServerChannelSink = new UdpServerChannelSink(next);
}
} // SetupMachineName
private void SetupChannel()
{
// set channel data
// (These get changed inside of StartListening(), in the case where the listen
// port is 0, because we can't determine the port number until after the
// TcpListener starts.)
_channelData = new ChannelDataStore(null);
if (_port > 0)
{
String channelUri = GetChannelUri();
_channelData.ChannelUris = new String[1];
_channelData.ChannelUris[0] = channelUri;
_wantsToListen = false;
}
// set default provider (soap formatter) if no provider has been set
if (_sinkProvider == null)
{
_sinkProvider = CreateDefaultServerProviderChain();
}
CoreChannel.CollectChannelDataFromServerSinkProviders(_channelData, _sinkProvider);
// construct sink chain
_sinkChain = ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this);
_transportSink = new HttpServerTransportSink(_sinkChain);
// set sink properties on base class, so that properties will be chained.
SinksWithProperties = _sinkChain;
if (_port >= 0)
{
// Open a TCP port and create a thread to start listening
_tcpListener = new ExclusiveTcpListener(_bindToAddr, _port);
ThreadStart t = new ThreadStart(this.Listen);
_listenerThread = new Thread(t);
_listenerThread.IsBackground = true;
// Wait for thread to spin up
StartListening(null);
}
} // SetupChannel
} // SetupMachineName
private void SetupChannel()
{
// set channel data
// (These get changed inside of StartListening(), in the case where the listen
// port is 0, because we can't determine the port number until after the
// TcpListener starts.)
if (authSet && !_secure)
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_AuthenticationConfigServer"));
}
_channelData = new ChannelDataStore(null);
if (_port > 0)
{
_channelData.ChannelUris = new String[1];
_channelData.ChannelUris[0] = GetChannelUri();
}
// set default provider (soap formatter) if no provider has been set
if (_sinkProvider == null)
{
_sinkProvider = CreateDefaultServerProviderChain();
}
CoreChannel.CollectChannelDataFromServerSinkProviders(_channelData, _sinkProvider);
// construct sink chain
IServerChannelSink sink = ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this);
_transportSink = new TcpServerTransportSink(sink, _impersonate);
// Initialize the accept socket callback
_acceptSocketCallback = new AsyncCallback(AcceptSocketCallbackHelper);
if (_port >= 0)
{
// Open a TCP port and create a thread to start listening
_tcpListener = new ExclusiveTcpListener(_bindToAddr, _port);
// Wait for thread to spin up
StartListening(null);
}
} // SetupChannel
private void Initialize(IDictionary properties, IServerChannelSinkProvider sinkProvider)
{
if (properties != null)
{
// read property values
foreach (DictionaryEntry property in properties)
{
switch ((string)property.Key)
{
case "name": _channelName = Convert.ToString(property.Value); break;
case "priority": _channelPriority = Convert.ToInt32(property.Value); break;
case "pipe": _pipe = Convert.ToString(property.Value); break;
case "securityDescriptor": _securityDescriptor = (property.Value as SecurityDescriptor); break;
}
}
}
// setup pipe name
_pipeName = new PipeName(@"\\.\pipe\" + _pipe);
// create the chain of the sink providers that will process all messages
_sinkProvider = ChannelHelper.ServerChannelCreateSinkProviderChain(sinkProvider);
_channelData = ChannelHelper.ServerChannelCreateDataStore(ChannelUri, _sinkProvider);
// create transport sink
IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this);
_transportSink = new ServerTransportSink(nextSink);
// create listener thread
_transportListener = new TransportListener(ChannelUri, typeof(PipeTransport));
_listenerThread = new Thread(new ThreadStart(ListenerStart));
_listenerThread.IsBackground = true;
_requestHandler = new ProcessRequestCallback(_transportSink.ProcessRequest);
// start listening on the channel
StartListening(null);
}
private void Initialise(TypeFilterLevel typeFilterLevel, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider, int port, bool listen, bool keepAlive, ulong keepAliveTime, ulong KeepAliveInterval, short maxRetries, int retryDelay, IPAddress bindToAddress)
{
_tcpKeepAliveEnabled = keepAlive;
_tcpKeepAliveTime = keepAliveTime;
_tcpKeepAliveInterval = KeepAliveInterval;
_maxRetries = maxRetries;
_retryDelay = retryDelay;
_bindToAddress = bindToAddress;
if (clientSinkProvider == null)
{
clientSinkProvider = new BinaryClientFormatterSinkProvider();
}
if (serverSinkProvider == null)
{
Trace.WriteLine("Setting serialization filter: {0}", typeFilterLevel);
BinaryServerFormatterSinkProvider tempProvider = new BinaryServerFormatterSinkProvider();
tempProvider.TypeFilterLevel = typeFilterLevel;
serverSinkProvider = tempProvider;
}
// Initialise clientSinkProvider
this.clientSinkProvider = clientSinkProvider;
while (clientSinkProvider.Next != null)
{
clientSinkProvider = clientSinkProvider.Next;
}
clientSinkProvider.Next = new ClientTransportSinkProvider();
messageSink = new ServerTransportSink(ChannelServices.CreateServerChannelSinkChain(serverSinkProvider, this));
serverSinkProvider.GetChannelData(channelData);
if (listen)
{
StartListening(port);
}
channelData = new TcpExChannelData(this);
Manager.BeginReadMessage(_channelID, null, new AsyncCallback(messageSink.ReceiveMessage), _channelID);
}
private void SetupChannel()
{
// set channel data
// (These get changed inside of StartListening(), in the case where the listen
// port is 0, because we can't determine the port number until after the
// IpcListener starts.)
if (authSet && !_secure)
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Ipc_AuthenticationConfig"));
}
_channelData = new ChannelDataStore(null);
_channelData.ChannelUris = new String[1];
_channelData.ChannelUris[0] = GetChannelUri();
// set default provider (soap formatter) if no provider has been set
if (_sinkProvider == null)
{
_sinkProvider = CreateDefaultServerProviderChain();
}
CoreChannel.CollectChannelDataFromServerSinkProviders(_channelData, _sinkProvider);
// construct sink chain
IServerChannelSink sink = ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this);
_transportSink = new IpcServerTransportSink(sink, _secure, _impersonate);
// Start a thread to listen for incoming requests
ThreadStart t = new ThreadStart(this.Listen);
_listenerThread = new Thread(t);
_listenerThread.IsBackground = true;
// Wait for thread to spin up
StartListening(null);
} // SetupChannel
private void SetupChannel()
{
if (this.authSet && !this._secure)
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Ipc_AuthenticationConfig"));
}
this._channelData = new ChannelDataStore(null);
this._channelData.ChannelUris = new string[] { this.GetChannelUri() };
if (this._sinkProvider == null)
{
this._sinkProvider = this.CreateDefaultServerProviderChain();
}
CoreChannel.CollectChannelDataFromServerSinkProviders(this._channelData, this._sinkProvider);
IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(this._sinkProvider, this);
this._transportSink = new IpcServerTransportSink(nextSink, this._secure, this._impersonate);
ThreadStart start = new ThreadStart(this.Listen);
this._listenerThread = new Thread(start);
this._listenerThread.IsBackground = true;
this.StartListening(null);
}
void Init(IServerChannelSinkProvider provider)
{
if (!_e.Incoming)
{
throw new InvalidOperationException("Non-listening Endpoint passed to IceServerChannel");
}
if (!(_e is TcpEndpoint))
{
throw new NotSupportedException("Only TcpEndpoints are supported as servers (for now)");
}
if (provider == null)
{
provider = new IceServerFormatterSinkProvider();
}
IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(provider, this);
TcpEndpoint te = _e as TcpEndpoint;
string[] uris = null;
if (te.port != 0)
{
uris = new string[1];
uris[0] = "ice://" + te.host + ":" + te.port;
}
_channelData = new ChannelDataStore(uris);
_channelData["__iceEndpoint"] = _e;
_sink = new IceServerTransportSink(nextSink);
// _listener = new TcpListener (te.IPAddress, te.port);
_listener = new TcpListener(IPAddress.Any, te.port);
_listenerThread = null;
StartListening(null);
}
public BidirTcpClientChannel(IDictionary properties, IClientChannelSinkProvider clientSinkProvider, IServerChannelSinkProvider serverSinkProvider)
{
_properties = properties;
_provider = clientSinkProvider;
_name = (String)_properties["name"];
String[] urls = { this.GetURLBase() };
// needed for CAOs!
_channelData = new ChannelDataStore(urls);
if (_provider == null)
{
_provider = new BinaryClientFormatterSinkProvider();
}
if (serverSinkProvider == null)
{
serverSinkProvider = new BinaryServerFormatterSinkProvider();
}
// collect additional channel data from all providers
IServerChannelSinkProvider prov = serverSinkProvider;
while (prov != null)
{
prov.GetChannelData(_channelData);
prov = prov.Next;
}
// create the sink chain
IServerChannelSink snk =
ChannelServices.CreateServerChannelSinkChain(serverSinkProvider, this);
// add the BidirTcpServerTransportSink as a first element to the chain
_serverSink = new BidirTcpServerTransportSink(snk);
MessageHandler.RegisterServer(_serverSink, Helper.GetMyGUID().ToString());
}
void BuildSink(IServerChannelSinkProvider sinkProvider)
{
//resolve names (modified from TcpChannel)
if (machineName == null)
{
if (useIPAddress)
{
if (!bindAddress.Equals(IPAddress.Any))
{
machineName = bindAddress.ToString();
}
else
{
IPHostEntry hostEntry = Dns.Resolve(Dns.GetHostName());
if (hostEntry.AddressList.Length == 0)
{
throw new RemotingException("IP address could not be determined for this host");
}
// We DON'T want to take the resolved address from the hostEntry, since the socket
// should still bind to IPAddress.Any, so that we get the loopback too
machineName = hostEntry.AddressList[0].ToString();
}
}
else
{
IPHostEntry hostEntry = Dns.GetHostByName(Dns.GetHostName());
bindAddress = hostEntry.AddressList[0];
machineName = hostEntry.HostName;
}
}
if (sinkProvider == null)
{
//build a default chain that can handle wsdl, soap, binary
sinkProvider = new SdlChannelSinkProvider(); //for wsdl
sinkProvider.Next = new SoapServerFormatterSinkProvider();
sinkProvider.Next.Next = new BinaryServerFormatterSinkProvider();
}
//MS compat: channelData is null when port < 0
if (port >= 0)
{
channelData = new ChannelDataStore(null);
IServerChannelSinkProvider provider = sinkProvider;
while (provider != null)
{
provider.GetChannelData(channelData);
provider = provider.Next;
}
}
//create the sink chain and add an HTTP sink
IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(sinkProvider, this);
sink = new HttpServerTransportSink(nextSink);
// BaseChannelWithProperties wants this to be set with the chain
base.SinksWithProperties = nextSink;
StartListening(null);
}
} // SetupChannel
/// <summary>
/// Configures the ProtocolSinkStack to communicate received messages with the
/// Remoting infrastructure.
/// </summary>
private void SetupServerChannel()
{
IServerChannelSink sink = ChannelServices.CreateServerChannelSinkChain(null, this);
prot_stack.NextChannelSink = sink;
}
public Receiver(IDictionary properties, IServerChannelSinkProvider serverSinkProvider)
{
// administratively setup using the config values
// static knowledge base
ChannelName = properties.Contains(MSMQChannelProperties.ChannelName) ?
Convert.ToString(properties[MSMQChannelProperties.ChannelName]) : MSMQChannelDefaults.ChannelName;
ChannelPriority = properties.Contains(MSMQChannelProperties.ChannelPriority) ?
Convert.ToInt32(properties[MSMQChannelProperties.ChannelPriority]) : MSMQChannelDefaults.ChannelPriority;
ListenerPath = properties.Contains(MSMQChannelProperties.Listener) ?
Convert.ToString(properties[MSMQChannelProperties.Listener]) : MSMQChannelDefaults.QueuePath;
AllowToUpdate = properties.Contains(MSMQChannelProperties.UpdateKB) ?
Convert.ToBoolean(properties[MSMQChannelProperties.UpdateKB]) : MSMQChannelDefaults.CanBeUpdated;
// dynamically knowledge base
NotifyTime = properties.Contains(MSMQChannelProperties.NotifyTime) ?
Convert.ToInt32(properties[MSMQChannelProperties.NotifyTime]) : MSMQChannelDefaults.TimeoutInSec;
RetryTime = properties.Contains(MSMQChannelProperties.RetryTime) ?
Convert.ToInt32(properties[MSMQChannelProperties.RetryTime]) : MSMQChannelDefaults.TimeoutInSec;
RetryCounter = properties.Contains(MSMQChannelProperties.Retry) ?
Convert.ToInt32(properties[MSMQChannelProperties.Retry]) : MSMQChannelDefaults.RetryCounter;
RetryFilter = properties.Contains(MSMQChannelProperties.RetryFilter) ?
Convert.ToString(properties[MSMQChannelProperties.RetryFilter]) : MSMQChannelDefaults.EmptyStr;
NotifyUrl = properties.Contains(MSMQChannelProperties.NotifyUrl) ?
Convert.ToString(properties[MSMQChannelProperties.NotifyUrl]) : MSMQChannelDefaults.EmptyStr;
AcknowledgeUrl = properties.Contains(MSMQChannelProperties.AckUrl) ?
Convert.ToString(properties[MSMQChannelProperties.AckUrl]) : MSMQChannelDefaults.EmptyStr;
ExceptionUrl = properties.Contains(MSMQChannelProperties.ExceptionUrl) ?
Convert.ToString(properties[MSMQChannelProperties.ExceptionUrl]) : MSMQChannelDefaults.EmptyStr;
UseTimeout = properties.Contains(MSMQChannelProperties.UseTimeout) ?
Convert.ToBoolean(properties[MSMQChannelProperties.UseTimeout]) : MSMQChannelDefaults.UseTimeout;
// validate number of threads
MaxNumberOfWorkers = MSMQChannelDefaults.MaxThreads;
if (properties.Contains(MSMQChannelProperties.MaxThreads))
{
string maxthreads = Convert.ToString(properties[MSMQChannelProperties.MaxThreads]);
Update(MSMQChannelProperties.MaxThreads, maxthreads);
}
// channel provider
m_Provider = serverSinkProvider == null ? new BinaryServerFormatterSinkProvider() : serverSinkProvider;
/*
* // Collect the rest of the channel data:
* IServerChannelSinkProvider provider = m_Provider;
* while(provider != null)
* {
* provider.GetChannelData(_data);
* provider = provider.Next;
* }
*/
IServerChannelSink next = ChannelServices.CreateServerChannelSinkChain(m_Provider, this);
m_Sink = new MSMQServerTransportSink(next);
// publish the MSMQChannel endpoint using the channel name.
base.Publish(ChannelName);
// start Listener
StartListening(null);
}
private void Initialize(IDictionary properties, IServerChannelSinkProvider sinkProvider)
{
if (properties != null)
{
// read property values
foreach (DictionaryEntry property in properties)
{
switch ((string)property.Key)
{
case "name": _channelName = Convert.ToString(property.Value); break;
case "priority": _channelPriority = Convert.ToInt32(property.Value); break;
case "port": _port = Convert.ToInt32(property.Value); break;
case "bindTo": _bindToAddr = IPAddress.Parse(Convert.ToString(property.Value)); break;
case "machineName": _machineName = Convert.ToString(property.Value); break;
case "useIpAddress": _useIpAddress = Convert.ToBoolean(property.Value); break;
case "rejectRemoteRequests": if (Convert.ToBoolean(property.Value))
{
_bindToAddr = IPAddress.Loopback;
}
break;
}
}
}
if (_machineName == null)
{
// setup machine name
if (_useIpAddress)
{
if (_bindToAddr == IPAddress.Any)
{
_machineName = NetHelper.GetMachineIp();
}
else
{
_machineName = _bindToAddr.ToString();
}
}
else
{
_machineName = NetHelper.GetMachineName();
}
}
// create the chain of the sink providers that will process all messages
_sinkProvider = ChannelHelper.ServerChannelCreateSinkProviderChain(sinkProvider);
_channelData = ChannelHelper.ServerChannelCreateDataStore(ChannelUri, _sinkProvider);
// create transport sink
IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this);
_transportSink = new ServerTransportSink(nextSink);
// create listener thread
_transportListener = new TransportListener(ListenerUri, typeof(TcpTransport));
_listenerThread = new Thread(new ThreadStart(ListenerStart));
_listenerThread.IsBackground = true;
_requestHandler = new ProcessRequestCallback(_transportSink.ProcessRequest);
// start listening on the channel
StartListening(null);
}
