1394main.c

winddk src目录下的WDM源码压缩!

/*++

Copyright (c) 1998  Microsoft Corporation

Module Name:

    1394main.c

Abstract


Author:

    Peter Binder (pbinder) 4/22/98

Revision History:
Date     Who       What
-------- --------- ------------------------------------------------------------
4/22/98  pbinder   moved from 1394api.c
--*/

#define _1394MAIN_C
#define INITGUID
#include "pch.h"
#undef _1394MAIN_C

//
// globals
//
ULONG TraceLevel = TL_FATAL;

//
//  LibMain32
//
BOOL
WINAPI
DllMain(
    HINSTANCE   hInstance,
    ULONG       ulReason,
    LPVOID      pvReserved
    )
{
    BOOL                    bReturn, bCreateProcess;
    DWORD                   dwError;

    TRACE(TL_TRACE, (NULL, "hInstance = 0x%x\r\n", hInstance));

    switch(ulReason) {

        case DLL_PROCESS_ATTACH:
            TRACE(TL_TRACE, (NULL, "DLLMain: DLL_PROCESS_ATTACH\r\n"));

            hData = CreateFileMapping( INVALID_HANDLE_VALUE,
                                       NULL,
                                       PAGE_READWRITE,
                                       0,
                                       sizeof(SHARED_DATA),
                                       "1394APISharedDataMap"
                                       );
            dwError = GetLastError();

            if (!hData) {

                TRACE(TL_ERROR, (NULL, "CreateFileMapping failed = 0x%x\r\n", dwError));
            }
            else {

                bCreateProcess = (dwError != ERROR_ALREADY_EXISTS);
                SharedData = (PSHARED_DATA) MapViewOfFile( hData,
                                                           FILE_MAP_ALL_ACCESS,
                                                           0,
                                                           0,
                                                           0
                                                           );

                if (!SharedData) {

                    dwError = GetLastError();
                    TRACE(TL_ERROR, (NULL, "Error mapping SharedData = 0x%x\r\n", dwError));
                }
                else {

                    TRACE(TL_TRACE, (NULL, "SharedData = 0x%x\r\n", SharedData));

                    if (bCreateProcess) {

                        CHAR    szCommandLine[] = "\"RUNDLL32.exe\" 1394API.DLL,DLL_Thread";

                        TRACE(TL_TRACE, (NULL, "Creating process...\r\n"));

                        // zero out memory...
                        ZeroMemory(SharedData, sizeof(SHARED_DATA));

                        SharedData->g_hInstance = (HANDLE)0x400000; //hInstance;

                        // right now, this isn't being used. in the future, we might want
                        // to use this to keep track of internal dll trace.
                        SharedData->g_hWndEdit = NULL;

                        bReturn = CreateProcess( NULL,
                                                 szCommandLine,
                                                 NULL,
                                                 NULL,
                                                 FALSE,
                                                 DETACHED_PROCESS,
                                                 NULL,
                                                 NULL,
                                                 &SharedData->StartUpInfo,
                                                 &SharedData->ProcessInfo
                                                 );

                        if (!bReturn) {

                            dwError = GetLastError();
                            TRACE(TL_ERROR, (NULL, "CreateProcess failed = 0x%x\r\n", dwError));
                        }
                    }

                    SharedData->nAttachedProcess++;
                }
            }


            break;

        case DLL_PROCESS_DETACH:
            TRACE(TL_TRACE, (NULL, "DLLMain: DLL_PROCESS_DETACH\r\n"));

            TRACE(TL_TRACE, (NULL, "nAttachedProcess = 0x%x\n", SharedData->nAttachedProcess));

            SharedData->nAttachedProcess--;

            // check for no more attached processes. we use one here
            // because our attached process counts as one.
            if (SharedData->nAttachedProcess == 1) {

                // need to close the handles to the created process and thread
                CloseHandle(SharedData->ProcessInfo.hProcess);
                CloseHandle(SharedData->ProcessInfo.hThread);

                SendMessage(SharedData->g_hWnd, WM_DESTROY, 0, 0);
            }

            UnmapViewOfFile( SharedData );
            CloseHandle( hData );
            break;

        case DLL_THREAD_ATTACH:
            TRACE(TL_TRACE, (NULL, "DLLMain: DLL_THREAD_ATTACH\r\n"));
            break;

        case DLL_THREAD_DETACH:
            TRACE(TL_TRACE, (NULL, "DLLMain: DLL_THREAD_DETACH\r\n"));
            break;

        default:
            TRACE(TL_TRACE, (NULL, "DLLMain: UNKNOWN ulReason recieved = 0x%x\r\n", ulReason));
            break;
    }

    return(TRUE);
}

LRESULT
CALLBACK
DLL_WndProc(
    HWND        hWnd,
    UINT        iMsg,
    WPARAM      wParam,
    LPARAM      lParam
    )
/*++

Routine Description:

    This is the application main WndProc. Here we will handle
    all messages sent to the application.

--*/
{
    switch(iMsg) {

        case WM_CREATE:
            TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: WM_CREATE\r\n"));

            // create an edit control for the main app.
            SharedData->g_hWndEdit = CreateWindow( "edit",
                                                   NULL,
                                                   WS_CHILD | WS_VISIBLE | WS_VSCROLL |
                                                   WS_BORDER | ES_LEFT | ES_MULTILINE |
                                                   ES_WANTRETURN | ES_AUTOHSCROLL | ES_AUTOVSCROLL |
                                                   ES_READONLY,
                                                   0,
                                                   0,
                                                   0,
                                                   0,
                                                   hWnd,
                                                   0,
                                                   SharedData->g_hInstance,
                                                   NULL
                                                   );

            // get the windows version
            InternalGetWinVersion(SharedData->g_hWndEdit);

            // get the device list
            InternalGetDeviceList(SharedData->g_hWndEdit);

            break; // WM_CREATE

        case WM_SIZE:
            MoveWindow(SharedData->g_hWndEdit, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
            break; // WM_SIZE

        case WM_DESTROY:
            TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: WM_DESTROY\r\n"));
            //StopBusResetThread(hWnd);
            PostQuitMessage(0);
            break; // WM_DESTROY

        case WM_DEVICECHANGE:
            TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: WM_DEVICECHANGE\r\n"));

            switch ((UINT)wParam) {
/*
                case DBT_DEVICEARRIVAL: {

                    PDEV_BROADCAST_HDR  devHdr;

                    devHdr = (PDEV_BROADCAST_HDR)lParam;

                    TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: DBT_DEVICEARRIVAL\r\n"));
                    TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: devHdr.dbch_devicetype = %d\r\n", devHdr->dbch_devicetype));

                    if (devHdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {

                        InternalGetDeviceList(SharedData->g_hWndEdit);
                        NotifyClients(SharedData->g_hWndEdit, NOTIFY_DEVICE_CHANGE);
                    }
                }
                break; // DBT_DEVICEARRIVAL

                case DBT_DEVICEREMOVECOMPLETE:
                    TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: DBT_DEVICEREMOVECOMPLETE\r\n"));

                    InternalGetDeviceList(SharedData->g_hWndEdit);
                    NotifyClients(SharedData->g_hWndEdit, NOTIFY_DEVICE_CHANGE);
                    break; // DBT_DEVICEREMOVECOMPLETE
*/
                case DBT_DEVNODES_CHANGED:
                    TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: DBT_DEVNODES_CHANGED\r\n"));

                    InternalGetDeviceList(SharedData->g_hWndEdit);
                    NotifyClients(SharedData->g_hWndEdit, NOTIFY_DEVICE_CHANGE);
                    break; // DBT_DEVNODES_CHANGED

            case VER_PLATFORM_WIN32_WINDOWS:
           
            case VER_PLATFORM_WIN32_NT:

                default:
                    break; // default
            }

            break; // WM_DEVICECHANGE

        case WM_REGISTER_CLIENT:
            TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: WM_REGISTER_CLIENT\r\n"));

            InternalRegisterClient((HWND)lParam);

            // update the device list
//            InternalGetDeviceList(SharedData->g_hWndEdit);

            // send them a notify message to grab the updated device list...
            SendMessage((HWND)lParam, NOTIFY_DEVICE_CHANGE, 0, 0);
            break; // WM_REGISTER_CLIENT

        case WM_DEREGISTER_CLIENT:
            TRACE(TL_TRACE, (SharedData->g_hWndEdit, "DLL_WndProc: WM_DEREGISTER_CLIENT\r\n"));

            InternalDeRegisterClient((HWND)lParam);

            break; // WM_DEREGISTER_CLIENT

        default:
            break;
    } // switch iMsg

    return DefWindowProc(hWnd, iMsg, wParam, lParam);
} // DLL_WndProc

DWORD
WINAPI
DLL_Thread(
    LPVOID      lpParameter
    )
{
    CHAR                            szAppClassName[] = "DLL_1394Class";
    CHAR                            szTitleBar[] = "1394API DLL";
    MSG                             Msg;
    WNDCLASSEX                      WndClassEx;
    DEV_BROADCAST_DEVICEINTERFACE   devBroadcastInterface;
    HANDLE                          hNotify;
    GUID                            t1394DiagGUID = GUID_1394DIAG;
    ATOM                            atom;

    TRACE(TL_TRACE, (NULL, "Enter DLLThread\r\n"));
    TRACE(TL_TRACE, (NULL, "SharedData->g_hInstance = 0x%x\r\n", SharedData->g_hInstance));

	// initialize our global data
	BusResetThreadParams = NULL;
	
    // main window app...
    WndClassEx.cbSize = sizeof(WNDCLASSEX);
    WndClassEx.style = CS_DBLCLKS | CS_BYTEALIGNWINDOW | CS_GLOBALCLASS;
    WndClassEx.lpfnWndProc = DLL_WndProc;
    WndClassEx.cbClsExtra = 0;
    WndClassEx.cbWndExtra = 0;
    WndClassEx.hInstance = SharedData->g_hInstance;
    WndClassEx.hIcon = NULL;
    WndClassEx.hIconSm = NULL;
    WndClassEx.hCursor = NULL;
    WndClassEx.hbrBackground = NULL;
    WndClassEx.lpszMenuName = "AppMenu";
    WndClassEx.lpszClassName = szAppClassName;

    atom = RegisterClassEx( &WndClassEx );

    if (atom == 0) {

        TRACE(TL_ERROR, (NULL, "RegisterClassEx Failed = %d\r\n", GetLastError()));
    }
    else {

        SharedData->g_hWnd = CreateWindowEx( WS_EX_WINDOWEDGE | WS_EX_ACCEPTFILES,
                                             szAppClassName,
                                             szTitleBar,
                                             WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                                             0, //CW_USEDEFAULT,
                                             0, //CW_USEDEFAULT,
                                             600, //CW_USEDEFAULT,
                                             200,
                                             NULL,
                                             NULL,
                                             SharedData->g_hInstance,
                                             NULL
                                             );

        if (SharedData->g_hWnd == NULL) {

            TRACE(TL_ERROR, (NULL, "Failed to create windows = 0x%x\r\n", GetLastError()));
        }
        else {

            devBroadcastInterface.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
            devBroadcastInterface.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
            devBroadcastInterface.dbcc_name[0] = 0;
            devBroadcastInterface.dbcc_classguid = t1394DiagGUID;

            hNotify = RegisterDeviceNotification( SharedData->g_hWnd,
                                                  &devBroadcastInterface,
                                                  DEVICE_NOTIFY_WINDOW_HANDLE
                                                  );

            if (!hNotify){

                TRACE(TL_ERROR, (SharedData->g_hWndEdit, "RegisterDeviceNotification Failed = 0x%x\r\n", GetLastError()));
            }

            while (GetMessage(&Msg, NULL, 0, 0)) {
                TranslateMessage(&Msg);
                DispatchMessage(&Msg);
            }

            UnregisterDeviceNotification(hNotify);
        }
    }

    TRACE(TL_TRACE, (SharedData->g_hWndEdit, "Exit DLLThread\r\n"));
    ExitProcess(0);
    return(0);
} // DLLThread

ULONG
InternalGetWinVersion(
    HWND    hWnd
    )
{
    OSVERSIONINFO   vi;
    ULONG           ulExitCode = 0;

    TRACE(TL_TRACE, (SharedData->g_hWndEdit, "CheckVersion\r\n"));

    vi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    
    if (GetVersionEx(&vi) == FALSE) {

        ulExitCode = GetLastError();
    }
    else {
    
        TRACE(TL_TRACE, (SharedData->g_hWndEdit, "dwPlatformId = %d\r\n", vi.dwPlatformId));

        SharedData->PlatformId = vi.dwPlatformId;
    }

    TRACE(TL_TRACE, (NULL, "CheckVersion = 0x%x\r\n", ulExitCode));
    return (ulExitCode);
}

DWORD
InternalFillDeviceList(
    HWND            hWnd,
    LPGUID          guid,
    PDEVICE_DATA    pDeviceData
    )
{
    HDEVINFO                            hDevInfo;
    SP_DEVICE_INTERFACE_DATA            deviceInterfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA    DeviceInterfaceDetailData;
    ULONG                               i = 0;
    ULONG                               requiredSize;
    ULONG                               dwError = 0;
    BOOL                                bReturn;

    //
    // get a handle to 1394 test class using guid.
    //