//------------------------------------------------------------------------------
//      Copyright (c) 2003, Ingo Weinhold
//
//      Permission is hereby granted, free of charge, to any person obtaining a
//      copy of this software and associated documentation files (the "Software"),
//      to deal in the Software without restriction, including without limitation
//      the rights to use, copy, modify, merge, publish, distribute, sublicense,
//      and/or sell copies of the Software, and to permit persons to whom the
//      Software is furnished to do so, subject to the following conditions:
//
//      The above copyright notice and this permission notice shall be included in
//      all copies or substantial portions of the Software.
//
//      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//      FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//      DEALINGS IN THE SOFTWARE.
//
//      File Name:              ElfSymbolPatcher.h
//      Author:                 Ingo Weinhold (bonefish@users.sf.net)
//      Description:    Interface declaration of classes used for patching ELF
//                                      symbols. Central class is ElfSymbolPatcher. It is a kind of
//                                      roster, managing all necessary infos (loaded images) and
//                                      being able to fill ElfSymbolPatchInfos with life.
//                                      An ElfSymbolPatchInfo represents a symbol and is able to
//                                      patch/restore it. An ElfSymbolPatchGroup bundles several
//                                      ElfSymbolPatchInfos and can update their data, e.g.
//                                      when images are loaded/unloaded. It uses a
//                                      ElfSymbolPatcher internally and provides a more convenient
//                                      API for the user.
//------------------------------------------------------------------------------

#ifndef ELF_SYMBOL_PATCHER_H
#define ELF_SYMBOL_PATCHER_H

#include <List.h>
#include <String.h>


namespace SymbolPatcher {

class ElfImage;
class ElfSymbolPatcher;
class ElfSymbolPatchGroup;

// ElfSymbolPatchInfo
class ElfSymbolPatchInfo {
public:
                                                                ElfSymbolPatchInfo();
                                                                ~ElfSymbolPatchInfo();

                        status_t                        InitCheck() const;

                        const char*                     GetSymbolName() const;
                        void*                           GetOriginalAddress() const;
                        image_id                        GetOriginalAddressImage() const;

                        status_t                        Patch(void* newAddress);
                        status_t                        Restore();

private:
                        class Entry;

private:
                        void                            Unset();
                        status_t                        SetSymbolName(const char* name);
                        void                            SetOriginalAddress(void* address,
                                                                                                   image_id image);
                        status_t                        CreateEntry(image_id image, BList* targets);
                        bool                            DeleteEntry(image_id image);
                        Entry*                          EntryAt(int32 index);
                        Entry*                          EntryFor(image_id image);

private:
                        friend class ElfSymbolPatcher;
                        friend class ElfSymbolPatchGroup;

                        BString                         fSymbolName;
                        void*                           fOriginalAddress;
                        image_id                        fOriginalAddressImage;
                        BList                           fEntries;
};

// ElfSymbolPatcher
class ElfSymbolPatcher {
public:
                        class UpdateAdapter;

public:
                                                                ElfSymbolPatcher();
                                                                ~ElfSymbolPatcher();

                        status_t                        InitCheck() const;
                        status_t                        Update(UpdateAdapter* updateAdapter = NULL);
                        void                            Unload();

                        status_t                        GetSymbolPatchInfo(const char* symbolName,
                                                                                                   ElfSymbolPatchInfo* info);
                        status_t                        UpdateSymbolPatchInfo(ElfSymbolPatchInfo* info,
                                                                                                          ElfImage* image);

private:
                        status_t                        _Init();
                        void                            _Cleanup();

                        ElfImage*                       _ImageAt(int32 index) const;
                        ElfImage*                       _ImageForID(image_id id) const;

private:
                        BList                           fImages;
                        status_t                        fInitStatus;
};

// UpdateAdapter
class ElfSymbolPatcher::UpdateAdapter {
public:
                                                                UpdateAdapter();
        virtual                                         ~UpdateAdapter();

        virtual void                            ImageAdded(ElfImage* image);
        virtual void                            ImageRemoved(ElfImage* image);
};


// ElfSymbolPatchGroup
class ElfSymbolPatchGroup : private ElfSymbolPatcher::UpdateAdapter {
public:
                                                                ElfSymbolPatchGroup(
                                                                        ElfSymbolPatcher* patcher = NULL);
                                                                ~ElfSymbolPatchGroup();

                        ElfSymbolPatcher*       GetPatcher() const      { return fPatcher; }

                        status_t                        AddPatch(const char* symbolName,
                                                                                 void* newAddress,
                                                                                 void** originalAddress);

                        void                            RemoveAllPatches();

                        status_t                        Patch();
                        status_t                        Restore();

                        status_t                        Update();

private:
                        class PatchInfo : public ElfSymbolPatchInfo {
                        public:
                                void*                   fNewAddress;
                        };

private:
        virtual void                            ImageAdded(ElfImage* image);
        virtual void                            ImageRemoved(ElfImage* image);

private:
                        ElfSymbolPatcher*       fPatcher;
                        BList                           fPatchInfos;
                        bool                            fOwnsPatcher;
                        bool                            fPatched;
};

} // namespace SymbolPatcher

using namespace SymbolPatcher;


#endif  // ELF_SYMBOL_PATCHER_H