s4: fix various warnings (not "const" related ones)

[sfrench/samba-autobuild/.git] / source4 / libcli / ldap / ldap_client.c

diff --git a/source4/libcli/ldap/ldap_client.c b/source4/libcli/ldap/ldap_client.c
index 082f6fa3e4402f60805bd097268eceb431abafc0..3c78a7c7e29dc0f5a7d58a25466044ee8db1ad81 100644 (file)
--- a/source4/libcli/ldap/ldap_client.c
+++ b/source4/libcli/ldap/ldap_client.c
@@ -23,10 +23,10 @@
 */
 
 #include "includes.h"
+#include <tevent.h>
+#include "lib/socket/socket.h"
 #include "../lib/util/asn1.h"
 #include "../lib/util/dlinklist.h"
-#include "lib/events/events.h"
-#include "lib/socket/socket.h"
 #include "libcli/ldap/ldap.h"
 #include "libcli/ldap/ldap_proto.h"
 #include "libcli/ldap/ldap_client.h"
@@ -43,7 +43,7 @@
 */
 _PUBLIC_ struct ldap_connection *ldap4_new_connection(TALLOC_CTX *mem_ctx, 
                                             struct loadparm_context *lp_ctx,
-                                            struct event_context *ev)
+                                            struct tevent_context *ev)
 {
        struct ldap_connection *conn;
 
@@ -200,7 +200,7 @@ static NTSTATUS ldap_recv_handler(void *private_data, DATA_BLOB blob)
                return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
        }
        
-       status = ldap_decode(asn1, msg);
+       status = ldap_decode(asn1, samba_ldap_control_handlers(), msg);
        if (!NT_STATUS_IS_OK(status)) {
                asn1_free(asn1);
                return status;
@@ -224,16 +224,16 @@ void ldap_read_io_handler(void *private_data, uint16_t flags)
 /*
   handle ldap socket events
 */
-static void ldap_io_handler(struct event_context *ev, struct fd_event *fde, 
+static void ldap_io_handler(struct tevent_context *ev, struct tevent_fd *fde, 
                            uint16_t flags, void *private_data)
 {
        struct ldap_connection *conn = talloc_get_type(private_data, 
                                                       struct ldap_connection);
-       if (flags & EVENT_FD_WRITE) {
+       if (flags & TEVENT_FD_WRITE) {
                packet_queue_run(conn->packet);
                if (!tls_enabled(conn->sock)) return;
        }
-       if (flags & EVENT_FD_READ) {
+       if (flags & TEVENT_FD_READ) {
                ldap_read_io_handler(private_data, flags);
        }
 }
@@ -335,7 +335,9 @@ _PUBLIC_ struct composite_context *ldap_connect_send(struct ldap_connection *con
                SMB_ASSERT(sizeof(protocol)>10);
                SMB_ASSERT(sizeof(path)>1024);
        
-               /* LDAPI connections are to localhost, so give the local host name as the target for gensec */
+               /* LDAPI connections are to localhost, so give the
+                * local host name as the target for gensec's
+                * DIGEST-MD5 mechanism */
                conn->host = talloc_asprintf(conn, "%s.%s", lp_netbios_name(conn->lp_ctx),  lp_realm(conn->lp_ctx));
                if (composite_nomem(conn->host, state->ctx)) {
                        return result;
@@ -387,20 +389,20 @@ static void ldap_connect_got_sock(struct composite_context *ctx,
                                  struct ldap_connection *conn) 
 {
        /* setup a handler for events on this socket */
-       conn->event.fde = event_add_fd(conn->event.event_ctx, conn->sock, 
-                                      socket_get_fd(conn->sock), 
-                                      EVENT_FD_READ | EVENT_FD_AUTOCLOSE, ldap_io_handler, conn);
+       conn->event.fde = tevent_add_fd(conn->event.event_ctx, conn->sock,
+                                       socket_get_fd(conn->sock),
+                                       TEVENT_FD_READ, ldap_io_handler, conn);
        if (conn->event.fde == NULL) {
                composite_error(ctx, NT_STATUS_INTERNAL_ERROR);
                return;
        }
 
+       tevent_fd_set_close_fn(conn->event.fde, socket_tevent_fd_close_fn);
        socket_set_flags(conn->sock, SOCKET_FLAG_NOCLOSE);
 
        talloc_steal(conn, conn->sock);
        if (conn->ldaps) {
                struct socket_context *tls_socket;
-               struct socket_context *tmp_socket;
                char *cafile = lp_tls_cafile(conn->sock, conn->lp_ctx);
 
                if (!cafile || !*cafile) {
@@ -416,10 +418,7 @@ static void ldap_connect_got_sock(struct composite_context *ctx,
                        return;
                }
 
-               /* the original socket, must become a child of the tls socket */
-               tmp_socket = conn->sock;
                conn->sock = talloc_steal(conn, tls_socket);
-               talloc_steal(conn->sock, tmp_socket);
        }
 
        conn->packet = packet_init(conn);
@@ -437,6 +436,10 @@ static void ldap_connect_got_sock(struct composite_context *ctx,
        packet_set_fde(conn->packet, conn->event.fde);
 /*     packet_set_serialise(conn->packet); */
 
+       if (conn->ldaps) {
+               packet_set_unreliable_select(conn->packet);
+       }
+
        composite_done(ctx);
 }
 
@@ -544,7 +547,7 @@ static int ldap_request_destructor(struct ldap_request *req)
 /*
   called on timeout of a ldap request
 */
-static void ldap_request_timeout(struct event_context *ev, struct timed_event *te, 
+static void ldap_request_timeout(struct tevent_context *ev, struct tevent_timer *te, 
                                      struct timeval t, void *private_data)
 {
        struct ldap_request *req = talloc_get_type(private_data, struct ldap_request);
@@ -562,7 +565,7 @@ static void ldap_request_timeout(struct event_context *ev, struct timed_event *t
 /*
   called on completion of a one-way ldap request
 */
-static void ldap_request_complete(struct event_context *ev, struct timed_event *te, 
+static void ldap_request_complete(struct tevent_context *ev, struct tevent_timer *te, 
                                  struct timeval t, void *private_data)
 {
        struct ldap_request *req = talloc_get_type(private_data, struct ldap_request);
@@ -603,7 +606,7 @@ _PUBLIC_ struct ldap_request *ldap_request_send(struct ldap_connection *conn,
 
        msg->messageid = req->messageid;
 
-       if (!ldap_encode(msg, &req->data, req)) {
+       if (!ldap_encode(msg, samba_ldap_control_handlers(), &req->data, req)) {
                status = NT_STATUS_INTERNAL_ERROR;
                goto failed;            
        }
@@ -621,8 +624,8 @@ _PUBLIC_ struct ldap_request *ldap_request_send(struct ldap_connection *conn,
                req->state = LDAP_REQUEST_DONE;
                /* we can't call the async callback now, as it isn't setup, so
                   call it as next event */
-               event_add_timed(conn->event.event_ctx, req, timeval_zero(),
-                               ldap_request_complete, req);
+               tevent_add_timer(conn->event.event_ctx, req, timeval_zero(),
+                                ldap_request_complete, req);
                return req;
        }
 
@@ -630,17 +633,17 @@ _PUBLIC_ struct ldap_request *ldap_request_send(struct ldap_connection *conn,
        DLIST_ADD(conn->pending, req);
 
        /* put a timeout on the request */
-       req->time_event = event_add_timed(conn->event.event_ctx, req, 
-                                         timeval_current_ofs(conn->timeout, 0),
-                                         ldap_request_timeout, req);
+       req->time_event = tevent_add_timer(conn->event.event_ctx, req,
+                                          timeval_current_ofs(conn->timeout, 0),
+                                          ldap_request_timeout, req);
 
        return req;
 
 failed:
        req->status = status;
        req->state = LDAP_REQUEST_ERROR;
-       event_add_timed(conn->event.event_ctx, req, timeval_zero(),
-                       ldap_request_complete, req);
+       tevent_add_timer(conn->event.event_ctx, req, timeval_zero(),
+                        ldap_request_complete, req);
 
        return req;
 }
@@ -653,7 +656,7 @@ failed:
 _PUBLIC_ NTSTATUS ldap_request_wait(struct ldap_request *req)
 {
        while (req->state < LDAP_REQUEST_DONE) {
-               if (event_loop_once(req->conn->event.event_ctx) != 0) {
+               if (tevent_loop_once(req->conn->event.event_ctx) != 0) {
                        req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
                        break;
                }
@@ -768,7 +771,7 @@ _PUBLIC_ NTSTATUS ldap_result_n(struct ldap_request *req, int n, struct ldap_mes
        NT_STATUS_HAVE_NO_MEMORY(req);
 
        while (req->state < LDAP_REQUEST_DONE && n >= req->num_replies) {
-               if (event_loop_once(req->conn->event.event_ctx) != 0) {
+               if (tevent_loop_once(req->conn->event.event_ctx) != 0) {
                        return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
                }
        }