protected override bool VerifyMessage (HandshakeType type)
		{
			switch (type) {
			case HandshakeType.ServerHello:
				return hello == null;

			case HandshakeType.Certificate:
				return hello != null && certificate == null && certificateRequest == null && done == null;

			case HandshakeType.ServerKeyExchange:
				if (!UsingServerKeyExchange)
					return false;
				return hello != null && certificate != null && certificateRequest == null && done == null;

			case HandshakeType.CertificateRequest:
				if (UsingServerKeyExchange && serverKeyExchange == null)
					return false;
				return hello != null && certificate != null && certificateRequest == null && done == null;

			case HandshakeType.ServerHelloDone:
				if (UsingServerKeyExchange && serverKeyExchange == null)
					return false;
				return hello != null && done == null;
			default:
				return false;
			}
		}

		public override HandshakeMessage GetMessage(HandshakeType type)
		{
			// Create and process the record message
			HandshakeMessage msg = this.createServerHandshakeMessage(type);

			return msg;
		}

		public static HandshakeMessage ReadMessage (TlsContext context, HandshakeType handshakeType, TlsBuffer incoming)
		{
			HandshakeMessage message;
			switch (handshakeType) {
			case HandshakeType.HelloRequest:
				message = new TlsHelloRequest ();
				break;
			case HandshakeType.ServerHello:
				return new TlsServerHello (context, incoming);
			case HandshakeType.Certificate:
				return new TlsCertificate (incoming);
			case HandshakeType.ServerHelloDone:
				message = new TlsServerHelloDone ();
				break;
			case HandshakeType.Finished:
				return new TlsFinished (incoming);
			case HandshakeType.ClientHello:
				return new TlsClientHello (context, incoming);
			case HandshakeType.ClientKeyExchange:
				return new TlsClientKeyExchange (context, incoming);
			case HandshakeType.CertificateRequest:
				return new TlsCertificateRequest (context.NegotiatedProtocol, incoming);
			case HandshakeType.CertificateVerify:
				return new TlsCertificateVerify (context.NegotiatedProtocol, incoming);
			case HandshakeType.ServerKeyExchange:
				return new TlsServerKeyExchange (context, incoming);
			default:
				throw new TlsException (AlertDescription.UnexpectedMessage, "Unknown server handshake message received: {0}", handshakeType);
			}

			message.Read (incoming);
			return message;
		}

 public Handshake(HandshakeType type, ushort payloadSize)
 {
     MessageId = type;
     PayloadSize = payloadSize;
     MajorVersion = Majorversion;
     MinorVersion = Minorversion;
 }

 /// <summary>
 /// Prevents a default instance of the <see cref="NextProtocolNegotiationMessage"/> class from being created.
 /// </summary>
 /// <param name="type">The message type.</param>
 /// <param name="selectedProtocol">The selected during NPN protocol.</param>
 public NextProtocolNegotiationMessage(HandshakeType type, string selectedProtocol)
     : base(type, null)
 {
     this.selectedProtocol = selectedProtocol;
     this.padding = this.CalcPadding(this.selectedProtocol);
     this.fragment = this.FormByteFragment();
 }

		public virtual void SendRecord(HandshakeType type)
		{

			IAsyncResult ar = this.BeginSendRecord(type, null, null);

			this.EndSendRecord(ar);

		}

		public HandshakeMessage(
			Context			context, 
			HandshakeType	handshakeType, 
			byte[]			data) : base(data)
		{
			this.context		= context;
			this.handshakeType	= handshakeType;						
		}

 void CheckType(HandshakeType type)
 {
     if (type == HandshakeType.ServerHelloDone)
         HasServerHelloDone = true;
     else if (type == HandshakeType.Finished)
         _hasFinished = true;
     else if (type == HandshakeType.HelloRequest)
         _hasHelloRequest = true;
 }

		protected override bool VerifyMessage (HandshakeType type)
		{
			switch (type) {
			case HandshakeType.ClientHello:
				return hello == null;
			default:
				return false;
			}
		}

		protected override bool VerifyMessage (HandshakeType type)
		{
			switch (type) {
			case HandshakeType.ChanceCipherSpec:
				return changeCipher == null;
			case HandshakeType.Finished:
				return changeCipher != null && finished == null;
			default:
				return false;
			}
		}

        private void UpdateVerify(HandshakeType type, uint length, byte[] body)
        {
            if (type == HandshakeType.Finished)
            {
                state.ComputeHandshakeVerify();
            }

            state.UpdateHandshakeVerify(new[] {(byte) type}, 0, 1);
            state.UpdateHandshakeVerify(EndianBitConverter.Big.GetBytes(length), 1, 3);
            state.UpdateHandshakeVerify(body, 0, body.Length);
        }

        private HandshakeMessage Read(HandshakeType type, byte[] body)
        {
            switch (type)
            {
                case HandshakeType.ClientHello:
                    return ClientHelloMessage.Read(state, body);
                case HandshakeType.ClientKeyExchange:
                    return state.KeyExchange.ReadClientKeyExchange(body);
                case HandshakeType.Finished:
                    return FinishedHandshakeMessage.Read(state, body);

                default:
                    throw new ArgumentOutOfRangeException(nameof(type), type, null);
            }
        }

		public override void SendRecord(HandshakeType type)
		{
			// Create the record message
			HandshakeMessage msg = this.createServerHandshakeMessage(type);
			msg.Process();
			
			// Write record
			this.SendRecord(msg.ContentType, msg.EncodeMessage());

			// Update session
			msg.Update();

			// Reset message contents
			msg.Reset();
		}

        protected HelloMessage(HandshakeType type, TlsVersion version, byte[] randomBytes, byte[] sessionId, HelloExtension[] extensions) : base(type)
        {
            Version = version;

            SecurityAssert.NotNull(randomBytes);
            SecurityAssert.SAssert(randomBytes.Length == 32);
            RandomBytes = randomBytes;

            SecurityAssert.NotNull(sessionId);
            SecurityAssert.SAssert(sessionId.Length >= 0 && sessionId.Length <= 32);
            SessionId = sessionId;

            SecurityAssert.NotNull(extensions);
            SecurityAssert.SAssert(extensions.Length >= 0 && extensions.Length <= 0xFFFF);
            Extensions = extensions;
        }

		protected override bool VerifyMessage (HandshakeType type)
		{
			switch (type) {
			case HandshakeType.ClientKeyExchange:
				return keyExchange == null;
			case HandshakeType.Certificate:
				return keyExchange == null && certificate == null;
			case HandshakeType.ChanceCipherSpec:
				return keyExchange != null && cipherSpec == null;
			case HandshakeType.Finished:
				return cipherSpec != null && finished == null;
			case HandshakeType.CertificateVerify:
				return keyExchange != null && certificate != null && certificateVerify == null && finished == null;
			default:
				return false;
			}
		}

		protected override HandshakeMessage CreateMessage (HandshakeType type, TlsBuffer incoming)
		{
			if (type != HandshakeType.ClientHello)
				throw new TlsException (AlertDescription.UnexpectedMessage);

			if (Renegotiating) {
				var flags = Config.RenegotiationFlags;
				if ((flags & RenegotiationFlags.DisallowRenegotiation) != 0)
					throw new TlsException (AlertDescription.HandshakeFailure, "Renegotiation not allowed.");
				if (!Session.SecureRenegotiation)
					throw new TlsException (AlertDescription.HandshakeFailure, "Renegotiation not allowed.");
			}

			StartHandshake ();

			return base.CreateMessage (type, incoming);
		}

		public override void SendRecord(HandshakeType type)
		{
			// Create and process the record message
			HandshakeMessage msg = this.createClientHandshakeMessage(type);
			msg.Process();

			DebugHelper.WriteLine(">>>> Write handshake record ({0}|{1})", context.Protocol, msg.ContentType);

			// Write record
			this.SendRecord(msg.ContentType, msg.EncodeMessage());

			// Update session
			msg.Update();

			// Reset message contents
			msg.Reset();
		}

    /// <summary>
    /// Handshake with the Audioscrobbler service
    /// </summary>
    /// <returns>True if the connection was successful, false otherwise</returns>
    private static void DoHandshake(bool forceNow_, HandshakeType ReasonForHandshake)
    {
      if (_useDebugLog)
      {
        Log.Debug("AudioscrobblerBase: Attempting {0} handshake", ReasonForHandshake.ToString());
      }

      // Handle uninitialized username/password.
      if (username.Length < 1 || password.Length < 1)
      {
        Log.Error("AudioscrobblerBase: {0}", "user or password not defined");
        workerFailed(ReasonForHandshake, DateTime.MinValue, new Exception("Account details insufficent"));
        return;
      }

      if (!forceNow_ || ReasonForHandshake != HandshakeType.Recover)
      {
        // Check whether we had a *successful* handshake recently.
        if (DateTime.Now < lastHandshake.Add(handshakeInterval))
        {
          string nexthandshake = lastHandshake.Add(handshakeInterval).ToString();
          string logmessage = "Next handshake due at " + nexthandshake;
          if (_useDebugLog)
          {
            Log.Debug("AudioscrobblerBase: {0}", logmessage);
          }
          workerSuccess(ReasonForHandshake, lastHandshake);
          return;
        }
      }

      if (ReasonForHandshake != HandshakeType.Init)
      {
        if (ReasonForHandshake == HandshakeType.PreRadio)
        {
          Log.Warn("AudioscrobblerBase: Disconnected - nevertheless trying radio handshake to listen without submits");
          AttemptRadioHandshake();
          return;
        }
        //else
        //{
        //  Log.Warn("AudioscrobblerBase: Disconnected - not attempting {0} handshake", ReasonForHandshake.ToString());
        //  workerFailed(ReasonForHandshake, DateTime.MinValue, new Exception("Disconnected!"));
        //  return;
        //}
      }

      BackgroundWorker worker = new BackgroundWorker();
      worker.DoWork += new DoWorkEventHandler(Worker_TryHandshake);
      worker.RunWorkerAsync(ReasonForHandshake);
    }

		private void ProcessHandshakeMessage(HandshakeType type, byte[] buf)
		{
			MemoryStream inStr = new MemoryStream(buf, false);

			/*
			* Check the type.
			*/
			switch (type)
			{
				case HandshakeType.certificate:
				{
					switch (connection_state)
					{
						case CS_SERVER_HELLO_RECEIVED:
						{
							// Parse the Certificate message and send to cipher suite

							Certificate serverCertificate = Certificate.Parse(inStr);

							AssertEmpty(inStr);

							this.keyExchange.ProcessServerCertificate(serverCertificate);

							this.authentication = tlsClient.GetAuthentication();
							this.authentication.NotifyServerCertificate(serverCertificate);

							break;
						}
						default:
							this.FailWithError(AlertLevel.fatal, AlertDescription.unexpected_message);
							break;
					}

					connection_state = CS_SERVER_CERTIFICATE_RECEIVED;
					break;
				}
				case HandshakeType.finished:
					switch (connection_state)
					{
						case CS_SERVER_CHANGE_CIPHER_SPEC_RECEIVED:
							/*
							 * Read the checksum from the finished message, it has always 12 bytes.
							 */
							byte[] serverVerifyData = new byte[12];
							TlsUtilities.ReadFully(serverVerifyData, inStr);

							AssertEmpty(inStr);

							/*
							 * Calculate our own checksum.
							 */
							byte[] expectedServerVerifyData = TlsUtilities.PRF(
								securityParameters.masterSecret, "server finished",
								rs.GetCurrentHash(), 12);

							/*
							 * Compare both checksums.
							 */
							if (!Arrays.ConstantTimeAreEqual(expectedServerVerifyData, serverVerifyData))
							{
								/*
								 * Wrong checksum in the finished message.
								 */
								this.FailWithError(AlertLevel.fatal, AlertDescription.handshake_failure);
							}

							connection_state = CS_DONE;

							/*
							* We are now ready to receive application data.
							*/
							this.appDataReady = true;
							break;
						default:
							this.FailWithError(AlertLevel.fatal, AlertDescription.unexpected_message);
							break;
					}
					break;
				case HandshakeType.server_hello:
					switch (connection_state)
					{
						case CS_CLIENT_HELLO_SEND:
							/*
							 * Read the server hello message
							 */
							TlsUtilities.CheckVersion(inStr, this);

							/*
							 * Read the server random
							 */
							securityParameters.serverRandom = new byte[32];
							TlsUtilities.ReadFully(securityParameters.serverRandom, inStr);

							byte[] sessionID = TlsUtilities.ReadOpaque8(inStr);
							if (sessionID.Length > 32)
							{
								this.FailWithError(AlertLevel.fatal, AlertDescription.illegal_parameter);
							}

							this.tlsClient.NotifySessionID(sessionID);
//.........这里部分代码省略.........

 private static void OnHandshakeSuccessful(HandshakeType ReasonForHandshake, DateTime lastSuccessfulHandshake)
 {
   switch (ReasonForHandshake)
   {
     case HandshakeType.ChangeUser:
       LoadSettings();
       Log.Info("AudioscrobblerBase: Changed user to {0} - loaded {1} queue items", username, queue.Count);
       break;
     case HandshakeType.PreRadio:
       AttemptRadioHandshake();
       break;
     case HandshakeType.Init:
       AttemptSubmitNow();
       break;
     case HandshakeType.Submit:
       AttemptSubmitNow();
       break;
     case HandshakeType.Announce:
       AttemptAnnounceNow();
       break;
   }
 }