windows-server-2003/com/mobile/sens/conn/senssvc/event.cxx

/*++

Copyright (C) Microsoft Corporation, 1997 - 1999

Module Name:

    event.cxx

Abstract:

    SENS code related to firing Events using LCE mechanism.

Author:

    Gopal Parupudi    <GopalP>

[Notes:]

    optional-notes

Revision History:

    GopalP          10/31/1997         Start.

--*/


#include <precomp.hxx>


//
// Some useful Macros
//


/*++

Macro Description:

    Helper Macro for firing Winlogon events.

Arguments:

    See signature.

--*/
#define FIRE_WINLOGON_EVENT(_EVENT_NAME_, _EVENT_TYPE_)                         \
{                                                                               \
    PSENSEVENT_WINLOGON pData = (PSENSEVENT_WINLOGON)EventData;                 \
    WCHAR buffer[CRED_MAX_USERNAME_LENGTH];                                     \
                                                                                \
    *buffer = 0;                                                                \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("\t|            WINLOGON Event\n")));                         \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                 Type  -  %s\n"), _EVENT_NAME_));    \
    SensPrint(SENS_INFO, (SENS_STRING("\t|                 Size  -  %d\n"), pData->Info.Size));     \
    SensPrint(SENS_INFO, (SENS_STRING("\t|                Flags  -  0x%x\n"), pData->Info.Flags));  \
    SensPrintW(SENS_INFO, (SENS_BSTR("\t|             UserName  -  %s\n"),                          \
              pData->Info.UserName ? pData->Info.UserName : SENS_BSTR("")));                        \
    SensPrintW(SENS_INFO, (SENS_BSTR("\t|               Domain  -  %s\n"),                          \
              pData->Info.Domain ? pData->Info.Domain : SENS_BSTR("")));                            \
    SensPrintW(SENS_INFO, (SENS_BSTR("\t|           WinStation  -  %s\n"),                          \
              pData->Info.WindowStation ? pData->Info.WindowStation : SENS_BSTR("")));              \
    SensPrint(SENS_INFO, (SENS_STRING("\t|               hToken  -  0x%x\n"), pData->Info.hToken)); \
    SensPrint(SENS_INFO, (SENS_STRING("\t|             hDesktop  -  0x%x\n"), pData->Info.hDesktop));    \
    SensPrint(SENS_INFO, (SENS_STRING("\t|          dwSessionId  -  0x%x\n"), pData->Info.dwSessionId)); \
                                                                                \
    if (pData->Info.Domain != NULL)                                             \
        {                                                                       \
        StringCchCopy(buffer, CRED_MAX_USERNAME_LENGTH, pData->Info.Domain);    \
        StringCchCat(buffer, CRED_MAX_USERNAME_LENGTH, SENS_BSTR("\\"));        \
        }                                                                       \
    if (pData->Info.UserName != NULL)                                           \
        {                                                                       \
        StringCchCat(buffer, CRED_MAX_USERNAME_LENGTH, pData->Info.UserName);   \
        }                                                                       \
    SensPrintW(SENS_INFO, (SENS_BSTR("\t|    UserName passed is -  %s\n"), buffer));   \
    hr = SensFireWinlogonEventHelper(buffer, pData->Info.dwSessionId, _EVENT_TYPE_);   \
                                                                                \
    break;                                                                      \
}


/*++

Macro Description:

    Helper Macro for firing PnP events.

Arguments:

    See signature.

Notes:

    a. This is not an actual event exposed by SENS.

--*/
#define FIRE_PNP_EVENT(_EVENT_NAME_)                                            \
{                                                                               \
    PSENSEVENT_PNP pData = (PSENSEVENT_PNP)EventData;                           \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("\t|            PNP Event\n")));          \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                 Type  -  DEVICE %s\n"), _EVENT_NAME_)); \
    SensPrint(SENS_INFO, (SENS_STRING("\t|                 Size  -  %d\n"), pData->Size));            \
    SensPrint(SENS_INFO, (SENS_STRING("\t|              DevType  -  %d\n"), pData->DevType));         \
    SensPrint(SENS_INFO, (SENS_STRING("\t|             Resource  -  0x%x\n"), pData->Resource));      \
    SensPrint(SENS_INFO, (SENS_STRING("\t|                Flags  -  0x%x\n"), pData->Flags));         \
                                                                                \
    break;                                                                      \
}


/*++

Macro Description:

    Helper Macro for firing Power events.

Arguments:

    See signature.

--*/
#define FIRE_POWER_EVENT(_EVENT_NAME_, _EVENT_TYPE_)                            \
{                                                                               \
    PSENSEVENT_POWER pData = (PSENSEVENT_POWER)EventData;                       \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("\t|            POWER MANAGEMENT Event\n"))); \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                  Type  -  %s\n"), _EVENT_NAME_));     \
    SensPrint(SENS_INFO, (SENS_STRING("\t|          ACLineStatus  -  %d\n"),        \
              pData->PowerStatus.ACLineStatus));                                    \
    SensPrint(SENS_INFO, (SENS_STRING("\t|           BatteryFlag  -  %d\n"),        \
              pData->PowerStatus.BatteryFlag));                                     \
    SensPrint(SENS_INFO, (SENS_STRING("\t|    BatteryLifePercent  -  %d\n"),        \
              pData->PowerStatus.BatteryLifePercent));                              \
    SensPrint(SENS_INFO, (SENS_STRING("\t|       BatteryLifeTime  -  0x%x secs\n"), \
              pData->PowerStatus.BatteryLifeTime));                                 \
    SensPrint(SENS_INFO, (SENS_STRING("\t|   BatteryFullLifeTime  -  0x%x secs\n"), \
              pData->PowerStatus.BatteryFullLifeTime));                         \
    hr = SensFirePowerEventHelper(pData->PowerStatus, _EVENT_TYPE_);            \
    break;                                                                      \
}


/*++

Macro Description:

    Helper Macro for firing RAS events.

Arguments:

    See signature.

Notes:

    a. This is not an actual event exposed by SENS. It may, however, generate
       a WAN Connectivity event.

--*/
#define FIRE_RAS_EVENT(_EVENT_NAME_)                                            \
{                                                                               \
                                                                                \
    PSENSEVENT_RAS pData = (PSENSEVENT_RAS)EventData;                           \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("\t|            RAS Event\n")));          \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                 Type  -  %s\n"), _EVENT_NAME_));     \
    SensPrint(SENS_INFO, (SENS_STRING("\t|    Connection Handle  -  0x%x\n"), pData->hConnection));  \
    break;                                                                      \
}


/*++

Macro Description:

    Helper Macro for firing LAN events.

Arguments:

    See signature.

Notes:

    a. This is not an actual event exposed by SENS. It may, however, generate
       a LAN Connectivity event.

--*/
#define FIRE_LAN_EVENT(_EVENT_NAME_)                                            \
                                                                                \
{                                                                               \
    PSENSEVENT_LAN pData = (PSENSEVENT_LAN)EventData;                           \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("\t|            LAN Event\n")));          \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                 Type  -  %s\n"), _EVENT_NAME_));    \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|      Connection Name  -  %s\n"), pData->Name));     \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                Status -  0x%x\n"), pData->Status)); \
    SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|                  Type -  0x%x\n"), pData->Type));   \
    break;                                                                      \
}


/*++

Macro Description:

    This macro is called when we allocate the EventData so that it can be
    queued to a worker thread. ALLOCATE_END() should be called to signal the
    end of the allocation.

Arguments:

    See signature.

Notes:

    a. pData, pTempData and pReturnData are fixed names for the variable.
       They should not be changed without updating the code that uses
       this macro.

--*/
#define ALLOCATE_BEGIN(_EVENT_STRUCT_)                                          \
                                                                                \
    _EVENT_STRUCT_ *pData, *pTempData;                                          \
                                                                                \
    /* Allocate the Data structure */                                           \
    pTempData = (_EVENT_STRUCT_ *) EventData;                                   \
    pData = (_EVENT_STRUCT_ *) new char[sizeof(_EVENT_STRUCT_)];                \
    if (NULL == pData)                                                          \
        {                                                                       \
        goto Cleanup;                                                           \
        }                                                                       \
                                                                                \
    memcpy(pData, EventData, sizeof(_EVENT_STRUCT_));



/*++

Macro Description:

    This macro is called when we allocate the strings in the EventData before
    queueing to a worker thread. FREE_STRING_MEMBER() should be called to free
    the string before the EventData itself is freed.

Arguments:

    See signature.

Notes:

    a. pData, pTempData and pReturnData are fixed names for the variable.
       They should not be changed without updating the code that uses
       this macro.

--*/
#define ALLOCATE_STRING_MEMBER(_DEST_, _SOURCE_)                                \
                                                                                \
    if (NULL != _SOURCE_)                                                       \
        {                                                                       \
        SIZE_T size = wcslen(_SOURCE_)+1;                                       \
        /* Allocate the string */                                               \
        _DEST_ = new WCHAR[size];                                              \
        if (NULL == (_DEST_))                                                   \
            {                                                                   \
            delete pData;                                                       \
            goto Cleanup;                                                       \
            }                                                                   \
        StringCchCopy((_DEST_), size, (_SOURCE_));                              \
        }


/*++

Macro Description:

    This macro is called when we finish allocating the EventData so that
    it can be queued to a worker thread. It should be always called after
    ALLOCATE_BEGIN() macro.

Arguments:

    None.

Notes:

    a. pData, pTempData and pReturnData are fixed names for the variable.
       They should not be changed without updating the code that uses
       this macro.

--*/
#define ALLOCATE_END()                                                          \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("******** Allocated a DS (0x%x)\n"), pData));     \
    pReturnData = pData;                                                        \
    break;



/*++

Macro Description:

    This macro is called to begin the deallocation of the EventData. This
    should always match with a call to ALLOCATE_BEGIN() macro.

Arguments:

    None.

Notes:

    a. pData, pTempData and pReturnData are fixed names for the variable.
       They should not be changed without updating the code that uses
       this macro.

--*/
#define FREE_BEGIN(_EVENT_STRUCT_)                                              \
                                                                                \
    _EVENT_STRUCT_ *pData;                                                      \
                                                                                \
    pData = (_EVENT_STRUCT_ *) EventData;


/*++

Macro Description:

    This macro is called to free the string member of an EventData. This
    should always match with a call to ALLOCATE_STRING_MEMBER() macro.

Arguments:

    See signature.

Notes:

    a. pData, pTempData and pReturnData are fixed names for the variable.
       They should not be changed without updating the code that uses
       this macro.

--*/
#define FREE_STRING_MEMBER(_STRING_)                                            \
                                                                                \
    if (NULL != _STRING_)                                                       \
        {                                                                       \
        /* Free the string */                                                   \
        delete _STRING_;                                                        \
        }


/*++

Macro Description:

    This macro is called to end the deallocation of EventData. This
    should always match with a call to FREE_BEGIN() macro.

Arguments:

    See signature.

Notes:

    a. pData, pTempData and pReturnData are fixed names for the variable.
       They should not be changed without updating the code that uses
       this macro.

--*/
#define FREE_END()                                                              \
                                                                                \
    SensPrint(SENS_INFO, (SENS_STRING("********** Freed a DS (0x%x)\n"), pData));       \
    delete pData;                                                               \
    break;





void
EvaluateConnectivity(
    IN CONNECTIVITY_TYPE Type
    )
/*++

Routine Description:

    This code queues up a job (for evaluating Network connectivity) to
    a worker thread.

Arguments:

    Type - Indicates the type of connectivity to be evaluated.

Return Value:

    None.

--*/
{
    BOOL bRetVal;
    LPTHREAD_START_ROUTINE lpfnEvaluate;

    switch (Type)
        {
        case TYPE_WAN:
            lpfnEvaluate = (LPTHREAD_START_ROUTINE) EvaluateWanConnectivity;
            break;

        case TYPE_DELAY_LAN:
            lpfnEvaluate = (LPTHREAD_START_ROUTINE) EvaluateLanConnectivityDelayed;
            break;

        default:
        case TYPE_LAN:
            lpfnEvaluate = (LPTHREAD_START_ROUTINE) EvaluateLanConnectivity;
            break;
        }

    bRetVal = SensQueueUserWorkItem(
                  (LPTHREAD_START_ROUTINE) lpfnEvaluate,
                  NULL,
                  SENS_LONG_ITEM    // Flags
                  );
    if (FALSE == bRetVal)
        {
        SensPrintA(SENS_ERR, ("EvaluateConnectivity(): SensQueueUserWorkItem() failed with %d.\n",
                   GetLastError()));
        }
}




void
SensFireEvent(
    IN PVOID EventData
    )
/*++

Routine Description:

    This code queues up a job (for firing a SENS event) to a worker thread.

Arguments:

    EventData - Data relating to the event.

Return Value:

    None.

--*/
{
    BOOL bRetVal;
    PVOID pAllocatedData;

    pAllocatedData = AllocateEventData(EventData);
    if (NULL == pAllocatedData)
        {
        SensPrintA(SENS_ERR, ("SensFireEvent(): Failed to allocate Event Data!\n"));
        return;
        }

    bRetVal = SensQueueUserWorkItem(
                  (LPTHREAD_START_ROUTINE) SensFireEventHelper,
                  pAllocatedData,   // Event Data
                  SENS_LONG_ITEM    // Flags
                  );
    if (FALSE == bRetVal)
        {
        SensPrintA(SENS_ERR, ("SensFireEvent(): SensQueueUserWorkItem() failed with %d.\n",
                   GetLastError()));
        }
    else
        {
        SensPrintA(SENS_INFO, ("SensFireEvent(): SensQueueUserWorkItem() succeeded.\n"));
        }
}




DWORD WINAPI
SensFireEventHelper(
    IN PVOID EventData
    )
/*++

Routine Description:

    This code sets up the necessary stuff for firing a SENS event.

Arguments:

    EventData - Data relating to the event.

Return Value:

    S_OK, if successful

    hr, otherwise

--*/
{
    SENS_EVENT_TYPE eType;
    HRESULT hr;

    SensPrint(SENS_INFO, (SENS_STRING("\t|-------------------------------------------------------|\n")));
    SensPrint(SENS_INFO, (SENS_STRING("\t|               E V E N T   F I R E D                   |\n")));
    SensPrint(SENS_INFO, (SENS_STRING("\t|-------------------------------------------------------|\n")));

    hr = S_OK;
    eType = *(SENS_EVENT_TYPE *)EventData;

    switch (eType)
        {
        case SENS_EVENT_NETALIVE:
            {
            PSENSEVENT_NETALIVE pData = (PSENSEVENT_NETALIVE)EventData;

            SensPrint(SENS_INFO, (SENS_STRING("\t|   %s%sNetwork Connectivity is %sPRESENT.\n\t|\n"),
                      (pData->QocInfo.dwFlags & CONNECTION_WAN) ? SENS_STRING("WAN ") : SENS_STRING(""),
                      (pData->QocInfo.dwFlags & CONNECTION_LAN) ? SENS_STRING("LAN ") : SENS_STRING(""),
                      pData->bAlive ? SENS_STRING("") : SENS_STRING("NOT "))
                      );

            hr = SensFireNetEventHelper(pData);
            break;
            }

        case SENS_EVENT_REACH:
            {
            PSENSEVENT_REACH pData = (PSENSEVENT_REACH)EventData;

            SensPrint(SENS_INFO, (SENS_STRING("\t|   Destination is %sREACHABLE.\n"), pData->bReachable ? "" : "NOT "));
            SensPrint(SENS_INFO, (SENS_STRING("\t|\n\t|          Name   : %s\n"), pData->Destination));
            if (pData->bReachable == TRUE)
                {
                SensPrint(SENS_INFO, (SENS_STRING("\t|       dwFlags   : 0x%x \n"), pData->QocInfo.dwFlags));
                SensPrint(SENS_INFO, (SENS_STRING("\t|       InSpeed   : %d bits/sec.\n"), pData->QocInfo.dwInSpeed));
                SensPrint(SENS_INFO, (SENS_STRING("\t|      OutSpeed   : %d bits/sec.\n"), pData->QocInfo.dwOutSpeed));
                }

            hr = SensFireReachabilityEventHelper(pData);
            break;
            }

        case SENS_EVENT_PNP_DEVICE_ARRIVED:
            FIRE_PNP_EVENT(SENS_STRING("ARRIVED"));

        case SENS_EVENT_PNP_DEVICE_REMOVED:
            FIRE_PNP_EVENT(SENS_STRING("REMOVED"));

        case SENS_EVENT_POWER_ON_ACPOWER:
            FIRE_POWER_EVENT(SENS_STRING("ON AC POWER"), eType);

        case SENS_EVENT_POWER_ON_BATTERYPOWER:
            FIRE_POWER_EVENT(SENS_STRING("ON BATTERY POWER"), eType);

        case SENS_EVENT_POWER_BATTERY_LOW:
            FIRE_POWER_EVENT(SENS_STRING("BATTERY IS LOW"), eType);

        case SENS_EVENT_POWER_STATUS_CHANGE:
            FIRE_POWER_EVENT(SENS_STRING("POWER STATUS CHANGED"), eType);

        case SENS_EVENT_LOGON:
            FIRE_WINLOGON_EVENT(SENS_STRING("LOGON"), eType);

        case SENS_EVENT_LOGOFF:
            FIRE_WINLOGON_EVENT(SENS_STRING("LOGOFF"), eType);

        case SENS_EVENT_STARTSHELL:
            FIRE_WINLOGON_EVENT(SENS_STRING("STARTSHELL"), eType);

        case SENS_EVENT_POSTSHELL:
            FIRE_WINLOGON_EVENT(SENS_STRING("POSTSHELL"), eType);

        case SENS_EVENT_SESSION_DISCONNECT:
            FIRE_WINLOGON_EVENT(SENS_STRING("SESSION DISCONNECT"), eType);

        case SENS_EVENT_SESSION_RECONNECT:
            FIRE_WINLOGON_EVENT(SENS_STRING("SESSION RECONNECT"), eType);

        case SENS_EVENT_STARTSCREENSAVER:
            FIRE_WINLOGON_EVENT(SENS_STRING("STARTSCREENSAVER"), eType);

        case SENS_EVENT_STOPSCREENSAVER:
            FIRE_WINLOGON_EVENT(SENS_STRING("STOPSCREENSAVER"), eType);

        case SENS_EVENT_LOCK:
            FIRE_WINLOGON_EVENT(SENS_STRING("DISPLAY LOCK"), eType);

        case SENS_EVENT_UNLOCK:
            FIRE_WINLOGON_EVENT(SENS_STRING("DISPLAY UNLOCK"), eType);

        case SENS_EVENT_RAS_STARTED:
            FIRE_RAS_EVENT(SENS_STRING("RAS STARTED"));

        case SENS_EVENT_RAS_STOPPED:
            FIRE_RAS_EVENT(SENS_STRING("RAS STOPPED"));

        case SENS_EVENT_RAS_CONNECT:
            FIRE_RAS_EVENT(SENS_STRING("RAS CONNECT"));

        case SENS_EVENT_RAS_DISCONNECT:
            FIRE_RAS_EVENT(SENS_STRING("RAS DISCONNECT"));

        case SENS_EVENT_RAS_DISCONNECT_PENDING:
            FIRE_RAS_EVENT(SENS_STRING("RAS DISCONNECT PENDING"));

        case SENS_EVENT_LAN_CONNECT:
            FIRE_LAN_EVENT(SENS_STRING("LAN CONNECT"));

        case SENS_EVENT_LAN_DISCONNECT:
            FIRE_LAN_EVENT(SENS_STRING("LAN DISCONNECT"));

        default:
            SensPrint(SENS_ERR, (SENS_STRING("\t|   A bogus event - %d !\n"), eType));
            hr = HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
        }

    //
    // Free the allocated Event data structure.
    //
    FreeEventData(EventData);

    return ((DWORD) hr);
}




PVOID
AllocateEventData(
    PVOID EventData
    )
/*++

Routine Description:

    Allocated the EventData depending on the type of the event.

Arguments:

    EventData - Data relating to the event.

Return Value:

    None.

--*/
{
    SENS_EVENT_TYPE eType;
    PVOID pReturnData;

    pReturnData = NULL;
    if (NULL == EventData)
        {
        goto Cleanup;
        }

    eType = *(SENS_EVENT_TYPE *)EventData;

    switch (eType)
        {
        case SENS_EVENT_NETALIVE:
            {
            ALLOCATE_BEGIN(SENSEVENT_NETALIVE);

            ALLOCATE_STRING_MEMBER(pData->strConnection, pTempData->strConnection);

            ALLOCATE_END();
            }

        case SENS_EVENT_REACH:
            {
            ALLOCATE_BEGIN(SENSEVENT_REACH);

            ALLOCATE_STRING_MEMBER(pData->Destination, pTempData->Destination);
            ALLOCATE_STRING_MEMBER(pData->strConnection, pTempData->strConnection);

            ALLOCATE_END();
            }

        case SENS_EVENT_PNP_DEVICE_ARRIVED:
        case SENS_EVENT_PNP_DEVICE_REMOVED:
            {
            ALLOCATE_BEGIN(SENSEVENT_PNP);

            ALLOCATE_END();
            }


        case SENS_EVENT_POWER_ON_ACPOWER:
        case SENS_EVENT_POWER_ON_BATTERYPOWER:
        case SENS_EVENT_POWER_BATTERY_LOW:
        case SENS_EVENT_POWER_STATUS_CHANGE:
            {
            ALLOCATE_BEGIN(SENSEVENT_POWER);

            ALLOCATE_END();
            }

        case SENS_EVENT_LOGON:
        case SENS_EVENT_LOGOFF:
        case SENS_EVENT_STARTSHELL:
        case SENS_EVENT_POSTSHELL:
        case SENS_EVENT_SESSION_DISCONNECT:
        case SENS_EVENT_SESSION_RECONNECT:
        case SENS_EVENT_STARTSCREENSAVER:
        case SENS_EVENT_STOPSCREENSAVER:
        case SENS_EVENT_LOCK:
        case SENS_EVENT_UNLOCK:
            {
            ALLOCATE_BEGIN(SENSEVENT_WINLOGON);

            ALLOCATE_STRING_MEMBER(pData->Info.UserName, pTempData->Info.UserName);
            ALLOCATE_STRING_MEMBER(pData->Info.Domain, pTempData->Info.Domain);
            ALLOCATE_STRING_MEMBER(pData->Info.WindowStation, pTempData->Info.WindowStation);

            ALLOCATE_END();
            }

        case SENS_EVENT_RAS_STARTED:
        case SENS_EVENT_RAS_STOPPED:
        case SENS_EVENT_RAS_CONNECT:
        case SENS_EVENT_RAS_DISCONNECT:
        case SENS_EVENT_RAS_DISCONNECT_PENDING:
            {
            ALLOCATE_BEGIN(SENSEVENT_RAS);

            ALLOCATE_END();
            }

        case SENS_EVENT_LAN_CONNECT:
        case SENS_EVENT_LAN_DISCONNECT:
             {
            ALLOCATE_BEGIN(SENSEVENT_LAN);

            ALLOCATE_STRING_MEMBER(pData->Name, pTempData->Name);

            ALLOCATE_END();
            }

        default:
            SensPrint(SENS_ERR, (SENS_STRING("\t|   A bogus event - %d !\n"), eType));
            break;
        }

Cleanup:
    //
    // Cleanup
    //
    return pReturnData;
}




void
FreeEventData(
    PVOID EventData
    )
/*++

Routine Description:

    Frees the EventData depending on the type of the event.

Arguments:

    EventData - Data relating to the event.

Return Value:

    None.

--*/
{
    SENS_EVENT_TYPE eType;

    if (NULL == EventData)
        {
        goto Cleanup;
        }
    eType = *(SENS_EVENT_TYPE *)EventData;

    switch (eType)
        {
        case SENS_EVENT_NETALIVE:
            {
            FREE_BEGIN(SENSEVENT_NETALIVE);

            FREE_STRING_MEMBER(pData->strConnection);

            FREE_END();
            }

        case SENS_EVENT_REACH:
            {
            FREE_BEGIN(SENSEVENT_REACH);

            FREE_STRING_MEMBER(pData->Destination);
            FREE_STRING_MEMBER(pData->strConnection);

            FREE_END();
            }

        case SENS_EVENT_PNP_DEVICE_ARRIVED:
        case SENS_EVENT_PNP_DEVICE_REMOVED:
            {
            FREE_BEGIN(SENSEVENT_PNP);

            FREE_END();
            }


        case SENS_EVENT_POWER_ON_ACPOWER:
        case SENS_EVENT_POWER_ON_BATTERYPOWER:
        case SENS_EVENT_POWER_BATTERY_LOW:
        case SENS_EVENT_POWER_STATUS_CHANGE:
            {
            FREE_BEGIN(SENSEVENT_POWER);

            FREE_END();
            }

        case SENS_EVENT_LOGON:
        case SENS_EVENT_LOGOFF:
        case SENS_EVENT_STARTSHELL:
        case SENS_EVENT_POSTSHELL:
        case SENS_EVENT_SESSION_DISCONNECT:
        case SENS_EVENT_SESSION_RECONNECT:
        case SENS_EVENT_STARTSCREENSAVER:
        case SENS_EVENT_STOPSCREENSAVER:
        case SENS_EVENT_LOCK:
        case SENS_EVENT_UNLOCK:
            {
            FREE_BEGIN(SENSEVENT_WINLOGON);

            FREE_STRING_MEMBER(pData->Info.UserName);
            FREE_STRING_MEMBER(pData->Info.Domain);
            FREE_STRING_MEMBER(pData->Info.WindowStation);

            FREE_END();
            }

        case SENS_EVENT_RAS_STARTED:
        case SENS_EVENT_RAS_STOPPED:
        case SENS_EVENT_RAS_CONNECT:
        case SENS_EVENT_RAS_DISCONNECT:
        case SENS_EVENT_RAS_DISCONNECT_PENDING:
            {
            FREE_BEGIN(SENSEVENT_RAS);

            FREE_END();
            }

        case SENS_EVENT_LAN_CONNECT:
        case SENS_EVENT_LAN_DISCONNECT:
            {
            FREE_BEGIN(SENSEVENT_LAN);

            FREE_STRING_MEMBER(pData->Name);

            FREE_END();
            }

        default:
            SensPrint(SENS_ERR, (SENS_STRING("\t|   A bogus structure to free - %d !\n"), eType));
            break;
        }

Cleanup:
    //
    // Cleanup
    //
    return;
}




HRESULT
SensFireNetEventHelper(
    PSENSEVENT_NETALIVE pData
    )
/*++

Routine Description:

    Helps fire the SENS Network Alive event.

Arguments:

    pData - Net alive event data.

Return Value:

    S_OK, if successful.

    Failure hr, otherwise.

--*/
{
    HRESULT hr;
    BSTR bstrConnectionName;
    BSTR bstrMethodName;
    ISensNetwork    *pISensNetwork;
    IEventControl   *pIEventControl;
    SENS_QOCINFO    SensQocInfo;
    CImpISensNetworkFilter NetEventsFilter; // Already AddRef'ed

    hr = S_OK;
    bstrConnectionName = NULL;
    bstrMethodName = NULL;
    pISensNetwork = NULL;
    pIEventControl = NULL;

    hr = CoCreateInstance(
             SENSGUID_EVENTCLASS_NETWORK,
             NULL,
             CLSCTX_SERVER,
             IID_ISensNetwork,
             (LPVOID *) &pISensNetwork
             );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get ISensNetwork object - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created ISensNetwork Object\n")));

    //
    // Setup Publisher filtering
    //
    hr = pISensNetwork->QueryInterface(
                            IID_IEventControl,
                            (LPVOID *) &pIEventControl
                            );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get IEventControl object - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created IEventControl Object\n")));

    //
    // Disallow inproc activation (we're local system, and we
    // don't like foreign components in our security context,
    // potentially crashing us).
    //
    pIEventControl->put_AllowInprocActivation(FALSE);

    AllocateBstrFromString(bstrConnectionName, pData->strConnection);

    if (pData->bAlive)
        {
        // Connect events
        AllocateBstrFromString(bstrMethodName, CONNECTION_MADE_NOQOC_METHOD);
        hr = NetEventsFilter.Initialize(bstrMethodName, pIEventControl);
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't initialize PublisherFilters for Net Connect Event - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }
        hr = pIEventControl->SetPublisherFilter(
                                 bstrMethodName,
                                 &NetEventsFilter
                                 );
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't set PublisherFilters for Net Connect Event - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }

        //
        // Fire the necessary ISensNetwork events
        //

        //
        // ConnectionMadeNoQOCInfo event
        //
        hr = pISensNetwork->ConnectionMadeNoQOCInfo(
                                bstrConnectionName,
                                pData->QocInfo.dwFlags
                                );
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire ConnectionMadeQOCInfo - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }
        SensPrint(SENS_INFO, (SENS_STRING("\t| ConnectionMadeNoQOCInfo() returned 0x%x\n"), hr));

        //
        // ConnectionMade event
        //
        FreeBstr(bstrMethodName);
        AllocateBstrFromString(bstrMethodName, CONNECTION_MADE_METHOD);
        hr = NetEventsFilter.Initialize(bstrMethodName, pIEventControl);
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| initialize't set PublisherFilters for NetEvent - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }
        hr = pIEventControl->SetPublisherFilter(
                                 bstrMethodName,
                                 &NetEventsFilter
                                 );
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't set PublisherFilters for NetEvent - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }

        memcpy(&SensQocInfo, &pData->QocInfo, sizeof(SENS_QOCINFO));
        hr = pISensNetwork->ConnectionMade(
                                bstrConnectionName,
                                pData->QocInfo.dwFlags,
                                &SensQocInfo
                                );
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire ConnectionMade - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }
        SensPrint(SENS_INFO, (SENS_STRING("\t| ConnectionMade() returned 0x%x\n"), hr));
        }
    else    // bAlive == FALSE
        {
        // Disconnect event
        AllocateBstrFromString(bstrMethodName, CONNECTION_LOST_METHOD);
        hr = NetEventsFilter.Initialize(bstrMethodName, pIEventControl);
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't initialize PublisherFilters for Net Disconnect Event - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }
        hr = pIEventControl->SetPublisherFilter(
                                 bstrMethodName,
                                 &NetEventsFilter
                                 );
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't set PublisherFilters for Net Disconnect Event - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }

        //
        // Fire the necessary ISensNetwork events
        //

        //
        // ConnectionMadeNoQOCInfo event
        //
        hr = pISensNetwork->ConnectionLost(
                                bstrConnectionName,
                                pData->QocInfo.dwFlags
                                );
        if (FAILED(hr))
            {
            SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire ConnectionLost - ")
                      SENS_STRING("hr = 0x%x\n"), hr));
            goto Cleanup;
            }
        SensPrint(SENS_INFO, (SENS_STRING("\t| ConnectionLost() returned 0x%x\n"), hr));
        }


Cleanup:
    //
    // Cleanup
    //
    if (pIEventControl)
        {
        pIEventControl->Release();
        }
    if (pISensNetwork)
        {
        pISensNetwork->Release();
        }

    FreeBstr(bstrMethodName);
    FreeBstr(bstrConnectionName);

    return hr;
}




HRESULT
SensFireReachabilityEventHelper(
    PSENSEVENT_REACH pData
    )
/*++

Routine Description:

    Helps fire the SENS Reachability event.

Arguments:

    pData - Reachability event Data.

Return Value:

    S_OK, if successful.

    Failure hr, otherwise.

--*/
{
    HRESULT hr;
    BSTR bstrConnectionName;
    BSTR bstrMethodName;
    BSTR bstrDestinationName;
    ISensNetwork    *pISensNetwork;
    IEventControl   *pIEventControl;
    SENS_QOCINFO    SensQocInfo;
    CImpISensNetworkFilter NetEventsFilter; // Already AddRef'ed

    hr = S_OK;
    bstrMethodName = NULL;
    bstrConnectionName = NULL;
    bstrDestinationName = NULL;
    pISensNetwork = NULL;
    pIEventControl = NULL;

    hr = CoCreateInstance(
             SENSGUID_EVENTCLASS_NETWORK,
             NULL,
             CLSCTX_SERVER,
             IID_ISensNetwork,
             (LPVOID *) &pISensNetwork
             );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get ISensNetwork object - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created ISensNetwork Object\n")));

    //
    // Setup Publisher filtering
    //
    hr = pISensNetwork->QueryInterface(
                            IID_IEventControl,
                            (LPVOID *) &pIEventControl
                            );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get IEventControl object - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created IEventControl Object\n")));

    //
    // Disallow inproc activation (we're local system, and we
    // don't like foreign components in our security context,
    // potentially crashing us).
    //
    pIEventControl->put_AllowInprocActivation(FALSE);

    AllocateBstrFromString(bstrMethodName, DESTINATION_REACHABLE_NOQOC_METHOD);
    hr = NetEventsFilter.Initialize(bstrMethodName, pIEventControl);
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| initialize't set PublisherFilters for ReachabilityEvent - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    hr = pIEventControl->SetPublisherFilter(
                             bstrMethodName,
                             &NetEventsFilter
                             );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't set PublisherFilters for ReachabilityEvent - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }

    //
    // Fire the Reachability events
    //
    AllocateBstrFromString(bstrConnectionName, pData->strConnection);
    AllocateBstrFromString(bstrDestinationName, pData->Destination);

    //
    // DestinationReachableNoQOCInfo event
    //
    hr = pISensNetwork->DestinationReachableNoQOCInfo(
                            bstrDestinationName,
                            bstrConnectionName,
                            pData->QocInfo.dwFlags
                            );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire DestinationReachableNoQOCInfo - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| DestinationReachableNoQOCInfo() returned 0x%x\n"), hr));

    //
    // DestinationReachable event
    //
    FreeBstr(bstrMethodName);
    AllocateBstrFromString(bstrMethodName, DESTINATION_REACHABLE_METHOD);
    hr = NetEventsFilter.Initialize(bstrMethodName, pIEventControl);
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| initialize't set PublisherFilters for ReachabilityEvent - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    hr = pIEventControl->SetPublisherFilter(
                             bstrMethodName,
                             &NetEventsFilter
                             );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't set PublisherFilters for ReachabilityEvent - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }

    memcpy(&SensQocInfo, &pData->QocInfo, sizeof(SENS_QOCINFO));
    hr = pISensNetwork->DestinationReachable(
                            bstrDestinationName,
                            bstrConnectionName,
                            pData->QocInfo.dwFlags,
                            &SensQocInfo
                            );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire DestinationReachable - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| DestinationReachable() returned 0x%x\n"), hr));



Cleanup:
    //
    // Cleanup
    //
    if (pIEventControl)
        {
        pIEventControl->Release();
        }
    if (pISensNetwork)
        {
        pISensNetwork->Release();
        }

    FreeBstr(bstrMethodName);
    FreeBstr(bstrConnectionName);
    FreeBstr(bstrDestinationName);

    return hr;
}




HRESULT
SensFireWinlogonEventHelper(
    LPWSTR strArg,
    DWORD dwSessionId,
    SENS_EVENT_TYPE eType
    )
/*++

Routine Description:

    Helps fire the SENS Winlogon event.

Arguments:

    strArg - DomainName\UserName

    dwSessionId - Session Id of the session on which this event was fired.

    eType - Type of Winlogon event.

Return Value:

    S_OK, if successful.

    Failure hr, otherwise.

--*/
{
    HRESULT hr;
    HRESULT hr2;
    BOOL bLogon2;
    BSTR bstrUserName;
    ISensLogon  *pISensLogon;
    ISensLogon2 *pISensLogon2;

    hr = S_OK;
    hr2 = S_OK;
    bstrUserName = NULL;
    pISensLogon = NULL;
    pISensLogon2 = NULL;

    //
    // Get the ISensLogon Object
    //
    hr = CoCreateInstance(
             SENSGUID_EVENTCLASS_LOGON,
             NULL,
             CLSCTX_SERVER,
             IID_ISensLogon,
             (LPVOID *) &pISensLogon
             );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get ISensLogon object - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created ISensLogon Object\n")));

    //
    // Get the ISensLogon2 Object
    //
    hr2 = CoCreateInstance(
             SENSGUID_EVENTCLASS_LOGON2,
             NULL,
             CLSCTX_SERVER,
             IID_ISensLogon2,
             (LPVOID *) &pISensLogon2
             );
    if (FAILED(hr2))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get ISensLogon2 object - ")
                  SENS_STRING("hr = 0x%x\n"), hr2));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created ISensLogon2 Object\n")));

    AllocateBstrFromString(bstrUserName, strArg);

    switch (eType)
        {
        case SENS_EVENT_LOGON:
            hr = pISensLogon->Logon(bstrUserName);
            hr2 = pISensLogon2->Logon(bstrUserName, dwSessionId);
            break;

        case SENS_EVENT_LOGOFF:
            hr = pISensLogon->Logoff(bstrUserName);
            hr2 = pISensLogon2->Logoff(bstrUserName, dwSessionId);
            break;

        case SENS_EVENT_STARTSHELL:
            hr = pISensLogon->StartShell(bstrUserName);
            break;

        case SENS_EVENT_POSTSHELL:
            hr2 = pISensLogon2->PostShell(bstrUserName, dwSessionId);
            break;

        case SENS_EVENT_SESSION_DISCONNECT:
            hr2 = pISensLogon2->SessionDisconnect(bstrUserName, dwSessionId);
            break;

        case SENS_EVENT_SESSION_RECONNECT:
            hr2 = pISensLogon2->SessionReconnect(bstrUserName, dwSessionId);
            break;

        case SENS_EVENT_LOCK:
            hr = pISensLogon->DisplayLock(bstrUserName);
            break;

        case SENS_EVENT_UNLOCK:
            hr = pISensLogon->DisplayUnlock(bstrUserName);
            break;

        case SENS_EVENT_STARTSCREENSAVER:
            hr = pISensLogon->StartScreenSaver(bstrUserName);
            break;

        case SENS_EVENT_STOPSCREENSAVER:
            hr = pISensLogon->StopScreenSaver(bstrUserName);
            break;

        default:
            SensPrint(SENS_WARN, (SENS_STRING("\t| Bad Winlogon Event - %d\n"), eType));
            break;
        }

    //
    // Check for failures
    //

    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire ISensLogon->WinlogonEvent - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        }
    else
        {
        SensPrint(SENS_INFO, (SENS_STRING("\t| ISensLogon->WinlogonEvent() returned 0x%x\n"), hr));
        }

    if (FAILED(hr2))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire ISensLogon2->WinlogonEvent(%d) - ")
                  SENS_STRING("hr = 0x%x\n"), dwSessionId, hr2));
        }
    else
        {
        SensPrint(SENS_INFO, (SENS_STRING("\t| ISensLogon2->WinlogonEvent(%d) returned 0x%x\n"), dwSessionId, hr));
        }


Cleanup:
    //
    // Cleanup
    //
    if (pISensLogon)
        {
        pISensLogon->Release();
        }

    if (pISensLogon2)
        {
        pISensLogon2->Release();
        }

    FreeBstr(bstrUserName);

    return hr;
}




HRESULT
SensFirePowerEventHelper(
    SYSTEM_POWER_STATUS PowerStatus,
    SENS_EVENT_TYPE eType
    )
/*++

Routine Description:

    Helps fire the SENS Power event.

Arguments:

    PowerStatus - Power Status event structure

    eType - Type of the Power event.

Return Value:

    S_OK, if successful.

    Failure hr, otherwise.

--*/
{
    HRESULT hr;
    ISensOnNow  *pISensOnNow;

    hr = S_OK;
    pISensOnNow = NULL;

    //
    // Get the ISensOnNow Object
    //
    hr = CoCreateInstance(
             SENSGUID_EVENTCLASS_ONNOW,
             NULL,
             CLSCTX_SERVER,
             IID_ISensOnNow,
             (LPVOID *) &pISensOnNow
             );
    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't get ISensOnNow object - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| Successfully created ISensOnNow Object\n")));

    switch (eType)
        {
        case SENS_EVENT_POWER_ON_ACPOWER:
            hr = pISensOnNow->OnACPower();
            break;

        case SENS_EVENT_POWER_ON_BATTERYPOWER:
            hr = pISensOnNow->OnBatteryPower(PowerStatus.BatteryLifePercent);
            break;

        case SENS_EVENT_POWER_BATTERY_LOW:
            hr = pISensOnNow->BatteryLow(PowerStatus.BatteryLifePercent);
            break;

        default:
            SensPrint(SENS_WARN, (SENS_STRING("\t| Bad Power Event - %d\n"), eType));
            break;
        }

    if (FAILED(hr))
        {
        SensPrint(SENS_ERR, (SENS_STRING("\t| Couldn't fire ISensOnNow->PowerEvent - ")
                  SENS_STRING("hr = 0x%x\n"), hr));
        //SensPrintToDebugger(SENS_DEB, ("\t| Couldn't fire ISensOnNow->PowerEvent - "
        //                    "hr = 0x%x\n", hr));
        goto Cleanup;
        }
    SensPrint(SENS_INFO, (SENS_STRING("\t| ISensOnNow->PowerEvent() returned 0x%x\n"), hr));
    //SensPrintToDebugger(SENS_DEB, ("\t| ISensOnNow->PowerEvent() returned 0x%x\n", hr));

Cleanup:
    //
    // Cleanup
    //
    if (pISensOnNow)
        {
        pISensOnNow->Release();
        }

    return hr;
}