public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink nextSink = null;
     if (nextProvider != null)
         nextSink = nextProvider.CreateSink(channel);
     return new ServerAuthenticationSink(nextSink, secMgr, contexts);
 }

        public void Start(Channel channel)
        {
            channelReceiver = (IChannelReceiver)builder.Build(channel.Receiver);

            channelReceiver.DataReceived += DataReceivedOnChannel;
            channelReceiver.Start(channel.ReceiveAddress, channel.NumWorkerThreads);
        }

 /// <include file='doc\SdlChannelSink.uex' path='docs/doc[@for="SdlChannelSinkProvider.CreateSink"]/*' />
 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink nextSink = null;
     if (_next != null)
         nextSink = _next.CreateSink(channel);
     return new SdlChannelSink(channel, nextSink);
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink nextSink = null;
     if (this.m_NextProvider != null)
     {
         nextSink = this.m_NextProvider.CreateSink(channel);
     }
     IPFilterChannelSink sink2 = new IPFilterChannelSink(this.m_IsAccept, nextSink);
     foreach (SinkProviderData data in this.m_ProviderData)
     {
         string ipString = (string) data.Properties["mask"];
         string str2 = (string) data.Properties["ip"];
         string hostName = (string) data.Properties["machine"];
         IPAddress mask = null;
         IPAddress ip = null;
         if (str2 != null)
         {
             mask = IPAddress.Parse(ipString);
             ip = IPAddress.Parse(str2);
         }
         else
         {
             mask = IPAddress.Parse("255.255.255.255");
             ip = Dns.Resolve(hostName).AddressList[0];
         }
         sink2.AddFilter(mask, ip);
     }
     return sink2;
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink sink = null;
     if (Next != null)
         sink = Next.CreateSink(channel);
     return new WebServerChannelSink(sink, channel, _webServer);
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink nextSink = null;
     if(next != null)
         nextSink = next.CreateSink(channel);
     return new MethodRestrictionServerSink(this, nextSink);
 }

		public SoapServerFormatterSink (SoapServerFormatterSink.Protocol protocol,
						IServerChannelSink nextSink,
						IChannelReceiver receiver)
		{
			this.next_sink = nextSink;
			_receiver = receiver;
		}

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink scs = null;
     if (Next != null)
         scs = Next.CreateSink(channel);
     return new XmlRpcServerFormatterSink(scs);
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink sink = null;
     if (Next != null)
         sink = Next.CreateSink(channel);
     return new XmlRpcServerChannelSink(sink);
 }

		public BinaryServerFormatterSink (BinaryServerFormatterSink.Protocol protocol,
						  IServerChannelSink nextSink,
						  IChannelReceiver receiver)
		{
			this.protocol = protocol;
			this.next_sink = nextSink;
			this.receiver = receiver;
		}

        public IServerChannelSink CreateSink(IChannelReceiver channel)
        {
            IServerChannelSink nextSink = null;

            if (_nextProvider != null)
                nextSink = _nextProvider.CreateSink(channel);
            return new IpFixServerChannelSink(nextSink, _eventLink);
        }

 public HathiServerChannelSink(IServerChannelSinkProvider Provider, IChannelReceiver channel)
 {
     IServerChannelSink nextServer = (IServerChannelSink)new BinaryServerFormatterSink(
                                                                         BinaryServerFormatterSink.Protocol.Other, this.NextChannelSink, channel);
     if (channel != null) m_channel = channel;
     if (Provider != null) m_Provider = Provider as HathiServerSinkProvider;
     m_NextIServerChannelSink = new HathiServerChannelSink(Provider, channel, nextServer);
 }

		public IServerChannelSink CreateSink (IChannelReceiver channel)
		{
			IServerChannelSink chain = _next.CreateSink(channel);
			SoapServerFormatterSink sinkFormatter = new SoapServerFormatterSink(SoapServerFormatterSink.Protocol.Http, chain, channel);
			sinkFormatter.SoapCore = _soapCore;
			
			return sinkFormatter;
		}

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink next = null;
     if (this._nextProvider != null)
     {
         next = this._nextProvider.CreateSink(channel);
     }
     return new ClientIPServerSink(next);
 }

		public IServerChannelSink CreateSink(
			IChannelReceiver channel_in
		) {
			return new ClientIPAddressServerSink(
				this.next_.CreateSink(
					channel_in
				)
			);
		}

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink nextSink = null;
     if (_nextProvider != null)
     {
         nextSink = _nextProvider.CreateSink(channel);
     }
     return new ClientAddressServerChannelSink(nextSink);
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink next = null;
     if (this.m_NextProvider != null)
     {
         next = this.m_NextProvider.CreateSink(channel);
     }
     return new PrincipalServerSink(next);
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     IServerChannelSink nextSink = null;
     if (this._next != null)
     {
         nextSink = this._next.CreateSink(channel);
     }
     return new SdlChannelSink(channel, nextSink) { RemoteApplicationMetadataEnabled = this._bRemoteApplicationMetadataEnabled, MetadataEnabled = this._bMetadataEnabled };
 }

 public IServerChannelSink CreateSink(IChannelReceiver channel)
 {
     if (this.Next != null)
     {
         var nextChannelSink = Next.CreateSink(channel);
         if (nextChannelSink != null)
             return new JsonServerFormatterSink(nextChannelSink);
     }
     return null;
 }

 public SoapServerFormatterSink(Protocol protocol, IServerChannelSink nextSink, IChannelReceiver receiver)
 {
     if (receiver == null)
     {
         throw new ArgumentNullException("receiver");
     }
     this._nextSink = nextSink;
     this._protocol = protocol;
     this._receiver = receiver;
 }