dlls/msident/msident.c

   1 /*
   2  * Copyright 2012 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include "windows.h"
  22 #include "initguid.h"
  23 #include "msident.h"
  24 #include "rpcproxy.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/heap.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(msident);
  30
  31 static HINSTANCE msident_instance;
  32
  33 typedef struct {
  34     IEnumUserIdentity IEnumUserIdentity_iface;
  35     LONG ref;
  36 } EnumUserIdentity;
  37
  38 static inline EnumUserIdentity *impl_from_IEnumUserIdentity(IEnumUserIdentity *iface)
  39 {
  40     return CONTAINING_RECORD(iface, EnumUserIdentity, IEnumUserIdentity_iface);
  41 }
  42
  43 static HRESULT WINAPI EnumUserIdentity_QueryInterface(IEnumUserIdentity *iface, REFIID riid, void **ppv)
  44 {
  45     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  46
  47     if(IsEqualGUID(&IID_IUnknown, riid)) {
  48         TRACE("(IID_IUnknown %p)\n", ppv);
  49         *ppv = &This->IEnumUserIdentity_iface;
  50     }else if(IsEqualGUID(&IID_IEnumUserIdentity, riid)) {
  51         TRACE("(IID_IEnumUserIdentity %p)\n", ppv);
  52         *ppv = &This->IEnumUserIdentity_iface;
  53     }else {
  54         WARN("(%s %p)\n", debugstr_guid(riid), ppv);
  55         *ppv = NULL;
  56         return E_NOINTERFACE;
  57     }
  58
  59     IUnknown_AddRef((IUnknown*)*ppv);
  60     return S_OK;
  61 }
  62
  63 static ULONG WINAPI EnumUserIdentity_AddRef(IEnumUserIdentity *iface)
  64 {
  65     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  66     LONG ref = InterlockedIncrement(&This->ref);
  67
  68     TRACE("(%p) ref=%d\n", This, ref);
  69
  70     return ref;
  71 }
  72
  73 static ULONG WINAPI EnumUserIdentity_Release(IEnumUserIdentity *iface)
  74 {
  75     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  76     LONG ref = InterlockedDecrement(&This->ref);
  77
  78     TRACE("(%p) ref=%d\n", This, ref);
  79
  80     if(!ref)
  81         heap_free(This);
  82
  83     return ref;
  84 }
  85
  86 static HRESULT WINAPI EnumUserIdentity_Next(IEnumUserIdentity *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
  87 {
  88     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  89     FIXME("(%p)->(%u %p %p)\n", This, celt, rgelt, pceltFetched);
  90     return E_NOTIMPL;
  91 }
  92
  93 static HRESULT WINAPI EnumUserIdentity_Skip(IEnumUserIdentity *iface, ULONG celt)
  94 {
  95     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  96     FIXME("(%p)->(%u)\n", This, celt);
  97     return E_NOTIMPL;
  98 }
  99
 100 static HRESULT WINAPI EnumUserIdentity_Reset(IEnumUserIdentity *iface)
 101 {
 102     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
 103     FIXME("(%p)->()\n", This);
 104     return E_NOTIMPL;
 105 }
 106
 107 static HRESULT WINAPI EnumUserIdentity_Clone(IEnumUserIdentity *iface, IEnumUserIdentity **ppenum)
 108 {
 109     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
 110     FIXME("(%p)->(%p)\n", This, ppenum);
 111     return E_NOTIMPL;
 112 }
 113
 114 static HRESULT WINAPI EnumUserIdentity_GetCount(IEnumUserIdentity *iface, ULONG *pnCount)
 115 {
 116     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
 117
 118     FIXME("(%p)->(%p)\n", This, pnCount);
 119
 120     *pnCount = 0;
 121     return S_OK;
 122 }
 123
 124 static const IEnumUserIdentityVtbl EnumUserIdentityVtbl = {
 125     EnumUserIdentity_QueryInterface,
 126     EnumUserIdentity_AddRef,
 127     EnumUserIdentity_Release,
 128     EnumUserIdentity_Next,
 129     EnumUserIdentity_Skip,
 130     EnumUserIdentity_Reset,
 131     EnumUserIdentity_Clone,
 132     EnumUserIdentity_GetCount
 133 };
 134
 135 static HRESULT WINAPI UserIdentityManager_QueryInterface(IUserIdentityManager *iface, REFIID riid, void **ppv)
 136 {
 137     if(IsEqualGUID(&IID_IUnknown, riid)) {
 138         TRACE("(IID_IUnknown %p)\n", ppv);
 139         *ppv = iface;
 140     }else if(IsEqualGUID(&IID_IUserIdentityManager, riid)) {
 141         TRACE("(IID_IUserIdentityManager %p)\n", ppv);
 142         *ppv = iface;
 143     }else {
 144         WARN("(%s %p)\n", debugstr_guid(riid), ppv);
 145         *ppv = NULL;
 146         return E_NOINTERFACE;
 147     }
 148
 149     IUnknown_AddRef((IUnknown*)*ppv);
 150     return S_OK;
 151 }
 152
 153 static ULONG WINAPI UserIdentityManager_AddRef(IUserIdentityManager *iface)
 154 {
 155     TRACE("\n");
 156     return 2;
 157 }
 158
 159 static ULONG WINAPI UserIdentityManager_Release(IUserIdentityManager *iface)
 160 {
 161     TRACE("\n");
 162     return 1;
 163 }
 164
 165 static HRESULT WINAPI UserIdentityManager_EnumIdentities(IUserIdentityManager *iface, IEnumUserIdentity **ppEnumUser)
 166 {
 167     EnumUserIdentity *ret;
 168
 169     TRACE("(%p)\n", ppEnumUser);
 170
 171     ret = heap_alloc(sizeof(*ret));
 172     if(!ret)
 173         return E_OUTOFMEMORY;
 174
 175     ret->IEnumUserIdentity_iface.lpVtbl = &EnumUserIdentityVtbl;
 176     ret->ref = 1;
 177
 178     *ppEnumUser = &ret->IEnumUserIdentity_iface;
 179     return S_OK;
 180 }
 181
 182 static HRESULT WINAPI UserIdentityManager_ManageIdentities(IUserIdentityManager *iface, HWND hwndParent, DWORD dwFlags)
 183 {
 184     FIXME("(%p %x)\n", hwndParent, dwFlags);
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI UserIdentityManager_Logon(IUserIdentityManager *iface, HWND hwndParent,
 189         DWORD dwFlags, IUserIdentity **ppIdentity)
 190 {
 191     FIXME("(%p %x %p)\n", hwndParent, dwFlags, ppIdentity);
 192     return E_USER_CANCELLED;
 193 }
 194
 195 static HRESULT WINAPI UserIdentityManager_Logoff(IUserIdentityManager *iface, HWND hwndParent)
 196 {
 197     FIXME("(%p)\n", hwndParent);
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI UserIdentityManager_GetIdentityByCookie(IUserIdentityManager *iface, GUID *uidCookie,
 202         IUserIdentity **ppIdentity)
 203 {
 204     FIXME("(%p %p)\n", uidCookie, ppIdentity);
 205     return E_NOTIMPL;
 206 }
 207
 208 static const IUserIdentityManagerVtbl UserIdentityManagerVtbl = {
 209     UserIdentityManager_QueryInterface,
 210     UserIdentityManager_AddRef,
 211     UserIdentityManager_Release,
 212     UserIdentityManager_EnumIdentities,
 213     UserIdentityManager_ManageIdentities,
 214     UserIdentityManager_Logon,
 215     UserIdentityManager_Logoff,
 216     UserIdentityManager_GetIdentityByCookie
 217 };
 218
 219 static IUserIdentityManager UserIdentityManager = { &UserIdentityManagerVtbl };
 220
 221 static HRESULT WINAPI UserIdentityManager_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 222 {
 223     TRACE("\n");
 224
 225     return IUserIdentityManager_QueryInterface(&UserIdentityManager, riid, ppv);
 226 }
 227
 228 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 229 {
 230     *ppv = NULL;
 231
 232     if(IsEqualGUID(&IID_IUnknown, riid)) {
 233         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 234         *ppv = iface;
 235     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
 236         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
 237         *ppv = iface;
 238     }
 239
 240     if(*ppv) {
 241         IUnknown_AddRef((IUnknown*)*ppv);
 242         return S_OK;
 243     }
 244
 245     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 246     return E_NOINTERFACE;
 247 }
 248
 249 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 250 {
 251     TRACE("(%p)\n", iface);
 252     return 2;
 253 }
 254
 255 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 256 {
 257     TRACE("(%p)\n", iface);
 258     return 1;
 259 }
 260
 261 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 262 {
 263     TRACE("(%p)->(%x)\n", iface, fLock);
 264     return S_OK;
 265 }
 266
 267 static const IClassFactoryVtbl UserIdentityManagerCFVtbl = {
 268     ClassFactory_QueryInterface,
 269     ClassFactory_AddRef,
 270     ClassFactory_Release,
 271     UserIdentityManager_CreateInstance,
 272     ClassFactory_LockServer
 273 };
 274
 275 static IClassFactory UserIdentityManagerCF = { &UserIdentityManagerCFVtbl };
 276
 277 /******************************************************************
 278  *              DllMain (msident.@)
 279  */
 280 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 281 {
 282     TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv);
 283
 284     switch(fdwReason)
 285     {
 286     case DLL_PROCESS_ATTACH:
 287         msident_instance = hInstDLL;
 288         DisableThreadLibraryCalls(hInstDLL);
 289         break;
 290     }
 291
 292     return TRUE;
 293 }
 294
 295 /***********************************************************************
 296  *              DllGetClassObject       (msident.@)
 297  */
 298 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 299 {
 300     if(IsEqualGUID(&CLSID_UserIdentityManager, rclsid)) {
 301         TRACE("CLSID_UserIdentityManager\n");
 302         return IClassFactory_QueryInterface(&UserIdentityManagerCF, riid, ppv);
 303     }
 304
 305     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 306     return CLASS_E_CLASSNOTAVAILABLE;
 307 }
 308
 309 /***********************************************************************
 310  *          DllCanUnloadNow (msident.@)
 311  */
 312 HRESULT WINAPI DllCanUnloadNow(void)
 313 {
 314     return S_FALSE;
 315 }
 316
 317 /***********************************************************************
 318  *          DllRegisterServer (msident.@)
 319  */
 320 HRESULT WINAPI DllRegisterServer(void)
 321 {
 322     TRACE("()\n");
 323     return __wine_register_resources(msident_instance);
 324 }
 325
 326 /***********************************************************************
 327  *          DllUnregisterServer (msident.@)
 328  */
 329 HRESULT WINAPI DllUnregisterServer(void)
 330 {
 331     TRACE("()\n");
 332     return __wine_unregister_resources(msident_instance);
 333 }