protos.hpp

//--------------------------------------------------------------------*- C++ -*-
// Kunai-static-analyzer: library for doing analysis of dalvik files
// @author Farenain <kunai.static.analysis@gmail.com>
// @author Ernesto Java <javaernesto@gmail.com>
//
// @file protos.hpp
// @brief Manage all the prototypes used in a DEX file, the prototypes
// include parameters return types, etc.
 
/*
 * Each proto structure is:
 *  ProtoID {
 *      uint shorty_idx, # OFFSET to a string with return type
 *      uint return_type_idx, # OFFSET to a type which points to string with return type
 *      uint parameters_off # ---------| Offset to parameters in type list type
 *  }                                  |
 *                                     |
 *  ------------------------------------
 *  |
 *  v
 *  type_list {
 *      uint size, # Size of the list in entries
 *      list type_item[size] # ---------|
 *  }                                   |
 *                                      |
 *  -------------------------------------
 *  |
 *  v
 *  type_item {
 *      ushort type_idx # type_idx of each member
 *  }
 *
 *  ProtoID[] protos
 */
 
#ifndef KUNAI_DEX_PARSER_PROTOS_HPP
#define KUNAI_DEX_PARSER_PROTOS_HPP
 
#include "Kunai/Utils/kunaistream.hpp"
#include "Kunai/DEX/parser/types.hpp"
#include "Kunai/DEX/parser/strings.hpp"
 
#include <vector>
 
namespace KUNAI
{
namespace DEX
{
 
    class ProtoID
    {
        std::string &shorty_idx;
        DVMType *return_type;
        std::vector<DVMType *> parameters;
        void parse_parameters(
            stream::KunaiStream *stream,
            Types *types,
            std::uint32_t parameters_off);
 
    public:
        ProtoID(
            stream::KunaiStream *stream,
            Types *types,
            std::string& shorty_idx,
            std::uint32_t return_type_idx,
            std::uint32_t parameters_off)
            : shorty_idx(shorty_idx),
              return_type(types->get_type_from_order(return_type_idx))
        {
            parse_parameters(stream, types, parameters_off);
        }
 
        const std::string& get_shorty_idx() const
        {
            return shorty_idx;
        }
 
        std::string& get_shorty_idx()
        {
            return shorty_idx;
        }
 
        const DVMType* get_return_type() const
        {
            return return_type;
        }
 
        DVMType* get_return_type()
        {
            return return_type;
        }
 
        const std::vector<DVMType *>& get_parameters() const
        {
            return parameters;
        }
 
        std::vector<DVMType*>& get_parameters()
        {
            return parameters;
        } 
    };
 
    using protoid_t = std::unique_ptr<ProtoID>;
 
    class Protos
    {
        std::vector<protoid_t> proto_ids;
        std::uint32_t number_of_protos;
 
    public:
        Protos() = default;
        ~Protos() = default;
 
        void parse_protos(stream::KunaiStream* stream,
                          std::uint32_t number_of_protos,
                          std::uint32_t offset,
                          Strings* strings,
                          Types* types);
 
        const std::vector<protoid_t>& get_proto_ids() const
        {
            return proto_ids;
        }
        
        std::vector<protoid_t>& get_proto_ids()
        {
            return proto_ids;
        }
 
        std::uint32_t get_number_of_protos() const
        {
            return number_of_protos;
        }
 
        ProtoID* get_proto_by_order(std::uint32_t pos);
 
        friend std::ostream &operator<<(std::ostream &os, const Protos &entry);
        
        void to_xml(std::ofstream& xml_file);
    };
} // namespace DEX
} // namespace KUNAI
 
#endif