sysfuzzer/common/specification_parser/SpecificationBuilder.cpp

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "specification_parser/SpecificationBuilder.h"

#include <dirent.h>

#include <iostream>
#include <queue>
#include <string>

#include "fuzz_tester/FuzzerBase.h"
#include "fuzz_tester/FuzzerWrapper.h"
#include "specification_parser/InterfaceSpecificationParser.h"

#include "test/vts/sysfuzzer/common/proto/InterfaceSpecificationMessage.pb.h"
#include <google/protobuf/text_format.h>

namespace android {
namespace vts {

SpecificationBuilder::SpecificationBuilder(
    const string dir_path, int epoch_count)
    : dir_path_(dir_path),
      epoch_count_(epoch_count),
      if_spec_msg_(NULL),
      module_name_(NULL) {}


vts::InterfaceSpecificationMessage*
SpecificationBuilder::FindInterfaceSpecification(
    const int target_class,
    const int target_type,
    const float target_version,
    const string submodule_name) {
  DIR* dir;
  struct dirent* ent;

  if (!(dir = opendir(dir_path_.c_str()))) {
    cerr << __FUNCTION__ << ": Can't opendir " << dir_path_ << endl;
    return NULL;
  }

  while ((ent = readdir(dir))) {
    if (string(ent->d_name).find(SPEC_FILE_EXT) != std::string::npos) {
      cout << __FUNCTION__ << ": Checking a file " << ent->d_name << endl;
      const string file_path = string(dir_path_) + "/" + string(ent->d_name);
      vts::InterfaceSpecificationMessage* message =
          new vts::InterfaceSpecificationMessage();
      if (InterfaceSpecificationParser::parse(file_path.c_str(), message)) {
        if (message->component_type() == target_type
            && message->component_type_version() == target_version) {
          if (submodule_name.length() > 0) {
            if (message->component_class() != HAL_SUBMODULE
                || message->original_data_structure_name() != submodule_name) {
              continue;
            }
          } else if (message->component_class() != target_class) continue;
          closedir(dir);
          return message;
        }
      }
      delete message;
    }
  }
  closedir(dir);
  return NULL;
}


FuzzerBase* SpecificationBuilder::GetFuzzerBase(
    const vts::InterfaceSpecificationMessage& iface_spec_msg,
    const char* dll_file_name,
    const char* target_func_name) {
  cout << __FUNCTION__ << ":" << __LINE__ << " " << "entry" << endl;
  FuzzerBase* fuzzer = wrapper_.GetFuzzer(iface_spec_msg);
  if (!fuzzer) {
    cerr << __FUNCTION__ << ": couldn't get a fuzzer base class" << endl;
    return NULL;
  }
  cout << __FUNCTION__ << ":" << __LINE__ << " " << "got fuzzer" << endl;
  if (!fuzzer->LoadTargetComponent(dll_file_name, module_name_)) {
    cerr << __FUNCTION__ << ": couldn't load target component file, "
        << dll_file_name << endl;
    return NULL;
  }
  cout << __FUNCTION__ << ":" << __LINE__ << " " << "loaded target comp" << endl;

  for (const vts::FunctionSpecificationMessage& func_msg : iface_spec_msg.api()) {
    cout << "checking " << func_msg.name() << endl;
    if (!strcmp(target_func_name, func_msg.name().c_str())) {
      return fuzzer;
    }
  }
  return NULL;
}


FuzzerBase* SpecificationBuilder::GetFuzzerBaseAndAddAllFunctionsToQueue(
    const vts::InterfaceSpecificationMessage& iface_spec_msg,
    const char* dll_file_name) {
  FuzzerBase* fuzzer = wrapper_.GetFuzzer(iface_spec_msg);
  if (!fuzzer) {
    cerr << __FUNCTION__ << ": couldn't get a fuzzer base class" << endl;
    return NULL;
  }
  if (!fuzzer->LoadTargetComponent(dll_file_name)) return NULL;

  for (const vts::FunctionSpecificationMessage& func_msg : iface_spec_msg.api()) {
    cout << "Add a job " << func_msg.name() << endl;
    FunctionSpecificationMessage* func_msg_copy = func_msg.New();
    func_msg_copy->CopyFrom(func_msg);
    job_queue_.push(make_pair(func_msg_copy, fuzzer));
  }
  return fuzzer;
}


bool SpecificationBuilder::LoadTargetComponent(
    const char* dll_file_name,
    const char* spec_lib_file_path,
    int target_class,
    int target_type,
    float target_version,
    const char* module_name) {
  if_spec_msg_ = FindInterfaceSpecification(
      target_class, target_type, target_version);
  if (!if_spec_msg_) {
    cerr << __FUNCTION__ <<
        ": no interface specification file found for "
        << "class " << target_class
        << " type " << target_type
        << " version " << target_version << endl;
    return false;
  }
  spec_lib_file_path_ = (char*) malloc(strlen(spec_lib_file_path) + 1);
  strcpy(spec_lib_file_path_, spec_lib_file_path);

  dll_file_name_ = (char*) malloc(strlen(dll_file_name) + 1);
  strcpy(dll_file_name_, dll_file_name);

  cout << "ifspec addr load " << if_spec_msg_ << endl;
  string output;
  if_spec_msg_->SerializeToString(&output);
  cout << "loaded text " << output.length() << endl;
  cout << "loaded text " << strlen(output.c_str()) << endl;
  cout << "loaded text " << output << endl;

  module_name_ = (char*) malloc(strlen(module_name) + 1);
  strcpy(module_name_, module_name);
  return true;
}


const string empty_string = string();

const string& SpecificationBuilder::CallFunction(
    FunctionSpecificationMessage* func_msg) {
  if (!wrapper_.LoadInterfaceSpecificationLibrary(spec_lib_file_path_)) {
    return empty_string;
  }
  cout << __FUNCTION__ << ":" << __LINE__ << " " << "loaded if_spec lib" << endl;

  FuzzerBase* func_fuzzer = GetFuzzerBase(
      *if_spec_msg_, dll_file_name_, func_msg->name().c_str());
  if (!func_fuzzer) {
    cerr << "can't find FuzzerBase for " << func_msg->name() << " using "
        << dll_file_name_ << endl;
    return empty_string;
  }

  void* result;
  func_fuzzer->FunctionCallBegin();
  cout << "Call Function " << func_msg->name() << endl;
  func_fuzzer->Fuzz(*func_msg, &result);
  cout << __FUNCTION__ << ": called" << endl;

  // set coverage data.
  vector<unsigned>* coverage = func_fuzzer->FunctionCallEnd();
  if (coverage && coverage->size() > 0) {
    for (unsigned int index = 0; index < coverage->size(); index++) {
      func_msg->mutable_coverage_data()->Add(coverage->at(index));
    }
  }

  if (func_msg->return_type().aggregate_type().size() > 0) {
    // TODO: actually handle this case.
    if (result != NULL) {
      // loads that interface spec and enqueues all functions.
      cout << __FUNCTION__ << " return type: "
          << func_msg->return_type().aggregate_type(0) << endl;
    } else {
      cout << __FUNCTION__ << " return value = NULL" << endl;
    }
    cerr << __FUNCTION__ << " todo: support aggregate" << endl;
    string* output = new string();
    google::protobuf::TextFormat::PrintToString(*func_msg, output);
    return *output;
  } else if (func_msg->return_type().primitive_type().size() > 0) {
    // TODO handle when the size > 1.
    if (!strcmp(func_msg->return_type().primitive_type(0).c_str(), "int32_t")) {
      func_msg->mutable_return_type()->mutable_primitive_value()->Add()->set_int32_t(
          *((int*)(&result)));
      cout << "result " << endl;
      // todo handle more types;
      string* output = new string();
      google::protobuf::TextFormat::PrintToString(*func_msg, output);
      return *output;
    }
  }
  return *(new string("void"));
}


bool SpecificationBuilder::Process(
    const char* dll_file_name,
    const char* spec_lib_file_path,
    int target_class,
    int target_type,
    float target_version) {
  vts::InterfaceSpecificationMessage* interface_specification_message =
      FindInterfaceSpecification(target_class, target_type, target_version);
  cout << "ifspec addr " << interface_specification_message << endl;

  if (!interface_specification_message) {
    cerr << __FUNCTION__ <<
        ": no interface specification file found for "
        << "class " << target_class
        << " type " << target_type
        << " version " << target_version << endl;
    return false;
  }

  if (!wrapper_.LoadInterfaceSpecificationLibrary(spec_lib_file_path)) {
    return false;
  }

  if (!GetFuzzerBaseAndAddAllFunctionsToQueue(
          *interface_specification_message, dll_file_name)) return false;

  for (int i = 0; i < epoch_count_; i++) {
    // by default, breath-first-searching is used.
    if (job_queue_.empty()) {
      cout << "no more job to process; stopping after epoch " << i << endl;
      break;
    }

    pair<vts::FunctionSpecificationMessage*, FuzzerBase*> curr_job =
        job_queue_.front();
    job_queue_.pop();

    vts::FunctionSpecificationMessage* func_msg = curr_job.first;
    FuzzerBase* func_fuzzer = curr_job.second;

    void* result;
    cout << "Iteration " << (i + 1) << " Function " << func_msg->name() << endl;
    func_fuzzer->Fuzz(*func_msg, &result);
    if (func_msg->return_type().aggregate_type().size() > 0) {
      if (result != NULL) {
        // loads that interface spec and enqueues all functions.
        cout << __FUNCTION__ << " return type: "
            << func_msg->return_type().aggregate_type(0) << endl;
        // TODO: handle the case when size > 1
        string submodule_name = func_msg->return_type().aggregate_type(0);
        while (!submodule_name.empty()
               && (std::isspace(submodule_name.back())
                   || submodule_name.back() == '*')) {
          submodule_name.pop_back();
        }
        vts::InterfaceSpecificationMessage* iface_spec_msg =
            FindInterfaceSpecification(
                target_class, target_type, target_version, submodule_name);
        if (iface_spec_msg) {
          cout << __FUNCTION__ << " submodule found - " << submodule_name << endl;
          if (!GetFuzzerBaseAndAddAllFunctionsToQueue(
                  *iface_spec_msg, dll_file_name)) {
            return false;
          }
        } else {
          cout << __FUNCTION__ << " submodule not found - " << submodule_name << endl;
        }
      } else {
        cout << __FUNCTION__ << " return value = NULL" << endl;
      }
    }
  }

  return true;
}


vts::InterfaceSpecificationMessage*
SpecificationBuilder::GetInterfaceSpecification() const {
  cout << "ifspec addr get " << if_spec_msg_ << endl;
  return if_spec_msg_;
}

}  // namespace vts
}  // namespace android