Monitoring RDS events

wts.cc

#include <iostream>
#include "AutoWTSFreeMemory.h"

namespace {
    const char* connection_state_to_string(WTS_CONNECTSTATE_CLASS connectionState){
        switch (connectionState){
        case WTSActive:{
            return "WTSActive";
        } break;

        case WTSConnected:{
            return "WTSConnected";
        } break;

        case WTSConnectQuery:{
            return "WTSConnectQuery";
        } break;

        case WTSShadow:{
            return "WTSShadow";
        } break;

        case WTSDisconnected:{
            return "WTSDisconnected";
        } break;

        case WTSIdle:{
            return "WTSIdle";
        } break;

        case WTSListen:{
            return "WTSListen";
        } break;

        case WTSReset:{
            return "WTSReset";
        } break;

        case WTSDown:{
            return "WTSDown";
        } break;

        case WTSInit:{
            return "WTSInit";
        } break;

        default:{
            return "UNKNOWN";
        } break;
        }
    }

    const char* wts_to_string(DWORD flag) {
        switch (flag) {
            case WTS_EVENT_NONE: {
                return "WTS_EVENT_NONE\n";
            } break;

            case WTS_EVENT_CONNECT: {
                return "WTS_EVENT_CONNECT\n";
            } break;

            case WTS_EVENT_CREATE: {
                return "WTS_EVENT_CREATE\n";
            } break;

            case WTS_EVENT_DELETE: {
                return "WTS_EVENT_DELETE\n";
            } break;

            case WTS_EVENT_DISCONNECT: {
                return "WTS_EVENT_DISCONNECT\n";
            } break;

            case WTS_EVENT_LICENSE: {
                return "WTS_EVENT_LICENSE\n";
            } break;

            case WTS_EVENT_LOGOFF: {
                return "WTS_EVENT_LOGOFF\n";
            } break;

            case WTS_EVENT_LOGON: {
                return "WTS_EVENT_LOGON\n";
            } break;

            case WTS_EVENT_RENAME: {
                return "WTS_EVENT_RENAME\n";
            } break;

            case WTS_EVENT_STATECHANGE: {
                return "WTS_EVENT_STATECHANGE\n";
            } break;

            default: {
                return "UNKNOWN\n";
            } break;
        }
    }

    void print_flags(DWORD flags){
        if (flags == WTS_EVENT_NONE) {
            std::cout << "WTS_EVENT_NONE\n";
            return;
        }
        for (auto flag : {
                WTS_EVENT_CONNECT, WTS_EVENT_CREATE, WTS_EVENT_DELETE, WTS_EVENT_DISCONNECT, WTS_EVENT_LICENSE,
                WTS_EVENT_LOGOFF, WTS_EVENT_LOGON, WTS_EVENT_RENAME, WTS_EVENT_STATECHANGE})
            {
                bool hasFlag = flags & flag;
                if (hasFlag){
                    std::cout << wts_to_string(flag);
                }
            }
    }
}

int main()
{
    while (true) {
        std::cout << "=============== WAITING FOR WTS EVENT ================ \n";
        DWORD resultingFlags = 0;
        if (::WTSWaitSystemEvent(WTS_CURRENT_SERVER_HANDLE, WTS_EVENT_ALL, &resultingFlags)) {
            std::cout << "FLAGS:\n";
            print_flags(resultingFlags);

            std::cout << "\nCurrent Session Info:\n";
            helpers::AutoWTSFreeMemory<WTS_CONNECTSTATE_CLASS> mem;
            DWORD dataSize = 0;
            if (::WTSQuerySessionInformationW(
                WTS_CURRENT_SERVER_HANDLE,
                WTS_CURRENT_SESSION,
                WTSConnectState,
                reinterpret_cast<wchar_t**>(mem.p_ptr()),
                &dataSize))
            {
                std::cout << connection_state_to_string(*mem.ptr()) << "\n";
            } else {
                std::cout << "WTSQuerySessionInformationW failed!\n";
            }
        } else {
            //TODO: report error
            std::cout << "WTSWaitSystemEvent failed\n";
        }
    }
    return 0;
}