Exception self-handler in c using Assembly - c

Question

I create a self exception handler by using assembly in c file by this code:
__asm
{
pushad
mov esi, offset Handler
push esi
push dword ptr fs:[0]
mov dword ptr fs:[0], esp
push u32Param
call pFunc;
jmp NoException
Handler:
mov esp, [esp + 8]
pop dword ptr fs:[0]
add esp, 4
popad
mov eax, 0x80000000
jmp ExceptionHandled
NoException:
pop dword ptr fs:[0]
add esp, 40
ExceptionHandled:
}
This code is simple exception handling in assembly.
This code works in new created vc project.But in my project it make an exception and vc says that there is an invalid exception handler.
Any Suggestion?

Answer 1

If you are following this article, which it seems you are, then why aren't you properly restoring the stack as shown in the code there?
The code in the article:
18 NoException&;Handler: ;;No Exception Occured
19 pop dword ptr fs:[0] ;;Restore Old Exception Handler
20 add esp, 32 + 4 ;;ESP value before SEH was set. 32 for pushad and ...
21 ExceptionHandled&;Handler: ;;...4 for push offset Handler. (No Restore State)
22 ;;Exception has been handled, or no exception occured
Your code:
NoException:
pop dword ptr fs:[0]
add esp, 8
ExceptionHandled:
32 in that code is to undo pushad, 4 is to undo push esi. Why do you have 8? 32 + 4 ≠ 8.
If that's how you want to remove u32Param from the stack (in case pFunc doesn't do it for you), then you should do it between these two lines:
call pFunc;
add esp, 4
jmp NoException
My version:
// file: tst.c
// compile with Open Watcom C/C++ 1.9: wcl386.exe /q /we /wx tst.c
// ditto with debug info: wcl386.exe /q /we /wx /d2 tst.c
#include <stdio.h>
unsigned __stdcall func(volatile unsigned* p)
{
return *p;
}
unsigned blah(unsigned (__stdcall *pFunc)(volatile unsigned*), volatile unsigned* u32Param)
{
unsigned result = 0;
__asm
{
pushad
// mov esi, offset Handler // Open Watcom C/C++ says Handler is undefined
// push esi
// lea eax, blah
// add eax, Handler - blah // this difference doesn't come out correct with Open Watcom C/C++
// add eax, 78 // 78 is Handler - blah // this is unreliable
// push eax
push 0xFDCB4321
jmp GetHandlerAddr
GotHandlerAddr:
pop eax
add esp, 4
push eax
push dword ptr fs:[0]
mov dword ptr fs:[0], esp
push u32Param
call dword ptr [pFunc]
jmp NoException
GetHandlerAddr:
call Handler // this will place &Handler on the stack
Handler:
cmp dword ptr [esp + 4], 0xFDCB4321
je GotHandlerAddr
mov esp, [esp + 8]
pop dword ptr fs:[0]
add esp, 4
popad
mov eax, 0x80000000
jmp ExceptionHandled
NoException:
pop dword ptr fs:[0]
add esp, 32 + 4
ExceptionHandled:
mov result, eax
}
return result;
}
int main(void)
{
volatile unsigned n = 0x113355AA;
printf("%08X\n", func(&n));
printf("%08X\n", blah(&func, &n));
printf("%08X\n", blah(&func, (volatile unsigned*)0));
printf("%08X\n", blah(&func, (volatile unsigned*)0));
return 0;
}
Output:
113355AA
113355AA
80000000
80000000