comctl32: Remove redundant NULL check before free (found by Smatch).
[wine] / dlls / wldap32 / misc.c
1 /*
2  * WLDAP32 - LDAP support for Wine
3  *
4  * Copyright 2005 Hans Leidekker
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 "config.h"
22
23 #include "wine/port.h"
24 #include "wine/debug.h"
25
26 #include <stdarg.h>
27 #include <stdio.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winnls.h"
32
33 #ifdef HAVE_LDAP_H
34 #include <ldap.h>
35 #else
36 #define LDAP_SUCCESS        0x00
37 #define LDAP_NOT_SUPPORTED  0x5c
38 #endif
39
40 #include "winldap_private.h"
41 #include "wldap32.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
44
45 /***********************************************************************
46  *      ldap_abandon     (WLDAP32.@)
47  *
48  * Cancel an asynchronous operation.
49  *
50  * PARAMS
51  *  ld    [I] Pointer to an LDAP context.
52  *  msgid [I] ID of the operation to cancel.
53  *
54  * RETURNS
55  *  Success: LDAP_SUCCESS
56  *  Failure: An LDAP error code.
57  */
58 ULONG CDECL WLDAP32_ldap_abandon( WLDAP32_LDAP *ld, ULONG msgid )
59 {
60     ULONG ret = LDAP_NOT_SUPPORTED;
61 #ifdef HAVE_LDAP
62
63     TRACE( "(%p, 0x%08x)\n", ld, msgid );
64
65     if (!ld) return ~0UL;
66     ret = ldap_abandon_ext( ld, msgid, NULL, NULL );
67
68 #endif
69     return ret;
70 }
71
72 /***********************************************************************
73  *      ldap_check_filterA     (WLDAP32.@)
74  *
75  * See ldap_check_filterW.
76  */
77 ULONG CDECL ldap_check_filterA( WLDAP32_LDAP *ld, PCHAR filter )
78 {
79     ULONG ret;
80     WCHAR *filterW = NULL;
81
82     TRACE( "(%p, %s)\n", ld, debugstr_a(filter) );
83
84     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
85
86     if (filter) {
87         filterW = strAtoW( filter );
88         if (!filterW) return WLDAP32_LDAP_NO_MEMORY;
89     }
90
91     ret = ldap_check_filterW( ld, filterW );
92
93     strfreeW( filterW );
94     return ret;
95 }
96
97 /***********************************************************************
98  *      ldap_check_filterW     (WLDAP32.@)
99  *
100  * Check filter syntax.
101  *
102  * PARAMS
103  *  ld     [I] Pointer to an LDAP context.
104  *  filter [I] Filter string.
105  *
106  * RETURNS
107  *  Success: LDAP_SUCCESS
108  *  Failure: An LDAP error code.
109  */
110 ULONG CDECL ldap_check_filterW( WLDAP32_LDAP *ld, PWCHAR filter )
111 {
112     TRACE( "(%p, %s)\n", ld, debugstr_w(filter) );
113
114     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
115     return LDAP_SUCCESS; /* FIXME: do some checks */
116 }
117
118 /***********************************************************************
119  *      ldap_cleanup     (WLDAP32.@)
120  */
121 ULONG CDECL ldap_cleanup( HANDLE instance )
122 {
123     TRACE( "(%p)\n", instance );
124     return LDAP_SUCCESS;
125 }
126
127 /***********************************************************************
128  *      ldap_conn_from_msg     (WLDAP32.@)
129  *
130  * Get the LDAP context for a given message.
131  *
132  * PARAMS
133  *  ld  [I] Pointer to an LDAP context.
134  *  res [I] LDAP message.
135  *
136  * RETURNS
137  *  Success: Pointer to an LDAP context.
138  *  Failure: NULL
139  */
140 WLDAP32_LDAP * CDECL ldap_conn_from_msg( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
141 {
142     TRACE( "(%p, %p)\n", ld, res );
143
144     if (!ld || !res) return NULL;
145     return ld; /* FIXME: not always correct */
146 }
147
148 /***********************************************************************
149  *      ldap_count_entries     (WLDAP32.@)
150  *
151  * Count the number of entries returned from a search.
152  *
153  * PARAMS
154  *  ld  [I] Pointer to an LDAP context.
155  *  res [I] LDAP message.
156  *
157  * RETURNS
158  *  Success: The number of entries.
159  *  Failure: ~0UL
160  */
161 ULONG CDECL WLDAP32_ldap_count_entries( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
162 {
163     ULONG ret = LDAP_NOT_SUPPORTED;
164 #ifdef HAVE_LDAP
165
166     TRACE( "(%p, %p)\n", ld, res );
167
168     if (!ld) return ~0UL;
169     ret = ldap_count_entries( ld, res );
170
171 #endif
172     return ret;
173 }
174
175 /***********************************************************************
176  *      ldap_count_references     (WLDAP32.@)
177  *
178  * Count the number of references returned from a search.
179  *
180  * PARAMS
181  *  ld  [I] Pointer to an LDAP context.
182  *  res [I] LDAP message.
183  *
184  * RETURNS
185  *  Success: The number of references.
186  *  Failure: ~0UL
187  */
188 ULONG CDECL WLDAP32_ldap_count_references( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
189 {
190     ULONG ret = LDAP_NOT_SUPPORTED;
191 #ifdef HAVE_LDAP_COUNT_REFERENCES
192
193     TRACE( "(%p, %p)\n", ld, res );
194
195     if (!ld) return 0;
196     ret = ldap_count_references( ld, res );
197
198 #endif
199     return ret;
200 }
201
202 static ULONG get_escape_size( PCHAR src, ULONG srclen )
203 {
204     ULONG i, size = 0;
205
206     if (src)
207     {
208         for (i = 0; i < srclen; i++)
209         {
210             if ((src[i] >= '0' && src[i] <= '9') ||
211                 (src[i] >= 'A' && src[i] <= 'Z') ||
212                 (src[i] >= 'a' && src[i] <= 'z'))
213                 size++;
214             else
215                 size += 3;
216         }
217     }
218     return size + 1;
219 }
220
221 static void escape_filter_element( PCHAR src, ULONG srclen, PCHAR dst )
222 {
223     ULONG i;
224     static const char fmt[] = "\\%02X";
225     char *d = dst;
226
227     for (i = 0; i < srclen; i++)
228     {
229         if ((src[i] >= '0' && src[i] <= '9') ||
230             (src[i] >= 'A' && src[i] <= 'Z') ||
231             (src[i] >= 'a' && src[i] <= 'z'))
232             *d++ = src[i];
233         else
234         {
235             sprintf( d, fmt, (unsigned char)src[i] );
236             d += 3;
237         }
238     }
239     *++d = 0;
240 }
241
242 /***********************************************************************
243  *      ldap_escape_filter_elementA     (WLDAP32.@)
244  *
245  * See ldap_escape_filter_elementW.
246  */
247 ULONG CDECL ldap_escape_filter_elementA( PCHAR src, ULONG srclen, PCHAR dst, ULONG dstlen )
248 {
249     ULONG len;
250
251     TRACE( "(%p, 0x%08x, %p, 0x%08x)\n", src, srclen, dst, dstlen );
252
253     len = get_escape_size( src, srclen );
254     if (!dst) return len;
255
256     if (!src || dstlen < len)
257         return WLDAP32_LDAP_PARAM_ERROR;
258     else
259     {
260         escape_filter_element( src, srclen, dst );
261         return LDAP_SUCCESS;
262     }
263 }
264
265 /***********************************************************************
266  *      ldap_escape_filter_elementW     (WLDAP32.@)
267  *
268  * Escape binary data for safe passing in filters.
269  *
270  * PARAMS
271  *  src    [I] Filter element to be escaped.
272  *  srclen [I] Length in bytes of the filter element.
273  *  dst    [O] Destination buffer for the escaped filter element.
274  *  dstlen [I] Length in bytes of the destination buffer.
275  *
276  * RETURNS
277  *  Success: LDAP_SUCCESS
278  *  Failure: An LDAP error code.
279  */
280 ULONG CDECL ldap_escape_filter_elementW( PCHAR src, ULONG srclen, PWCHAR dst, ULONG dstlen )
281 {
282     ULONG len;
283
284     TRACE( "(%p, 0x%08x, %p, 0x%08x)\n", src, srclen, dst, dstlen );
285
286     len = get_escape_size( src, srclen );
287     if (!dst) return len;
288
289     /* no matter what you throw at it, this is what native returns */
290     return WLDAP32_LDAP_PARAM_ERROR;
291 }
292
293 /***********************************************************************
294  *      ldap_first_attributeA     (WLDAP32.@)
295  *
296  * See ldap_first_attributeW.
297  */
298 PCHAR CDECL ldap_first_attributeA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
299     WLDAP32_BerElement** ptr )
300 {
301     PCHAR ret = NULL;
302 #ifdef HAVE_LDAP
303     WCHAR *retW;
304
305     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
306
307     if (!ld || !entry) return NULL;
308     retW = ldap_first_attributeW( ld, entry, ptr );
309
310     ret = strWtoA( retW );
311     ldap_memfreeW( retW );
312
313 #endif
314     return ret;
315 }
316
317 /***********************************************************************
318  *      ldap_first_attributeW     (WLDAP32.@)
319  *
320  * Get the first attribute for a given entry. 
321  *
322  * PARAMS
323  *  ld    [I] Pointer to an LDAP context.
324  *  entry [I] Entry to retrieve attribute for.
325  *  ptr   [O] Position pointer.
326  *
327  * RETURNS
328  *  Success: Name of the first attribute.
329  *  Failure: NULL
330  *
331  * NOTES
332  *  Use ldap_memfree to free the returned string.
333  */
334 PWCHAR CDECL ldap_first_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
335     WLDAP32_BerElement** ptr )
336 {
337     PWCHAR ret = NULL;
338 #ifdef HAVE_LDAP
339     char *retU;
340
341     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
342
343     if (!ld || !entry) return NULL;
344     retU = ldap_first_attribute( ld, entry, ptr );
345
346     ret = strUtoW( retU );
347     ldap_memfree( retU );
348
349 #endif
350     return ret;
351 }
352
353 /***********************************************************************
354  *      ldap_first_entry     (WLDAP32.@)
355  *
356  * Get the first entry from a result message.
357  *
358  * PARAMS
359  *  ld  [I] Pointer to an LDAP context.
360  *  res [I] Search result message.
361  *
362  * RETURNS
363  *  Success: The first entry.
364  *  Failure: NULL
365  *
366  * NOTES
367  *  The returned entry will be freed when the message is freed. 
368  */
369 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_entry( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
370 {
371 #ifdef HAVE_LDAP
372
373     TRACE( "(%p, %p)\n", ld, res );
374
375     if (!ld || !res) return NULL;
376     return ldap_first_entry( ld, res );
377
378 #else
379     return NULL;
380 #endif
381 }
382
383 /***********************************************************************
384  *      ldap_first_reference     (WLDAP32.@)
385  *
386  * Get the first reference from a result message.
387  *
388  * PARAMS
389  *  ld  [I] Pointer to an LDAP context.
390  *  res [I] Search result message.
391  *
392  * RETURNS
393  *  Success: The first reference.
394  *  Failure: NULL
395  */
396 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_reference( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
397 {
398 #ifdef HAVE_LDAP_FIRST_REFERENCE
399
400     TRACE( "(%p, %p)\n", ld, res );
401
402     if (!ld) return NULL;
403     return ldap_first_reference( ld, res );
404
405 #else
406     return NULL;
407 #endif
408 }
409
410 /***********************************************************************
411  *      ldap_memfreeA     (WLDAP32.@)
412  *
413  * See ldap_memfreeW.
414  */
415 void CDECL ldap_memfreeA( PCHAR block )
416 {
417     TRACE( "(%p)\n", block );
418     strfreeA( block );
419 }
420
421 /***********************************************************************
422  *      ldap_memfreeW     (WLDAP32.@)
423  *
424  * Free a block of memory.
425  *
426  * PARAMS
427  *  block [I] Pointer to memory block to be freed.
428  */
429 void CDECL ldap_memfreeW( PWCHAR block )
430 {
431     TRACE( "(%p)\n", block );
432     strfreeW( block );
433 }
434
435 /***********************************************************************
436  *      ldap_msgfree     (WLDAP32.@)
437  *
438  * Free a message.
439  *
440  * PARAMS
441  *  res [I] Message to be freed.
442  */
443 ULONG CDECL WLDAP32_ldap_msgfree( WLDAP32_LDAPMessage *res )
444 {
445     ULONG ret = LDAP_SUCCESS;
446 #ifdef HAVE_LDAP
447
448     TRACE( "(%p)\n", res );
449     ldap_msgfree( res );
450
451 #endif
452     return ret;
453 }
454
455 /***********************************************************************
456  *      ldap_next_attributeA     (WLDAP32.@)
457  *
458  * See ldap_next_attributeW.
459  */
460 PCHAR CDECL ldap_next_attributeA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
461     WLDAP32_BerElement *ptr )
462 {
463     PCHAR ret = NULL;
464 #ifdef HAVE_LDAP
465     WCHAR *retW;
466
467     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
468
469     if (!ld || !entry || !ptr) return NULL;
470     retW = ldap_next_attributeW( ld, entry, ptr );
471
472     ret = strWtoA( retW );
473     ldap_memfreeW( retW );
474
475 #endif
476     return ret;
477 }
478
479 /***********************************************************************
480  *      ldap_next_attributeW     (WLDAP32.@)
481  *
482  * Get the next attribute for a given entry.
483  *
484  * PARAMS
485  *  ld    [I]   Pointer to an LDAP context.
486  *  entry [I]   Entry to retrieve attribute for.
487  *  ptr   [I/O] Position pointer.
488  *
489  * RETURNS
490  *  Success: The name of the next attribute.
491  *  Failure: NULL
492  *
493  * NOTES
494  *  Free the returned string after each iteration with ldap_memfree.
495  *  When done iterating and when ptr != NULL, call ber_free( ptr, 0 ).
496  */
497 PWCHAR CDECL ldap_next_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
498     WLDAP32_BerElement *ptr )
499 {
500     PWCHAR ret = NULL;
501 #ifdef HAVE_LDAP
502     char *retU;
503
504     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
505
506     if (!ld || !entry || !ptr) return NULL;
507     retU = ldap_next_attribute( ld, entry, ptr );
508
509     ret = strUtoW( retU );
510     ldap_memfree( retU );
511
512 #endif
513     return ret;
514 }
515
516 /***********************************************************************
517  *      ldap_next_entry     (WLDAP32.@)
518  *
519  * Get the next entry from a result message.
520  *
521  * PARAMS
522  *  ld    [I] Pointer to an LDAP context.
523  *  entry [I] Entry returned by a previous call.
524  *
525  * RETURNS
526  *  Success: The next entry.
527  *  Failure: NULL
528  *
529  * NOTES
530  *  The returned entry will be freed when the message is freed.
531  */
532 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_entry( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry )
533 {
534 #ifdef HAVE_LDAP
535
536     TRACE( "(%p, %p)\n", ld, entry );
537
538     if (!ld || !entry) return NULL;
539     return ldap_next_entry( ld, entry );
540
541 #else
542     return NULL;
543 #endif
544 }
545
546 /***********************************************************************
547  *      ldap_next_reference     (WLDAP32.@)
548  *
549  * Get the next reference from a result message.
550  *
551  * PARAMS
552  *  ld    [I] Pointer to an LDAP context.
553  *  entry [I] Entry returned by a previous call.
554  *
555  * RETURNS
556  *  Success: The next reference.
557  *  Failure: NULL
558  *
559  * NOTES
560  *  The returned entry will be freed when the message is freed.
561  */
562 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_reference( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry )
563 {
564 #ifdef HAVE_LDAP_NEXT_REFERENCE
565
566     TRACE( "(%p, %p)\n", ld, entry );
567
568     if (!ld || !entry) return NULL;
569     return ldap_next_reference( ld, entry );
570
571 #else
572     return NULL;
573 #endif
574 }
575
576 /***********************************************************************
577  *      ldap_result     (WLDAP32.@)
578  *
579  * Get the result of an asynchronous operation.
580  *
581  * PARAMS
582  *  ld      [I] Pointer to an LDAP context.
583  *  msgid   [I] Message ID of the operation.
584  *  all     [I] How many results should be returned?
585  *  timeout [I] How long to wait for the results?
586  *  res     [O] Result message for the operation.
587  *
588  * RETURNS
589  *  Success: One of the following values:
590  *
591  *   LDAP_RES_ADD
592  *   LDAP_RES_BIND
593  *   LDAP_RES_COMPARE
594  *   LDAP_RES_DELETE
595  *   LDAP_RES_EXTENDED
596  *   LDAP_RES_MODIFY
597  *   LDAP_RES_MODRDN
598  *   LDAP_RES_REFERRAL
599  *   LDAP_RES_SEARCH_ENTRY
600  *   LDAP_RES_SEARCH_RESULT
601  *
602  *  Failure: ~0UL
603  *
604  *  This function returns 0 when the timeout has expired.
605  *
606  * NOTES
607  *  A NULL timeout pointer causes the function to block waiting
608  *  for results to arrive. A timeout value of 0 causes the function
609  *  to immediately return any available results. Free returned results
610  *  with ldap_msgfree.
611  */
612 ULONG CDECL WLDAP32_ldap_result( WLDAP32_LDAP *ld, ULONG msgid, ULONG all,
613     struct l_timeval *timeout, WLDAP32_LDAPMessage **res )
614 {
615     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
616 #ifdef HAVE_LDAP
617
618     TRACE( "(%p, 0x%08x, 0x%08x, %p, %p)\n", ld, msgid, all, timeout, res );
619
620     if (!ld || !res || msgid == ~0UL) return ~0UL;
621     ret = ldap_result( ld, msgid, all, (struct timeval *)timeout, res );
622
623 #endif
624     return ret;
625 }
626
627 /***********************************************************************
628  *      LdapUnicodeToUTF8     (WLDAP32.@)
629  *
630  * Convert a wide character string to a UTF8 string.
631  *
632  * PARAMS
633  *  src    [I] Wide character string to convert.
634  *  srclen [I] Size of string to convert, in characters.
635  *  dst    [O] Pointer to a buffer that receives the converted string.
636  *  dstlen [I] Size of the destination buffer in characters. 
637  *
638  * RETURNS
639  *  The number of characters written into the destination buffer.
640  *
641  * NOTES
642  *  Set dstlen to zero to ask for the required buffer size.
643  */
644 int CDECL LdapUnicodeToUTF8( LPCWSTR src, int srclen, LPSTR dst, int dstlen )
645 {
646     return WideCharToMultiByte( CP_UTF8, 0, src, srclen, dst, dstlen, NULL, NULL );
647 }
648
649 /***********************************************************************
650  *      LdapUTF8ToUnicode     (WLDAP32.@)
651  *
652  * Convert a UTF8 string to a wide character string.
653  *
654  * PARAMS
655  *  src    [I] UTF8 string to convert.
656  *  srclen [I] Size of string to convert, in characters.
657  *  dst    [O] Pointer to a buffer that receives the converted string.
658  *  dstlen [I] Size of the destination buffer in characters. 
659  *
660  * RETURNS
661  *  The number of characters written into the destination buffer.
662  *
663  * NOTES
664  *  Set dstlen to zero to ask for the required buffer size.
665  */
666 int CDECL LdapUTF8ToUnicode( LPCSTR src, int srclen, LPWSTR dst, int dstlen )
667 {
668     return MultiByteToWideChar( CP_UTF8, 0, src, srclen, dst, dstlen );
669 }