//=--------------------------------------------------------------------------= // IPServer.Cpp //=--------------------------------------------------------------------------= // Copyright 1995-1996 Microsoft Corporation. All Rights Reserved. // // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A // PARTICULAR PURPOSE. //=--------------------------------------------------------------------------= // // implements all exported DLL functions for the program, as well as a few // others that will be used by same // #include "IPServer.H" #include "LocalSrv.H" #include "AutoObj.H" #include "ClassF.H" #include "CtrlObj.H" #include "Globals.H" #include "Unknown.H" #include "Util.H" //=--------------------------------------------------------------------------= // Private module level data // // for ASSERT and FAIL // SZTHISFILE //=--------------------------------------------------------------------------= // These are used for reflection in OLE Controls. Not that big of a hit that // we mind defining them for all servers, including automation or generic // COM. // char g_szReflectClassName [] = "CtlFrameWork_ReflectWindow"; BYTE g_fRegisteredReflect = FALSE; //=--------------------------------------------------------------------------= // allow controls to register for DLL_THREAD_ATTACH and DLL_THREAD_DETACH // THRDNFYPROC g_pfnThreadProc = NULL; extern "C" void SetLibraryThreadProc(THRDNFYPROC pfnThreadNotify) { if ((g_pfnThreadProc = pfnThreadNotify) == NULL) DisableThreadLibraryCalls((HMODULE)g_hInstance); } // ref count for LockServer // LONG g_cLocks; // private routines for this file. // int IndexOfOleObject(REFCLSID); HRESULT RegisterAllObjects(void); HRESULT UnregisterAllObjects(void); //=--------------------------------------------------------------------------= // DllMain //=--------------------------------------------------------------------------= // yon standard LibMain. // // Parameters and Output: // - see SDK Docs on DllMain // // Notes: // BOOL WINAPI DllMain ( HANDLE hInstance, DWORD dwReason, void *pvReserved ) { int i; switch (dwReason) { // set up some global variables, and get some OS/Version information // set up. // case DLL_PROCESS_ATTACH: { DWORD dwVer = GetVersion(); DWORD dwWinVer; // swap the two lowest bytes of dwVer so that the major and minor version // numbers are in a usable order. // for dwWinVer: high byte = major version, low byte = minor version // OS Sys_WinVersion (as of 5/2/95) // =-------------= =-------------= // Win95 0x035F (3.95) // WinNT ProgMan 0x0333 (3.51) // WinNT Win95 UI 0x0400 (4.00) // dwWinVer = (UINT)(((dwVer & 0xFF) << 8) | ((dwVer >> 8) & 0xFF)); g_fSysWinNT = FALSE; g_fSysWin95 = FALSE; g_fSysWin95Shell = FALSE; if (dwVer < 0x80000000) { g_fSysWinNT = TRUE; g_fSysWin95Shell = (dwWinVer >= 0x0334); } else { g_fSysWin95 = TRUE; g_fSysWin95Shell = TRUE; } // initialize a critical seciton for our apartment threading support // InitializeCriticalSection(&g_CriticalSection); // create an initial heap for everybody to use. // currently, we're going to let the system make things thread-safe, // which will make them a little slower, but hopefully not enough // to notice // g_hHeap = GetProcessHeap(); if (!g_hHeap) { FAIL("Couldn't get Process Heap. Not good!"); return FALSE; } g_hInstance = (HINSTANCE)hInstance; // give the user a chance to initialize whatever // InitializeLibrary(); // if they didn't ask for thread notifications then optimize by turning // them off for our DLL. // if (!g_pfnThreadProc) DisableThreadLibraryCalls((HMODULE)hInstance); } break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: if (g_pfnThreadProc) g_pfnThreadProc(hInstance, dwReason, pvReserved); break; // do a little cleaning up! // case DLL_PROCESS_DETACH: // clean up our critical seciton // DeleteCriticalSection(&g_CriticalSection); // unregister all the registered window classes. // i = 0; while (!ISEMPTYOBJECT(i)) { if (g_ObjectInfo[i].usType == OI_CONTROL) { if (CTLWNDCLASSREGISTERED(i)) UnregisterClass(WNDCLASSNAMEOFCONTROL(i), g_hInstance); } i++; } // clean up our parking window. // if (g_hwndParking) { DestroyWindow(g_hwndParking); UnregisterClass("CtlFrameWork_Parking", g_hInstance); --g_cLocks; } // clean up after reflection, if appropriate. // if (g_fRegisteredReflect) UnregisterClass(g_szReflectClassName, g_hInstance); // give the user a chance to do some cleaning up // UninitializeLibrary(); break; } return TRUE; } //=--------------------------------------------------------------------------= // DllRegisterServer //=--------------------------------------------------------------------------= // registers the Automation server // // Output: // HRESULT // // Notes: // STDAPI DllRegisterServer ( void ) { HRESULT hr; hr = RegisterAllObjects(); RETURN_ON_FAILURE(hr); // call user registration function. // return (RegisterData())? S_OK : E_FAIL; } //=--------------------------------------------------------------------------= // DllUnregisterServer //=--------------------------------------------------------------------------= // unregister's the Automation server // // Output: // HRESULT // // Notes: // STDAPI DllUnregisterServer ( void ) { HRESULT hr; hr = UnregisterAllObjects(); RETURN_ON_FAILURE(hr); // call user unregistration function // return (UnregisterData()) ? S_OK : E_FAIL; } //=--------------------------------------------------------------------------= // DllCanUnloadNow //=--------------------------------------------------------------------------= // we are being asked whether or not it's okay to unload the DLL. just check // the lock counts on remaining objects ... // // Output: // HRESULT - S_OK, can unload now, S_FALSE, can't. // // Notes: // STDAPI DllCanUnloadNow ( void ) { // if there are any objects lying around, then we can't unload. The // controlling CUnknownObject class that people should be inheriting from // takes care of this // return (g_cLocks) ? S_FALSE : S_OK; } //=--------------------------------------------------------------------------= // DllGetClassObject //=--------------------------------------------------------------------------= // creates a ClassFactory object, and returns it. // // Parameters: // REFCLSID - CLSID for the class object // REFIID - interface we want class object to be. // void ** - pointer to where we should ptr to new object. // // Output: // HRESULT - S_OK, CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, // E_INVALIDARG, E_UNEXPECTED // // Notes: // STDAPI DllGetClassObject ( REFCLSID rclsid, REFIID riid, void **ppvObjOut ) { HRESULT hr; void *pv; int iIndex; // arg checking // if (!ppvObjOut) return E_INVALIDARG; // first of all, make sure they're asking for something we work with. // iIndex = IndexOfOleObject(rclsid); if (iIndex == -1) return CLASS_E_CLASSNOTAVAILABLE; // create the blank object. // pv = (void *)new CClassFactory(iIndex); if (!pv) return E_OUTOFMEMORY; // QI for whatever the user has asked for. // hr = ((IUnknown *)pv)->QueryInterface(riid, ppvObjOut); ((IUnknown *)pv)->Release(); return hr; } //=--------------------------------------------------------------------------= // IndexOfOleObject //=--------------------------------------------------------------------------= // returns the index in our global table of objects of the given CLSID. if // it's not a supported object, then we return -1 // // Parameters: // REFCLSID - [in] duh. // // Output: // int - >= 0 is index into global table, -1 means not supported // // Notes: // int IndexOfOleObject ( REFCLSID rclsid ) { int x = 0; // an object is creatable if it's CLSID is in the table of all allowable object // types. // while (!ISEMPTYOBJECT(x)) { if (OBJECTISCREATABLE(x)) { if (rclsid == CLSIDOFOBJECT(x)) return x; } x++; } return -1; } //=--------------------------------------------------------------------------= // RegisterAllObjects //=--------------------------------------------------------------------------= // registers all the objects for the given automation server. // // Parameters: // none // // Output: // HERSULT - S_OK, E_FAIL // // Notes: // HRESULT RegisterAllObjects ( void ) { ITypeLib *pTypeLib; HRESULT hr; DWORD dwPathLen; char szTmp[MAX_PATH]; int x = 0; // loop through all of our creatable objects [those that have a clsid in // our global table] and register them. // while (!ISEMPTYOBJECT(x)) { if (!OBJECTISCREATABLE(x)) { x++; continue; } // depending on the object type, register different pieces of information // switch (g_ObjectInfo[x].usType) { // for both simple co-creatable objects and proeprty pages, do the same // thing // case OI_UNKNOWN: case OI_PROPERTYPAGE: RegisterUnknownObject(NAMEOFOBJECT(x), CLSIDOFOBJECT(x)); break; case OI_AUTOMATION: RegisterAutomationObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), *g_pLibid, CLSIDOFOBJECT(x)); break; case OI_CONTROL: RegisterControlObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), *g_pLibid, CLSIDOFOBJECT(x), OLEMISCFLAGSOFCONTROL(x), BITMAPIDOFCONTROL(x)); break; } x++; } // Load and register our type library. // if (g_fServerHasTypeLibrary) { dwPathLen = GetModuleFileName(g_hInstance, szTmp, MAX_PATH); MAKE_WIDEPTR_FROMANSI(pwsz, szTmp); hr = LoadTypeLib(pwsz, &pTypeLib); RETURN_ON_FAILURE(hr); hr = RegisterTypeLib(pTypeLib, pwsz, NULL); pTypeLib->Release(); RETURN_ON_FAILURE(hr); } return S_OK; } //=--------------------------------------------------------------------------= // UnregisterAllObjects //=--------------------------------------------------------------------------= // un-registers all the objects for the given automation server. // // Parameters: // none // // Output: // HRESULT - S_OK // // Notes: // HRESULT UnregisterAllObjects ( void ) { int x = 0; // loop through all of our creatable objects [those that have a clsid in // our global table] and register them. // while (!ISEMPTYOBJECT(x)) { if (!OBJECTISCREATABLE(x)) { x++; continue; } switch (g_ObjectInfo[x].usType) { case OI_UNKNOWN: case OI_PROPERTYPAGE: UnregisterUnknownObject(CLSIDOFOBJECT(x)); break; case OI_CONTROL: UnregisterControlObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), CLSIDOFOBJECT(x)); case OI_AUTOMATION: UnregisterAutomationObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), CLSIDOFOBJECT(x)); break; } x++; } // if we've got one, unregister our type library [this isn't an API function // -- we've implemented this ourselves] // if (g_pLibid) UnregisterTypeLibrary(*g_pLibid); return S_OK; }