/** Loads the provider names from the jive properties config file. */
  private static void loadProviders() {
    if (factory == null) {
      // Use className as a convenient object to get a lock on.
      synchronized (classNames) {
        if (factory == null) {
          try {
            Class[] providers = new Class[classNames.length];
            for (int i = 0; i < classNames.length; i++) {
              // Convert XML based provider setup to Database based
              JiveGlobals.migrateProperty(propNames[i]);

              String className = classNames[i];
              // See if the classname has been set as a Jive property.
              String classNameProp = JiveGlobals.getProperty(propNames[i]);
              if (classNameProp != null) {
                className = classNameProp;
              }
              try {
                providers[i] = ClassUtils.forName(className);
              } catch (Exception e) {
                Log.error("Exception loading class: " + className, e);
              }
            }
            setProviders(providers);
          } catch (Exception e) {
            Log.error("Exception loading class: " + classNames, e);
          }
        }
      }
    }
  }
 public static synchronized void addAgentSelectorClass(Class newClass)
     throws IllegalArgumentException {
   try {
     AgentSelector newAlgorithm = (AgentSelector) newClass.newInstance();
     // Make sure the interceptor isn't already in the list.
     List<AgentSelector> availableAgentSelectors = getAvailableAgentSelectors();
     for (AgentSelector algorithm : availableAgentSelectors) {
       if (newAlgorithm.getClass().equals(algorithm.getClass())) {
         return;
       }
     }
     // Add in the new algorithm
     availableAgentSelectors.add(newAlgorithm);
     // Write out new class names.
     JiveGlobals.deleteProperty("agentSelector.classes");
     for (int i = 0; i < availableAgentSelectors.size(); i++) {
       String cName = availableAgentSelectors.get(i).getClass().getName();
       JiveGlobals.setProperty("agentSelector.classes." + i, cName);
     }
   } catch (IllegalAccessException e) {
     throw new IllegalArgumentException(e.getMessage());
   } catch (InstantiationException e2) {
     throw new IllegalArgumentException(e2.getMessage());
   } catch (ClassCastException e5) {
     throw new IllegalArgumentException("Class is not a AgentSelector");
   }
 }
  static {
    String propertyValue = JiveGlobals.getProperty(JIVE_CROWD_GROUPS_CACHE_TTL_SECS);
    int ttl =
        (propertyValue == null || propertyValue.trim().length() == 0)
            ? CACHE_TTL
            : Integer.parseInt(propertyValue);

    crowdGroupSync.scheduleAtFixedRate(new GroupSynch(), 0, ttl, TimeUnit.SECONDS);

    JiveGlobals.setProperty(JIVE_CROWD_GROUPS_CACHE_TTL_SECS, String.valueOf(ttl));
  }
 /**
  * Returns <tt>null</tt> if the admin console will be available in all network interfaces of this
  * machine or a String representing the only interface where the admin console will be available.
  *
  * @return String representing the only interface where the admin console will be available or
  *     null if it will be available in all interfaces.
  */
 public String getBindInterface() {
   String adminInterfaceName = JiveGlobals.getXMLProperty("adminConsole.interface");
   String globalInterfaceName = JiveGlobals.getXMLProperty("network.interface");
   String bindInterface = null;
   if (adminInterfaceName != null && adminInterfaceName.trim().length() > 0) {
     bindInterface = adminInterfaceName;
   } else if (globalInterfaceName != null && globalInterfaceName.trim().length() > 0) {
     bindInterface = globalInterfaceName;
   }
   return bindInterface;
 }
Exemple #5
0
  static {
    String algorithm = JiveGlobals.getProperty("xmpp.socket.ssl.algorithm", "TLS");
    String storeType = JiveGlobals.getProperty("xmpp.socket.ssl.storeType", "jks");

    // Get the keystore location. The default location is security/keystore
    keyStoreLocation =
        JiveGlobals.getProperty(
            "xmpp.socket.ssl.keystore",
            "resources" + File.separator + "security" + File.separator + "keystore");
    keyStoreLocation = JiveGlobals.getHomeDirectory() + File.separator + keyStoreLocation;

    // Get the keystore password. The default password is "changeit".
    keypass = JiveGlobals.getProperty("xmpp.socket.ssl.keypass", "changeit");
    keypass = keypass.trim();

    // Get the truststore location; default at security/truststore
    trustStoreLocation =
        JiveGlobals.getProperty(
            "xmpp.socket.ssl.truststore",
            "resources" + File.separator + "security" + File.separator + "truststore");
    trustStoreLocation = JiveGlobals.getHomeDirectory() + File.separator + trustStoreLocation;

    // Get the truststore passwprd; default is "changeit".
    trustpass = JiveGlobals.getProperty("xmpp.socket.ssl.trustpass", "changeit");
    trustpass = trustpass.trim();

    try {
      keyStore = KeyStore.getInstance(storeType);
      keyStore.load(new FileInputStream(keyStoreLocation), keypass.toCharArray());

      trustStore = KeyStore.getInstance(storeType);
      trustStore.load(new FileInputStream(trustStoreLocation), trustpass.toCharArray());

      sslFactory =
          (SSLJiveServerSocketFactory)
              SSLJiveServerSocketFactory.getInstance(algorithm, keyStore, trustStore);
    } catch (Exception e) {
      Log.error(
          "SSLConfig startup problem.\n"
              + "  storeType: ["
              + storeType
              + "]\n"
              + "  keyStoreLocation: ["
              + keyStoreLocation
              + "]\n"
              + "  keypass: ["
              + keypass
              + "]\n"
              + "  trustStoreLocation: ["
              + trustStoreLocation
              + "]\n"
              + "  trustpass: ["
              + trustpass
              + "]",
          e);
      keyStore = null;
      trustStore = null;
      sslFactory = null;
    }
  }
  private List<String> getServerInterfaces() {

    List<String> bindInterfaces = new ArrayList<String>();

    String interfaceName = JiveGlobals.getXMLProperty("network.interface");
    String bindInterface = null;
    if (interfaceName != null) {
      if (interfaceName.trim().length() > 0) {
        bindInterface = interfaceName;
      }
    }

    int adminPort = JiveGlobals.getXMLProperty("adminConsole.port", 9090);
    int adminSecurePort = JiveGlobals.getXMLProperty("adminConsole.securePort", 9091);

    if (bindInterface == null) {
      try {
        Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
        for (NetworkInterface netInterface : Collections.list(nets)) {
          Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
          for (InetAddress address : Collections.list(addresses)) {
            if ("127.0.0.1".equals(address.getHostAddress())) {
              continue;
            }
            if (address.getHostAddress().startsWith("0.")) {
              continue;
            }
            Socket socket = new Socket();
            InetSocketAddress remoteAddress =
                new InetSocketAddress(address, adminPort > 0 ? adminPort : adminSecurePort);
            try {
              socket.connect(remoteAddress);
              bindInterfaces.add(address.getHostAddress());
              break;
            } catch (IOException e) {
              // Ignore this address. Let's hope there is more addresses to validate
            }
          }
        }
      } catch (SocketException e) {
        // We failed to discover a valid IP address where the admin console is running
        return null;
      }
    } else {
      bindInterfaces.add(bindInterface);
    }

    return bindInterfaces;
  }
 static {
   // Fill out the allowedIPs with the system property
   String allowed = JiveGlobals.getProperty("xmpp.client.login.allowed", "");
   StringTokenizer tokens = new StringTokenizer(allowed, ", ");
   while (tokens.hasMoreTokens()) {
     String address = tokens.nextToken().trim();
     allowedIPs.put(address, "");
   }
   String allowedAnonym = JiveGlobals.getProperty("xmpp.client.login.allowedAnonym", "");
   tokens = new StringTokenizer(allowedAnonym, ", ");
   while (tokens.hasMoreTokens()) {
     String address = tokens.nextToken().trim();
     allowedAnonymIPs.put(address, "");
   }
 }
 void checkHealth() {
   // Check that the sending operation is still active
   if (writeStarted > -1
       && System.currentTimeMillis() - writeStarted
           > JiveGlobals.getIntProperty("xmpp.session.sending-limit", 60000)) {
     // Close the socket
     if (Log.isDebugEnabled()) {
       Log.debug(
           "Closing connection: "
               + this
               + " that started sending data at: "
               + new Date(writeStarted));
     }
     forceClose();
   } else {
     // Check if the connection has been idle. A connection is considered idle if the client
     // has not been receiving data for a period. Sending data to the client is not
     // considered as activity.
     if (idleTimeout > -1
         && socketReader != null
         && System.currentTimeMillis() - socketReader.getLastActive() > idleTimeout) {
       // Close the socket
       if (Log.isDebugEnabled()) {
         Log.debug("Closing connection that has been idle: " + this);
       }
       forceClose();
     }
   }
 }
Exemple #9
0
 /**
  * Forwards the received message to the list of users defined in the property
  * <b>xmpp.forward.admins</b>. The property may include bare JIDs or just usernames separated by
  * commas or white spaces. When using bare JIDs the target user may belong to a remote server.
  *
  * <p>If the property <b>xmpp.forward.admins</b> was not defined then the message will be sent to
  * all the users allowed to enter the admin console.
  *
  * @param packet the message to forward.
  */
 private void sendMessageToAdmins(Message packet) {
   String jids = JiveGlobals.getProperty("xmpp.forward.admins");
   if (jids != null && jids.trim().length() > 0) {
     // Forward the message to the users specified in the "xmpp.forward.admins" property
     StringTokenizer tokenizer = new StringTokenizer(jids, ", ");
     while (tokenizer.hasMoreTokens()) {
       String username = tokenizer.nextToken();
       Message forward = packet.createCopy();
       if (username.contains("@")) {
         // Use the specified bare JID address as the target address
         forward.setTo(username);
       } else {
         forward.setTo(username + "@" + serverName);
       }
       route(forward);
     }
   } else {
     // Forward the message to the users allowed to log into the admin console
     for (JID jid : XMPPServer.getInstance().getAdmins()) {
       Message forward = packet.createCopy();
       forward.setTo(jid);
       route(forward);
     }
   }
 }
Exemple #10
0
  /**
   * Returns a full JID based off of a username passed in.
   *
   * <p>If it already looks like a JID, returns what was passed in.
   *
   * @param username Username to turn into a JID.
   * @return Converted username.
   */
  public String generateFullJID(String username) {
    if (username.indexOf("@") > -1) {
      return username;
    }

    if (getTransport().getType().equals(TransportType.gtalk)) {
      return username + "@" + "gmail.com";
    } else if (getTransport().getType().equals(TransportType.facebook)) {
      return username + "@" + "chat.facebook.com";
    } else if (getTransport().getType().equals(TransportType.renren)) {
      return username + "@" + "renren.com";
    } else if (getTransport().getType().equals(TransportType.livejournal)) {
      return username + "@" + "livejournal.com";
    } else {
      String connecthost =
          JiveGlobals.getProperty(
              "plugin.gateway." + getTransport().getType() + ".connecthost",
              (getTransport().getType().equals(TransportType.gtalk)
                  ? "talk.google.com"
                  : getTransport().getType().equals(TransportType.facebook)
                      ? "chat.facebook.com"
                      : "jabber.org"));
      return username + "@" + connecthost;
    }
  }
  public void initializePlugin(PluginManager manager, File pluginDirectory) {
    System.out.println("Starting Client Control Plugin");

    // Check if we Enterprise is installed and stop loading this plugin if found
    File pluginDir = new File(JiveGlobals.getHomeDirectory(), "plugins");
    File[] jars =
        pluginDir.listFiles(
            new FileFilter() {
              public boolean accept(File pathname) {
                String fileName = pathname.getName().toLowerCase();
                return (fileName.equalsIgnoreCase("enterprise.jar"));
              }
            });
    if (jars.length > 0) {
      // Do not load this plugin since Enterprise is still installed
      System.out.println("Enterprise plugin found. Stopping Client Control Plugin");
      throw new IllegalStateException("This plugin cannot run next to the Enterprise plugin");
    }

    taskEngine = TaskEngine.getInstance();
    sparkManager = new SparkManager(taskEngine);
    sparkManager.start();

    // Create and start the Spark version manager
    sparkVersionManager = new SparkVersionManager();
    sparkVersionManager.start();

    fileTransferFilterManager = new FileTransferFilterManager();
    fileTransferFilterManager.start();
  }
  public static synchronized List<AgentSelector> getAvailableAgentSelectors() {
    List<AgentSelector> answer = new ArrayList<AgentSelector>();
    // First, add in built-in list of algorithms.
    for (Class newClass : getBuiltInAgentSelectorClasses()) {
      try {
        AgentSelector algorithm = (AgentSelector) newClass.newInstance();
        answer.add(algorithm);
      } catch (Exception e) {
        Log.error(e.getMessage(), e);
      }
    }

    // Now get custom algorithms.
    List<String> classNames = JiveGlobals.getProperties("agentSelector.classes");
    for (String className : classNames) {
      install_algorithm:
      try {
        Class algorithmClass = loadClass(className);
        // Make sure that the intercepter isn't already installed.
        for (AgentSelector agentSelector : answer) {
          if (algorithmClass.equals(agentSelector.getClass())) {
            break install_algorithm;
          }
        }
        AgentSelector algorithm = (AgentSelector) algorithmClass.newInstance();
        answer.add(algorithm);
      } catch (Exception e) {
        Log.error(e.getMessage(), e);
      }
    }
    return answer;
  }
  public NativeAuthProvider() {
    // Convert XML based provider setup to Database based
    JiveGlobals.migrateProperty("nativeAuth.domain");

    this.domain = JiveGlobals.getProperty("nativeAuth.domain");

    // Configure the library path so that we can load the shaj native library
    // from the Openfire lib directory.
    // Find the root path of this class.
    try {
      String binaryPath =
          (new URL(Shaj.class.getProtectionDomain().getCodeSource().getLocation(), "."))
              .openConnection()
              .getPermission()
              .getName();
      binaryPath = (new File(binaryPath)).getCanonicalPath();

      // Add the binary path to "java.library.path".
      String newLibPath = binaryPath + File.pathSeparator + System.getProperty("java.library.path");
      System.setProperty("java.library.path", newLibPath);
      Field fieldSysPath = ClassLoader.class.getDeclaredField("sys_paths");
      fieldSysPath.setAccessible(true);
      fieldSysPath.set(System.class.getClassLoader(), null);
    } catch (Exception e) {
      Log.error(e);
    }

    // Configure Shaj to log output to the Openfire logger.
    com.cenqua.shaj.log.Log.Factory.setInstance(
        new com.cenqua.shaj.log.Log() {
          public boolean isDebug() {
            return Log.isDebugEnabled();
          }

          public void error(String string) {
            Log.error(string);
          }

          public void error(String string, Throwable throwable) {
            Log.error(string, throwable);
          }

          public void debug(String string) {
            Log.debug("NativeAuthProvider: " + string);
          }
        });
  }
  /** Save properties as Jive properties. */
  private void saveProperties() {

    JiveGlobals.setXMLProperty("database.defaultProvider.driver", driver);
    JiveGlobals.setXMLProperty("database.defaultProvider.serverURL", serverURL);
    JiveGlobals.setXMLProperty("database.defaultProvider.username", username);
    JiveGlobals.setXMLProperty("database.defaultProvider.password", password);
    JiveGlobals.setXMLProperty("database.defaultProvider.testSQL", testSQL);
    JiveGlobals.setXMLProperty("database.defaultProvider.testBeforeUse", testBeforeUse.toString());
    JiveGlobals.setXMLProperty("database.defaultProvider.testAfterUse", testAfterUse.toString());

    JiveGlobals.setXMLProperty(
        "database.defaultProvider.minConnections", Integer.toString(minConnections));
    JiveGlobals.setXMLProperty(
        "database.defaultProvider.maxConnections", Integer.toString(maxConnections));
    JiveGlobals.setXMLProperty(
        "database.defaultProvider.connectionTimeout", Double.toString(connectionTimeout));
  }
 /**
  * Sets the list of IP address that are allowed to connect to the server for anonymous users. If
  * the list is empty then anonymous will be only restricted by {@link #getAllowedIPs()}.
  *
  * @param allowed the list of IP address that are allowed to connect to the server.
  */
 public static void setAllowedAnonymIPs(Map<String, String> allowed) {
   allowedAnonymIPs = allowed;
   if (allowedAnonymIPs.isEmpty()) {
     JiveGlobals.deleteProperty("xmpp.client.login.allowedAnonym");
   } else {
     // Iterate through the elements in the map.
     StringBuilder buf = new StringBuilder();
     Iterator<String> iter = allowedAnonymIPs.keySet().iterator();
     if (iter.hasNext()) {
       buf.append(iter.next());
     }
     while (iter.hasNext()) {
       buf.append(", ").append(iter.next());
     }
     JiveGlobals.setProperty("xmpp.client.login.allowedAnonym", buf.toString());
   }
 }
  /**
   * Initializes the server's security audit provider, based on configuration and defaults to
   * DefaultSecurityAuditProvider if the specified provider is not valid or not specified.
   */
  private void initProvider() {
    // Convert XML based provider setup to Database based
    JiveGlobals.migrateProperty("provider.securityAudit.className");

    String className =
        JiveGlobals.getProperty(
            "provider.securityAudit.className",
            "org.jivesoftware.openfire.security.DefaultSecurityAuditProvider");
    // Check if we need to reset the provider class
    if (provider == null || !className.equals(provider.getClass().getName())) {
      try {
        Class c = ClassUtils.forName(className);
        provider = (SecurityAuditProvider) c.newInstance();
      } catch (Exception e) {
        Log.error("Error loading security audit provider: " + className, e);
        provider = new DefaultSecurityAuditProvider();
      }
    }
  }
Exemple #17
0
 /**
  * Returns a username based off of a registered name (possible JID) passed in.
  *
  * <p>If it already looks like a username, returns what was passed in.
  *
  * @param regName Registered name to turn into a username.
  * @return Converted registered name.
  */
 public String generateUsername(String regName) {
   if (regName.equals("{PLATFORM}")) {
     return JiveGlobals.getProperty("plugin.gateway.facebook.platform.apikey")
         + "|"
         + JiveGlobals.getProperty("plugin.gateway.facebook.platform.apisecret");
   } else if (regName.indexOf("@") > -1) {
     if (getTransport().getType().equals(TransportType.gtalk)) {
       return regName;
     } else {
       return regName.substring(0, regName.indexOf("@"));
     }
   } else {
     if (getTransport().getType().equals(TransportType.gtalk)) {
       return regName + "@gmail.com";
     } else {
       return regName;
     }
   }
 }
  /**
   * Returns true if the principal is explicity authorized to the JID
   *
   * @param principal The autheticated principal requesting authorization.
   * @return The name of the default username to use.
   */
  @Override
  public String map(String principal) {
    if (principal.contains("@")) {
      String realm = principal.substring(principal.lastIndexOf('@') + 1);
      String username = principal.substring(0, principal.lastIndexOf('@'));

      if (realm.length() > 0) {
        if (realm.equals(JiveGlobals.getProperty("xmpp.domain"))) {
          Log.debug("DefaultAuthorizationMapping: realm = xmpp.domain");
          return username;
        } else if (realm.equals(JiveGlobals.getProperty("sasl.realm"))) {
          Log.debug("DefaultAuthorizationMapping: ream = sasl.realm");
          return username;
        } else {
          for (String approvedRealm : approvedRealms) {
            if (realm.equals(approvedRealm)) {
              Log.debug(
                  "DefaultAuthorizationMapping: realm ("
                      + realm
                      + ") = "
                      + approvedRealm
                      + " which is approved");
              return username;
            } else {
              Log.debug(
                  "DefaultAuthorizationPolicy: realm ("
                      + realm
                      + ") != "
                      + approvedRealm
                      + " which is approved");
            }
          }
        }
        Log.debug("DefaultAuthorizationMapping: No approved mappings found.");
        return principal;
      } else {
        Log.debug("DefaultAuthorizationMapping: Realm has no length");
      }
    } else {
      Log.debug("DefaultAuthorizationMapping: No realm found");
    }
    return principal;
  }
  public DefaultAuthorizationMapping() {
    approvedRealms = new Vector<>();

    String realmList = JiveGlobals.getProperty("sasl.approvedRealms");
    if (realmList != null) {
      StringTokenizer st = new StringTokenizer(realmList, " ,\t\n\r\f");
      while (st.hasMoreTokens()) {
        approvedRealms.add(st.nextToken());
      }
    }
  }
Exemple #20
0
 /** Check GMail for new mail. */
 @Override
 public void run() {
   if (getTransport().getType().equals(TransportType.gtalk)
       && JiveGlobals.getBooleanProperty("plugin.gateway.gtalk.mailnotifications", true)) {
     GoogleMailNotifyExtension gmne = new GoogleMailNotifyExtension();
     gmne.setNewerThanTime(listener.getLastGMailThreadDate());
     gmne.setNewerThanTid(listener.getLastGMailThreadId());
     conn.sendPacket(
         new IQWithPacketExtension(generateFullJID(getRegistration().getUsername()), gmne));
   }
 }
  private DatabaseManager() {

    /*
     * Load time from globals if it is set. It represents the minutes the
     * log entries stay in database until they will get deleted
     */
    // TODO: Use PropertyEventListener to check if cleaner.minutes have
    // changed
    _dbCleanMinutes = JiveGlobals.getIntProperty("plugin.remoteroster.log.cleaner.minutes", 60);

    startDatabaseCleanLoop();
  }
Exemple #22
0
  public void startTLS(boolean clientMode, String remoteServer, ClientAuth authentication)
      throws Exception {
    boolean c2s = (remoteServer == null);
    KeyStore ksKeys = SSLConfig.getKeyStore();
    String keypass = SSLConfig.getKeyPassword();

    KeyStore ksTrust = (c2s ? SSLConfig.getc2sTrustStore() : SSLConfig.gets2sTrustStore());
    String trustpass = (c2s ? SSLConfig.getc2sTrustPassword() : SSLConfig.gets2sTrustPassword());
    if (c2s) Log.debug("NIOConnection: startTLS: using c2s");
    else Log.debug("NIOConnection: startTLS: using s2s");
    // KeyManager's decide which key material to use.
    KeyManager[] km = SSLJiveKeyManagerFactory.getKeyManagers(ksKeys, keypass);

    // TrustManager's decide whether to allow connections.
    TrustManager[] tm = SSLJiveTrustManagerFactory.getTrustManagers(ksTrust, trustpass);

    if (clientMode || authentication == ClientAuth.needed || authentication == ClientAuth.wanted) {
      // We might need to verify a certificate from our peer, so get different TrustManager[]'s
      if (c2s) {
        // Check if we can trust certificates presented by the client
        tm = new TrustManager[] {new ClientTrustManager(ksTrust)};
      } else {
        // Check if we can trust certificates presented by the server
        tm = new TrustManager[] {new ServerTrustManager(remoteServer, ksTrust, this)};
      }
    }

    String algorithm = JiveGlobals.getProperty(ConnectionSettings.Client.TLS_ALGORITHM, "TLS");
    SSLContext tlsContext = SSLContext.getInstance(algorithm);

    tlsContext.init(km, tm, null);

    SslFilter filter = new SslFilter(tlsContext);
    filter.setUseClientMode(clientMode);
    // Disable SSLv3 due to POODLE vulnerability.
    filter.setEnabledProtocols(new String[] {"TLSv1", "TLSv1.1", "TLSv1.2"});
    if (authentication == ClientAuth.needed) {
      filter.setNeedClientAuth(true);
    } else if (authentication == ClientAuth.wanted) {
      // Just indicate that we would like to authenticate the client but if client
      // certificates are self-signed or have no certificate chain then we are still
      // good
      filter.setWantClientAuth(true);
    }
    ioSession.getFilterChain().addAfter(EXECUTOR_FILTER_NAME, TLS_FILTER_NAME, filter);
    ioSession.setAttribute(SslFilter.DISABLE_ENCRYPTION_ONCE, Boolean.TRUE);

    if (!clientMode) {
      // Indicate the client that the server is ready to negotiate TLS
      deliverRawText("<proceed xmlns=\"urn:ietf:params:xml:ns:xmpp-tls\"/>");
    }
  }
 /**
  * Returns whether TLS is mandatory, optional or is disabled for clients. When TLS is mandatory
  * clients are required to secure their connections or otherwise their connections will be closed.
  * On the other hand, when TLS is disabled clients are not allowed to secure their connections
  * using TLS. Their connections will be closed if they try to secure the connection. in this last
  * case.
  *
  * @return whether TLS is mandatory, optional or is disabled.
  */
 public static SocketConnection.TLSPolicy getTLSPolicy() {
   // Set the TLS policy stored as a system property
   String policyName =
       JiveGlobals.getProperty("xmpp.client.tls.policy", Connection.TLSPolicy.optional.toString());
   SocketConnection.TLSPolicy tlsPolicy;
   try {
     tlsPolicy = Connection.TLSPolicy.valueOf(policyName);
   } catch (IllegalArgumentException e) {
     Log.error("Error parsing xmpp.client.tls.policy: " + policyName, e);
     tlsPolicy = Connection.TLSPolicy.optional;
   }
   return tlsPolicy;
 }
Exemple #24
0
  public String getMemoryData() {
    try {
      String port = JiveGlobals.getProperty("httpbind.port.plain", "7070");
      String host = XMPPServer.getInstance().getServerInfo().getHostname();
      String username = JiveGlobals.getProperty("jmxweb.admin.username", "admin");
      String password = JiveGlobals.getProperty("jmxweb.admin.password", "admin");

      URL url =
          new URL(
              "http://"
                  + username
                  + ":"
                  + password
                  + "@"
                  + host
                  + ":"
                  + port
                  + "/jolokia/read/java.lang:type=Memory/HeapMemoryUsage");
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setRequestMethod("GET");
      conn.setRequestProperty("Accept", "application/json");
      if (conn.getResponseCode() != 200) {
        throw new RuntimeException(
            "HTTP Call Failed : HTTP error code : " + conn.getResponseCode());
      }
      BufferedReader br = new BufferedReader(new InputStreamReader((conn.getInputStream())));
      while ((line = br.readLine()) != null) {
        resultString.append(line);
      }
      Log.info("Memory data: " + resultString.toString());
      conn.disconnect();

    } catch (MalformedURLException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return resultString.toString();
  }
 public ServerSocketReader(
     PacketRouter router,
     RoutingTable routingTable,
     String serverName,
     Socket socket,
     SocketConnection connection,
     boolean useBlockingMode) {
   super(router, routingTable, serverName, socket, connection, useBlockingMode);
   // Create a pool of threads that will process received packets. If more threads are
   // required then the command will be executed on the SocketReader process
   int coreThreads = JiveGlobals.getIntProperty("xmpp.server.processing.core.threads", 2);
   int maxThreads = JiveGlobals.getIntProperty("xmpp.server.processing.max.threads", 50);
   int queueSize = JiveGlobals.getIntProperty("xmpp.server.processing.queue", 50);
   threadPool =
       new ThreadPoolExecutor(
           coreThreads,
           maxThreads,
           60,
           TimeUnit.SECONDS,
           new LinkedBlockingQueue<Runnable>(queueSize),
           new ThreadPoolExecutor.CallerRunsPolicy());
 }
Exemple #26
0
  public Packet doAction(Packet packet) throws PacketRejectedException {
    SessionManager sessionManager = SessionManager.getInstance();
    ClientSession clientSession = sessionManager.getSession(packet.getFrom());
    Packet rejectPacket;
    String pfFrom = JiveGlobals.getProperty("pf.From", "packetfilter");

    if (packet instanceof Message) {
      Message in = (Message) packet.createCopy();
      if (clientSession != null && in.getBody() != null) {

        in.setFrom(new JID(pfFrom));
        String rejectMessage =
            JiveGlobals.getProperty(
                "pf.rejectMessage", "Your message was rejected by the packet filter");
        in.setBody(rejectMessage);
        in.setType(Message.Type.error);
        in.setTo(packet.getFrom());
        String rejectSubject = JiveGlobals.getProperty("pf.rejectSubject", "Rejected");
        in.setSubject(rejectSubject);
        clientSession.process(in);
      }

    } else if (packet instanceof Presence) {
      rejectPacket = new Presence();
      rejectPacket.setTo(packet.getFrom());
      rejectPacket.setError(PacketError.Condition.forbidden);

    } else if (packet instanceof IQ) {
      rejectPacket = new IQ();
      rejectPacket.setTo(packet.getFrom());
      rejectPacket.setError(PacketError.Condition.forbidden);
    }
    if (doLog()) {
      Log.info("Rejecting packet from " + packet.getFrom() + " to " + packet.getTo());
    }
    throw new PacketRejectedException();
  }
  /** Constructs a new login limit manager. */
  private LoginLimitManager() {
    // Set up initial maps
    attemptsPerIP = new ConcurrentHashMap<String, Long>();
    attemptsPerUsername = new ConcurrentHashMap<String, Long>();

    // Max number of attempts per ip address that can be performed in given time frame (10 attempts
    // default)
    maxAttemptsPerIP = JiveGlobals.getLongProperty("adminConsole.maxAttemptsPerIP", 10);
    // Time frame before attempts per ip addresses are reset (15 minutes default)
    millisecondsBetweenPerIP =
        JiveGlobals.getLongProperty("adminConsole.perIPAttemptResetInterval", 900000);
    // Max number of attempts per username that can be performed in a given time frame (10 attempts
    // default)
    maxAttemptsPerUsername = JiveGlobals.getLongProperty("adminConsole.maxAttemptsPerUsername", 10);
    // Time frame before attempts per ip addresses are reset (15 minutes default)
    millisecondsBetweenPerUsername =
        JiveGlobals.getLongProperty("adminConsole.perUsernameAttemptResetInterval", 900000);
    // Set up per username attempt reset task
    TaskEngine.getInstance()
        .scheduleAtFixedRate(new PerUsernameTask(), 0, millisecondsBetweenPerUsername);
    // Set up per IP attempt reset task
    TaskEngine.getInstance()
        .scheduleAtFixedRate(new PerIPAddressTask(), 0, millisecondsBetweenPerIP);
  }
  private void init() {
    // Create a pool of threads that will process incoming packets.
    int maxThreads = JiveGlobals.getIntProperty("xmpp.manager.incoming.threads", 5);
    if (maxThreads < 1) {
      // Ensure that the max number of threads in the pool is at least 1
      maxThreads = 1;
    }
    threadPool =
        new ThreadPoolExecutor(
            maxThreads,
            maxThreads,
            60,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(),
            new ThreadPoolExecutor.CallerRunsPolicy());

    // Create a thread that will read and store DOM Elements.
    Thread thread =
        new Thread("Server Packet Reader") {
          public void run() {
            while (open) {
              Element doc;
              try {
                doc = reader.parseDocument().getRootElement();

                if (doc == null) {
                  // Stop reading the stream since the remote server has sent an end of
                  // stream element and probably closed the connection.
                  shutdown();
                } else {
                  // Queue task that process incoming stanzas
                  threadPool.execute(new ProcessStanzaTask(packetsHandler, doc));
                }
              } catch (IOException e) {
                Log.debug("Finishing Incoming Server Stanzas Reader.", e);
                shutdown();
              } catch (Exception e) {
                Log.error("Finishing Incoming Server Stanzas Reader.", e);
                shutdown();
              }
            }
          }
        };
    thread.setDaemon(true);
    thread.start();
  }
Exemple #29
0
 private GroupManager() {
   // Initialize caches.
   CacheManager.initializeCache("group", 128 * 1024);
   CacheManager.initializeCache("group member", 32 * 1024);
   groupCache = CacheManager.getCache("group");
   // Load a group provider.
   String className =
       JiveGlobals.getXMLProperty(
           "provider.group.className", "org.jivesoftware.wildfire.group.DefaultGroupProvider");
   try {
     Class c = ClassUtils.forName(className);
     provider = (GroupProvider) c.newInstance();
   } catch (Exception e) {
     Log.error("Error loading group provider: " + className, e);
     provider = new DefaultGroupProvider();
   }
 }
Exemple #30
0
  private void deliverRawText(String text, boolean asynchronous) {
    if (!isClosed()) {
      boolean errorDelivering = false;
      IoBuffer buffer = IoBuffer.allocate(text.length());
      buffer.setAutoExpand(true);
      try {
        // Charset charset = Charset.forName(CHARSET);
        // buffer.putString(text, charset.newEncoder());
        buffer.put(text.getBytes(CHARSET));
        if (flashClient) {
          buffer.put((byte) '\0');
        }
        buffer.flip();
        ioSessionLock.lock();
        try {
          if (asynchronous) {
            // OF-464: handle dropped connections (no backupDeliverer in this case?)
            if (!ioSession.isConnected()) {
              throw new IOException("Connection reset/closed by peer");
            }
            ioSession.write(buffer);
          } else {
            // Send stanza and wait for ACK (using a 2 seconds default timeout)
            boolean ok =
                ioSession
                    .write(buffer)
                    .awaitUninterruptibly(
                        JiveGlobals.getIntProperty("connection.ack.timeout", 2000));
            if (!ok) {
              Log.warn("No ACK was received when sending stanza to: " + this.toString());
            }
          }
        } finally {
          ioSessionLock.unlock();
        }
      } catch (Exception e) {
        Log.debug("Error delivering raw text:\n" + text, e);
        errorDelivering = true;
      }

      // Close the connection if delivering text fails and we are already not closing the connection
      if (errorDelivering && asynchronous) {
        close();
      }
    }
  }