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