dlls/adsldp/adsldp.c

   1 /*
   2  * Active Directory services LDAP Provider
   3  *
   4  * Copyright 2018 Dmitry Timoshkov
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "initguid.h"
  28 #include "objbase.h"
  29 #include "rpcproxy.h"
  30 #include "iads.h"
  31 #define SECURITY_WIN32
  32 #include "security.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(adsldp);
  37
  38 static HMODULE adsldp_hinst;
  39
  40 typedef struct
  41 {
  42     IADsADSystemInfo IADsADSystemInfo_iface;
  43     LONG ref;
  44 } AD_sysinfo;
  45
  46 static inline AD_sysinfo *impl_from_IADsADSystemInfo(IADsADSystemInfo *iface)
  47 {
  48     return CONTAINING_RECORD(iface, AD_sysinfo, IADsADSystemInfo_iface);
  49 }
  50
  51 static HRESULT WINAPI sysinfo_QueryInterface(IADsADSystemInfo *iface, REFIID riid, void **obj)
  52 {
  53     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
  54
  55     if (!riid || !obj) return E_INVALIDARG;
  56
  57     if (IsEqualGUID(riid, &IID_IADsADSystemInfo) ||
  58         IsEqualGUID(riid, &IID_IDispatch) ||
  59         IsEqualGUID(riid, &IID_IUnknown))
  60     {
  61         IADsADSystemInfo_AddRef(iface);
  62         *obj = iface;
  63         return S_OK;
  64     }
  65
  66     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
  67     return E_NOINTERFACE;
  68 }
  69
  70 static ULONG WINAPI sysinfo_AddRef(IADsADSystemInfo *iface)
  71 {
  72     AD_sysinfo *sysinfo = impl_from_IADsADSystemInfo(iface);
  73     return InterlockedIncrement(&sysinfo->ref);
  74 }
  75
  76 static ULONG WINAPI sysinfo_Release(IADsADSystemInfo *iface)
  77 {
  78     AD_sysinfo *sysinfo = impl_from_IADsADSystemInfo(iface);
  79     LONG ref = InterlockedDecrement(&sysinfo->ref);
  80
  81     if (!ref)
  82     {
  83         TRACE("destroying %p\n", iface);
  84         HeapFree(GetProcessHeap(), 0, sysinfo);
  85     }
  86
  87     return ref;
  88 }
  89
  90 static HRESULT WINAPI sysinfo_GetTypeInfoCount(IADsADSystemInfo *iface, UINT *count)
  91 {
  92     FIXME("%p,%p: stub\n", iface, count);
  93     return E_NOTIMPL;
  94 }
  95
  96 static HRESULT WINAPI sysinfo_GetTypeInfo(IADsADSystemInfo *iface, UINT index, LCID lcid, ITypeInfo **info)
  97 {
  98     FIXME("%p,%u,%#x,%p: stub\n", iface, index, lcid, info);
  99     return E_NOTIMPL;
 100 }
 101
 102 static HRESULT WINAPI sysinfo_GetIDsOfNames(IADsADSystemInfo *iface, REFIID riid, LPOLESTR *names,
 103                                             UINT count, LCID lcid, DISPID *dispid)
 104 {
 105     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT WINAPI sysinfo_Invoke(IADsADSystemInfo *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 110                                      DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 111 {
 112     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 113           params, result, excepinfo, argerr);
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI sysinfo_get_UserName(IADsADSystemInfo *iface, BSTR *retval)
 118 {
 119     FIXME("%p,%p: stub\n", iface, retval);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI sysinfo_get_ComputerName(IADsADSystemInfo *iface, BSTR *retval)
 124 {
 125     UINT size;
 126     WCHAR *name;
 127
 128     TRACE("%p,%p\n", iface, retval);
 129
 130     size = 0;
 131     GetComputerObjectNameW(NameFullyQualifiedDN, NULL, &size);
 132     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 133         return HRESULT_FROM_WIN32(GetLastError());
 134
 135     name = SysAllocStringLen(NULL, size);
 136     if (!name) return E_OUTOFMEMORY;
 137
 138     if (!GetComputerObjectNameW(NameFullyQualifiedDN, name, &size))
 139     {
 140         SysFreeString(name);
 141         return HRESULT_FROM_WIN32(GetLastError());
 142     }
 143
 144     *retval = name;
 145     return S_OK;
 146 }
 147
 148 static HRESULT WINAPI sysinfo_get_SiteName(IADsADSystemInfo *iface, BSTR *retval)
 149 {
 150     FIXME("%p,%p: stub\n", iface, retval);
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI sysinfo_get_DomainShortName(IADsADSystemInfo *iface, BSTR *retval)
 155 {
 156     FIXME("%p,%p: stub\n", iface, retval);
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI sysinfo_get_DomainDNSName(IADsADSystemInfo *iface, BSTR *retval)
 161 {
 162     FIXME("%p,%p: stub\n", iface, retval);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI sysinfo_get_ForestDNSName(IADsADSystemInfo *iface, BSTR *retval)
 167 {
 168     FIXME("%p,%p: stub\n", iface, retval);
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI sysinfo_get_PDCRoleOwner(IADsADSystemInfo *iface, BSTR *retval)
 173 {
 174     FIXME("%p,%p: stub\n", iface, retval);
 175     return E_NOTIMPL;
 176 }
 177
 178 static HRESULT WINAPI sysinfo_get_SchemaRoleOwner(IADsADSystemInfo *iface, BSTR *retval)
 179 {
 180     FIXME("%p,%p: stub\n", iface, retval);
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI sysinfo_get_IsNativeMode(IADsADSystemInfo *iface, VARIANT_BOOL *retval)
 185 {
 186     FIXME("%p,%p: stub\n", iface, retval);
 187     return E_NOTIMPL;
 188 }
 189
 190 static HRESULT WINAPI sysinfo_GetAnyDCName(IADsADSystemInfo *iface, BSTR *retval)
 191 {
 192     FIXME("%p,%p: stub\n", iface, retval);
 193     return E_NOTIMPL;
 194 }
 195
 196 static HRESULT WINAPI sysinfo_GetDCSiteName(IADsADSystemInfo *iface, BSTR server, BSTR *retval)
 197 {
 198     FIXME("%p,%s,%p: stub\n", iface, debugstr_w(server), retval);
 199     return E_NOTIMPL;
 200 }
 201
 202 static HRESULT WINAPI sysinfo_RefreshSchemaCache(IADsADSystemInfo *iface)
 203 {
 204     FIXME("%p: stub\n", iface);
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI sysinfo_GetTrees(IADsADSystemInfo *iface, VARIANT *retval)
 209 {
 210     FIXME("%p,%p: stub\n", iface, retval);
 211     return E_NOTIMPL;
 212 }
 213
 214 static const IADsADSystemInfoVtbl IADsADSystemInfo_vtbl =
 215 {
 216     sysinfo_QueryInterface,
 217     sysinfo_AddRef,
 218     sysinfo_Release,
 219     sysinfo_GetTypeInfoCount,
 220     sysinfo_GetTypeInfo,
 221     sysinfo_GetIDsOfNames,
 222     sysinfo_Invoke,
 223     sysinfo_get_UserName,
 224     sysinfo_get_ComputerName,
 225     sysinfo_get_SiteName,
 226     sysinfo_get_DomainShortName,
 227     sysinfo_get_DomainDNSName,
 228     sysinfo_get_ForestDNSName,
 229     sysinfo_get_PDCRoleOwner,
 230     sysinfo_get_SchemaRoleOwner,
 231     sysinfo_get_IsNativeMode,
 232     sysinfo_GetAnyDCName,
 233     sysinfo_GetDCSiteName,
 234     sysinfo_RefreshSchemaCache,
 235     sysinfo_GetTrees
 236 };
 237
 238 static HRESULT ADSystemInfo_create(void **obj)
 239 {
 240     AD_sysinfo *sysinfo;
 241
 242     sysinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*sysinfo));
 243     if (!sysinfo) return E_OUTOFMEMORY;
 244
 245     sysinfo->IADsADSystemInfo_iface.lpVtbl = &IADsADSystemInfo_vtbl;
 246     sysinfo->ref = 1;
 247     *obj = &sysinfo->IADsADSystemInfo_iface;
 248
 249     TRACE("created %p\n", *obj);
 250
 251     return S_OK;
 252 }
 253
 254 typedef struct
 255 {
 256     IClassFactory IClassFactory_iface;
 257     HRESULT (*constructor)(void **);
 258 } ADSystemInfo_factory;
 259
 260 static inline ADSystemInfo_factory *impl_from_IClassFactory(IClassFactory *iface)
 261 {
 262     return CONTAINING_RECORD(iface, ADSystemInfo_factory, IClassFactory_iface);
 263 }
 264
 265 static HRESULT WINAPI factory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *obj)
 266 {
 267     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 268
 269     if (!riid || !obj) return E_INVALIDARG;
 270
 271     if (IsEqualIID(riid, &IID_IUnknown) ||
 272         IsEqualIID(riid, &IID_IClassFactory))
 273     {
 274         IClassFactory_AddRef(iface);
 275         *obj = iface;
 276         return S_OK;
 277     }
 278
 279     *obj = NULL;
 280     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 281     return E_NOINTERFACE;
 282 }
 283
 284 static ULONG WINAPI factory_AddRef(IClassFactory *iface)
 285 {
 286     return 2;
 287 }
 288
 289 static ULONG WINAPI factory_Release(IClassFactory *iface)
 290 {
 291     return 1;
 292 }
 293
 294 static HRESULT WINAPI factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
 295 {
 296     ADSystemInfo_factory *factory = impl_from_IClassFactory(iface);
 297     IUnknown *unknown;
 298     HRESULT hr;
 299
 300     TRACE("%p,%s,%p\n", outer, debugstr_guid(riid), obj);
 301
 302     if (!riid || !obj) return E_INVALIDARG;
 303
 304     *obj = NULL;
 305     if (outer) return CLASS_E_NOAGGREGATION;
 306
 307     hr = factory->constructor((void **)&unknown);
 308     if (hr == S_OK)
 309     {
 310         hr = IUnknown_QueryInterface(unknown, riid, obj);
 311         IUnknown_Release(unknown);
 312     }
 313     return hr;
 314 }
 315
 316 static HRESULT WINAPI factory_LockServer(IClassFactory *iface, BOOL lock)
 317 {
 318     FIXME("%p,%d: stub\n", iface, lock);
 319     return S_OK;
 320 }
 321
 322 static const struct IClassFactoryVtbl factory_vtbl =
 323 {
 324     factory_QueryInterface,
 325     factory_AddRef,
 326     factory_Release,
 327     factory_CreateInstance,
 328     factory_LockServer
 329 };
 330
 331 static ADSystemInfo_factory ADSystemInfo_cf = { { &factory_vtbl }, ADSystemInfo_create };
 332
 333 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *obj)
 334 {
 335     TRACE("%s,%s,%p\n", debugstr_guid(clsid), debugstr_guid(iid), obj);
 336
 337     if (!clsid || !iid || !obj) return E_INVALIDARG;
 338
 339     *obj = NULL;
 340
 341     if (IsEqualGUID(clsid, &CLSID_ADSystemInfo))
 342         return IClassFactory_QueryInterface(&ADSystemInfo_cf.IClassFactory_iface, iid, obj);
 343
 344     FIXME("class %s/%s is not implemented\n", debugstr_guid(clsid), debugstr_guid(iid));
 345     return CLASS_E_CLASSNOTAVAILABLE;
 346 }
 347
 348 HRESULT WINAPI DllCanUnloadNow(void)
 349 {
 350     return S_FALSE;
 351 }
 352
 353 HRESULT WINAPI DllRegisterServer(void)
 354 {
 355     return __wine_register_resources(adsldp_hinst);
 356 }
 357
 358 HRESULT WINAPI DllUnregisterServer(void)
 359 {
 360     return __wine_unregister_resources(adsldp_hinst);
 361 }
 362
 363 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, void *reserved)
 364 {
 365     TRACE("%p,%u,%p\n", hinst, reason, reserved);
 366
 367     switch (reason)
 368     {
 369     case DLL_WINE_PREATTACH:
 370         return FALSE; /* prefer native version */
 371
 372     case DLL_PROCESS_ATTACH:
 373         adsldp_hinst = hinst;
 374         DisableThreadLibraryCalls(hinst);
 375         break;
 376     }
 377
 378     return TRUE;
 379 }