dlls/activeds/activeds_main.c

   1 /*
   2  * Implementation of the Active Directory Service Interface
   3  *
   4  * Copyright 2005 Detlef Riekenberg
   5  * Copyright 2019 Dmitry Timoshkov
   6  *
   7  * This file contains only stubs to get the printui.dll up and running
   8  * activeds.dll is much much more than this
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include <stdarg.h>
  26
  27 #define COBJMACROS
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32
  33 #include "objbase.h"
  34 #include "initguid.h"
  35 #include "iads.h"
  36 #include "adshlp.h"
  37 #include "adserr.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(activeds);
  42
  43 /*****************************************************
  44  * ADsGetObject     [ACTIVEDS.3]
  45  */
  46 HRESULT WINAPI ADsGetObject(LPCWSTR path, REFIID riid, void **obj)
  47 {
  48     HRESULT hr;
  49
  50     hr = ADsOpenObject(path, NULL, NULL, ADS_SECURE_AUTHENTICATION, riid, obj);
  51     if (hr != S_OK)
  52         hr = ADsOpenObject(path, NULL, NULL, 0, riid, obj);
  53     return hr;
  54 }
  55
  56 /*****************************************************
  57  * ADsBuildEnumerator    [ACTIVEDS.4]
  58  */
  59 HRESULT WINAPI ADsBuildEnumerator(IADsContainer * pADsContainer, IEnumVARIANT** ppEnumVariant)
  60 {
  61     FIXME("(%p)->(%p)!stub\n",pADsContainer, ppEnumVariant);
  62     return E_NOTIMPL;
  63 }
  64
  65 /*****************************************************
  66  * ADsFreeEnumerator     [ACTIVEDS.5]
  67  */
  68 HRESULT WINAPI ADsFreeEnumerator(IEnumVARIANT* pEnumVariant)
  69 {
  70     FIXME("(%p)!stub\n",pEnumVariant);
  71     return E_NOTIMPL;
  72 }
  73
  74 /*****************************************************
  75  * ADsEnumerateNext     [ACTIVEDS.6]
  76  */
  77 HRESULT WINAPI ADsEnumerateNext(IEnumVARIANT* pEnumVariant, ULONG cElements, VARIANT* pvar, ULONG * pcElementsFetched)
  78 {
  79     FIXME("(%p)->(%u, %p, %p)!stub\n",pEnumVariant, cElements, pvar, pcElementsFetched);
  80     return E_NOTIMPL;
  81 }
  82
  83 /*****************************************************
  84  * ADsBuildVarArrayStr     [ACTIVEDS.7]
  85  */
  86 HRESULT WINAPI ADsBuildVarArrayStr(LPWSTR *str, DWORD count, VARIANT *var)
  87 {
  88     HRESULT hr;
  89     SAFEARRAY *sa;
  90     LONG idx, end = count;
  91
  92     TRACE("(%p, %u, %p)\n", str, count, var);
  93
  94     if (!var) return E_ADS_BAD_PARAMETER;
  95
  96     sa = SafeArrayCreateVector(VT_VARIANT, 0, count);
  97     if (!sa) return E_OUTOFMEMORY;
  98
  99     VariantInit(var);
 100     for (idx = 0; idx < end; idx++)
 101     {
 102         VARIANT item;
 103
 104         V_VT(&item) = VT_BSTR;
 105         V_BSTR(&item) = SysAllocString(str[idx]);
 106         if (!V_BSTR(&item))
 107         {
 108             hr = E_OUTOFMEMORY;
 109             goto fail;
 110         }
 111
 112         hr = SafeArrayPutElement(sa, &idx, &item);
 113         SysFreeString(V_BSTR(&item));
 114         if (hr != S_OK) goto fail;
 115     }
 116
 117     V_VT(var) = VT_ARRAY | VT_VARIANT;
 118     V_ARRAY(var) = sa;
 119     return S_OK;
 120
 121 fail:
 122     SafeArrayDestroy(sa);
 123     return hr;
 124 }
 125
 126 /*****************************************************
 127  * ADsBuildVarArrayInt     [ACTIVEDS.8]
 128  */
 129 HRESULT WINAPI ADsBuildVarArrayInt(LPDWORD lpdwObjectTypes, DWORD dwObjectTypes, VARIANT* pvar)
 130 {
 131     FIXME("(%p, %d, %p)!stub\n",lpdwObjectTypes, dwObjectTypes, pvar);
 132     return E_NOTIMPL;
 133 }
 134
 135 /*****************************************************
 136  * ADsOpenObject     [ACTIVEDS.9]
 137  */
 138 HRESULT WINAPI ADsOpenObject(LPCWSTR path, LPCWSTR user, LPCWSTR password, DWORD reserved, REFIID riid, void **obj)
 139 {
 140     HRESULT hr;
 141     HKEY hkey, hprov;
 142     WCHAR provider[MAX_PATH], progid[MAX_PATH];
 143     DWORD idx = 0;
 144
 145     TRACE("(%s,%s,%u,%s,%p)\n", debugstr_w(path), debugstr_w(user), reserved, debugstr_guid(riid), obj);
 146
 147     if (!path || !riid || !obj)
 148         return E_INVALIDARG;
 149
 150     hr = E_FAIL;
 151
 152     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\ADs\\Providers", 0, KEY_READ, &hkey))
 153         return hr;
 154
 155     for (;;)
 156     {
 157         if (RegEnumKeyW(hkey, idx++, provider, ARRAY_SIZE(provider)))
 158             break;
 159
 160         TRACE("provider %s\n", debugstr_w(provider));
 161
 162         if (!wcsnicmp(path, provider, wcslen(provider)) && path[wcslen(provider)] == ':')
 163         {
 164             LONG size;
 165
 166             if (RegOpenKeyExW(hkey, provider, 0, KEY_READ, &hprov))
 167                 break;
 168
 169             size = ARRAY_SIZE(progid);
 170             if (!RegQueryValueW(hprov, NULL, progid, &size))
 171             {
 172                 CLSID clsid;
 173
 174                 if (CLSIDFromProgID(progid, &clsid) == S_OK)
 175                 {
 176                     IADsOpenDSObject *adsopen;
 177                     IDispatch *disp;
 178
 179                     TRACE("ns %s => clsid %s\n", debugstr_w(progid), wine_dbgstr_guid(&clsid));
 180                     if (CoCreateInstance(&clsid, 0, CLSCTX_INPROC_SERVER, &IID_IADsOpenDSObject, (void **)&adsopen) == S_OK)
 181                     {
 182                         BSTR bpath, buser, bpassword;
 183
 184                         bpath = SysAllocString(path);
 185                         buser = SysAllocString(user);
 186                         bpassword = SysAllocString(password);
 187
 188                         hr = IADsOpenDSObject_OpenDSObject(adsopen, bpath, buser, bpassword, reserved, &disp);
 189                         if (hr == S_OK)
 190                         {
 191                             hr = IDispatch_QueryInterface(disp, riid, obj);
 192                             IDispatch_Release(disp);
 193                         }
 194
 195                         SysFreeString(bpath);
 196                         SysFreeString(buser);
 197                         SysFreeString(bpassword);
 198
 199                         IADsOpenDSObject_Release(adsopen);
 200                     }
 201                 }
 202             }
 203
 204             RegCloseKey(hprov);
 205             break;
 206         }
 207     }
 208
 209     RegCloseKey(hkey);
 210
 211     return hr;
 212 }
 213
 214 /*****************************************************
 215  * ADsSetLastError    [ACTIVEDS.12]
 216  */
 217 VOID WINAPI ADsSetLastError(DWORD dwErr, LPWSTR pszError, LPWSTR pszProvider)
 218 {
 219     FIXME("(%d,%p,%p)!stub\n", dwErr, pszError, pszProvider);
 220 }
 221
 222 /*****************************************************
 223  * ADsGetLastError    [ACTIVEDS.13]
 224  */
 225 HRESULT WINAPI ADsGetLastError(LPDWORD perror, LPWSTR errorbuf, DWORD errorbuflen, LPWSTR namebuf, DWORD namebuflen)
 226 {
 227     FIXME("(%p,%p,%d,%p,%d)!stub\n", perror, errorbuf, errorbuflen, namebuf, namebuflen);
 228     return E_NOTIMPL;
 229 }
 230
 231 /*****************************************************
 232  * AllocADsMem             [ACTIVEDS.14]
 233  */
 234 LPVOID WINAPI AllocADsMem(DWORD cb)
 235 {
 236     return HeapAlloc(GetProcessHeap(), 0, cb);
 237 }
 238
 239 /*****************************************************
 240  * FreeADsMem             [ACTIVEDS.15]
 241  */
 242 BOOL WINAPI FreeADsMem(LPVOID pMem)
 243 {
 244     return HeapFree(GetProcessHeap(), 0, pMem);
 245 }
 246
 247 /*****************************************************
 248  * ReallocADsMem             [ACTIVEDS.16]
 249  */
 250 LPVOID WINAPI ReallocADsMem(LPVOID pOldMem, DWORD cbOld, DWORD cbNew)
 251 {
 252     return HeapReAlloc(GetProcessHeap(), 0, pOldMem, cbNew);
 253 }
 254
 255 /*****************************************************
 256  * AllocADsStr             [ACTIVEDS.17]
 257  */
 258 LPWSTR WINAPI AllocADsStr(LPWSTR pStr)
 259 {
 260     LPWSTR ret;
 261     SIZE_T len;
 262
 263     TRACE("(%p)\n", pStr);
 264
 265     if (!pStr) return NULL;
 266
 267     len = (wcslen(pStr) + 1) * sizeof(WCHAR);
 268     ret = AllocADsMem(len);
 269     if (ret) memcpy(ret, pStr, len);
 270
 271     return ret;
 272 }
 273
 274 /*****************************************************
 275  * FreeADsStr             [ACTIVEDS.18]
 276  */
 277 BOOL WINAPI FreeADsStr(LPWSTR pStr)
 278 {
 279     TRACE("(%p)\n", pStr);
 280
 281     return FreeADsMem(pStr);
 282 }
 283
 284 /*****************************************************
 285  * ReallocADsStr             [ACTIVEDS.19]
 286  */
 287 BOOL WINAPI ReallocADsStr(LPWSTR *ppStr, LPWSTR pStr)
 288 {
 289     FIXME("(%p,%p)!stub\n",*ppStr, pStr);
 290     return FALSE;
 291 }
 292
 293 /*****************************************************
 294  * ADsEncodeBinaryData     [ACTIVEDS.20]
 295  */
 296 HRESULT WINAPI ADsEncodeBinaryData(PBYTE pbSrcData, DWORD dwSrcLen, LPWSTR *ppszDestData)
 297 {
 298     FIXME("(%p,%d,%p)!stub\n", pbSrcData, dwSrcLen, *ppszDestData);
 299     return E_NOTIMPL;
 300 }