/*******************************************************************************
*
*  (C) COPYRIGHT MICROSOFT CORP., 1998
*
*  TITLE:       Main.Cpp
*
*  VERSION:     2.0
*
*  AUTHOR:      ReedB
*
*  DATE:        9 Jan, 1998
*
*  DESCRIPTION:
*
*   Implementation of WinMain for WIA device manager server device object.
*
*******************************************************************************/
#include "precomp.h"
#include "stiexe.h"

#include "wiamindr.h"

#include "wiacfact.h"
#include "devmgr.h"
#include "wialog.h"
#include "wiaevntp.h"

//
// Image transfer critical section.
//

CRITICAL_SECTION g_semDeviceMan;

//
// Critical section for event node, should only be used in event notifier
//

CRITICAL_SECTION g_semEventNode;

//
// data to initialize WiaDevMgr CLSID
//

FACTORY_DATA g_FactoryData[] =
{
    {CWiaDevMgr::CreateInstance,     // Object creator
     NULL,                           // Pointer to running class factory
     0,                              // ID for running object
     &CLSID_WiaDevMgr,               // Class ID
     &LIBID_WiaDevMgr,               // Type Library ID
     TEXT("WIA Device Manager"),    // Friendly Name
     TEXT("WiaDevMgr.1"),           // Program ID
     TEXT("WiaDevMgr"),             // Version-independent Program ID
     TEXT("StiSvc"),                // Service ID
     SERVICE_FILE_NAME}             // Filename
};

UINT g_uiFactoryDataCount = sizeof(g_FactoryData) / sizeof(FACTORY_DATA);

//
// data to initialize WiaLog CLSID
//

FACTORY_DATA g_LogFactoryData[] =
{
    {CWiaLog::CreateInstance,        // Object creator
     NULL,                           // Pointer to running class factory
     0,                              // ID for running object
     &CLSID_WiaLog,                  // Class ID
     &LIBID_WiaDevMgr,               // Type Library ID (Logging shares Type lib)
     TEXT("WIA Logger"),            // Friendly Name
     TEXT("WiaLog.1"),              // Program ID
     TEXT("WiaLog"),                // Version-independent Program ID
     TEXT("StiSvc"),                // Service ID (Logging uses same service)
     SERVICE_FILE_NAME}             // Filename (Logging uses same .exe)
};

UINT g_uiLogFactoryDataCount = sizeof(g_LogFactoryData) / sizeof(FACTORY_DATA);

//
// Private function proto's:
//

LRESULT CALLBACK WiaMainWndProc(HWND, UINT, UINT, LONG);


/**************************************************************************\
* ProcessWiaMsg
*
*   !!! minimal message server: is this needed
*
* Arguments:
*
*   hwnd   - window handle
*   uMsg   - message
*   wParam - param
*   lParam - param
*
* Return Value:
*
*    Status
*
* History:
*
*    4/8/1999 Original Version
*
\**************************************************************************/

HRESULT ProcessWiaMsg(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg) {
       case WM_CREATE:
          break;

       case WM_DESTROY:
          if (CFactory::CanUnloadNow() != S_OK) {

              //
              // Don't let STI process this message.
              //

              return S_OK;
          }
          break;

       case WM_CLOSE:
         break;

    }

    //
    // Let STI handle the message.
    //

    return S_FALSE;
}

#if 0

/**************************************************************************\
* DispatchWiaMsg
*
*   Handle Event messages
*
*
*   !!! WM_NOTIFY_WIA_VOLUME_EVENT is a temp hack and needs to be
*       added for real or removed
*
* Arguments:
*
*   pMsg    WM_NOTIFY_WIA_DEV_EVENT or WM_NOTIFY_WIA_VOLUME_EVENT
*
* Return Value:
*
*    Status
*
* History:
*
*    4/8/1999 Original Version
*
\**************************************************************************/

HRESULT DispatchWiaMsg(MSG *pMsg)
{
    DBG_FN(::DispatchWiaMsg);
    PWIANOTIFY pwn;

    if (pMsg->message == WM_NOTIFY_WIA_DEV_EVENT) {

        //
        // find out if this is a valid WIA event, call handler
        //

        DBG_ERR(("WIA Processing WM_NOTIFY_WIA_DEV_EVENT: shouldn't be called"));

        //
        // event are now directly fired, not posted
        //

        #if 0
            pwn = (PWIANOTIFY) pMsg->lParam;

            if (pwn && (pwn->lSize == sizeof(WIANOTIFY))) {

                if (g_eventNotifier.NotifySTIEvent(pwn) == S_FALSE) {
                    DBG_WRN(("::DispatchWiaMsg, No Applications were registered for this event"));
                }

                SysFreeString(pwn->bstrDevId);
                LocalFree(pwn);
            }
            else {
                DBG_ERR(("::DispatchWiaMsg, Bad WIA notify data"));
            }
        #endif

    } else if (pMsg->message == WM_NOTIFY_WIA_VOLUME_EVENT) {

        //
        // WIA volume arrival
        //

        DBG_TRC(("::DispatchWiaMsg, WIA Processing WM_NOTIFY_WIA_VOLUME_EVENT"));

        PWIANOTIFY_VOLUME pwn = (PWIANOTIFY_VOLUME) pMsg->lParam;

        if (pwn && (pwn->lSize == sizeof(WIANOTIFY_VOLUME))) {

            //
            // look at root fo volume for WIA File wia.cmd
            //

            int     i;
            char    c    = 'A';
            DWORD   mask = pwn->unitmask;

            //
            // find drive letter
            //

            if (mask & 0x07ffffff) {

                for (i=0;i<24;i++) {
                    if (mask & 0x00000001) {
                        break;
                    }

                    c++;
                    mask >>= 1;
                }

                //
                // build file name
                //

                char FileName[MAX_PATH];

                FileName[0]  = c;
                FileName[1]  = ':';
                FileName[2]  = '\\';
                FileName[3]  = 'w';
                FileName[4]  = 'i';
                FileName[5]  = 'a';
                FileName[6]  = '.';
                FileName[7]  = 'c';
                FileName[8]  = 'm';
                FileName[9]  = 'd';
                FileName[10] = '\0';

                //
                // open file
                //



                HANDLE hFile = CreateFileA(
                    FileName,
                    GENERIC_WRITE | GENERIC_READ  ,
                    FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_ATTRIBUTE_NORMAL,
                    NULL
                    );

                if (hFile != INVALID_HANDLE_VALUE) {

                    //
                    // file name is on volume root
                    //

                    if (g_eventNotifier.NotifyVolumeEvent(pwn) == S_FALSE) {
                        DBG_WRN(("::DispatchWiaMsg, No Applications were registered for this Volume event"));
                    }

                    CloseHandle(hFile);
                }
            }

            //
            // free message
            //

            LocalFree(pwn);
        }
        else {
            DBG_ERR(("::DispatchWiaMsg, Bad WIA notify data"));
        }
    }

    //
    // Let STI handle the message.
    //

    return S_FALSE;

}

#endif

/**************************************************************************\
* RegisterWiaDevMan
*
*   Register WiaDevMgr class factory
*
* Arguments:
*
*    bRegister - register/unregister
*
* Return Value:
*
*    Status
*
* History:
*
*    4/8/1999 Original Version
*
\**************************************************************************/

HRESULT RegisterWiaDevMan(BOOLEAN bRegister)
{
    HRESULT hr = CFactory::RegisterUnregisterAll(g_FactoryData,
                                                 g_uiFactoryDataCount,
                                                 bRegister,
                                                 TRUE);
    if(SUCCEEDED(hr)) {
        hr = CFactory::RegisterUnregisterAll(g_LogFactoryData,
                                         g_uiLogFactoryDataCount,
                                         bRegister,
                                         TRUE);
    }
    return hr;
}

/**************************************************************************\
* StartLOGClassFactories
*
*   Starts the Class factories for WIA logging object
*
* Arguments:
*
*   none
*
* Return Value:
*
*    Status
*
* History:
*
*    8/23/1999 Original Version
*
\**************************************************************************/
HRESULT StartLOGClassFactories()
{

#ifdef WINNT
    HRESULT hr = S_OK;

    //
    // Set COM security options.
    // NOTE:  Calling CoInitializeSecurity will override any DCOM 
    //  AccessPermissions that have been set (these are stored under
    //  our AppID key).  We really want to use these permissions and
    //  not a hardcoded security descriptor, so that if a vendor wanted
    //  to enable shared/remote scanning, all they need to do is adjust
    //  the DCOM AccessPermissions on the Wia Device Manager object.
    //  This can be done either through DCOM Config GUI, or programatically
    //  via the vendor's installation program.  (See our ClassFactory for
    //  an example of how to set the AccessPermissions.  When we are installed,
    //  we set default access permissions when doing our COM registration).
    // The way we get COM to use the DCOM AccessPermissions for the WIA 
    //  Device Manager, is we pass in the AppID (as a pointer to a GUID); and 
    //  the EOAC_APPID flag indicating that the first parameter is an AppID 
    //  rather than a security descriptor.  This informs COM that the 
    //  security descriptor should be taken from this objects AppID entry 
    //  in the registry.
    //

    hr =  CoInitializeSecurity((PVOID)&CLSID_WiaDevMgr,
                               -1,
                               NULL,
                               NULL,
                               RPC_C_AUTHN_LEVEL_CONNECT,
                               RPC_C_IMP_LEVEL_IMPERSONATE,
                               NULL,
                               EOAC_DYNAMIC_CLOAKING | EOAC_APPID,
                               NULL);
    if (FAILED(hr)) {

        DBG_ERR(("StartLOGClassFactories() CoInitializeSecurity failed, hr = 0x%08X", hr));

        ::CoUninitialize();
    }
#endif

    if (CFactory::StartFactories(g_LogFactoryData, g_uiLogFactoryDataCount))
        return S_OK;
    else
        return E_FAIL;
}

/**************************************************************************\
* InitWiaDevMan
*
*   Wia Initialization called from STI
*
* Arguments:
*
*   action - Action to be taken
*
* Return Value:
*
*    Status
*
* History:
*
*    4/8/1999 Original Version
*
\**************************************************************************/

HRESULT InitWiaDevMan(
    WIA_SERVICE_INIT_ACTION         action)
{

    DBG_FN("InitWiaDevMan");

    HRESULT             hr = E_FAIL;

    switch (action) {
        case WiaInitialize:

            //
            // Get Thread ID and process handle for the class factory.
            //

            CFactory::s_dwThreadID  = GetCurrentThreadId();
            CFactory::s_hModule     = g_hInst;

        /*
        //
        // This was moved to StartLOGClassFactories(), because of COM security's need
        // to be initialized before an object can be CoCreated correctly.
        // (investigate better way to do this..)
        //

        #ifdef WINNT

            //
            // Set COM security options. For now we set no security.
            // We will need to investigate this before shipping.
            //


            hr =  CoInitializeSecurity(NULL,
                                       -1,
                                       NULL,
                                       NULL,
                                       RPC_C_AUTHN_LEVEL_CONNECT,
                                       RPC_C_IMP_LEVEL_IMPERSONATE,
                                       NULL,
                                       0,
                                       NULL);
            if (FAILED(hr)) {

                DBG_ERR(("CoInitializeSecurity failed  (0x%X)", hr));

                ::CoUninitialize();

                break;
            }

        #endif
         */
            //
            // Register all of the class factories.
            //

            if (CFactory::StartFactories(g_FactoryData, g_uiFactoryDataCount)) {

                //
                // Restore persistent Event Callbacks
                //

                hr = g_eventNotifier.RestoreAllPersistentCBs();
            }

            hr = E_FAIL;
            break;

        case WiaUninitialize:

            //
            // Unregister the class factories.
            //

            CFactory::StopFactories(g_FactoryData, g_uiFactoryDataCount);
            CFactory::StopFactories(g_LogFactoryData, g_uiLogFactoryDataCount);

            hr = S_OK;
            break;

        case WiaRegister:
            hr = RegisterWiaDevMan(TRUE);
            break;

        case WiaUnregister:
            hr = RegisterWiaDevMan(FALSE);
            break;
    }
    return hr;
}

/**************************************************************************\
* NotifyWiaDeviceEvent
*
*    Called by STI service when WIA needs an async notification.
*
* Arguments:
*
*    pwszDevID   - ID of device generating event
*    pEventGUID  - event GUID
*    dwThreadId  - thread event msg needs to be posted to
*
* Return Value:
*
*    Status
*
* History:
*
*    4/8/1999 Original Version
*
\**************************************************************************/

HRESULT NotifyWiaDeviceEvent(
    LPWSTR      pwszDevID,
    const GUID  *pEventGUID,
    PBYTE       pNotificationData,
    ULONG       ulEventType,
    DWORD       dwThreadId)
{
    DBG_FN(NotifyWiaDeviceEvent);

    HRESULT     hr;
    BSTR        bstrDevId;
    WIANOTIFY   wn;

    DBG_TRC(("NotifyWiaDeviceEvent, pwszDevID= %S", pwszDevID));
    bstrDevId = SysAllocString(pwszDevID);

    if (bstrDevId != NULL) {

        wn.lSize                          = sizeof(WIANOTIFY);
        wn.bstrDevId                      = bstrDevId;
        wn.stiNotify.dwSize               = sizeof(STINOTIFY);
        wn.stiNotify.guidNotificationCode = *pEventGUID;

        if (! pNotificationData) {
            ZeroMemory(&wn.stiNotify.abNotificationData, MAX_NOTIFICATION_DATA);
        } else {
            CopyMemory(
                &wn.stiNotify.abNotificationData,
                pNotificationData,
                MAX_NOTIFICATION_DATA);
        }

        g_eventNotifier.NotifySTIEvent(&wn, ulEventType, NULL);

        //
        // We should return S_TRUE for events that we want STI to
        // handle also.
        //

        SysFreeString(bstrDevId);

        hr = S_FALSE;
    } else {
        hr = E_OUTOFMEMORY;
    }

    return hr;
}

/**************************************************************************\
* NotifyWiaVolumeEvent
*
*   Called by STI service when a removable volume arrives
*
* Arguments:
*
*    dbcv_unitmask - volume information flags
*    dwThreadId    - msg thread
*
* Return Value:
*
*    Status
*
* History:
*
*    4/8/1999 Original Version
*
\**************************************************************************/

HRESULT WINAPI NotifyWiaVolumeEvent(
    DWORD       dbcv_unitmask,
    DWORD       dwThreadId)
{
    PWIANOTIFY_VOLUME  pwn;

    //
    // Validate the thread ID.
    //

    if (!dwThreadId) {
        return E_FAIL;
    }

    //
    // Allocate and fill in WIANOTIFY structure for msg post.
    //

    pwn = (PWIANOTIFY_VOLUME)LocalAlloc(LPTR, sizeof(WIANOTIFY_VOLUME));

    if (pwn) {

        pwn->lSize    = sizeof(WIANOTIFY_VOLUME);
        pwn->unitmask = dbcv_unitmask;

        PostThreadMessage(dwThreadId,
                          WM_NOTIFY_WIA_VOLUME_EVENT,
                          0,
                          (LPARAM)pwn);
    } else {

        return E_OUTOFMEMORY;
    }

    //
    // We should return S_TRUE for events that we want STI to
    // handle also.
    //

    return S_FALSE;
}