示例#1
0
 /**
  * Calculate the ver attribute.
  *
  * @param info The discover info to calculate the ver.
  * @param hashMethod the hash algorithm to use.
  * @return the value of the ver attribute
  * @throws NoSuchAlgorithmException if the hash algorithm is not supported.
  */
 private String calculateVer(DiscoverInfo info, String hashMethod)
     throws NoSuchAlgorithmException {
   StringBuilder s = new StringBuilder();
   for (DiscoverInfo.Identity identity : getSortedIdentity(info)) {
     String c = identity.getCategory();
     if (c != null) s.append(c);
     s.append('/');
     c = identity.getType();
     if (c != null) s.append(c);
     s.append('/');
     // Should add lang but it is not available
     //             c = identity.getType();
     //             if (c != null)
     //                 S.append(c);
     s.append('/');
     c = identity.getName();
     if (c != null) s.append(c);
     s.append('<');
   }
   for (String f : getSortedFeature(info)) {
     s.append(f);
     s.append('<');
   }
   // Should add data form (XEP 0128) but it is not available
   byte[] hash = getHash(hashMethod, s.toString().getBytes());
   return StringUtils.encodeBase64(hash);
 }
示例#2
0
  public PubSubNodeInfo getNodeDetails(String nodeId) throws SoxLibException {
    PubSubNodeInfo result = new PubSubNodeInfo();
    DiscoverInfo di = null;
    try {
      Node node = mPubSubManager.getNode(nodeId);
      if (!(node instanceof LeafNode)) {
        throw new SoxLibException("Expecting leaf node, but got something else:" + nodeId);
      }
      LeafNode leaf = (LeafNode) node;
      di = leaf.discoverInfo();
    } catch (XMPPException e) {
      throw new SoxLibException("Problem accessing node list:" + nodeId);
    }

    // Expect one and only one identity.
    Iterator<DiscoverInfo.Identity> iter = di.getIdentities();
    if (iter.hasNext()) {
      DiscoverInfo.Identity info = iter.next();
      // logger.log(Level.FINER, "type:" + info.getType());
      // logger.log(Level.FINER, "cat:" + info.getCategory());
      result.nodeType = info.getType();
      // Assert iter.hasNext == false
    }

    // If no form data, returns null for this field.
    result.nodeForm = (DataForm) di.getExtension("jabber:x:data");

    return result;
  }
示例#3
0
 /**
  * Get the Discover Information send by your own connection.
  *
  * @return your own DiscoverInfo
  */
 private DiscoverInfo getOwnInformation() {
   DiscoverInfo result = new DiscoverInfo();
   DiscoverInfo.Identity id =
       new DiscoverInfo.Identity("client", ServiceDiscoveryManager.getIdentityName());
   id.setType(ServiceDiscoveryManager.getIdentityType());
   result.addIdentity(id);
   Iterator<String> it = mSdm.getFeatures();
   while (it.hasNext()) {
     result.addFeature(it.next());
   }
   return result;
 }
 /** Discover the features provided by the server. */
 private void discoverServerFeatures() {
   try {
     // jid et server
     ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(mAdaptee);
     DiscoverInfo info = sdm.discoverInfo(mAdaptee.getServiceName());
     Iterator<DiscoverInfo.Identity> it = info.getIdentities();
     while (it.hasNext()) {
       DiscoverInfo.Identity identity = it.next();
       if ("pubsub".equals(identity.getCategory()) && "pep".equals(identity.getType())) {
         initPEP();
       }
     }
   } catch (XMPPException e) {
     Log.w(TAG, "Unable to discover server features", e);
   }
 }
 /**
  * Checks the service discovery item returned from a server component to verify if it is a File
  * Transfer proxy or not.
  *
  * @param manager the service discovery manager which will be used to query the component
  * @param item the discovered item on the server relating
  * @return returns the JID of the proxy if it is a proxy or null if the item is not a proxy.
  */
 private String checkIsProxy(ServiceDiscoveryManager manager, DiscoverItems.Item item) {
   DiscoverInfo info;
   try {
     info = manager.discoverInfo(item.getEntityID());
   } catch (XMPPException e) {
     return null;
   }
   Iterator itx = info.getIdentities();
   while (itx.hasNext()) {
     DiscoverInfo.Identity identity = (DiscoverInfo.Identity) itx.next();
     if ("proxy".equalsIgnoreCase(identity.getCategory())
         && "bytestreams".equalsIgnoreCase(identity.getType())) {
       return info.getFrom();
     }
   }
   return null;
 }
示例#6
0
  /**
   * Add discover info response data.
   *
   * @param response the discover info response packet
   */
  public void addDiscoverInfoTo(DiscoverInfo response) {
    // Set this client identity
    DiscoverInfo.Identity identity = new DiscoverInfo.Identity("client", getIdentityName());
    identity.setType(getIdentityType());
    response.addIdentity(identity);
    // Add the registered features to the response
    synchronized (features) {
      // Add Entity Capabilities (XEP-0115) feature node.
      response.addFeature("http://jabber.org/protocol/caps");

      for (Iterator<String> it = getFeatures(); it.hasNext(); ) {
        response.addFeature(it.next());
      }
      if (extendedInfo != null) {
        response.addExtension(extendedInfo);
      }
    }
  }
示例#7
0
  /**
   * Calculates the <tt>String</tt> for a specific <tt>DiscoverInfo</tt> which is to be hashed in
   * order to compute the ver string for that <tt>DiscoverInfo</tt>.
   *
   * @param discoverInfo the <tt>DiscoverInfo</tt> for which the <tt>String</tt> to be hashed in
   *     order to compute its ver string is to be calculated
   * @return the <tt>String</tt> for <tt>discoverInfo</tt> which is to be hashed in order to compute
   *     its ver string
   */
  private static String calculateEntityCapsString(DiscoverInfo discoverInfo) {
    StringBuilder bldr = new StringBuilder();

    // Add identities
    {
      Iterator<DiscoverInfo.Identity> identities = discoverInfo.getIdentities();
      SortedSet<DiscoverInfo.Identity> is =
          new TreeSet<DiscoverInfo.Identity>(
              new Comparator<DiscoverInfo.Identity>() {
                public int compare(DiscoverInfo.Identity i1, DiscoverInfo.Identity i2) {
                  int category = i1.getCategory().compareTo(i2.getCategory());

                  if (category != 0) return category;

                  int type = i1.getType().compareTo(i2.getType());

                  if (type != 0) return type;

                  /*
                   * TODO Sort by xml:lang.
                   *
                   * Since sort by xml:lang is currently missing,
                   * use the last supported sort criterion i.e.
                   * type.
                   */
                  return type;
                }
              });

      if (identities != null) while (identities.hasNext()) is.add(identities.next());

      for (DiscoverInfo.Identity i : is) {
        bldr.append(i.getCategory())
            .append('/')
            .append(i.getType())
            .append("//")
            .append(i.getName())
            .append('<');
      }
    }

    // Add features
    {
      Iterator<DiscoverInfo.Feature> features = getDiscoverInfoFeatures(discoverInfo);
      SortedSet<String> fs = new TreeSet<String>();

      if (features != null) while (features.hasNext()) fs.add(features.next().getVar());

      for (String f : fs) bldr.append(f).append('<');
    }

    DataForm extendedInfo = (DataForm) discoverInfo.getExtension("x", "jabber:x:data");

    if (extendedInfo != null) {
      synchronized (extendedInfo) {
        SortedSet<FormField> fs =
            new TreeSet<FormField>(
                new Comparator<FormField>() {
                  public int compare(FormField f1, FormField f2) {
                    return f1.getVariable().compareTo(f2.getVariable());
                  }
                });

        FormField formType = null;

        for (Iterator<FormField> fieldsIter = extendedInfo.getFields(); fieldsIter.hasNext(); ) {
          FormField f = fieldsIter.next();
          if (!f.getVariable().equals("FORM_TYPE")) fs.add(f);
          else formType = f;
        }

        // Add FORM_TYPE values
        if (formType != null) formFieldValuesToCaps(formType.getValues(), bldr);

        // Add the other values
        for (FormField f : fs) {
          bldr.append(f.getVariable()).append('<');
          formFieldValuesToCaps(f.getValues(), bldr);
        }
      }
    }

    return bldr.toString();
  }