Java 类soot.jimple.infoflow.android.resources.ARSCFileParser.StringResource 实例源码

@Override
public void attr(String ns, String name, int resourceId, int type, Object obj) {
    // Is this the target file attribute?
    String tname = name.trim();
    if (tname.equals("layout")) {
        if (type == AxmlVisitor.TYPE_REFERENCE && obj instanceof Integer) {
            // We need to get the target XML file from the binary manifest
            AbstractResource targetRes = resParser.findResource((Integer) obj);
            if (targetRes == null) {
                logger.trace(Utils.INDENT + "Target resource " + obj + " for layout include not found");
                return;
            }    
            if (!(targetRes instanceof StringResource)) {
                logger.trace(Utils.INDENT + "Invalid target node for include tag in layout XML, was " + targetRes.getClass().getName());
                return;
            }    
            String targetFile = ((StringResource) targetRes).getValue();

            // If we have already processed the target file, we can
            // simply copy the callbacks we have found there
            if (callbackMethods.containsKey(targetFile))
                for (String callback : callbackMethods.get(targetFile))
                    addCallbackMethod(layoutFile, callback);
            else {
                // We need to record a dependency to resolve later
                MapUtils.addToSet(includeDependencies, targetFile, layoutFile);
            }    
        }    
    }    

    super.attr(ns, name, resourceId, type, obj);
}

/**
 * Parses the attributes required for a layout file inclusion
 * @param layoutFile The full path and file name of the file being parsed
 * @param rootNode The AXml node containing the attributes
 */
private void parseIncludeAttributes(String layoutFile, AXmlNode rootNode) {
    for (Entry<String, AXmlAttribute<?>> entry : rootNode.getAttributes().entrySet()) {
        String attrName = entry.getKey().trim();
        AXmlAttribute<?> attr = entry.getValue();

        if (attrName.equals("layout")) {
            if ((attr.getType() == AxmlVisitor.TYPE_REFERENCE || attr.getType() == AxmlVisitor.TYPE_INT_HEX)
                    && attr.getValue() instanceof Integer) {
                // We need to get the target XML file from the binary manifest
                AbstractResource targetRes = resParser.findResource((Integer) attr.getValue());
                if (targetRes == null) {
                    System.err.println("Target resource " + attr.getValue() + " for layout include not found");
                    return;
                }
                if (!(targetRes instanceof StringResource)) {
                    System.err.println("Invalid target node for include tag in layout XML, was "
                            + targetRes.getClass().getName());
                    return;
                }
                String targetFile = ((StringResource) targetRes).getValue();

                // If we have already processed the target file, we can
                // simply copy the callbacks we have found there
                if (callbackMethods.containsKey(targetFile))
                    for (String callback : callbackMethods.get(targetFile))
                        addCallbackMethod(layoutFile, callback);
                else {
                    // We need to record a dependency to resolve later
                    addToMapSet(includeDependencies, targetFile, layoutFile);
                }
            }
        }
    }
}

/**
 * Collects the XML-based callback methods, e.g., Button.onClick() declared in layout XML files
 *
 * @param resParser The ARSC resource parser
 * @param lfp The layout file parser
 * @param jimpleClass The analysis class that gives us a mapping between layout IDs and components
 */
private void collectXmlBasedCallbackMethods(ARSCFileParser resParser, LayoutFileParser lfp,
    AbstractCallbackAnalyzer jimpleClass) {
  // Collect the XML-based callback methods
  for (Entry<String, Set<Integer>> lcentry : jimpleClass.getLayoutClasses().entrySet()) {
    final SootClass callbackClass = Scene.v().getSootClass(lcentry.getKey());

    for (Integer classId : lcentry.getValue()) {
      AbstractResource resource = resParser.findResource(classId);
      if (resource instanceof StringResource) {
        final String layoutFileName = ((StringResource) resource).getValue();

        // Add the callback methods for the given class
        Set<String> callbackMethods = lfp.getCallbackMethods().get(layoutFileName);
        if (callbackMethods != null) {
          for (String methodName : callbackMethods) {
            final String subSig = "void " + methodName + "(android.view.View)";

            // The callback may be declared directly in the
            // class
            // or in one of the superclasses
            SootClass currentClass = callbackClass;
            while (true) {
              SootMethod callbackMethod = currentClass.getMethodUnsafe(subSig);
              if (callbackMethod != null) {
                addCallbackMethod(callbackClass.getName(), new AndroidMethod(callbackMethod));
                break;
              }
              if (!currentClass.hasSuperclass()) {
                System.err.println("Callback method " + methodName + " not found in class "
                    + callbackClass.getName());
                break;
              }
              currentClass = currentClass.getSuperclass();
            }
          }
        }

        // For user-defined views, we need to emulate their
        // callbacks
        Set<LayoutControl> controls = lfp.getUserControls().get(layoutFileName);
        if (controls != null) {
          for (LayoutControl lc : controls) {
            registerCallbackMethodsForView(callbackClass, lc);
          }
        }
      } else {
        System.err.println("Unexpected resource type for layout class");
      }
    }
  }

  // Add the callback methods as sources and sinks
  {
    Set<SootMethodAndClass> callbacksPlain = new HashSet<SootMethodAndClass>();
    for (Set<SootMethodAndClass> set : this.callbackMethods.values()) {
      callbacksPlain.addAll(set);
    }
    System.out.println("Found " + callbacksPlain.size() + " callback methods for "
        + this.callbackMethods.size() + " components");
  }
}