Merge pull request diffblue#146 from NathanJPhillips/cleanup/store-rules-in-map

Cleanup/store rules in map

Author: NathanJPhillips

src/goto-analyzer/taint_rules.cpp

@@ -1,161 +1,17 @@
 #include "taint_rules.h"
 #include <json/json_parser.h>
 #include <util/file_util.h>
-#include <util/string2int.h>
 #include <util/msgstream.h>
-#include <fstream>
 #include <util/prefix.h>
 
 
-std::unique_ptr<taintable_locationt> taintable_locationt::load(
-  const std::string &location_string,
-  bool dereference,
-  message_handlert &message_handler)
-{
-  messaget msg(message_handler);
-
-  std::unique_ptr<taintable_locationt> taintable_argument =
-    taintable_location_argumentt::load(location_string, dereference, message_handler);
-  if(taintable_argument != nullptr)
-    return taintable_argument;
-  // Prefer returns but allow return_value
-  else if(location_string == "returns" || location_string == "return_value")
-    return std::unique_ptr<taintable_locationt>(
-      new taintable_location_return_valuet(dereference));
-  else
-    return nullptr;
-}
-
-std::unique_ptr<taintable_location_argumentt> taintable_location_argumentt::load(
-  const std::string &location_string,
-  bool dereference,
-  message_handlert &message_handler)
-{
-  messaget msg(message_handler);
-
-  if(location_string == "this")
-    return std::unique_ptr<taintable_location_argumentt>(
-      new taintable_location_argumentt());
-  else if(has_prefix(location_string, "arg"))
-  {
-    // Parse string and handle invalid input/out of range
-    const char *arg_no_string = location_string.c_str() + 3;
-    char *arg_no_string_end;
-    long arg_no;
-    arg_no = strtol(arg_no_string, &arg_no_string_end, 0);
-    if(arg_no > 100 || arg_no < 1)
-    {
-      msg.error()
-        << "JSON tainted location specification location was to an invalid argument index."
-        << messaget::eom;
-      return nullptr;
-    }
-    if(*arg_no_string == '\0' || *arg_no_string_end != '\0')
-    {
-      msg.error()
-        << "JSON tainted location specification location was to an argument without an index."
-        << messaget::eom;
-      return nullptr;
-    }
-    return std::unique_ptr<taintable_location_argumentt>(
-      new taintable_location_argumentt(arg_no, dereference));
-  }
-  else
-    return nullptr;
-}
-
-template<typename taintable_locationt>
-boost::optional<tainted_locationt<taintable_locationt>> tainted_locationt<taintable_locationt>::load(
-  const jsont &json,
-  taint_tokent::named_tokenst &tokens,
-  message_handlert &message_handler)
-{
-  messaget msg(message_handler);
-
-  if(json.is_null())
-    return boost::none;
-  if(!json.is_object())
-  {
-    msg.error()
-      << "JSON tainted location specification was not an object, ignoring it."
-      << messaget::eom;
-    return boost::none;
-  }
-  // Read the location
-  const jsont &dereference_json = json["dereference"];
-  bool dereference = dereference_json.is_true();  // Null == false
-  if(!(dereference_json.is_null()
-    || dereference_json.is_true() || dereference_json.is_false()))
-  {
-    msg.error()
-      << "JSON tainted location included an invalid value for dereference, assuming true was intended."
-      << messaget::eom;
-    dereference = true;
-  }
-  std::unique_ptr<taintable_locationt> location =
-    taintable_locationt::load(json["location"].value, dereference, message_handler);
-  if(location == nullptr)
-  {
-    msg.error()
-      << "JSON tainted location specification did not have valid location, ignoring it."
-      << messaget::eom;
-    return boost::none;
-  }
-  // Read the taint
-  std::string taint_string = json["taint"].value;
-  if(taint_string.empty())
-    taint_string = json["vulnerability"].value;
-  if(taint_string.empty())
-  {
-    msg.error()
-      << "JSON tainted location specification did not specify taint symbol, ignoring it."
-      << messaget::eom;
-    return boost::none;
-  }
-  // Try to add a new token, get the token added or already in the set
-  taint_tokent token =
-    tokens.left.insert({ taint_string, taint_tokent::fresh() }).first->second;
-  return tainted_locationt<taintable_locationt>(std::move(location), token);
-}
-
-
-std::unique_ptr<taintable_locationt> taintable_location_return_valuet::applied(
-  bool has_this, size_t arg_count_including_this) const
-{
-  return std::unique_ptr<taintable_locationt>(
-    new taintable_location_return_valuet(*this));
-}
-
-std::unique_ptr<taintable_locationt> taintable_location_argumentt::applied(
-  bool has_this, size_t arg_count_including_this) const
-{
-  return applied_argument(has_this, arg_count_including_this);
-}
-
-std::unique_ptr<taintable_location_argumentt> taintable_location_argumentt::applied_argument(
-  bool has_this, size_t arg_count_including_this) const
-{
-  if(has_this)
-  {
-    if(arg_index >= arg_count_including_this)
-      return nullptr;
-    return std::unique_ptr<taintable_location_argumentt>(
-      new taintable_location_argumentt(*this));
-  }
-  if(arg_index == 0 || arg_index - 1 >= arg_count_including_this)
-    return nullptr;
-  return std::unique_ptr<taintable_location_argumentt>(
-    new taintable_location_argumentt(arg_index - 1, dereference));
-}
-
-
-taint_sett taint_propogation_rulet::apply()
+taint_sett taint_propogation_rulet::apply() const
 {
   assert(!has_input_condition());
   return taint_sett::from_token(result.taint);
 }
 
-taint_sett taint_propogation_rulet::apply(const taint_sett &input_taint)
+taint_sett taint_propogation_rulet::apply(const taint_sett &input_taint) const
 {
   assert(has_input_condition());
   return input_taint.map_conditional(input->taint, result.taint);
@@ -334,7 +190,7 @@ std::unique_ptr<taint_rulest> taint_rulest::load(
         if(failure)
           continue;   // Doesn't match this function overload
         rules->add(fn_detail_it->second.id,
-          std::make_shared<taint_sink_rulet>(
+          taint_sink_rulet(
             std::move(input), std::move(*sink_target), comment, message));
         overload_found = true;
       }
@@ -354,7 +210,7 @@ std::unique_ptr<taint_rulest> taint_rulest::load(
         if(failure)
           continue;   // Doesn't match this function overload
         rules->add(fn_detail_it->second.id,
-          std::make_shared<taint_sanitizer_rulet>(std::move(*sanitizes), comment));
+          taint_sanitizer_rulet(std::move(*sanitizes), comment));
         overload_found = true;
       }
     }
@@ -369,7 +225,7 @@ std::unique_ptr<taint_rulest> taint_rulest::load(
         if(failure)
           continue;   // Doesn't match this function overload
         rules->add(fn_detail_it->second.id,
-          std::make_shared<taint_propogation_rulet>(
+          taint_propogation_rulet(
             std::move(input), std::move(*result), comment));
         overload_found = true;
       }