Sweden-Number/dlls/msident/msident.c

288 lines
8.1 KiB
C
Raw Normal View History

2012-03-09 11:12:25 +01:00
/*
* Copyright 2012 Jacek Caban for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#include "windows.h"
#include "initguid.h"
#include "msident.h"
#include "rpcproxy.h"
2012-03-09 11:12:25 +01:00
#include "wine/debug.h"
#include "wine/heap.h"
2012-03-09 11:12:25 +01:00
WINE_DEFAULT_DEBUG_CHANNEL(msident);
typedef struct {
IEnumUserIdentity IEnumUserIdentity_iface;
LONG ref;
} EnumUserIdentity;
static inline EnumUserIdentity *impl_from_IEnumUserIdentity(IEnumUserIdentity *iface)
{
return CONTAINING_RECORD(iface, EnumUserIdentity, IEnumUserIdentity_iface);
}
static HRESULT WINAPI EnumUserIdentity_QueryInterface(IEnumUserIdentity *iface, REFIID riid, void **ppv)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(IID_IUnknown %p)\n", ppv);
*ppv = &This->IEnumUserIdentity_iface;
}else if(IsEqualGUID(&IID_IEnumUserIdentity, riid)) {
TRACE("(IID_IEnumUserIdentity %p)\n", ppv);
*ppv = &This->IEnumUserIdentity_iface;
}else {
WARN("(%s %p)\n", debugstr_guid(riid), ppv);
*ppv = NULL;
return E_NOINTERFACE;
}
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI EnumUserIdentity_AddRef(IEnumUserIdentity *iface)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
LONG ref = InterlockedIncrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
return ref;
}
static ULONG WINAPI EnumUserIdentity_Release(IEnumUserIdentity *iface)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
LONG ref = InterlockedDecrement(&This->ref);
TRACE("(%p) ref=%d\n", This, ref);
if(!ref)
heap_free(This);
return ref;
}
static HRESULT WINAPI EnumUserIdentity_Next(IEnumUserIdentity *iface, ULONG celt, IUnknown **rgelt, ULONG *pceltFetched)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
FIXME("(%p)->(%u %p %p)\n", This, celt, rgelt, pceltFetched);
return E_NOTIMPL;
}
static HRESULT WINAPI EnumUserIdentity_Skip(IEnumUserIdentity *iface, ULONG celt)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
FIXME("(%p)->(%u)\n", This, celt);
return E_NOTIMPL;
}
static HRESULT WINAPI EnumUserIdentity_Reset(IEnumUserIdentity *iface)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
FIXME("(%p)->()\n", This);
return E_NOTIMPL;
}
static HRESULT WINAPI EnumUserIdentity_Clone(IEnumUserIdentity *iface, IEnumUserIdentity **ppenum)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
FIXME("(%p)->(%p)\n", This, ppenum);
return E_NOTIMPL;
}
static HRESULT WINAPI EnumUserIdentity_GetCount(IEnumUserIdentity *iface, ULONG *pnCount)
{
EnumUserIdentity *This = impl_from_IEnumUserIdentity(iface);
FIXME("(%p)->(%p)\n", This, pnCount);
*pnCount = 0;
return S_OK;
}
static const IEnumUserIdentityVtbl EnumUserIdentityVtbl = {
EnumUserIdentity_QueryInterface,
EnumUserIdentity_AddRef,
EnumUserIdentity_Release,
EnumUserIdentity_Next,
EnumUserIdentity_Skip,
EnumUserIdentity_Reset,
EnumUserIdentity_Clone,
EnumUserIdentity_GetCount
};
static HRESULT WINAPI UserIdentityManager_QueryInterface(IUserIdentityManager *iface, REFIID riid, void **ppv)
{
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(IID_IUnknown %p)\n", ppv);
*ppv = iface;
}else if(IsEqualGUID(&IID_IUserIdentityManager, riid)) {
TRACE("(IID_IUserIdentityManager %p)\n", ppv);
*ppv = iface;
}else {
WARN("(%s %p)\n", debugstr_guid(riid), ppv);
*ppv = NULL;
return E_NOINTERFACE;
}
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
static ULONG WINAPI UserIdentityManager_AddRef(IUserIdentityManager *iface)
{
TRACE("\n");
return 2;
}
static ULONG WINAPI UserIdentityManager_Release(IUserIdentityManager *iface)
{
TRACE("\n");
return 1;
}
static HRESULT WINAPI UserIdentityManager_EnumIdentities(IUserIdentityManager *iface, IEnumUserIdentity **ppEnumUser)
{
EnumUserIdentity *ret;
TRACE("(%p)\n", ppEnumUser);
ret = heap_alloc(sizeof(*ret));
if(!ret)
return E_OUTOFMEMORY;
ret->IEnumUserIdentity_iface.lpVtbl = &EnumUserIdentityVtbl;
ret->ref = 1;
*ppEnumUser = &ret->IEnumUserIdentity_iface;
return S_OK;
}
static HRESULT WINAPI UserIdentityManager_ManageIdentities(IUserIdentityManager *iface, HWND hwndParent, DWORD dwFlags)
{
FIXME("(%p %x)\n", hwndParent, dwFlags);
return E_NOTIMPL;
}
static HRESULT WINAPI UserIdentityManager_Logon(IUserIdentityManager *iface, HWND hwndParent,
DWORD dwFlags, IUserIdentity **ppIdentity)
{
FIXME("(%p %x %p)\n", hwndParent, dwFlags, ppIdentity);
return E_USER_CANCELLED;
}
static HRESULT WINAPI UserIdentityManager_Logoff(IUserIdentityManager *iface, HWND hwndParent)
{
FIXME("(%p)\n", hwndParent);
return E_NOTIMPL;
}
static HRESULT WINAPI UserIdentityManager_GetIdentityByCookie(IUserIdentityManager *iface, GUID *uidCookie,
IUserIdentity **ppIdentity)
{
FIXME("(%p %p)\n", uidCookie, ppIdentity);
return E_NOTIMPL;
}
static const IUserIdentityManagerVtbl UserIdentityManagerVtbl = {
UserIdentityManager_QueryInterface,
UserIdentityManager_AddRef,
UserIdentityManager_Release,
UserIdentityManager_EnumIdentities,
UserIdentityManager_ManageIdentities,
UserIdentityManager_Logon,
UserIdentityManager_Logoff,
UserIdentityManager_GetIdentityByCookie
};
static IUserIdentityManager UserIdentityManager = { &UserIdentityManagerVtbl };
static HRESULT WINAPI UserIdentityManager_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
{
TRACE("\n");
return IUserIdentityManager_QueryInterface(&UserIdentityManager, riid, ppv);
}
static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
{
*ppv = NULL;
if(IsEqualGUID(&IID_IUnknown, riid)) {
TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
*ppv = iface;
}else if(IsEqualGUID(&IID_IClassFactory, riid)) {
TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
*ppv = iface;
}
if(*ppv) {
IUnknown_AddRef((IUnknown*)*ppv);
return S_OK;
}
FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
return E_NOINTERFACE;
}
static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
{
TRACE("(%p)\n", iface);
return 2;
}
static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
{
TRACE("(%p)\n", iface);
return 1;
}
static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
{
TRACE("(%p)->(%x)\n", iface, fLock);
return S_OK;
}
static const IClassFactoryVtbl UserIdentityManagerCFVtbl = {
ClassFactory_QueryInterface,
ClassFactory_AddRef,
ClassFactory_Release,
UserIdentityManager_CreateInstance,
ClassFactory_LockServer
};
static IClassFactory UserIdentityManagerCF = { &UserIdentityManagerCFVtbl };
2012-03-09 11:12:25 +01:00
/***********************************************************************
* DllGetClassObject (msident.@)
*/
HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
{
if(IsEqualGUID(&CLSID_UserIdentityManager, rclsid)) {
TRACE("CLSID_UserIdentityManager\n");
return IClassFactory_QueryInterface(&UserIdentityManagerCF, riid, ppv);
}
2012-03-09 11:12:25 +01:00
FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
return CLASS_E_CLASSNOTAVAILABLE;
}