/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Utility functions for getting data via 3rd party tools

*

*/

#include "appdep.hpp"

// ----------------------------------------------------------------------------------------------------------

// Note that in C/C++ code \ has been replaced with \\ and " with \".

// ----------------------------------------------------------------------------------------------------------

void GetImportTableWithPetran(const string& petran_location, binary_info& b_info)

{

    vector<dependency> deps;

    vector<string> tempVector;

    // init defaults

    b_info.binary_format = UNKNOWN;

    b_info.uid1 = UNKNOWN;

    b_info.uid2 = UNKNOWN;

    b_info.uid3 = UNKNOWN;

    b_info.secureid = NOT_VALID;

    b_info.vendorid = NOT_VALID;

    b_info.capabilities = 0;

    b_info.min_heap_size = 0;

    b_info.max_heap_size = 0;

    b_info.stack_size = 0;

    // execute petran

    string cmd;

    if (_cl_use_gcce || _cl_use_rvct)

        cmd = petran_location + " -dump hi \"" + b_info.directory + b_info.filename + "\" " + CERR_TO_NULL;

    else

        cmd = petran_location + " \"" + b_info.directory + b_info.filename + "\" " + CERR_TO_NULL;

    //cerr << cmd << endl;

    ExecuteCommand(cmd, tempVector);

    // get binary format, assuming it's the first line which begings with EPOC

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^(EPOC.+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            TrimAll(ms1);

            b_info.binary_format = ms1;

            break;

        }

    }

    // get uids

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Uids:\\s+(\\S+)\\s+(\\S+)\\s+(\\S+).+");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            string ms2(matches[2].first, matches[2].second);

            string ms3(matches[3].first, matches[3].second);

            b_info.uid1 = "0x"+ms1;

            b_info.uid2 = "0x"+ms2;

            b_info.uid3 = "0x"+ms3;

            break;

        }

    }

    // get secure id

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Secure\\sID:\\s+(\\S+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            b_info.secureid = "0x"+ms1;

            break;

        }

    }

    // get vendor id

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Vendor\\sID:\\s+(\\S+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            b_info.vendorid = "0x"+ms1;

            break;

        }

    }

    // get capabilities

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Capabilities:\\s+\\S+\\s+(\\S+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            b_info.capabilities = Str2Int("0x"+ms1);

            break;

        }

    }

    // get min heap size

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Min\\sHeap\\sSize:\\s+(\\S+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            b_info.min_heap_size = Str2Int("0x"+ms1);

            break;

        }

    }

    // get max heap size

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Max\\sHeap\\sSize:\\s+(\\S+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            b_info.max_heap_size = Str2Int("0x"+ms1);

            break;

        }

    }

    // get stack size

    for (unsigned int j=0; j<tempVector.size() && j<100; j++)

    {

        boost::regex re("^Stack\\sSize:\\s+(\\S+)");

        boost::cmatch matches;

        if (boost::regex_match(tempVector.at(j).c_str(), matches, re))

        {

            string ms1(matches[1].first, matches[1].second);

            b_info.stack_size = Str2Int("0x"+ms1);

            break;

        }

    }

    // finally get the dependency information

    for (unsigned int j=0; j<tempVector.size(); j++)

    {

        // first find where the import table begins, example:

        // Offset of import address table (relative to code section): 00005660

        if (tempVector.at(j).find("Offset of import", 0) != string::npos)

        {

            // continue looping

            while (j<tempVector.size()-1)

            {

                j++;

                // now find denpendency entry, examples:

                // 68 imports from euser{000a0000}[100039e5].dll

                // 1 imports from COMMONENGINE[100058fe].DLL

                // 3 imports from drtrvct2_2{000a0000}.dll

                // 27 imports from libdbus-utils{000a0000}[20010154].dll

                boost::regex re1("^(\\d+)\\simports\\sfrom\\s([\\w\\-]+)\\S*(\\.\\w+).*");

                boost::cmatch matches1;

                if (boost::regex_match(tempVector.at(j).c_str(), matches1, re1))

                {

                    // match found

                    string ms1(matches1[1].first, matches1[1].second); // number in the beginning

                    string ms2(matches1[2].first, matches1[2].second); // first part of filename

                    string ms3(matches1[3].first, matches1[3].second); // extension of filename

                    unsigned int number_of_imports = Str2Int(ms1);

                    vector<import> imps; // imports

                    string filename = ms2+ms3;

                    // get position of the filename in import libaries

                    int lib_pos = -1;

                    for (unsigned int x=0; x<_all_import_library_infos.size(); x++)

                    {

                        if (StringICmpFileNamesWithoutExtension(_all_import_library_infos.at(x).filename, filename) == 0)

                        {

                            lib_pos = x;

                            break;

                        }

                    }

                    // read ordinal numbers

                    for (unsigned int k=0; k<number_of_imports; k++)

                    {

                        j++;

                        import imp;

                        imp.is_vtable = false;

                        imp.vtable_offset = 0;

                        string ordinal_data = tempVector.at(j);

                        TrimAll(ordinal_data);

                        // check if it's virtual data

                        string::size_type pos = ordinal_data.find(" offset by", 0);

                        if (pos == string::npos)

                        {

                            // regular entry, just get the ordinal number

                            imp.funcpos = Str2Int(ordinal_data);

                            imp.is_vtable = false;

                            imp.vtable_offset = 0;

                        }

                        else

                        {

                            // this is a virtual table entry

                            imp.funcpos = Str2Int(ordinal_data.substr(0, pos));

                            imp.is_vtable = true;

                            imp.vtable_offset = Str2Int(ordinal_data.substr(pos+11, ordinal_data.length()-pos-1));

                        }

                        // get the function name

                        if (lib_pos >= 0)

                        {

                            if (imp.funcpos-1 < _all_import_library_infos.at(lib_pos).symbol_table.size())

                                imp.funcname = _all_import_library_infos.at(lib_pos).symbol_table.at(imp.funcpos-1);

                            else

                                imp.funcname = "BC break: This ordinal position is not in the import library!";

                        }

                        else

                        {

                            imp.funcname = "Import library not found!";

                        }

                        // Checking for possible duplicate imported function ordinals.

                        import compare[] = { imp };

                        vector<import>::iterator it = find_first_of(imps.begin(), imps.end(), compare, compare+1, ImportFunctionsHasSameOrdinal);

                        if(it == imps.end())

                        {

                            // No duplicate detected. Appending ordinal data to the array.

                            imps.push_back(imp);

                        }

                    }

                    // append to the vector

                    dependency dep;

                    dep.filename = filename;

                    dep.imports = imps;

                    deps.push_back( dep );

                }

            }

            break; //for (int j=0; j<tempVector.size(); j++)

        }

    } // for (int j=0; j<tempVector.size(); j++)

    // store the dependencies array

    b_info.dependencies = deps;

}

// ----------------------------------------------------------------------------------------------------------

bool ImportFunctionsHasSameOrdinal(import imp1, import imp2)

{

    return (imp1.funcpos == imp2.funcpos);

}

// ----------------------------------------------------------------------------------------------------------

void GetSymbolTableWithNM(const string& nm_location, const string& lib_directory, const string& lib_name, vector<string>& symbol_table)

{

    symbol_table.clear();

    vector<string> tempVector;

    vector<ordinal> ordinals;

    // execute nm

    string cmd = nm_location + " --demangle \"" + lib_directory + lib_name + "\"";

    ExecuteCommand(cmd, tempVector);

    // parse the results of the command

    for (unsigned int j=0; j<tempVector.size(); j++)

    {

        // first check if we have found the beginning of a block

        boost::cmatch matches1;

        boost::cmatch matches2;

        boost::cmatch matches3;

        bool match1 = false;

        bool match2 = false;

        bool match3 = false;

        // Symbian OS 6.1 LIB file, example: ds00001.o:

        boost::regex re1("^ds(\\d+)\\.o\\:");

        match1 = boost::regex_match(tempVector.at(j).c_str(), matches1, re1);

        if (!match1)

        {

            // Symbian OS 7.x-8.x LIB file, example: C:/DOCUME~1/mattlait/LOCALS~1/Temp/1/d1000s_00001.o:

            boost::regex re2("^\\S*s_(\\d+)\\.o\\:");

            match2 = boost::regex_match(tempVector.at(j).c_str(), matches2, re2);

            if (!match2)

            {

                // Symbian OS 9.x LIB file, example: AGENTDIALOG{000a0000}-14.o:

                boost::regex re3("^\\S*\\{000a0000\\}-(\\d+)\\.o\\:");

                match3 = boost::regex_match(tempVector.at(j).c_str(), matches3, re3);

            }

        }

        if (match1 || match2 || match3)

        {

            // now get the ordinal number

            string ordNum;

            if (match1)

                {

                string ms(matches1[1].first, matches1[1].second);

                ordNum = ms;

                }

            else if (match2)

                {

                string ms(matches2[1].first, matches2[1].second);

                ordNum = ms;

                }

            else if (match3)

                {

                string ms(matches3[1].first, matches3[1].second);

                ordNum = ms;

                }

            // now start looking for the line with the export name

            // eg: 00000000 T CUserActivityManager::RunL(void)

            while (j<tempVector.size()-1)

            {

                j++;

                boost::regex re4("^\\d+\\sT\\s(.*)$");

                boost::cmatch matches4;

                if (boost::regex_match(tempVector.at(j).c_str(), matches4, re4))

                {

                    // now we have a full entry

                    string ms(matches4[1].first, matches4[1].second);

                    // append to the ordinal list

                    ordinals.push_back(ordinal(Str2Int(ordNum), ms));

                    break;

                }

            }

        } // (match1 || match2)

    } // for (int j=0; j<tempVector.size(); j++)

    // convert the ordinal list into a symbol table

    ConvertOrdinalListIntoSymbolTable(ordinals, symbol_table, lib_directory+lib_name);

}

// ----------------------------------------------------------------------------------------------------------

void GetSymbolTableWithReadelf(const string& readelf_location, const string& cfilt_location, const string& lib_directory, const string& lib_name, vector<string>& symbol_table)

{

    symbol_table.clear();

    vector<string> tempVector;

    vector<ordinal> ordinals;

    // execute readelf

    // note: 2>NUL is used here to redirect standard error output to NULL since readelf seems to output lots of unwanted warning messages

    string cmd = readelf_location + " -s -W \"" + lib_directory + lib_name + "\" " + CERR_TO_NULL;

    ExecuteCommand(cmd, tempVector);

    // parse the results of the command

    for (unsigned int j=0; j<tempVector.size(); j++)

    {

        boost::cmatch matches1;

        // example:

        //     1: 00000000     4 NOTYPE  GLOBAL DEFAULT    1 _ZN13CSpdiaControl10DrawShadowER9CWindowGcRK5TSize@@SpdCtrl{000a0000}[10005986].dll

        boost::regex re1("^\\s*(\\d+)\\:.+GLOBAL.+\\d+\\s+(.*)\\@\\@.*");

        if (boost::regex_match(tempVector.at(j).c_str(), matches1, re1))

        {

            // match found

            string ms1(matches1[1].first, matches1[1].second);

            string ms2(matches1[2].first, matches1[2].second);

            // append to the ordinal list

            ordinals.push_back(ordinal(Str2Int(ms1), ms2));

        }

    } // for (int j=0; j<tempVector.size(); j++)

    // convert the ordinal list into a symbol table

    ConvertOrdinalListIntoSymbolTable(ordinals, symbol_table, lib_directory+lib_name);

    // finally demangle all function names since it's not done in this case automatically

    DemangleOrdinalsInSymbolTable(cfilt_location, symbol_table);

}

// ----------------------------------------------------------------------------------------------------------

void GetSymbolTableWithArmar(const string& armar_location, const string& cfilt_location, const string& lib_directory, const string& lib_name, vector<string>& symbol_table)

{

    symbol_table.clear();

    vector<string> tempVector;

    vector<ordinal> ordinals;

    // execute armar

    string cmd = armar_location + " --zs \"" + lib_directory + lib_name + "\"";

    ExecuteCommand(cmd, tempVector);

    // parse the results of the command

    for (unsigned int j=0; j<tempVector.size(); j++)

    {

        // find the entries, example:

        // _ZN13TAgnWeeklyRptC1Ev from AGNMODEL{000a0000}-187.o at offset 158366

        boost::regex re1("(\\S*)\\s+from\\s.*-(\\d+)\\.o.*");

        boost::cmatch matches1;

        if (boost::regex_match(tempVector.at(j).c_str(), matches1, re1))

        {

            // match found

            string ms1(matches1[2].first, matches1[2].second);

            string ms2(matches1[1].first, matches1[1].second);

            // append to the ordinal list

            ordinals.push_back(ordinal(Str2Int(ms1), ms2));

        }

    } // for (int j=0; j<tempVector.size(); j++)

    // convert the ordinal list into a symbol table

    ConvertOrdinalListIntoSymbolTable(ordinals, symbol_table, lib_directory+lib_name);

    // finally demangle all function names since it's not done in this case automatically

    DemangleOrdinalsInSymbolTable(cfilt_location, symbol_table);

}

// ----------------------------------------------------------------------------------------------------------

void GetSymbolTableWithFromelf(const string& fromelf_location, const string& cfilt_location, const string& lib_directory, const string& lib_name, vector<string>& symbol_table)

{

    symbol_table.clear();

    vector<string> tempVector;

    vector<ordinal> ordinals;

    // execute fromelf

    string cmd = fromelf_location + " -s \"" + lib_directory + lib_name + "\"";

    ExecuteCommand(cmd, tempVector);

    // parse the results of the command

    for (unsigned int j=0; j<tempVector.size(); j++)

    {

        // first find the start of the symbol table

        // ** Section #5 '.version' (SHT_GNU_versym)

        boost::regex re1("^.*(SHT_GNU_versym).*");

        boost::cmatch matches1;

        if (boost::regex_match(tempVector.at(j).c_str(), matches1, re1))

        {

            //int previous_ordinal = 0;

            while (j<tempVector.size()-1)

            {

                j++;

                // now find the entries, examples:

                //         7   _ZNK17CPbkContactEngine9FsSessionEv           2 PbkEng{000a0000}[101f4cce].dll

                //         8   _ZN17CPbkContactEngine19CreateEmptyContactLEv

                //                                                           2 PbkEng{000a0000}[101f4cce].dll

                // notice that line can be spread to two lines so make sure we don't accidentally get a wrong line

                // first parse out any unwanted lines

                boost::regex re2("^\\s*\\d+\\s+\\S+\\.\\w+$");

                boost::cmatch matches2;

                if (boost::regex_match(tempVector.at(j).c_str(), matches2, re2))

                {

                    continue;

                }

                // now it should be the wanted line

                boost::regex re3("^\\s*(\\d+)\\s*(\\S*).*");

                boost::cmatch matches3;

                if (boost::regex_match(tempVector.at(j).c_str(), matches3, re3))

                {

                    // match found

                    string ms1(matches3[1].first, matches3[1].second);

                    string ms2(matches3[2].first, matches3[2].second);

                    // append to the ordinal list

                    ordinals.push_back(ordinal(Str2Int(ms1), ms2));

                }

            } //while (j<tempVector.size())

        } //if (boost::regex_match(tempVector.at(j).c_str(), matches1, re1))

    } // for (int j=0; j<tempVector.size(); j++)

    // convert the ordinal list into a symbol table

    ConvertOrdinalListIntoSymbolTable(ordinals, symbol_table, lib_directory+lib_name);

    // finally demangle all function names since it's not done in this case automatically

    DemangleOrdinalsInSymbolTable(cfilt_location, symbol_table);

}