Грабли с WM_DEVICECHANGE

//
// Copyright (c) Убежденный
// :)
//
// ВНИМАНИЕ!
// Код только для демонстрации, нормальная проверка
// ошибок и очистка ресурсов отсутствует.
//
 
#include <Windows.h>
#include <ShlObj.h>
#include <dbt.h>
#include <string>
#include <vector>
#include <strsafe.h>
 
 
 
//
// Custom window message for SHChangeNotifyRegister.
//
#define WM_CHANGE_NOTIFY (WM_APP + 1)
 
 
 
HANDLE      volatile g_hFile     = INVALID_HANDLE_VALUE;
HMODULE     volatile g_hInst     = NULL;
HWND        volatile g_hWnd      = NULL;
HDEVNOTIFY  volatile g_hNotify   = NULL;
ULONG       volatile g_hShNotify = 0;
 
 
 
//
// Convert DBT_XXX constant (dbt.h) to string.
// 
char const * DbtToStr(WPARAM wParam)
{
#define CASE(_x_) case _x_: return #_x_
 
    switch (wParam)
    {
        CASE(DBT_CONFIGCHANGECANCELED);
        CASE(DBT_CONFIGCHANGED);
        CASE(DBT_CUSTOMEVENT);
        CASE(DBT_DEVICEARRIVAL);
        CASE(DBT_DEVICEQUERYREMOVE);
        CASE(DBT_DEVICEQUERYREMOVEFAILED);
        CASE(DBT_DEVICEREMOVECOMPLETE);
        CASE(DBT_DEVICEREMOVEPENDING);
        CASE(DBT_DEVICETYPESPECIFIC);
        CASE(DBT_DEVNODES_CHANGED);
        CASE(DBT_QUERYCHANGECONFIG);
        CASE(DBT_USERDEFINED);
    }
 
#undef CASE
 
    return "<UNKNOWN>";
}
 
 
 
//
// Convert SHCNE_XXX constant (ShlObj.h) to string.
//
char const * EvtToStr(LONG EventId)
{
#define CASE(_x_) case _x_: return #_x_
 
    switch (EventId)
    {
        CASE(SHCNE_MEDIAINSERTED);
        CASE(SHCNE_MEDIAREMOVED);
        CASE(SHCNE_DRIVEADD);
        CASE(SHCNE_DRIVEREMOVED);
    }
 
#undef CASE
 
    return "<UNKNOWN>";
}
 
 
 
//
// Create formatted string.
//
std::string FormatStr(char const * pFormat, va_list VaList)
{
    size_t const BuffSize = 1000;
    std::vector<char> Buffer(BuffSize);
    if (S_OK == StringCchVPrintfA(&Buffer[0], BuffSize, pFormat, VaList))
        return (&Buffer[0]);
    return pFormat;
}
 
 
 
//
// Show error box and exit program.
//
__declspec(noreturn) 
void ThrowExc(char const * pFormat, ...)
{
    va_list VaList;
    va_start(VaList, pFormat);
    std::string const Msg = FormatStr(pFormat, VaList);
    MessageBoxA(g_hWnd, Msg.c_str(), "ERROR", MB_ICONERROR);
    _exit(EXIT_FAILURE);
}
#define THROW_EXC(Fmt,...) ThrowExc(__FUNCTION__ ": " Fmt, __VA_ARGS__)
#define THROW_CODE(Func,Code) THROW_EXC(#Func " failed, err = 0x%.8lx.", Code)
#define THROW_GLE(Func) THROW_CODE(Func,GetLastError())
 
 
 
//
// Write string to log file.
// 
void Log(char const * pFormat, ...)
{
    SYSTEMTIME st = {0};
    GetLocalTime(&st);
    size_t const BuffSize = 256;
    std::vector<char> Buffer(BuffSize);
    std::string Msg;
    if (S_OK == StringCchPrintfA(
        &Buffer[0],
        BuffSize,
        "%.4lu.%.2lu.%.2lu-%.2lu:%.2lu:%.2lu    ",
        st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond
        ))
    {
        Msg = &Buffer[0];
    }
 
    va_list VaList;
    va_start(VaList, pFormat);
    Msg += FormatStr(pFormat, VaList) + "\r\n";
    DWORD nBytes;
    WriteFile(g_hFile, Msg.c_str(), static_cast<DWORD>(Msg.length()), &nBytes, NULL);
    FlushFileBuffers(g_hFile);
}
 
 
 
//
// Window procedure.
// 
LRESULT CALLBACK MyWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
    switch (Msg)
    {
        case WM_CREATE:
        {
            g_hWnd = hWnd;
 
            //
            // Create log file.
            //
 
            g_hFile = CreateFileW(
                L"C:\\Test\\Test.log",
                GENERIC_WRITE,
                FILE_SHARE_READ,
                NULL, // Security attributes.
                CREATE_ALWAYS,
                FILE_ATTRIBUTE_NORMAL,
                NULL  // Template handle.
                );
            if (INVALID_HANDLE_VALUE == g_hFile) {
                THROW_GLE(CreateFileW);
            }
 
            //
            // Register device change notification.
            //
 
            DEV_BROADCAST_DEVICEINTERFACE_W Flt = {0};
            Flt.dbcc_size       = sizeof (Flt);
            Flt.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
            
            g_hNotify = RegisterDeviceNotificationW(
                hWnd,
                &Flt,
                DEVICE_NOTIFY_WINDOW_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES
                );
            if (!g_hNotify) {
                THROW_GLE(RegisterDeviceNotificationW);
            }
 
            //
            // Register shell & filesystem notification.
            //
 
            SHChangeNotifyEntry Entry = {0};
            Entry.fRecursive = TRUE;
 
            LPITEMIDLIST pidl;
 
            HRESULT const Status = SHGetFolderLocation(
                NULL, // Reserved.
                CSIDL_DESKTOP,
                NULL, // Access token.
                0,    // Reserved.
                &pidl
                );
            if (!SUCCEEDED(Status)) {
                THROW_CODE(SHGetFolderLocation, Status);
            }
 
            Entry.pidl = pidl;
 
            g_hShNotify = SHChangeNotifyRegister(
                hWnd,
                SHCNRF_ShellLevel | SHCNRF_InterruptLevel | SHCNRF_NewDelivery,
                SHCNE_MEDIAINSERTED | SHCNE_MEDIAREMOVED | SHCNE_DRIVEADD | SHCNE_DRIVEREMOVED,
                WM_CHANGE_NOTIFY,
                1,
                &Entry
                );
            if (!g_hShNotify) {
                THROW_GLE(SHChangeNotifyRegister);
            }
 
            ILFree(pidl);
        }
        break;
 
        case WM_DESTROY:
        {
            //
            // Unregister shell & filesystem notification.
            //
 
            if (!SHChangeNotifyDeregister(g_hShNotify)) {
                THROW_GLE(SHChangeNotifyDeregister);
            }
 
            //
            // Unregister device change notification.
            //
 
            if (!UnregisterDeviceNotification(g_hNotify)) {
                THROW_GLE(UnregisterDeviceNotification);
            }
 
            //
            // Close log file.
            //
 
            if (!CloseHandle(g_hFile)) {
                THROW_GLE(CloseHandle);
            }
 
            PostQuitMessage(0);
            return 0;
        }
        break;
 
        case WM_DEVICECHANGE:
        {
            Log(
                "WM_DEVICECHANGE: wParam = %s (0x%.8lx)",
                DbtToStr(wParam),
                wParam
                );                
            return TRUE;
        }
        break;
 
        case WM_CHANGE_NOTIFY:
        {
            LONG EventId;
            HANDLE const hLock = SHChangeNotification_Lock(
                reinterpret_cast<HANDLE>(wParam),
                static_cast<DWORD>(lParam),
                NULL, // [out] LPITEMIDLIST **
                &EventId
                );
            SHChangeNotification_Unlock(hLock);
 
            Log(
                "WM_CHANGE_NOTIFY: EventId = %s (0x%.8lx)",
                EvtToStr(EventId),
                EventId
                );
        }
        break;
    }
 
    return (DefWindowProcW(hWnd, Msg, wParam, lParam));
}
 
 
 
//
// Program entry point.
// 
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int)
{
    g_hInst = hInst;
 
    //
    // Register window class.
    //
 
    WNDCLASSEXW wc = {0};
    wc.cbSize        = sizeof (wc);
    wc.hbrBackground = CreateSolidBrush(0x404040);
    wc.hCursor       = LoadCursorW(NULL, IDC_ARROW);
    wc.hIcon         = LoadIconW(NULL, IDI_APPLICATION);
    wc.hIconSm       = wc.hIcon;
    wc.hInstance     = hInst;
    wc.lpfnWndProc   = MyWndProc;
    wc.lpszClassName = L"SdCardDetectWndClass";
    wc.style         = CS_HREDRAW | CS_VREDRAW;
 
    ATOM const Atom = RegisterClassExW(&wc);
    if (!Atom) {
        THROW_GLE(RegisterClassExW);
    }
 
    //
    // Create window.
    //
 
    HWND const hWnd = CreateWindowExW(
        0, // Extended styles.
        reinterpret_cast<LPCWSTR>(Atom),
        L"SD Card Detect",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        NULL, // Parent window.
        NULL, // Menu handle.
        hInst,
        NULL // Init argument.
        );
    if (!hWnd) {
        THROW_GLE(CreateWindowExW);
    }
 
    ShowWindow(hWnd, SW_SHOWNORMAL);
    UpdateWindow(hWnd);
 
    //
    // Message loop.
    //
 
    MSG Msg;
 
    for (;;)
    {
        int const Status = GetMessageW(&Msg, NULL, 0, 0);
        if ( (-1 == Status) || (0 == Status) )
        {
            break;
        }
 
        TranslateMessage(&Msg);
        DispatchMessageW(&Msg);
    }
 
    return EXIT_SUCCESS;
}