Make up a full hostname for ldapi connections.
[kai/samba.git] / source4 / libcli / ldap / ldap_client.c
1 /* 
2    Unix SMB/CIFS mplementation.
3    LDAP protocol helper functions for SAMBA
4    
5    Copyright (C) Andrew Tridgell  2004
6    Copyright (C) Volker Lendecke 2004
7    Copyright (C) Stefan Metzmacher 2004
8    Copyright (C) Simo Sorce 2004
9     
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22    
23 */
24
25 #include "includes.h"
26 #include "lib/util/asn1.h"
27 #include "lib/util/dlinklist.h"
28 #include "lib/events/events.h"
29 #include "lib/socket/socket.h"
30 #include "libcli/ldap/ldap.h"
31 #include "libcli/ldap/ldap_proto.h"
32 #include "libcli/ldap/ldap_client.h"
33 #include "libcli/composite/composite.h"
34 #include "lib/stream/packet.h"
35 #include "lib/tls/tls.h"
36 #include "auth/gensec/gensec.h"
37 #include "system/time.h"
38 #include "param/param.h"
39 #include "libcli/resolve/resolve.h"
40
41 /**
42   create a new ldap_connection stucture. The event context is optional
43 */
44 _PUBLIC_ struct ldap_connection *ldap4_new_connection(TALLOC_CTX *mem_ctx, 
45                                              struct loadparm_context *lp_ctx,
46                                              struct event_context *ev)
47 {
48         struct ldap_connection *conn;
49
50         if (ev == NULL) {
51                 return NULL;
52         }
53
54         conn = talloc_zero(mem_ctx, struct ldap_connection);
55         if (conn == NULL) {
56                 return NULL;
57         }
58
59         conn->next_messageid  = 1;
60         conn->event.event_ctx = ev;
61
62         conn->lp_ctx = lp_ctx;
63
64         /* set a reasonable request timeout */
65         conn->timeout = 60;
66
67         /* explicitly avoid reconnections by default */
68         conn->reconnect.max_retries = 0;
69         
70         return conn;
71 }
72
73 /*
74   the connection is dead
75 */
76 static void ldap_connection_dead(struct ldap_connection *conn)
77 {
78         struct ldap_request *req;
79
80         /* return an error for any pending request ... */
81         while (conn->pending) {
82                 req = conn->pending;
83                 DLIST_REMOVE(req->conn->pending, req);
84                 req->state = LDAP_REQUEST_DONE;
85                 req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
86                 if (req->async.fn) {
87                         req->async.fn(req);
88                 }
89         }
90
91         talloc_free(conn->sock);  /* this will also free event.fde */
92         talloc_free(conn->packet);
93         conn->sock = NULL;
94         conn->event.fde = NULL;
95         conn->packet = NULL;
96 }
97
98 static void ldap_reconnect(struct ldap_connection *conn);
99
100 /*
101   handle packet errors
102 */
103 static void ldap_error_handler(void *private_data, NTSTATUS status)
104 {
105         struct ldap_connection *conn = talloc_get_type(private_data, 
106                                                        struct ldap_connection);
107         ldap_connection_dead(conn);
108
109         /* but try to reconnect so that the ldb client can go on */
110         ldap_reconnect(conn);
111 }
112
113
114 /*
115   match up with a pending message, adding to the replies list
116 */
117 static void ldap_match_message(struct ldap_connection *conn, struct ldap_message *msg)
118 {
119         struct ldap_request *req;
120         int i;
121
122         for (req=conn->pending; req; req=req->next) {
123                 if (req->messageid == msg->messageid) break;
124         }
125         /* match a zero message id to the last request sent.
126            It seems that servers send 0 if unable to parse */
127         if (req == NULL && msg->messageid == 0) {
128                 req = conn->pending;
129         }
130         if (req == NULL) {
131                 DEBUG(0,("ldap: no matching message id for %u\n",
132                          msg->messageid));
133                 talloc_free(msg);
134                 return;
135         }
136
137         /* Check for undecoded critical extensions */
138         for (i=0; msg->controls && msg->controls[i]; i++) {
139                 if (!msg->controls_decoded[i] && 
140                     msg->controls[i]->critical) {
141                         req->status = NT_STATUS_LDAP(LDAP_UNAVAILABLE_CRITICAL_EXTENSION);
142                         req->state = LDAP_REQUEST_DONE;
143                         DLIST_REMOVE(conn->pending, req);
144                         if (req->async.fn) {
145                                 req->async.fn(req);
146                         }
147                         return;
148                 }
149         }
150
151         /* add to the list of replies received */
152         talloc_steal(req, msg);
153         req->replies = talloc_realloc(req, req->replies, 
154                                       struct ldap_message *, req->num_replies+1);
155         if (req->replies == NULL) {
156                 req->status = NT_STATUS_NO_MEMORY;
157                 req->state = LDAP_REQUEST_DONE;
158                 DLIST_REMOVE(conn->pending, req);
159                 if (req->async.fn) {
160                         req->async.fn(req);
161                 }
162                 return;
163         }
164
165         req->replies[req->num_replies] = talloc_steal(req->replies, msg);
166         req->num_replies++;
167
168         if (msg->type != LDAP_TAG_SearchResultEntry &&
169             msg->type != LDAP_TAG_SearchResultReference) {
170                 /* currently only search results expect multiple
171                    replies */
172                 req->state = LDAP_REQUEST_DONE;
173                 DLIST_REMOVE(conn->pending, req);
174         }
175
176         if (req->async.fn) {
177                 req->async.fn(req);
178         }
179 }
180
181
182 /*
183   decode/process LDAP data
184 */
185 static NTSTATUS ldap_recv_handler(void *private_data, DATA_BLOB blob)
186 {
187         NTSTATUS status;
188         struct ldap_connection *conn = talloc_get_type(private_data, 
189                                                        struct ldap_connection);
190         struct ldap_message *msg = talloc(conn, struct ldap_message);
191         struct asn1_data *asn1 = asn1_init(conn);
192
193         if (asn1 == NULL || msg == NULL) {
194                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
195         }
196
197         if (!asn1_load(asn1, blob)) {
198                 talloc_free(msg);
199                 talloc_free(asn1);
200                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
201         }
202         
203         status = ldap_decode(asn1, msg);
204         if (!NT_STATUS_IS_OK(status)) {
205                 asn1_free(asn1);
206                 return status;
207         }
208
209         ldap_match_message(conn, msg);
210
211         data_blob_free(&blob);
212         asn1_free(asn1);
213         return NT_STATUS_OK;
214 }
215
216 /* Handle read events, from the GENSEC socket callback, or real events */
217 void ldap_read_io_handler(void *private_data, uint16_t flags) 
218 {
219         struct ldap_connection *conn = talloc_get_type(private_data, 
220                                                        struct ldap_connection);
221         packet_recv(conn->packet);
222 }
223
224 /*
225   handle ldap socket events
226 */
227 static void ldap_io_handler(struct event_context *ev, struct fd_event *fde, 
228                             uint16_t flags, void *private_data)
229 {
230         struct ldap_connection *conn = talloc_get_type(private_data, 
231                                                        struct ldap_connection);
232         if (flags & EVENT_FD_WRITE) {
233                 packet_queue_run(conn->packet);
234                 if (!tls_enabled(conn->sock)) return;
235         }
236         if (flags & EVENT_FD_READ) {
237                 ldap_read_io_handler(private_data, flags);
238         }
239 }
240
241 /*
242   parse a ldap URL
243 */
244 static NTSTATUS ldap_parse_basic_url(TALLOC_CTX *mem_ctx, const char *url,
245                                      char **host, uint16_t *port, bool *ldaps)
246 {
247         int tmp_port = 0;
248         char protocol[11];
249         char tmp_host[1025];
250         int ret;
251
252         /* Paranoia check */
253         SMB_ASSERT(sizeof(protocol)>10 && sizeof(tmp_host)>254);
254                 
255         ret = sscanf(url, "%10[^:]://%254[^:/]:%d", protocol, tmp_host, &tmp_port);
256         if (ret < 2) {
257                 return NT_STATUS_INVALID_PARAMETER;
258         }
259
260         if (strequal(protocol, "ldap")) {
261                 *port = 389;
262                 *ldaps = false;
263         } else if (strequal(protocol, "ldaps")) {
264                 *port = 636;
265                 *ldaps = true;
266         } else {
267                 DEBUG(0, ("unrecognised ldap protocol (%s)!\n", protocol));
268                 return NT_STATUS_PROTOCOL_UNREACHABLE;
269         }
270
271         if (tmp_port != 0)
272                 *port = tmp_port;
273
274         *host = talloc_strdup(mem_ctx, tmp_host);
275         NT_STATUS_HAVE_NO_MEMORY(*host);
276
277         return NT_STATUS_OK;
278 }
279
280 /*
281   connect to a ldap server
282 */
283
284 struct ldap_connect_state {
285         struct composite_context *ctx;
286         struct ldap_connection *conn;
287 };
288
289 static void ldap_connect_recv_unix_conn(struct composite_context *ctx);
290 static void ldap_connect_recv_tcp_conn(struct composite_context *ctx);
291
292 _PUBLIC_ struct composite_context *ldap_connect_send(struct ldap_connection *conn,
293                                             const char *url)
294 {
295         struct composite_context *result, *ctx;
296         struct ldap_connect_state *state;
297         char protocol[11];
298         int ret;
299
300         result = talloc_zero(conn, struct composite_context);
301         if (result == NULL) goto failed;
302         result->state = COMPOSITE_STATE_IN_PROGRESS;
303         result->async.fn = NULL;
304         result->event_ctx = conn->event.event_ctx;
305
306         state = talloc(result, struct ldap_connect_state);
307         if (state == NULL) goto failed;
308         state->ctx = result;
309         result->private_data = state;
310
311         state->conn = conn;
312
313         if (conn->reconnect.url == NULL) {
314                 conn->reconnect.url = talloc_strdup(conn, url);
315                 if (conn->reconnect.url == NULL) goto failed;
316         }
317
318         /* Paranoia check */
319         SMB_ASSERT(sizeof(protocol)>10);
320
321         ret = sscanf(url, "%10[^:]://", protocol);
322         if (ret < 1) {
323                 return NULL;
324         }
325
326         if (strequal(protocol, "ldapi")) {
327                 struct socket_address *unix_addr;
328                 char path[1025];
329         
330                 NTSTATUS status = socket_create("unix", SOCKET_TYPE_STREAM, &conn->sock, 0);
331                 if (!NT_STATUS_IS_OK(status)) {
332                         return NULL;
333                 }
334                 talloc_steal(conn, conn->sock);
335                 SMB_ASSERT(sizeof(protocol)>10);
336                 SMB_ASSERT(sizeof(path)>1024);
337         
338                 /* LDAPI connections are to localhost, so give the local host name as the target for gensec */
339                 conn->host = talloc_asprintf(conn, "%s.%s", lp_netbios_name(conn->lp_ctx),  lp_realm(conn->lp_ctx));
340                 if (composite_nomem(conn->host, state->ctx)) {
341                         return result;
342                 }
343
344                 /* The %c specifier doesn't null terminate :-( */
345                 ZERO_STRUCT(path);
346                 ret = sscanf(url, "%10[^:]://%1025c", protocol, path);
347                 if (ret < 2) {
348                         composite_error(state->ctx, NT_STATUS_INVALID_PARAMETER);
349                         return result;
350                 }
351
352                 rfc1738_unescape(path);
353         
354                 unix_addr = socket_address_from_strings(conn, conn->sock->backend_name, 
355                                                         path, 0);
356                 if (!unix_addr) {
357                         return NULL;
358                 }
359
360                 ctx = socket_connect_send(conn->sock, NULL, unix_addr, 
361                                           0, lp_resolve_context(conn->lp_ctx), conn->event.event_ctx);
362                 ctx->async.fn = ldap_connect_recv_unix_conn;
363                 ctx->async.private_data = state;
364                 return result;
365         } else {
366                 NTSTATUS status = ldap_parse_basic_url(conn, url, &conn->host,
367                                                           &conn->port, &conn->ldaps);
368                 if (!NT_STATUS_IS_OK(state->ctx->status)) {
369                         composite_error(state->ctx, status);
370                         return result;
371                 }
372                 
373                 ctx = socket_connect_multi_send(state, conn->host, 1, &conn->port,
374                                                 lp_resolve_context(conn->lp_ctx), conn->event.event_ctx);
375                 if (ctx == NULL) goto failed;
376
377                 ctx->async.fn = ldap_connect_recv_tcp_conn;
378                 ctx->async.private_data = state;
379                 return result;
380         }
381  failed:
382         talloc_free(result);
383         return NULL;
384 }
385
386 static void ldap_connect_got_sock(struct composite_context *ctx, 
387                                   struct ldap_connection *conn) 
388 {
389         /* setup a handler for events on this socket */
390         conn->event.fde = event_add_fd(conn->event.event_ctx, conn->sock, 
391                                        socket_get_fd(conn->sock), 
392                                        EVENT_FD_READ | EVENT_FD_AUTOCLOSE, ldap_io_handler, conn);
393         if (conn->event.fde == NULL) {
394                 composite_error(ctx, NT_STATUS_INTERNAL_ERROR);
395                 return;
396         }
397
398         socket_set_flags(conn->sock, SOCKET_FLAG_NOCLOSE);
399
400         talloc_steal(conn, conn->sock);
401         if (conn->ldaps) {
402                 struct socket_context *tls_socket;
403                 char *cafile = private_path(conn->sock, conn->lp_ctx, lp_tls_cafile(conn->lp_ctx));
404
405                 if (!cafile || !*cafile) {
406                         talloc_free(conn->sock);
407                         return;
408                 }
409
410                 tls_socket = tls_init_client(conn->sock, conn->event.fde, cafile);
411                 talloc_free(cafile);
412
413                 if (tls_socket == NULL) {
414                         talloc_free(conn->sock);
415                         return;
416                 }
417                 talloc_unlink(conn, conn->sock);
418                 conn->sock = tls_socket;
419                 talloc_steal(conn, conn->sock);
420         }
421
422         conn->packet = packet_init(conn);
423         if (conn->packet == NULL) {
424                 talloc_free(conn->sock);
425                 return;
426         }
427
428         packet_set_private(conn->packet, conn);
429         packet_set_socket(conn->packet, conn->sock);
430         packet_set_callback(conn->packet, ldap_recv_handler);
431         packet_set_full_request(conn->packet, ldap_full_packet);
432         packet_set_error_handler(conn->packet, ldap_error_handler);
433         packet_set_event_context(conn->packet, conn->event.event_ctx);
434         packet_set_fde(conn->packet, conn->event.fde);
435         packet_set_serialise(conn->packet);
436
437         composite_done(ctx);
438 }
439
440 static void ldap_connect_recv_tcp_conn(struct composite_context *ctx)
441 {
442         struct ldap_connect_state *state =
443                 talloc_get_type(ctx->async.private_data,
444                                 struct ldap_connect_state);
445         struct ldap_connection *conn = state->conn;
446         uint16_t port;
447         NTSTATUS status = socket_connect_multi_recv(ctx, state, &conn->sock,
448                                                        &port);
449         if (!NT_STATUS_IS_OK(status)) {
450                 composite_error(state->ctx, status);
451                 return;
452         }
453
454         ldap_connect_got_sock(state->ctx, conn);
455 }
456
457 static void ldap_connect_recv_unix_conn(struct composite_context *ctx)
458 {
459         struct ldap_connect_state *state =
460                 talloc_get_type(ctx->async.private_data,
461                                 struct ldap_connect_state);
462         struct ldap_connection *conn = state->conn;
463
464         NTSTATUS status = socket_connect_recv(ctx);
465
466         if (!NT_STATUS_IS_OK(state->ctx->status)) {
467                 composite_error(state->ctx, status);
468                 return;
469         }
470
471         ldap_connect_got_sock(state->ctx, conn);
472 }
473
474 _PUBLIC_ NTSTATUS ldap_connect_recv(struct composite_context *ctx)
475 {
476         NTSTATUS status = composite_wait(ctx);
477         talloc_free(ctx);
478         return status;
479 }
480
481 _PUBLIC_ NTSTATUS ldap_connect(struct ldap_connection *conn, const char *url)
482 {
483         struct composite_context *ctx = ldap_connect_send(conn, url);
484         return ldap_connect_recv(ctx);
485 }
486
487 /* set reconnect parameters */
488
489 _PUBLIC_ void ldap_set_reconn_params(struct ldap_connection *conn, int max_retries)
490 {
491         if (conn) {
492                 conn->reconnect.max_retries = max_retries;
493                 conn->reconnect.retries = 0;
494                 conn->reconnect.previous = time(NULL);
495         }
496 }
497
498 /* Actually this function is NOT ASYNC safe, FIXME? */
499 static void ldap_reconnect(struct ldap_connection *conn)
500 {
501         NTSTATUS status;
502         time_t now = time(NULL);
503
504         /* do we have set up reconnect ? */
505         if (conn->reconnect.max_retries == 0) return;
506
507         /* is the retry time expired ? */
508         if (now > conn->reconnect.previous + 30) {
509                 conn->reconnect.retries = 0;
510                 conn->reconnect.previous = now;
511         }
512
513         /* are we reconnectind too often and too fast? */
514         if (conn->reconnect.retries > conn->reconnect.max_retries) return;
515
516         /* keep track of the number of reconnections */
517         conn->reconnect.retries++;
518
519         /* reconnect */
520         status = ldap_connect(conn, conn->reconnect.url);
521         if ( ! NT_STATUS_IS_OK(status)) {
522                 return;
523         }
524
525         /* rebind */
526         status = ldap_rebind(conn);
527         if ( ! NT_STATUS_IS_OK(status)) {
528                 ldap_connection_dead(conn);
529         }
530 }
531
532 /* destroy an open ldap request */
533 static int ldap_request_destructor(struct ldap_request *req)
534 {
535         if (req->state == LDAP_REQUEST_PENDING) {
536                 DLIST_REMOVE(req->conn->pending, req);
537         }
538         return 0;
539 }
540
541 /*
542   called on timeout of a ldap request
543 */
544 static void ldap_request_timeout(struct event_context *ev, struct timed_event *te, 
545                                       struct timeval t, void *private_data)
546 {
547         struct ldap_request *req = talloc_get_type(private_data, struct ldap_request);
548         req->status = NT_STATUS_IO_TIMEOUT;
549         if (req->state == LDAP_REQUEST_PENDING) {
550                 DLIST_REMOVE(req->conn->pending, req);
551         }
552         req->state = LDAP_REQUEST_DONE;
553         if (req->async.fn) {
554                 req->async.fn(req);
555         }
556 }
557
558
559 /*
560   called on completion of a one-way ldap request
561 */
562 static void ldap_request_complete(struct event_context *ev, struct timed_event *te, 
563                                   struct timeval t, void *private_data)
564 {
565         struct ldap_request *req = talloc_get_type(private_data, struct ldap_request);
566         if (req->async.fn) {
567                 req->async.fn(req);
568         }
569 }
570
571 /*
572   send a ldap message - async interface
573 */
574 _PUBLIC_ struct ldap_request *ldap_request_send(struct ldap_connection *conn,
575                                        struct ldap_message *msg)
576 {
577         struct ldap_request *req;
578         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
579
580         req = talloc_zero(conn, struct ldap_request);
581         if (req == NULL) return NULL;
582
583         if (conn->sock == NULL) {
584                 status = NT_STATUS_INVALID_CONNECTION;
585                 goto failed;
586         }
587
588         req->state       = LDAP_REQUEST_SEND;
589         req->conn        = conn;
590         req->messageid   = conn->next_messageid++;
591         if (conn->next_messageid == 0) {
592                 conn->next_messageid = 1;
593         }
594         req->type        = msg->type;
595         if (req->messageid == -1) {
596                 goto failed;
597         }
598
599         talloc_set_destructor(req, ldap_request_destructor);
600
601         msg->messageid = req->messageid;
602
603         if (!ldap_encode(msg, &req->data, req)) {
604                 status = NT_STATUS_INTERNAL_ERROR;
605                 goto failed;            
606         }
607
608         status = packet_send(conn->packet, req->data);
609         if (!NT_STATUS_IS_OK(status)) {
610                 goto failed;
611         }
612
613         /* some requests don't expect a reply, so don't add those to the
614            pending queue */
615         if (req->type == LDAP_TAG_AbandonRequest ||
616             req->type == LDAP_TAG_UnbindRequest) {
617                 req->status = NT_STATUS_OK;
618                 req->state = LDAP_REQUEST_DONE;
619                 /* we can't call the async callback now, as it isn't setup, so
620                    call it as next event */
621                 event_add_timed(conn->event.event_ctx, req, timeval_zero(),
622                                 ldap_request_complete, req);
623                 return req;
624         }
625
626         req->state = LDAP_REQUEST_PENDING;
627         DLIST_ADD(conn->pending, req);
628
629         /* put a timeout on the request */
630         req->time_event = event_add_timed(conn->event.event_ctx, req, 
631                                           timeval_current_ofs(conn->timeout, 0),
632                                           ldap_request_timeout, req);
633
634         return req;
635
636 failed:
637         req->status = status;
638         req->state = LDAP_REQUEST_ERROR;
639         event_add_timed(conn->event.event_ctx, req, timeval_zero(),
640                         ldap_request_complete, req);
641
642         return req;
643 }
644
645
646 /*
647   wait for a request to complete
648   note that this does not destroy the request
649 */
650 _PUBLIC_ NTSTATUS ldap_request_wait(struct ldap_request *req)
651 {
652         while (req->state < LDAP_REQUEST_DONE) {
653                 if (event_loop_once(req->conn->event.event_ctx) != 0) {
654                         req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
655                         break;
656                 }
657         }
658         return req->status;
659 }
660
661
662 /*
663   a mapping of ldap response code to strings
664 */
665 static const struct {
666         enum ldap_result_code code;
667         const char *str;
668 } ldap_code_map[] = {
669 #define _LDAP_MAP_CODE(c) { c, #c }
670         _LDAP_MAP_CODE(LDAP_SUCCESS),
671         _LDAP_MAP_CODE(LDAP_OPERATIONS_ERROR),
672         _LDAP_MAP_CODE(LDAP_PROTOCOL_ERROR),
673         _LDAP_MAP_CODE(LDAP_TIME_LIMIT_EXCEEDED),
674         _LDAP_MAP_CODE(LDAP_SIZE_LIMIT_EXCEEDED),
675         _LDAP_MAP_CODE(LDAP_COMPARE_FALSE),
676         _LDAP_MAP_CODE(LDAP_COMPARE_TRUE),
677         _LDAP_MAP_CODE(LDAP_AUTH_METHOD_NOT_SUPPORTED),
678         _LDAP_MAP_CODE(LDAP_STRONG_AUTH_REQUIRED),
679         _LDAP_MAP_CODE(LDAP_REFERRAL),
680         _LDAP_MAP_CODE(LDAP_ADMIN_LIMIT_EXCEEDED),
681         _LDAP_MAP_CODE(LDAP_UNAVAILABLE_CRITICAL_EXTENSION),
682         _LDAP_MAP_CODE(LDAP_CONFIDENTIALITY_REQUIRED),
683         _LDAP_MAP_CODE(LDAP_SASL_BIND_IN_PROGRESS),
684         _LDAP_MAP_CODE(LDAP_NO_SUCH_ATTRIBUTE),
685         _LDAP_MAP_CODE(LDAP_UNDEFINED_ATTRIBUTE_TYPE),
686         _LDAP_MAP_CODE(LDAP_INAPPROPRIATE_MATCHING),
687         _LDAP_MAP_CODE(LDAP_CONSTRAINT_VIOLATION),
688         _LDAP_MAP_CODE(LDAP_ATTRIBUTE_OR_VALUE_EXISTS),
689         _LDAP_MAP_CODE(LDAP_INVALID_ATTRIBUTE_SYNTAX),
690         _LDAP_MAP_CODE(LDAP_NO_SUCH_OBJECT),
691         _LDAP_MAP_CODE(LDAP_ALIAS_PROBLEM),
692         _LDAP_MAP_CODE(LDAP_INVALID_DN_SYNTAX),
693         _LDAP_MAP_CODE(LDAP_ALIAS_DEREFERENCING_PROBLEM),
694         _LDAP_MAP_CODE(LDAP_INAPPROPRIATE_AUTHENTICATION),
695         _LDAP_MAP_CODE(LDAP_INVALID_CREDENTIALS),
696         _LDAP_MAP_CODE(LDAP_INSUFFICIENT_ACCESS_RIGHTS),
697         _LDAP_MAP_CODE(LDAP_BUSY),
698         _LDAP_MAP_CODE(LDAP_UNAVAILABLE),
699         _LDAP_MAP_CODE(LDAP_UNWILLING_TO_PERFORM),
700         _LDAP_MAP_CODE(LDAP_LOOP_DETECT),
701         _LDAP_MAP_CODE(LDAP_NAMING_VIOLATION),
702         _LDAP_MAP_CODE(LDAP_OBJECT_CLASS_VIOLATION),
703         _LDAP_MAP_CODE(LDAP_NOT_ALLOWED_ON_NON_LEAF),
704         _LDAP_MAP_CODE(LDAP_NOT_ALLOWED_ON_RDN),
705         _LDAP_MAP_CODE(LDAP_ENTRY_ALREADY_EXISTS),
706         _LDAP_MAP_CODE(LDAP_OBJECT_CLASS_MODS_PROHIBITED),
707         _LDAP_MAP_CODE(LDAP_AFFECTS_MULTIPLE_DSAS),
708         _LDAP_MAP_CODE(LDAP_OTHER)
709 };
710
711 /*
712   used to setup the status code from a ldap response
713 */
714 _PUBLIC_ NTSTATUS ldap_check_response(struct ldap_connection *conn, struct ldap_Result *r)
715 {
716         int i;
717         const char *codename = "unknown";
718
719         if (r->resultcode == LDAP_SUCCESS) {
720                 return NT_STATUS_OK;
721         }
722
723         if (conn->last_error) {
724                 talloc_free(conn->last_error);
725         }
726
727         for (i=0;i<ARRAY_SIZE(ldap_code_map);i++) {
728                 if (r->resultcode == ldap_code_map[i].code) {
729                         codename = ldap_code_map[i].str;
730                         break;
731                 }
732         }
733
734         conn->last_error = talloc_asprintf(conn, "LDAP error %u %s - %s <%s> <%s>", 
735                                            r->resultcode,
736                                            codename,
737                                            r->dn?r->dn:"(NULL)", 
738                                            r->errormessage?r->errormessage:"", 
739                                            r->referral?r->referral:"");
740         
741         return NT_STATUS_LDAP(r->resultcode);
742 }
743
744 /*
745   return error string representing the last error
746 */
747 _PUBLIC_ const char *ldap_errstr(struct ldap_connection *conn, 
748                         TALLOC_CTX *mem_ctx, 
749                         NTSTATUS status)
750 {
751         if (NT_STATUS_IS_LDAP(status) && conn->last_error != NULL) {
752                 return talloc_strdup(mem_ctx, conn->last_error);
753         }
754         return talloc_asprintf(mem_ctx, "LDAP client internal error: %s", nt_errstr(status));
755 }
756
757
758 /*
759   return the Nth result message, waiting if necessary
760 */
761 _PUBLIC_ NTSTATUS ldap_result_n(struct ldap_request *req, int n, struct ldap_message **msg)
762 {
763         *msg = NULL;
764
765         NT_STATUS_HAVE_NO_MEMORY(req);
766
767         while (req->state < LDAP_REQUEST_DONE && n >= req->num_replies) {
768                 if (event_loop_once(req->conn->event.event_ctx) != 0) {
769                         return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
770                 }
771         }
772
773         if (n < req->num_replies) {
774                 *msg = req->replies[n];
775                 return NT_STATUS_OK;
776         }
777
778         if (!NT_STATUS_IS_OK(req->status)) {
779                 return req->status;
780         }
781
782         return NT_STATUS_NO_MORE_ENTRIES;
783 }
784
785
786 /*
787   return a single result message, checking if it is of the expected LDAP type
788 */
789 _PUBLIC_ NTSTATUS ldap_result_one(struct ldap_request *req, struct ldap_message **msg, int type)
790 {
791         NTSTATUS status;
792         status = ldap_result_n(req, 0, msg);
793         if (!NT_STATUS_IS_OK(status)) {
794                 return status;
795         }
796         if ((*msg)->type != type) {
797                 *msg = NULL;
798                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
799         }
800         return status;
801 }
802
803 /*
804   a simple ldap transaction, for single result requests that only need a status code
805   this relies on single valued requests having the response type == request type + 1
806 */
807 _PUBLIC_ NTSTATUS ldap_transaction(struct ldap_connection *conn, struct ldap_message *msg)
808 {
809         struct ldap_request *req = ldap_request_send(conn, msg);
810         struct ldap_message *res;
811         NTSTATUS status;
812         status = ldap_result_n(req, 0, &res);
813         if (!NT_STATUS_IS_OK(status)) {
814                 talloc_free(req);
815                 return status;
816         }
817         if (res->type != msg->type + 1) {
818                 talloc_free(req);
819                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
820         }
821         status = ldap_check_response(conn, &res->r.GeneralResult);
822         talloc_free(req);
823         return status;
824 }