public DTLSTransport accept(TlsServer server, DatagramTransport transport) throws IOException {
    if (server == null) {
      throw new IllegalArgumentException("'server' cannot be null");
    }
    if (transport == null) {
      throw new IllegalArgumentException("'transport' cannot be null");
    }

    SecurityParameters securityParameters = new SecurityParameters();
    securityParameters.entity = ConnectionEnd.server;
    securityParameters.serverRandom = TlsProtocol.createRandomBlock(secureRandom);

    ServerHandshakeState state = new ServerHandshakeState();
    state.server = server;
    state.serverContext = new TlsServerContextImpl(secureRandom, securityParameters);
    server.init(state.serverContext);

    DTLSRecordLayer recordLayer =
        new DTLSRecordLayer(transport, state.serverContext, server, ContentType.handshake);

    // TODO Need to handle sending of HelloVerifyRequest without entering a full connection

    try {
      return serverHandshake(state, recordLayer);
    } catch (TlsFatalAlert fatalAlert) {
      recordLayer.fail(fatalAlert.getAlertDescription());
      throw fatalAlert;
    } catch (IOException e) {
      recordLayer.fail(AlertDescription.internal_error);
      throw e;
    } catch (RuntimeException e) {
      recordLayer.fail(AlertDescription.internal_error);
      throw new TlsFatalAlert(AlertDescription.internal_error);
    }
  }
  protected DTLSTransport serverHandshake(ServerHandshakeState state, DTLSRecordLayer recordLayer)
      throws IOException {
    SecurityParameters securityParameters = state.serverContext.getSecurityParameters();
    DTLSReliableHandshake handshake = new DTLSReliableHandshake(state.serverContext, recordLayer);

    DTLSReliableHandshake.Message clientMessage = handshake.receiveMessage();

    {
      // NOTE: After receiving a record from the client, we discover the record layer version
      ProtocolVersion client_version = recordLayer.getDiscoveredPeerVersion();
      // TODO Read RFCs for guidance on the expected record layer version number
      state.serverContext.setClientVersion(client_version);
    }

    if (clientMessage.getType() == HandshakeType.client_hello) {
      processClientHello(state, clientMessage.getBody());
    } else {
      throw new TlsFatalAlert(AlertDescription.unexpected_message);
    }

    {
      byte[] serverHelloBody = generateServerHello(state);

      if (state.maxFragmentLength >= 0) {
        int plainTextLimit = 1 << (8 + state.maxFragmentLength);
        recordLayer.setPlaintextLimit(plainTextLimit);
      }

      securityParameters.cipherSuite = state.selectedCipherSuite;
      securityParameters.compressionAlgorithm = state.selectedCompressionMethod;
      securityParameters.prfAlgorithm =
          TlsProtocol.getPRFAlgorithm(state.serverContext, state.selectedCipherSuite);

      /*
       * RFC 5264 7.4.9. Any cipher suite which does not explicitly specify verify_data_length
       * has a verify_data_length equal to 12. This includes all existing cipher suites.
       */
      securityParameters.verifyDataLength = 12;

      handshake.sendMessage(HandshakeType.server_hello, serverHelloBody);
    }

    handshake.notifyHelloComplete();

    Vector serverSupplementalData = state.server.getServerSupplementalData();
    if (serverSupplementalData != null) {
      byte[] supplementalDataBody = generateSupplementalData(serverSupplementalData);
      handshake.sendMessage(HandshakeType.supplemental_data, supplementalDataBody);
    }

    state.keyExchange = state.server.getKeyExchange();
    state.keyExchange.init(state.serverContext);

    state.serverCredentials = state.server.getCredentials();

    Certificate serverCertificate = null;

    if (state.serverCredentials == null) {
      state.keyExchange.skipServerCredentials();
    } else {
      state.keyExchange.processServerCredentials(state.serverCredentials);

      serverCertificate = state.serverCredentials.getCertificate();
      byte[] certificateBody = generateCertificate(serverCertificate);
      handshake.sendMessage(HandshakeType.certificate, certificateBody);
    }

    // TODO[RFC 3546] Check whether empty certificates is possible, allowed, or excludes
    // CertificateStatus
    if (serverCertificate == null || serverCertificate.isEmpty()) {
      state.allowCertificateStatus = false;
    }

    if (state.allowCertificateStatus) {
      CertificateStatus certificateStatus = state.server.getCertificateStatus();
      if (certificateStatus != null) {
        byte[] certificateStatusBody = generateCertificateStatus(state, certificateStatus);
        handshake.sendMessage(HandshakeType.certificate_status, certificateStatusBody);
      }
    }

    byte[] serverKeyExchange = state.keyExchange.generateServerKeyExchange();
    if (serverKeyExchange != null) {
      handshake.sendMessage(HandshakeType.server_key_exchange, serverKeyExchange);
    }

    if (state.serverCredentials != null) {
      state.certificateRequest = state.server.getCertificateRequest();
      if (state.certificateRequest != null) {
        state.keyExchange.validateCertificateRequest(state.certificateRequest);

        byte[] certificateRequestBody = generateCertificateRequest(state, state.certificateRequest);
        handshake.sendMessage(HandshakeType.certificate_request, certificateRequestBody);

        TlsUtils.trackHashAlgorithms(
            handshake.getHandshakeHash(),
            state.certificateRequest.getSupportedSignatureAlgorithms());
      }
    }

    handshake.sendMessage(HandshakeType.server_hello_done, TlsUtils.EMPTY_BYTES);

    handshake.getHandshakeHash().sealHashAlgorithms();

    clientMessage = handshake.receiveMessage();

    if (clientMessage.getType() == HandshakeType.supplemental_data) {
      processClientSupplementalData(state, clientMessage.getBody());
      clientMessage = handshake.receiveMessage();
    } else {
      state.server.processClientSupplementalData(null);
    }

    if (state.certificateRequest == null) {
      state.keyExchange.skipClientCredentials();
    } else {
      if (clientMessage.getType() == HandshakeType.certificate) {
        processClientCertificate(state, clientMessage.getBody());
        clientMessage = handshake.receiveMessage();
      } else {
        if (TlsUtils.isTLSv12(state.serverContext)) {
          /*
           * RFC 5246 If no suitable certificate is available, the client MUST send a
           * certificate message containing no certificates.
           *
           * NOTE: In previous RFCs, this was SHOULD instead of MUST.
           */
          throw new TlsFatalAlert(AlertDescription.unexpected_message);
        }

        notifyClientCertificate(state, Certificate.EMPTY_CHAIN);
      }
    }

    if (clientMessage.getType() == HandshakeType.client_key_exchange) {
      processClientKeyExchange(state, clientMessage.getBody());
    } else {
      throw new TlsFatalAlert(AlertDescription.unexpected_message);
    }

    TlsProtocol.establishMasterSecret(state.serverContext, state.keyExchange);
    recordLayer.initPendingEpoch(state.server.getCipher());

    TlsHandshakeHash prepareFinishHash = handshake.prepareToFinish();

    /*
     * RFC 5246 7.4.8 This message is only sent following a client certificate that has signing
     * capability (i.e., all certificates except those containing fixed Diffie-Hellman
     * parameters).
     */
    if (expectCertificateVerifyMessage(state)) {
      byte[] certificateVerifyBody = handshake.receiveMessageBody(HandshakeType.certificate_verify);
      processCertificateVerify(state, certificateVerifyBody, prepareFinishHash);
    }

    // NOTE: Calculated exclusive of the actual Finished message from the client
    byte[] expectedClientVerifyData =
        TlsUtils.calculateVerifyData(
            state.serverContext,
            ExporterLabel.client_finished,
            TlsProtocol.getCurrentPRFHash(state.serverContext, handshake.getHandshakeHash(), null));
    processFinished(handshake.receiveMessageBody(HandshakeType.finished), expectedClientVerifyData);

    if (state.expectSessionTicket) {
      NewSessionTicket newSessionTicket = state.server.getNewSessionTicket();
      byte[] newSessionTicketBody = generateNewSessionTicket(state, newSessionTicket);
      handshake.sendMessage(HandshakeType.session_ticket, newSessionTicketBody);
    }

    // NOTE: Calculated exclusive of the Finished message itself
    byte[] serverVerifyData =
        TlsUtils.calculateVerifyData(
            state.serverContext,
            ExporterLabel.server_finished,
            TlsProtocol.getCurrentPRFHash(state.serverContext, handshake.getHandshakeHash(), null));
    handshake.sendMessage(HandshakeType.finished, serverVerifyData);

    handshake.finish();

    state.server.notifyHandshakeComplete();

    return new DTLSTransport(recordLayer);
  }