?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Add RIM_TYPEHID type / hid member to rawinput union.
[wine.git] / dlls / adsldp / adsldp.c
blob701f27cd969ebd31b874e16ee02ef71fd2c813d2
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 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "initguid.h"
29 #include "objbase.h"
30 #include "rpcproxy.h"
31 #include "rpc.h"
32 #include "iads.h"
33 #include "adshlp.h"
34 #include "adserr.h"
35 #define SECURITY_WIN32
36 #include "security.h"
37 #include "dsgetdc.h"
38 #include "lmcons.h"
39 #include "lmapibuf.h"
40 #include "winldap.h"
41 #include "winber.h"
42
43 #include "adsldp_private.h"
44
45 #include "wine/debug.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(adsldp);
48
49 #ifndef LDAP_OPT_SERVER_CONTROLS
50 #define LDAP_OPT_SERVER_CONTROLS 0x0012
51 #endif
52
53 DEFINE_GUID(CLSID_LDAP,0x228d9a81,0xc302,0x11cf,0x9a,0xa4,0x00,0xaa,0x00,0x4a,0x56,0x91);
54 DEFINE_GUID(CLSID_LDAPNamespace,0x228d9a82,0xc302,0x11cf,0x9a,0xa4,0x00,0xaa,0x00,0x4a,0x56,0x91);
55
56 static HRESULT LDAPNamespace_create(REFIID riid, void **obj);
57
58 typedef struct
59 {
60 IParseDisplayName IParseDisplayName_iface;
61 LONG ref;
62 } LDAP_PARSE;
63
64 static inline LDAP_PARSE *impl_from_IParseDisplayName(IParseDisplayName *iface)
65 {
66 return CONTAINING_RECORD(iface, LDAP_PARSE, IParseDisplayName_iface);
67 }
68
69 static HRESULT WINAPI ldap_QueryInterface(IParseDisplayName *iface, REFIID riid, void **obj)
70 {
71 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
72
73 if (!riid || !obj) return E_INVALIDARG;
74
75 if (IsEqualGUID(riid, &IID_IUnknown) ||
76 IsEqualGUID(riid, &IID_IParseDisplayName))
77 {
78 IParseDisplayName_AddRef(iface);
79 *obj = iface;
80 return S_OK;
81 }
82
83 *obj = NULL;
84 FIXME("interface %s is not implemented\n", debugstr_guid(riid));
85 return E_NOINTERFACE;
86 }
87
88 static ULONG WINAPI ldap_AddRef(IParseDisplayName *iface)
89 {
90 LDAP_PARSE *ldap = impl_from_IParseDisplayName(iface);
91 return InterlockedIncrement(&ldap->ref);
92 }
93
94 static ULONG WINAPI ldap_Release(IParseDisplayName *iface)
95 {
96 LDAP_PARSE *ldap = impl_from_IParseDisplayName(iface);
97 LONG ref = InterlockedDecrement(&ldap->ref);
98
99 if (!ref)
100 {
101 TRACE("destroying %p\n", iface);
102 heap_free(ldap);
103 }
104
105 return ref;
106 }
107
108 static HRESULT WINAPI ldap_ParseDisplayName(IParseDisplayName *iface, IBindCtx *bc,
109 LPOLESTR name, ULONG *eaten, IMoniker **mk)
110 {
111 HRESULT hr;
112 IADsOpenDSObject *ads_open;
113 IDispatch *disp;
114
115 TRACE("%p,%p,%s,%p,%p\n", iface, bc, debugstr_w(name), eaten, mk);
116
117 hr = LDAPNamespace_create(&IID_IADsOpenDSObject, (void **)&ads_open);
118 if (hr != S_OK) return hr;
119
120 hr = IADsOpenDSObject_OpenDSObject(ads_open, name, NULL, NULL, ADS_SECURE_AUTHENTICATION, &disp);
121 if (hr != S_OK)
122 hr = IADsOpenDSObject_OpenDSObject(ads_open, name, NULL, NULL, 0, &disp);
123 if (hr == S_OK)
124 {
125 hr = CreatePointerMoniker((IUnknown *)disp, mk);
126 if (hr == S_OK)
127 *eaten = wcslen(name);
128
129 IDispatch_Release(disp);
130 }
131
132 IADsOpenDSObject_Release(ads_open);
133
134 return hr;
135 }
136
137 static const IParseDisplayNameVtbl LDAP_PARSE_vtbl =
138 {
139 ldap_QueryInterface,
140 ldap_AddRef,
141 ldap_Release,
142 ldap_ParseDisplayName
143 };
144
145 static HRESULT LDAP_create(REFIID riid, void **obj)
146 {
147 LDAP_PARSE *ldap;
148 HRESULT hr;
149
150 ldap = heap_alloc(sizeof(*ldap));
151 if (!ldap) return E_OUTOFMEMORY;
152
153 ldap->IParseDisplayName_iface.lpVtbl = &LDAP_PARSE_vtbl;
154 ldap->ref = 1;
155
156 hr = IParseDisplayName_QueryInterface(&ldap->IParseDisplayName_iface, riid, obj);
157 IParseDisplayName_Release(&ldap->IParseDisplayName_iface);
158
159 return hr;
160 }
161
162 typedef struct
163 {
164 IADsADSystemInfo IADsADSystemInfo_iface;
165 LONG ref;
166 } AD_sysinfo;
167
168 static inline AD_sysinfo *impl_from_IADsADSystemInfo(IADsADSystemInfo *iface)
169 {
170 return CONTAINING_RECORD(iface, AD_sysinfo, IADsADSystemInfo_iface);
171 }
172
173 static HRESULT WINAPI sysinfo_QueryInterface(IADsADSystemInfo *iface, REFIID riid, void **obj)
174 {
175 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
176
177 if (!riid || !obj) return E_INVALIDARG;
178
179 if (IsEqualGUID(riid, &IID_IADsADSystemInfo) ||
180 IsEqualGUID(riid, &IID_IDispatch) ||
181 IsEqualGUID(riid, &IID_IUnknown))
182 {
183 IADsADSystemInfo_AddRef(iface);
184 *obj = iface;
185 return S_OK;
186 }
187
188 *obj = NULL;
189 FIXME("interface %s is not implemented\n", debugstr_guid(riid));
190 return E_NOINTERFACE;
191 }
192
193 static ULONG WINAPI sysinfo_AddRef(IADsADSystemInfo *iface)
194 {
195 AD_sysinfo *sysinfo = impl_from_IADsADSystemInfo(iface);
196 return InterlockedIncrement(&sysinfo->ref);
197 }
198
199 static ULONG WINAPI sysinfo_Release(IADsADSystemInfo *iface)
200 {
201 AD_sysinfo *sysinfo = impl_from_IADsADSystemInfo(iface);
202 LONG ref = InterlockedDecrement(&sysinfo->ref);
203
204 if (!ref)
205 {
206 TRACE("destroying %p\n", iface);
207 heap_free(sysinfo);
208 }
209
210 return ref;
211 }
212
213 static HRESULT WINAPI sysinfo_GetTypeInfoCount(IADsADSystemInfo *iface, UINT *count)
214 {
215 FIXME("%p,%p: stub\n", iface, count);
216 return E_NOTIMPL;
217 }
218
219 static HRESULT WINAPI sysinfo_GetTypeInfo(IADsADSystemInfo *iface, UINT index, LCID lcid, ITypeInfo **info)
220 {
221 FIXME("%p,%u,%#x,%p: stub\n", iface, index, lcid, info);
222 return E_NOTIMPL;
223 }
224
225 static HRESULT WINAPI sysinfo_GetIDsOfNames(IADsADSystemInfo *iface, REFIID riid, LPOLESTR *names,
226 UINT count, LCID lcid, DISPID *dispid)
227 {
228 FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
229 return E_NOTIMPL;
230 }
231
232 static HRESULT WINAPI sysinfo_Invoke(IADsADSystemInfo *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
233 DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
234 {
235 FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
236 params, result, excepinfo, argerr);
237 return E_NOTIMPL;
238 }
239
240 static HRESULT WINAPI sysinfo_get_UserName(IADsADSystemInfo *iface, BSTR *retval)
241 {
242 FIXME("%p,%p: stub\n", iface, retval);
243 return E_NOTIMPL;
244 }
245
246 static HRESULT WINAPI sysinfo_get_ComputerName(IADsADSystemInfo *iface, BSTR *retval)
247 {
248 UINT size;
249 WCHAR *name;
250
251 TRACE("%p,%p\n", iface, retval);
252
253 size = 0;
254 GetComputerObjectNameW(NameFullyQualifiedDN, NULL, &size);
255 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
256 return HRESULT_FROM_WIN32(GetLastError());
257
258 name = SysAllocStringLen(NULL, size);
259 if (!name) return E_OUTOFMEMORY;
260
261 if (!GetComputerObjectNameW(NameFullyQualifiedDN, name, &size))
262 {
263 SysFreeString(name);
264 return HRESULT_FROM_WIN32(GetLastError());
265 }
266
267 *retval = name;
268 return S_OK;
269 }
270
271 static HRESULT WINAPI sysinfo_get_SiteName(IADsADSystemInfo *iface, BSTR *retval)
272 {
273 FIXME("%p,%p: stub\n", iface, retval);
274 return E_NOTIMPL;
275 }
276
277 static HRESULT WINAPI sysinfo_get_DomainShortName(IADsADSystemInfo *iface, BSTR *retval)
278 {
279 FIXME("%p,%p: stub\n", iface, retval);
280 return E_NOTIMPL;
281 }
282
283 static HRESULT WINAPI sysinfo_get_DomainDNSName(IADsADSystemInfo *iface, BSTR *retval)
284 {
285 FIXME("%p,%p: stub\n", iface, retval);
286 return E_NOTIMPL;
287 }
288
289 static HRESULT WINAPI sysinfo_get_ForestDNSName(IADsADSystemInfo *iface, BSTR *retval)
290 {
291 FIXME("%p,%p: stub\n", iface, retval);
292 return E_NOTIMPL;
293 }
294
295 static HRESULT WINAPI sysinfo_get_PDCRoleOwner(IADsADSystemInfo *iface, BSTR *retval)
296 {
297 FIXME("%p,%p: stub\n", iface, retval);
298 return E_NOTIMPL;
299 }
300
301 static HRESULT WINAPI sysinfo_get_SchemaRoleOwner(IADsADSystemInfo *iface, BSTR *retval)
302 {
303 FIXME("%p,%p: stub\n", iface, retval);
304 return E_NOTIMPL;
305 }
306
307 static HRESULT WINAPI sysinfo_get_IsNativeMode(IADsADSystemInfo *iface, VARIANT_BOOL *retval)
308 {
309 FIXME("%p,%p: stub\n", iface, retval);
310 return E_NOTIMPL;
311 }
312
313 static HRESULT WINAPI sysinfo_GetAnyDCName(IADsADSystemInfo *iface, BSTR *retval)
314 {
315 FIXME("%p,%p: stub\n", iface, retval);
316 return E_NOTIMPL;
317 }
318
319 static HRESULT WINAPI sysinfo_GetDCSiteName(IADsADSystemInfo *iface, BSTR server, BSTR *retval)
320 {
321 FIXME("%p,%s,%p: stub\n", iface, debugstr_w(server), retval);
322 return E_NOTIMPL;
323 }
324
325 static HRESULT WINAPI sysinfo_RefreshSchemaCache(IADsADSystemInfo *iface)
326 {
327 FIXME("%p: stub\n", iface);
328 return E_NOTIMPL;
329 }
330
331 static HRESULT WINAPI sysinfo_GetTrees(IADsADSystemInfo *iface, VARIANT *retval)
332 {
333 FIXME("%p,%p: stub\n", iface, retval);
334 return E_NOTIMPL;
335 }
336
337 static const IADsADSystemInfoVtbl IADsADSystemInfo_vtbl =
338 {
339 sysinfo_QueryInterface,
340 sysinfo_AddRef,
341 sysinfo_Release,
342 sysinfo_GetTypeInfoCount,
343 sysinfo_GetTypeInfo,
344 sysinfo_GetIDsOfNames,
345 sysinfo_Invoke,
346 sysinfo_get_UserName,
347 sysinfo_get_ComputerName,
348 sysinfo_get_SiteName,
349 sysinfo_get_DomainShortName,
350 sysinfo_get_DomainDNSName,
351 sysinfo_get_ForestDNSName,
352 sysinfo_get_PDCRoleOwner,
353 sysinfo_get_SchemaRoleOwner,
354 sysinfo_get_IsNativeMode,
355 sysinfo_GetAnyDCName,
356 sysinfo_GetDCSiteName,
357 sysinfo_RefreshSchemaCache,
358 sysinfo_GetTrees
359 };
360
361 static HRESULT ADSystemInfo_create(REFIID riid, void **obj)
362 {
363 AD_sysinfo *sysinfo;
364 HRESULT hr;
365
366 sysinfo = heap_alloc(sizeof(*sysinfo));
367 if (!sysinfo) return E_OUTOFMEMORY;
368
369 sysinfo->IADsADSystemInfo_iface.lpVtbl = &IADsADSystemInfo_vtbl;
370 sysinfo->ref = 1;
371
372 hr = IADsADSystemInfo_QueryInterface(&sysinfo->IADsADSystemInfo_iface, riid, obj);
373 IADsADSystemInfo_Release(&sysinfo->IADsADSystemInfo_iface);
374
375 return hr;
376 }
377
378 struct ldap_attribute
379 {
380 WCHAR *name;
381 WCHAR **values;
382 };
383
384 typedef struct
385 {
386 IADs IADs_iface;
387 IADsOpenDSObject IADsOpenDSObject_iface;
388 IDirectorySearch IDirectorySearch_iface;
389 IDirectoryObject IDirectoryObject_iface;
390 LONG ref;
391 LDAP *ld;
392 BSTR host;
393 BSTR object;
394 ULONG port;
395 ULONG attrs_count, attrs_count_allocated;
396 struct ldap_attribute *attrs;
397 struct attribute_type *at;
398 ULONG at_single_count, at_multiple_count;
399 struct
400 {
401 ADS_SCOPEENUM scope;
402 int pagesize;
403 BOOL cache_results;
404 BOOL attribtypes_only;
405 BOOL tombstone;
406 } search;
407 } LDAP_namespace;
408
409 struct ldap_search_context
410 {
411 LDAPSearch *page;
412 LDAPMessage *res, *entry;
413 BerElement *ber;
414 ULONG count, pos;
415 BOOL add_ADsPath;
416 };
417
418 static inline LDAP_namespace *impl_from_IADs(IADs *iface)
419 {
420 return CONTAINING_RECORD(iface, LDAP_namespace, IADs_iface);
421 }
422
423 static HRESULT WINAPI ldapns_QueryInterface(IADs *iface, REFIID riid, void **obj)
424 {
425 LDAP_namespace *ldap = impl_from_IADs(iface);
426
427 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
428
429 if (!riid || !obj) return E_INVALIDARG;
430
431 if (IsEqualGUID(riid, &IID_IUnknown) ||
432 IsEqualGUID(riid, &IID_IDispatch) ||
433 IsEqualGUID(riid, &IID_IADs))
434 {
435 IADs_AddRef(iface);
436 *obj = iface;
437 return S_OK;
438 }
439
440 if (IsEqualGUID(riid, &IID_IADsOpenDSObject))
441 {
442 IADs_AddRef(iface);
443 *obj = &ldap->IADsOpenDSObject_iface;
444 return S_OK;
445 }
446
447 if (IsEqualGUID(riid, &IID_IDirectorySearch))
448 {
449 if (!ldap->ld || (ldap->object && !wcsicmp(ldap->object, L"rootDSE")))
450 return E_NOINTERFACE;
451
452 IADs_AddRef(iface);
453 *obj = &ldap->IDirectorySearch_iface;
454 return S_OK;
455 }
456
457 if (IsEqualGUID(riid, &IID_IDirectoryObject))
458 {
459 IADs_AddRef(iface);
460 *obj = &ldap->IDirectoryObject_iface;
461 return S_OK;
462 }
463
464 FIXME("interface %s is not implemented\n", debugstr_guid(riid));
465 return E_NOINTERFACE;
466 }
467
468 static ULONG WINAPI ldapns_AddRef(IADs *iface)
469 {
470 LDAP_namespace *ldap = impl_from_IADs(iface);
471 return InterlockedIncrement(&ldap->ref);
472 }
473
474 static void free_attributes(LDAP_namespace *ldap)
475 {
476 ULONG i;
477
478 if (!ldap->attrs) return;
479
480 for (i = 0; i < ldap->attrs_count; i++)
481 {
482 ldap_memfreeW(ldap->attrs[i].name);
483 ldap_value_freeW(ldap->attrs[i].values);
484 }
485
486 heap_free(ldap->attrs);
487 ldap->attrs = NULL;
488 ldap->attrs_count = 0;
489 }
490
491 static ULONG WINAPI ldapns_Release(IADs *iface)
492 {
493 LDAP_namespace *ldap = impl_from_IADs(iface);
494 LONG ref = InterlockedDecrement(&ldap->ref);
495
496 if (!ref)
497 {
498 TRACE("destroying %p\n", iface);
499 if (ldap->ld) ldap_unbind(ldap->ld);
500 SysFreeString(ldap->host);
501 SysFreeString(ldap->object);
502 free_attributes(ldap);
503 free_attribute_types(ldap->at, ldap->at_single_count + ldap->at_multiple_count);
504 heap_free(ldap);
505 }
506
507 return ref;
508 }
509
510 static HRESULT WINAPI ldapns_GetTypeInfoCount(IADs *iface, UINT *count)
511 {
512 FIXME("%p,%p: stub\n", iface, count);
513 return E_NOTIMPL;
514 }
515
516 static HRESULT WINAPI ldapns_GetTypeInfo(IADs *iface, UINT index, LCID lcid, ITypeInfo **info)
517 {
518 FIXME("%p,%u,%#x,%p: stub\n", iface, index, lcid, info);
519 return E_NOTIMPL;
520 }
521
522 static HRESULT WINAPI ldapns_GetIDsOfNames(IADs *iface, REFIID riid, LPOLESTR *names,
523 UINT count, LCID lcid, DISPID *dispid)
524 {
525 FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
526 return E_NOTIMPL;
527 }
528
529 static HRESULT WINAPI ldapns_Invoke(IADs *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
530 DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
531 {
532 FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
533 params, result, excepinfo, argerr);
534 return E_NOTIMPL;
535 }
536
537 static HRESULT WINAPI ldapns_get_Name(IADs *iface, BSTR *retval)
538 {
539 FIXME("%p,%p: stub\n", iface, retval);
540 return E_NOTIMPL;
541 }
542
543 static HRESULT WINAPI ldapns_get_Class(IADs *iface, BSTR *retval)
544 {
545 FIXME("%p,%p: stub\n", iface, retval);
546 return E_NOTIMPL;
547 }
548
549 static HRESULT WINAPI ldapns_get_GUID(IADs *iface, BSTR *retval)
550 {
551 FIXME("%p,%p: stub\n", iface, retval);
552 return E_NOTIMPL;
553 }
554
555 static HRESULT WINAPI ldapns_get_ADsPath(IADs *iface, BSTR *retval)
556 {
557 FIXME("%p,%p: stub\n", iface, retval);
558 return E_NOTIMPL;
559 }
560
561 static HRESULT WINAPI ldapns_get_Parent(IADs *iface, BSTR *retval)
562 {
563 FIXME("%p,%p: stub\n", iface, retval);
564 return E_NOTIMPL;
565 }
566
567 static HRESULT WINAPI ldapns_get_Schema(IADs *iface, BSTR *retval)
568 {
569 FIXME("%p,%p: stub\n", iface, retval);
570 return E_NOTIMPL;
571 }
572
573 static HRESULT WINAPI ldapns_GetInfo(IADs *iface)
574 {
575 HRESULT hr;
576 VARIANT var;
577
578 TRACE("%p\n", iface);
579
580 hr = ADsBuildVarArrayStr(NULL, 0, &var);
581 if (hr == S_OK)
582 {
583 hr = IADs_GetInfoEx(iface, var, 0);
584 VariantClear(&var);
585 }
586 return hr;
587 }
588
589 static HRESULT WINAPI ldapns_SetInfo(IADs *iface)
590 {
591 FIXME("%p: stub\n", iface);
592 return E_NOTIMPL;
593 }
594
595 static HRESULT WINAPI ldapns_Get(IADs *iface, BSTR name, VARIANT *prop)
596 {
597 LDAP_namespace *ldap = impl_from_IADs(iface);
598 HRESULT hr;
599 ULONG i;
600
601 TRACE("%p,%s,%p\n", iface, debugstr_w(name), prop);
602
603 if (!name || !prop) return E_ADS_BAD_PARAMETER;
604
605 if (!ldap->attrs_count)
606 {
607 hr = IADs_GetInfo(iface);
608 if (hr != S_OK) return hr;
609 }
610
611 for (i = 0; i < ldap->attrs_count; i++)
612 {
613 if (!wcsicmp(name, ldap->attrs[i].name))
614 {
615 LONG count = ldap_count_valuesW(ldap->attrs[i].values);
616 if (!count)
617 {
618 V_BSTR(prop) = NULL;
619 V_VT(prop) = VT_BSTR;
620 return S_OK;
621 }
622
623 if (count > 1)
624 {
625 SAFEARRAY *sa;
626 VARIANT item;
627 LONG idx;
628
629 TRACE("attr %s has %u values\n", debugstr_w(ldap->attrs[i].name), count);
630
631 sa = SafeArrayCreateVector(VT_VARIANT, 0, count);
632 if (!sa) return E_OUTOFMEMORY;
633
634 for (idx = 0; idx < count; idx++)
635 {
636 TRACE("=> %s\n", debugstr_w(ldap->attrs[i].values[idx]));
637 V_VT(&item) = VT_BSTR;
638 V_BSTR(&item) = SysAllocString(ldap->attrs[i].values[idx]);
639 if (!V_BSTR(&item))
640 {
641 hr = E_OUTOFMEMORY;
642 goto fail;
643 }
644
645 hr = SafeArrayPutElement(sa, &idx, &item);
646 SysFreeString(V_BSTR(&item));
647 if (hr != S_OK) goto fail;
648 }
649
650 V_VT(prop) = VT_ARRAY | VT_VARIANT;
651 V_ARRAY(prop) = sa;
652 return S_OK;
653 fail:
654 SafeArrayDestroy(sa);
655 return hr;
656 }
657 else
658 {
659 TRACE("=> %s\n", debugstr_w(ldap->attrs[i].values[0]));
660 V_BSTR(prop) = SysAllocString(ldap->attrs[i].values[0]);
661 if (!V_BSTR(prop)) return E_OUTOFMEMORY;
662 V_VT(prop) = VT_BSTR;
663 return S_OK;
664 }
665 }
666 }
667
668 return E_ADS_PROPERTY_NOT_FOUND;
669 }
670
671 static HRESULT WINAPI ldapns_Put(IADs *iface, BSTR name, VARIANT prop)
672 {
673 FIXME("%p,%s,%s: stub\n", iface, debugstr_w(name), wine_dbgstr_variant(&prop));
674 return E_NOTIMPL;
675 }
676
677 static HRESULT WINAPI ldapns_GetEx(IADs *iface, BSTR name, VARIANT *prop)
678 {
679 FIXME("%p,%s,%p: stub\n", iface, debugstr_w(name), prop);
680 return E_NOTIMPL;
681 }
682
683 static HRESULT WINAPI ldapns_PutEx(IADs *iface, LONG code, BSTR name, VARIANT prop)
684 {
685 FIXME("%p,%d,%s,%s: stub\n", iface, code, debugstr_w(name), wine_dbgstr_variant(&prop));
686 return E_NOTIMPL;
687 }
688
689 static HRESULT add_attribute(LDAP_namespace *ldap, WCHAR *name, WCHAR **values)
690 {
691 struct ldap_attribute *new_attrs;
692
693 if (!ldap->attrs)
694 {
695 ldap->attrs = heap_alloc(256 * sizeof(ldap->attrs[0]));
696 if (!ldap->attrs) return E_OUTOFMEMORY;
697 ldap->attrs_count_allocated = 256;
698 }
699 else if (ldap->attrs_count_allocated < ldap->attrs_count + 1)
700 {
701 new_attrs = heap_realloc(ldap->attrs, (ldap->attrs_count_allocated * 2) * sizeof(*new_attrs));
702 if (!new_attrs) return E_OUTOFMEMORY;
703
704 ldap->attrs_count_allocated *= 2;
705 ldap->attrs = new_attrs;
706 }
707
708 ldap->attrs[ldap->attrs_count].name = name;
709 ldap->attrs[ldap->attrs_count].values = values;
710 ldap->attrs_count++;
711
712 return S_OK;
713 }
714
715 static HRESULT WINAPI ldapns_GetInfoEx(IADs *iface, VARIANT prop, LONG reserved)
716 {
717 LDAP_namespace *ldap = impl_from_IADs(iface);
718 HRESULT hr;
719 SAFEARRAY *sa;
720 VARIANT *item;
721 WCHAR **props = NULL, *attr, **values;
722 DWORD i, count, err;
723 LDAPMessage *res = NULL, *entry;
724 BerElement *ber;
725
726 TRACE("%p,%s,%d\n", iface, wine_dbgstr_variant(&prop), reserved);
727
728 free_attributes(ldap);
729
730 if (!ldap->ld) return E_NOTIMPL;
731
732 if (V_VT(&prop) != (VT_ARRAY | VT_VARIANT))
733 return E_ADS_BAD_PARAMETER;
734
735 sa = V_ARRAY(&prop);
736 if (sa->cDims != 1)
737 return E_ADS_BAD_PARAMETER;
738
739 hr = SafeArrayAccessData(sa, (void *)&item);
740 if (hr != S_OK) return hr;
741
742 count = sa->rgsabound[0].cElements;
743 if (count)
744 {
745 props = heap_alloc((count + 1) * sizeof(props[0]));
746 if (!props)
747 {
748 hr = E_OUTOFMEMORY;
749 goto exit;
750 }
751
752 for (i = 0; i < count; i++)
753 {
754 if (V_VT(&item[i]) != VT_BSTR)
755 {
756 hr = E_ADS_BAD_PARAMETER;
757 goto exit;
758 }
759 props[i] = V_BSTR(&item[i]);
760 }
761 props[sa->rgsabound[0].cElements] = NULL;
762 }
763
764 err = ldap_search_sW(ldap->ld, NULL, LDAP_SCOPE_BASE, (WCHAR *)L"(objectClass=*)", props, FALSE, &res);
765 if (err != LDAP_SUCCESS)
766 {
767 TRACE("ldap_search_sW error %#x\n", err);
768 hr = HRESULT_FROM_WIN32(map_ldap_error(err));
769 goto exit;
770 }
771
772 entry = ldap_first_entry(ldap->ld, res);
773 while (entry)
774 {
775 attr = ldap_first_attributeW(ldap->ld, entry, &ber);
776 while (attr)
777 {
778 TRACE("attr: %s\n", debugstr_w(attr));
779
780 values = ldap_get_valuesW(ldap->ld, entry, attr);
781
782 hr = add_attribute(ldap, attr, values);
783 if (hr != S_OK)
784 {
785 ldap_value_freeW(values);
786 ldap_memfreeW(attr);
787 ber_free(ber, 0);
788 goto exit;
789 }
790
791 attr = ldap_next_attributeW(ldap->ld, entry, ber);
792 }
793
794 ber_free(ber, 0);
795 entry = ldap_next_entry(ldap->ld, res);
796 }
797
798 exit:
799 if (res) ldap_msgfree(res);
800 heap_free(props);
801 SafeArrayUnaccessData(sa);
802 return hr;
803 }
804
805 static const IADsVtbl IADs_vtbl =
806 {
807 ldapns_QueryInterface,
808 ldapns_AddRef,
809 ldapns_Release,
810 ldapns_GetTypeInfoCount,
811 ldapns_GetTypeInfo,
812 ldapns_GetIDsOfNames,
813 ldapns_Invoke,
814 ldapns_get_Name,
815 ldapns_get_Class,
816 ldapns_get_GUID,
817 ldapns_get_ADsPath,
818 ldapns_get_Parent,
819 ldapns_get_Schema,
820 ldapns_GetInfo,
821 ldapns_SetInfo,
822 ldapns_Get,
823 ldapns_Put,
824 ldapns_GetEx,
825 ldapns_PutEx,
826 ldapns_GetInfoEx
827 };
828
829 static inline LDAP_namespace *impl_from_IADsOpenDSObject(IADsOpenDSObject *iface)
830 {
831 return CONTAINING_RECORD(iface, LDAP_namespace, IADsOpenDSObject_iface);
832 }
833
834 static HRESULT WINAPI openobj_QueryInterface(IADsOpenDSObject *iface, REFIID riid, void **obj)
835 {
836 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
837
838 if (!riid || !obj) return E_INVALIDARG;
839
840 if (IsEqualGUID(riid, &IID_IADsOpenDSObject) ||
841 IsEqualGUID(riid, &IID_IDispatch) ||
842 IsEqualGUID(riid, &IID_IUnknown))
843 {
844 IADsOpenDSObject_AddRef(iface);
845 *obj = iface;
846 return S_OK;
847 }
848
849 FIXME("interface %s is not implemented\n", debugstr_guid(riid));
850 return E_NOINTERFACE;
851 }
852
853 static ULONG WINAPI openobj_AddRef(IADsOpenDSObject *iface)
854 {
855 LDAP_namespace *ldap = impl_from_IADsOpenDSObject(iface);
856 return IADs_AddRef(&ldap->IADs_iface);
857 }
858
859 static ULONG WINAPI openobj_Release(IADsOpenDSObject *iface)
860 {
861 LDAP_namespace *ldap = impl_from_IADsOpenDSObject(iface);
862 return IADs_Release(&ldap->IADs_iface);
863 }
864
865 static HRESULT WINAPI openobj_GetTypeInfoCount(IADsOpenDSObject *iface, UINT *count)
866 {
867 FIXME("%p,%p: stub\n", iface, count);
868 return E_NOTIMPL;
869 }
870
871 static HRESULT WINAPI openobj_GetTypeInfo(IADsOpenDSObject *iface, UINT index, LCID lcid, ITypeInfo **info)
872 {
873 FIXME("%p,%u,%#x,%p: stub\n", iface, index, lcid, info);
874 return E_NOTIMPL;
875 }
876
877 static HRESULT WINAPI openobj_GetIDsOfNames(IADsOpenDSObject *iface, REFIID riid, LPOLESTR *names,
878 UINT count, LCID lcid, DISPID *dispid)
879 {
880 FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
881 return E_NOTIMPL;
882 }
883
884 static HRESULT WINAPI openobj_Invoke(IADsOpenDSObject *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
885 DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
886 {
887 FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
888 params, result, excepinfo, argerr);
889 return E_NOTIMPL;
890 }
891
892 static HRESULT parse_path(WCHAR *path, BSTR *host, ULONG *port, BSTR *object)
893 {
894 WCHAR *p, *p_host;
895 int host_len;
896
897 if (host) *host = NULL;
898 if (port) *port = 0;
899 if (object) *object = NULL;
900
901 if (wcsnicmp(path, L"LDAP:", 5) != 0)
902 return E_ADS_BAD_PATHNAME;
903
904 p = path + 5;
905 if (!*p) return S_OK;
906
907 if (*p++ != '/' || *p++ != '/' || !*p)
908 return E_ADS_BAD_PATHNAME;
909
910 p_host = p;
911 host_len = 0;
912 while (*p && *p != '/')
913 {
914 if (*p == ':')
915 {
916 ULONG dummy;
917 if (!port) port = &dummy;
918 *port = wcstol(p + 1, &p, 10);
919 if (*p && *p != '/') return E_ADS_BAD_PATHNAME;
920 }
921 else
922 {
923 p++;
924 host_len++;
925 }
926 }
927 if (host_len == 0) return E_ADS_BAD_PATHNAME;
928
929 if (host)
930 {
931 *host = SysAllocStringLen(p_host, host_len);
932 if (!*host) return E_OUTOFMEMORY;
933 }
934
935 if (!*p) return S_OK;
936
937 if (*p++ != '/' || !*p)
938 {
939 SysFreeString(*host);
940 return E_ADS_BAD_PATHNAME;
941 }
942
943 if (object)
944 {
945 *object = SysAllocString(p);
946 if (!*object)
947 {
948 SysFreeString(*host);
949 return E_OUTOFMEMORY;
950 }
951 }
952
953 return S_OK;
954 }
955
956 static HRESULT WINAPI openobj_OpenDSObject(IADsOpenDSObject *iface, BSTR path, BSTR user, BSTR password,
957 LONG flags, IDispatch **obj)
958 {
959 BSTR host, object;
960 ULONG port;
961 IADs *ads;
962 LDAP *ld = NULL;
963 HRESULT hr;
964 ULONG err, at_single_count = 0, at_multiple_count = 0;
965 struct attribute_type *at = NULL;
966
967 TRACE("%p,%s,%s,%p,%08x,%p\n", iface, debugstr_w(path), debugstr_w(user), password, flags, obj);
968
969 hr = parse_path(path, &host, &port, &object);
970 if (hr != S_OK) return hr;
971
972 TRACE("host %s, port %u, object %s\n", debugstr_w(host), port, debugstr_w(object));
973
974 if (host)
975 {
976 int version;
977
978 if (!wcsicmp(host, L"rootDSE"))
979 {
980 DOMAIN_CONTROLLER_INFOW *dcinfo;
981
982 if (object)
983 {
984 hr = E_ADS_BAD_PATHNAME;
985 goto fail;
986 }
987
988 object = host;
989
990 err = DsGetDcNameW(NULL, NULL, NULL, NULL, DS_RETURN_DNS_NAME, &dcinfo);
991 if (err != ERROR_SUCCESS)
992 {
993 hr = HRESULT_FROM_WIN32(LdapGetLastError());
994 goto fail;
995 }
996
997 host = SysAllocString(dcinfo->DomainName);
998 NetApiBufferFree(dcinfo);
999
1000 if (!host)
1001 {
1002 hr = E_OUTOFMEMORY;
1003 goto fail;
1004 }
1005 }
1006
1007 ld = ldap_initW(host, port);
1008 if (!ld)
1009 {
1010 hr = HRESULT_FROM_WIN32(LdapGetLastError());
1011 goto fail;
1012 }
1013
1014 version = LDAP_VERSION3;
1015 err = ldap_set_optionW(ld, LDAP_OPT_PROTOCOL_VERSION, &version);
1016 if (err != LDAP_SUCCESS)
1017 {
1018 hr = HRESULT_FROM_WIN32(map_ldap_error(err));
1019 ldap_unbind(ld);
1020 goto fail;
1021 }
1022
1023 err = ldap_connect(ld, NULL);
1024 if (err != LDAP_SUCCESS)
1025 {
1026 hr = HRESULT_FROM_WIN32(map_ldap_error(err));
1027 ldap_unbind(ld);
1028 goto fail;
1029 }
1030
1031 if (flags & ADS_SECURE_AUTHENTICATION)
1032 {
1033 SEC_WINNT_AUTH_IDENTITY_W id;
1034
1035 id.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
1036 id.Domain = (unsigned short *)host;
1037 id.DomainLength = wcslen(host);
1038 id.User = (unsigned short *)user;
1039 id.UserLength = user ? wcslen(user) : 0;
1040 id.Password = (unsigned short *)password;
1041 id.PasswordLength = password ? wcslen(password) : 0;
1042
1043 err = ldap_bind_sW(ld, NULL, (WCHAR *)&id, LDAP_AUTH_NEGOTIATE);
1044 if (err != LDAP_SUCCESS)
1045 {
1046 TRACE("ldap_bind_sW error %#x\n", err);
1047 hr = HRESULT_FROM_WIN32(map_ldap_error(err));
1048 ldap_unbind(ld);
1049 goto fail;
1050 }
1051 }
1052 else
1053 {
1054 err = ldap_simple_bind_sW(ld, user, password);
1055 if (err != LDAP_SUCCESS)
1056 {
1057 TRACE("ldap_simple_bind_sW error %#x\n", err);
1058 hr = HRESULT_FROM_WIN32(map_ldap_error(err));
1059 ldap_unbind(ld);
1060 goto fail;
1061 }
1062 }
1063
1064 at = load_schema(ld, &at_single_count, &at_multiple_count);
1065 }
1066
1067 hr = LDAPNamespace_create(&IID_IADs, (void **)&ads);
1068 if (hr == S_OK)
1069 {
1070 LDAP_namespace *ldap = impl_from_IADs(ads);
1071 ldap->ld = ld;
1072 ldap->host = host;
1073 ldap->port = port;
1074 ldap->object = object;
1075 ldap->at = at;
1076 ldap->at_single_count = at_single_count;
1077 ldap->at_multiple_count = at_multiple_count;
1078 hr = IADs_QueryInterface(ads, &IID_IDispatch, (void **)obj);
1079 IADs_Release(ads);
1080 return hr;
1081 }
1082
1083 fail:
1084 SysFreeString(host);
1085 SysFreeString(object);
1086
1087 return hr;
1088 }
1089
1090 static const IADsOpenDSObjectVtbl IADsOpenDSObject_vtbl =
1091 {
1092 openobj_QueryInterface,
1093 openobj_AddRef,
1094 openobj_Release,
1095 openobj_GetTypeInfoCount,
1096 openobj_GetTypeInfo,
1097 openobj_GetIDsOfNames,
1098 openobj_Invoke,
1099 openobj_OpenDSObject
1100 };
1101
1102 static inline LDAP_namespace *impl_from_IDirectorySearch(IDirectorySearch *iface)
1103 {
1104 return CONTAINING_RECORD(iface, LDAP_namespace, IDirectorySearch_iface);
1105 }
1106
1107 static HRESULT WINAPI search_QueryInterface(IDirectorySearch *iface, REFIID riid, void **obj)
1108 {
1109 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
1110
1111 if (!riid || !obj) return E_INVALIDARG;
1112
1113 if (IsEqualGUID(riid, &IID_IDirectorySearch) ||
1114 IsEqualGUID(riid, &IID_IUnknown))
1115 {
1116 IDirectorySearch_AddRef(iface);
1117 *obj = iface;
1118 return S_OK;
1119 }
1120
1121 FIXME("interface %s is not implemented\n", debugstr_guid(riid));
1122 return E_NOINTERFACE;
1123 }
1124
1125 static ULONG WINAPI search_AddRef(IDirectorySearch *iface)
1126 {
1127 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1128 return IADs_AddRef(&ldap->IADs_iface);
1129 }
1130
1131 static ULONG WINAPI search_Release(IDirectorySearch *iface)
1132 {
1133 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1134 return IADs_Release(&ldap->IADs_iface);
1135 }
1136
1137 static HRESULT WINAPI search_SetSearchPreference(IDirectorySearch *iface, PADS_SEARCHPREF_INFO prefs, DWORD count)
1138 {
1139 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1140 HRESULT hr = S_OK;
1141 DWORD i;
1142
1143 TRACE("%p,%p,%u\n", iface, prefs, count);
1144
1145 for (i = 0; i < count; i++)
1146 {
1147 switch (prefs[i].dwSearchPref)
1148 {
1149 case ADS_SEARCHPREF_SEARCH_SCOPE:
1150 if (prefs[i].vValue.dwType != ADSTYPE_INTEGER)
1151 {
1152 FIXME("ADS_SEARCHPREF_SEARCH_SCOPE: unsupported dwType %d\n", prefs[i].vValue.dwType);
1153 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1154 break;
1155 }
1156
1157 switch (prefs[i].vValue.u.Integer)
1158 {
1159 case ADS_SCOPE_BASE:
1160 case ADS_SCOPE_ONELEVEL:
1161 case ADS_SCOPE_SUBTREE:
1162 TRACE("SEARCH_SCOPE: %d\n", prefs[i].vValue.u.Integer);
1163 ldap->search.scope = prefs[i].vValue.u.Integer;
1164 prefs[i].dwStatus = ADS_STATUS_S_OK;
1165 break;
1166
1167 default:
1168 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1169 break;
1170 }
1171 break;
1172
1173 case ADS_SEARCHPREF_SECURITY_MASK:
1174 {
1175 int security_mask;
1176 ULONG err;
1177 BerElement *ber;
1178 struct berval *berval;
1179 LDAPControlW *ctrls[2], mask;
1180
1181 if (prefs[i].vValue.dwType != ADSTYPE_INTEGER)
1182 {
1183 FIXME("ADS_SEARCHPREF_SECURITY_MASK: not supported dwType %d\n", prefs[i].vValue.dwType);
1184 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1185 break;
1186 }
1187
1188 TRACE("SECURITY_MASK: %08x\n", prefs[i].vValue.u.Integer);
1189 security_mask = prefs[i].vValue.u.Integer;
1190 if (!security_mask)
1191 security_mask = ADS_SECURITY_INFO_OWNER;
1192
1193 ber = ber_alloc_t(LBER_USE_DER);
1194 if (!ber || ber_printf(ber, (char *)"{i}", security_mask) == -1 || ber_flatten(ber, &berval) == -1)
1195 {
1196 ber_free(ber, 1);
1197 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREF;
1198 break;
1199 }
1200 TRACE("ber: %s\n", debugstr_an(berval->bv_val, berval->bv_len));
1201
1202 mask.ldctl_oid = (WCHAR *)L"1.2.840.113556.1.4.801";
1203 mask.ldctl_iscritical = TRUE;
1204 mask.ldctl_value.bv_val = berval->bv_val;
1205 mask.ldctl_value.bv_len = berval->bv_len;
1206 ctrls[0] = &mask;
1207 ctrls[1] = NULL;
1208 err = ldap_set_optionW(ldap->ld, LDAP_OPT_SERVER_CONTROLS, ctrls);
1209 if (err != LDAP_SUCCESS)
1210 {
1211 TRACE("ldap_set_option error %#x\n", err);
1212 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREF;
1213 hr = S_ADS_ERRORSOCCURRED;
1214 }
1215 else
1216 prefs[i].dwStatus = ADS_STATUS_S_OK;
1217
1218 ber_bvfree(berval);
1219 ber_free(ber, 1);
1220 break;
1221 }
1222
1223 case ADS_SEARCHPREF_PAGESIZE:
1224 if (prefs[i].vValue.dwType != ADSTYPE_INTEGER)
1225 {
1226 FIXME("ADS_SEARCHPREF_PAGESIZE: unsupported dwType %d\n", prefs[i].vValue.dwType);
1227 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1228 break;
1229 }
1230
1231 TRACE("PAGESIZE: %d\n", prefs[i].vValue.u.Integer);
1232 ldap->search.pagesize = prefs[i].vValue.u.Integer;
1233 prefs[i].dwStatus = ADS_STATUS_S_OK;
1234 break;
1235
1236 case ADS_SEARCHPREF_CACHE_RESULTS:
1237 if (prefs[i].vValue.dwType != ADSTYPE_BOOLEAN)
1238 {
1239 FIXME("ADS_SEARCHPREF_CACHE_RESULTS: unsupported dwType %d\n", prefs[i].vValue.dwType);
1240 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1241 break;
1242 }
1243
1244 TRACE("CACHE_RESULTS: %d\n", prefs[i].vValue.u.Boolean);
1245 ldap->search.cache_results = prefs[i].vValue.u.Boolean;
1246 prefs[i].dwStatus = ADS_STATUS_S_OK;
1247 break;
1248
1249 case ADS_SEARCHPREF_ATTRIBTYPES_ONLY:
1250 if (prefs[i].vValue.dwType != ADSTYPE_BOOLEAN)
1251 {
1252 FIXME("ADS_SEARCHPREF_ATTRIBTYPES_ONLY: unsupported dwType %d\n", prefs[i].vValue.dwType);
1253 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1254 break;
1255 }
1256
1257 TRACE("ATTRIBTYPES_ONLY: %d\n", prefs[i].vValue.u.Boolean);
1258 ldap->search.attribtypes_only = prefs[i].vValue.u.Boolean;
1259 prefs[i].dwStatus = ADS_STATUS_S_OK;
1260 break;
1261
1262 case ADS_SEARCHPREF_TOMBSTONE:
1263 if (prefs[i].vValue.dwType != ADSTYPE_BOOLEAN)
1264 {
1265 FIXME("ADS_SEARCHPREF_TOMBSTONE: unsupported dwType %d\n", prefs[i].vValue.dwType);
1266 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREFVALUE;
1267 break;
1268 }
1269
1270 TRACE("TOMBSTONE: %d\n", prefs[i].vValue.u.Boolean);
1271 ldap->search.tombstone = prefs[i].vValue.u.Boolean;
1272 prefs[i].dwStatus = ADS_STATUS_S_OK;
1273 break;
1274
1275 default:
1276 FIXME("pref %d, type %u: stub\n", prefs[i].dwSearchPref, prefs[i].vValue.dwType);
1277 prefs[i].dwStatus = ADS_STATUS_INVALID_SEARCHPREF;
1278 break;
1279 }
1280 }
1281
1282 return hr;
1283 }
1284
1285 static HRESULT WINAPI search_ExecuteSearch(IDirectorySearch *iface, LPWSTR filter, LPWSTR *names,
1286 DWORD count, PADS_SEARCH_HANDLE res)
1287 {
1288 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1289 ULONG err, i;
1290 WCHAR **props;
1291 LDAPControlW **ctrls = NULL, *ctrls_a[2], tombstone;
1292 struct ldap_search_context *ldap_ctx;
1293
1294 TRACE("%p,%s,%p,%u,%p\n", iface, debugstr_w(filter), names, count, res);
1295
1296 if (!res) return E_ADS_BAD_PARAMETER;
1297
1298 ldap_ctx = heap_alloc_zero(sizeof(*ldap_ctx));
1299 if (!ldap_ctx) return E_OUTOFMEMORY;
1300
1301 if (count == 0xffffffff)
1302 props = NULL;
1303 else
1304 {
1305 if (count && !names) return E_ADS_BAD_PARAMETER;
1306
1307 props = heap_alloc((count + 1) * sizeof(props[0]));
1308 if (!props)
1309 {
1310 heap_free(ldap_ctx);
1311 return E_OUTOFMEMORY;
1312 }
1313
1314 for (i = 0; i < count; i++)
1315 {
1316 TRACE("=> %s\n", debugstr_w(names[i]));
1317 props[i] = names[i];
1318 }
1319
1320 props[count] = NULL;
1321 }
1322
1323 if (ldap->search.tombstone)
1324 {
1325 tombstone.ldctl_oid = (WCHAR *)L"1.2.840.113556.1.4.417";
1326 tombstone.ldctl_iscritical = TRUE;
1327 tombstone.ldctl_value.bv_val = NULL;
1328 tombstone.ldctl_value.bv_len = 0;
1329 ctrls_a[0] = &tombstone;
1330 ctrls_a[1] = NULL;
1331 ctrls = ctrls_a;
1332 }
1333
1334 if (ldap->search.pagesize)
1335 {
1336 ldap_ctx->page = ldap_search_init_pageW(ldap->ld, ldap->object, ldap->search.scope,
1337 filter, props, ldap->search.attribtypes_only,
1338 ctrls, NULL, 0, 0, NULL);
1339 if (ldap_ctx->page)
1340 err = ldap_get_next_page_s(ldap->ld, ldap_ctx->page, NULL,
1341 ldap->search.pagesize, &count, &ldap_ctx->res);
1342 else
1343 err = LDAP_NO_MEMORY;
1344 }
1345 else
1346 err = ldap_search_ext_sW(ldap->ld, ldap->object, ldap->search.scope, filter, props,
1347 ldap->search.attribtypes_only, ctrls, NULL, NULL, 0, &ldap_ctx->res);
1348 heap_free(props);
1349 if (err != LDAP_SUCCESS)
1350 {
1351 TRACE("ldap_search_sW error %#x\n", err);
1352 if (ldap_ctx->page)
1353 ldap_search_abandon_page(ldap->ld, ldap_ctx->page);
1354 heap_free(ldap_ctx);
1355 return HRESULT_FROM_WIN32(map_ldap_error(err));
1356 }
1357
1358 *res = ldap_ctx;
1359 return S_OK;
1360 }
1361
1362 static HRESULT WINAPI search_AbandonSearch(IDirectorySearch *iface, ADS_SEARCH_HANDLE res)
1363 {
1364 FIXME("%p,%p: stub\n", iface, res);
1365 return E_NOTIMPL;
1366 }
1367
1368 static HRESULT WINAPI search_GetFirstRow(IDirectorySearch *iface, ADS_SEARCH_HANDLE res)
1369 {
1370 struct ldap_search_context *ldap_ctx = res;
1371
1372 TRACE("%p,%p\n", iface, res);
1373
1374 if (!res) return E_ADS_BAD_PARAMETER;
1375
1376 ldap_ctx->entry = NULL;
1377
1378 return IDirectorySearch_GetNextRow(iface, res);
1379 }
1380
1381 static HRESULT WINAPI search_GetNextRow(IDirectorySearch *iface, ADS_SEARCH_HANDLE res)
1382 {
1383 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1384 struct ldap_search_context *ldap_ctx = res;
1385
1386 TRACE("%p,%p\n", iface, res);
1387
1388 if (!res) return E_ADS_BAD_PARAMETER;
1389
1390 if (!ldap_ctx->entry)
1391 {
1392 ldap_ctx->count = ldap_count_entries(ldap->ld, ldap_ctx->res);
1393 ldap_ctx->pos = 0;
1394
1395 if (ldap_ctx->pos >= ldap_ctx->count)
1396 return S_ADS_NOMORE_ROWS;
1397
1398 ldap_ctx->entry = ldap_first_entry(ldap->ld, ldap_ctx->res);
1399 }
1400 else
1401 {
1402 if (ldap_ctx->pos >= ldap_ctx->count)
1403 {
1404 if (ldap_ctx->page)
1405 {
1406 ULONG err, count;
1407
1408 ldap_msgfree(ldap_ctx->res);
1409 ldap_ctx->res = NULL;
1410
1411 err = ldap_get_next_page_s(ldap->ld, ldap_ctx->page, NULL, ldap->search.pagesize, &count, &ldap_ctx->res);
1412 if (err == LDAP_SUCCESS)
1413 {
1414 ldap_ctx->count = ldap_count_entries(ldap->ld, ldap_ctx->res);
1415 ldap_ctx->pos = 0;
1416
1417 if (ldap_ctx->pos >= ldap_ctx->count)
1418 return S_ADS_NOMORE_ROWS;
1419
1420 ldap_ctx->entry = ldap_first_entry(ldap->ld, ldap_ctx->res);
1421 goto exit;
1422 }
1423
1424 if (err != LDAP_NO_RESULTS_RETURNED)
1425 {
1426 TRACE("ldap_get_next_page_s error %#x\n", err);
1427 return HRESULT_FROM_WIN32(map_ldap_error(err));
1428 }
1429 /* fall through */
1430 }
1431
1432 return S_ADS_NOMORE_ROWS;
1433 }
1434
1435 ldap_ctx->entry = ldap_next_entry(ldap->ld, ldap_ctx->entry);
1436 }
1437
1438 exit:
1439 if (!ldap_ctx->entry)
1440 return S_ADS_NOMORE_ROWS;
1441
1442 ldap_ctx->pos++;
1443 ldap_ctx->ber = NULL;
1444
1445 return S_OK;
1446 }
1447
1448 static HRESULT WINAPI search_GetPreviousRow(IDirectorySearch *iface, ADS_SEARCH_HANDLE res)
1449 {
1450 FIXME("%p,%p: stub\n", iface, res);
1451 return E_NOTIMPL;
1452 }
1453
1454 static HRESULT WINAPI search_GetNextColumnName(IDirectorySearch *iface, ADS_SEARCH_HANDLE res, LPWSTR *name)
1455 {
1456 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1457 struct ldap_search_context *ldap_ctx = res;
1458 WCHAR *attr;
1459
1460 TRACE("%p,%p,%p\n", iface, res, name);
1461
1462 if (!name || !ldap_ctx || !ldap_ctx->entry) return E_ADS_BAD_PARAMETER;
1463
1464 if (!ldap_ctx->ber)
1465 {
1466 attr = ldap_first_attributeW(ldap->ld, ldap_ctx->entry, &ldap_ctx->ber);
1467 ldap_ctx->add_ADsPath = TRUE;
1468 }
1469 else
1470 attr = ldap_next_attributeW(ldap->ld, ldap_ctx->entry, ldap_ctx->ber);
1471
1472 if (attr)
1473 {
1474 TRACE("=> %s\n", debugstr_w(attr));
1475 *name = AllocADsStr(attr);
1476 ldap_memfreeW(attr);
1477 return *name ? S_OK : E_OUTOFMEMORY;
1478 }
1479 else if (ldap_ctx->add_ADsPath)
1480 {
1481 ldap_ctx->add_ADsPath = FALSE;
1482 *name = AllocADsStr((WCHAR *)L"ADsPath");
1483 TRACE("=> %s\n", debugstr_w(*name));
1484 return *name ? S_OK : E_OUTOFMEMORY;
1485 }
1486
1487 *name = NULL;
1488 return S_ADS_NOMORE_COLUMNS;
1489 }
1490
1491 static HRESULT add_column_values(LDAP_namespace *ldap, struct ldap_search_context *ldap_ctx,
1492 LPWSTR name, ADS_SEARCH_COLUMN *col)
1493 {
1494 ADSTYPEENUM type;
1495 DWORD i, count;
1496
1497 type = get_schema_type(name, ldap->at, ldap->at_single_count, ldap->at_multiple_count);
1498 TRACE("%s => type %d\n", debugstr_w(name), type);
1499
1500 switch (type)
1501 {
1502 default:
1503 FIXME("no special handling for type %d\n", type);
1504 /* fall through */
1505 case ADSTYPE_DN_STRING:
1506 case ADSTYPE_CASE_EXACT_STRING:
1507 case ADSTYPE_CASE_IGNORE_STRING:
1508 case ADSTYPE_PRINTABLE_STRING:
1509 {
1510 WCHAR **values = ldap_get_valuesW(ldap->ld, ldap_ctx->entry, name);
1511 if (!values)
1512 return E_ADS_COLUMN_NOT_SET;
1513 count = ldap_count_valuesW(values);
1514
1515 col->pADsValues = heap_alloc_zero(count * sizeof(col->pADsValues[0]));
1516 if (!col->pADsValues)
1517 {
1518 ldap_value_freeW(values);
1519 return E_OUTOFMEMORY;
1520 }
1521
1522 for (i = 0; i < count; i++)
1523 {
1524 TRACE("=> %s\n", debugstr_w(values[i]));
1525 col->pADsValues[i].dwType = type;
1526 col->pADsValues[i].u.CaseIgnoreString = values[i];
1527 }
1528
1529 col->hReserved = values;
1530 break;
1531 }
1532
1533 case ADSTYPE_BOOLEAN:
1534 {
1535 WCHAR **values = ldap_get_valuesW(ldap->ld, ldap_ctx->entry, name);
1536 if (!values)
1537 return E_ADS_COLUMN_NOT_SET;
1538 count = ldap_count_valuesW(values);
1539
1540 col->pADsValues = heap_alloc_zero(count * sizeof(col->pADsValues[0]));
1541 if (!col->pADsValues)
1542 {
1543 ldap_value_freeW(values);
1544 return E_OUTOFMEMORY;
1545 }
1546
1547 for (i = 0; i < count; i++)
1548 {
1549 col->pADsValues[i].dwType = type;
1550
1551 if (!wcsicmp(values[i], L"TRUE"))
1552 col->pADsValues[i].u.Boolean = 1;
1553 else if (!wcsicmp(values[i], L"FALSE"))
1554 col->pADsValues[i].u.Boolean = 0;
1555 else
1556 {
1557 FIXME("not recognized boolean value %s\n", debugstr_w(values[i]));
1558 col->pADsValues[i].u.Boolean = 0;
1559 }
1560 TRACE("%s => %d\n", debugstr_w(values[i]), col->pADsValues[i].u.Boolean);
1561 }
1562
1563 ldap_value_freeW(values);
1564 col->hReserved = NULL;
1565 break;
1566 }
1567
1568 case ADSTYPE_INTEGER:
1569 case ADSTYPE_LARGE_INTEGER:
1570 {
1571 struct berval **values = ldap_get_values_lenW(ldap->ld, ldap_ctx->entry, name);
1572 if (!values)
1573 return E_ADS_COLUMN_NOT_SET;
1574 count = ldap_count_values_len(values);
1575
1576 col->pADsValues = heap_alloc_zero(count * sizeof(col->pADsValues[0]));
1577 if (!col->pADsValues)
1578 {
1579 ldap_value_free_len(values);
1580 return E_OUTOFMEMORY;
1581 }
1582
1583 for (i = 0; i < count; i++)
1584 {
1585 col->pADsValues[i].dwType = type;
1586
1587 if (type == ADSTYPE_LARGE_INTEGER)
1588 {
1589 col->pADsValues[i].u.LargeInteger.QuadPart = _atoi64(values[i]->bv_val);
1590 TRACE("%s => %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len), wine_dbgstr_longlong(col->pADsValues[i].u.LargeInteger.QuadPart));
1591 }
1592 else
1593 {
1594 col->pADsValues[i].u.Integer = atol(values[i]->bv_val);
1595 TRACE("%s => %d\n", debugstr_an(values[i]->bv_val, values[i]->bv_len), col->pADsValues[i].u.Integer);
1596 }
1597 }
1598
1599 ldap_value_free_len(values);
1600 col->hReserved = NULL;
1601 break;
1602 }
1603
1604 case ADSTYPE_OCTET_STRING:
1605 case ADSTYPE_NT_SECURITY_DESCRIPTOR:
1606 {
1607 struct berval **values = ldap_get_values_lenW(ldap->ld, ldap_ctx->entry, name);
1608 if (!values)
1609 return E_ADS_COLUMN_NOT_SET;
1610 count = ldap_count_values_len(values);
1611
1612 col->pADsValues = heap_alloc_zero(count * sizeof(col->pADsValues[0]));
1613 if (!col->pADsValues)
1614 {
1615 ldap_value_free_len(values);
1616 return E_OUTOFMEMORY;
1617 }
1618
1619 for (i = 0; i < count; i++)
1620 {
1621 TRACE("=> %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len));
1622 col->pADsValues[i].dwType = type;
1623 col->pADsValues[i].u.OctetString.dwLength = values[i]->bv_len;
1624 col->pADsValues[i].u.OctetString.lpValue = (BYTE *)values[i]->bv_val;
1625 }
1626
1627 col->hReserved = values;
1628 break;
1629 }
1630
1631 case ADSTYPE_UTC_TIME:
1632 {
1633 struct berval **values = ldap_get_values_lenW(ldap->ld, ldap_ctx->entry, name);
1634 if (!values)
1635 return E_ADS_COLUMN_NOT_SET;
1636 count = ldap_count_values_len(values);
1637
1638 col->pADsValues = heap_alloc_zero(count * sizeof(col->pADsValues[0]));
1639 if (!col->pADsValues)
1640 {
1641 ldap_value_free_len(values);
1642 return E_OUTOFMEMORY;
1643 }
1644
1645 for (i = 0; i < count; i++)
1646 {
1647 col->pADsValues[i].dwType = type;
1648 if (values[i]->bv_len < 14 ||
1649 _snscanf_l(values[i]->bv_val, values[i]->bv_len, "%04hu%02hu%02hu%02hu%02hu%02hu", NULL,
1650 &col->pADsValues[i].u.UTCTime.wYear, &col->pADsValues[i].u.UTCTime.wMonth,
1651 &col->pADsValues[i].u.UTCTime.wDay, &col->pADsValues[i].u.UTCTime.wHour,
1652 &col->pADsValues[i].u.UTCTime.wMinute, &col->pADsValues[i].u.UTCTime.wSecond) != 6)
1653 {
1654 FIXME("not recognized UTCTime: %s\n", debugstr_an(values[i]->bv_val, values[i]->bv_len));
1655 memset(&col->pADsValues[i].u.UTCTime, 0, sizeof(col->pADsValues[i].u.UTCTime));
1656 continue;
1657 }
1658
1659 if ((values[i]->bv_val[14] != '.' && values[i]->bv_val[14] != ',') ||
1660 values[i]->bv_val[15] != '0' || values[i]->bv_val[16] != 'Z')
1661 FIXME("not handled time zone: %s\n", debugstr_an(values[i]->bv_val + 14, values[i]->bv_len - 14));
1662
1663 TRACE("%s => %02u.%02u.%04u %02u:%02u:%02u\n", debugstr_an(values[i]->bv_val, values[i]->bv_len),
1664 col->pADsValues[i].u.UTCTime.wDay, col->pADsValues[i].u.UTCTime.wMonth,
1665 col->pADsValues[i].u.UTCTime.wYear, col->pADsValues[i].u.UTCTime.wHour,
1666 col->pADsValues[i].u.UTCTime.wMinute, col->pADsValues[i].u.UTCTime.wSecond);
1667 }
1668
1669 ldap_value_free_len(values);
1670 col->hReserved = NULL;
1671 break;
1672 }
1673
1674 case ADSTYPE_DN_WITH_BINARY:
1675 {
1676 static const BYTE hex2bin[] =
1677 {
1678 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
1679 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
1680 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
1681 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
1682 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
1683 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
1684 0,10,11,12,13,14,15 /* 0x60 */
1685 };
1686 ADS_DN_WITH_BINARY *dnb;
1687 WCHAR **values = ldap_get_valuesW(ldap->ld, ldap_ctx->entry, name);
1688 if (!values)
1689 return E_ADS_COLUMN_NOT_SET;
1690 count = ldap_count_valuesW(values);
1691
1692 col->pADsValues = heap_alloc_zero(count * (sizeof(col->pADsValues[0]) + sizeof(col->pADsValues[0].u.pDNWithBinary[0])));
1693 if (!col->pADsValues)
1694 {
1695 ldap_value_freeW(values);
1696 return E_OUTOFMEMORY;
1697 }
1698
1699 dnb = (ADS_DN_WITH_BINARY *)(col->pADsValues + count);
1700
1701 for (i = 0; i < count; i++)
1702 {
1703 WCHAR *p = values[i];
1704 DWORD n;
1705
1706 col->pADsValues[i].dwType = type;
1707 col->pADsValues[i].u.pDNWithBinary = dnb++;
1708
1709 if ((p[0] != 'b' && p[0] != 'B') || p[1] != ':')
1710 FIXME("wrong DN with binary tag '%c%c'\n", p[0], p[1]);
1711 p += 2;
1712
1713 col->pADsValues[i].u.pDNWithBinary->dwLength = wcstol(p, &p, 10) / 2;
1714 if (*p != ':')
1715 FIXME("wrong DN with binary separator '%c'\n", *p);
1716 p++;
1717 col->pADsValues[i].u.pDNWithBinary->lpBinaryValue = (BYTE *)p;
1718 /* decode values in-place */
1719 for (n = 0; n < col->pADsValues[i].u.pDNWithBinary->dwLength; n++, p += 2)
1720 {
1721 BYTE b;
1722
1723 if (p[0] > 'f' || (p[0] != '0' && !hex2bin[p[0]]) ||
1724 p[1] > 'f' || (p[1] != '0' && !hex2bin[p[1]]))
1725 {
1726 FIXME("bad hex encoding at %s\n", debugstr_w(p));
1727 continue;
1728 }
1729
1730 b = (hex2bin[p[0]] << 4) | hex2bin[p[1]];
1731 col->pADsValues[i].u.pDNWithBinary->lpBinaryValue[n] = b;
1732 }
1733 if (*p != ':')
1734 FIXME("wrong DN with binary separator '%c'\n", *p);
1735 col->pADsValues[i].u.pDNWithBinary->pszDNString = p + 1;
1736
1737 TRACE("%s => %u,%s,%s\n", debugstr_w(values[i]),
1738 col->pADsValues[i].u.pDNWithBinary->dwLength,
1739 debugstr_an((char *)col->pADsValues[i].u.pDNWithBinary->lpBinaryValue, col->pADsValues[i].u.pDNWithBinary->dwLength),
1740 debugstr_w(col->pADsValues[i].u.pDNWithBinary->pszDNString));
1741 }
1742
1743 col->hReserved = values;
1744 break;
1745 }
1746 }
1747
1748 col->dwADsType = type;
1749 col->dwNumValues = count;
1750 col->pszAttrName = strdupW(name);
1751
1752 return S_OK;
1753 }
1754
1755 static HRESULT WINAPI search_GetColumn(IDirectorySearch *iface, ADS_SEARCH_HANDLE res,
1756 LPWSTR name, PADS_SEARCH_COLUMN col)
1757 {
1758 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1759 struct ldap_search_context *ldap_ctx = res;
1760 HRESULT hr;
1761 ULONG count;
1762
1763 TRACE("%p,%p,%s,%p\n", iface, res, debugstr_w(name), col);
1764
1765 if (!res || !name || !ldap_ctx->entry) return E_ADS_BAD_PARAMETER;
1766
1767 memset(col, 0, sizeof(*col));
1768
1769 if (!wcsicmp(name, L"ADsPath"))
1770 {
1771 WCHAR *dn = ldap_get_dnW(ldap->ld, ldap_ctx->entry);
1772
1773 col->pADsValues = heap_alloc(sizeof(col->pADsValues[0]));
1774 if (!col->pADsValues)
1775 {
1776 hr = E_OUTOFMEMORY;
1777 goto exit;
1778 }
1779
1780 count = sizeof(L"LDAP://") + (wcslen(ldap->host) + 1 /* '/' */) * sizeof(WCHAR);
1781 if (dn) count += wcslen(dn) * sizeof(WCHAR);
1782
1783 col->pADsValues[0].u.CaseIgnoreString = heap_alloc(count);
1784 if (!col->pADsValues[0].u.CaseIgnoreString)
1785 {
1786 hr = E_OUTOFMEMORY;
1787 goto exit;
1788 }
1789
1790 wcscpy(col->pADsValues[0].u.CaseIgnoreString, L"LDAP://");
1791 wcscat(col->pADsValues[0].u.CaseIgnoreString, ldap->host);
1792 wcscat(col->pADsValues[0].u.CaseIgnoreString, L"/");
1793 if (dn) wcscat(col->pADsValues[0].u.CaseIgnoreString, dn);
1794 col->pADsValues[0].dwType = ADSTYPE_CASE_IGNORE_STRING;
1795 col->dwADsType = ADSTYPE_CASE_IGNORE_STRING;
1796 col->dwNumValues = 1;
1797 col->pszAttrName = strdupW(name);
1798 col->hReserved = NULL;
1799
1800 TRACE("=> %s\n", debugstr_w(col->pADsValues[0].u.CaseIgnoreString));
1801 hr = S_OK;
1802 exit:
1803 ldap_memfreeW(dn);
1804 return hr;
1805 }
1806
1807 return add_column_values(ldap, ldap_ctx, name, col);
1808 }
1809
1810 static HRESULT WINAPI search_FreeColumn(IDirectorySearch *iface, PADS_SEARCH_COLUMN col)
1811 {
1812 TRACE("%p,%p\n", iface, col);
1813
1814 if (!col) return E_ADS_BAD_PARAMETER;
1815
1816 if (!wcsicmp(col->pszAttrName, L"ADsPath"))
1817 heap_free(col->pADsValues[0].u.CaseIgnoreString);
1818 heap_free(col->pADsValues);
1819 heap_free(col->pszAttrName);
1820
1821 if (col->hReserved)
1822 {
1823 if (col->dwADsType == ADSTYPE_OCTET_STRING || col->dwADsType == ADSTYPE_NT_SECURITY_DESCRIPTOR)
1824 ldap_value_free_len(col->hReserved);
1825 else
1826 ldap_value_freeW(col->hReserved);
1827 }
1828
1829 return S_OK;
1830 }
1831
1832 static HRESULT WINAPI search_CloseSearchHandle(IDirectorySearch *iface, ADS_SEARCH_HANDLE res)
1833 {
1834 LDAP_namespace *ldap = impl_from_IDirectorySearch(iface);
1835 struct ldap_search_context *ldap_ctx = res;
1836
1837 TRACE("%p,%p\n", iface, res);
1838
1839 if (!res) return E_ADS_BAD_PARAMETER;
1840
1841 if (ldap_ctx->page)
1842 ldap_search_abandon_page(ldap->ld, ldap_ctx->page);
1843 if (ldap_ctx->res)
1844 ldap_msgfree(ldap_ctx->res);
1845 if (ldap_ctx->ber)
1846 ber_free(ldap_ctx->ber, 0);
1847 heap_free(ldap_ctx);
1848
1849 return S_OK;
1850 }
1851
1852 static const IDirectorySearchVtbl IDirectorySearch_vtbl =
1853 {
1854 search_QueryInterface,
1855 search_AddRef,
1856 search_Release,
1857 search_SetSearchPreference,
1858 search_ExecuteSearch,
1859 search_AbandonSearch,
1860 search_GetFirstRow,
1861 search_GetNextRow,
1862 search_GetPreviousRow,
1863 search_GetNextColumnName,
1864 search_GetColumn,
1865 search_FreeColumn,
1866 search_CloseSearchHandle
1867 };
1868
1869 static inline LDAP_namespace *impl_from_IDirectoryObject(IDirectoryObject *iface)
1870 {
1871 return CONTAINING_RECORD(iface, LDAP_namespace, IDirectoryObject_iface);
1872 }
1873
1874 static HRESULT WINAPI dirobj_QueryInterface(IDirectoryObject *iface, REFIID riid, void **obj)
1875 {
1876 LDAP_namespace *ldap = impl_from_IDirectoryObject(iface);
1877
1878 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
1879
1880 if (!riid || !obj) return E_INVALIDARG;
1881
1882 if (IsEqualGUID(riid, &IID_IDirectoryObject) ||
1883 IsEqualGUID(riid, &IID_IUnknown))
1884 {
1885 IDirectoryObject_AddRef(iface);
1886 *obj = iface;
1887 return S_OK;
1888 }
1889
1890 return IADs_QueryInterface(&ldap->IADs_iface, riid, obj);
1891 }
1892
1893 static ULONG WINAPI dirobj_AddRef(IDirectoryObject *iface)
1894 {
1895 LDAP_namespace *ldap = impl_from_IDirectoryObject(iface);
1896 return IADs_AddRef(&ldap->IADs_iface);
1897 }
1898
1899 static ULONG WINAPI dirobj_Release(IDirectoryObject *iface)
1900 {
1901 LDAP_namespace *ldap = impl_from_IDirectoryObject(iface);
1902 return IADs_Release(&ldap->IADs_iface);
1903 }
1904
1905 static HRESULT WINAPI dirobj_GetObjectInformation(IDirectoryObject *iface, PADS_OBJECT_INFO *info)
1906 {
1907 FIXME("%p,%p: stub\n", iface, info);
1908 return E_NOTIMPL;
1909 }
1910
1911 static HRESULT WINAPI dirobj_GetObjectAttributes(IDirectoryObject *iface, LPWSTR *names,
1912 DWORD count, PADS_ATTR_INFO *attrs, DWORD *count_returned)
1913 {
1914 FIXME("%p,%p,%u,%p,%p: stub\n", iface, names, count, attrs, count_returned);
1915 return E_NOTIMPL;
1916 }
1917
1918 static HRESULT WINAPI dirobj_SetObjectAttributes(IDirectoryObject *iface, PADS_ATTR_INFO attrs,
1919 DWORD count, DWORD *count_set)
1920 {
1921 FIXME("%p,%p,%u,%p: stub\n", iface, attrs, count, count_set);
1922 return E_NOTIMPL;
1923 }
1924
1925 static HRESULT WINAPI dirobj_CreateDSObject(IDirectoryObject *iface, LPWSTR name,
1926 PADS_ATTR_INFO attrs, DWORD count, IDispatch **obj)
1927 {
1928 FIXME("%p,%s,%p,%u,%p: stub\n", iface, debugstr_w(name), attrs, count, obj);
1929 return E_NOTIMPL;
1930 }
1931
1932 static HRESULT WINAPI dirobj_DeleteDSObject(IDirectoryObject *iface, LPWSTR name)
1933 {
1934 FIXME("%p,%s: stub\n", iface, debugstr_w(name));
1935 return E_NOTIMPL;
1936 }
1937
1938 static const IDirectoryObjectVtbl IDirectoryObject_vtbl =
1939 {
1940 dirobj_QueryInterface,
1941 dirobj_AddRef,
1942 dirobj_Release,
1943 dirobj_GetObjectInformation,
1944 dirobj_GetObjectAttributes,
1945 dirobj_SetObjectAttributes,
1946 dirobj_CreateDSObject,
1947 dirobj_DeleteDSObject
1948 };
1949
1950 static HRESULT LDAPNamespace_create(REFIID riid, void **obj)
1951 {
1952 LDAP_namespace *ldap;
1953 HRESULT hr;
1954
1955 ldap = heap_alloc(sizeof(*ldap));
1956 if (!ldap) return E_OUTOFMEMORY;
1957
1958 ldap->IADs_iface.lpVtbl = &IADs_vtbl;
1959 ldap->IADsOpenDSObject_iface.lpVtbl = &IADsOpenDSObject_vtbl;
1960 ldap->IDirectorySearch_iface.lpVtbl = &IDirectorySearch_vtbl;
1961 ldap->IDirectoryObject_iface.lpVtbl = &IDirectoryObject_vtbl;
1962 ldap->ref = 1;
1963 ldap->ld = NULL;
1964 ldap->host = NULL;
1965 ldap->object = NULL;
1966 ldap->attrs_count = 0;
1967 ldap->attrs_count_allocated = 0;
1968 ldap->attrs = NULL;
1969 ldap->search.scope = ADS_SCOPE_SUBTREE;
1970 ldap->search.pagesize = 0;
1971 ldap->search.cache_results = TRUE;
1972 ldap->search.attribtypes_only = FALSE;
1973 ldap->search.tombstone = FALSE;
1974 ldap->at = NULL;
1975 ldap->at_single_count = 0;
1976 ldap->at_multiple_count = 0;
1977
1978 hr = IADs_QueryInterface(&ldap->IADs_iface, riid, obj);
1979 IADs_Release(&ldap->IADs_iface);
1980
1981 return hr;
1982 }
1983
1984 static const struct class_info
1985 {
1986 const CLSID *clsid;
1987 HRESULT (*constructor)(REFIID, void **);
1988 } class_info[] =
1989 {
1990 { &CLSID_ADSystemInfo, ADSystemInfo_create },
1991 { &CLSID_LDAP, LDAP_create },
1992 { &CLSID_LDAPNamespace, LDAPNamespace_create },
1993 };
1994
1995 typedef struct
1996 {
1997 IClassFactory IClassFactory_iface;
1998 LONG ref;
1999 const struct class_info *info;
2000 } class_factory;
2001
2002 static inline class_factory *impl_from_IClassFactory(IClassFactory *iface)
2003 {
2004 return CONTAINING_RECORD(iface, class_factory, IClassFactory_iface);
2005 }
2006
2007 static HRESULT WINAPI factory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *obj)
2008 {
2009 TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
2010
2011 if (!riid || !obj) return E_INVALIDARG;
2012
2013 if (IsEqualIID(riid, &IID_IUnknown) ||
2014 IsEqualIID(riid, &IID_IClassFactory))
2015 {
2016 IClassFactory_AddRef(iface);
2017 *obj = iface;
2018 return S_OK;
2019 }
2020
2021 *obj = NULL;
2022 FIXME("interface %s is not implemented\n", debugstr_guid(riid));
2023 return E_NOINTERFACE;
2024 }
2025
2026 static ULONG WINAPI factory_AddRef(IClassFactory *iface)
2027 {
2028 class_factory *factory = impl_from_IClassFactory(iface);
2029 ULONG ref = InterlockedIncrement(&factory->ref);
2030
2031 TRACE("(%p) ref %u\n", iface, ref);
2032
2033 return ref;
2034 }
2035
2036 static ULONG WINAPI factory_Release(IClassFactory *iface)
2037 {
2038 class_factory *factory = impl_from_IClassFactory(iface);
2039 ULONG ref = InterlockedDecrement(&factory->ref);
2040
2041 TRACE("(%p) ref %u\n", iface, ref);
2042
2043 if (!ref)
2044 heap_free(factory);
2045
2046 return ref;
2047 }
2048
2049 static HRESULT WINAPI factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
2050 {
2051 class_factory *factory = impl_from_IClassFactory(iface);
2052
2053 TRACE("%p,%s,%p\n", outer, debugstr_guid(riid), obj);
2054
2055 if (!riid || !obj) return E_INVALIDARG;
2056
2057 *obj = NULL;
2058 if (outer) return CLASS_E_NOAGGREGATION;
2059
2060 return factory->info->constructor(riid, obj);
2061 }
2062
2063 static HRESULT WINAPI factory_LockServer(IClassFactory *iface, BOOL lock)
2064 {
2065 FIXME("%p,%d: stub\n", iface, lock);
2066 return S_OK;
2067 }
2068
2069 static const struct IClassFactoryVtbl factory_vtbl =
2070 {
2071 factory_QueryInterface,
2072 factory_AddRef,
2073 factory_Release,
2074 factory_CreateInstance,
2075 factory_LockServer
2076 };
2077
2078 static HRESULT factory_constructor(const struct class_info *info, REFIID riid, void **obj)
2079 {
2080 class_factory *factory;
2081 HRESULT hr;
2082
2083 factory = heap_alloc(sizeof(*factory));
2084 if (!factory) return E_OUTOFMEMORY;
2085
2086 factory->IClassFactory_iface.lpVtbl = &factory_vtbl;
2087 factory->ref = 1;
2088 factory->info = info;
2089
2090 hr = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, obj);
2091 IClassFactory_Release(&factory->IClassFactory_iface);
2092
2093 return hr;
2094 }
2095
2096 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *obj)
2097 {
2098 int i;
2099
2100 TRACE("%s,%s,%p\n", debugstr_guid(clsid), debugstr_guid(iid), obj);
2101
2102 if (!clsid || !iid || !obj) return E_INVALIDARG;
2103
2104 *obj = NULL;
2105
2106 for (i = 0; i < ARRAY_SIZE(class_info); i++)
2107 {
2108 if (IsEqualCLSID(class_info[i].clsid, clsid))
2109 return factory_constructor(&class_info[i], iid, obj);
2110 }
2111
2112 FIXME("class %s/%s is not implemented\n", debugstr_guid(clsid), debugstr_guid(iid));
2113 return CLASS_E_CLASSNOTAVAILABLE;
2114 }
Windows API implementation