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 typedef struct {
  32     IEnumUserIdentity IEnumUserIdentity_iface;
  33     LONG ref;
  34 } EnumUserIdentity;
  35
  36 static inline EnumUserIdentity *impl_from_IEnumUserIdentity(IEnumUserIdentity *iface)
  37 {
  38     return CONTAINING_RECORD(iface, EnumUserIdentity, IEnumUserIdentity_iface);
  39 }
  40
  41 static HRESULT WINAPI EnumUserIdentity_QueryInterface(IEnumUserIdentity *iface, REFIID riid, void **ppv)
  42 {
  43     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  44
  45     if(IsEqualGUID(&IID_IUnknown, riid)) {
  46         TRACE("(IID_IUnknown %p)\n", ppv);
  47         *ppv = &This->IEnumUserIdentity_iface;
  48     }else if(IsEqualGUID(&IID_IEnumUserIdentity, riid)) {
  49         TRACE("(IID_IEnumUserIdentity %p)\n", ppv);
  50         *ppv = &This->IEnumUserIdentity_iface;
  51     }else {
  52         WARN("(%s %p)\n", debugstr_guid(riid), ppv);
  53         *ppv = NULL;
  54         return E_NOINTERFACE;
  55     }
  56
  57     IUnknown_AddRef((IUnknown*)*ppv);
  58     return S_OK;
  59 }
  60
  61 static ULONG WINAPI EnumUserIdentity_AddRef(IEnumUserIdentity *iface)
  62 {
  63     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  64     LONG ref = InterlockedIncrement(&This->ref);
  65
  66     TRACE("(%p) ref=%d\n", This, ref);
  67
  68     return ref;
  69 }
  70
  71 static ULONG WINAPI EnumUserIdentity_Release(IEnumUserIdentity *iface)
  72 {
  73     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  74     LONG ref = InterlockedDecrement(&This->ref);
  75
  76     TRACE("(%p) ref=%d\n", This, ref);
  77
  78     if(!ref)
  79         heap_free(This);
  80
  81     return ref;
  82 }
  83
  84 static HRESULT WINAPI EnumUserIdentity_Next(IEnumUserIdentity *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
  85 {
  86     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  87     FIXME("(%p)->(%u %p %p)\n", This, celt, rgelt, pceltFetched);
  88     return E_NOTIMPL;
  89 }
  90
  91 static HRESULT WINAPI EnumUserIdentity_Skip(IEnumUserIdentity *iface, ULONG celt)
  92 {
  93     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
  94     FIXME("(%p)->(%u)\n", This, celt);
  95     return E_NOTIMPL;
  96 }
  97
  98 static HRESULT WINAPI EnumUserIdentity_Reset(IEnumUserIdentity *iface)
  99 {
 100     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
 101     FIXME("(%p)->()\n", This);
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI EnumUserIdentity_Clone(IEnumUserIdentity *iface, IEnumUserIdentity **ppenum)
 106 {
 107     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
 108     FIXME("(%p)->(%p)\n", This, ppenum);
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI EnumUserIdentity_GetCount(IEnumUserIdentity *iface, ULONG *pnCount)
 113 {
 114     EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
 115
 116     FIXME("(%p)->(%p)\n", This, pnCount);
 117
 118     *pnCount = 0;
 119     return S_OK;
 120 }
 121
 122 static const IEnumUserIdentityVtbl EnumUserIdentityVtbl = {
 123     EnumUserIdentity_QueryInterface,
 124     EnumUserIdentity_AddRef,
 125     EnumUserIdentity_Release,
 126     EnumUserIdentity_Next,
 127     EnumUserIdentity_Skip,
 128     EnumUserIdentity_Reset,
 129     EnumUserIdentity_Clone,
 130     EnumUserIdentity_GetCount
 131 };
 132
 133 static HRESULT WINAPI UserIdentityManager_QueryInterface(IUserIdentityManager *iface, REFIID riid, void **ppv)
 134 {
 135     if(IsEqualGUID(&IID_IUnknown, riid)) {
 136         TRACE("(IID_IUnknown %p)\n", ppv);
 137         *ppv = iface;
 138     }else if(IsEqualGUID(&IID_IUserIdentityManager, riid)) {
 139         TRACE("(IID_IUserIdentityManager %p)\n", ppv);
 140         *ppv = iface;
 141     }else {
 142         WARN("(%s %p)\n", debugstr_guid(riid), ppv);
 143         *ppv = NULL;
 144         return E_NOINTERFACE;
 145     }
 146
 147     IUnknown_AddRef((IUnknown*)*ppv);
 148     return S_OK;
 149 }
 150
 151 static ULONG WINAPI UserIdentityManager_AddRef(IUserIdentityManager *iface)
 152 {
 153     TRACE("\n");
 154     return 2;
 155 }
 156
 157 static ULONG WINAPI UserIdentityManager_Release(IUserIdentityManager *iface)
 158 {
 159     TRACE("\n");
 160     return 1;
 161 }
 162
 163 static HRESULT WINAPI UserIdentityManager_EnumIdentities(IUserIdentityManager *iface, IEnumUserIdentity **ppEnumUser)
 164 {
 165     EnumUserIdentity *ret;
 166
 167     TRACE("(%p)\n", ppEnumUser);
 168
 169     ret = heap_alloc(sizeof(*ret));
 170     if(!ret)
 171         return E_OUTOFMEMORY;
 172
 173     ret->IEnumUserIdentity_iface.lpVtbl = &EnumUserIdentityVtbl;
 174     ret->ref = 1;
 175
 176     *ppEnumUser = &ret->IEnumUserIdentity_iface;
 177     return S_OK;
 178 }
 179
 180 static HRESULT WINAPI UserIdentityManager_ManageIdentities(IUserIdentityManager *iface, HWND hwndParent, DWORD dwFlags)
 181 {
 182     FIXME("(%p %x)\n", hwndParent, dwFlags);
 183     return E_NOTIMPL;
 184 }
 185
 186 static HRESULT WINAPI UserIdentityManager_Logon(IUserIdentityManager *iface, HWND hwndParent,
 187         DWORD dwFlags, IUserIdentity **ppIdentity)
 188 {
 189     FIXME("(%p %x %p)\n", hwndParent, dwFlags, ppIdentity);
 190     return E_USER_CANCELLED;
 191 }
 192
 193 static HRESULT WINAPI UserIdentityManager_Logoff(IUserIdentityManager *iface, HWND hwndParent)
 194 {
 195     FIXME("(%p)\n", hwndParent);
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI UserIdentityManager_GetIdentityByCookie(IUserIdentityManager *iface, GUID *uidCookie,
 200         IUserIdentity **ppIdentity)
 201 {
 202     FIXME("(%p %p)\n", uidCookie, ppIdentity);
 203     return E_NOTIMPL;
 204 }
 205
 206 static const IUserIdentityManagerVtbl UserIdentityManagerVtbl = {
 207     UserIdentityManager_QueryInterface,
 208     UserIdentityManager_AddRef,
 209     UserIdentityManager_Release,
 210     UserIdentityManager_EnumIdentities,
 211     UserIdentityManager_ManageIdentities,
 212     UserIdentityManager_Logon,
 213     UserIdentityManager_Logoff,
 214     UserIdentityManager_GetIdentityByCookie
 215 };
 216
 217 static IUserIdentityManager UserIdentityManager = { &UserIdentityManagerVtbl };
 218
 219 static HRESULT WINAPI UserIdentityManager_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 220 {
 221     TRACE("\n");
 222
 223     return IUserIdentityManager_QueryInterface(&UserIdentityManager, riid, ppv);
 224 }
 225
 226 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 227 {
 228     *ppv = NULL;
 229
 230     if(IsEqualGUID(&IID_IUnknown, riid)) {
 231         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 232         *ppv = iface;
 233     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
 234         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
 235         *ppv = iface;
 236     }
 237
 238     if(*ppv) {
 239         IUnknown_AddRef((IUnknown*)*ppv);
 240         return S_OK;
 241     }
 242
 243     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 244     return E_NOINTERFACE;
 245 }
 246
 247 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 248 {
 249     TRACE("(%p)\n", iface);
 250     return 2;
 251 }
 252
 253 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 254 {
 255     TRACE("(%p)\n", iface);
 256     return 1;
 257 }
 258
 259 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 260 {
 261     TRACE("(%p)->(%x)\n", iface, fLock);
 262     return S_OK;
 263 }
 264
 265 static const IClassFactoryVtbl UserIdentityManagerCFVtbl = {
 266     ClassFactory_QueryInterface,
 267     ClassFactory_AddRef,
 268     ClassFactory_Release,
 269     UserIdentityManager_CreateInstance,
 270     ClassFactory_LockServer
 271 };
 272
 273 static IClassFactory UserIdentityManagerCF = { &UserIdentityManagerCFVtbl };
 274
 275 /***********************************************************************
 276  *              DllGetClassObject       (msident.@)
 277  */
 278 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 279 {
 280     if(IsEqualGUID(&CLSID_UserIdentityManager, rclsid)) {
 281         TRACE("CLSID_UserIdentityManager\n");
 282         return IClassFactory_QueryInterface(&UserIdentityManagerCF, riid, ppv);
 283     }
 284
 285     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 286     return CLASS_E_CLASSNOTAVAILABLE;
 287 }