// Constructor.
		public SinkStackEntry(IServerChannelSink sink, Object state,
							  SinkStackEntry below)
				{
					this.sink = sink;
					this.state = state;
					this.below = below;
				}

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

 public BidirTcpServerTransportSink(IServerChannelSink nextSink, int port, String IPAddress)
 {
     _port = port;
     _IPAddress = IPAddress;
     _nextSink = nextSink;
     // StartListening();
 }

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

        /// <summary>Erstellt eine neue Instanz von CounterServerChannelSink.</summary>
        /// <param name="nextSink">Nächste Kanalsenke in der Senkenkette</param>
        public CounterServerChannelSink(IServerChannelSink nextSink)
        {
            //Lock objekt erstellen
            _lockObject = new object();

            // Nächste Kanalsenke übernehmen
            _next = nextSink;
        }

 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 ServerTransportSink(IServerChannelSink nextSink)
		{
			// parameters validation
			if (nextSink == null)
				throw new ArgumentNullException("nextSink");

			_nextSink = nextSink;
		}

        public IpFixServerChannelSink(IServerChannelSink nextSink, IEventLink eventLink)
        {
            if (nextSink == null) 
                throw new ArgumentNullException("nextSink");

            _nextSink = nextSink;
            _eventLink = eventLink;
        }

 /// <summary>
 /// Constructor with properties.
 /// </summary>
 /// <param name="nextSink">Next sink.</param>
 /// <param name="compressionThreshold">Compression threshold. If 0, compression is disabled globally.</param>
 public CompressionServerChannelSink(
     IServerChannelSink nextSink,
     int compressionThreshold)
 {
     // Set the next sink.
     _next = nextSink;
     // Set the compression threshold.
     _compressionThreshold = compressionThreshold;
 }

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

        public ServerFormatterSink(IWireFormatter formatter, IServerChannelSink nextSink)
        {
            // parameters validation
            if (formatter == null)
                throw new ArgumentNullException("formatter");
            if (nextSink == null)
                throw new ArgumentNullException("nextSink");

            _formatter = formatter;
            _nextSink = nextSink;
        }

		public CompressionServerSink(
			IServerChannelSink nextChannelSink_in,
			bool mustDo_in
		) {
#if DEBUG
			Console.WriteLine("initiating compression sink");
#endif

			this.mustdo_ = mustDo_in;
			this.nextchannelsink_ = nextChannelSink_in;
		} 

        public SecureServerChannelSink(IServerChannelSink nextSink, string algorithm, double connectionAgeLimit, double sweeperFrequency, bool requireSecurity)
        {
            _algorithm = algorithm;
            _connectionAgeLimit = connectionAgeLimit;
            _sweepFrequency = sweeperFrequency;
            _requireSecurity = requireSecurity;

            _next = nextSink;

            _connections = new Hashtable(103, 0.5F);
            StartConnectionSweeper();
        }

		public object Pop (IServerChannelSink sink)
		{
			// Pops until the sink is found

			while (_sinkStack != null)
			{
				ChanelSinkStackEntry stackEntry = _sinkStack;
				_sinkStack = _sinkStack.Next;
				if (stackEntry.Sink == sink) return stackEntry.State;
			}
			throw new RemotingException ("The current sink stack is empty, or the specified sink was never pushed onto the current stack");
		}

		public EncryptionServerSink(
			IServerChannelSink nextChannelSink_in,
			string keysPath_in, 
			bool mustDo_in
		) {
#if DEBUG
			Console.WriteLine("initiating encryption sink");
#endif

			keyspath_ = keysPath_in;
			mustdo_ = mustDo_in;
			nextchannelsink_ = nextChannelSink_in;
		} 

        /// <summary>
        /// Initializes a new instance of the <see cref="CryptoServerChannelSink"/> class.
        /// </summary>
        /// <param name="nextSink">The next sink.</param>
        /// <param name="algorithm">Symmetric encryption algorithm.</param>
        /// <param name="oaep">if set to <c>true</c>, OAEP padding is enabled.</param>
        /// <param name="connectionAgeLimit">Connection age limit.</param>
        /// <param name="sweeperFrequency">Connection sweeper frequency.</param>
        /// <param name="requireCryptoClient">if set to <c>true</c>, crypto client sink is required.</param>
        /// <param name="securityExemptionList">Security exemption list.</param>
        public CryptoServerChannelSink(IServerChannelSink nextSink, string algorithm, bool oaep, double connectionAgeLimit, double sweeperFrequency, bool requireCryptoClient, IPAddress[] securityExemptionList)
        {
            _algorithm = algorithm;
            _oaep = oaep;
            _connectionAgeLimit = connectionAgeLimit;
            _sweepFrequency = sweeperFrequency;
            _requireCryptoClient = requireCryptoClient;
            _securityExemptionList = securityExemptionList;
            _next = nextSink;
            _connections = new Hashtable(103, 0.5F);

            StartConnectionSweeper();
        }

 public object Pop(IServerChannelSink sink)
 {
     if (this._stack == null)
     {
         throw new RemotingException(Environment.GetResourceString("Remoting_Channel_PopOnEmptySinkStack"));
     }
 Label_0018:
     if (this._stack.Sink != sink)
     {
         this._stack = this._stack.PrevStack;
         if (this._stack != null)
         {
             goto Label_0018;
         }
     }
     if (this._stack.Sink == null)
     {
         throw new RemotingException(Environment.GetResourceString("Remoting_Channel_PopFromSinkStackWithoutPush"));
     }
     object state = this._stack.State;
     this._stack = this._stack.PrevStack;
     return state;
 }

        [System.Security.SecurityCritical]  // auto-generated 
        public void StoreAndDispatch(IServerChannelSink sink, Object state)
        {
            Store(sink, state);
            FlipRememberedStack(); 

            CrossContextChannel.DoAsyncDispatch(_asyncMsg, null); 
        } // Store 

        public BinaryServerFormatterSink(Protocol protocol, IServerChannelSink nextSink,
                                         IChannelReceiver receiver)
        {
            if (receiver == null)
                throw new ArgumentNullException("receiver");

            _nextSink = nextSink;
            _protocol = protocol;
            _receiver = receiver;            
        } // BinaryServerFormatterSinkProvider

        public Object Pop(IServerChannelSink sink)
        { 
            if (_stack == null)
            {
                throw new RemotingException(
                    Environment.GetResourceString("Remoting_Channel_PopOnEmptySinkStack")); 
            }
 
            // find this sink on the stack 
            do
            { 
                if (_stack.Sink == sink)
                    break;

                _stack = _stack.PrevStack; 
            } while (_stack != null);
 
            if (_stack.Sink == null) 
            {
                throw new RemotingException( 
                    Environment.GetResourceString("Remoting_Channel_PopFromSinkStackWithoutPush"));
            }

            Object state = _stack.State; 
            _stack = _stack.PrevStack;
 
            return state; 
        } // Pop