Xreferat.com » Рефераты по информатике и программированию » Перехват методов COM интерфейсов

Перехват методов COM интерфейсов

HRESULT __stdcall thunk(void* pthis)

{

 return S_OK;

}

typedef HRESULT (__stdcall * pthunk)(void* pthis);

pthunk vtbl[1024];

for(int i = 0 ; i < sizeof(vtbl) / sizeof(vtbl[0]); ++i)

 vtbl[i] = &thunk;

pthunk* vptr = vtbl;

IUnknown* pUnk = reinterpret_cast<IUnknown*>(&vptr);

pUnk->AddRef();

Метод-перехватчик, используя ассемблер, выполняет пред-обработку (проверку счетчика ссылок) и после этого передает управление исходному методу с помощью инструкции безусловного перехода jmp.

Замена указателей в vtbl

Для отладочных целей в приведенном выше примере нам было бы достаточно перехватывать только вызовы AddRef, Release и QueryInterface. Но для перехвата всех остальных методов интерфейса, сигнатура которых неизвестна на этапе компиляции, требуется более универсальный код.

Альтернативный способ перехвата вызовов методов интерфейса заключается в том, чтобы заменить в исходной vtbl интерфейса указатели на те методы, которые мы собираемся перехватывать. Эта технология была замечательно описана в статье “Перехват методов COM интерфейсовПерехват методов интерфейса IUnknown”.

Если нам известны сигнатуры перехватываемых методов (как в случае с методами IUnknown), нам не потребуется универсальный перехватчик, так как вызовы всех остальных методов будут осуществляться напрямую. Такой способ имеет следующие особенности по сравнению с рассмотренным выше:

Перехватываются все вызовы через любой указатель на интерфейс, так как мы меняем исходную vtbl интерфейса.

Vtbl обычно размещается в R/O секции памяти, поэтому код установки перехватчика должен менять настройки защиты этой секции.

Нет необходимости в генерации vtbl нужного размера (мы используем исходную vtbl), в некоторых случаях нет необходимости в универсальном коде перехвата методов с неизвестной сигнатурой.

В многопоточном приложении после установки перехватчика часть вызовов может выполниться напрямую, так как некоторые потоки могли уже успеть получить адрес метода из vtbl, но еще не выполнить вызов call.

Эта технология не подходит, когда в приложении нужно перехватывать вызовы через конкретный указатель на интерфейс, а не через любые указатели на этот интерфейс, и когда нужно контролировать время жизни перехватчика.

ПРИМЕЧАНИЕ

Посмотрим, например, что произойдет при выгрузке модуля перехватчика. При этом он должен восстановить исходные адреса методов в vtbl, после чего выгрузиться. В многопоточном приложении один из потоков мог успеть получить адрес метода из vtbl (который все еще указывал на перехватчик), но не успеть сделать вызов по этому адресу. Если модуль перехватчика не будет предпринимать специальных мер по синхронизации, вызов по адресу выгруженного модуля закончится AV (access violation – ошибка доступа к памяти).

Перехватчик с постобработкой

Вернемся снова к методу перехвата, используемому в ATL. Код перехватчика позволяет с легкостью выполнить подготовку к вызову – предобработку, но затем он выполняет безусловный переход jmp в исходную функцию. Попробуем дополнить его код так, чтобы позволить выполнить постобработку после вызова.

Первая задача, которую необходимо решить – генерация vtbl перехватчика. ATL использует с этой целью макросы ATL_IMPL_THUNK, явно объявляя 1024 метода в теле класса. Рассмотрим альтернативный подход, заключающийся в динамическом создании vtbl нужного вида в runtime.

Код перехватчика должен знать порядковый номер n метода интерфейса, чтобы выполнить его вызов. Мы можем разделить весь код универсального перехватчика на 2 части – первая будет зависеть от порядкового номера перехватываемого метода (n) и будет передавать управление второй, передавая n через стек, а вторая часть будет одинаковой для всех методов.

Код первой части тривиален – мы опускаем в стек n и затем выполняем переход на тело универсального перехватчика. Мы будем использовать технику ATL (которая используется для создания оконных процедур обработки сообщений, смысл этого будет описан ниже) – создадим структуру, содержащую нужные инструкции:

#pragma pack(push, 1)

 struct vthunk

 {

 BYTE m_push;

 DWORD m_n;

 BYTE m_jmp;

 DWORD m_offset;

 void init(DWORD_PTR proc, int n)

 {

 m_push = 0x68;

 m_n = n;

 m_jmp = 0xE9;

 m_offset = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(vthunk)));

 FlushInstructionCache(GetCurrentProcess(), this, sizeof(vthunk));

 }

 };

#pragma pack(pop)

Структуру vtbl можно имитировать с помощью массива указателей на vthunk:

struct ThunkVtbl

{

 ThunkVtbl(DWORD_PTR pthunk)

 {

 for(int i = 0; i < thunk_n; ++ i)

 {

 code[i].init(pthunk, i);

 vtbl[i] = reinterpret_cast<DWORD_PTR>(&code[i]);

 }

 }

 static const int thunk_n = 1024;

 DWORD_PTR vtbl[thunk_n];

 vthunk code[thunk_n];

};

В конструкторе ThunkVtbl мы инициализируем каждый из перехватчиков vthunk порядковым номером n и адресом универсального перехватчика pthunk. Теперь массив vtbl содержит 1024 указателя на структуры vthunk, каждая из которых содержит код для вызова перехватчика:

push n

jmp pthunk

Для постобработки нам потребуется хранить адрес возврата в клиентский код. С этой целью мы будем использовать TLS и контейнер std::deque (так как в одном потоке вызовы могут быть вложенными, нам нужен именно стек).

ПРИМЕЧАНИЕ

Автор говорит о стеке, но по каким-то причинам использует двунаправленную очередь. С точки зрения функциональности это, в общем, безразлично, но несколько сбивает с толку. – прим. ред.

Внутри перехватчика указатель на нужный std::deque берется из TLS, но так как поток создается не нами, мы не можем получить уведомление о его завершении. Значит, у нас нет точки в программе, где можно было бы безопасно уничтожить объект std::deque, ассоциированный с конкретным потоком. Во избежание потери ресурсов нужно дополнительно хранить список всех созданных объектов std::deque и уничтожать их перед завершением приложения.

Ниже приведена реализация специального класса-обертки, автоматизирующего выполнение всех этих действий. Список созданных std::deque в этом классе хранится в динамическом массиве (std::vector), добавление элементов в который происходит в конкурентном режиме и требует синхронизации. Для синхронизации доступа к нему используется критическая секция.

template<class T>

struct TlsStorage

{

 TlsStorage()

 {

 m_slot = TlsAlloc();

 }

 ~TlsStorage()

 {

 std::vector<std::deque<T>* >::iterator it = m_stacks.begin();

 for( ; it != m_stacks.end(); ++it)

 delete *it;

 TlsFree(m_slot);

 }

 void push(T t)

 {

 std::deque<T>* p =

 reinterpret_cast<std::deque<T>* >(TlsGetValue(m_slot));

 if(!p)

 {

 p = new std::deque<T>;

 m_sec.Lock();

 m_stacks.push_back(p);

 m_sec.Unlock();

 TlsSetValue(m_slot, p);

 }

 p->push_back(t);

 }

 T pop()

 {

 std::deque<T>* p =

 reinterpret_cast<std::deque<T>* >(TlsGetValue(m_slot));

 T t = p->back();

 p->pop_back();

 return t;

 }

 std::vector<std::deque<T>* > m_stacks;

 CComAutoCriticalSection m_sec;

 DWORD m_slot;

};

Теперь у нас есть все необходимые составляющие. Класс ItfThunk собирает их вместе:

class ItfThunk

{

public:

 ItfThunk(void* p) : m_p(p)

 {

 vptr = &vtbl;

 }

 void __stdcall preprocess(int n)

 {

 std::cout << "method " << n << " preprocess" << std::endl;

 }

 HRESULT __stdcall postprocess(int n, HRESULT hr)

 {

 std::cout << "method " << n << " postrocess, result "

 << std::hex << hr << std::endl;

 return hr;

 }

private:

#pragma pack(push,1)

 struct CallInfo

 {

 void* p;

 int n;

 HRESULT hr;

 DWORD_PTR ret_addr;

 };

#pragma pack(pop)

private:

 static void __cdecl store(int n, DWORD_PTR ret_addr, void* p)

 {

 CallInfo i = { p, n, 0, ret_addr };

 storage.push(i);

 }

 static void __cdecl restore(HRESULT hr, CallInfo* pi)

 {

 *pi = storage.pop();

 pi->hr = hr;

 }

 static void thunk();

private:

 ThunkVtbl* vptr;

 void* m_p;

 static TlsStorage<CallInfo> storage;

 static ThunkVtbl vtbl;

};

__declspec(selectany) ThunkVtbl

 ItfThunk::vtbl(reinterpret_cast<DWORD_PTR>(ItfThunk::thunk));

__declspec(selectany) TlsStorage<ItfThunk::CallInfo> ItfThunk::storage;

Переменная-член ThunkVtbl* vptr имитирует указатель vptr на таблицу виртуальных функций “обычного” C++-класса, структура CallInfo хранит информацию, необходимую для постобработки вызова. Нам осталось рассмотреть лишь реализацию статического метода void thunk(), выполняющего универсальный перехват. Перед вызовом этого перехватчика в стеке находятся параметры для исходного метода, указатель на this, адрес возврата в клиентский код и n – порядковый номер метода (который положил в стек vthunk):

Перехват методов COM интерфейсов 

Рисунок 3. Стек вызова

__declspec(naked) void ItfThunk::thunk()

{

 __asm

 {

 push [esp] // кладем в стек n (параметр метода preprocess)

 push [esp+0Ch] // кладем в стек this для вызова preprocess

 call preprocess // вызываем ItfThunk::preprocess(n)

 call store // вызываем ItfThunk::store

 mov eax, [esp+8] // заменяем this в стеке на исходный

 mov eax, [eax+4] // из переменной ItfThunk::m_p

 mov [esp+8], eax

 lea eax, post_thunk // заменяем адрес возврата на post_thunk

 mov [esp+4], eax

 mov eax,[esp+8] // получаем vptr из исходного указателя

 mov eax, [eax]

 pop ecx // убираем из стека лишний параметр n

 mov eax, [eax+4*ecx] // полчаем адрес метода из vtbl

 jmp eax // переходим в исходный метод

post_thunk:

 sub esp, 10h // выделяем в стеке место для CallInfo

 push esp

 push eax // результат вызова исходного метода в eax

 call restore // восстанавливаем инфрмацию из TLS

 add esp,8

 call postprocess // постобработка

 ret

 }

}

Использовать перехватчик очень просто – клиент передает указатель на настоящий интерфейс конструктору ItfThunk и затем использует ItfThunk в качестве указателя:

CComPtr<IFoo> spFoo;

HRESULT hr = spFoo.CoCreateInstance(__uuidof(Foo));

thunks::ItfThunk t(spFoo.p);

spFoo.p = reinterpret_cast<IFoo*>(&t);

spFoo->F();

Теперь мы можем выполнять постобработку вызова, но есть еще одна задача, которую этот перехватчик не решает – предположим, что в некоторых случаях в результате предобработки мы принимаем решение, что вызов исходного метода должен быть заблокирован. Типичный пример – ролевая безопасность. Вызов метода не проходит проверку ролевой безопасности и должен быть отклонен. Но мы не можем сделать этого, так как точное количество параметров метода неизвестно, и наш перехватчик делегирует очистку стека после вызова самому методу.

В общем случае для COM-интерфейсов мы не можем узнать сигнатуру их методов, но для интерфейсов, использующих typelib-маршалинг или итерфейсов, proxy/stub которых сгенерирован с ключом MIDL /oicf, эта информация доступна.

ПРИМЕЧАНИЕ

Ключ /oicf компилятора midl позволяет генерировать интерпретируемый код для proxy/stub и, как результат, информация о сигнатурах метода доступна программно. Подробнее об этом можно прочитать в статье Перехват методов COM интерфейсов“Секреты маршалинга”.

Получив информацию о количестве параметров метода, мы смогли решить несколько задач:

Заблокировать вызов метода.

Выполнять отложенный/асинхронный вызов.

И все это благодаря тому, что перехватчик сможет очищать стек самостоятельно, не делегируя эту работу исходному методу.

Необходимости самостоятельно разрабатывать перехватчик, опирающийся на информацию из библиотеки типов, нет – начиная с W2K документирован API, позволяющий использовать стандартные перехватчики из инфраструктуры COM/COM+ в своих целях.

CoGetInterceptor, CoGetInterceptorFromTypeInfo

В предыдущем разделе статьи мы рассмотрели несколько технологий перехвата вызовов методов интерфейсов (и могли почувствовать сложность создания универсального перехватчика). Но ни одна из этих технологий не позволила решить задачу перехвата полностью. В частности, не решена задача асинхронных/отложенных вызовов.

К нашей радости, теперь документированы API-функции, позволяющие использовать в приложениях перехватчики из инфраструктуры COM/COM+.

ПРИМЕЧАНИЕ

Это те самые перехватчики, с помощью которых COM+ обеспечивает свои сервисы прозрачно для компонента и клиента – ролевую безопасность, синхронизацию и т.д.

Получить перехватчик для произвольного интерфейса можно с помощью функции CoGetInterceptor:

HRESULT CoGetInterceptor(

 REFIID iidIntercepted, // IID перехватываемого интерфейса

 IUnknown * punkOuter, // IUnknown для агрегации

 REFIID iid, // IID интерфейса, запрашиваемого у перехватчика

 void ** ppv // указатель на интерфейс перехватчика

);

Перехватчики COM+ используют информацию из библиотеки типов, чтобы определить сигнатуру метода и количество/типы параметров, а также выполнить маршалинг. Поэтому, если быть более точным, в качестве первого параметра (iidInterceptor) годятся не произвольные интерфейсы, а только те из них, которые совместимы с oleautomation и описаны в библиотеке типов.

Основной интерфейс перехватчика – ICallInterceptor, его мы и будем запрашивать в вызове CoGetInterceptor:

#include <callobj.h>

CComModule _Module;

int _tmain(int argc, _TCHAR* argv[])

{

 CoInitialize( 0);

 _Module.Init(0, 0 );

 {

 CComPtr<IFoo> spFoo;

 HRESULT hr = spFoo.CoCreateInstance(__uuidof(Foo));

 CComPtr<ICallInterceptor> spInt;

 hr = CoGetInterceptor(__uuidof(IFoo), 0, __uuidof(ICallInterceptor),

 reinterpret_cast<void**>(&spInt));

 }

 _Module.Term();

 CoUninitialize();

 return 0;

}

Результатом выполнения

Если Вам нужна помощь с академической работой (курсовая, контрольная, диплом, реферат и т.д.), обратитесь к нашим специалистам. Более 90000 специалистов готовы Вам помочь.
Бесплатные корректировки и доработки. Бесплатная оценка стоимости работы.

Поможем написать работу на аналогичную тему

Получить выполненную работу или консультацию специалиста по вашему учебному проекту
Нужна помощь в написании работы?
Мы - биржа профессиональных авторов (преподавателей и доцентов вузов). Пишем статьи РИНЦ, ВАК, Scopus. Помогаем в публикации. Правки вносим бесплатно.

Похожие рефераты: