SHUTDOWN event einmal abfangen und Programm ausführen lassen

Hallo Jungs und Mädels,
ich hab es jetzt so weit das es grob funktioniert!! Hab aber noch a paar Fragen.

Dieser Code ist kopiert. Alleine hätte ich das wohl nicht so schnell gehabt.

Bei diesem Zeilenabschnitt //xx hab ich eine schleife eingebaut. Nicht performant ich weiß ! Aber das gab mir die nötige Zeit um in der cmd den shutdown -a auszulösen.

Es hat funkioniert. Der Shutdown wurde abgebrochen ok ok

Jetzt aber wie bekomm ich das hin wenn eine gewisse Sequenz von Befehlen die abgearbeitet wird, wobei ein Befehl durchaus mal 10 Minuten daueren kann. Wie muss ich jetzt mit der PreventSystemShutdown(); umgehen ??

Muss ich das in einer anderen exe laufen lassen und ständig überprüfen oder einen eigenen Prozess dazu starten -> in UNIX gehts mit fork() in Windows glaub ich CreateProcess()

Wenn dieser ganze Code auch kürzer geht dann bin ich sehr mit Kritik einverstanden. Ich hab leider noch ned den Durchblick bei der Struktur der WinApi ?: )
C/C++ sollt ich verstehen.

Vielen Dank an alle schon mal

#include <windows.h> 

#define WinVerMajor()  LOBYTE(LOWORD(GetVersion())) 

#define IsWinVerNTs()  (GetVersion() < 0x80000000) 
#define IsWinVerNT351Plus() (IsWinVerNTs() && WinVerMajor() >= 3) 

#define ERR_MSG TEXT("This program requires Windows NT version 3.1 or later!") 

BOOL (__stdcall * MyAbortSystemShutdown)(LPTSTR); 

BOOL fAbortSystemShutdown(LPTSTR lpMachineName); 
BOOL PreventSystemShutdown(void); 

int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
                      LPSTR lpCmdLine, int nCmdShow) 
{ 
         //xx 
         int i=0; 
    while( i <= 10000000) 
    { 
        i++; 
    } 

    if (IsWinVerNT351Plus()) 
    { 
        PreventSystemShutdown(); 
    } 
    else 
    { 
        MessageBox(NULL, ERR_MSG, TEXT("Abort System Shutdown"), MB_OK); 
    } 

    return (0); 
} 

/* 
 *    AbortSystemShutdown 
 * 
 *    The AbortSystemShutdown function stops a system shutdown started by using 
 *    the InitiateSystemShutdown function. 
 */ 
BOOL fAbortSystemShutdown(LPTSTR lpMachineName) 
{ 
    HINSTANCE hinstLib; 
    BOOL result = FALSE; 

    if (IsWinVerNT351Plus()) 
    { 
        hinstLib = LoadLibrary(TEXT("Advapi32.dll")); 

        if (hinstLib) 
        { 
            if (MyAbortSystemShutdown = (BOOL (__stdcall *)(LPTSTR)) 
                #ifdef UNICODE 
                    GetProcAddress(hinstLib, "AbortSystemShutdownW"))   
                #else 
                    GetProcAddress(hinstLib, "AbortSystemShutdownA")) 
                #endif // !UNICODE 
            { 
                result = (MyAbortSystemShutdown)(lpMachineName); 
            } 
        } 

        FreeLibrary(hinstLib); 
    } 

    return (result); 
} 

BOOL PreventSystemShutdown(void) 
{ 
    HANDLE hToken;              // handle to process token 
    TOKEN_PRIVILEGES tkp;       // pointer to token structure 

    // Get the current process token 
    // handle so we can get shutdown privilege. 
    if (!OpenProcessToken(GetCurrentProcess(), 
        TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) 
    { 
        return (FALSE); 
    } 

    // Get the LUID for shutdown privilege. 
    LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid); 

    tkp.PrivilegeCount = 1;  // one privilege to set     
    tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 

    // Get shutdown privilege for this process. 
    AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, 
                          (PTOKEN_PRIVILEGES) NULL, 0); 

    if (GetLastError() != ERROR_SUCCESS) 
    { 
        return (FALSE); 
    } 

    // Prevent the system from shutting down. 
    if (! fAbortSystemShutdown(NULL)) 
    { 
        LPVOID lpMsgBuf; 

        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                      FORMAT_MESSAGE_FROM_SYSTEM | 
                      FORMAT_MESSAGE_IGNORE_INSERTS, 
            NULL, GetLastError(), 
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language 
            (LPTSTR) &lpMsgBuf, 0, NULL 
        ); 

        // Display the string. 
        MessageBox(NULL, (LPCTSTR) lpMsgBuf, TEXT("Error"), 
                   MB_OK | MB_ICONINFORMATION); 

        // Free the buffer. 
        LocalFree(lpMsgBuf); 

        return (FALSE); 
    } 

    // Disable shutdown privilege. 
    tkp.Privileges[0].Attributes = 0; 
    AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES) NULL, 0); 

    return (TRUE); 
}

Martin Richter

Und was soll diese Funktion?
Wenn jemand shutdown -t 0 ausführt wirkt Deine Funktion gar nicht.
Wenn man einen normalen Shutdown auslöst wirkt sie auch nicht.

Hallo Martin,

du startest die cmd
shutdown -s

und führst dann diese exe aus. Dann wird der Shutdown abgebrochen.

Ich kenn mich mit der WINAPI leider noch ned wirklich aus, finde des sehr komisch strukturiert.
Ich glaub auch immer noch das des ganze keine 130 Code zeilen benötigt. Des sollte doch einfacher gehen oder ned ??

Was will ich?
Ich will in einem Programm einen shutdown event abfangen, der soll dann nicht ausgeführt werden. Ich will noch ein paar Befehle nach diesem Shutdown ausführen und dann selbst runterfahren.

Meine Grobe Struktur meines Programms sieht in etwas so aus.

header.h

class X

   method1
   method2
   ....

main.cpp
{
   Programmablauf

   /////
   hier irgendwie den shutdown event abfangen wenns so möglich ist
   /////

return 0;
}

Kann man die WINAPI überhaupt mit C++ so einfach verknüpfen ? Von der Struktur der WINAPI sieht das etwas anders aus...

Mein Vorhaben sollte doch möglich sein. Ich weiß wie gesagt nicht wo und wie ich diesen event abfangen soll. Geht das überhaupt in einer Sequenz von Befehlen ? Oder muss die event in einem eigenem Process laufen ??

Viele Dank an jeden Kommi