コード例 #1
0
/**
 * Transport resolver using the JSTUN library, to discover public IP and use it as a candidate.
 *
 * <p>The goal of this resolver is to take possible to establish and manage out-of-band connections
 * between two XMPP entities, even if they are behind Network Address Translators (NATs) or
 * firewalls.
 *
 * @author Thiago Camargo
 */
public class STUNResolver extends TransportResolver {

  /** STUN service definition. */
  protected class STUNService {

    private String hostname; // The hostname of the service

    private int port; // The port number

    /** Default constructor, without name and port. */
    public STUNService() {
      this(null, -1);
    }

    /**
     * Basic constructor, with the hostname and port
     *
     * @param hostname The hostname
     * @param port The port
     */
    public STUNService(String hostname, int port) {
      super();

      this.hostname = hostname;
      this.port = port;
    }

    /**
     * Check a binding with the STUN currentServer.
     *
     * <p>Note: this function blocks for some time, waiting for a response.
     *
     * @return true if the currentServer is usable.
     */
    public boolean checkBinding() {
      final boolean result = false;

      try {
        final BindingLifetimeTest binding = new BindingLifetimeTest(hostname, port);

        binding.test();

        while (true) {
          Thread.sleep(5000);
          if (binding.getLifetime() != -1) {
            if (binding.isCompleted()) {
              return true;
            }
          } else {
            break;
          }
        }
      } catch (final Exception e) {
        LOGGER.error(e.getMessage(), e);
      }

      return result;
    }

    /**
     * Get the host name of the STUN service.
     *
     * @return The host name
     */
    public String getHostname() {
      return hostname;
    }

    /**
     * Get the port of the STUN service
     *
     * @return The port number where the STUN server is waiting.
     */
    public int getPort() {
      return port;
    }

    /**
     * Basic format test: the service is not null.
     *
     * @return true if the hostname and port are null
     */
    public boolean isNull() {
      if (hostname == null) {
        return true;
      } else if (hostname.length() == 0) {
        return true;
      } else if (port < 0) {
        return true;
      } else {
        return false;
      }
    }

    /**
     * Set the hostname of the STUN service.
     *
     * @param hostname The host name of the service.
     */
    public void setHostname(String hostname) {
      this.hostname = hostname;
    }

    /**
     * Set the port number for the STUN service.
     *
     * @param port The port number.
     */
    public void setPort(int port) {
      this.port = port;
    }
  }

  private static final SmackLogger LOGGER = SmackLogger.getLogger(STUNResolver.class);

  // The filename where the STUN servers are stored.
  public static final String STUNSERVERS_FILENAME = "META-INF/stun-config.xml";

  // Current STUN server we are using
  protected STUNService currentServer;

  protected Thread resolverThread;

  protected int defaultPort;
  protected String resolvedPublicIP;

  protected String resolvedLocalIP;

  /** Constructor with default STUN server. */
  public STUNResolver() {
    super();

    defaultPort = 0;
    currentServer = new STUNService();
  }

  /**
   * Constructor with a default port.
   *
   * @param defaultPort Port to use by default.
   */
  public STUNResolver(int defaultPort) {
    this();

    this.defaultPort = defaultPort;
  }

  /**
   * Get the best usable STUN server from a list.
   *
   * @return the best STUN server that can be used.
   */
  private STUNService bestSTUNServer(ArrayList listServers) {
    if (listServers.isEmpty()) {
      return null;
    } else {
      // TODO: this should use some more advanced criteria...
      return (STUNService) listServers.get(0);
    }
  }

  /**
   * Cancel any operation.
   *
   * @see TransportResolver#cancel()
   */
  @Override
  public synchronized void cancel() throws XMPPException {
    if (isResolving()) {
      resolverThread.interrupt();
      setResolveEnd();
    }
  }

  /**
   * Clear the list of candidates and start the resolution again.
   *
   * @see TransportResolver#clear()
   */
  @Override
  public synchronized void clear() throws XMPPException {
    defaultPort = 0;
    super.clear();
  }

  /**
   * Get the name of the current STUN server.
   *
   * @return the name of the STUN server
   */
  public String getCurrentServerName() {
    if (!currentServer.isNull()) {
      return currentServer.getHostname();
    } else {
      return null;
    }
  }

  /**
   * Get the port of the current STUN server.
   *
   * @return the port of the STUN server
   */
  public int getCurrentServerPort() {
    if (!currentServer.isNull()) {
      return currentServer.getPort();
    } else {
      return 0;
    }
  }

  /**
   * Initialize the resolver.
   *
   * @throws XMPPException
   */
  @Override
  public void initialize() throws XMPPException {
    LOGGER.debug("Initialized");
    if (!isResolving() && !isResolved()) {
      // Get the best STUN server available
      if (currentServer.isNull()) {
        loadSTUNServers();
      }
      // We should have a valid STUN server by now...
      if (!currentServer.isNull()) {

        clearCandidates();

        resolverThread =
            new Thread(
                new Runnable() {
                  @Override
                  public void run() {
                    // Iterate through the list of interfaces, and ask
                    // to the STUN server for our address.
                    try {
                      final Enumeration ifaces = NetworkInterface.getNetworkInterfaces();
                      String candAddress;
                      int candPort;

                      while (ifaces.hasMoreElements()) {

                        final NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
                        final Enumeration iaddresses = iface.getInetAddresses();

                        while (iaddresses.hasMoreElements()) {
                          final InetAddress iaddress = (InetAddress) iaddresses.nextElement();
                          if (!iaddress.isLoopbackAddress() && !iaddress.isLinkLocalAddress()) {

                            // Reset the candidate
                            candAddress = null;
                            candPort = -1;

                            final DiscoveryTest test =
                                new DiscoveryTest(
                                    iaddress, currentServer.getHostname(), currentServer.getPort());
                            try {
                              // Run the tests and get the
                              // discovery
                              // information, where all the
                              // info is stored...
                              final DiscoveryInfo di = test.test();

                              candAddress =
                                  di.getPublicIP() != null
                                      ? di.getPublicIP().getHostAddress()
                                      : null;

                              // Get a valid port
                              if (defaultPort == 0) {
                                candPort = getFreePort();
                              } else {
                                candPort = defaultPort;
                              }

                              // If we have a valid candidate,
                              // add it to the list.
                              if (candAddress != null && candPort >= 0) {
                                final TransportCandidate candidate =
                                    new TransportCandidate.Fixed(candAddress, candPort);
                                candidate.setLocalIp(
                                    iaddress.getHostAddress() != null
                                        ? iaddress.getHostAddress()
                                        : iaddress.getHostName());
                                addCandidate(candidate);

                                resolvedPublicIP = candidate.getIp();
                                resolvedLocalIP = candidate.getLocalIp();
                                return;
                              }
                            } catch (final Exception e) {
                              LOGGER.error(e.getMessage(), e);
                            }
                          }
                        }
                      }
                    } catch (final SocketException e) {
                      LOGGER.error(e.getMessage(), e);
                    } finally {
                      setInitialized();
                    }
                  }
                },
                "Waiting for all the transport candidates checks...");

        resolverThread.setName("STUN resolver");
        resolverThread.start();
      } else {
        throw new IllegalStateException("No valid STUN server found.");
      }
    }
  }

  /**
   * Return true if the service is working.
   *
   * @see TransportResolver#isResolving()
   */
  @Override
  public boolean isResolving() {
    return super.isResolving() && resolverThread != null;
  }

  /**
   * Load a list of services: STUN servers and ports. Some public STUN servers are:
   *
   * <p>
   *
   * <pre>
   *               iphone-stun.freenet.de:3478
   *               larry.gloo.net:3478
   *               stun.xten.net:3478
   *               stun.fwdnet.net
   *               stun.fwd.org (no DNS SRV record)
   *               stun01.sipphone.com (no DNS SRV record)
   *               stun.softjoys.com (no DNS SRV record)
   *               stun.voipbuster.com (no DNS SRV record)
   *               stun.voxgratia.org (no DNS SRV record)
   *               stun.noc.ams-ix.net
   * </pre>
   *
   * <p>This list should be contained in a file in the "META-INF" directory
   *
   * @return a list of services
   */
  public ArrayList loadSTUNServers() {
    final ArrayList serversList = new ArrayList();

    // Load the STUN configuration
    try {
      // Get an array of class loaders to try loading the config from.
      final ClassLoader[] classLoaders = new ClassLoader[2];
      classLoaders[0] = new STUNResolver() {}.getClass().getClassLoader();
      classLoaders[1] = Thread.currentThread().getContextClassLoader();

      for (final ClassLoader classLoader : classLoaders) {
        final Enumeration stunConfigEnum = classLoader.getResources(STUNSERVERS_FILENAME);

        while (stunConfigEnum.hasMoreElements() && serversList.isEmpty()) {
          final URL url = (URL) stunConfigEnum.nextElement();
          java.io.InputStream stunConfigStream = null;

          stunConfigStream = url.openStream();
          serversList.addAll(loadSTUNServers(stunConfigStream));
          stunConfigStream.close();
        }
      }
    } catch (final Exception e) {
      LOGGER.error(e.getMessage(), e);
    }

    return serversList;
  }

  /**
   * Load the STUN configuration from a stream.
   *
   * @param stunConfigStream An InputStream with the configuration file.
   * @return A list of loaded servers
   */
  public ArrayList loadSTUNServers(java.io.InputStream stunConfigStream) {
    final ArrayList serversList = new ArrayList();
    String serverName;
    int serverPort;

    try {
      final XmlPullParser parser = new MXParser();
      parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
      parser.setInput(stunConfigStream, "UTF-8");

      int eventType = parser.getEventType();
      do {
        if (eventType == XmlPullParser.START_TAG) {

          // Parse a STUN server definition
          if (parser.getName().equals("stunServer")) {

            serverName = null;
            serverPort = -1;

            // Parse the hostname
            parser.next();
            parser.next();
            serverName = parser.nextText();

            // Parse the port
            parser.next();
            parser.next();
            try {
              serverPort = Integer.parseInt(parser.nextText());
            } catch (final Exception e) {
            }

            // If we have a valid hostname and port, add
            // it to the list.
            if (serverName != null && serverPort != -1) {
              final STUNService service = new STUNService(serverName, serverPort);

              serversList.add(service);
            }
          }
        }
        eventType = parser.next();

      } while (eventType != XmlPullParser.END_DOCUMENT);

    } catch (final XmlPullParserException e) {
      LOGGER.error(e.getMessage(), e);
    } catch (final IOException e) {
      LOGGER.error(e.getMessage(), e);
    }

    currentServer = bestSTUNServer(serversList);

    return serversList;
  }

  /** Resolve the IP and obtain a valid transport method. */
  @Override
  public synchronized void resolve(JingleSession session) throws XMPPException {

    setResolveInit();

    clearCandidates();

    final TransportCandidate candidate =
        new TransportCandidate.Fixed(resolvedPublicIP, getFreePort());
    candidate.setLocalIp(resolvedLocalIP);

    LOGGER.debug("RESOLVING : " + resolvedPublicIP + ":" + candidate.getPort());

    addCandidate(candidate);

    setResolveEnd();
  }

  /**
   * Set the STUN server name and port
   *
   * @param ip the STUN server name
   * @param port the STUN server port
   */
  public void setSTUNService(String ip, int port) {
    currentServer = new STUNService(ip, port);
  }
}
コード例 #2
0
/**
 * An image Quantizer based on the Octree algorithm. This is a very basic implementation at present
 * and could be much improved by picking the nodes to reduce more carefully (i.e. not completely at
 * random) when I get the time.
 */
public class OctTreeQuantizer implements Quantizer {

  private static final SmackLogger LOGGER = SmackLogger.getLogger(OctTreeQuantizer.class);

  /** The greatest depth the tree is allowed to reach */
  static final int MAX_LEVEL = 5;

  /** An Octtree node. */
  class OctTreeNode {
    int children;
    int level;
    OctTreeNode parent;
    OctTreeNode leaf[] = new OctTreeNode[8];
    boolean isLeaf;
    int count;
    int totalRed;
    int totalGreen;
    int totalBlue;
    int index;

    /** A debugging method which prints the tree out. */
    public void list(PrintStream s, int level) {
      String indentStr = "";
      for (int i = 0; i < level; i++) indentStr += " ";
      if (count == 0) LOGGER.debug(indentStr + index + ": count=" + count);
      else
        LOGGER.debug(
            indentStr
                + index
                + ": count="
                + count
                + " red="
                + (totalRed / count)
                + " green="
                + (totalGreen / count)
                + " blue="
                + (totalBlue / count));
      for (int i = 0; i < 8; i++) if (leaf[i] != null) leaf[i].list(s, level + 2);
    }
  }

  private int nodes = 0;
  private OctTreeNode root;
  private int reduceColors;
  private int maximumColors;
  private int colors = 0;
  private Vector[] colorList;

  public OctTreeQuantizer() {
    setup(256);
    colorList = new Vector[MAX_LEVEL + 1];
    for (int i = 0; i < MAX_LEVEL + 1; i++) colorList[i] = new Vector();
    root = new OctTreeNode();
  }

  /**
   * Initialize the quantizer. This should be called before adding any pixels.
   *
   * @param numColors the number of colors we're quantizing to.
   */
  public void setup(int numColors) {
    maximumColors = numColors;
    reduceColors = Math.max(512, numColors * 2);
  }

  /**
   * Add pixels to the quantizer.
   *
   * @param pixels the array of ARGB pixels
   * @param offset the offset into the array
   * @param count the count of pixels
   */
  public void addPixels(int[] pixels, int offset, int count) {
    for (int i = 0; i < count; i++) {
      insertColor(pixels[i + offset]);
      if (colors > reduceColors) reduceTree(reduceColors);
    }
  }

  /**
   * Get the color table index for a color.
   *
   * @param rgb the color
   * @return the index
   */
  public int getIndexForColor(int rgb) {
    int red = (rgb >> 16) & 0xff;
    int green = (rgb >> 8) & 0xff;
    int blue = rgb & 0xff;

    OctTreeNode node = root;

    for (int level = 0; level <= MAX_LEVEL; level++) {
      OctTreeNode child;
      int bit = 0x80 >> level;

      int index = 0;
      if ((red & bit) != 0) index += 4;
      if ((green & bit) != 0) index += 2;
      if ((blue & bit) != 0) index += 1;

      child = node.leaf[index];

      if (child == null) return node.index;
      else if (child.isLeaf) return child.index;
      else node = child;
    }
    LOGGER.debug("getIndexForColor failed");
    return 0;
  }

  private void insertColor(int rgb) {
    int red = (rgb >> 16) & 0xff;
    int green = (rgb >> 8) & 0xff;
    int blue = rgb & 0xff;

    OctTreeNode node = root;

    //		LOGGER.debug("insertColor="+Integer.toHexString(rgb));
    for (int level = 0; level <= MAX_LEVEL; level++) {
      OctTreeNode child;
      int bit = 0x80 >> level;

      int index = 0;
      if ((red & bit) != 0) index += 4;
      if ((green & bit) != 0) index += 2;
      if ((blue & bit) != 0) index += 1;

      child = node.leaf[index];

      if (child == null) {
        node.children++;

        child = new OctTreeNode();
        child.parent = node;
        node.leaf[index] = child;
        node.isLeaf = false;
        nodes++;
        colorList[level].addElement(child);

        if (level == MAX_LEVEL) {
          child.isLeaf = true;
          child.count = 1;
          child.totalRed = red;
          child.totalGreen = green;
          child.totalBlue = blue;
          child.level = level;
          colors++;
          return;
        }

        node = child;
      } else if (child.isLeaf) {
        child.count++;
        child.totalRed += red;
        child.totalGreen += green;
        child.totalBlue += blue;
        return;
      } else node = child;
    }
    LOGGER.debug("insertColor failed");
  }

  private void reduceTree(int numColors) {
    for (int level = MAX_LEVEL - 1; level >= 0; level--) {
      Vector v = colorList[level];
      if (v != null && v.size() > 0) {
        for (int j = 0; j < v.size(); j++) {
          OctTreeNode node = (OctTreeNode) v.elementAt(j);
          if (node.children > 0) {
            for (int i = 0; i < 8; i++) {
              OctTreeNode child = node.leaf[i];
              if (child != null) {
                if (!child.isLeaf) LOGGER.debug("not a leaf!");
                node.count += child.count;
                node.totalRed += child.totalRed;
                node.totalGreen += child.totalGreen;
                node.totalBlue += child.totalBlue;
                node.leaf[i] = null;
                node.children--;
                colors--;
                nodes--;
                colorList[level + 1].removeElement(child);
              }
            }
            node.isLeaf = true;
            colors++;
            if (colors <= numColors) return;
          }
        }
      }
    }

    LOGGER.debug("Unable to reduce the OctTree");
  }

  /**
   * Build the color table.
   *
   * @return the color table
   */
  public int[] buildColorTable() {
    int[] table = new int[colors];
    buildColorTable(root, table, 0);
    return table;
  }

  /**
   * A quick way to use the quantizer. Just create a table the right size and pass in the pixels.
   *
   * @param inPixels the input colors
   * @param table the output color table
   */
  public void buildColorTable(int[] inPixels, int[] table) {
    int count = inPixels.length;
    maximumColors = table.length;
    for (int i = 0; i < count; i++) {
      insertColor(inPixels[i]);
      if (colors > reduceColors) reduceTree(reduceColors);
    }
    if (colors > maximumColors) reduceTree(maximumColors);
    buildColorTable(root, table, 0);
  }

  private int buildColorTable(OctTreeNode node, int[] table, int index) {
    if (colors > maximumColors) reduceTree(maximumColors);

    if (node.isLeaf) {
      int count = node.count;
      table[index] =
          0xff000000
              | ((node.totalRed / count) << 16)
              | ((node.totalGreen / count) << 8)
              | node.totalBlue / count;
      node.index = index++;
    } else {
      for (int i = 0; i < 8; i++) {
        if (node.leaf[i] != null) {
          node.index = index;
          index = buildColorTable(node.leaf[i], table, index);
        }
      }
    }
    return index;
  }
}