embedserv/source/inprocserv/dllentry.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "sal/types.h"
  21
  22 #include <stdio.h>
  23 #include <inprocembobj.h>
  24 #ifdef __MINGW32__
  25 #define INITGUID
  26 #define INPROC_DLLPUBLIC SAL_DLLPUBLIC_EXPORT
  27 #else
  28 #define INPROC_DLLPUBLIC
  29 #endif
  30 #include <embservconst.h>
  31
  32 static const GUID* guidList[ SUPPORTED_FACTORIES_NUM ] = {
  33     &OID_WriterTextServer,
  34     &OID_WriterOASISTextServer,
  35     &OID_CalcServer,
  36     &OID_CalcOASISServer,
  37     &OID_DrawingServer,
  38     &OID_DrawingOASISServer,
  39     &OID_PresentationServer,
  40     &OID_PresentationOASISServer,
  41     &OID_MathServer,
  42     &OID_MathOASISServer
  43 };
  44
  45 static HINSTANCE g_hInstance = NULL;
  46 static ULONG g_nObj = 0;
  47 static ULONG g_nLock = 0;
  48
  49
  50 namespace {
  51     void FillCharFromInt( int nValue, char* pBuf, int nLen )
  52     {
  53         int nInd = 0;
  54         while( nInd < nLen )
  55         {
  56             char nSign = ( nValue / ( 1 << ( ( nLen - nInd - 1 ) * 4 ) ) ) % 16;
  57             if ( nSign >= 0 && nSign <= 9 )
  58                 pBuf[nInd] = nSign + '0';
  59             else if ( nSign >= 10 && nSign <= 15 )
  60                 pBuf[nInd] = nSign - 10 + 'a';
  61
  62             nInd++;
  63         }
  64     }
  65
  66     int GetStringFromClassID( const GUID& guid, char* pBuf, int nLen )
  67     {
  68         // is not allowed to insert
  69         if ( nLen < 38 )
  70             return 0;
  71
  72         pBuf[0] = '{';
  73         FillCharFromInt( guid.Data1, &pBuf[1], 8 );
  74         pBuf[9] = '-';
  75         FillCharFromInt( guid.Data2, &pBuf[10], 4 );
  76         pBuf[14] = '-';
  77         FillCharFromInt( guid.Data3, &pBuf[15], 4 );
  78         pBuf[19] = '-';
  79
  80         int nInd = 0;
  81         for ( nInd = 0; nInd < 2 ; nInd++ )
  82             FillCharFromInt( guid.Data4[nInd], &pBuf[20 + 2*nInd], 2 );
  83         pBuf[24] = '-';
  84         for ( nInd = 2; nInd < 8 ; nInd++ )
  85             FillCharFromInt( guid.Data4[nInd], &pBuf[20 + 1 + 2*nInd], 2 );
  86         pBuf[37] = '}';
  87
  88         return 38;
  89     }
  90
  91     HRESULT WriteLibraryToRegistry( const char* pLibrary, DWORD nLen )
  92     {
  93         HRESULT hRes = E_FAIL;
  94         if ( pLibrary && nLen )
  95         {
  96             HKEY hKey = NULL;
  97
  98             hRes = S_OK;
  99             for ( int nInd = 0; nInd < SUPPORTED_FACTORIES_NUM; nInd++ )
 100             {
 101                 const char pSubKeyTemplate[] = "Software\\Classes\\CLSID\\.....................................\\InprocHandler32";
 102                 char pSubKey[SAL_N_ELEMENTS(pSubKeyTemplate)];
 103                 strncpy(pSubKey, pSubKeyTemplate, SAL_N_ELEMENTS(pSubKeyTemplate));
 104
 105                 int nGuidLen = GetStringFromClassID( *guidList[nInd], &pSubKey[23], 38 );
 106
 107                 BOOL bLocalSuccess = FALSE;
 108                 if ( nGuidLen && nGuidLen == 38 )
 109                 {
 110                     if ( ERROR_SUCCESS == RegOpenKey( HKEY_LOCAL_MACHINE, pSubKey, &hKey ) )
 111                     {
 112                         if ( ERROR_SUCCESS == RegSetValueEx( hKey, "", 0, REG_SZ, (const BYTE*)pLibrary, nLen ) )
 113                             bLocalSuccess = TRUE;
 114                     }
 115
 116                     if ( hKey )
 117                     {
 118                         RegCloseKey( hKey );
 119                         hKey = NULL;
 120                     }
 121                 }
 122
 123                 if ( !bLocalSuccess )
 124                     hRes = E_FAIL;
 125             }
 126         }
 127
 128         return hRes;
 129     }
 130 };
 131
 132
 133 // InprocEmbedProvider_Impl declaration
 134
 135
 136 namespace inprocserv
 137 {
 138
 139 class InprocEmbedProvider_Impl : public IClassFactory, public InprocCountedObject_Impl
 140 {
 141 public:
 142
 143     InprocEmbedProvider_Impl( const GUID& guid );
 144     virtual ~InprocEmbedProvider_Impl();
 145
 146     /* IUnknown methods */
 147     STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppvObj);
 148     STDMETHOD_(ULONG, AddRef)();
 149     STDMETHOD_(ULONG, Release)();
 150
 151     /* IClassFactory methods */
 152     STDMETHOD(CreateInstance)(IUnknown FAR* punkOuter, REFIID riid, void FAR* FAR* ppv);
 153     STDMETHOD(LockServer)(int fLock);
 154
 155 protected:
 156
 157     ULONG               m_refCount;
 158     GUID                m_guid;
 159 };
 160 }; // namespace inprocserv
 161
 162
 163
 164 // Entry points
 165
 166
 167
 168 extern "C" INPROC_DLLPUBLIC BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/ )
 169 {
 170     if (dwReason == DLL_PROCESS_ATTACH)
 171     {
 172         g_hInstance = hInstance;
 173     }
 174     else if (dwReason == DLL_PROCESS_DETACH)
 175     {
 176     }
 177
 178     return TRUE;    // ok
 179 }
 180
 181
 182 extern "C" STDAPI INPROC_DLLPUBLIC DllGetClassObject( REFCLSID rclsid, REFIID riid, LPVOID* ppv )
 183 {
 184     for( int nInd = 0; nInd < SUPPORTED_FACTORIES_NUM; nInd++ )
 185          if ( *guidList[nInd] == rclsid )
 186          {
 187             if ( !IsEqualIID( riid, IID_IUnknown ) && !IsEqualIID( riid, IID_IClassFactory ) )
 188                 return E_NOINTERFACE;
 189
 190             *ppv = new inprocserv::InprocEmbedProvider_Impl( rclsid );
 191             ((LPUNKNOWN)*ppv)->AddRef();
 192             return S_OK;
 193          }
 194
 195     return E_FAIL;
 196 }
 197
 198
 199 extern "C" STDAPI INPROC_DLLPUBLIC DllCanUnloadNow()
 200 {
 201     if ( !g_nObj && !g_nLock )
 202         return S_OK;
 203
 204     return S_FALSE;
 205 }
 206
 207
 208 STDAPI INPROC_DLLPUBLIC DllRegisterServer()
 209 {
 210     HMODULE aCurModule = GetModuleHandleA( "inprocserv.dll" );
 211     if( aCurModule )
 212     {
 213         char aLibPath[1024];
 214         DWORD nLen = GetModuleFileNameA( aCurModule, aLibPath, 1019 );
 215         if ( nLen && nLen < 1019 )
 216         {
 217             aLibPath[nLen++] = 0;
 218             return WriteLibraryToRegistry( aLibPath, nLen );
 219         }
 220     }
 221
 222     return E_FAIL;
 223 }
 224
 225
 226 STDAPI INPROC_DLLPUBLIC DllUnregisterServer()
 227 {
 228     return WriteLibraryToRegistry( "ole32.dll", 10 );
 229 }
 230
 231
 232 // End of entry points
 233
 234
 235 namespace inprocserv
 236 {
 237
 238
 239 // InprocCountedObject_Impl implementation
 240
 241
 242
 243 InprocCountedObject_Impl::InprocCountedObject_Impl()
 244 {
 245     g_nObj++;
 246 }
 247
 248
 249 InprocCountedObject_Impl::~InprocCountedObject_Impl()
 250 {
 251     g_nObj--;
 252 }
 253
 254
 255 // InprocEmbedProvider_Impl implementation
 256
 257
 258
 259 InprocEmbedProvider_Impl::InprocEmbedProvider_Impl( const GUID& guid )
 260 : m_refCount( 0 )
 261 , m_guid( guid )
 262 {
 263 }
 264
 265
 266 InprocEmbedProvider_Impl::~InprocEmbedProvider_Impl()
 267 {
 268 }
 269
 270 // IUnknown
 271
 272 STDMETHODIMP InprocEmbedProvider_Impl::QueryInterface( REFIID riid, void FAR* FAR* ppv )
 273 {
 274     if(IsEqualIID(riid, IID_IUnknown))
 275     {
 276         AddRef();
 277         *ppv = (IUnknown*) this;
 278         return S_OK;
 279     }
 280     else if (IsEqualIID(riid, IID_IClassFactory))
 281     {
 282         AddRef();
 283         *ppv = (IClassFactory*) this;
 284         return S_OK;
 285     }
 286
 287     *ppv = NULL;
 288     return E_NOINTERFACE;
 289 }
 290
 291
 292 STDMETHODIMP_(ULONG) InprocEmbedProvider_Impl::AddRef()
 293 {
 294     return ++m_refCount;
 295 }
 296
 297
 298 STDMETHODIMP_(ULONG) InprocEmbedProvider_Impl::Release()
 299 {
 300     sal_Int32 nCount = --m_refCount;
 301     if ( nCount == 0 )
 302         delete this;
 303     return nCount;
 304 }
 305
 306
 307 STDMETHODIMP InprocEmbedProvider_Impl::CreateInstance(IUnknown FAR* punkOuter,
 308                                                        REFIID riid,
 309                                                        void FAR* FAR* ppv)
 310 {
 311     // TODO/LATER: should the aggregation be supported?
 312     // if ( punkOuter != NULL && riid != IID_IUnknown )
 313     //     return E_NOINTERFACE;
 314     if ( punkOuter != NULL )
 315         return CLASS_E_NOAGGREGATION;
 316
 317     InprocEmbedDocument_Impl* pEmbedDocument = new InprocEmbedDocument_Impl( m_guid );
 318     pEmbedDocument->AddRef();
 319     HRESULT hr = pEmbedDocument->Init();
 320     if ( SUCCEEDED( hr ) )
 321         hr = pEmbedDocument->QueryInterface( riid, ppv );
 322     pEmbedDocument->Release();
 323
 324     if ( !SUCCEEDED( hr ) )
 325         *ppv = NULL;
 326
 327     return hr;
 328 }
 329
 330
 331 STDMETHODIMP InprocEmbedProvider_Impl::LockServer( int fLock )
 332 {
 333     if ( fLock )
 334         g_nLock++;
 335     else
 336         g_nLock--;
 337
 338     return S_OK;
 339 }
 340
 341 }; // namespace inprocserv
 342
 343 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */