Java StreamError类代码示例

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
* 协商TLS协议
* 
* @return
*/
  private boolean negotiateTLS() {
      if (connection.getTlsPolicy() == Connection.TLSPolicy.disabled) {
	// 设置not_authorized错误
          StreamError error = new StreamError(
                  StreamError.Condition.not_authorized);
          connection.deliverRawText(error.toXML());
          connection.close();
	log.warn("当TLS从未提供服务时，将请求初始化，关闭连接 : " + connection);
          return false;
      }
// 客户要求使用TLS安全连接
      try {
          startTLS();
      } catch (Exception e) {
	log.error("在协商TLS时发生错误：", e);
          connection
                  .deliverRawText("<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\">");
          connection.close();
          return false;
      }
      return true;
  }
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
private void closeStream(StreamError streamError)
{
    if (isWebSocketOpen()) {

        if (streamError != null) {
            deliver(streamError.toXML());
        }

        StringBuilder sb = new StringBuilder(250);
        sb.append("<close ");
        sb.append("xmlns='").append(FRAMING_NAMESPACE).append("'");
        sb.append("/>");
        deliver(sb.toString());
        closeWebSocket();
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Authenticates the connection manager. Shared secret is validated with the one provided
 * by the connection manager. If everything went fine then the session will have a status
 * of "authenticated" and the connection manager will receive the client configuration
 * options.
 *
 * @param digest the digest provided by the connection manager with the handshake stanza.
 * @return true if the connection manager was sucessfully authenticated.
 */
public boolean authenticate(String digest) {
    // Perform authentication. Wait for the handshake (with the secret key)
    String anticipatedDigest = AuthFactory.createDigest(getStreamID().getID(),
            ConnectionMultiplexerManager.getDefaultSecret());
    // Check that the provided handshake (secret key + sessionID) is correct
    if (!anticipatedDigest.equalsIgnoreCase(digest)) {
        Log.debug("LocalConnectionMultiplexerSession: [ConMng] Incorrect handshake for connection manager with domain: " +
                getAddress().getDomain());
        //  The credentials supplied by the initiator are not valid (answer an error
        // and close the connection)
        conn.deliverRawText(new StreamError(StreamError.Condition.not_authorized).toXML());
        // Close the underlying connection
        conn.close();
        return false;
    }
    else {
        // Component has authenticated fine
        setStatus(STATUS_AUTHENTICATED);
        // Send empty handshake element to acknowledge success
        conn.deliverRawText("<handshake></handshake>");
        Log.debug("LocalConnectionMultiplexerSession: [ConMng] Connection manager was AUTHENTICATED with domain: " + getAddress());
        sendClientOptions();
        return true;
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
private boolean negotiateTLS() {
    if (connection.getTlsPolicy() == Connection.TLSPolicy.disabled) {
        // Set the not_authorized error
        StreamError error = new StreamError(
                StreamError.Condition.not_authorized);
        connection.deliverRawText(error.toXML());
        connection.close();
        log.warn("TLS requested by initiator when TLS was never offered"
                + " by server. Closing connection : " + connection);
        return false;
    }
    // Client requested to secure the connection using TLS.
    try {
        startTLS();
    } catch (Exception e) {
        log.error("Error while negotiating TLS", e);
        connection
                .deliverRawText("<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\">");
        connection.close();
        return false;
    }
    return true;
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Tries to secure the connection using TLS. If the connection is secured then reset
 * the parser to use the new secured reader. But if the connection failed to be secured
 * then send a <failure> stanza and close the connection.
 *
 * @return true if the connection was secured.
 */
private boolean negotiateTLS() {
    if (connection.getTlsPolicy() == Connection.TLSPolicy.disabled) {
        // Set the not_authorized error
        StreamError error = new StreamError(StreamError.Condition.not_authorized);
        // Deliver stanza
        connection.deliverRawText(error.toXML());
        // Close the underlying connection
        connection.close();
        // Log a warning so that admins can track this case from the server side
        Log.warn("TLS requested by initiator when TLS was never offered by server. " +
                "Closing connection : " + connection);
        return false;
    }
    // Client requested to secure the connection using TLS. Negotiate TLS.
    try {
        startTLS();
    }
    catch (Exception e) {
        Log.error("Error while negotiating TLS", e);
        connection.deliverRawText("<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\">");
        connection.close();
        return false;
    }
    return true;
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
* 创建Session
* 
* @param xpp
*            xmlpull解析器
* @throws XmlPullParserException
*             xmlpull解析器异常
* @throws IOException
*             IO异常
*/
  private void createSession(XmlPullParser xpp)
          throws XmlPullParserException, IOException {
      for (int eventType = xpp.getEventType(); eventType != XmlPullParser.START_TAG;) {
          eventType = xpp.next();
      }
// 基于所发送的命名空间创建正确的会话
      String namespace = xpp.getNamespace(null);
      if ("jabber:client".equals(namespace)) {
          session = ClientSession.createSession(serverName, connection, xpp);
          if (session == null) {
              StringBuilder sb = new StringBuilder(250);
              sb.append("<?xml version='1.0' encoding='UTF-8'?>");
              sb.append("<stream:stream from=\"").append(serverName);
              sb.append("\" id=\"").append(randomString(5));
              sb.append("\" xmlns=\"").append(xpp.getNamespace(null));
              sb.append("\" xmlns:stream=\"").append(
                      xpp.getNamespace("stream"));
              sb.append("\" version=\"1.0\">");

		// 响应中的一个糟糕的命名空间前缀
              StreamError error = new StreamError(
                      StreamError.Condition.bad_namespace_prefix);
              sb.append(error.toXML());
              connection.deliverRawText(sb.toString());
              connection.close();
		log.warn("由于bad_namespace_prefix关闭session在数据流的头部: " + namespace);
          }
      }
  }
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Terminate open session for the user with specified user name. Username should be complete ie it should
 * include the % appid.
 * @param username
 */
public static void terminateSessions(String username) throws ServerNotInitializedException {
  final StreamError error = new StreamError(StreamError.Condition.not_authorized);
  for (ClientSession session : getSessionManager().getSessions(username) ) {
    LOGGER.info("Terminating session for user with name:{}", username);
    session.deliverRawText(error.toXML());
    session.close();
  }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
@OnWebSocketError
public void onError(Throwable error)
{
    Log.error("Error detected; session: " + wsSession, error);
    closeStream(new StreamError(StreamError.Condition.internal_server_error));
    try {
        if (wsSession != null) {
            wsSession.disconnect();
        }
    } catch ( Exception e ) {
        Log.error("Error disconnecting websocket", e);
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Close the connection since TLS was mandatory and the entity never negotiated TLS. Before
 * closing the connection a stream error will be sent to the entity.
 */
void closeNeverSecuredConnection() {
    // Set the not_authorized error
    StreamError error = new StreamError(StreamError.Condition.not_authorized);
    // Deliver stanza
    connection.deliverRawText(error.toXML());
    // Close the underlying connection
    connection.close();
    // Log a warning so that admins can track this case from the server side
    Log.warn("TLS was required by the server and connection was never secured. " +
            "Closing connection : " + connection);
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
private static void deleteUser(User oldUser) {
    UserManager.getInstance().deleteUser(oldUser);
    final StreamError error = new StreamError(StreamError.Condition.not_authorized);
    for (ClientSession sess : SessionManager.getInstance().getSessions(oldUser.getUsername())) {
        sess.deliverRawText(error.toXML());
        sess.close();
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Sends an unsupported version error and name of client the user attempted to connect with.
 *
 * @param session    the users current session.
 * @param clientName the name of the client they were connecting with.
 */
private void closeSession(final Session session, String clientName) {
    // Increase the number of logins not allowed by 1.
    disconnects.incrementAndGet();

    Log.debug("Closed connection to client attempting to connect from " + clientName);

    // Send message information user.
    final Message message = new Message();
    message.setFrom(serviceName + "." + componentManager.getServerName());
    message.setTo(session.getAddress());

    message.setBody("You are using an invalid client, and therefore will be disconnected. "
            + "Please ask your system administrator for client choices.");

    // Send Message
    sendPacket(message);

    // Disconnect user after 5 seconds.
    taskEngine.schedule(new TimerTask() {
        @Override
        public void run() {
            // Include the not-authorized error in the response
            StreamError error = new StreamError(StreamError.Condition.policy_violation);
            session.deliverRawText(error.toXML());
            // Close the underlying connection
            session.close();
        }
    }, 5000);


}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Disable user.
 *
 * @param username
 *            the username
 * @throws ServiceException
 *             the service exception
 */
public void disableUser(String username) throws ServiceException {
    getAndCheckUser(username);
    lockOutManager.disableAccount(username, null, null);
    
    if (lockOutManager.isAccountDisabled(username)) {
        final StreamError error = new StreamError(StreamError.Condition.not_authorized);
        for (ClientSession sess : SessionManager.getInstance().getSessions(username)) {
            sess.deliverRawText(error.toXML());
            sess.close();
        }
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Removes the user sessions.
 *
 * @param username the username
 * @throws ServiceException the service exception
 */
public void removeUserSessions(String username) throws ServiceException {
    final StreamError error = new StreamError(StreamError.Condition.not_authorized);
    for (ClientSession session : SessionManager.getInstance().getSessions(username)) {
        session.deliverRawText(error.toXML());
        session.close();
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
/**
 * Delete user.
 *
 * @param oldUser
 *            the old user
 */
private static void deleteUser(User oldUser) {
    UserManager.getInstance().deleteUser(oldUser);
    LockOutManager.getInstance().enableAccount(oldUser.getUsername());
    final StreamError error = new StreamError(StreamError.Condition.not_authorized);
    for (ClientSession sess : SessionManager.getInstance().getSessions(oldUser.getUsername())) {
        sess.deliverRawText(error.toXML());
        sess.close();
    }
}
 

import org.xmpp.packet.StreamError; //导入依赖的package包/类
private void createSession(XmlPullParser xpp)
        throws XmlPullParserException, IOException {
    for (int eventType = xpp.getEventType(); eventType != XmlPullParser.START_TAG;) {
        eventType = xpp.next();
    }
    // Create the correct session based on the sent namespace
    String namespace = xpp.getNamespace(null);
    if ("jabber:client".equals(namespace)) {
        session = ClientSession.createSession(serverName, connection, xpp);
        if (session == null) {
            StringBuilder sb = new StringBuilder(250);
            sb.append("<?xml version='1.0' encoding='UTF-8'?>");
            sb.append("<stream:stream from=\"").append(serverName);
            sb.append("\" id=\"").append(randomString(5));
            sb.append("\" xmlns=\"").append(xpp.getNamespace(null));
            sb.append("\" xmlns:stream=\"").append(
                    xpp.getNamespace("stream"));
            sb.append("\" version=\"1.0\">");

            // bad-namespace-prefix in the response
            StreamError error = new StreamError(
                    StreamError.Condition.bad_namespace_prefix);
            sb.append(error.toXML());
            connection.deliverRawText(sb.toString());
            connection.close();
            log
                    .warn("Closing session due to bad_namespace_prefix in stream header: "
                            + namespace);
        }
    }
}