Merge pull request diffblue#220 from diffblue/feature/introducing_java-class-info_tool

marek-trtik · web-flow · commit d64e00b8eec6 · 2017-10-04T11:39:33.000+01:00
SEC-68 : Introducing java-class-info executable.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -20,4 +20,5 @@ add_subdirectory(summaries)
 add_subdirectory(taint-analysis)
 add_subdirectory(taint-slicer)
 add_subdirectory(util)
+add_subdirectory(java-class-info)
 
diff --git a/src/java-class-info/CMakeLists.txt b/src/java-class-info/CMakeLists.txt
@@ -0,0 +1,33 @@
+add_executable(java-class-info
+        java_class_info.cpp
+        )
+
+find_package(Git)
+if(GIT_FOUND)
+    execute_process(
+            COMMAND "${GIT_EXECUTABLE}" "describe" "--tags" "--always" "--long"
+            OUTPUT_VARIABLE git_repo_version
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    message(STATUS "Executable is version ${git_repo_version}")
+else()
+    message(FATAL_ERROR "Git is not installed, cannot generate version string")
+endif()
+
+target_compile_definitions(java-class-info
+        PRIVATE "-DJAVA_CLASS_INFO_VERSION=\"${git_repo_version}\""
+                USE_BOOST=1
+        )
+
+generic_includes(java-class-info)
+target_link_libraries(java-class-info
+        # cbmc includes
+        java_bytecode
+        langapi
+        json
+        util
+        )
+
+install(TARGETS java-class-info DESTINATION bin)
+
diff --git a/src/java-class-info/java_class_info.cpp b/src/java-class-info/java_class_info.cpp
@@ -0,0 +1,254 @@
+#include <util/ui_message.h>
+#include <util/parse_options.h>
+#include <util/file_util.h>
+#include <json/json_parser.h>
+#include <iostream>
+#include <fstream>
+#include <java_bytecode/java_bytecode_parse_tree.h>
+#include <java_bytecode/java_bytecode_parser.h>
+
+class cmdline_optionst final:
+  public parse_options_baset
+{
+public:
+  cmdline_optionst(int argc, const char **argv);
+
+  void help() override;
+  int doit() override;
+
+private:
+  ui_message_handlert ui_message_handler;
+};
+
+cmdline_optionst::cmdline_optionst(int argc, const char **argv):
+  parse_options_baset("(version)(in-json):(out-json):", argc, argv),
+  ui_message_handler(cmdline, "java-class-info " JAVA_CLASS_INFO_VERSION)
+{}
+
+void cmdline_optionst::help()
+{
+  std::cout <<
+    "java-class-info v." JAVA_CLASS_INFO_VERSION " - Copyright (C) 2017\n\n"
+    "Usages:\n"
+    "  java-class-info --help\n"
+    "  java-class-info --version\n"
+    "  java-class-info --in-json <file> --out-json <file>\n\n"
+    "Options:                     Explanation:\n"
+    "--help:                      Prints this help message.\n"
+    "--version:                   Prints id of Git commit this tool was\n"
+    "                             built from.\n"
+    "--in-json:                   A pathname of an input JSON file comprising\n"
+    "                             of an array of pathnames of Java class\n"
+    "                             files whose properties should be read.\n"
+    "--out-json:                  A pathname of an output JSON file into\n"
+    "                             which the properties of the all Java class\n"
+    "                             files (listed in JSON file; see --in-json)\n"
+    "                             will be written.\n";
+}
+
+int cmdline_optionst::doit()
+{
+  messaget msg(ui_message_handler);
+
+  if(cmdline.isset("version"))
+  {
+    msg.status() << JAVA_CLASS_INFO_VERSION << messaget::eom;
+    return 0;
+  }
+  if(!cmdline.isset("in-json"))
+  {
+    msg.error()
+      << "ERROR: The option --in-json was not specified."
+      << messaget::eom;
+    return -1;
+  }
+  const std::string in_json_pathname=cmdline.get_value("in-json");
+  if(!fileutl_file_exists(in_json_pathname))
+  {
+    msg.error()
+      << "ERROR: The input file '" << in_json_pathname
+      << "' does not exist." << messaget::eom;
+    return -2;
+  }
+  jsont cfg;
+  if(parse_json(in_json_pathname, ui_message_handler, cfg))
+  {
+    msg.error()
+      << "ERROR: The input file '" << in_json_pathname
+      << "' is not a valid JSON file." << messaget::eom;
+    return -3;
+  }
+  if(!cfg.is_array())
+  {
+    msg.error()
+      << "ERROR: The input JSON file '"
+      << in_json_pathname
+      << "' does not consists of one array of strings (paths to Java "
+      << "class files)." << messaget::eom;
+    return -4;
+  }
+  if(!cmdline.isset("out-json"))
+  {
+    msg.error()
+      << "ERROR: The option --out-json was not specified." << messaget::eom;
+    return -5;
+  }
+  const std::string out_json_pathname=cmdline.get_value("out-json");
+  if(fileutl_is_directory(out_json_pathname))
+  {
+    msg.error()
+      << "ERROR: The output path '" << out_json_pathname
+      << "' references an existing directory." << messaget::eom;
+    return -6;
+  }
+
+  json_objectt results;
+  json_arrayt errors;
+
+  int ret_code=0;
+  for(auto const &json_array_element : cfg.array)
+  {
+    if(!json_array_element.is_string())
+    {
+      std::stringstream sstr;
+      sstr
+        << "Encountered a non-string element in the array of paths "
+        << "in the input JSON file.";
+      msg.warning()
+        << "WARNING: "
+        << sstr.str()
+        << " Skipping this file."
+        << messaget::eom;
+      errors.push_back(json_stringt(sstr.str()));
+      ret_code=-7;
+      continue;
+    }
+
+    const std::string &class_file_pathname=json_array_element.value;
+    if(!fileutl_file_exists(class_file_pathname))
+    {
+      std::stringstream sstr;
+      sstr
+        << "Java class file '" << class_file_pathname
+        << "' specified in '" << in_json_pathname
+        << "' does not exist.";
+      msg.warning()
+        << "WARNING: "
+        << sstr.str()
+        << " Skipping this file."
+        << messaget::eom;
+      errors.push_back(json_stringt(sstr.str()));
+      ret_code=-7;
+      continue;
+    }
+
+    jsont class_json;
+    try
+    {
+      java_bytecode_parse_treet parse_tree;
+      if(java_bytecode_parse(
+        class_file_pathname,
+        parse_tree,
+        ui_message_handler))
+      {
+        std::stringstream sstr;
+        sstr
+          << "The load of Java class file '"
+          << class_file_pathname
+          << "' specified in '"
+          << in_json_pathname
+          << "' has failed (by error return code from "
+          << "'java_bytecode_parse').";
+        msg.warning()
+          << "WARNING: "
+          << sstr.str()
+          << " Skipping this file."
+          << messaget::eom;
+        class_json=json_stringt(sstr.str());
+        ret_code=-7;
+      }
+      else
+      {
+        INVARIANT(parse_tree.loading_successful,
+          "False returned from 'java_bytecode_parse' should imply "
+          "'parse_tree.loading_successful' is True.");
+
+        json_objectt class_props;
+        {
+          class_props["name"]=
+            json_stringt(id2string(parse_tree.parsed_class.name));
+          class_props["extends"]=
+            json_stringt(id2string(parse_tree.parsed_class.extends));
+          {
+            json_arrayt interfaces;
+            for(auto const &interface : parse_tree.parsed_class.implements)
+              interfaces.push_back(json_stringt(id2string(interface)));
+            class_props["implements"]=interfaces;
+          }
+          class_props["is_abstract"]=jsont::json_boolean(
+            parse_tree.parsed_class.is_abstract);
+          class_props["is_public"]=jsont::json_boolean(
+            parse_tree.parsed_class.is_public);
+          class_props["is_private"]=jsont::json_boolean(
+            parse_tree.parsed_class.is_private);
+          class_props["is_protected"]=jsont::json_boolean(
+            parse_tree.parsed_class.is_protected);
+          class_props["is_enum"]=jsont::json_boolean(
+            parse_tree.parsed_class.is_enum);
+        }
+        class_json=class_props;
+      }
+    }
+    catch(...)
+    {
+      std::stringstream sstr;
+      sstr
+        << "The load of Java class file '"
+        << class_file_pathname
+        << "' specified in '"
+        << in_json_pathname
+        << "' has failed (by throwing an exception)."
+        << "";
+      msg.warning()
+        << "WARNING: "
+        << sstr.str()
+        << " Skipping this file."
+        << messaget::eom;
+      class_json=json_stringt(sstr.str());
+      ret_code=-7;
+    }
+    if(class_json.is_string())
+      errors.push_back(class_json);
+    else
+      results[class_file_pathname]=class_json;
+  }
+
+  std::ofstream ofile(out_json_pathname);
+  if(!ofile)
+  {
+    msg.error()
+      << "ERROR: Cannot open the output JSON file '"
+      << out_json_pathname
+      << "' for writing."
+      << messaget::eom;
+    return -8;
+  }
+  json_objectt result;
+  result["results"]=results;
+  result["errors"]=errors;
+  ofile << result;
+
+  return ret_code;
+}
+
+#ifdef _MSC_VER
+int wmain(int argc, const wchar_t **argv_wide)
+{
+  const char **argv=narrow_argv(argc, argv_wide);
+#else
+int main(int argc, const char **argv)
+{
+#endif
+  cmdline_optionst options(argc, argv);
+  return options.main();
+}
