internal void ReceiveKerberos(Object threadContext) { try { _AuthStream.BeginRead(_buff, 0, _buff.Length, myReceiveKerberosCallback, _AuthStream); } catch { StreamIsConnected = false; Stop(); if (_rbr2 != null) { _rbr2.Close(); } if (_rbr2 != null) { _rbr2 = null; } if (_rms2 != null) { _rms2.Dispose(); } if (_buff != null) { _buff = null; } } }
public static void AuthenticateClient(TcpClient client) { var networkStream = client.GetStream(); // Create the NegotiateStream. var negotiateStream = new NegotiateStream(networkStream, false); // Combine client and NegotiateStream instance into ClientState. var clientState = new ClientState(negotiateStream, client); // Listen for the client authentication request. negotiateStream.BeginAuthenticateAsServer( EndAuthenticateCallback, clientState ); // Wait until the authentication completes. clientState.Waiter.WaitOne(); clientState.Waiter.Reset(); // Receive encoded message sent by client. negotiateStream.BeginRead( clientState.Buffer, 0, clientState.Buffer.Length, EndReadCallback, clientState); clientState.Waiter.WaitOne(); // Close stream and client. negotiateStream.Close(); client.Close(); }
//<snippet1> public static void AuthenticateClient(TcpClient clientRequest) { NetworkStream stream = clientRequest.GetStream(); // Create the NegotiateStream. NegotiateStream authStream = new NegotiateStream(stream, false); // Save the current client and NegotiateStream instance // in a ClientState object. ClientState cState = new ClientState(authStream, clientRequest); // Listen for the client authentication request. authStream.BeginAuthenticateAsServer( new AsyncCallback(EndAuthenticateCallback), cState ); // Wait until the authentication completes. cState.Waiter.WaitOne(); cState.Waiter.Reset(); authStream.BeginRead(cState.Buffer, 0, cState.Buffer.Length, new AsyncCallback(EndReadCallback), cState); cState.Waiter.WaitOne(); // Finished with the current client. authStream.Close(); clientRequest.Close(); }
/// <summary> /// Extends BeginRead so that when a state object is not needed, null does not need to be passed. /// <example> /// negotiatestream.BeginRead(buffer, offset, count, asyncCallback); /// </example> /// </summary> public static IAsyncResult BeginRead(this NegotiateStream negotiatestream, Byte[] buffer, Int32 offset, Int32 count, AsyncCallback asyncCallback) { if (negotiatestream == null) { throw new ArgumentNullException("negotiatestream"); } return(negotiatestream.BeginRead(buffer, offset, count, asyncCallback, null)); }
/// <summary> /// Extends BeginRead so that buffer offset of 0 and call to Array.Length are not needed. /// <example> /// negotiatestream.BeginRead(buffer, asyncCallback); /// </example> /// </summary> public static IAsyncResult BeginRead(this NegotiateStream negotiatestream, Byte[] buffer, AsyncCallback asyncCallback) { if (negotiatestream == null) { throw new ArgumentNullException("negotiatestream"); } if (buffer == null) { throw new ArgumentNullException("buffer"); } return(negotiatestream.BeginRead(buffer, 0, buffer.Length, asyncCallback)); }
public async Task NegotiateStream_ConcurrentAsyncReadOrWrite_ThrowsNotSupportedException() { byte[] recvBuf = new byte[s_sampleMsg.Length]; var network = new VirtualNetwork(); using (var clientStream = new VirtualNetworkStream(network, isServer: false)) using (var serverStream = new VirtualNetworkStream(network, isServer: true)) using (var client = new NegotiateStream(clientStream)) using (var server = new NegotiateStream(serverStream)) { await TestConfiguration.WhenAllOrAnyFailedWithTimeout( client.AuthenticateAsClientAsync(CredentialCache.DefaultNetworkCredentials, string.Empty), server.AuthenticateAsServerAsync()); // Custom EndWrite/Read will not reset the variable which monitors concurrent write/read. await TestConfiguration.WhenAllOrAnyFailedWithTimeout( Task.Factory.FromAsync(client.BeginWrite, (ar) => { Assert.NotNull(ar); }, s_sampleMsg, 0, s_sampleMsg.Length, client), Task.Factory.FromAsync(server.BeginRead, (ar) => { Assert.NotNull(ar); }, recvBuf, 0, s_sampleMsg.Length, server)); Assert.Throws <NotSupportedException>(() => client.BeginWrite(s_sampleMsg, 0, s_sampleMsg.Length, (ar) => { Assert.Null(ar); }, null)); Assert.Throws <NotSupportedException>(() => server.BeginRead(recvBuf, 0, s_sampleMsg.Length, (ar) => { Assert.Null(ar); }, null)); } }
//</snippet2> //<snippet3> public static void EndReadCallback(IAsyncResult ar) { // Get the saved data. ClientState cState = (ClientState)ar.AsyncState; TcpClient clientRequest = cState.Client; NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream; // Get the buffer that stores the message sent by the client. int bytes = -1; // Read the client message. try { bytes = authStream.EndRead(ar); cState.Message.Append(Encoding.UTF8.GetChars(cState.Buffer, 0, bytes)); if (bytes != 0) { authStream.BeginRead(cState.Buffer, 0, cState.Buffer.Length, new AsyncCallback(EndReadCallback), cState); return; } } catch (Exception e) { // A real application should do something // useful here, such as logging the failure. Console.WriteLine("Client message exception:"); Console.WriteLine(e); cState.Waiter.Set(); return; } IIdentity id = authStream.RemoteIdentity; Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString()); cState.Waiter.Set(); }