Quelle  hidden_api.h

/*
 * Copyright (C) 2018 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.
 */

#ifndef ART_TOOLS_VERIDEX_HIDDEN_API_H_
#define ART_TOOLS_VERIDEX_HIDDEN_API_H_

#include <map>
#include <optional>
#include <ostream>
#include <string>

#include "api_list_filter.h"
#include "base/hiddenapi_flags.h"
#include "dex/method_reference.h"

namespace art {

class DexFile;

enum class SignatureSource {
  UNKNOWN,
  BOOT,
  APP,
};

/**
 * Helper class for logging if a method/field is in a hidden API list.
 */
class HiddenApi {
 public:
  HiddenApi(const char* flags_file,
            const char* flagged_apis_file,
            const ApiListFilter& api_list_filter);

  hiddenapi::ApiList GetApiList(const std::string& name) const {
    auto it = api_list_.find(name);
    return (it == api_list_.end()) ? hiddenapi::ApiList::Invalid() : it->second;
  }

  bool ShouldReport(const std::string& signature) const {
    return api_list_filter_.Matches(GetApiList(signature));
  }

  std::optional<std::string> GetFlag(const std::string& name) const {
    if (flagged_apis_.empty()) {
      return std::nullopt;
    }

    // Search for a prefix match
    auto it = flagged_apis_.upper_bound(name);
    while (it != flagged_apis_.begin()) {
      it = std::prev(it);
      const std::string& key = it->first;
      if (name.size() >= key.size() && name.compare(0, key.size(), key) == 0) {
        // Exact match
        bool is_boundary = (name.size() == key.size());
        if (!is_boundary) {
          // If not exact match, check if the prefix ends with any of class name
          // boundary characters (';', '$', or '-')
          char next_char = name[key.size()];
          if (next_char == ';' || next_char == '$' || next_char == '-') {
            is_boundary = true;
          }
        }

        if (is_boundary) {
          return std::make_optional(it->second);
        }
      }
    }
    return std::nullopt;
  }

  void AddSignatureSource(const std::string &signature, SignatureSource source) {
    const auto type = GetApiClassName(signature);
    auto it = source_.find(type);
    if (it == source_.end() || it->second == SignatureSource::UNKNOWN) {
      source_[type] = source;
    } else if (it->second != source) {
      LOG(WARNING) << type << "is present both in boot and in app.";
      if (source == SignatureSource::BOOT) {
        // Runtime resolves to boot type, so it takes precedence.
        it->second = source;
      }
    } else {
      // Already exists with the same source.
    }
  }

  SignatureSource GetSignatureSource(const std::string& signature) const {
    auto it = source_.find(GetApiClassName(signature));
    return (it == source_.end()) ? SignatureSource::UNKNOWN : it->second;
  }

  bool IsInBoot(const std::string& signature) const {
    return SignatureSource::BOOT == GetSignatureSource(signature);
  }

  static std::string GetApiMethodName(const DexFile& dex_file, uint32_t method_index);

  static std::string GetApiFieldName(const DexFile& dex_file, uint32_t field_index);

  static std::string GetApiMethodName(MethodReference ref) {
    return HiddenApi::GetApiMethodName(*ref.dex_file, ref.index);
  }

  static std::string ToInternalName(const std::string& str) {
    std::string val = str;
    std::replace(val.begin(), val.end(), '.', '/');
    return "L" + val + ";";
  }

 private:
  void AddSignatureToApiList(const std::string& signature, hiddenapi::ApiList membership);

  static std::string GetApiClassName(const std::string& signature) {
    size_t pos = signature.find("->");
    if (pos != std::string::npos) {
      return signature.substr(0, pos);
    }
    return signature;
  }

  const ApiListFilter& api_list_filter_;
  std::map<std::string, hiddenapi::ApiList> api_list_;
  std::map<std::string, SignatureSource> source_;
  std::map<std::string, std::string> flagged_apis_;
};

struct HiddenApiStats {
  uint32_t count = 0;
  uint32_t reflection_count = 0;
  uint32_t linking_count = 0;
  // Ensure enough space for kInvalid as well, and initialize all to zero
  uint32_t api_counts[hiddenapi::ApiList::kValueSize] = {};
};


}  // namespace art

#endif  // ART_TOOLS_VERIDEX_HIDDEN_API_H_