Changeset 988 for vendor/current/source4/libcli

vendor/current/source4/libcli/cliconnect.c

-              r740
+              r988
 #include "libcli/auth/libcli_auth.h"
 #include "libcli/smb_composite/smb_composite.h"
+#include "libcli/smb/smbXcli_base.h"
 /*
 …
                            struct resolve_context *resolve_ctx,
                            struct smbcli_options *options,
+               const char *socket_options)
+{
+        struct smbcli_socket *sock;
+        sock = smbcli_sock_connect_byname(server, ports, NULL,
+                                          resolve_ctx, ev_ctx,
+                      socket_options);
+        if (sock == NULL) return false;
+        cli->transport = smbcli_transport_init(sock, cli, true, options);
+        if (!cli->transport) {
+                           const char *socket_options,
+                           struct nbt_name *calling,
+                           struct nbt_name *called)
+{
+        NTSTATUS status;
+        cli->options = *options;
+        status = smbcli_sock_connect(cli,
+                                     NULL, /* host_addr */
+                                     ports,
+                                     server,
+                                     resolve_ctx,
+                                     ev_ctx,
+                                     socket_options,
+                                     calling,
+                                     called,
+                                     &cli->sock);
+        if (!NT_STATUS_IS_OK(status)) {
                 return false;
+        }
         return true;
+}
-/* wrapper around smbcli_transport_connect() */
-bool smbcli_transport_establish(struct smbcli_state *cli,
-                                struct nbt_name *calling,
-                                struct nbt_name *called)
+{
-        return smbcli_transport_connect(cli->transport, calling, called);
+}
 …
 NTSTATUS smbcli_negprot(struct smbcli_state *cli, bool unicode, int maxprotocol)
+{
+        return smb_raw_negotiate(cli->transport, unicode, maxprotocol);
+        if (unicode) {
+                cli->options.unicode = 1;
+        } else {
+                cli->options.unicode = 0;
+        }
+        cli->transport = smbcli_transport_init(cli->sock, cli,
+                                               true, &cli->options);
+        cli->sock = NULL;
+        if (!cli->transport) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        return smb_raw_negotiate(cli->transport, unicode, PROTOCOL_CORE, maxprotocol);
+}
 …
         /* setup a tree connect */
         tcon.generic.level = RAW_TCON_TCONX;
+        tcon.tconx.in.flags = 0;
+        tcon.tconx.in.flags = TCONX_FLAG_EXTENDED_RESPONSE;
+        tcon.tconx.in.flags |= TCONX_FLAG_EXTENDED_SIGNATURES;
         if (cli->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) {
                 tcon.tconx.in.password = data_blob(NULL, 0);
 …
         cli->tree->tid = tcon.tconx.out.tid;
+        if (tcon.tconx.out.options & SMB_EXTENDED_SIGNATURES) {
+                smb1cli_session_protect_session_key(cli->tree->session->smbXcli);
+        }
         talloc_free(mem_ctx);

vendor/current/source4/libcli/clifile.c

-              r740
+              r988
 /****************************************************************************
- Map standard UNIX permissions onto wire representations.
-****************************************************************************/
-uint32_t unix_perms_to_wire(mode_t perms)
+{
-        unsigned int ret = 0;
-        ret |= ((perms & S_IXOTH) ?  UNIX_X_OTH : 0);
-        ret |= ((perms & S_IWOTH) ?  UNIX_W_OTH : 0);
-        ret |= ((perms & S_IROTH) ?  UNIX_R_OTH : 0);
-        ret |= ((perms & S_IXGRP) ?  UNIX_X_GRP : 0);
-        ret |= ((perms & S_IWGRP) ?  UNIX_W_GRP : 0);
-        ret |= ((perms & S_IRGRP) ?  UNIX_R_GRP : 0);
-        ret |= ((perms & S_IXUSR) ?  UNIX_X_USR : 0);
-        ret |= ((perms & S_IWUSR) ?  UNIX_W_USR : 0);
-        ret |= ((perms & S_IRUSR) ?  UNIX_R_USR : 0);
-#ifdef S_ISVTX
-        ret |= ((perms & S_ISVTX) ?  UNIX_STICKY : 0);
-#endif
-#ifdef S_ISGID
-        ret |= ((perms & S_ISGID) ?  UNIX_SET_GID : 0);
-#endif
-#ifdef S_ISUID
-        ret |= ((perms & S_ISUID) ?  UNIX_SET_UID : 0);
-#endif
-        return ret;
+}
-/****************************************************************************
  Symlink a file (UNIX extensions).
 ****************************************************************************/
 …
         TALLOC_CTX *mem_ctx;
         NTSTATUS status;
+        int ret = -1;
         mem_ctx = talloc_init("raw_open");
         if (!mem_ctx) return -1;
+        if (!mem_ctx) return ret;
         open_parms.openx.level = RAW_OPEN_CTEMP;
 …
         status = smb_raw_open(tree, mem_ctx, &open_parms);
+        if (tmp_path) {
+                *tmp_path = strdup(open_parms.ctemp.out.name);
+        if (NT_STATUS_IS_OK(status)) {
+                if (tmp_path) {
+                        *tmp_path = strdup(open_parms.ctemp.out.name);
+                }
+                ret = open_parms.ctemp.out.file.fnum;
+        }
         talloc_free(mem_ctx);
+        if (NT_STATUS_IS_OK(status)) {
+                return open_parms.ctemp.out.file.fnum;
+        }
+        return -1;
+}
+        return ret;
+}

vendor/current/source4/libcli/clilist.c

-              r414
+              r988
         int max_matches = 512;
         char *mask;
         int ff_eos = 0, i, ff_searchcount;
+        int ff_eos = 0, i;
         int ff_dir_handle=0;
 …
                         ff_dir_handle = first_parms.t2ffirst.out.handle;
-                        ff_searchcount = first_parms.t2ffirst.out.count;
                         ff_eos = first_parms.t2ffirst.out.end_of_search;
 …
                                 return -1;
+                        }
-                        ff_searchcount = next_parms.t2fnext.out.count;
                         ff_eos = next_parms.t2fnext.out.end_of_search;
                         received = next_parms.t2fnext.out.count;

vendor/current/source4/libcli/climessage.c

-              r414
+              r988
         req = smbcli_request_setup(tree, SMBsendstrt, 0, 0);
+        if (req == NULL) {
+                return false;
+        }
         smbcli_req_append_string(req, username, STR_TERMINATE);
         smbcli_req_append_string(req, host, STR_TERMINATE);
 …
         req = smbcli_request_setup(tree, SMBsendtxt, 1, 0);
+        if (req == NULL) {
+                return false;
+        }
         SSVAL(req->out.vwv, VWV(0), grp);
 …
         req = smbcli_request_setup(tree, SMBsendend, 1, 0);
+        if (req == NULL) {
+                return false;
+        }
         SSVAL(req->out.vwv, VWV(0), grp);

vendor/current/source4/libcli/clireadwrite.c

-              r414
+              r988
         parms.writex.in.wmode = write_mode;
         parms.writex.in.remaining = 0;
         while (total < size) {
+        do {
                 NTSTATUS status;
 …
                 total += parms.writex.out.nwritten;
                 buf += parms.writex.out.nwritten;
+        }
+        } while (total < size);
         return total;

vendor/current/source4/libcli/composite/composite.c

-              r740
+              r988
         while (c->state < COMPOSITE_STATE_DONE) {
                 if (event_loop_once(c->event_ctx) != 0) {
+                if (tevent_loop_once(c->event_ctx) != 0) {
                         return NT_STATUS_UNSUCCESSFUL;
+                }
 …
+        }
         if (!ctx->used_wait && !ctx->async.fn) {
                 event_add_timed(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
+                tevent_add_timer(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
+        }
         ctx->status = status;
 …
+{
         if (!ctx->used_wait && !ctx->async.fn) {
                 event_add_timed(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
+                tevent_add_timer(ctx->event_ctx, ctx, timeval_zero(), composite_trigger, ctx);
+        }
         ctx->state = COMPOSITE_STATE_DONE;
 …
            immediate event, otherwise we can be stuck forever */
         if (new_ctx->state >= COMPOSITE_STATE_DONE && continuation) {
                 event_add_timed(new_ctx->event_ctx, new_ctx, timeval_zero(), composite_trigger, new_ctx);
+                tevent_add_timer(new_ctx->event_ctx, new_ctx, timeval_zero(), composite_trigger, new_ctx);
+        }
+}
 …
+{
         if (composite_nomem(new_req, ctx)) return;
+        if (new_req->state > SMBCLI_REQUEST_RECV) {
+                composite_error(ctx, new_req->status);
+                return;
+        }
         new_req->async.fn = continuation;
         new_req->async.private_data = private_data;
 …
+{
         if (composite_nomem(new_req, ctx)) return;
+        if (new_req->state > SMB2_REQUEST_RECV) {
+                composite_error(ctx, new_req->status);
+                return;
+        }
         new_req->async.fn = continuation;
         new_req->async.private_data = private_data;

vendor/current/source4/libcli/dgram/dgramsocket.c

-              r740
+              r988
         blob = data_blob_talloc(tmp_ctx, NULL, dsize);
         if (blob.data == NULL) {
+        if ((dsize != 0) && (blob.data == NULL)) {
                 talloc_free(tmp_ctx);
                 return;
 …
+        }
         EVENT_FD_NOT_WRITEABLE(dgmsock->fde);
+        TEVENT_FD_NOT_WRITEABLE(dgmsock->fde);
         return;
+}
 …
         struct nbt_dgram_socket *dgmsock = talloc_get_type(private_data,
                                                            struct nbt_dgram_socket);
         if (flags & EVENT_FD_WRITE) {
+        if (flags & TEVENT_FD_WRITE) {
                 dgm_socket_send(dgmsock);
+        }
         if (flags & EVENT_FD_READ) {
+        if (flags & TEVENT_FD_READ) {
                 dgm_socket_recv(dgmsock);
+        }
 …
         talloc_steal(dgmsock, dgmsock->sock);
         dgmsock->fde = event_add_fd(dgmsock->event_ctx, dgmsock,
+        dgmsock->fde = tevent_add_fd(dgmsock->event_ctx, dgmsock,
                                     socket_get_fd(dgmsock->sock), 0,
                                     dgm_socket_handler, dgmsock);
 …
         dgmsock->incoming.handler = handler;
         dgmsock->incoming.private_data = private_data;
         EVENT_FD_READABLE(dgmsock->fde);
+        TEVENT_FD_READABLE(dgmsock->fde);
         return NT_STATUS_OK;
+}
 …
+        }
         DLIST_ADD_END(dgmsock->send_queue, req, struct nbt_dgram_request *);
         EVENT_FD_WRITEABLE(dgmsock->fde);
+        DLIST_ADD_END(dgmsock->send_queue, req);
+        TEVENT_FD_WRITEABLE(dgmsock->fde);
         return NT_STATUS_OK;

vendor/current/source4/libcli/dgram/mailslot.c

r740	r988
72	72	talloc_set_destructor(dgmslot, dgram_mailslot_destructor);
73	73
74		EVENT_FD_READABLE(dgmsock->fde);
	74	TEVENT_FD_READABLE(dgmsock->fde);
75	75
76	76	return dgmslot;

vendor/current/source4/libcli/finddcs_cldap.c

-              r740
+              r988
 #include "libcli/security/security.h"
 #include "lib/util/tevent_ntstatus.h"
+#include "lib/tsocket/tsocket.h"
 #include "libcli/composite/composite.h"
+#include "lib/util/util_net.h"
 struct finddcs_cldap_state {
 …
         struct cldap_socket *cldap;
         struct cldap_netlogon *netlogon;
+        NTSTATUS status;
 };
 …
                                      struct resolve_context *resolve_ctx,
                                      struct tevent_context *event_ctx);
+static void finddcs_cldap_nbt_resolved(struct composite_context *ctx);
+static bool finddcs_cldap_name_lookup(struct finddcs_cldap_state *state,
+                                      struct finddcs *io,
+                                      struct resolve_context *resolve_ctx,
+                                      struct tevent_context *event_ctx);
 static void finddcs_cldap_name_resolved(struct composite_context *ctx);
 static void finddcs_cldap_next_server(struct finddcs_cldap_state *state);
 …
 /*
  * find a list of DCs via DNS/CLDAP
+ *
  */
 struct tevent_req *finddcs_cldap_send(TALLOC_CTX *mem_ctx,
 …
         state->ev = event_ctx;
         state->minimum_dc_flags = io->in.minimum_dc_flags;
+        state->domain_name = talloc_strdup(state, io->in.domain_name);
+        if (tevent_req_nomem(state->domain_name, req)) {
+                return tevent_req_post(req, event_ctx);
+        if (io->in.domain_name) {
+                state->domain_name = talloc_strdup(state, io->in.domain_name);
+                if (tevent_req_nomem(state->domain_name, req)) {
+                        return tevent_req_post(req, event_ctx);
+                }
+        } else {
+                state->domain_name = NULL;
+        }
 …
         if (io->in.server_address) {
+                DEBUG(4,("finddcs: searching for a DC by IP %s\n", io->in.server_address));
+                if (!finddcs_cldap_ipaddress(state, io)) {
+                        return tevent_req_post(req, event_ctx);
+                }
+        } else if (strchr(state->domain_name, '.')) {
+                /* looks like a DNS name */
+                DEBUG(4,("finddcs: searching for a DC by DNS domain %s\n", state->domain_name));
+                if (!finddcs_cldap_srv_lookup(state, io, resolve_ctx, event_ctx)) {
+                        return tevent_req_post(req, event_ctx);
+                if (is_ipaddress(io->in.server_address)) {
+                        DEBUG(4,("finddcs: searching for a DC by IP %s\n",
+                                 io->in.server_address));
+                        if (!finddcs_cldap_ipaddress(state, io)) {
+                                return tevent_req_post(req, event_ctx);
+                        }
+                } else {
+                        if (!finddcs_cldap_name_lookup(state, io, resolve_ctx,
+                                                       event_ctx)) {
+                                return tevent_req_post(req, event_ctx);
+                        }
+                }
+        } else if (io->in.domain_name) {
+                if (strchr(state->domain_name, '.')) {
+                        /* looks like a DNS name */
+                        DEBUG(4,("finddcs: searching for a DC by DNS domain %s\n", state->domain_name));
+                        if (!finddcs_cldap_srv_lookup(state, io, resolve_ctx,
+                                                      event_ctx)) {
+                                return tevent_req_post(req, event_ctx);
+                        }
+                } else {
+                        DEBUG(4,("finddcs: searching for a DC by NBT lookup %s\n", state->domain_name));
+                        if (!finddcs_cldap_nbt_lookup(state, io, resolve_ctx,
+                                                      event_ctx)) {
+                                return tevent_req_post(req, event_ctx);
+                        }
+                }
         } else {
                 DEBUG(4,("finddcs: searching for a DC by NBT lookup %s\n", state->domain_name));
                 if (!finddcs_cldap_nbt_lookup(state, io, resolve_ctx, event_ctx)) {
                         return tevent_req_post(req, event_ctx);
+                }
+                /* either we have the domain name or the IP address */
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER_MIX);
+                DEBUG(2,("finddcs: Please specify at least the domain name or the IP address! \n"));
+                return tevent_req_post(req, event_ctx);
+        }
 …
         state->srv_addresses[1] = NULL;
         state->srv_address_index = 0;
-        status = cldap_socket_init(state, state->ev, NULL, NULL, &state->cldap);
-        if (tevent_req_nterror(state->req, status)) {
-                return false;
+        }
         finddcs_cldap_next_server(state);
 …
                 return false;
+        }
+        creq->async.fn = finddcs_cldap_nbt_resolved;
+        creq->async.private_data = state;
+        return true;
+}
+static bool finddcs_cldap_name_lookup(struct finddcs_cldap_state *state,
+                                      struct finddcs *io,
+                                      struct resolve_context *resolve_ctx,
+                                      struct tevent_context *event_ctx)
+{
+        struct composite_context *creq;
+        struct nbt_name name;
+        make_nbt_name(&name, io->in.server_address, NBT_NAME_SERVER);
+        creq = resolve_name_send(resolve_ctx, state, &name, event_ctx);
+        if (tevent_req_nomem(creq, state->req)) {
+                return false;
+        }
         creq->async.fn = finddcs_cldap_name_resolved;
         creq->async.private_data = state;
 …
+{
         struct tevent_req *subreq;
+        struct tsocket_address *dest;
+        int ret;
+        TALLOC_FREE(state->cldap);
         if (state->srv_addresses[state->srv_address_index] == NULL) {
+                tevent_req_nterror(state->req, NT_STATUS_OBJECT_NAME_NOT_FOUND);
+                if (NT_STATUS_IS_OK(state->status)) {
+                        tevent_req_nterror(state->req, NT_STATUS_OBJECT_NAME_NOT_FOUND);
+                } else {
+                        tevent_req_nterror(state->req, state->status);
+                }
                 DEBUG(2,("finddcs: No matching CLDAP server found\n"));
                 return;
+        }
+        /* we should get the port from the SRV response */
+        ret = tsocket_address_inet_from_strings(state, "ip",
+                                                state->srv_addresses[state->srv_address_index],
+,
+                                                &dest);
+        if (ret == 0) {
+                state->status = NT_STATUS_OK;
+        } else {
+                state->status = map_nt_error_from_unix_common(errno);
+        }
+        if (!NT_STATUS_IS_OK(state->status)) {
+                state->srv_address_index++;
+                finddcs_cldap_next_server(state);
+                return;
+        }
+        state->status = cldap_socket_init(state, NULL, dest, &state->cldap);
+        if (!NT_STATUS_IS_OK(state->status)) {
+                state->srv_address_index++;
+                finddcs_cldap_next_server(state);
+                return;
+        }
+        TALLOC_FREE(state->netlogon);
         state->netlogon = talloc_zero(state, struct cldap_netlogon);
         if (tevent_req_nomem(state->netlogon, state->req)) {
                 return;
+        }
         state->netlogon->in.dest_address = state->srv_addresses[state->srv_address_index];
         /* we should get the port from the SRV response */
+        state->netlogon->in.dest_port = 389;
         if (strchr(state->domain_name, '.')) {
+        if (state->netlogon == NULL) {
+                state->status = NT_STATUS_NO_MEMORY;
+                state->srv_address_index++;
+                finddcs_cldap_next_server(state);
+                return;
+        }
+        if ((state->domain_name != NULL) && (strchr(state->domain_name, '.'))) {
                 state->netlogon->in.realm = state->domain_name;
+        }
         if (state->domain_sid) {
                 state->netlogon->in.domain_sid = dom_sid_string(state, state->domain_sid);
+                if (tevent_req_nomem(state->netlogon->in.domain_sid, state->req)) {
+                if (state->netlogon->in.domain_sid == NULL) {
+                        state->status = NT_STATUS_NO_MEMORY;
+                        state->srv_address_index++;
+                        finddcs_cldap_next_server(state);
                         return;
+                }
 …
         state->netlogon->in.map_response = true;
+        DEBUG(4,("finddcs: performing CLDAP query on %s\n", state->netlogon->in.dest_address));
+        subreq = cldap_netlogon_send(state, state->cldap, state->netlogon);
+        if (tevent_req_nomem(subreq, state->req)) {
+        DEBUG(4,("finddcs: performing CLDAP query on %s\n",
+                 state->srv_addresses[state->srv_address_index]));
+        subreq = cldap_netlogon_send(state, state->ev,
+                                     state->cldap, state->netlogon);
+        if (subreq == NULL) {
+                state->status = NT_STATUS_NO_MEMORY;
+                state->srv_address_index++;
+                finddcs_cldap_next_server(state);
                 return;
+        }
 …
         status = cldap_netlogon_recv(subreq, state->netlogon, state->netlogon);
+        talloc_free(subreq);
+        TALLOC_FREE(subreq);
+        TALLOC_FREE(state->cldap);
         if (!NT_STATUS_IS_OK(status)) {
+                state->status = status;
                 state->srv_address_index++;
                 finddcs_cldap_next_server(state);
 …
+}
-/*
-   handle NBT name lookup reply
- */
 static void finddcs_cldap_name_resolved(struct composite_context *ctx)
+{
         struct finddcs_cldap_state *state =
                 talloc_get_type(ctx->async.private_data, struct finddcs_cldap_state);
+        const char *address;
+        NTSTATUS status;
+        status = resolve_name_recv(ctx, state, &address);
+        NTSTATUS status;
+        unsigned i;
+        status = resolve_name_multiple_recv(ctx, state, &state->srv_addresses);
+        if (tevent_req_nterror(state->req, status)) {
+                DEBUG(2,("finddcs: No matching server found\n"));
+                return;
+        }
+        for (i=0; state->srv_addresses[i]; i++) {
+                DEBUG(4,("finddcs: response %u at '%s'\n",
+                         i, state->srv_addresses[i]));
+        }
+        state->srv_address_index = 0;
+        state->status = NT_STATUS_OK;
+        finddcs_cldap_next_server(state);
+}
+/*
+   handle NBT name lookup reply
+ */
+static void finddcs_cldap_nbt_resolved(struct composite_context *ctx)
+{
+        struct finddcs_cldap_state *state =
+                talloc_get_type(ctx->async.private_data, struct finddcs_cldap_state);
+        NTSTATUS status;
+        unsigned i;
+        status = resolve_name_multiple_recv(ctx, state, &state->srv_addresses);
         if (tevent_req_nterror(state->req, status)) {
                 DEBUG(2,("finddcs: No matching NBT <1c> server found\n"));
 …
+        }
+        DEBUG(4,("finddcs: Found NBT <1c> server at %s\n", address));
+        state->srv_addresses = talloc_array(state, const char *, 2);
+        if (tevent_req_nomem(state->srv_addresses, state->req)) {
+                return;
+        }
+        state->srv_addresses[0] = address;
+        state->srv_addresses[1] = NULL;
+        for (i=0; state->srv_addresses[i]; i++) {
+                DEBUG(4,("finddcs: NBT <1c> response %u at '%s'\n",
+                         i, state->srv_addresses[i]));
+        }
         state->srv_address_index = 0;
-        status = cldap_socket_init(state, state->ev, NULL, NULL, &state->cldap);
-        if (tevent_req_nterror(state->req, status)) {
-                return;
+        }
         finddcs_cldap_next_server(state);
 …
         state->srv_address_index = 0;
+        status = cldap_socket_init(state, state->ev, NULL, NULL, &state->cldap);
+        if (tevent_req_nterror(state->req, status)) {
+                return;
+        }
+        state->status = NT_STATUS_OK;
         finddcs_cldap_next_server(state);
+}
 …
                 return NT_STATUS_INTERNAL_ERROR;
+        }
+        status = tevent_req_simple_recv_ntstatus(req);
+        if (NT_STATUS_IS_OK(status)) {
+                talloc_steal(mem_ctx, state->netlogon);
+                io->out.netlogon = state->netlogon->out.netlogon;
+                io->out.address = talloc_steal(mem_ctx, state->srv_addresses[state->srv_address_index]);
+        }
+        if (tevent_req_is_nterror(req, &status)) {
+                tevent_req_received(req);
+                return status;
+        }
+        talloc_steal(mem_ctx, state->netlogon);
+        io->out.netlogon = state->netlogon->out.netlogon;
+        io->out.address = talloc_steal(
+                mem_ctx, state->srv_addresses[state->srv_address_index]);
         tevent_req_received(req);
         return status;
+        return NT_STATUS_OK;
+}

vendor/current/source4/libcli/finddcs_nbt.c

-              r740
+              r988
 #include "libcli/resolve/resolve.h"
 #include "lib/util/tevent_ntstatus.h"
+#include "libcli/finddc.h"
 struct finddcs_nbt_state {
         struct tevent_context *ev;
         struct tevent_req *req;
         struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         const char *my_netbios_name;
 …
                                 struct resolve_context *resolve_ctx,
                                 struct tevent_context *event_ctx,
                                 struct messaging_context *msg_ctx)
+                                struct imessaging_context *msg_ctx)
+{
         struct finddcs_nbt_state *state;
 …
         if (domain_sid) {
                 state->domain_sid = talloc_reference(state, domain_sid);
+                state->domain_sid = dom_sid_dup(state, domain_sid);
                 if (tevent_req_nomem(state->domain_sid, req)) {
                         return tevent_req_post(req, event_ctx);
 …
                 *dcs = talloc_steal(mem_ctx, state->dcs);
+        }
-        talloc_free(req);
         return status;
+}
 …
                  struct resolve_context *resolve_ctx,
                  struct tevent_context *event_ctx,
                  struct messaging_context *msg_ctx,
+                 struct imessaging_context *msg_ctx,
                  int *num_dcs, struct nbt_dc_name **dcs)
+{
+        NTSTATUS status;
         struct tevent_req *req = finddcs_nbt_send(mem_ctx,
                                               my_netbios_name,
 …
                                               resolve_ctx,
                                               event_ctx, msg_ctx);
+        return finddcs_nbt_recv(req, mem_ctx, num_dcs, dcs);
+}
+        status = finddcs_nbt_recv(req, mem_ctx, num_dcs, dcs);
+        talloc_free(req);
+        return status;
+}

vendor/current/source4/libcli/ldap/ldap_bind.c

-              r740
+              r988
 #include "lib/tls/tls.h"
 #include "auth/gensec/gensec.h"
+#include "auth/gensec/gensec_internal.h" /* TODO: remove this */
+#include "source4/auth/gensec/gensec_tstream.h"
 #include "auth/credentials/credentials.h"
 #include "lib/stream/packet.h"
 #include "param/param.h"
+#include "param/loadparm.h"
 struct ldap_simple_creds {
 …
         struct ldap_SearchResEntry *search;
         int count, i;
+        bool first = true;
+        int wrap_flags = 0;
         const char **sasl_names;
         uint32_t old_gensec_features;
 …
                 NULL
         };
+        gensec_init(lp_ctx);
+        unsigned int logon_retries = 0;
+        size_t queue_length;
+        if (conn->sockets.active == NULL) {
+                status = NT_STATUS_CONNECTION_DISCONNECTED;
+                goto failed;
+        }
+        queue_length = tevent_queue_length(conn->sockets.send_queue);
+        if (queue_length != 0) {
+                status = NT_STATUS_INVALID_PARAMETER_MIX;
+                DEBUG(1, ("SASL bind triggered with non empty send_queue[%zu]: %s\n",
+                          queue_length, nt_errstr(status)));
+                goto failed;
+        }
+        if (conn->pending != NULL) {
+                status = NT_STATUS_INVALID_PARAMETER_MIX;
+                DEBUG(1, ("SASL bind triggered with pending requests: %s\n",
+                          nt_errstr(status)));
+                goto failed;
+        }
+        status = ildap_search(conn, "", LDAP_SEARCH_SCOPE_BASE, "", supported_sasl_mech_attrs,
+                              false, NULL, NULL, &sasl_mechs_msgs);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("Failed to inquire of target's available sasl mechs in rootdse search: %s\n",
+                          nt_errstr(status)));
+                goto failed;
+        }
+        count = ildap_count_entries(conn, sasl_mechs_msgs);
+        if (count != 1) {
+                DEBUG(1, ("Failed to inquire of target's available sasl mechs in rootdse search: wrong number of replies: %d\n",
+                          count));
+                goto failed;
+        }
+        tmp_ctx = talloc_new(conn);
+        if (tmp_ctx == NULL) goto failed;
+        search = &sasl_mechs_msgs[0]->r.SearchResultEntry;
+        if (search->num_attributes != 1) {
+                DEBUG(1, ("Failed to inquire of target's available sasl mechs in rootdse search: wrong number of attributes: %d != 1\n",
+                          search->num_attributes));
+                goto failed;
+        }
+        sasl_names = talloc_array(tmp_ctx, const char *, search->attributes[0].num_values + 1);
+        if (!sasl_names) {
+                DEBUG(1, ("talloc_arry(char *, %d) failed\n",
+                          count));
+                goto failed;
+        }
+        for (i=0; i<search->attributes[0].num_values; i++) {
+                sasl_names[i] = (const char *)search->attributes[0].values[i].data;
+        }
+        sasl_names[i] = NULL;
+        gensec_init();
+        if (conn->sockets.active == conn->sockets.tls) {
+                /*
+                 * require Kerberos SIGN/SEAL only if we don't use SSL
+                 * Windows seem not to like double encryption
+                 */
+                wrap_flags = 0;
+        } else if (cli_credentials_is_anonymous(creds)) {
+                /*
+                 * anonymous isn't protected
+                 */
+                wrap_flags = 0;
+        } else {
+                wrap_flags = lpcfg_client_ldap_sasl_wrapping(lp_ctx);
+        }
+try_logon_again:
+        /*
+          we loop back here on a logon failure, and re-create the
+          gensec session. The logon_retries counter ensures we don't
+          loop forever.
+         */
+        data_blob_free(&input);
+        TALLOC_FREE(conn->gensec);
         status = gensec_client_start(conn, &conn->gensec,
-                                     conn->event.event_ctx,
                                      lpcfg_gensec_settings(conn, lp_ctx));
         if (!NT_STATUS_IS_OK(status)) {
 …
+        }
-        /* require Kerberos SIGN/SEAL only if we don't use SSL
-         * Windows seem not to like double encryption */
         old_gensec_features = cli_credentials_get_gensec_features(creds);
         if (tls_enabled(conn->sock)) {
+        if (wrap_flags == 0) {
                 cli_credentials_set_gensec_features(creds, old_gensec_features & ~(GENSEC_FEATURE_SIGN|GENSEC_FEATURE_SEAL));
+        }
 …
          * context, so we don't tatoo it ) */
         cli_credentials_set_gensec_features(creds, old_gensec_features);
+        if (wrap_flags & ADS_AUTH_SASL_SEAL) {
+                gensec_want_feature(conn->gensec, GENSEC_FEATURE_SIGN);
+                gensec_want_feature(conn->gensec, GENSEC_FEATURE_SEAL);
+        }
+        if (wrap_flags & ADS_AUTH_SASL_SIGN) {
+                gensec_want_feature(conn->gensec, GENSEC_FEATURE_SIGN);
+        }
+        /*
+         * This is an indication for the NTLMSSP backend to
+         * also encrypt when only GENSEC_FEATURE_SIGN is requested
+         * in gensec_[un]wrap().
+         */
+        gensec_want_feature(conn->gensec, GENSEC_FEATURE_LDAP_STYLE);
         if (conn->host) {
 …
+        }
-        status = ildap_search(conn, "", LDAP_SEARCH_SCOPE_BASE, "", supported_sasl_mech_attrs,
-                              false, NULL, NULL, &sasl_mechs_msgs);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(1, ("Failed to inquire of target's available sasl mechs in rootdse search: %s\n",
-                          nt_errstr(status)));
-                goto failed;
+        }
-        count = ildap_count_entries(conn, sasl_mechs_msgs);
-        if (count != 1) {
-                DEBUG(1, ("Failed to inquire of target's available sasl mechs in rootdse search: wrong number of replies: %d\n",
-                          count));
-                goto failed;
+        }
-        tmp_ctx = talloc_new(conn);
-        if (tmp_ctx == NULL) goto failed;
-        search = &sasl_mechs_msgs[0]->r.SearchResultEntry;
-        if (search->num_attributes != 1) {
-                DEBUG(1, ("Failed to inquire of target's available sasl mechs in rootdse search: wrong number of attributes: %d != 1\n",
-                          search->num_attributes));
-                goto failed;
+        }
-        sasl_names = talloc_array(tmp_ctx, const char *, search->attributes[0].num_values + 1);
-        if (!sasl_names) {
-                DEBUG(1, ("talloc_arry(char *, %d) failed\n",
-                          count));
-                goto failed;
+        }
-        for (i=0; i<search->attributes[0].num_values; i++) {
-                sasl_names[i] = (const char *)search->attributes[0].values[i].data;
+        }
-        sasl_names[i] = NULL;
         status = gensec_start_mech_by_sasl_list(conn->gensec, sasl_names);
         if (!NT_STATUS_IS_OK(status)) {
 …
                 int result = LDAP_OTHER;
+                status = gensec_update(conn->gensec, tmp_ctx,
+                status = gensec_update_ev(conn->gensec, tmp_ctx,
+                                       conn->event.event_ctx,
                                        input,
                                        &output);
 …
+                 *
                  * Likewise, you must not feed GENSEC too much (after the OK),
+                 * it doesn't like that either
+                 * it doesn't like that either.
+                 *
+                 * For SASL/EXTERNAL, there is no data to send, but we still
+                 * must send the actual Bind request the first time around.
+                 * Otherwise, a result of NT_STATUS_OK with 0 output means the
+                 * end of a multi-step authentication, and no message must be
+                 * sent.
                  */
 …
+                }
                 if (NT_STATUS_IS_OK(status) && output.length == 0) {
+                        break;
+                }
+                        if (!first)
+                                break;
+                }
+                first = false;
                 /* Perhaps we should make gensec_start_mech_by_sasl_list() return the name we got? */
 …
                 result = response->r.BindResponse.response.resultcode;
+                if (result == LDAP_STRONG_AUTH_REQUIRED) {
+                        if (wrap_flags == 0) {
+                                wrap_flags = ADS_AUTH_SASL_SIGN;
+                                goto try_logon_again;
+                        }
+                }
+                if (result == LDAP_INVALID_CREDENTIALS) {
+                        /*
+                          try a second time on invalid credentials, to
+                          give the user a chance to re-enter the
+                          password and to handle the case where our
+                          kerberos ticket is invalid as the server
+                          password has changed
+                        */
+                        const char *principal;
+                        principal = gensec_get_target_principal(conn->gensec);
+                        if (principal == NULL) {
+                                const char *hostname = gensec_get_target_hostname(conn->gensec);
+                                const char *service  = gensec_get_target_service(conn->gensec);
+                                if (hostname != NULL && service != NULL) {
+                                        principal = talloc_asprintf(tmp_ctx, "%s/%s", service, hostname);
+                                }
+                        }
+                        if (cli_credentials_failed_kerberos_login(creds, principal, &logon_retries) ||
+                            cli_credentials_wrong_password(creds)) {
+                                /*
+                                  destroy our gensec session and loop
+                                  back up to the top to retry,
+                                  offering the user a chance to enter
+                                  new credentials, or get a new ticket
+                                  if using kerberos
+                                 */
+                                goto try_logon_again;
+                        }
+                }
                 if (result != LDAP_SUCCESS && result != LDAP_SASL_BIND_IN_PROGRESS) {
                         status = ldap_check_response(conn,
 …
+        }
+        talloc_free(tmp_ctx);
+        if (NT_STATUS_IS_OK(status)) {
+                struct socket_context *sasl_socket;
+                status = gensec_socket_init(conn->gensec,
+                                            conn,
+                                            conn->sock,
+                                            conn->event.event_ctx,
+                                            ldap_read_io_handler,
+                                            conn,
+                                            &sasl_socket);
+                if (!NT_STATUS_IS_OK(status)) goto failed;
+                conn->sock = sasl_socket;
+                packet_set_socket(conn->packet, conn->sock);
+                conn->bind.type = LDAP_BIND_SASL;
+                conn->bind.creds = creds;
+        }
+        return status;
+        TALLOC_FREE(tmp_ctx);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto failed;
+        }
+        conn->bind.type = LDAP_BIND_SASL;
+        conn->bind.creds = creds;
+        if (wrap_flags & ADS_AUTH_SASL_SEAL) {
+                if (!gensec_have_feature(conn->gensec, GENSEC_FEATURE_SIGN)) {
+                        return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                }
+                if (!gensec_have_feature(conn->gensec, GENSEC_FEATURE_SEAL)) {
+                        return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                }
+        } else if (wrap_flags & ADS_AUTH_SASL_SIGN) {
+                if (!gensec_have_feature(conn->gensec, GENSEC_FEATURE_SIGN)) {
+                        return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                }
+        }
+        if (!gensec_have_feature(conn->gensec, GENSEC_FEATURE_SIGN) &&
+            !gensec_have_feature(conn->gensec, GENSEC_FEATURE_SEAL)) {
+                return NT_STATUS_OK;
+        }
+        status = gensec_create_tstream(conn->sockets.raw,
+                                       conn->gensec,
+                                       conn->sockets.raw,
+                                       &conn->sockets.sasl);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto failed;
+        }
+        conn->sockets.active = conn->sockets.sasl;
+        return NT_STATUS_OK;
 failed:

vendor/current/source4/libcli/ldap/ldap_client.c

-              r740
+              r988
 #include <tevent.h>
 #include "lib/socket/socket.h"
+#include "lib/tsocket/tsocket.h"
+#include "libcli/util/tstream.h"
 #include "../lib/util/asn1.h"
 #include "../lib/util/dlinklist.h"
 …
 #include "libcli/ldap/ldap_client.h"
 #include "libcli/composite/composite.h"
-#include "lib/stream/packet.h"
 #include "lib/tls/tls.h"
 #include "auth/gensec/gensec.h"
 …
 #include "libcli/resolve/resolve.h"
+static void ldap_connection_dead(struct ldap_connection *conn, NTSTATUS status);
+static int ldap_connection_destructor(struct ldap_connection *conn)
+{
+        /*
+         * NT_STATUS_OK means that callbacks of pending requests are not
+         * triggered
+         */
+        ldap_connection_dead(conn, NT_STATUS_OK);
+        return 0;
+}
 /**
   create a new ldap_connection stucture. The event context is optional
 */
 _PUBLIC_ struct ldap_connection *ldap4_new_connection(TALLOC_CTX *mem_ctx,
                                              struct loadparm_context *lp_ctx,
 …
         conn->event.event_ctx = ev;
+        conn->sockets.send_queue = tevent_queue_create(conn,
+                                        "ldap_connection send_queue");
+        if (conn->sockets.send_queue == NULL) {
+                TALLOC_FREE(conn);
+                return NULL;
+        }
         conn->lp_ctx = lp_ctx;
 …
         /* explicitly avoid reconnections by default */
         conn->reconnect.max_retries = 0;
+        talloc_set_destructor(conn, ldap_connection_destructor);
         return conn;
+}
 …
   the connection is dead
 */
 static void ldap_connection_dead(struct ldap_connection *conn)
+static void ldap_connection_dead(struct ldap_connection *conn, NTSTATUS status)
+{
         struct ldap_request *req;
+        talloc_free(conn->sock);  /* this will also free event.fde */
+        talloc_free(conn->packet);
+        conn->sock = NULL;
+        conn->event.fde = NULL;
+        conn->packet = NULL;
+        tevent_queue_stop(conn->sockets.send_queue);
+        TALLOC_FREE(conn->sockets.recv_subreq);
+        conn->sockets.active = NULL;
+        TALLOC_FREE(conn->sockets.sasl);
+        TALLOC_FREE(conn->sockets.tls);
+        TALLOC_FREE(conn->sockets.raw);
         /* return an error for any pending request ... */
 …
                 req = conn->pending;
                 DLIST_REMOVE(req->conn->pending, req);
+                req->conn = NULL;
                 req->state = LDAP_REQUEST_DONE;
+                req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
+                if (NT_STATUS_IS_OK(status)) {
+                        continue;
+                }
+                req->status = status;
                 if (req->async.fn) {
                         req->async.fn(req);
 …
   handle packet errors
 */
+static void ldap_error_handler(void *private_data, NTSTATUS status)
+{
+        struct ldap_connection *conn = talloc_get_type(private_data,
+                                                       struct ldap_connection);
+        ldap_connection_dead(conn);
+static void ldap_error_handler(struct ldap_connection *conn, NTSTATUS status)
+{
+        ldap_connection_dead(conn, status);
         /* but try to reconnect so that the ldb client can go on */
 …
                 DEBUG(0,("ldap: no matching message id for %u\n",
                          msg->messageid));
                 talloc_free(msg);
+                TALLOC_FREE(msg);
                 return;
+        }
 …
                 if (!msg->controls_decoded[i] &&
                     msg->controls[i]->critical) {
+                        TALLOC_FREE(msg);
                         req->status = NT_STATUS_LDAP(LDAP_UNAVAILABLE_CRITICAL_EXTENSION);
                         req->state = LDAP_REQUEST_DONE;
 …
         /* add to the list of replies received */
-        talloc_steal(req, msg);
         req->replies = talloc_realloc(req, req->replies,
                                       struct ldap_message *, req->num_replies+1);
         if (req->replies == NULL) {
+                TALLOC_FREE(msg);
                 req->status = NT_STATUS_NO_MEMORY;
                 req->state = LDAP_REQUEST_DONE;
 …
+}
+static void ldap_connection_recv_done(struct tevent_req *subreq);
+static void ldap_connection_recv_next(struct ldap_connection *conn)
+{
+        struct tevent_req *subreq = NULL;
+        if (conn->sockets.recv_subreq != NULL) {
+                return;
+        }
+        if (conn->sockets.active == NULL) {
+                return;
+        }
+        if (conn->pending == NULL) {
+                return;
+        }
+        /*
+         * The minimum size of a LDAP pdu is 7 bytes
+         *
+         * dumpasn1 -hh ldap-unbind-min.dat
+         *
+         *     <30 05 02 01 09 42 00>
+         *    0    5: SEQUENCE {
+         *     <02 01 09>
+         *    2    1:   INTEGER 9
+         *     <42 00>
+         *    5    0:   [APPLICATION 2]
+         *          :     Error: Object has zero length.
+         *          :   }
+         *
+         * dumpasn1 -hh ldap-unbind-windows.dat
+         *
+         *     <30 84 00 00 00 05 02 01 09 42 00>
+         *    0    5: SEQUENCE {
+         *     <02 01 09>
+         *    6    1:   INTEGER 9
+         *     <42 00>
+         *    9    0:   [APPLICATION 2]
+         *          :     Error: Object has zero length.
+         *          :   }
+         *
+         * This means using an initial read size
+         * of 7 is ok.
+         */
+        subreq = tstream_read_pdu_blob_send(conn,
+                                            conn->event.event_ctx,
+                                            conn->sockets.active,
+, /* initial_read_size */
+                                            ldap_full_packet,
+                                            conn);
+        if (subreq == NULL) {
+                ldap_error_handler(conn, NT_STATUS_NO_MEMORY);
+                return;
+        }
+        tevent_req_set_callback(subreq, ldap_connection_recv_done, conn);
+        conn->sockets.recv_subreq = subreq;
+        return;
+}
 /*
   decode/process LDAP data
 */
 static NTSTATUS ldap_recv_handler(void *private_data, DATA_BLOB blob)
+static void ldap_connection_recv_done(struct tevent_req *subreq)
+{
         NTSTATUS status;
+        struct ldap_connection *conn = talloc_get_type(private_data,
+                                                       struct ldap_connection);
+        struct ldap_message *msg = talloc(conn, struct ldap_message);
+        struct asn1_data *asn1 = asn1_init(conn);
+        if (asn1 == NULL || msg == NULL) {
+                return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+        }
+        if (!asn1_load(asn1, blob)) {
+                talloc_free(msg);
+                talloc_free(asn1);
+                return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+        }
+        struct ldap_connection *conn =
+                tevent_req_callback_data(subreq,
+                struct ldap_connection);
+        struct ldap_message *msg;
+        struct asn1_data *asn1;
+        DATA_BLOB blob;
+        msg = talloc_zero(conn, struct ldap_message);
+        if (msg == NULL) {
+                ldap_error_handler(conn, NT_STATUS_NO_MEMORY);
+                return;
+        }
+        asn1 = asn1_init(conn);
+        if (asn1 == NULL) {
+                TALLOC_FREE(msg);
+                ldap_error_handler(conn, NT_STATUS_NO_MEMORY);
+                return;
+        }
+        conn->sockets.recv_subreq = NULL;
+        status = tstream_read_pdu_blob_recv(subreq,
+                                            asn1,
+                                            &blob);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(msg);
+                asn1_free(asn1);
+                ldap_error_handler(conn, status);
+                return;
+        }
+        asn1_load_nocopy(asn1, blob.data, blob.length);
         status = ldap_decode(asn1, samba_ldap_control_handlers(), msg);
+        asn1_free(asn1);
         if (!NT_STATUS_IS_OK(status)) {
+                asn1_free(asn1);
+                return status;
+                TALLOC_FREE(msg);
+                ldap_error_handler(conn, status);
+                return;
+        }
         ldap_match_message(conn, msg);
+        data_blob_free(&blob);
+        asn1_free(asn1);
+        return NT_STATUS_OK;
+}
+/* Handle read events, from the GENSEC socket callback, or real events */
+void ldap_read_io_handler(void *private_data, uint16_t flags)
+{
+        struct ldap_connection *conn = talloc_get_type(private_data,
+                                                       struct ldap_connection);
+        packet_recv(conn->packet);
+}
+/*
+  handle ldap socket events
+*/
+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 & TEVENT_FD_WRITE) {
+                packet_queue_run(conn->packet);
+                if (!tls_enabled(conn->sock)) return;
+        }
+        if (flags & TEVENT_FD_READ) {
+                ldap_read_io_handler(private_data, flags);
+        }
+        ldap_connection_recv_next(conn);
+        return;
+}
 …
         struct composite_context *ctx;
         struct ldap_connection *conn;
+        struct socket_context *sock;
+        struct tstream_context *raw;
+        struct tstream_tls_params *tls_params;
+        struct tstream_context *tls;
 };
 …
                 char path[1025];
                 NTSTATUS status = socket_create("unix", SOCKET_TYPE_STREAM, &conn->sock, 0);
+                NTSTATUS status = socket_create("unix", SOCKET_TYPE_STREAM, &state->sock, 0);
                 if (!NT_STATUS_IS_OK(status)) {
                         return NULL;
+                }
                 talloc_steal(conn, conn->sock);
+                talloc_steal(state, state->sock);
                 SMB_ASSERT(sizeof(protocol)>10);
                 SMB_ASSERT(sizeof(path)>1024);
 …
                 rfc1738_unescape(path);
                 unix_addr = socket_address_from_strings(conn, conn->sock->backend_name,
+                unix_addr = socket_address_from_strings(state, state->sock->backend_name,
                                                         path, 0);
+                if (!unix_addr) {
+                        return NULL;
+                }
+                ctx = socket_connect_send(conn->sock, NULL, unix_addr,
+, conn->event.event_ctx);
+                if (composite_nomem(unix_addr, result)) {
+                        return result;
+                }
+                ctx = socket_connect_send(state->sock, NULL, unix_addr,
+, result->event_ctx);
                 ctx->async.fn = ldap_connect_recv_unix_conn;
                 ctx->async.private_data = state;
 …
                 NTSTATUS status = ldap_parse_basic_url(conn, url, &conn->host,
                                                           &conn->port, &conn->ldaps);
                 if (!NT_STATUS_IS_OK(state->ctx->status)) {
                         composite_error(state->ctx, status);
+                if (!NT_STATUS_IS_OK(status)) {
+                        composite_error(result, status);
                         return result;
+                }
+                if (conn->ldaps) {
+                        char *ca_file = lpcfg_tls_cafile(state, conn->lp_ctx);
+                        char *crl_file = lpcfg_tls_crlfile(state, conn->lp_ctx);
+                        const char *tls_priority = lpcfg_tls_priority(conn->lp_ctx);
+                        enum tls_verify_peer_state verify_peer =
+                                lpcfg_tls_verify_peer(conn->lp_ctx);
+                        status = tstream_tls_params_client(state,
+                                                           ca_file,
+                                                           crl_file,
+                                                           tls_priority,
+                                                           verify_peer,
+                                                           conn->host,
+                                                           &state->tls_params);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                composite_error(result, status);
+                                return result;
+                        }
+                }
                 ctx = socket_connect_multi_send(state, conn->host, 1, &conn->port,
+                                                lpcfg_resolve_context(conn->lp_ctx), conn->event.event_ctx);
+                if (ctx == NULL) goto failed;
+                                                lpcfg_resolve_context(conn->lp_ctx),
+                                                result->event_ctx);
+                if (composite_nomem(ctx, result)) {
+                        return result;
+                }
                 ctx->async.fn = ldap_connect_recv_tcp_conn;
 …
+}
+static void ldap_connect_got_tls(struct tevent_req *subreq);
 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 = 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;
+                char *cafile = lpcfg_tls_cafile(conn->sock, conn->lp_ctx);
+                if (!cafile || !*cafile) {
+                        talloc_free(conn->sock);
+                        return;
+                }
+                tls_socket = tls_init_client(conn->sock, conn->event.fde, cafile);
+                talloc_free(cafile);
+                if (tls_socket == NULL) {
+                        talloc_free(conn->sock);
+                        return;
+                }
+                conn->sock = talloc_steal(conn, tls_socket);
+        }
+        conn->packet = packet_init(conn);
+        if (conn->packet == NULL) {
+                talloc_free(conn->sock);
+                return;
+        }
+        packet_set_private(conn->packet, conn);
+        packet_set_socket(conn->packet, conn->sock);
+        packet_set_callback(conn->packet, ldap_recv_handler);
+        packet_set_full_request(conn->packet, ldap_full_packet);
+        packet_set_error_handler(conn->packet, ldap_error_handler);
+        packet_set_event_context(conn->packet, conn->event.event_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);
+                                  struct ldap_connection *conn)
+{
+        struct ldap_connect_state *state =
+                talloc_get_type_abort(ctx->private_data,
+                struct ldap_connect_state);
+        struct tevent_req *subreq = NULL;
+        int fd;
+        int ret;
+        socket_set_flags(state->sock, SOCKET_FLAG_NOCLOSE);
+        fd = socket_get_fd(state->sock);
+        TALLOC_FREE(state->sock);
+        smb_set_close_on_exec(fd);
+        ret = set_blocking(fd, false);
+        if (ret == -1) {
+                NTSTATUS status = map_nt_error_from_unix_common(errno);
+                composite_error(state->ctx, status);
+                return;
+        }
+        ret = tstream_bsd_existing_socket(state, fd, &state->raw);
+        if (ret == -1) {
+                NTSTATUS status = map_nt_error_from_unix_common(errno);
+                composite_error(state->ctx, status);
+                return;
+        }
+        if (!conn->ldaps) {
+                conn->sockets.raw = talloc_move(conn, &state->raw);
+                conn->sockets.active = conn->sockets.raw;
+                composite_done(state->ctx);
+                return;
+        }
+        subreq = tstream_tls_connect_send(state, state->ctx->event_ctx,
+                                          state->raw, state->tls_params);
+        if (composite_nomem(subreq, state->ctx)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, ldap_connect_got_tls, state);
+}
+static void ldap_connect_got_tls(struct tevent_req *subreq)
+{
+        struct ldap_connect_state *state =
+                tevent_req_callback_data(subreq,
+                struct ldap_connect_state);
+        int err;
+        int ret;
+        ret = tstream_tls_connect_recv(subreq, &err, state, &state->tls);
+        TALLOC_FREE(subreq);
+        if (ret == -1) {
+                NTSTATUS status = map_nt_error_from_unix_common(err);
+                composite_error(state->ctx, status);
+                return;
+        }
+        talloc_steal(state->tls, state->tls_params);
+        state->conn->sockets.raw = talloc_move(state->conn, &state->raw);
+        state->conn->sockets.tls = talloc_move(state->conn->sockets.raw,
+                                               &state->tls);
+        state->conn->sockets.active = state->conn->sockets.tls;
+        composite_done(state->ctx);
+}
 …
+{
         struct ldap_connect_state *state =
                 talloc_get_type(ctx->async.private_data,
                                 struct ldap_connect_state);
+                talloc_get_type_abort(ctx->async.private_data,
+                struct ldap_connect_state);
         struct ldap_connection *conn = state->conn;
         uint16_t port;
         NTSTATUS status = socket_connect_multi_recv(ctx, state, &conn->sock,
+        NTSTATUS status = socket_connect_multi_recv(ctx, state, &state->sock,
                                                        &port);
         if (!NT_STATUS_IS_OK(status)) {
 …
+{
         struct ldap_connect_state *state =
                 talloc_get_type(ctx->async.private_data,
                                 struct ldap_connect_state);
+                talloc_get_type_abort(ctx->async.private_data,
+                struct ldap_connect_state);
         struct ldap_connection *conn = state->conn;
 …
         status = ldap_rebind(conn);
         if ( ! NT_STATUS_IS_OK(status)) {
+                ldap_connection_dead(conn);
+        }
+                ldap_connection_dead(conn, status);
+        }
+}
+static void ldap_request_destructor_abandon(struct ldap_request *abandon)
+{
+        TALLOC_FREE(abandon);
+}
 …
+{
         if (req->state == LDAP_REQUEST_PENDING) {
+                struct ldap_message msg = {
+                        .type = LDAP_TAG_AbandonRequest,
+                        .r.AbandonRequest.messageid = req->messageid,
+                };
+                struct ldap_request *abandon = NULL;
                 DLIST_REMOVE(req->conn->pending, req);
+        }
+                abandon = ldap_request_send(req->conn, &msg);
+                if (abandon == NULL) {
+                        ldap_error_handler(req->conn, NT_STATUS_NO_MEMORY);
+                        return 0;
+                }
+                abandon->async.fn = ldap_request_destructor_abandon;
+                abandon->async.private_data = NULL;
+        }
         return 0;
+}
+/*
+  called on timeout of a ldap request
+*/
+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);
+        req->status = NT_STATUS_IO_TIMEOUT;
+static void ldap_request_timeout_abandon(struct ldap_request *abandon)
+{
+        struct ldap_request *req =
+                talloc_get_type_abort(abandon->async.private_data,
+                struct ldap_request);
         if (req->state == LDAP_REQUEST_PENDING) {
                 DLIST_REMOVE(req->conn->pending, req);
 …
+}
+/*
+  called on completion of a failed ldap request
+*/
+static void ldap_request_failed_complete(struct tevent_context *ev, struct tevent_timer *te,
+/*
+  called on timeout of a ldap request
+*/
+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);
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+/*
+  called on completion of a one-way ldap request
+*/
+static void ldap_request_oneway_complete(void *private_data)
+{
+        struct ldap_request *req = talloc_get_type(private_data, struct ldap_request);
+        struct ldap_request *req =
+                talloc_get_type_abort(private_data,
+                struct ldap_request);
+        req->status = NT_STATUS_IO_TIMEOUT;
         if (req->state == LDAP_REQUEST_PENDING) {
+                struct ldap_message msg = {
+                        .type = LDAP_TAG_AbandonRequest,
+                        .r.AbandonRequest.messageid = req->messageid,
+                };
+                struct ldap_request *abandon = NULL;
+                abandon = ldap_request_send(req->conn, &msg);
+                if (abandon == NULL) {
+                        ldap_error_handler(req->conn, NT_STATUS_NO_MEMORY);
+                        return;
+                }
+                talloc_reparent(req->conn, req, abandon);
+                abandon->async.fn = ldap_request_timeout_abandon;
+                abandon->async.private_data = req;
                 DLIST_REMOVE(req->conn->pending, req);
+                return;
+        }
         req->state = LDAP_REQUEST_DONE;
 …
+        }
+}
+/*
+  called on completion of a failed ldap request
+*/
+static void ldap_request_failed_complete(struct tevent_context *ev, struct tevent_timer *te,
+                                      struct timeval t, void *private_data)
+{
+        struct ldap_request *req =
+                talloc_get_type_abort(private_data,
+                struct ldap_request);
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+static void ldap_request_written(struct tevent_req *subreq);
 /*
   send a ldap message - async interface
 …
         struct ldap_request *req;
         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
         packet_send_callback_fn_t send_callback = NULL;
+        struct tevent_req *subreq = NULL;
         req = talloc_zero(conn, struct ldap_request);
         if (req == NULL) return NULL;
         if (conn->sock == NULL) {
+        if (conn->sockets.active == NULL) {
                 status = NT_STATUS_INVALID_CONNECTION;
                 goto failed;
 …
+        }
-        if (req->type == LDAP_TAG_AbandonRequest ||
-            req->type == LDAP_TAG_UnbindRequest) {
-                send_callback = ldap_request_oneway_complete;
+        }
-        status = packet_send_callback(conn->packet, req->data,
-                                      send_callback, req);
-        if (!NT_STATUS_IS_OK(status)) {
-                goto failed;
+        }
-        req->state = LDAP_REQUEST_PENDING;
-        DLIST_ADD(conn->pending, req);
         /* put a timeout on the request */
         req->time_event = tevent_add_timer(conn->event.event_ctx, req,
                                            timeval_current_ofs(conn->timeout, 0),
                                            ldap_request_timeout, req);
+        if (req->time_event == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto failed;
+        }
+        req->write_iov.iov_base = req->data.data;
+        req->write_iov.iov_len = req->data.length;
+        subreq = tstream_writev_queue_send(req, conn->event.event_ctx,
+                                           conn->sockets.active,
+                                           conn->sockets.send_queue,
+                                           &req->write_iov, 1);
+        if (subreq == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto failed;
+        }
+        tevent_req_set_callback(subreq, ldap_request_written, req);
+        req->state = LDAP_REQUEST_PENDING;
+        DLIST_ADD(conn->pending, req);
         return req;
 …
+}
+static void ldap_request_written(struct tevent_req *subreq)
+{
+        struct ldap_request *req =
+                tevent_req_callback_data(subreq,
+                struct ldap_request);
+        int err;
+        ssize_t ret;
+        ret = tstream_writev_queue_recv(subreq, &err);
+        TALLOC_FREE(subreq);
+        if (ret == -1) {
+                NTSTATUS error = map_nt_error_from_unix_common(err);
+                ldap_error_handler(req->conn, error);
+                return;
+        }
+        if (req->type == LDAP_TAG_AbandonRequest ||
+            req->type == LDAP_TAG_UnbindRequest)
+        {
+                if (req->state == LDAP_REQUEST_PENDING) {
+                        DLIST_REMOVE(req->conn->pending, req);
+                }
+                req->state = LDAP_REQUEST_DONE;
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+                return;
+        }
+        ldap_connection_recv_next(req->conn);
+}
 /*
 …
         while (req->state < LDAP_REQUEST_DONE) {
                 if (tevent_loop_once(req->conn->event.event_ctx) != 0) {
+                        req->state = LDAP_REQUEST_ERROR;
                         req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
                         break;

vendor/current/source4/libcli/ldap/ldap_client.h

-              r740
+              r988
+#include "system/network.h" /* for struct iovec */
 #include "libcli/ldap/libcli_ldap.h"
 …
         NTSTATUS status;
         DATA_BLOB data;
+        struct iovec write_iov;
         struct {
                 void (*fn)(struct ldap_request *);
 …
 /* main context for a ldap client connection */
 struct ldap_connection {
+        struct socket_context *sock;
+        struct {
+                struct tstream_context *raw;
+                struct tstream_context *tls;
+                struct tstream_context *sasl;
+                struct tstream_context *active;
+                struct tevent_queue *send_queue;
+                struct tevent_req *recv_subreq;
+        } sockets;
         struct loadparm_context *lp_ctx;
 …
         struct {
                 struct tevent_context *event_ctx;
-                struct tevent_fd *fde;
         } event;
-        struct packet_context *packet;
 };

vendor/current/source4/libcli/ldap/ldap_controls.c

-              r740
+              r988
+}
+static bool decode_verify_name_request(void *mem_ctx, DATA_BLOB in, void *_out)
+{
+        void **out = (void **)_out;
+        DATA_BLOB name;
+        struct asn1_data *data = asn1_init(mem_ctx);
+        struct ldb_verify_name_control *lvnc;
+        int len;
+        if (!data) return false;
+        if (!asn1_load(data, in)) {
+                return false;
+        }
+        lvnc = talloc(mem_ctx, struct ldb_verify_name_control);
+        if (!lvnc) {
+                return false;
+        }
+        if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) {
+                return false;
+        }
+        if (!asn1_read_Integer(data, &(lvnc->flags))) {
+                return false;
+        }
+        if (!asn1_read_OctetString(data, mem_ctx, &name)) {
+                return false;
+        }
+        if (name.length) {
+                len = utf16_len_n(name.data, name.length);
+                convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
+                                        name.data, len,
+                                        (void **)&lvnc->gc, &lvnc->gc_len);
+                if (!(lvnc->gc)) {
+                        return false;
+                }
+        } else {
+                lvnc->gc_len = 0;
+                lvnc->gc = NULL;
+        }
+        if (!asn1_end_tag(data)) {
+                return false;
+        }
+        *out = lvnc;
+        return true;
+}
+static bool encode_verify_name_request(void *mem_ctx, void *in, DATA_BLOB *out)
+{
+        struct ldb_verify_name_control *lvnc = talloc_get_type(in, struct ldb_verify_name_control);
+        struct asn1_data *data = asn1_init(mem_ctx);
+        DATA_BLOB gc_utf16;
+        if (!data) return false;
+        if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) {
+                return false;
+        }
+        if (!asn1_write_Integer(data, lvnc->flags)) {
+                return false;
+        }
+        if (lvnc->gc_len) {
+                convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16,
+                                                lvnc->gc, lvnc->gc_len,
+                                                (void **)&gc_utf16.data, &gc_utf16.length);
+                if (!asn1_write_OctetString(data, gc_utf16.data, gc_utf16.length)) {
+                        return false;
+                }
+        } else {
+                if (!asn1_write_OctetString(data, NULL, 0)) {
+                        return false;
+                }
+        }
+        if (!asn1_pop_tag(data)) {
+                return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
+        talloc_free(data);
+        return true;
+}
 static bool decode_vlv_request(void *mem_ctx, DATA_BLOB in, void *_out)
+{
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+        }
         *out = data_blob_talloc(mem_ctx, data->data, data->length);
         if (out->data == NULL) {
                 return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
 …
+                }
+                asn1_pop_tag(data);
+                asn1_pop_tag(data);
+        }
+        asn1_pop_tag(data);
+        *out = data_blob_talloc(mem_ctx, data->data, data->length);
+        if (out->data == NULL) {
+                return false;
+        }
+                if (!asn1_pop_tag(data)) {
+                        return false;
+                }
+                if (!asn1_pop_tag(data)) {
+                        return false;
+                }
+        }
+        if (!asn1_pop_tag(data)) {
+                return false;
+        }
+        if (!asn1_extract_blob(data, mem_ctx, out)) {
+                return false;
+        }
         talloc_free(data);
         return true;
 …
+                }
+                asn1_read_OctetString_talloc(r[i], data, &r[i]->source_attribute);
+                asn1_read_OctetString_talloc(r[i], data, &r[i]->dereferenced_dn);
+                if (!asn1_read_OctetString_talloc(r[i], data, &r[i]->source_attribute)) {
+                        return false;
+                }
+                if (!asn1_read_OctetString_talloc(r[i], data, &r[i]->dereferenced_dn)) {
+                        return false;
+                }
                 if (asn1_peek_tag(data, ASN1_CONTEXT(0))) {
                         if (!asn1_start_tag(data, ASN1_CONTEXT(0))) {
                                 return false;
+                        }
                         ldap_decode_attribs_bare(r, data, &r[i]->attributes,
                                                  &r[i]->num_attributes);
+                        if (!ldap_decode_attribs_bare(r, data, &r[i]->attributes,
+                                                 &r[i]->num_attributes)) {
+                                return false;
+                        }
                         if (!asn1_end_tag(data)) {
                                 return false;
 …
         { LDB_CONTROL_ASQ_OID, decode_asq_control, encode_asq_control },
         { LDB_CONTROL_DIRSYNC_OID, decode_dirsync_request, encode_dirsync_request },
+        { LDB_CONTROL_DIRSYNC_EX_OID, decode_dirsync_request, encode_dirsync_request },
         { LDB_CONTROL_VLV_REQ_OID, decode_vlv_request, encode_vlv_request },
         { LDB_CONTROL_VLV_RESP_OID, decode_vlv_response, encode_vlv_response },
 …
         { LDB_CONTROL_RELAX_OID, decode_flag_request, encode_flag_request },
         { DSDB_OPENLDAP_DEREFERENCE_CONTROL, decode_openldap_dereference, encode_openldap_dereference },
+/* DSDB_CONTROL_CURRENT_PARTITION_OID is internal only, and has no network representation */
+        { LDB_CONTROL_VERIFY_NAME_OID, decode_verify_name_request, encode_verify_name_request },
+        /* the following are internal only, with a network
+           representation */
+        { DSDB_CONTROL_BYPASS_PASSWORD_HASH_OID, decode_flag_request, encode_flag_request },
+        /* all the ones below are internal only, and have no network
+         * representation */
         { DSDB_CONTROL_CURRENT_PARTITION_OID, NULL, NULL },
-/* DSDB_CONTROL_REPLICATED_UPDATE_OID is internal only, and has no network representation */
         { DSDB_CONTROL_REPLICATED_UPDATE_OID, NULL, NULL },
-/* DSDB_CONTROL_DN_STORAGE_FORMAT_OID is internal only, and has no network representation */
         { DSDB_CONTROL_DN_STORAGE_FORMAT_OID, NULL, NULL },
-/* LDB_CONTROL_RECALCULATE_SD_OID is internal only, and has no network representation */
         { LDB_CONTROL_RECALCULATE_SD_OID, NULL, NULL },
-/* LDB_CONTROL_REVEAL_INTERNALS is internal only, and has no network representation */
         { LDB_CONTROL_REVEAL_INTERNALS, NULL, NULL },
-/* LDB_CONTROL_AS_SYSTEM_OID is internal only, and has no network representation */
         { LDB_CONTROL_AS_SYSTEM_OID, NULL, NULL },
-/* DSDB_CONTROL_PASSWORD_CHANGE_STATUS_OID is internal only, and has no network representation */
         { DSDB_CONTROL_PASSWORD_CHANGE_STATUS_OID, NULL, NULL },
-/* DSDB_CONTROL_PASSWORD_HASH_VALUES_OID is internal only, and has no network representation */
         { DSDB_CONTROL_PASSWORD_HASH_VALUES_OID, NULL, NULL },
-/* DSDB_CONTROL_PASSWORD_CHANGE_OID is internal only, and has no network representation */
         { DSDB_CONTROL_PASSWORD_CHANGE_OID, NULL, NULL },
-/* DSDB_CONTROL_APPLY_LINKS is internal only, and has no network representation */
         { DSDB_CONTROL_APPLY_LINKS, NULL, NULL },
-/* DSDB_CONTROL_BYPASS_PASSWORD_HASH_OID is internal only, and has an empty network representation */
-        { DSDB_CONTROL_BYPASS_PASSWORD_HASH_OID, decode_flag_request, encode_flag_request },
-/* LDB_CONTROL_BYPASS_OPERATIONAL_OID is internal only, and has no network representation */
         { LDB_CONTROL_BYPASS_OPERATIONAL_OID, NULL, NULL },
-/* DSDB_CONTROL_CHANGEREPLMETADATA_OID is internal only, and has no network representation */
         { DSDB_CONTROL_CHANGEREPLMETADATA_OID, NULL, NULL },
-/* LDB_CONTROL_PROVISION_OID is internal only, and has no network representation */
         { LDB_CONTROL_PROVISION_OID, NULL, NULL },
-/* DSDB_EXTENDED_REPLICATED_OBJECTS_OID is internal only, and has no network representation */
         { DSDB_EXTENDED_REPLICATED_OBJECTS_OID, NULL, NULL },
-/* DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID is internal only, and has no network representation */
         { DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID, NULL, NULL },
-/* DSDB_EXTENDED_ALLOCATE_RID_POOL is internal only, and has no network representation */
         { DSDB_EXTENDED_ALLOCATE_RID_POOL, NULL, NULL },
+        { DSDB_CONTROL_NO_GLOBAL_CATALOG, NULL, NULL },
+        { DSDB_EXTENDED_SCHEMA_UPGRADE_IN_PROGRESS_OID, NULL, NULL },
         { NULL, NULL, NULL }
 };

vendor/current/source4/libcli/ldap/ldap_ildap.c

-              r740
+              r988
                       struct ldap_message ***results)
+{
+        NTSTATUS status;
         struct ldb_parse_tree *tree = ldb_parse_tree(conn, expression);
+        NTSTATUS status;
+        if (tree == NULL) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
         status = ildap_search_bytree(conn, basedn, scope, tree, attrs,
                                      attributesonly, control_req,

vendor/current/source4/libcli/ldap/wscript_build

-              r740
+              r988
                   source='ldap_client.c ldap_bind.c ldap_ildap.c ldap_controls.c',
                   autoproto='ldap_proto.h',
                   public_deps='errors tevent LIBPACKET',
                   public_headers='libcli_ldap.h:ldap-util.h',
                   deps='LIBCLI_COMPOSITE samba_socket NDR_SAMR LIBTLS LIBCLI_LDAP_NDR ndr LP_RESOLVE gensec LIBCLI_LDAP_MESSAGE',
+                  public_deps='samba-errors tevent',
+                  private_headers='libcli_ldap.h:ldap-util.h',
+                  deps='cli_composite LIBSAMBA_TSOCKET samba_socket NDR_SAMR LIBTLS ndr LP_RESOLVE gensec cli-ldap-common',
                   private_library=True
+                  )

vendor/current/source4/libcli/libcli.h

-              r414
+              r988
 #include "librpc/gen_ndr/nbt.h"
+#include "libcli/raw/libcliraw.h"
 struct substitute_context;
 …
  */
 struct smbcli_state {
+        struct smbcli_options options;
+        struct smbcli_socket *sock; /* NULL if connected */
         struct smbcli_transport *transport;
         struct smbcli_session *session;
 …
 };
 #include "libcli/raw/libcliraw.h"
 struct gensec_settings;
+#include "libcli/libcli_proto.h"
+ssize_t smbcli_read(struct smbcli_tree *tree, int fnum, void *_buf, off_t offset, size_t size);
+/****************************************************************************
+  write to a file
+  write_mode: 0x0001 disallow write cacheing
+x0002 return bytes remaining
+x0004 use raw named pipe protocol
+x0008 start of message mode named pipe protocol
+****************************************************************************/
+ssize_t smbcli_write(struct smbcli_tree *tree,
+                     int fnum, uint16_t write_mode,
+                     const void *_buf, off_t offset, size_t size);
+/****************************************************************************
+  write to a file using a SMBwrite and not bypassing 0 byte writes
+****************************************************************************/
+ssize_t smbcli_smbwrite(struct smbcli_tree *tree,
+                     int fnum, const void *_buf, off_t offset, size_t size1);
+bool smbcli_socket_connect(struct smbcli_state *cli, const char *server,
+                           const char **ports,
+                           struct tevent_context *ev_ctx,
+                           struct resolve_context *resolve_ctx,
+                           struct smbcli_options *options,
+                           const char *socket_options,
+                           struct nbt_name *calling,
+                           struct nbt_name *called);
+NTSTATUS smbcli_negprot(struct smbcli_state *cli, bool unicode, int maxprotocol);
+NTSTATUS smbcli_session_setup(struct smbcli_state *cli,
+                              struct cli_credentials *credentials,
+                              const char *workgroup,
+                              struct smbcli_session_options options,
+                              struct gensec_settings *gensec_settings);
+NTSTATUS smbcli_tconX(struct smbcli_state *cli, const char *sharename,
+                      const char *devtype, const char *password);
+NTSTATUS smbcli_full_connection(TALLOC_CTX *parent_ctx,
+                                struct smbcli_state **ret_cli,
+                                const char *host,
+                                const char **ports,
+                                const char *sharename,
+                                const char *devtype,
+                                const char *socket_options,
+                                struct cli_credentials *credentials,
+                                struct resolve_context *resolve_ctx,
+                                struct tevent_context *ev,
+                                struct smbcli_options *options,
+                                struct smbcli_session_options *session_options,
+                                struct gensec_settings *gensec_settings);
+NTSTATUS smbcli_tdis(struct smbcli_state *cli);
+/****************************************************************************
+ Initialise a client state structure.
+****************************************************************************/
+struct smbcli_state *smbcli_state_init(TALLOC_CTX *mem_ctx);
+bool smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
+                      char **hostname, char **sharename);
+/****************************************************************************
+ Symlink a file (UNIX extensions).
+****************************************************************************/
+NTSTATUS smbcli_unix_symlink(struct smbcli_tree *tree, const char *fname_src,
+                          const char *fname_dst);
+/****************************************************************************
+ Hard a file (UNIX extensions).
+****************************************************************************/
+NTSTATUS smbcli_unix_hardlink(struct smbcli_tree *tree, const char *fname_src,
+                           const char *fname_dst);
+/****************************************************************************
+ chmod a file (UNIX extensions).
+****************************************************************************/
+NTSTATUS smbcli_unix_chmod(struct smbcli_tree *tree, const char *fname, mode_t mode);
+/****************************************************************************
+ chown a file (UNIX extensions).
+****************************************************************************/
+NTSTATUS smbcli_unix_chown(struct smbcli_tree *tree, const char *fname, uid_t uid,
+                        gid_t gid);
+/****************************************************************************
+ Rename a file.
+****************************************************************************/
+NTSTATUS smbcli_rename(struct smbcli_tree *tree, const char *fname_src,
+                    const char *fname_dst);
+/****************************************************************************
+ Delete a file.
+****************************************************************************/
+NTSTATUS smbcli_unlink(struct smbcli_tree *tree, const char *fname);
+/****************************************************************************
+ Create a directory.
+****************************************************************************/
+NTSTATUS smbcli_mkdir(struct smbcli_tree *tree, const char *dname);
+/****************************************************************************
+ Remove a directory.
+****************************************************************************/
+NTSTATUS smbcli_rmdir(struct smbcli_tree *tree, const char *dname);
+/****************************************************************************
+ Set or clear the delete on close flag.
+****************************************************************************/
+NTSTATUS smbcli_nt_delete_on_close(struct smbcli_tree *tree, int fnum,
+                                   bool flag);
+/****************************************************************************
+ Create/open a file - exposing the full horror of the NT API :-).
+ Used in CIFS-on-CIFS NTVFS.
+****************************************************************************/
+int smbcli_nt_create_full(struct smbcli_tree *tree, const char *fname,
+                       uint32_t CreatFlags, uint32_t DesiredAccess,
+                       uint32_t FileAttributes, uint32_t ShareAccess,
+                       uint32_t CreateDisposition, uint32_t CreateOptions,
+                       uint8_t SecurityFlags);
+/****************************************************************************
+ Open a file (using SMBopenx)
+ WARNING: if you open with O_WRONLY then getattrE won't work!
+****************************************************************************/
+int smbcli_open(struct smbcli_tree *tree, const char *fname, int flags,
+             int share_mode);
+/****************************************************************************
+ Close a file.
+****************************************************************************/
+NTSTATUS smbcli_close(struct smbcli_tree *tree, int fnum);
+/****************************************************************************
+ send a lock with a specified locktype
+ this is used for testing LOCKING_ANDX_CANCEL_LOCK
+****************************************************************************/
+NTSTATUS smbcli_locktype(struct smbcli_tree *tree, int fnum,
+                      uint32_t offset, uint32_t len, int timeout,
+                      uint8_t locktype);
+/****************************************************************************
+ Lock a file.
+****************************************************************************/
+NTSTATUS smbcli_lock(struct smbcli_tree *tree, int fnum,
+                  uint32_t offset, uint32_t len, int timeout,
+                  enum brl_type lock_type);
+/****************************************************************************
+ Unlock a file.
+****************************************************************************/
+NTSTATUS smbcli_unlock(struct smbcli_tree *tree, int fnum, uint32_t offset, uint32_t len);
+/****************************************************************************
+ Lock a file with 64 bit offsets.
+****************************************************************************/
+NTSTATUS smbcli_lock64(struct smbcli_tree *tree, int fnum,
+                    off_t offset, off_t len, int timeout,
+                    enum brl_type lock_type);
+/****************************************************************************
+ Unlock a file with 64 bit offsets.
+****************************************************************************/
+NTSTATUS smbcli_unlock64(struct smbcli_tree *tree, int fnum, off_t offset,
+                         off_t len);
+/****************************************************************************
+ Do a SMBgetattrE call.
+****************************************************************************/
+NTSTATUS smbcli_getattrE(struct smbcli_tree *tree, int fnum,
+                      uint16_t *attr, size_t *size,
+                      time_t *c_time, time_t *a_time, time_t *m_time);
+/****************************************************************************
+ Do a SMBgetatr call
+****************************************************************************/
+NTSTATUS smbcli_getatr(struct smbcli_tree *tree, const char *fname,
+                    uint16_t *attr, size_t *size, time_t *t);
+/****************************************************************************
+ Do a SMBsetatr call.
+****************************************************************************/
+NTSTATUS smbcli_setatr(struct smbcli_tree *tree, const char *fname, uint16_t mode,
+                    time_t t);
+/****************************************************************************
+ Do a setfileinfo basic_info call.
+****************************************************************************/
+NTSTATUS smbcli_fsetatr(struct smbcli_tree *tree, int fnum, uint16_t mode,
+                        NTTIME create_time, NTTIME access_time,
+                        NTTIME write_time, NTTIME change_time);
+/****************************************************************************
+ truncate a file to a given size
+****************************************************************************/
+NTSTATUS smbcli_ftruncate(struct smbcli_tree *tree, int fnum, uint64_t size);
+/****************************************************************************
+ Check for existence of a dir.
+****************************************************************************/
+NTSTATUS smbcli_chkpath(struct smbcli_tree *tree, const char *path);
+/****************************************************************************
+ Query disk space.
+****************************************************************************/
+NTSTATUS smbcli_dskattr(struct smbcli_tree *tree, uint32_t *bsize,
+                        uint64_t *total, uint64_t *avail);
+/****************************************************************************
+ Create and open a temporary file.
+****************************************************************************/
+int smbcli_ctemp(struct smbcli_tree *tree, const char *path, char **tmp_path);
+/****************************************************************************
+ Interpret a long filename structure.
+****************************************************************************/
+int smbcli_list_new(struct smbcli_tree *tree, const char *Mask, uint16_t attribute,
+                    enum smb_search_data_level level,
+                    void (*fn)(struct clilist_file_info *, const char *, void *),
+                    void *caller_state);
+/****************************************************************************
+ Interpret a short filename structure.
+ The length of the structure is returned.
+****************************************************************************/
+int smbcli_list_old(struct smbcli_tree *tree, const char *Mask, uint16_t attribute,
+                 void (*fn)(struct clilist_file_info *, const char *, void *),
+                 void *caller_state);
+/****************************************************************************
+ Do a directory listing, calling fn on each file found.
+ This auto-switches between old and new style.
+****************************************************************************/
+int smbcli_list(struct smbcli_tree *tree, const char *Mask,uint16_t attribute,
+                void (*fn)(struct clilist_file_info *, const char *, void *), void *state);
+/****************************************************************************
+send a qpathinfo call
+****************************************************************************/
+NTSTATUS smbcli_qpathinfo(struct smbcli_tree *tree, const char *fname,
+                       time_t *c_time, time_t *a_time, time_t *m_time,
+                       size_t *size, uint16_t *mode);
+/****************************************************************************
+send a qpathinfo call with the SMB_QUERY_FILE_ALL_INFO info level
+****************************************************************************/
+NTSTATUS smbcli_qpathinfo2(struct smbcli_tree *tree, const char *fname,
+                        time_t *c_time, time_t *a_time, time_t *m_time,
+                        time_t *w_time, size_t *size, uint16_t *mode,
+                        ino_t *ino);
+/****************************************************************************
+send a qfileinfo QUERY_FILE_NAME_INFO call
+****************************************************************************/
+NTSTATUS smbcli_qfilename(struct smbcli_tree *tree, int fnum, const char **name);
+/****************************************************************************
+send a qfileinfo call
+****************************************************************************/
+NTSTATUS smbcli_qfileinfo(struct smbcli_tree *tree, int fnum,
+                       uint16_t *mode, size_t *size,
+                       time_t *c_time, time_t *a_time, time_t *m_time,
+                       time_t *w_time, ino_t *ino);
+/****************************************************************************
+send a qpathinfo SMB_QUERY_FILE_ALT_NAME_INFO call
+****************************************************************************/
+NTSTATUS smbcli_qpathinfo_alt_name(struct smbcli_tree *tree, const char *fname,
+                                const char **alt_name);
+/* The following definitions come from ../source4/libcli/climessage.c  */
+/****************************************************************************
+start a message sequence
+****************************************************************************/
+bool smbcli_message_start(struct smbcli_tree *tree, const char *host, const char *username,
+                       int *grp);
+/****************************************************************************
+send a message
+****************************************************************************/
+bool smbcli_message_text(struct smbcli_tree *tree, char *msg, int len, int grp);
+/****************************************************************************
+end a message
+****************************************************************************/
+bool smbcli_message_end(struct smbcli_tree *tree, int grp);
+int smbcli_deltree(struct smbcli_tree *tree, const char *dname);
 #endif /* __LIBCLI_H__ */

vendor/current/source4/libcli/rap/rap.c

-              r740
+              r988
         struct rap_call *call;
+        call = talloc(mem_ctx, struct rap_call);
+        if (call == NULL)
+        call = talloc_zero(mem_ctx, struct rap_call);
+        if (call == NULL) {
                 return NULL;
+        }
         call->callno = callno;
         call->rcv_paramlen = 4;
         call->paramdesc = NULL;
         call->datadesc = NULL;
         call->auxdatadesc = NULL;
         call->ndr_push_param = ndr_push_init_ctx(mem_ctx);
+        call->ndr_push_param = ndr_push_init_ctx(call);
+        if (call->ndr_push_param == NULL) {
+                talloc_free(call);
+                return NULL;
+        }
         call->ndr_push_param->flags = RAPNDR_FLAGS;
+        call->ndr_push_data = ndr_push_init_ctx(mem_ctx);
+        call->ndr_push_data = ndr_push_init_ctx(call);
+        if (call->ndr_push_data == NULL) {
+                talloc_free(call);
+                return NULL;
+        }
         call->ndr_push_data->flags = RAPNDR_FLAGS;
+        call->pull_mem_ctx = mem_ctx;
         return call;
 …
         call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call);
         call->ndr_pull_param->flags = RAPNDR_FLAGS;
+        call->ndr_pull_param->current_mem_ctx = call->pull_mem_ctx;
         call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call);
         call->ndr_pull_data->flags = RAPNDR_FLAGS;
+        call->ndr_pull_data->current_mem_ctx = call->pull_mem_ctx;
         return result;

vendor/current/source4/libcli/rap/rap.h

-              r740
+              r988
         const char *auxdatadesc;
-        uint16_t status;
-        uint16_t convert;
         uint16_t rcv_paramlen, rcv_datalen;
         struct ndr_push *ndr_push_param;
         struct ndr_push *ndr_push_data;
+        TALLOC_CTX *pull_mem_ctx;
         struct ndr_pull *ndr_pull_param;
         struct ndr_pull *ndr_pull_data;

vendor/current/source4/libcli/rap/wscript_build

r740	r988
3	3	bld.SAMBA_SUBSYSTEM('LIBCLI_RAP',
4	4	source='rap.c',
5		public_deps='~~LIBCLI_RAW~~ NDR_RAP',
	5	public_deps='smbclient-raw NDR_RAP',
6	6	autoproto='proto.h'
7	7	)

vendor/current/source4/libcli/raw/clioplock.c

-              r414
+              r988
         req = smbcli_request_setup(tree, SMBlockingX, 8, 0);
+        if (req == NULL) {
+                return false;
+        }
         SSVAL(req->out.vwv,VWV(0),0xFF);
 …
         SSVAL(req->out.vwv,VWV(7),0);
+        /* this request does not expect a reply, so tell the signing
+           subsystem not to allocate an id for a reply */
+        req->one_way_request = 1;
+        ret = smbcli_request_send(req);
+        /*
+         * The low level code knows it is a
+         * one way request by looking at SMBlockingX,
+         * wct == 8 and LOCKING_ANDX_OPLOCK_RELEASE
+         */
+        ret = smbcli_request_send(req);
         return ret;

vendor/current/source4/libcli/raw/clisession.c

-              r414
+              r988
 #include "libcli/raw/raw_proto.h"
 #include "system/filesys.h"
+#include "../libcli/smb/smbXcli_base.h"
 #define SETUP_REQUEST_SESSION(cmd, wct, buflen) do { \
 …
         session->vuid = UID_FIELD_INVALID;
         session->options = options;
+        /*
+         * for now session->vuid is still used by the callers, but we call:
+         * smb1cli_session_set_id(session->smbXcli, session->vuid);
+         * before using session->smbXcli, in future we should remove
+         * session->vuid.
+         */
+        session->smbXcli = smbXcli_session_create(session, transport->conn);
+        if (session->smbXcli == NULL) {
+                talloc_free(session);
+                return NULL;
+        }
         capabilities = transport->negotiate.capabilities;
 …
                 flags2 |= FLAGS2_EXTENDED_SECURITY;
+        }
         if (session->transport->negotiate.sign_info.doing_signing) {
+        if (smb1cli_conn_signing_is_active(session->transport->conn)) {
                 flags2 |= FLAGS2_SMB_SECURITY_SIGNATURES;
+        }

vendor/current/source4/libcli/raw/clisocket.c

-              r740
+              r988
 #include "includes.h"
+#include "system/network.h"
+#include "../lib/async_req/async_sock.h"
+#include "../lib/util/tevent_ntstatus.h"
 #include "lib/events/events.h"
 #include "libcli/raw/libcliraw.h"
 …
 #include "param/param.h"
 #include "libcli/raw/raw_proto.h"
+#include "../libcli/smb/read_smb.h"
+struct smbcli_transport_connect_state {
+        struct tevent_context *ev;
+        struct socket_context *sock;
+        struct tevent_req *io_req;
+        uint8_t *request;
+        struct iovec iov;
+        uint8_t *response;
+};
+static void smbcli_transport_connect_cleanup(struct tevent_req *req,
+                                             enum tevent_req_state req_state);
+static void smbcli_transport_connect_writev_done(struct tevent_req *subreq);
+static void smbcli_transport_connect_read_smb_done(struct tevent_req *subreq);
+static struct tevent_req *smbcli_transport_connect_send(TALLOC_CTX *mem_ctx,
+                                                 struct tevent_context *ev,
+                                                 struct socket_context *sock,
+                                                 uint16_t port,
+                                                 uint32_t timeout_msec,
+                                                 struct nbt_name *calling,
+                                                 struct nbt_name *called)
+{
+        struct tevent_req *req;
+        struct smbcli_transport_connect_state *state;
+        struct tevent_req *subreq;
+        DATA_BLOB calling_blob, called_blob;
+        uint8_t *p;
+        NTSTATUS status;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct smbcli_transport_connect_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->sock = sock;
+        if (port != 139) {
+                tevent_req_done(req);
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_cleanup_fn(req, smbcli_transport_connect_cleanup);
+        status = nbt_name_to_blob(state, &calling_blob, calling);
+        if (tevent_req_nterror(req, status)) {
+                return tevent_req_post(req, ev);
+        }
+        status = nbt_name_to_blob(state, &called_blob, called);
+        if (tevent_req_nterror(req, status)) {
+                return tevent_req_post(req, ev);
+        }
+        state->request = talloc_array(state, uint8_t,
+                                      NBT_HDR_SIZE +
+                                      called_blob.length +
+                                      calling_blob.length);
+        if (tevent_req_nomem(state->request, req)) {
+                return tevent_req_post(req, ev);
+        }
+        /* put in the destination name */
+        p = state->request + NBT_HDR_SIZE;
+        memcpy(p, called_blob.data, called_blob.length);
+        p += called_blob.length;
+        memcpy(p, calling_blob.data, calling_blob.length);
+        p += calling_blob.length;
+        _smb_setlen_nbt(state->request,
+                        PTR_DIFF(p, state->request) - NBT_HDR_SIZE);
+        SCVAL(state->request, 0, NBSSrequest);
+        state->iov.iov_len = talloc_array_length(state->request);
+        state->iov.iov_base = (void *)state->request;
+        subreq = writev_send(state, ev, NULL,
+                             sock->fd,
+                             true, /* err_on_readability */
+                             &state->iov, 1);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq,
+                                smbcli_transport_connect_writev_done,
+                                req);
+        state->io_req = subreq;
+        if (timeout_msec > 0) {
+                struct timeval endtime;
+                endtime = timeval_current_ofs_msec(timeout_msec);
+                if (!tevent_req_set_endtime(req, ev, endtime)) {
+                        return tevent_req_post(req, ev);
+                }
+        }
+        return req;
+}
+static void smbcli_transport_connect_cleanup(struct tevent_req *req,
+                                             enum tevent_req_state req_state)
+{
+        struct smbcli_transport_connect_state *state =
+                tevent_req_data(req,
+                struct smbcli_transport_connect_state);
+        TALLOC_FREE(state->io_req);
+        if (state->sock == NULL) {
+                return;
+        }
+        if (state->sock->fd == -1) {
+                return;
+        }
+        if (req_state == TEVENT_REQ_DONE) {
+                /*
+                 * we keep the socket open for the caller to use
+                 */
+                state->sock = NULL;
+                return;
+        }
+        close(state->sock->fd);
+        state->sock->fd = -1;
+        state->sock = NULL;
+}
+static void smbcli_transport_connect_writev_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        struct smbcli_transport_connect_state *state =
+                tevent_req_data(req,
+                struct smbcli_transport_connect_state);
+        ssize_t ret;
+        int err;
+        state->io_req = NULL;
+        ret = writev_recv(subreq, &err);
+        TALLOC_FREE(subreq);
+        if (ret == -1) {
+                NTSTATUS status = map_nt_error_from_unix_common(err);
+                tevent_req_nterror(req, status);
+                return;
+        }
+        subreq = read_smb_send(state, state->ev,
+                               state->sock->fd);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq,
+                                smbcli_transport_connect_read_smb_done,
+                                req);
+        state->io_req = subreq;
+}
+static void smbcli_transport_connect_read_smb_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        struct smbcli_transport_connect_state *state =
+                tevent_req_data(req,
+                struct smbcli_transport_connect_state);
+        ssize_t ret;
+        int err;
+        NTSTATUS status;
+        uint8_t error;
+        state->io_req = NULL;
+        ret = read_smb_recv(subreq, state,
+                            &state->response, &err);
+        TALLOC_FREE(subreq);
+        if (ret == -1) {
+                status = map_nt_error_from_unix_common(err);
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (ret < 4) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                return;
+        }
+        switch (CVAL(state->response, 0)) {
+        case NBSSpositive:
+                tevent_req_done(req);
+                return;
+        case NBSSnegative:
+                if (ret < 5) {
+                        tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                        return;
+                }
+                error = CVAL(state->response, 4);
+                switch (error) {
+                case 0x80:
+                case 0x81:
+                        status = NT_STATUS_REMOTE_NOT_LISTENING;
+                        break;
+                case 0x82:
+                        status = NT_STATUS_RESOURCE_NAME_NOT_FOUND;
+                        break;
+                case 0x83:
+                        status = NT_STATUS_REMOTE_RESOURCES;
+                        break;
+                default:
+                        status = NT_STATUS_INVALID_NETWORK_RESPONSE;
+                        break;
+                }
+                break;
+        case NBSSretarget:
+                DEBUG(1,("Warning: session retarget not supported\n"));
+                status = NT_STATUS_NOT_SUPPORTED;
+                break;
+        default:
+                status = NT_STATUS_INVALID_NETWORK_RESPONSE;
+                break;
+        }
+        tevent_req_nterror(req, status);
+}
+static NTSTATUS smbcli_transport_connect_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
 struct sock_connect_state {
 …
         const char *socket_options;
         struct smbcli_socket *result;
+        struct socket_connect_multi_ex multi_ex;
+        struct nbt_name calling;
+        struct nbt_name called;
 };
 …
   if port is 0 then choose 445 then 139
 */
+static struct tevent_req *smbcli_sock_establish_send(TALLOC_CTX *mem_ctx,
+                                                     struct tevent_context *ev,
+                                                     struct socket_context *sock,
+                                                     struct socket_address *addr,
+                                                     void *private_data)
+{
+        struct sock_connect_state *state =
+                talloc_get_type_abort(private_data,
+                struct sock_connect_state);
+        uint32_t timeout_msec = 15 * 1000;
+        return smbcli_transport_connect_send(state,
+                                             ev,
+                                             sock,
+                                             addr->port,
+                                             timeout_msec,
+                                             &state->calling,
+                                             &state->called);
+}
+static NTSTATUS smbcli_sock_establish_recv(struct tevent_req *req)
+{
+        return smbcli_transport_connect_recv(req);
+}
 static void smbcli_sock_connect_recv_conn(struct composite_context *ctx);
 …
                                                    struct resolve_context *resolve_ctx,
                                                    struct tevent_context *event_ctx,
+                                                   const char *socket_options)
+                                                   const char *socket_options,
+                                                   struct nbt_name *calling,
+                                                   struct nbt_name *called)
+{
         struct composite_context *result, *ctx;
         struct sock_connect_state *state;
+        NTSTATUS status;
         int i;
 …
+        }
+        ctx = socket_connect_multi_send(state, host_addr,
+                                        state->num_ports, state->ports,
+                                        resolve_ctx,
+                                        state->ctx->event_ctx);
+        state->multi_ex.private_data = state;
+        state->multi_ex.establish_send = smbcli_sock_establish_send;
+        state->multi_ex.establish_recv = smbcli_sock_establish_recv;
+        status = nbt_name_dup(state, calling, &state->calling);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto failed;
+        }
+        status = nbt_name_dup(state, called, &state->called);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto failed;
+        }
+        ctx = socket_connect_multi_ex_send(state, host_addr,
+                                           state->num_ports, state->ports,
+                                           resolve_ctx,
+                                           state->ctx->event_ctx,
+                                           &state->multi_ex);
         if (ctx == NULL) goto failed;
         ctx->async.fn = smbcli_sock_connect_recv_conn;
 …
         uint16_t port;
         state->ctx->status = socket_connect_multi_recv(ctx, state, &sock,
                                                        &port);
+        state->ctx->status = socket_connect_multi_ex_recv(ctx, state, &sock,
+                                                          &port);
         if (!composite_is_ok(state->ctx)) return;
 …
                              struct resolve_context *resolve_ctx,
                              struct tevent_context *event_ctx,
+                                 const char *socket_options,
+                             const char *socket_options,
+                             struct nbt_name *calling,
+                             struct nbt_name *called,
                              struct smbcli_socket **result)
+{
 …
                 smbcli_sock_connect_send(mem_ctx, host_addr, ports, host_name,
                                          resolve_ctx,
+                                         event_ctx, socket_options);
+                                         event_ctx, socket_options,
+                                         calling, called);
         return smbcli_sock_connect_recv(c, mem_ctx, result);
+}
-/****************************************************************************
- mark the socket as dead
-****************************************************************************/
-_PUBLIC_ void smbcli_sock_dead(struct smbcli_socket *sock)
+{
-        talloc_free(sock->event.fde);
-        sock->event.fde = NULL;
-        talloc_free(sock->sock);
-        sock->sock = NULL;
+}
-/****************************************************************************
- Set socket options on a open connection.
-****************************************************************************/
-void smbcli_sock_set_options(struct smbcli_socket *sock, const char *options)
+{
-        socket_set_option(sock->sock, options, NULL);
+}
-/****************************************************************************
-resolve a hostname and connect
-****************************************************************************/
-_PUBLIC_ struct smbcli_socket *smbcli_sock_connect_byname(const char *host, const char **ports,
-                                                 TALLOC_CTX *mem_ctx,
-                                                 struct resolve_context *resolve_ctx,
-                                                 struct tevent_context *event_ctx,
-                                                 const char *socket_options)
+{
-        int name_type = NBT_NAME_SERVER;
-        const char *address;
-        NTSTATUS status;
-        struct nbt_name nbt_name;
-        char *name, *p;
-        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
-        struct smbcli_socket *result;
-        if (event_ctx == NULL) {
-                DEBUG(0, ("Invalid NULL event context passed in as parameter\n"));
-                return NULL;
+        }
-        if (tmp_ctx == NULL) {
-                DEBUG(0, ("talloc_new failed\n"));
-                return NULL;
+        }
-        name = talloc_strdup(tmp_ctx, host);
-        if (name == NULL) {
-                DEBUG(0, ("talloc_strdup failed\n"));
-                talloc_free(tmp_ctx);
-                return NULL;
+        }
-        /* allow hostnames of the form NAME#xx and do a netbios lookup */
-        if ((p = strchr(name, '#'))) {
-                name_type = strtol(p+1, NULL, 16);
-                *p = 0;
+        }
-        make_nbt_name(&nbt_name, host, name_type);
-        status = resolve_name(resolve_ctx, &nbt_name, tmp_ctx, &address, event_ctx);
-        if (!NT_STATUS_IS_OK(status)) {
-                talloc_free(tmp_ctx);
-                return NULL;
+        }
-        status = smbcli_sock_connect(mem_ctx, address, ports, name, resolve_ctx,
-                                     event_ctx,
-                                         socket_options, &result);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(9, ("smbcli_sock_connect failed: %s\n",
-                          nt_errstr(status)));
-                talloc_free(tmp_ctx);
-                return NULL;
+        }
-        talloc_free(tmp_ctx);
-        return result;
+}

vendor/current/source4/libcli/raw/clitransport.c

-              r740
+              r988
 #include "includes.h"
+#include "system/network.h"
+#include "../lib/async_req/async_sock.h"
+#include "../lib/util/tevent_ntstatus.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
 #include "lib/socket/socket.h"
-#include "../lib/util/dlinklist.h"
 #include "lib/events/events.h"
-#include "lib/stream/packet.h"
 #include "librpc/gen_ndr/ndr_nbt.h"
 #include "../libcli/nbt/libnbt.h"
+/*
+  an event has happened on the socket
+*/
+static void smbcli_transport_event_handler(struct tevent_context *ev,
+                                           struct tevent_fd *fde,
+                                           uint16_t flags, void *private_data)
+{
+        struct smbcli_transport *transport = talloc_get_type(private_data,
+                                                             struct smbcli_transport);
+        if (flags & EVENT_FD_READ) {
+                packet_recv(transport->packet);
+                return;
+        }
+        if (flags & EVENT_FD_WRITE) {
+                packet_queue_run(transport->packet);
+        }
+}
+#include "../libcli/smb/smbXcli_base.h"
+#include "../libcli/smb/read_smb.h"
 /*
 …
         return 0;
+}
-/*
-  handle receive errors
-*/
-static void smbcli_transport_error(void *private_data, NTSTATUS status)
+{
-        struct smbcli_transport *transport = talloc_get_type(private_data, struct smbcli_transport);
-        smbcli_transport_dead(transport, status);
+}
-static NTSTATUS smbcli_transport_finish_recv(void *private_data, DATA_BLOB blob);
 /*
 …
+{
         struct smbcli_transport *transport;
+        uint32_t smb1_capabilities;
         transport = talloc_zero(parent_ctx, struct smbcli_transport);
         if (!transport) return NULL;
+        if (primary) {
+                transport->socket = talloc_steal(transport, sock);
+        } else {
+                transport->socket = talloc_reference(transport, sock);
+        }
+        transport->negotiate.protocol = PROTOCOL_NT1;
+        transport->ev = sock->event.ctx;
         transport->options = *options;
+        transport->negotiate.max_xmit = transport->options.max_xmit;
+        /* setup the stream -> packet parser */
+        transport->packet = packet_init(transport);
+        if (transport->packet == NULL) {
+                talloc_free(transport);
+        if (transport->options.max_protocol == PROTOCOL_DEFAULT) {
+                transport->options.max_protocol = PROTOCOL_NT1;
+        }
+        if (transport->options.max_protocol > PROTOCOL_NT1) {
+                transport->options.max_protocol = PROTOCOL_NT1;
+        }
+        TALLOC_FREE(sock->event.fde);
+        TALLOC_FREE(sock->event.te);
+        smb1_capabilities = 0;
+        smb1_capabilities |= CAP_LARGE_FILES;
+        smb1_capabilities |= CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
+        smb1_capabilities |= CAP_LOCK_AND_READ | CAP_NT_FIND;
+        smb1_capabilities |= CAP_DFS | CAP_W2K_SMBS;
+        smb1_capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX;
+        smb1_capabilities |= CAP_LWIO;
+        if (options->ntstatus_support) {
+                smb1_capabilities |= CAP_STATUS32;
+        }
+        if (options->unicode) {
+                smb1_capabilities |= CAP_UNICODE;
+        }
+        if (options->use_spnego) {
+                smb1_capabilities |= CAP_EXTENDED_SECURITY;
+        }
+        if (options->use_level2_oplocks) {
+                smb1_capabilities |= CAP_LEVEL_II_OPLOCKS;
+        }
+        transport->conn = smbXcli_conn_create(transport,
+                                              sock->sock->fd,
+                                              sock->hostname,
+                                              options->signing,
+                                              smb1_capabilities,
+                                              NULL, /* client_guid */
+); /* smb2_capabilities */
+        if (transport->conn == NULL) {
+                TALLOC_FREE(sock);
+                TALLOC_FREE(transport);
                 return NULL;
+        }
+        packet_set_private(transport->packet, transport);
+        packet_set_socket(transport->packet, transport->socket->sock);
+        packet_set_callback(transport->packet, smbcli_transport_finish_recv);
+        packet_set_full_request(transport->packet, packet_full_request_nbt);
+        packet_set_error_handler(transport->packet, smbcli_transport_error);
+        packet_set_event_context(transport->packet, transport->socket->event.ctx);
+        packet_set_nofree(transport->packet);
+        packet_set_initial_read(transport->packet, 4);
+        smbcli_init_signing(transport);
+        ZERO_STRUCT(transport->called);
+        /* take over event handling from the socket layer - it only
+           handles events up until we are connected */
+        talloc_free(transport->socket->event.fde);
+        transport->socket->event.fde = event_add_fd(transport->socket->event.ctx,
+                                                    transport->socket->sock,
+                                                    socket_get_fd(transport->socket->sock),
+                                                    EVENT_FD_READ,
+                                                    smbcli_transport_event_handler,
+                                                    transport);
+        packet_set_fde(transport->packet, transport->socket->event.fde);
+        packet_set_serialise(transport->packet);
+        sock->sock->fd = -1;
+        TALLOC_FREE(sock);
         talloc_set_destructor(transport, transport_destructor);
 …
 void smbcli_transport_dead(struct smbcli_transport *transport, NTSTATUS status)
+{
-        smbcli_sock_dead(transport->socket);
         if (NT_STATUS_EQUAL(NT_STATUS_UNSUCCESSFUL, status)) {
                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
+        }
+        /* kill only the first pending receive - this is so that if
+         that async function frees the connection we don't die trying
+         to use old memory. The caller has to cope with only one
+         network error */
+        if (transport->pending_recv) {
+                struct smbcli_request *req = transport->pending_recv;
+                req->state = SMBCLI_REQUEST_ERROR;
+                req->status = status;
+                DLIST_REMOVE(transport->pending_recv, req);
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+        }
+}
+/*
+  send a session request
+*/
+struct smbcli_request *smbcli_transport_connect_send(struct smbcli_transport *transport,
+                                                     struct nbt_name *calling,
+                                                     struct nbt_name *called)
+{
+        uint8_t *p;
+        struct smbcli_request *req;
+        DATA_BLOB calling_blob, called_blob;
+        TALLOC_CTX *tmp_ctx = talloc_new(transport);
+        NTSTATUS status;
+        status = nbt_name_dup(transport, called, &transport->called);
+        if (!NT_STATUS_IS_OK(status)) goto failed;
+        status = nbt_name_to_blob(tmp_ctx, &calling_blob, calling);
+        if (!NT_STATUS_IS_OK(status)) goto failed;
+        status = nbt_name_to_blob(tmp_ctx, &called_blob, called);
+        if (!NT_STATUS_IS_OK(status)) goto failed;
+        /* allocate output buffer */
+        req = smbcli_request_setup_nonsmb(transport,
+                                          NBT_HDR_SIZE +
+                                          calling_blob.length + called_blob.length);
+        if (req == NULL) goto failed;
+        /* put in the destination name */
+        p = req->out.buffer + NBT_HDR_SIZE;
+        memcpy(p, called_blob.data, called_blob.length);
+        p += called_blob.length;
+        memcpy(p, calling_blob.data, calling_blob.length);
+        p += calling_blob.length;
+        _smb_setlen(req->out.buffer, PTR_DIFF(p, req->out.buffer) - NBT_HDR_SIZE);
+        SCVAL(req->out.buffer,0,0x81);
+        if (!smbcli_request_send(req)) {
+                smbcli_request_destroy(req);
+                goto failed;
+        }
+        talloc_free(tmp_ctx);
+        return req;
+failed:
+        talloc_free(tmp_ctx);
+        return NULL;
+}
+/*
+  map a session request error to a NTSTATUS
+ */
+static NTSTATUS map_session_refused_error(uint8_t error)
+{
+        switch (error) {
+        case 0x80:
+        case 0x81:
+                return NT_STATUS_REMOTE_NOT_LISTENING;
+        case 0x82:
+                return NT_STATUS_RESOURCE_NAME_NOT_FOUND;
+        case 0x83:
+                return NT_STATUS_REMOTE_RESOURCES;
+        }
+        return NT_STATUS_UNEXPECTED_IO_ERROR;
+}
+/*
+  finish a smbcli_transport_connect()
+*/
+NTSTATUS smbcli_transport_connect_recv(struct smbcli_request *req)
+{
+        NTSTATUS status;
+        if (!smbcli_request_receive(req)) {
+                smbcli_request_destroy(req);
+                return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
+        }
+        switch (CVAL(req->in.buffer,0)) {
+        case 0x82:
+                status = NT_STATUS_OK;
+                break;
+        case 0x83:
+                status = map_session_refused_error(CVAL(req->in.buffer,4));
+                break;
+        case 0x84:
+                DEBUG(1,("Warning: session retarget not supported\n"));
+                status = NT_STATUS_NOT_SUPPORTED;
+                break;
+        default:
+                status = NT_STATUS_UNEXPECTED_IO_ERROR;
+                break;
+        }
+        smbcli_request_destroy(req);
+        return status;
+}
+/*
+  send a session request (if needed)
+*/
+bool smbcli_transport_connect(struct smbcli_transport *transport,
+                              struct nbt_name *calling,
+                              struct nbt_name *called)
+{
+        struct smbcli_request *req;
+        NTSTATUS status;
+        if (transport->socket->port == 445) {
+                return true;
+        }
+        req = smbcli_transport_connect_send(transport,
+                                            calling, called);
+        status = smbcli_transport_connect_recv(req);
+        return NT_STATUS_IS_OK(status);
+}
+/****************************************************************************
+get next mid in sequence
+****************************************************************************/
+uint16_t smbcli_transport_next_mid(struct smbcli_transport *transport)
+{
+        uint16_t mid;
+        struct smbcli_request *req;
+        mid = transport->next_mid;
+again:
+        /* now check to see if this mid is being used by one of the
+           pending requests. This is quite efficient because the list is
+           usually very short */
+        /* the zero mid is reserved for requests that don't have a mid */
+        if (mid == 0) mid = 1;
+        for (req=transport->pending_recv; req; req=req->next) {
+                if (req->mid == mid) {
+                        mid++;
+                        goto again;
+                }
+        }
+        transport->next_mid = mid+1;
+        return mid;
+        if (NT_STATUS_IS_OK(status)) {
+                status = NT_STATUS_LOCAL_DISCONNECT;
+        }
+        smbXcli_conn_disconnect(transport->conn, status);
+}
 …
         struct smbcli_transport *transport = talloc_get_type(private_data,
                                                              struct smbcli_transport);
+        struct timeval next = timeval_add(&t, 0, transport->idle.period);
+        transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
+                                                      transport,
+                                                      next,
+                                                      idle_handler, transport);
+        struct timeval next;
         transport->idle.func(transport, transport->idle.private_data);
+        next = timeval_current_ofs_usec(transport->idle.period);
+        transport->idle.te = tevent_add_timer(transport->ev,
+                                              transport,
+                                              next,
+                                              idle_handler,
+                                              transport);
+}
 …
                                    void *private_data)
+{
+        TALLOC_FREE(transport->idle.te);
         transport->idle.func = idle_func;
         transport->idle.private_data = private_data;
         transport->idle.period = period;
+        if (transport->socket->event.te != NULL) {
+                talloc_free(transport->socket->event.te);
+        }
+        transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
+                                                      transport,
+                                                      timeval_current_ofs(0, period),
+                                                      idle_handler, transport);
+}
+/*
+  we have a full request in our receive buffer - match it to a pending request
+  and process
+ */
+static NTSTATUS smbcli_transport_finish_recv(void *private_data, DATA_BLOB blob)
+{
+        struct smbcli_transport *transport = talloc_get_type(private_data,
+                                                             struct smbcli_transport);
+        uint8_t *buffer, *hdr, *vwv;
+        int len;
+        uint16_t wct=0, mid = 0, op = 0;
+        struct smbcli_request *req = NULL;
+        buffer = blob.data;
+        len = blob.length;
+        hdr = buffer+NBT_HDR_SIZE;
+        vwv = hdr + HDR_VWV;
+        /* see if it could be an oplock break request */
+        if (smbcli_handle_oplock_break(transport, len, hdr, vwv)) {
+                talloc_free(buffer);
+                return NT_STATUS_OK;
+        }
+        /* at this point we need to check for a readbraw reply, as
+           these can be any length */
+        if (transport->readbraw_pending) {
+                transport->readbraw_pending = 0;
+                /* it must match the first entry in the pending queue
+                   as the client is not allowed to have outstanding
+                   readbraw requests */
+                req = transport->pending_recv;
+                if (!req) goto error;
+                req->in.buffer = buffer;
+                talloc_steal(req, buffer);
+                req->in.size = len;
+                req->in.allocated = req->in.size;
+                goto async;
+        }
+        if (len >= MIN_SMB_SIZE) {
+                /* extract the mid for matching to pending requests */
+                mid = SVAL(hdr, HDR_MID);
+                wct = CVAL(hdr, HDR_WCT);
+                op  = CVAL(hdr, HDR_COM);
+        }
+        /* match the incoming request against the list of pending requests */
+        for (req=transport->pending_recv; req; req=req->next) {
+                if (req->mid == mid) break;
+        }
+        /* see if it's a ntcancel reply for the current MID */
+        req = smbcli_handle_ntcancel_reply(req, len, hdr);
+        if (!req) {
+                DEBUG(1,("Discarding unmatched reply with mid %d op %d\n", mid, op));
+                goto error;
+        }
+        /* fill in the 'in' portion of the matching request */
+        req->in.buffer = buffer;
+        talloc_steal(req, buffer);
+        req->in.size = len;
+        req->in.allocated = req->in.size;
+        /* handle NBT session replies */
+        if (req->in.size >= 4 && req->in.buffer[0] != 0) {
+                req->status = NT_STATUS_OK;
+                goto async;
+        }
+        /* handle non-SMB replies */
+        if (req->in.size < NBT_HDR_SIZE + MIN_SMB_SIZE) {
+                req->state = SMBCLI_REQUEST_ERROR;
+                goto error;
+        }
+        if (req->in.size < NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct)) {
+                DEBUG(2,("bad reply size for mid %d\n", mid));
+                req->status = NT_STATUS_UNSUCCESSFUL;
+                req->state = SMBCLI_REQUEST_ERROR;
+                goto error;
+        }
+        req->in.hdr = hdr;
+        req->in.vwv = vwv;
+        req->in.wct = wct;
+        if (req->in.size >= NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct)) {
+                req->in.data = req->in.vwv + VWV(wct) + 2;
+                req->in.data_size = SVAL(req->in.vwv, VWV(wct));
+                if (req->in.size < NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct) + req->in.data_size) {
+                        DEBUG(3,("bad data size for mid %d\n", mid));
+                        /* blergh - w2k3 gives a bogus data size values in some
+                           openX replies */
+                        req->in.data_size = req->in.size - (NBT_HDR_SIZE + MIN_SMB_SIZE + VWV(wct));
+                }
+        }
+        req->in.ptr = req->in.data;
+        req->flags2 = SVAL(req->in.hdr, HDR_FLG2);
+        smb_setup_bufinfo(req);
+        if (!(req->flags2 & FLAGS2_32_BIT_ERROR_CODES)) {
+                int eclass = CVAL(req->in.hdr,HDR_RCLS);
+                int code = SVAL(req->in.hdr,HDR_ERR);
+                if (eclass == 0 && code == 0) {
+                        transport->error.e.nt_status = NT_STATUS_OK;
+                } else {
+                        transport->error.e.nt_status = NT_STATUS_DOS(eclass, code);
+                }
+        } else {
+                transport->error.e.nt_status = NT_STATUS(IVAL(req->in.hdr, HDR_RCLS));
+        }
+        req->status = transport->error.e.nt_status;
+        if (NT_STATUS_IS_OK(req->status)) {
+                transport->error.etype = ETYPE_NONE;
+        } else {
+                transport->error.etype = ETYPE_SMB;
+        }
+        if (!smbcli_request_check_sign_mac(req)) {
+                transport->error.etype = ETYPE_SOCKET;
+                transport->error.e.socket_error = SOCKET_READ_BAD_SIG;
+                req->state = SMBCLI_REQUEST_ERROR;
+                req->status = NT_STATUS_ACCESS_DENIED;
+                goto error;
+        };
+async:
+        /* if this request has an async handler then call that to
+           notify that the reply has been received. This might destroy
+           the request so it must happen last */
+        req->state = SMBCLI_REQUEST_DONE;
+        if (req->recv_helper.fn) {
+                /*
+                 * let the recv helper decide in
+                 * what state the request really is
+                 */
+                req->state = req->recv_helper.fn(req);
+                /* if more parts are needed, wait for them */
+                if (req->state <= SMBCLI_REQUEST_RECV) {
+                        return NT_STATUS_OK;
+                }
+        }
+        DLIST_REMOVE(transport->pending_recv, req);
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+        return NT_STATUS_OK;
+error:
+        if (req) {
+                DLIST_REMOVE(transport->pending_recv, req);
+                req->state = SMBCLI_REQUEST_ERROR;
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+        } else {
+                talloc_free(buffer);
+        }
+        return NT_STATUS_OK;
+        transport->idle.te = tevent_add_timer(transport->ev,
+                                              transport,
+                                              timeval_current_ofs_usec(period),
+                                              idle_handler,
+                                              transport);
+}
 …
 _PUBLIC_ bool smbcli_transport_process(struct smbcli_transport *transport)
+{
+        NTSTATUS status;
+        size_t npending;
+        packet_queue_run(transport->packet);
+        if (transport->socket->sock == NULL) {
+        struct tevent_req *subreq = NULL;
+        int ret;
+        if (!smbXcli_conn_is_connected(transport->conn)) {
                 return false;
+        }
+        status = socket_pending(transport->socket->sock, &npending);
+        if (NT_STATUS_IS_OK(status) && npending > 0) {
+                packet_recv(transport->packet);
+        }
+        if (transport->socket->sock == NULL) {
+        if (!smbXcli_conn_has_async_calls(transport->conn)) {
+                return true;
+        }
+        /*
+         * do not block for more than 500 micro seconds
+         */
+        subreq = tevent_wakeup_send(transport,
+                                    transport->ev,
+                                    timeval_current_ofs_usec(500));
+        if (subreq == NULL) {
                 return false;
+        }
+        ret = tevent_loop_once(transport->ev);
+        if (ret != 0) {
+                return false;
+        }
+        TALLOC_FREE(subreq);
+        if (!smbXcli_conn_is_connected(transport->conn)) {
+                return false;
+        }
         return true;
+}
+/*
+  handle timeouts of individual smb requests
+*/
+static void smbcli_timeout_handler(struct tevent_context *ev, struct tevent_timer *te,
+                                   struct timeval t, void *private_data)
+{
+        struct smbcli_request *req = talloc_get_type(private_data, struct smbcli_request);
+        if (req->state == SMBCLI_REQUEST_RECV) {
+                DLIST_REMOVE(req->transport->pending_recv, req);
+        }
+        req->status = NT_STATUS_IO_TIMEOUT;
+        req->state = SMBCLI_REQUEST_ERROR;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+/*
+  destroy a request
+*/
+static int smbcli_request_destructor(struct smbcli_request *req)
+{
+        if (req->state == SMBCLI_REQUEST_RECV) {
+                DLIST_REMOVE(req->transport->pending_recv, req);
+        }
+        return 0;
+}
+static void smbcli_transport_break_handler(struct tevent_req *subreq);
+static void smbcli_request_done(struct tevent_req *subreq);
+struct tevent_req *smbcli_transport_setup_subreq(struct smbcli_request *req)
+{
+        struct smbcli_transport *transport = req->transport;
+        uint8_t smb_command;
+        uint8_t additional_flags;
+        uint8_t clear_flags;
+        uint16_t additional_flags2;
+        uint16_t clear_flags2;
+        uint32_t pid;
+        struct smbXcli_tcon *tcon = NULL;
+        struct smbXcli_session *session = NULL;
+        uint32_t timeout_msec = transport->options.request_timeout * 1000;
+        struct iovec *bytes_iov = NULL;
+        struct tevent_req *subreq = NULL;
+        smb_command = SVAL(req->out.hdr, HDR_COM);
+        additional_flags = CVAL(req->out.hdr, HDR_FLG);
+        additional_flags2 = SVAL(req->out.hdr, HDR_FLG2);
+        pid  = SVAL(req->out.hdr, HDR_PID);
+        pid |= SVAL(req->out.hdr, HDR_PIDHIGH)<<16;
+        clear_flags = ~additional_flags;
+        clear_flags2 = ~additional_flags2;
+        if (req->session) {
+                session = req->session->smbXcli;
+        }
+        if (req->tree) {
+                tcon = req->tree->smbXcli;
+        }
+        bytes_iov = talloc(req, struct iovec);
+        if (bytes_iov == NULL) {
+                return NULL;
+        }
+        bytes_iov->iov_base = (void *)req->out.data;
+        bytes_iov->iov_len = req->out.data_size;
+        subreq = smb1cli_req_create(req,
+                                    transport->ev,
+                                    transport->conn,
+                                    smb_command,
+                                    additional_flags,
+                                    clear_flags,
+                                    additional_flags2,
+                                    clear_flags2,
+                                    timeout_msec,
+                                    pid,
+                                    tcon,
+                                    session,
+                                    req->out.wct,
+                                    (uint16_t *)req->out.vwv,
+, bytes_iov);
+        if (subreq == NULL) {
+                return NULL;
+        }
+        ZERO_STRUCT(req->out);
+        return subreq;
+}
 /*
 …
 void smbcli_transport_send(struct smbcli_request *req)
+{
         DATA_BLOB blob;
+        struct smbcli_transport *transport = req->transport;
         NTSTATUS status;
+        /* check if the transport is dead */
+        if (req->transport->socket->sock == NULL) {
+        bool need_pending_break = false;
+        struct tevent_req *subreq = NULL;
+        size_t i;
+        size_t num_subreqs = 0;
+        if (transport->oplock.handler) {
+                need_pending_break = true;
+        }
+        if (transport->break_subreq) {
+                need_pending_break = false;
+        }
+        if (need_pending_break) {
+                subreq = smb1cli_req_create(transport,
+                                            transport->ev,
+                                            transport->conn,
+, /* smb_command */
+, /* additional_flags */
+, /* clear_flags */
+, /* additional_flags2 */
+, /* clear_flags2 */
+, /* timeout_msec */
+, /* pid */
+                                            NULL, /* tcon */
+                                            NULL, /* session */
+, /* wct */
+                                            NULL, /* vwv */
+, /* iov_count */
+                                            NULL); /* bytes_iov */
+                if (subreq != NULL) {
+                        smb1cli_req_set_mid(subreq, 0xFFFF);
+                        smbXcli_req_set_pending(subreq);
+                        tevent_req_set_callback(subreq,
+                                                smbcli_transport_break_handler,
+                                                transport);
+                        transport->break_subreq = subreq;
+                        subreq = NULL;
+                }
+        }
+        subreq = smbcli_transport_setup_subreq(req);
+        if (subreq == NULL) {
                 req->state = SMBCLI_REQUEST_ERROR;
                 req->status = NT_STATUS_NET_WRITE_FAULT;
+                req->status = NT_STATUS_NO_MEMORY;
                 return;
+        }
+        blob = data_blob_const(req->out.buffer, req->out.size);
+        status = packet_send(req->transport->packet, blob);
+        for (i = 0; i < ARRAY_SIZE(req->subreqs); i++) {
+                if (req->subreqs[i] == NULL) {
+                        req->subreqs[i] = subreq;
+                        subreq = NULL;
+                }
+                if (req->subreqs[i] == NULL) {
+                        break;
+                }
+                if (!tevent_req_is_in_progress(req->subreqs[i])) {
+                        req->state = SMBCLI_REQUEST_ERROR;
+                        req->status = NT_STATUS_INTERNAL_ERROR;
+                        return;
+                }
+        }
+        num_subreqs = i;
+        req->state = SMBCLI_REQUEST_RECV;
+        tevent_req_set_callback(req->subreqs[0], smbcli_request_done, req);
+        status = smb1cli_req_chain_submit(req->subreqs, num_subreqs);
         if (!NT_STATUS_IS_OK(status)) {
+                req->status = status;
                 req->state = SMBCLI_REQUEST_ERROR;
+                req->status = status;
+                smbXcli_conn_disconnect(transport->conn, status);
+        }
+}
+static void smbcli_request_done(struct tevent_req *subreq)
+{
+        struct smbcli_request *req =
+                tevent_req_callback_data(subreq,
+                struct smbcli_request);
+        struct smbcli_transport *transport = req->transport;
+        ssize_t len;
+        size_t i;
+        uint8_t *hdr = NULL;
+        uint8_t wct = 0;
+        uint16_t *vwv = NULL;
+        uint32_t num_bytes = 0;
+        uint8_t *bytes = NULL;
+        struct iovec *recv_iov = NULL;
+        uint8_t *inbuf = NULL;
+        req->status = smb1cli_req_recv(req->subreqs[0], req,
+                                       &recv_iov,
+                                       &hdr,
+                                       &wct,
+                                       &vwv,
+                                       NULL, /* pvwv_offset */
+                                       &num_bytes,
+                                       &bytes,
+                                       NULL, /* pbytes_offset */
+                                       &inbuf,
+                                       NULL, 0); /* expected */
+        TALLOC_FREE(req->subreqs[0]);
+        if (!NT_STATUS_IS_OK(req->status)) {
+                if (recv_iov == NULL) {
+                        req->state = SMBCLI_REQUEST_ERROR;
+                        transport->error.e.nt_status = req->status;
+                        transport->error.etype = ETYPE_SOCKET;
+                        if (req->async.fn) {
+                                req->async.fn(req);
+                        }
+                        return;
+                }
+        }
+        /*
+         * For SMBreadBraw hdr is NULL
+         */
+        len = recv_iov[0].iov_len;
+        for (i=1; hdr != NULL && i < 3; i++) {
+                uint8_t *p = recv_iov[i-1].iov_base;
+                uint8_t *c1 = recv_iov[i].iov_base;
+                uint8_t *c2 = p + recv_iov[i-1].iov_len;
+                len += recv_iov[i].iov_len;
+                c2 += i;
+                len += i;
+                if (recv_iov[i].iov_len == 0) {
+                        continue;
+                }
+                if (c1 != c2) {
+                        req->state = SMBCLI_REQUEST_ERROR;
+                        req->status = NT_STATUS_INTERNAL_ERROR;
+                        transport->error.e.nt_status = req->status;
+                        transport->error.etype = ETYPE_SMB;
+                        if (req->async.fn) {
+                                req->async.fn(req);
+                        }
+                        return;
+                }
+        }
+        /* fill in the 'in' portion of the matching request */
+        req->in.buffer = inbuf;
+        req->in.size = NBT_HDR_SIZE + len;
+        req->in.allocated = req->in.size;
+        req->in.hdr = hdr;
+        req->in.vwv = (uint8_t *)vwv;
+        req->in.wct = wct;
+        req->in.data = bytes;
+        req->in.data_size = num_bytes;
+        req->in.ptr = req->in.data;
+        if (hdr != NULL) {
+                req->flags2 = SVAL(req->in.hdr, HDR_FLG2);
+        }
+        smb_setup_bufinfo(req);
+        transport->error.e.nt_status = req->status;
+        if (NT_STATUS_IS_OK(req->status)) {
+                transport->error.etype = ETYPE_NONE;
+        } else {
+                transport->error.etype = ETYPE_SMB;
+        }
+        req->state = SMBCLI_REQUEST_DONE;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+static void smbcli_transport_break_handler(struct tevent_req *subreq)
+{
+        struct smbcli_transport *transport =
+                tevent_req_callback_data(subreq,
+                struct smbcli_transport);
+        NTSTATUS status;
+        struct iovec *recv_iov = NULL;
+        uint8_t *hdr = NULL;
+        uint16_t *vwv = NULL;
+        const struct smb1cli_req_expected_response expected[] = {
+        {
+                .status = NT_STATUS_OK,
+                .wct = 8,
+        }
+        };
+        uint16_t tid;
+        uint16_t fnum;
+        uint8_t level;
+        transport->break_subreq = NULL;
+        status = smb1cli_req_recv(subreq, transport,
+                                  &recv_iov,
+                                  &hdr,
+                                  NULL, /* pwct */
+                                  &vwv,
+                                  NULL, /* pvwv_offset */
+                                  NULL, /* pnum_bytes */
+                                  NULL, /* pbytes */
+                                  NULL, /* pbytes_offset */
+                                  NULL, /* pinbuf */
+                                  expected,
+                                  ARRAY_SIZE(expected));
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(recv_iov);
+                smbcli_transport_dead(transport, status);
                 return;
+        }
+        packet_queue_run(req->transport->packet);
+        if (req->transport->socket->sock == NULL) {
+                req->state = SMBCLI_REQUEST_ERROR;
+                req->status = NT_STATUS_NET_WRITE_FAULT;
+                return;
+        }
+        if (req->one_way_request) {
+                req->state = SMBCLI_REQUEST_DONE;
+                smbcli_request_destroy(req);
+                return;
+        }
+        req->state = SMBCLI_REQUEST_RECV;
+        DLIST_ADD(req->transport->pending_recv, req);
+        /* add a timeout */
+        if (req->transport->options.request_timeout) {
+                event_add_timed(req->transport->socket->event.ctx, req,
+                                timeval_current_ofs(req->transport->options.request_timeout, 0),
+                                smbcli_timeout_handler, req);
+        }
+        talloc_set_destructor(req, smbcli_request_destructor);
+        /*
+         * Setup the subreq to handle the
+         * next incoming SMB2 Break.
+         */
+        subreq = smb1cli_req_create(transport,
+                                    transport->ev,
+                                    transport->conn,
+, /* smb_command */
+, /* additional_flags */
+, /* clear_flags */
+, /* additional_flags2 */
+, /* clear_flags2 */
+, /* timeout_msec */
+, /* pid */
+                                    NULL, /* tcon */
+                                    NULL, /* session */
+, /* wct */
+                                    NULL, /* vwv */
+, /* iov_count */
+                                    NULL); /* bytes_iov */
+        if (subreq != NULL) {
+                smb1cli_req_set_mid(subreq, 0xFFFF);
+                smbXcli_req_set_pending(subreq);
+                tevent_req_set_callback(subreq,
+                                        smbcli_transport_break_handler,
+                                        transport);
+                transport->break_subreq = subreq;
+        }
+        tid = SVAL(hdr, HDR_TID);
+        fnum = SVAL(vwv+2, 0);
+        level = CVAL(vwv+3, 1);
+        TALLOC_FREE(recv_iov);
+        if (transport->oplock.handler) {
+                transport->oplock.handler(transport, tid, fnum, level,
+                                          transport->oplock.private_data);
+        } else {
+                DEBUG(5,("Got SMB oplock break with no handler\n"));
+        }
+}

vendor/current/source4/libcli/raw/clitree.c

-              r740
+              r988
 #include "libcli/raw/raw_proto.h"
 #include "libcli/smb_composite/smb_composite.h"
+#include "../libcli/smb/smbXcli_base.h"
 #define SETUP_REQUEST_TREE(cmd, wct, buflen) do { \
 …
+        }
+        tree->smbXcli = smbXcli_tcon_create(tree);
+        if (tree->smbXcli == NULL) {
+                talloc_free(tree);
+                return NULL;
+        }
         return tree;
 …
                 ZERO_STRUCT(parms->tconx.out);
                 parms->tconx.out.tid = SVAL(req->in.hdr, HDR_TID);
+                if (req->in.wct >= 4) {
+                        parms->tconx.out.options = SVAL(req->in.vwv, VWV(3));
+                if (req->in.wct >= 3) {
+                        parms->tconx.out.options = SVAL(req->in.vwv, VWV(2));
+                }
+                if (req->in.wct >= 7) {
+                        parms->tconx.out.max_access = IVAL(req->in.vwv, VWV(3));
+                        parms->tconx.out.guest_max_access = IVAL(req->in.vwv, VWV(5));
+                }
 …
         if (!tree) return NT_STATUS_OK;
         req = smbcli_request_setup(tree, SMBtdis, 0, 0);
+        if (req == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
         if (smbcli_request_send(req)) {

vendor/current/source4/libcli/raw/interfaces.h

-              r740
+              r988
 #define __LIBCLI_RAW_INTERFACES_H__
 #include "libcli/raw/smb.h"
+#include "source4/libcli/raw/smb.h"
 #include "../libcli/smb/smb_common.h"
 #include "librpc/gen_ndr/misc.h" /* for struct GUID */
+#include "librpc/gen_ndr/smb2_lease_struct.h"
 /* this structure is just a wrapper for a string, the only reason we
 …
 };
-/*
-  SMB2 lease structure (per MS-SMB2 2.2.13)
-*/
-struct smb2_lease_key {
-        uint64_t data[2];
-};
-struct smb2_lease {
-        struct smb2_lease_key lease_key;
-        uint32_t lease_state;
-        uint32_t lease_flags; /* should be 0 */
-        uint64_t lease_duration; /* should be 0 */
-};
 struct smb2_lease_break {
         struct smb2_lease current_lease;
+        uint16_t new_epoch; /* only for v2 leases */
         uint32_t break_flags;
         uint32_t new_lease_state;
 …
                 struct {
                         uint16_t options;
+                        uint32_t max_access;
+                        uint32_t guest_max_access;
                         char *dev_type;
                         char *fs_type;
 …
         RAW_SFILEINFO_UNIX_BASIC              = SMB_SFILEINFO_UNIX_BASIC,
         RAW_SFILEINFO_UNIX_INFO2              = SMB_SFILEINFO_UNIX_INFO2,
         RAW_SFILEINFO_UNIX_LINK               = SMB_SFILEINFO_UNIX_LINK,
         RAW_SFILEINFO_UNIX_HLINK              = SMB_SFILEINFO_UNIX_HLINK,
+        RAW_SFILEINFO_UNIX_LINK               = SMB_SET_FILE_UNIX_LINK,
+        RAW_SFILEINFO_UNIX_HLINK              = SMB_SET_FILE_UNIX_HLINK,
         RAW_SFILEINFO_BASIC_INFORMATION       = SMB_SFILEINFO_BASIC_INFORMATION,
         RAW_SFILEINFO_RENAME_INFORMATION      = SMB_SFILEINFO_RENAME_INFORMATION,
 …
         } unix_link, unix_hlink;
         /* RAW_FILEINFO_SET_SEC_DESC */
+        /* RAW_SFILEINFO_SEC_DESC */
         struct {
                 enum smb_setfileinfo_level level;
 …
                    RAW_QFS_QUOTA_INFORMATION              = SMB_QFS_QUOTA_INFORMATION,
                    RAW_QFS_FULL_SIZE_INFORMATION          = SMB_QFS_FULL_SIZE_INFORMATION,
+                   RAW_QFS_OBJECTID_INFORMATION           = SMB_QFS_OBJECTID_INFORMATION};
+                   RAW_QFS_OBJECTID_INFORMATION           = SMB_QFS_OBJECTID_INFORMATION,
+                   RAW_QFS_SECTOR_SIZE_INFORMATION        = SMB_QFS_SECTOR_SIZE_INFORMATION,
+};
 …
                 } out;
         } objectid_information;
+};
+        /* trans2 RAW_QFS_SECTOR_SIZE_INFORMATION interface */
+        struct {
+                enum smb_fsinfo_level level;
+                struct smb2_handle handle; /* only for smb2 */
+                struct {
+                        uint32_t logical_bytes_per_sector;
+                        uint32_t phys_bytes_per_sector_atomic;
+                        uint32_t phys_bytes_per_sector_perf;
+                        uint32_t fs_effective_phys_bytes_per_sector_atomic;
+                        uint32_t flags;
+                        uint32_t byte_off_sector_align;
+                        uint32_t byte_off_partition_align;
+                } out;
+        } sector_size_info;
+};
+enum smb_setfsinfo_level {
+                RAW_SETFS_UNIX_INFO                      = SMB_SET_CIFS_UNIX_INFO};
+union smb_setfsinfo {
+        /* generic interface */
+        struct {
+                enum smb_setfsinfo_level level;
+        } generic;
+        /* TRANS2 RAW_QFS_UNIX_INFO interface */
+        struct {
+                enum smb_setfsinfo_level level;
+                struct {
+                        uint16_t major_version;
+                        uint16_t minor_version;
+                        uint64_t capability;
+                } in;
+        } unix_info;
+};
 enum smb_open_level {
 …
                         bool   durable_open;
                         struct smb2_handle *durable_handle;
+                        /* data for durable handle v2 */
+                        bool durable_open_v2;
+                        struct GUID create_guid;
+                        bool persistent_open;
+                        uint32_t timeout;
+                        struct smb2_handle *durable_handle_v2;
                         bool   query_maximal_access;
                         NTTIME timewarp;
                         bool   query_on_disk_id;
                         struct smb2_lease *lease_request;
+                        struct smb2_lease *lease_request_v2;
+                        struct GUID *app_instance_id;
                         /* and any additional blobs the caller wants */
                         struct smb2_create_blobs blobs;
 …
                         uint8_t on_disk_id[32];
                         struct smb2_lease lease_response;
+                        struct smb2_lease lease_response_v2;
+                        bool durable_open;
+                        /* durable handle v2 */
+                        bool durable_open_v2;
+                        bool persistent_open;
+                        uint32_t timeout;
                         /* tagged blobs in the reply */
 …
                         uint16_t compaction_mode;
                         uint32_t nread;
+                        uint16_t flags2;
+                        uint16_t data_offset;
                 } out;
         } readx, generic;
 …
                 uint32_t  ea_size;
                 uint64_t file_id;
+                uint8_t short_name_buf[24];
                 struct smb_wire_string short_name;
                 struct smb_wire_string name;

vendor/current/source4/libcli/raw/libcliraw.h

-              r740
+              r988
 #define __LIBCLI_RAW_H__
+#include "../libcli/smb/smb_common.h"
 #include "libcli/raw/request.h"
 #include "librpc/gen_ndr/nbt.h"
+#include "libcli/raw/interfaces.h"
 struct smbcli_tree;  /* forward declare */
 …
         uint8_t sec_mode;               /* security mode returned by negprot */
-        uint8_t key_len;
-        DATA_BLOB server_guid;      /* server_guid */
         DATA_BLOB secblob;      /* cryptkey or negTokenInit blob */
         uint32_t sesskey;
-        struct smb_signing_context sign_info;
         /* capabilities that the server reported */
 …
         int server_zone;
         time_t server_time;
         unsigned int readbraw_supported:1;
         unsigned int writebraw_supported:1;
         unsigned int lockread_supported:1;
-        char *server_domain;
 };
 …
         unsigned int unicode:1;
         unsigned int ntstatus_support:1;
+        int min_protocol;
         int max_protocol;
         uint32_t max_xmit;
         uint16_t max_mux;
         int request_timeout;
+        enum smb_signing_state signing;
+        enum smb_signing_setting signing;
+        uint32_t smb2_capabilities;
+        struct GUID client_guid;
 };
 /* this is the context for the client transport layer */
 struct smbcli_transport {
+        /* socket level info */
+        struct smbcli_socket *socket;
+        /* the next mid to be allocated - needed for signing and
+           request matching */
+        uint16_t next_mid;
+        struct tevent_context *ev; /* TODO: remove this !!! */
+        struct smbXcli_conn *conn;
         /* negotiated protocol information */
         struct smbcli_negotiate negotiate;
 …
         struct smbcli_options options;
-        /* is a readbraw pending? we need to handle that case
-           specially on receiving packets */
-        unsigned int readbraw_pending:1;
         /* an idle function - if this is defined then it will be
            called once every period microseconds while we are waiting
 …
                 void *private_data;
                 unsigned int period;
+                struct tevent_timer *te;
         } idle;
 …
                 void *private_data;
         } oplock;
+        /* a list of async requests that are pending for receive on this connection */
+        struct smbcli_request *pending_recv;
+        /* remember the called name - some sub-protocols require us to
+           know the server name */
+        struct nbt_name called;
+        /* context of the stream -> packet parser */
+        struct packet_context *packet;
+        struct tevent_req *break_subreq;
 };
 …
         /* after a session setup the server provides us with
            a vuid identifying the security context */
+        struct smbXcli_session *smbXcli;
         uint16_t vuid;
 …
            the user to control these for torture testing */
         uint16_t flags2;
-        DATA_BLOB user_session_key;
         /* the spnego context if we use extented security */
 …
         struct smbcli_session *session;
+        struct smbXcli_tcon *smbXcli;
         uint16_t tid;                   /* tree id, aka cnum */
         char *device;
 …
  * This will allow requests to be multi-threaded. */
 struct smbcli_request {
         /* allow a request to be part of a list of requests */
         struct smbcli_request *next, *prev;
+        /* smbXcli_req */
+        struct tevent_req *subreqs[2];
         /* each request is in one of 4 possible states */
 …
         struct smbcli_tree *tree;
-        /* a receive helper, smbcli_transport_finish_recv will not call
-           req->async.fn callback handler unless the recv_helper returns
-           a value > SMBCLI_REQUEST_RECV. */
-        struct {
-                enum smbcli_request_state (*fn)(struct smbcli_request *);
-                void *private_data;
-        } recv_helper;
         /* the flags2 from the SMB request, in raw form (host byte
            order). Used to parse strings */
 …
            or code detecting error. */
         NTSTATUS status;
-        /* the sequence number of this packet - used for signing */
-        unsigned int seq_num;
-        /* list of ntcancel request for this requests */
-        struct smbcli_request *ntcancel;
-        /* set if this is a one-way request, meaning we are not
-           expecting a reply from the server. */
-        unsigned int one_way_request:1;
-        /* set this when the request should only increment the signing
-           counter by one */
-        unsigned int sign_single_increment:1;
         /* the caller wants to do the signing check */
 …
         bool do_not_free;
-        /* the mid of this packet - used to match replies */
-        uint16_t mid;
         struct smb_request_buffer in;
         struct smb_request_buffer out;
+        struct smb_trans2 trans2;
+        struct smb_nttrans nttrans;
         /* information on what to do with a reply when it is received
 …
       goto failed; \
+}
-#include "libcli/raw/interfaces.h"
 NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms);
 …
 NTSTATUS smbcli_request_destroy(struct smbcli_request *req);
 struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms);
+NTSTATUS smb_raw_write_recv(struct smbcli_request *req, union smb_write *parms);
 struct smbcli_request *smb_raw_close_send(struct smbcli_tree *tree, union smb_close *parms);
 NTSTATUS smb_raw_open_recv(struct smbcli_request *req, TALLOC_CTX *mem_ctx, union smb_open *parms);
 …
 const char *smbcli_errstr(struct smbcli_tree *tree);
 NTSTATUS smb_raw_fsinfo(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, union smb_fsinfo *fsinfo);
+NTSTATUS smb_raw_setfsinfo(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, union smb_setfsinfo *set_fsinfo);
 NTSTATUS smb_raw_pathinfo(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, union smb_fileinfo *parms);
 NTSTATUS smb_raw_shadow_data(struct smbcli_tree *tree, TALLOC_CTX *mem_ctx, struct smb_shadow_copy *info);
 …
                        struct smb_trans2 *parms);
-struct smbcli_socket *smbcli_sock_connect_byname(const char *host, const char **ports,
-                                                 TALLOC_CTX *mem_ctx,
-                                                 struct resolve_context *resolve_ctx,
-                                                 struct tevent_context *event_ctx,
-                                                 const char *socket_options);
-void smbcli_sock_dead(struct smbcli_socket *sock);
 #endif /* __LIBCLI_RAW__H__ */

vendor/current/source4/libcli/raw/raweas.c

-              r740
+              r988
+                }
+                if (ofs + next_ofs < ofs) {
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
                 ofs += next_ofs;
+                if (ofs+4 > blob->length) {
+                if (ofs+4 > blob->length || ofs+4 < ofs) {
                         return NT_STATUS_INVALID_PARAMETER;
+                }

vendor/current/source4/libcli/raw/rawfile.c

-              r740
+              r988
         if (!req) return NULL; \
 } while (0)
-/**
- Return a string representing a CIFS attribute for a file.
-**/
-char *attrib_string(TALLOC_CTX *mem_ctx, uint32_t attrib)
+{
-        int i, len;
-        const struct {
-                char c;
-                uint16_t attr;
-        } attr_strs[] = {
-                {'V', FILE_ATTRIBUTE_VOLUME},
-                {'D', FILE_ATTRIBUTE_DIRECTORY},
-                {'A', FILE_ATTRIBUTE_ARCHIVE},
-                {'H', FILE_ATTRIBUTE_HIDDEN},
-                {'S', FILE_ATTRIBUTE_SYSTEM},
-                {'N', FILE_ATTRIBUTE_NORMAL},
-                {'R', FILE_ATTRIBUTE_READONLY},
-                {'d', FILE_ATTRIBUTE_DEVICE},
-                {'t', FILE_ATTRIBUTE_TEMPORARY},
-                {'s', FILE_ATTRIBUTE_SPARSE},
-                {'r', FILE_ATTRIBUTE_REPARSE_POINT},
-                {'c', FILE_ATTRIBUTE_COMPRESSED},
-                {'o', FILE_ATTRIBUTE_OFFLINE},
-                {'n', FILE_ATTRIBUTE_NONINDEXED},
-                {'e', FILE_ATTRIBUTE_ENCRYPTED}
-        };
-        char *ret;
-        ret = talloc_array(mem_ctx, char, ARRAY_SIZE(attr_strs)+1);
-        if (!ret) {
-                return NULL;
+        }
-        for (len=i=0; i<ARRAY_SIZE(attr_strs); i++) {
-                if (attrib & attr_strs[i].attr) {
-                        ret[len++] = attr_strs[i].c;
+                }
+        }
-        ret[len] = 0;
-        talloc_set_name_const(ret, ret);
-        return ret;
+}
 /****************************************************************************
 …
+        }
         case RAW_LOCK_SMB2:
+        case RAW_LOCK_SMB2_BREAK:
                 return NULL;
+        }
 …
         struct smbcli_request *req;
         SETUP_REQUEST(SMBchkpth, 0, 0);
+        SETUP_REQUEST(SMBcheckpath, 0, 0);
         smbcli_req_append_ascii4(req, parms->chkpath.in.path, STR_TERMINATE);

vendor/current/source4/libcli/raw/rawfileinfo.c

-              r740
+              r988
                 bool ret;
                 void *vstr;
+                size_t converted_size = 0;
                 io->streams =
                         talloc_realloc(mem_ctx, io->streams, struct stream_struct, n+1);
 …
                 ret = convert_string_talloc(io->streams,
                                              CH_UTF16, CH_UNIX,
                                              blob.data+ofs+24, nlen, &vstr, NULL, false);
+                                             blob.data+ofs+24, nlen, &vstr, &converted_size);
                 if (!ret) {
                         return NT_STATUS_ILLEGAL_CHARACTER;

vendor/current/source4/libcli/raw/rawfsinfo.c

-              r740
+              r988
         req = smbcli_request_setup(tree, SMBdskattr, 0, 0);
+        if (req == NULL) {
+                return NULL;
+        }
         if (!smbcli_request_send(req)) {
 …
+                }
                 break;
+        case RAW_QFS_SECTOR_SIZE_INFORMATION:
+                QFS_CHECK_SIZE(28);
+                fsinfo->sector_size_info.out.logical_bytes_per_sector
+                                                        = IVAL(blob.data,  0);
+                fsinfo->sector_size_info.out.phys_bytes_per_sector_atomic
+                                                        = IVAL(blob.data,  4);
+                fsinfo->sector_size_info.out.phys_bytes_per_sector_perf
+                                                        = IVAL(blob.data,  8);
+                fsinfo->sector_size_info.out.fs_effective_phys_bytes_per_sector_atomic
+                                                        = IVAL(blob.data, 12);
+                fsinfo->sector_size_info.out.flags      = IVAL(blob.data, 16);
+                fsinfo->sector_size_info.out.byte_off_sector_align
+                                                        = IVAL(blob.data, 20);
+                fsinfo->sector_size_info.out.byte_off_partition_align
+                                                        = IVAL(blob.data, 24);
+                break;
+        }
 …
                 return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
                                                      RAW_QFS_OBJECTID_INFORMATION, fsinfo);
+        case RAW_QFS_SECTOR_SIZE_INFORMATION:
+                return smb_raw_fsinfo_passthru_parse(blob, mem_ctx,
+                                RAW_QFS_SECTOR_SIZE_INFORMATION, fsinfo);
+        }
 …
         return smb_raw_fsinfo_recv(req, mem_ctx, fsinfo);
+}
+/****************************************************************************
+ Set FSInfo raw interface (async recv)
+****************************************************************************/
+static NTSTATUS smb_raw_setfsinfo_recv(struct smbcli_request *req,
+                             TALLOC_CTX *mem_ctx,
+                             union smb_setfsinfo *set_fsinfo)
+{
+        DATA_BLOB blob = data_blob_null;
+        NTSTATUS status;
+        if (set_fsinfo->generic.level != RAW_SETFS_UNIX_INFO) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        status = smb_raw_qfsinfo_blob_recv(req, mem_ctx, &blob);
+        data_blob_free(&blob);
+        return status;
+}
+/****************************************************************************
+ Set FSInfo raw interface (async send)
+****************************************************************************/
+static struct smbcli_request *smb_raw_setfsinfo_send(struct smbcli_tree *tree,
+                                                TALLOC_CTX *mem_ctx,
+                                                union smb_setfsinfo *set_fsinfo)
+{
+        struct smb_trans2 tp;
+        uint16_t info_level;
+        uint16_t setup = TRANSACT2_SETFSINFO;
+        if (set_fsinfo->generic.level != RAW_SETFS_UNIX_INFO) {
+                return NULL;
+        }
+        tp.in.max_setup = 0;
+        tp.in.flags = 0;
+        tp.in.timeout = 0;
+        tp.in.setup_count = 1;
+        tp.in.max_param = 0;
+        tp.in.max_data = 0xFFFF;
+        tp.in.setup = &setup;
+        tp.in.timeout = 0;
+        tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
+        if (!tp.in.params.data) {
+                return NULL;
+        }
+        info_level = (uint16_t)set_fsinfo->generic.level;
+        SSVAL(tp.in.params.data, 0, 0);
+        SSVAL(tp.in.params.data, 2, info_level);
+        tp.in.data = data_blob_talloc(mem_ctx, NULL, 12);
+        if (!tp.in.data.data) {
+                return NULL;
+        }
+        SSVAL(tp.in.data.data, 0, set_fsinfo->unix_info.in.major_version);
+        SSVAL(tp.in.data.data, 2, set_fsinfo->unix_info.in.minor_version);
+        SBVAL(tp.in.data.data, 4, set_fsinfo->unix_info.in.capability);
+        return smb_raw_trans2_send(tree, &tp);
+}
+/****************************************************************************
+ Set FSInfo raw interface (sync interface)
+****************************************************************************/
+_PUBLIC_ NTSTATUS smb_raw_setfsinfo(struct smbcli_tree *tree,
+                        TALLOC_CTX *mem_ctx,
+                        union smb_setfsinfo *set_fsinfo)
+{
+        struct smbcli_request *req = smb_raw_setfsinfo_send(tree, mem_ctx, set_fsinfo);
+        return smb_raw_setfsinfo_recv(req, mem_ctx, set_fsinfo);
+}

vendor/current/source4/libcli/raw/rawnegotiate.c

-              r740
+              r988
 #include "includes.h"
+#include <tevent.h>
+#include "system/time.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
+#include "system/time.h"
+#include "../libcli/smb/smbXcli_base.h"
+#include "../lib/util/tevent_ntstatus.h"
+static const struct {
+        enum protocol_types prot;
+        const char *name;
+} prots[] = {
+        {PROTOCOL_CORE,"PC NETWORK PROGRAM 1.0"},
+        {PROTOCOL_COREPLUS,"MICROSOFT NETWORKS 1.03"},
+        {PROTOCOL_LANMAN1,"MICROSOFT NETWORKS 3.0"},
+        {PROTOCOL_LANMAN1,"LANMAN1.0"},
+        {PROTOCOL_LANMAN1,"Windows for Workgroups 3.1a"},
+        {PROTOCOL_LANMAN2,"LM1.2X002"},
+        {PROTOCOL_LANMAN2,"DOS LANMAN2.1"},
+        {PROTOCOL_LANMAN2,"LANMAN2.1"},
+        {PROTOCOL_LANMAN2,"Samba"},
+        {PROTOCOL_NT1,"NT LANMAN 1.0"},
+        {PROTOCOL_NT1,"NT LM 0.12"},
+#if 0
+        /* we don't yet handle chaining a SMB transport onto SMB2 */
+        {PROTOCOL_SMB2,"SMB 2.002"},
+#endif
+struct smb_raw_negotiate_state {
+        struct smbcli_transport *transport;
 };
+/*
+  Send a negprot command.
+*/
+struct smbcli_request *smb_raw_negotiate_send(struct smbcli_transport *transport,
+                                              bool unicode,
+                                              int maxprotocol)
+static void smb_raw_negotiate_done(struct tevent_req *subreq);
+struct tevent_req *smb_raw_negotiate_send(TALLOC_CTX *mem_ctx,
+                                          struct tevent_context *ev,
+                                          struct smbcli_transport *transport,
+                                          int minprotocol,
+                                          int maxprotocol)
+{
+        struct smbcli_request *req;
+        int i;
+        uint16_t flags2 = 0;
+        struct tevent_req *req;
+        struct smb_raw_negotiate_state *state;
+        struct tevent_req *subreq;
+        uint32_t timeout_msec = transport->options.request_timeout * 1000;
+        req = smbcli_request_setup_transport(transport, SMBnegprot, 0, 0);
+        if (!req) {
+        req = tevent_req_create(mem_ctx, &state,
+                                struct smb_raw_negotiate_state);;
+        if (req == NULL) {
                 return NULL;
+        }
+        state->transport = transport;
+        flags2 |= FLAGS2_32_BIT_ERROR_CODES;
+        if (unicode) {
+                flags2 |= FLAGS2_UNICODE_STRINGS;
+        }
+        flags2 |= FLAGS2_EXTENDED_ATTRIBUTES;
+        flags2 |= FLAGS2_LONG_PATH_COMPONENTS;
+        flags2 |= FLAGS2_IS_LONG_NAME;
+        if (transport->options.use_spnego) {
+                flags2 |= FLAGS2_EXTENDED_SECURITY;
+        if (maxprotocol > PROTOCOL_NT1) {
+                maxprotocol = PROTOCOL_NT1;
+        }
+        SSVAL(req->out.hdr,HDR_FLG2, flags2);
+        subreq = smbXcli_negprot_send(state, ev,
+                                      transport->conn,
+                                      timeout_msec,
+                                      minprotocol,
+                                      maxprotocol);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, smb_raw_negotiate_done, req);
+        /* setup the protocol strings */
+        for (i=0; i < ARRAY_SIZE(prots) && prots[i].prot <= maxprotocol; i++) {
+                smbcli_req_append_bytes(req, (const uint8_t *)"\2", 1);
+                smbcli_req_append_string(req, prots[i].name, STR_TERMINATE | STR_ASCII);
+        return req;
+}
+static void smb_raw_negotiate_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        struct smb_raw_negotiate_state *state =
+                tevent_req_data(req,
+                struct smb_raw_negotiate_state);
+        struct smbcli_negotiate *n = &state->transport->negotiate;
+        struct smbXcli_conn *c = state->transport->conn;
+        NTSTATUS status;
+        NTTIME ntt;
+        status = smbXcli_negprot_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        if (!smbcli_request_send(req)) {
+                smbcli_request_destroy(req);
+                return NULL;
+        n->protocol = smbXcli_conn_protocol(c);
+        n->sec_mode = smb1cli_conn_server_security_mode(c);
+        n->max_mux  = smbXcli_conn_max_requests(c);
+        n->max_xmit = smb1cli_conn_max_xmit(c);
+        n->sesskey  = smb1cli_conn_server_session_key(c);
+        n->capabilities = smb1cli_conn_capabilities(c);;
+        /* this time arrives in real GMT */
+        ntt = smbXcli_conn_server_system_time(c);
+        n->server_time = nt_time_to_unix(ntt);
+        n->server_zone = smb1cli_conn_server_time_zone(c);
+        if (n->capabilities & CAP_EXTENDED_SECURITY) {
+                const DATA_BLOB *b = smbXcli_conn_server_gss_blob(c);
+                if (b) {
+                        n->secblob = *b;
+                }
+        } else {
+                const uint8_t *p = smb1cli_conn_server_challenge(c);
+                if (p) {
+                        n->secblob = data_blob_const(p, 8);
+                }
+        }
+        return req;
+        n->readbraw_supported = smb1cli_conn_server_readbraw(c);
+        n->readbraw_supported = smb1cli_conn_server_writebraw(c);
+        n->lockread_supported = smb1cli_conn_server_lockread(c);
+        tevent_req_done(req);
+}
 …
  Send a negprot command.
 */
 NTSTATUS smb_raw_negotiate_recv(struct smbcli_request *req)
+NTSTATUS smb_raw_negotiate_recv(struct tevent_req *req)
+{
+        struct smbcli_transport *transport = req->transport;
+        int protocol;
+        if (!smbcli_request_receive(req) ||
+            smbcli_request_is_error(req)) {
+                return smbcli_request_destroy(req);
+        }
+        SMBCLI_CHECK_MIN_WCT(req, 1);
+        protocol = SVALS(req->in.vwv, VWV(0));
+        if (protocol >= ARRAY_SIZE(prots) || protocol < 0) {
+                req->status = NT_STATUS_UNSUCCESSFUL;
+                return smbcli_request_destroy(req);
+        }
+        transport->negotiate.protocol = prots[protocol].prot;
+        if (transport->negotiate.protocol >= PROTOCOL_NT1) {
+                NTTIME ntt;
+                /* NT protocol */
+                SMBCLI_CHECK_WCT(req, 17);
+                transport->negotiate.sec_mode = CVAL(req->in.vwv,VWV(1));
+                transport->negotiate.max_mux  = SVAL(req->in.vwv,VWV(1)+1);
+                transport->negotiate.max_xmit = IVAL(req->in.vwv,VWV(3)+1);
+                transport->negotiate.sesskey  = IVAL(req->in.vwv,VWV(7)+1);
+                transport->negotiate.capabilities = IVAL(req->in.vwv,VWV(9)+1);
+                /* this time arrives in real GMT */
+                ntt = smbcli_pull_nttime(req->in.vwv, VWV(11)+1);
+                transport->negotiate.server_time = nt_time_to_unix(ntt);
+                transport->negotiate.server_zone = SVALS(req->in.vwv,VWV(15)+1) * 60;
+                transport->negotiate.key_len = CVAL(req->in.vwv,VWV(16)+1);
+                if (transport->negotiate.capabilities & CAP_EXTENDED_SECURITY) {
+                        if (req->in.data_size < 16) {
+                                goto failed;
+                        }
+                        transport->negotiate.server_guid = smbcli_req_pull_blob(&req->in.bufinfo, transport, req->in.data, 16);
+                        transport->negotiate.secblob = smbcli_req_pull_blob(&req->in.bufinfo, transport, req->in.data + 16, req->in.data_size - 16);
+                } else {
+                        if (req->in.data_size < (transport->negotiate.key_len)) {
+                                goto failed;
+                        }
+                        transport->negotiate.secblob = smbcli_req_pull_blob(&req->in.bufinfo, transport, req->in.data, transport->negotiate.key_len);
+                        smbcli_req_pull_string(&req->in.bufinfo, transport, &transport->negotiate.server_domain,
+                                            req->in.data+transport->negotiate.key_len,
+                                            req->in.data_size-transport->negotiate.key_len, STR_UNICODE|STR_NOALIGN);
+                        /* here comes the server name */
+                }
+                if (transport->negotiate.capabilities & CAP_RAW_MODE) {
+                        transport->negotiate.readbraw_supported = true;
+                        transport->negotiate.writebraw_supported = true;
+                }
+                if (transport->negotiate.capabilities & CAP_LOCK_AND_READ)
+                        transport->negotiate.lockread_supported = true;
+        } else if (transport->negotiate.protocol >= PROTOCOL_LANMAN1) {
+                SMBCLI_CHECK_WCT(req, 13);
+                transport->negotiate.sec_mode = SVAL(req->in.vwv,VWV(1));
+                transport->negotiate.max_xmit = SVAL(req->in.vwv,VWV(2));
+                transport->negotiate.sesskey =  IVAL(req->in.vwv,VWV(6));
+                transport->negotiate.server_zone = SVALS(req->in.vwv,VWV(10)) * 60;
+                /* this time is converted to GMT by raw_pull_dos_date */
+                transport->negotiate.server_time = raw_pull_dos_date(transport,
+                                                                     req->in.vwv+VWV(8));
+                if ((SVAL(req->in.vwv,VWV(5)) & 0x1)) {
+                        transport->negotiate.readbraw_supported = 1;
+                }
+                if ((SVAL(req->in.vwv,VWV(5)) & 0x2)) {
+                        transport->negotiate.writebraw_supported = 1;
+                }
+                transport->negotiate.secblob = smbcli_req_pull_blob(&req->in.bufinfo, transport,
+                                                                 req->in.data, req->in.data_size);
+        } else {
+                /* the old core protocol */
+                transport->negotiate.sec_mode = 0;
+                transport->negotiate.server_time = time(NULL);
+                transport->negotiate.max_xmit = transport->options.max_xmit;
+                transport->negotiate.server_zone = get_time_zone(transport->negotiate.server_time);
+        }
+        /* a way to force ascii SMB */
+        if (!transport->options.unicode) {
+                transport->negotiate.capabilities &= ~CAP_UNICODE;
+        }
+        if (!transport->options.ntstatus_support) {
+                transport->negotiate.capabilities &= ~CAP_STATUS32;
+        }
+        if (!transport->options.use_level2_oplocks) {
+                transport->negotiate.capabilities &= ~CAP_LEVEL_II_OPLOCKS;
+        }
+failed:
+        return smbcli_request_destroy(req);
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
  Send a negprot command (sync interface)
 */
+NTSTATUS smb_raw_negotiate(struct smbcli_transport *transport, bool unicode, int maxprotocol)
+NTSTATUS smb_raw_negotiate(struct smbcli_transport *transport, bool unicode,
+                           int minprotocol, int maxprotocol)
+{
+        struct smbcli_request *req = smb_raw_negotiate_send(transport, unicode, maxprotocol);
+        return smb_raw_negotiate_recv(req);
+        NTSTATUS status = NT_STATUS_INTERNAL_ERROR;
+        struct tevent_req *subreq = NULL;
+        bool ok;
+        subreq = smb_raw_negotiate_send(transport,
+                                        transport->ev,
+                                        transport,
+                                        minprotocol,
+                                        maxprotocol);
+        if (subreq == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        ok = tevent_req_poll(subreq, transport->ev);
+        if (!ok) {
+                status = map_nt_error_from_unix_common(errno);
+                goto failed;
+        }
+        status = smb_raw_negotiate_recv(subreq);
+failed:
+        TALLOC_FREE(subreq);
+        return status;
+}

vendor/current/source4/libcli/raw/rawnotify.c

-              r740
+              r988
 #include "includes.h"
+#include <tevent.h>
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
-#include "../lib/util/dlinklist.h"
 /****************************************************************************
 …
 /****************************************************************************
-  handle ntcancel replies from the server,
-  as the MID of the real reply and the ntcancel reply is the same
-  we need to do find out to what request the reply belongs
-****************************************************************************/
-struct smbcli_request *smbcli_handle_ntcancel_reply(struct smbcli_request *req,
-                                                    size_t len, const uint8_t *hdr)
+{
-        struct smbcli_request *ntcancel;
-        if (!req) return req;
-        if (!req->ntcancel) return req;
-        if (len >= MIN_SMB_SIZE + NBT_HDR_SIZE &&
-            (CVAL(hdr, HDR_FLG) & FLAG_REPLY) &&
-             CVAL(hdr,HDR_COM) == SMBntcancel) {
-                ntcancel = req->ntcancel;
-                DLIST_REMOVE(req->ntcancel, ntcancel);
-                /*
-                 * TODO: untill we understand how the
-                 *       smb_signing works for this case we
-                 *       return NULL, to just ignore the packet
-                 */
-                /*return ntcancel;*/
-                return NULL;
+        }
-        return req;
+}
-/****************************************************************************
  Send a NT Cancel request - used to hurry along a pending request. Usually
  used to cancel a pending change notify request
 …
 NTSTATUS smb_raw_ntcancel(struct smbcli_request *oldreq)
+{
         struct smbcli_request *req;
+        bool ok;
+        req = smbcli_request_setup_transport(oldreq->transport, SMBntcancel, 0, 0);
+        if (oldreq->subreqs[0] == NULL) {
+                return NT_STATUS_OK;
+        }
+        SSVAL(req->out.hdr, HDR_MID, SVAL(oldreq->out.hdr, HDR_MID));
+        SSVAL(req->out.hdr, HDR_PID, SVAL(oldreq->out.hdr, HDR_PID));
+        SSVAL(req->out.hdr, HDR_TID, SVAL(oldreq->out.hdr, HDR_TID));
+        SSVAL(req->out.hdr, HDR_UID, SVAL(oldreq->out.hdr, HDR_UID));
+        /* this request does not expect a reply, so tell the signing
+           subsystem not to allocate an id for a reply */
+        req->sign_single_increment = 1;
+        req->one_way_request = 1;
+        /*
+         * smbcli_request_send() free's oneway requests
+         * but we want to keep it under oldreq->ntcancel
+         */
+        req->do_not_free = true;
+        talloc_steal(oldreq, req);
+        smbcli_request_send(req);
+        DLIST_ADD_END(oldreq->ntcancel, req, struct smbcli_request *);
+        ok = tevent_req_cancel(oldreq->subreqs[0]);
+        if (!ok) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
         return NT_STATUS_OK;

vendor/current/source4/libcli/raw/rawreadwrite.c

-              r414
+              r988
+        }
-        /* the transport layer needs to know that a readbraw is pending
-           and handle receives a little differently */
-        if (parms->generic.level == RAW_READ_READBRAW) {
-                tree->session->transport->readbraw_pending = 1;
+        }
         return req;
+}
 …
                 parms->readx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
                 parms->readx.out.nread = SVAL(req->in.vwv, VWV(5));
+                parms->readx.out.flags2 = req->flags2;
+                parms->readx.out.data_offset = SVAL(req->in.vwv, VWV(6));
                 /* handle oversize replies for non-chained readx replies with
 …
  raw write interface (async recv)
 ****************************************************************************/
 NTSTATUS smb_raw_write_recv(struct smbcli_request *req, union smb_write *parms)
+_PUBLIC_ NTSTATUS smb_raw_write_recv(struct smbcli_request *req, union smb_write *parms)
+{
         if (!smbcli_request_receive(req) ||

vendor/current/source4/libcli/raw/rawrequest.c

-              r740
+              r988
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
-#include "../lib/util/dlinklist.h"
 #include "lib/events/events.h"
 #include "librpc/ndr/libndr.h"
 #include "librpc/gen_ndr/ndr_misc.h"
+#include "../libcli/smb/smbXcli_base.h"
 /* we over allocate the data buffer to prevent too many realloc calls */
 …
         if (!req) return NT_STATUS_UNSUCCESSFUL;
-        if (req->transport) {
-                /* remove it from the list of pending requests (a null op if
-                   its not in the list) */
-                DLIST_REMOVE(req->transport->pending_recv, req);
+        }
         if (req->state == SMBCLI_REQUEST_ERROR &&
             NT_STATUS_IS_OK(req->status)) {
 …
 /*
   low-level function to setup a request buffer for a non-SMB packet
+  at the transport level
+*/
 struct smbcli_request *smbcli_request_setup_nonsmb(struct smbcli_transport *transport, size_t size)
+  setup a SMB packet at transport level
+*/
+struct smbcli_request *smbcli_request_setup_transport(struct smbcli_transport *transport,
+                                                      uint8_t command, unsigned int wct, unsigned int buflen)
+{
         struct smbcli_request *req;
+        req = talloc(transport, struct smbcli_request);
+        size_t size;
+        size = NBT_HDR_SIZE + MIN_SMB_SIZE + wct*2 + buflen;
+        req = talloc_zero(transport, struct smbcli_request);
         if (!req) {
                 return NULL;
+        }
-        ZERO_STRUCTP(req);
         /* setup the request context */
         req->state = SMBCLI_REQUEST_INIT;
         req->transport = transport;
-        req->session = NULL;
-        req->tree = NULL;
         req->out.size = size;
 …
         req->out.allocated = req->out.size + REQ_OVER_ALLOCATION;
         req->out.buffer = talloc_array(req, uint8_t, req->out.allocated);
+        req->out.buffer = talloc_zero_array(req, uint8_t, req->out.allocated);
         if (!req->out.buffer) {
                 return NULL;
+        }
-        SIVAL(req->out.buffer, 0, 0);
-        return req;
+}
-/*
-  setup a SMB packet at transport level
-*/
-struct smbcli_request *smbcli_request_setup_transport(struct smbcli_transport *transport,
-                                                      uint8_t command, unsigned int wct, unsigned int buflen)
+{
-        struct smbcli_request *req;
-        req = smbcli_request_setup_nonsmb(transport, NBT_HDR_SIZE + MIN_SMB_SIZE + wct*2 + buflen);
-        if (!req) return NULL;
         req->out.hdr = req->out.buffer + NBT_HDR_SIZE;
         req->out.vwv = req->out.hdr + HDR_VWV;
 …
         SSVAL(req->out.hdr,HDR_FLG2, 0);
-        if (command != SMBtranss && command != SMBtranss2) {
-                /* assign a mid */
-                req->mid = smbcli_transport_next_mid(transport);
+        }
         /* copy the pid, uid and mid to the request */
         SSVAL(req->out.hdr, HDR_PID, 0);
         SSVAL(req->out.hdr, HDR_UID, 0);
         SSVAL(req->out.hdr, HDR_MID, req->mid);
+        SSVAL(req->out.hdr, HDR_MID, 0);
         SSVAL(req->out.hdr, HDR_TID,0);
         SSVAL(req->out.hdr, HDR_PIDHIGH,0);
 …
         if (!req) return NULL;
+        smb1cli_session_set_id(session->smbXcli, session->vuid);
         req->session = session;
 …
         req = smbcli_request_setup_session(tree->session, command, wct, buflen);
         if (req) {
+                smb1cli_tcon_set_id(tree->smbXcli, tree->tid);
                 req->tree = tree;
                 SSVAL(req->out.hdr,HDR_TID,tree->tid);
 …
                                       unsigned int wct, size_t buflen)
+{
+        unsigned int new_size = 1 + (wct*2) + 2 + buflen;
+        SSVAL(req->out.vwv, VWV(0), command);
+        SSVAL(req->out.vwv, VWV(1), req->out.size - NBT_HDR_SIZE);
+        smbcli_req_grow_allocation(req, req->out.data_size + new_size);
+        req->out.vwv = req->out.buffer + req->out.size + 1;
+        SCVAL(req->out.vwv, -1, wct);
+        size_t wct_ofs;
+        size_t size;
+        /*
+         * here we only support one chained command
+         * If someone needs longer chains, the low
+         * level code should be used directly.
+         */
+        if (req->subreqs[0] != NULL) {
+                return NT_STATUS_INVALID_PARAMETER_MIX;
+        }
+        if (req->subreqs[1] != NULL) {
+                return NT_STATUS_INVALID_PARAMETER_MIX;
+        }
+        req->subreqs[0] = smbcli_transport_setup_subreq(req);
+        if (req->subreqs[0] == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        wct_ofs = smb1cli_req_wct_ofs(req->subreqs, 1);
+        size = NBT_HDR_SIZE + wct_ofs + 1 + VWV(wct) + 2 + buflen;
+        req->out.size = size;
+        /* over allocate by a small amount */
+        req->out.allocated = req->out.size + REQ_OVER_ALLOCATION;
+        req->out.buffer = talloc_zero_array(req, uint8_t, req->out.allocated);
+        if (!req->out.buffer) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        req->out.hdr = req->out.buffer + NBT_HDR_SIZE;
+        req->out.vwv = req->out.hdr + wct_ofs;
+        req->out.wct = wct;
+        req->out.data = req->out.vwv + VWV(wct) + 2;
+        req->out.data_size = buflen;
+        req->out.ptr = req->out.data;
+        SCVAL(req->out.hdr, HDR_WCT, wct);
         SSVAL(req->out.vwv, VWV(wct), buflen);
+        req->out.size += new_size;
+        req->out.data_size += new_size;
+        memcpy(req->out.hdr, "\377SMB", 4);
+        SCVAL(req->out.hdr,HDR_COM,command);
+        SCVAL(req->out.hdr,HDR_FLG, FLAG_CASELESS_PATHNAMES);
+        SSVAL(req->out.hdr,HDR_FLG2, 0);
+        /* copy the pid, uid and mid to the request */
+        SSVAL(req->out.hdr, HDR_PID, 0);
+        SSVAL(req->out.hdr, HDR_UID, 0);
+        SSVAL(req->out.hdr, HDR_MID, 0);
+        SSVAL(req->out.hdr, HDR_TID,0);
+        SSVAL(req->out.hdr, HDR_PIDHIGH,0);
+        SIVAL(req->out.hdr, HDR_RCLS, 0);
+        memset(req->out.hdr+HDR_SS_FIELD, 0, 10);
+        if (req->session != NULL) {
+                SSVAL(req->out.hdr, HDR_FLG2, req->session->flags2);
+                SSVAL(req->out.hdr, HDR_PID, req->session->pid & 0xFFFF);
+                SSVAL(req->out.hdr, HDR_PIDHIGH, req->session->pid >> 16);
+                SSVAL(req->out.hdr, HDR_UID, req->session->vuid);
+        }
+        if (req->tree != NULL) {
+                SSVAL(req->out.hdr, HDR_TID, req->tree->tid);
+        }
         return NT_STATUS_OK;
 …
 /*
   aadvance to the next chained reply in a request
+  advance to the next chained reply in a request
 */
 NTSTATUS smbcli_chained_advance(struct smbcli_request *req)
+{
+        uint8_t *buffer;
+        if (CVAL(req->in.vwv, VWV(0)) == SMB_CHAIN_NONE) {
+                return NT_STATUS_NOT_FOUND;
+        }
+        buffer = req->in.hdr + SVAL(req->in.vwv, VWV(1));
+        if (buffer + 3 > req->in.buffer + req->in.size) {
+                return NT_STATUS_BUFFER_TOO_SMALL;
+        }
+        req->in.vwv = buffer + 1;
+        req->in.wct = CVAL(buffer, 0);
+        if (buffer + 3 + req->in.wct*2 > req->in.buffer + req->in.size) {
+                return NT_STATUS_BUFFER_TOO_SMALL;
+        }
+        req->in.data = req->in.vwv + 2 + req->in.wct * 2;
+        req->in.data_size = SVAL(req->in.vwv, VWV(req->in.wct));
+        /* fix the bufinfo */
+        struct smbcli_transport *transport = req->transport;
+        uint8_t *hdr = NULL;
+        uint8_t wct = 0;
+        uint16_t *vwv = NULL;
+        uint32_t num_bytes = 0;
+        uint8_t *bytes = NULL;
+        struct iovec *recv_iov = NULL;
+        uint8_t *inbuf = NULL;
+        if (req->subreqs[0] != NULL) {
+                return NT_STATUS_INVALID_PARAMETER_MIX;
+        }
+        if (req->subreqs[1] == NULL) {
+                return NT_STATUS_INVALID_PARAMETER_MIX;
+        }
+        req->status = smb1cli_req_recv(req->subreqs[1], req,
+                                       &recv_iov,
+                                       &hdr,
+                                       &wct,
+                                       &vwv,
+                                       NULL, /* pvwv_offset */
+                                       &num_bytes,
+                                       &bytes,
+                                       NULL, /* pbytes_offset */
+                                       &inbuf,
+                                       NULL, 0); /* expected */
+        TALLOC_FREE(req->subreqs[1]);
+        if (!NT_STATUS_IS_OK(req->status)) {
+                if (recv_iov == NULL) {
+                        req->state = SMBCLI_REQUEST_ERROR;
+                        return req->status;
+                }
+        }
+        /* fill in the 'in' portion of the matching request */
+        req->in.buffer = inbuf;
+        req->in.size = NBT_HDR_SIZE + PTR_DIFF(bytes, hdr) + num_bytes;
+        req->in.allocated = req->in.size;
+        req->in.hdr = hdr;
+        req->in.vwv = (uint8_t *)vwv;
+        req->in.wct = wct;
+        req->in.data = bytes;
+        req->in.data_size = num_bytes;
+        req->in.ptr = req->in.data;
+        req->flags2 = SVAL(req->in.hdr, HDR_FLG2);
         smb_setup_bufinfo(req);
+        if (buffer + 3 + req->in.wct*2 + req->in.data_size >
+            req->in.buffer + req->in.size) {
+                return NT_STATUS_BUFFER_TOO_SMALL;
+        }
+        transport->error.e.nt_status = req->status;
+        if (NT_STATUS_IS_OK(req->status)) {
+                transport->error.etype = ETYPE_NONE;
+        } else {
+                transport->error.etype = ETYPE_SMB;
+        }
+        req->state = SMBCLI_REQUEST_DONE;
         return NT_STATUS_OK;
 …
 bool smbcli_request_send(struct smbcli_request *req)
+{
-        if (IVAL(req->out.buffer, 0) == 0) {
-                _smb_setlen(req->out.buffer, req->out.size - NBT_HDR_SIZE);
+        }
-        smbcli_request_calculate_sign_mac(req);
         smbcli_transport_send(req);
         return true;
+}
 …
         /* keep receiving packets until this one is replied to */
         while (req->state <= SMBCLI_REQUEST_RECV) {
                 if (event_loop_once(req->transport->socket->event.ctx) != 0) {
+                if (tevent_loop_once(req->transport->ev) != 0) {
                         return false;
+                }
 …
         return req->state == SMBCLI_REQUEST_DONE;
+}
-/*
-  handle oplock break requests from the server - return true if the request was
-  an oplock break
-*/
-bool smbcli_handle_oplock_break(struct smbcli_transport *transport, unsigned int len, const uint8_t *hdr, const uint8_t *vwv)
+{
-        /* we must be very fussy about what we consider an oplock break to avoid
-           matching readbraw replies */
-        if (len != MIN_SMB_SIZE + VWV(8) + NBT_HDR_SIZE ||
-            (CVAL(hdr, HDR_FLG) & FLAG_REPLY) ||
-            CVAL(hdr,HDR_COM) != SMBlockingX ||
-            SVAL(hdr, HDR_MID) != 0xFFFF ||
-            SVAL(vwv,VWV(6)) != 0 ||
-            SVAL(vwv,VWV(7)) != 0) {
-                return false;
+        }
-        if (transport->oplock.handler) {
-                uint16_t tid = SVAL(hdr, HDR_TID);
-                uint16_t fnum = SVAL(vwv,VWV(2));
-                uint8_t level = CVAL(vwv,VWV(3)+1);
-                transport->oplock.handler(transport, tid, fnum, level, transport->oplock.private_data);
+        }
-        return true;
+}
 …
+        }
         ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)dest, &ret_size, false);
+        ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)dest, &ret_size);
         if (!ret) {
                 *dest = NULL;
 …
+        }
         ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)dest, &ret_size, false);
+        ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)dest, &ret_size);
         if (!ret) {
 …
         src_len2 = utf16_len_n(src, src_len);
         ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size, false);
+        ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size);
         if (!ret) {
                 *dest = NULL;
 …
+        }
         ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size, false);
+        ret = convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX, src, src_len2, (void **)&dest2, &ret_size);
         if (!ret) {

vendor/current/source4/libcli/raw/rawsearch.c

r740	r988
457	457	&data->id_both_directory_info.short_name,
458	458	68, 70, STR_LEN8BIT \| STR_UNICODE);
	459	memcpy(data->id_both_directory_info.short_name_buf, blob->data + 70, 24);
459	460	data->id_both_directory_info.file_id = BVAL(blob->data, 96);
460	461	len = smbcli_blob_pull_string(NULL, mem_ctx, blob,

vendor/current/source4/libcli/raw/rawsetfileinfo.c

-              r740
+              r988
                 NEED_BLOB(20);
                 SIVAL(blob->data, 0, parms->rename_information.in.overwrite);
+                SIVAL(blob->data, 4, 0);
                 SBVAL(blob->data, 8, parms->rename_information.in.root_fid);
                 len = smbcli_blob_append_string(NULL, mem_ctx, blob,
 …
                                                     parms, blob);
+                /* Unhandled levels */
+        /* Unhandled levels */
         case RAW_SFILEINFO_UNIX_LINK:
         case RAW_SFILEINFO_UNIX_HLINK:
         case RAW_SFILEINFO_RENAME_INFORMATION_SMB2:
+        case RAW_SFILEINFO_LINK_INFORMATION:
                 break;
+        }

vendor/current/source4/libcli/raw/rawshadow.c

r414	r988
23	23	#include "libcli/raw/libcliraw.h"
24	24	#include "libcli/raw/raw_proto.h"
25		#include "~~libcli/raw/ioctl~~.h"
	25	#include "../libcli/smb/smb_constants.h"
26	26
27	27	/*

vendor/current/source4/libcli/raw/rawtrans.c

-              r740
+              r988
 #include "includes.h"
 #include "../lib/util/dlinklist.h"
+#include <tevent.h>
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
+#define TORTURE_TRANS_DATA 0
+/*
+  check out of bounds for incoming data
+*/
+static bool raw_trans_oob(struct smbcli_request *req,
+                          unsigned int offset, unsigned int count)
+{
+        uint8_t *ptr;
+        if (count == 0) {
+                return false;
+        }
+        ptr = req->in.hdr + offset;
+        /* be careful with wraparound! */
+        if ((uintptr_t)ptr < (uintptr_t)req->in.data ||
+            (uintptr_t)ptr >= (uintptr_t)req->in.data + req->in.data_size ||
+            count > req->in.data_size ||
+            (uintptr_t)ptr + count > (uintptr_t)req->in.data + req->in.data_size) {
+                return true;
+        }
+        return false;
+}
+static size_t raw_trans_space_left(struct smbcli_request *req)
+{
+        if (req->transport->negotiate.max_xmit <= req->out.size) {
+                return 0;
+        }
+        return req->transport->negotiate.max_xmit - req->out.size;
+}
+struct smb_raw_trans2_recv_state {
+        uint8_t command;
+        uint32_t params_total;
+        uint32_t data_total;
+        uint32_t params_left;
+        uint32_t data_left;
+        bool got_first;
+        uint32_t recvd_data;
+        uint32_t recvd_param;
+        struct smb_trans2 io;
+};
+#include "../libcli/smb/smbXcli_base.h"
+static void smb_raw_trans_backend_done(struct tevent_req *subreq);
+static struct smbcli_request *smb_raw_trans_backend_send(struct smbcli_tree *tree,
+                                                         struct smb_trans2 *parms,
+                                                         uint8_t command)
+{
+        struct smbcli_request *req;
+        uint8_t additional_flags;
+        uint8_t clear_flags;
+        uint16_t additional_flags2;
+        uint16_t clear_flags2;
+        uint32_t pid;
+        struct smbXcli_tcon *tcon = NULL;
+        struct smbXcli_session *session = NULL;
+        const char *pipe_name = NULL;
+        uint8_t s;
+        uint32_t timeout_msec;
+        uint32_t tmp;
+        tmp = parms->in.params.length + parms->in.data.length;
+        req = smbcli_request_setup(tree, command, parms->in.setup_count, tmp);
+        if (req == NULL) {
+                return NULL;
+        }
+        additional_flags = CVAL(req->out.hdr, HDR_FLG);
+        additional_flags2 = SVAL(req->out.hdr, HDR_FLG2);
+        pid  = SVAL(req->out.hdr, HDR_PID);
+        pid |= SVAL(req->out.hdr, HDR_PIDHIGH)<<16;
+        if (req->session) {
+                session = req->session->smbXcli;
+        }
+        if (req->tree) {
+                tcon = req->tree->smbXcli;
+        }
+        clear_flags = ~additional_flags;
+        clear_flags2 = ~additional_flags2;
+        timeout_msec = req->transport->options.request_timeout * 1000;
+        for (s=0; s < parms->in.setup_count; s++) {
+                SSVAL(req->out.vwv, VWV(s), parms->in.setup[s]);
+        }
+        memcpy(req->out.data,
+               parms->in.params.data,
+               parms->in.params.length);
+        memcpy(req->out.data + parms->in.params.length,
+               parms->in.data.data,
+               parms->in.data.length);
+        if (command == SMBtrans && parms->in.trans_name) {
+                pipe_name = parms->in.trans_name;
+        }
+        req->subreqs[0] = smb1cli_trans_send(req,
+                                             req->transport->ev,
+                                             req->transport->conn,
+                                             command,
+                                             additional_flags,
+                                             clear_flags,
+                                             additional_flags2,
+                                             clear_flags2,
+                                             timeout_msec,
+                                             pid,
+                                             tcon,
+                                             session,
+                                             pipe_name,
+xFFFF, /* fid */
+, /* function */
+                                             parms->in.flags,
+                                             (uint16_t *)req->out.vwv,
+                                             parms->in.setup_count,
+                                             parms->in.max_setup,
+                                             req->out.data,
+                                             parms->in.params.length,
+                                             parms->in.max_param,
+                                             req->out.data+
+                                             parms->in.params.length,
+                                             parms->in.data.length,
+                                             parms->in.max_data);
+        if (req->subreqs[0] == NULL) {
+                talloc_free(req);
+                return NULL;
+        }
+        tevent_req_set_callback(req->subreqs[0],
+                                smb_raw_trans_backend_done,
+                                req);
+        return req;
+}
+static void smb_raw_trans_backend_done(struct tevent_req *subreq)
+{
+        struct smbcli_request *req =
+                tevent_req_callback_data(subreq,
+                struct smbcli_request);
+        struct smbcli_transport *transport = req->transport;
+        uint16_t *setup = NULL;
+        uint8_t num_setup = 0;
+        uint8_t s;
+        uint8_t *param = NULL;
+        uint32_t num_param = 0;
+        uint8_t *data = NULL;
+        uint32_t num_data = 0;
+        req->status = smb1cli_trans_recv(req->subreqs[0], req,
+                                         &req->flags2,
+                                         &setup,
+, /* min_setup */
+                                         &num_setup,
+                                         &param,
+, /* min_param */
+                                         &num_param,
+                                         &data,
+, /* min_data */
+                                         &num_data);
+        TALLOC_FREE(req->subreqs[0]);
+        if (NT_STATUS_IS_ERR(req->status)) {
+                req->state = SMBCLI_REQUEST_ERROR;
+                transport->error.e.nt_status = req->status;
+                transport->error.etype = ETYPE_SMB;
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+                return;
+        }
+        req->trans2.out.setup_count = num_setup;
+        req->trans2.out.setup = talloc_array(req, uint16_t, num_setup);
+        if (req->trans2.out.setup == NULL) {
+                req->state = SMBCLI_REQUEST_ERROR;
+                req->status = NT_STATUS_NO_MEMORY;
+                transport->error.e.nt_status = req->status;
+                transport->error.etype = ETYPE_SMB;
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+                return;
+        }
+        for (s = 0; s < num_setup; s++) {
+                req->trans2.out.setup[s] = SVAL(setup, VWV(s));
+        }
+        req->trans2.out.params.data = param;
+        req->trans2.out.params.length = num_param;
+        req->trans2.out.data.data = data;
+        req->trans2.out.data.length = num_data;
+        transport->error.e.nt_status = req->status;
+        if (NT_STATUS_IS_OK(req->status)) {
+                transport->error.etype = ETYPE_NONE;
+        } else {
+                transport->error.etype = ETYPE_SMB;
+        }
+        req->state = SMBCLI_REQUEST_DONE;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+static NTSTATUS smb_raw_trans_backend_recv(struct smbcli_request *req,
+                                           TALLOC_CTX *mem_ctx,
+                                           struct smb_trans2 *parms)
+{
+        if (!smbcli_request_receive(req) ||
+            smbcli_request_is_error(req)) {
+                goto failed;
+        }
+        parms->out = req->trans2.out;
+        talloc_steal(mem_ctx, parms->out.setup);
+        talloc_steal(mem_ctx, parms->out.params.data);
+        talloc_steal(mem_ctx, parms->out.data.data);
+failed:
+        return smbcli_request_destroy(req);
+}
+_PUBLIC_ struct smbcli_request *smb_raw_trans_send(struct smbcli_tree *tree,
+                                       struct smb_trans2 *parms)
+{
+        return smb_raw_trans_backend_send(tree, parms, SMBtrans);
+}
+_PUBLIC_ NTSTATUS smb_raw_trans_recv(struct smbcli_request *req,
+                             TALLOC_CTX *mem_ctx,
+                             struct smb_trans2 *parms)
+{
+        return smb_raw_trans_backend_recv(req, mem_ctx, parms);
+}
+_PUBLIC_ NTSTATUS smb_raw_trans(struct smbcli_tree *tree,
+                       TALLOC_CTX *mem_ctx,
+                       struct smb_trans2 *parms)
+{
+        struct smbcli_request *req;
+        req = smb_raw_trans_send(tree, parms);
+        if (!req) return NT_STATUS_UNSUCCESSFUL;
+        return smb_raw_trans_recv(req, mem_ctx, parms);
+}
+struct smbcli_request *smb_raw_trans2_send(struct smbcli_tree *tree,
+                                       struct smb_trans2 *parms)
+{
+        return smb_raw_trans_backend_send(tree, parms, SMBtrans2);
+}
 NTSTATUS smb_raw_trans2_recv(struct smbcli_request *req,
 …
                              struct smb_trans2 *parms)
+{
+        struct smb_raw_trans2_recv_state *state;
+        if (!smbcli_request_receive(req) ||
+            smbcli_request_is_error(req)) {
+                goto failed;
+        }
+        state = talloc_get_type(req->recv_helper.private_data,
+                                struct smb_raw_trans2_recv_state);
+        parms->out = state->io.out;
+        talloc_steal(mem_ctx, parms->out.setup);
+        talloc_steal(mem_ctx, parms->out.params.data);
+        talloc_steal(mem_ctx, parms->out.data.data);
+        talloc_free(state);
+        ZERO_STRUCT(req->recv_helper);
+failed:
+        return smbcli_request_destroy(req);
+}
+static enum smbcli_request_state smb_raw_trans2_ship_rest(struct smbcli_request *req,
+                                                          struct smb_raw_trans2_recv_state *state);
+/*
+ * This helper returns SMBCLI_REQUEST_RECV until all data has arrived
+ */
+static enum smbcli_request_state smb_raw_trans2_recv_helper(struct smbcli_request *req)
+{
+        struct smb_raw_trans2_recv_state *state = talloc_get_type(req->recv_helper.private_data,
+                                                  struct smb_raw_trans2_recv_state);
+        uint16_t param_count, param_ofs, param_disp;
+        uint16_t data_count, data_ofs, data_disp;
+        uint16_t total_data, total_param;
+        uint8_t setup_count;
+        /*
+         * An NT RPC pipe call can return ERRDOS, ERRmoredata
+         * to a trans call. This is not an error and should not
+         * be treated as such.
+         */
+        if (smbcli_request_is_error(req)) {
+                goto failed;
+        }
+        if (state->params_left > 0 || state->data_left > 0) {
+                return smb_raw_trans2_ship_rest(req, state);
+        }
+        SMBCLI_CHECK_MIN_WCT(req, 10);
+        total_data = SVAL(req->in.vwv, VWV(1));
+        total_param = SVAL(req->in.vwv, VWV(0));
+        setup_count = CVAL(req->in.vwv, VWV(9));
+        param_count = SVAL(req->in.vwv, VWV(3));
+        param_ofs   = SVAL(req->in.vwv, VWV(4));
+        param_disp  = SVAL(req->in.vwv, VWV(5));
+        data_count = SVAL(req->in.vwv, VWV(6));
+        data_ofs   = SVAL(req->in.vwv, VWV(7));
+        data_disp  = SVAL(req->in.vwv, VWV(8));
+        if (!state->got_first) {
+                if (total_param > 0) {
+                        state->io.out.params = data_blob_talloc(state, NULL, total_param);
+                        if (!state->io.out.params.data) {
+                                goto nomem;
+                        }
+                }
+                if (total_data > 0) {
+                        state->io.out.data = data_blob_talloc(state, NULL, total_data);
+                        if (!state->io.out.data.data) {
+                                goto nomem;
+                        }
+                }
+                if (setup_count > 0) {
+                        uint16_t i;
+                        SMBCLI_CHECK_WCT(req, 10 + setup_count);
+                        state->io.out.setup_count = setup_count;
+                        state->io.out.setup = talloc_array(state, uint16_t, setup_count);
+                        if (!state->io.out.setup) {
+                                goto nomem;
+                        }
+                        for (i=0; i < setup_count; i++) {
+                                state->io.out.setup[i] = SVAL(req->in.vwv, VWV(10+i));
+                        }
+                }
+                state->got_first = true;
+        }
+        if (total_data > state->io.out.data.length ||
+            total_param > state->io.out.params.length) {
+                /* they must *only* shrink */
+                DEBUG(1,("smb_raw_trans2_recv_helper: data/params expanded!\n"));
+                req->status = NT_STATUS_BUFFER_TOO_SMALL;
+                goto failed;
+        }
+        state->io.out.data.length = total_data;
+        state->io.out.params.length = total_param;
+        if (data_count + data_disp > total_data ||
+            param_count + param_disp > total_param) {
+                DEBUG(1,("smb_raw_trans2_recv_helper: Buffer overflow\n"));
+                req->status = NT_STATUS_BUFFER_TOO_SMALL;
+                goto failed;
+        }
+        /* check the server isn't being nasty */
+        if (raw_trans_oob(req, param_ofs, param_count) ||
+            raw_trans_oob(req, data_ofs, data_count)) {
+                DEBUG(1,("smb_raw_trans2_recv_helper: out of bounds parameters!\n"));
+                req->status = NT_STATUS_BUFFER_TOO_SMALL;
+                goto failed;
+        }
+        if (data_count) {
+                memcpy(state->io.out.data.data + data_disp,
+                       req->in.hdr + data_ofs,
+                       data_count);
+        }
+        if (param_count) {
+                memcpy(state->io.out.params.data + param_disp,
+                       req->in.hdr + param_ofs,
+                       param_count);
+        }
+        state->recvd_param += param_count;
+        state->recvd_data += data_count;
+        if (state->recvd_data < total_data ||
+            state->recvd_param < total_param) {
+                /* we don't need the in buffer any more */
+                talloc_free(req->in.buffer);
+                ZERO_STRUCT(req->in);
+                /* we still wait for more data */
+                DEBUG(10,("smb_raw_trans2_recv_helper: more data needed\n"));
+                return SMBCLI_REQUEST_RECV;
+        }
+        DEBUG(10,("smb_raw_trans2_recv_helper: done\n"));
+        return SMBCLI_REQUEST_DONE;
+nomem:
+        req->status = NT_STATUS_NO_MEMORY;
+failed:
+        return SMBCLI_REQUEST_ERROR;
+}
+_PUBLIC_ NTSTATUS smb_raw_trans_recv(struct smbcli_request *req,
+                             TALLOC_CTX *mem_ctx,
+                             struct smb_trans2 *parms)
+{
+        return smb_raw_trans2_recv(req, mem_ctx, parms);
+}
+/*
+  trans/trans2 raw async interface - only BLOBs used in this interface.
+*/
+struct smbcli_request *smb_raw_trans_send_backend(struct smbcli_tree *tree,
+                                                  struct smb_trans2 *parms,
+                                                  uint8_t command)
+{
+        struct smb_raw_trans2_recv_state *state;
+        struct smbcli_request *req;
+        int i;
+        int padding;
+        size_t space_left;
+        size_t namelen = 0;
+        DATA_BLOB params_chunk;
+        uint16_t ofs;
+        uint16_t params_ofs = 0;
+        DATA_BLOB data_chunk;
+        uint16_t data_ofs = 0;
+        if (parms->in.params.length > UINT16_MAX ||
+            parms->in.data.length > UINT16_MAX) {
+                DEBUG(3,("Attempt to send invalid trans2 request (params %u, data %u)\n",
+                         (unsigned)parms->in.params.length, (unsigned)parms->in.data.length));
+                return NULL;
+        }
+        if (command == SMBtrans)
+                padding = 1;
+        else
+                padding = 3;
+        req = smbcli_request_setup(tree, command,
++ parms->in.setup_count,
+                                   padding);
+        if (!req) {
+                return NULL;
+        }
+        state = talloc_zero(req, struct smb_raw_trans2_recv_state);
+        if (!state) {
+                smbcli_request_destroy(req);
+                return NULL;
+        }
+        state->command = command;
+        /* make sure we don't leak data via the padding */
+        memset(req->out.data, 0, padding);
+        /* Watch out, this changes the req->out.* pointers */
+        if (command == SMBtrans && parms->in.trans_name) {
+                namelen = smbcli_req_append_string(req, parms->in.trans_name,
+                                                STR_TERMINATE);
+        }
+        ofs = PTR_DIFF(req->out.data,req->out.hdr)+padding+namelen;
+        /* see how much bytes of the params block we can ship in the first request */
+        space_left = raw_trans_space_left(req);
+        params_chunk.length = MIN(parms->in.params.length, space_left);
+        params_chunk.data = parms->in.params.data;
+        params_ofs = ofs;
+        state->params_left = parms->in.params.length - params_chunk.length;
+        if (state->params_left > 0) {
+                /* we copy the whole params block, if needed we can optimize that latter */
+                state->io.in.params = data_blob_talloc(state, NULL, parms->in.params.length);
+                if (!state->io.in.params.data) {
+                        smbcli_request_destroy(req);
+                        return NULL;
+                }
+                memcpy(state->io.in.params.data,
+                       parms->in.params.data,
+                       parms->in.params.length);
+        }
+        /* see how much bytes of the data block we can ship in the first request */
+        space_left -= params_chunk.length;
+#if TORTURE_TRANS_DATA
+        if (space_left > 1) {
+                space_left /= 2;
+        }
+#endif
+        data_chunk.length = MIN(parms->in.data.length, space_left);
+        data_chunk.data = parms->in.data.data;
+        data_ofs = params_ofs + params_chunk.length;
+        state->data_left = parms->in.data.length - data_chunk.length;
+        if (state->data_left > 0) {
+                /* we copy the whole params block, if needed we can optimize that latter */
+                state->io.in.data = data_blob_talloc(state, NULL, parms->in.data.length);
+                if (!state->io.in.data.data) {
+                        smbcli_request_destroy(req);
+                        return NULL;
+                }
+                memcpy(state->io.in.data.data,
+                       parms->in.data.data,
+                       parms->in.data.length);
+        }
+        state->params_total = parms->in.params.length;
+        state->data_total = parms->in.data.length;
+        /* primary request */
+        SSVAL(req->out.vwv,VWV(0),parms->in.params.length);
+        SSVAL(req->out.vwv,VWV(1),parms->in.data.length);
+        SSVAL(req->out.vwv,VWV(2),parms->in.max_param);
+        SSVAL(req->out.vwv,VWV(3),parms->in.max_data);
+        SCVAL(req->out.vwv,VWV(4),parms->in.max_setup);
+        SCVAL(req->out.vwv,VWV(4)+1,0); /* reserved */
+        SSVAL(req->out.vwv,VWV(5),parms->in.flags);
+        SIVAL(req->out.vwv,VWV(6),parms->in.timeout);
+        SSVAL(req->out.vwv,VWV(8),0); /* reserved */
+        SSVAL(req->out.vwv,VWV(9),params_chunk.length);
+        SSVAL(req->out.vwv,VWV(10),params_ofs);
+        SSVAL(req->out.vwv,VWV(11),data_chunk.length);
+        SSVAL(req->out.vwv,VWV(12),data_ofs);
+        SCVAL(req->out.vwv,VWV(13),parms->in.setup_count);
+        SCVAL(req->out.vwv,VWV(13)+1,0); /* reserved */
+        for (i=0;i<parms->in.setup_count;i++)   {
+                SSVAL(req->out.vwv,VWV(14)+VWV(i),parms->in.setup[i]);
+        }
+        smbcli_req_append_blob(req, &params_chunk);
+        smbcli_req_append_blob(req, &data_chunk);
+        /* add the helper which will check that all multi-part replies are
+           in before an async client callack will be issued */
+        req->recv_helper.fn = smb_raw_trans2_recv_helper;
+        req->recv_helper.private_data = state;
+        if (!smbcli_request_send(req)) {
+                smbcli_request_destroy(req);
+                return NULL;
+        }
+        return req;
+}
+static enum smbcli_request_state smb_raw_trans2_ship_next(struct smbcli_request *req,
+                                                          struct smb_raw_trans2_recv_state *state)
+{
+        struct smbcli_request *req2;
+        size_t space_left;
+        DATA_BLOB params_chunk;
+        uint16_t ofs;
+        uint16_t params_ofs = 0;
+        uint16_t params_disp = 0;
+        DATA_BLOB data_chunk;
+        uint16_t data_ofs = 0;
+        uint16_t data_disp = 0;
+        uint8_t wct;
+        if (state->command == SMBtrans2) {
+                wct = 9;
+        } else {
+                wct = 8;
+        }
+        req2 = smbcli_request_setup(req->tree, state->command+1, wct, 0);
+        if (!req2) {
+                goto nomem;
+        }
+        req2->mid = req->mid;
+        SSVAL(req2->out.hdr, HDR_MID, req2->mid);
+        ofs = PTR_DIFF(req2->out.data,req2->out.hdr);
+        /* see how much bytes of the params block we can ship in the first request */
+        space_left = raw_trans_space_left(req2);
+        params_disp = state->io.in.params.length - state->params_left;
+        params_chunk.length = MIN(state->params_left, space_left);
+        params_chunk.data = state->io.in.params.data + params_disp;
+        params_ofs = ofs;
+        state->params_left -= params_chunk.length;
+        /* see how much bytes of the data block we can ship in the first request */
+        space_left -= params_chunk.length;
+#if TORTURE_TRANS_DATA
+        if (space_left > 1) {
+                space_left /= 2;
+        }
+#endif
+        data_disp = state->io.in.data.length - state->data_left;
+        data_chunk.length = MIN(state->data_left, space_left);
+        data_chunk.data = state->io.in.data.data + data_disp;
+        data_ofs = params_ofs+params_chunk.length;
+        state->data_left -= data_chunk.length;
+        SSVAL(req2->out.vwv,VWV(0), state->params_total);
+        SSVAL(req2->out.vwv,VWV(1), state->data_total);
+        SSVAL(req2->out.vwv,VWV(2), params_chunk.length);
+        SSVAL(req2->out.vwv,VWV(3), params_ofs);
+        SSVAL(req2->out.vwv,VWV(4), params_disp);
+        SSVAL(req2->out.vwv,VWV(5), data_chunk.length);
+        SSVAL(req2->out.vwv,VWV(6), data_ofs);
+        SSVAL(req2->out.vwv,VWV(7), data_disp);
+        if (wct == 9) {
+                SSVAL(req2->out.vwv,VWV(8), 0xFFFF);
+        }
+        smbcli_req_append_blob(req2, &params_chunk);
+        smbcli_req_append_blob(req2, &data_chunk);
+        /*
+         * it's a one way request but we need
+         * the seq_num, so we destroy req2 by hand
+         */
+        if (!smbcli_request_send(req2)) {
+                goto failed;
+        }
+        req->seq_num = req2->seq_num;
+        smbcli_request_destroy(req2);
+        return SMBCLI_REQUEST_RECV;
+nomem:
+        req->status = NT_STATUS_NO_MEMORY;
+failed:
+        if (req2) {
+                req->status = smbcli_request_destroy(req2);
+        }
+        return SMBCLI_REQUEST_ERROR;
+}
+static enum smbcli_request_state smb_raw_trans2_ship_rest(struct smbcli_request *req,
+                                                          struct smb_raw_trans2_recv_state *state)
+{
+        enum smbcli_request_state ret = SMBCLI_REQUEST_ERROR;
+        while (state->params_left > 0 || state->data_left > 0) {
+                ret = smb_raw_trans2_ship_next(req, state);
+                if (ret != SMBCLI_REQUEST_RECV) {
+                        break;
+                }
+        }
+        return ret;
+}
+/*
+  trans/trans2 raw async interface - only BLOBs used in this interface.
+  note that this doesn't yet support multi-part requests
+*/
+_PUBLIC_ struct smbcli_request *smb_raw_trans_send(struct smbcli_tree *tree,
+                                       struct smb_trans2 *parms)
+{
+        return smb_raw_trans_send_backend(tree, parms, SMBtrans);
+}
+struct smbcli_request *smb_raw_trans2_send(struct smbcli_tree *tree,
+                                       struct smb_trans2 *parms)
+{
+        return smb_raw_trans_send_backend(tree, parms, SMBtrans2);
+}
+/*
+  trans2 synchronous blob interface
+*/
+        return smb_raw_trans_backend_recv(req, mem_ctx, parms);
+}
 NTSTATUS smb_raw_trans2(struct smbcli_tree *tree,
                         TALLOC_CTX *mem_ctx,
 …
+}
+/*
+  trans synchronous blob interface
+*/
+_PUBLIC_ NTSTATUS smb_raw_trans(struct smbcli_tree *tree,
+                       TALLOC_CTX *mem_ctx,
+                       struct smb_trans2 *parms)
+static void smb_raw_nttrans_done(struct tevent_req *subreq);
+struct smbcli_request *smb_raw_nttrans_send(struct smbcli_tree *tree,
+                                            struct smb_nttrans *parms)
+{
         struct smbcli_request *req;
+        req = smb_raw_trans_send(tree, parms);
+        if (!req) return NT_STATUS_UNSUCCESSFUL;
+        return smb_raw_trans_recv(req, mem_ctx, parms);
+}
+struct smb_raw_nttrans_recv_state {
+        uint32_t params_total;
+        uint32_t data_total;
+        uint32_t params_left;
+        uint32_t data_left;
+        bool got_first;
+        uint32_t recvd_data;
+        uint32_t recvd_param;
+        struct smb_nttrans io;
+};
+        uint8_t additional_flags;
+        uint8_t clear_flags;
+        uint16_t additional_flags2;
+        uint16_t clear_flags2;
+        uint32_t pid;
+        struct smbXcli_tcon *tcon = NULL;
+        struct smbXcli_session *session = NULL;
+        uint32_t timeout_msec;
+        uint32_t tmp;
+        tmp = parms->in.params.length + parms->in.data.length;
+        req = smbcli_request_setup(tree, SMBnttrans, parms->in.setup_count, tmp);
+        if (req == NULL) {
+                return NULL;
+        }
+        additional_flags = CVAL(req->out.hdr, HDR_FLG);
+        additional_flags2 = SVAL(req->out.hdr, HDR_FLG2);
+        pid  = SVAL(req->out.hdr, HDR_PID);
+        pid |= SVAL(req->out.hdr, HDR_PIDHIGH)<<16;
+        if (req->session) {
+                session = req->session->smbXcli;
+        }
+        if (req->tree) {
+                tcon = req->tree->smbXcli;
+        }
+        clear_flags = ~additional_flags;
+        clear_flags2 = ~additional_flags2;
+        timeout_msec = req->transport->options.request_timeout * 1000;
+        memcpy(req->out.vwv,
+               parms->in.setup,
+               parms->in.setup_count * 2);
+        memcpy(req->out.data,
+               parms->in.params.data,
+               parms->in.params.length);
+        memcpy(req->out.data + parms->in.params.length,
+               parms->in.data.data,
+               parms->in.data.length);
+        req->subreqs[0] = smb1cli_trans_send(req,
+                                             req->transport->ev,
+                                             req->transport->conn,
+                                             SMBnttrans,
+                                             additional_flags,
+                                             clear_flags,
+                                             additional_flags2,
+                                             clear_flags2,
+                                             timeout_msec,
+                                             pid,
+                                             tcon,
+                                             session,
+                                             NULL, /* pipe_name */
+xFFFF, /* fid */
+                                             parms->in.function,
+, /* flags */
+                                             (uint16_t *)req->out.vwv,
+                                             parms->in.setup_count,
+                                             parms->in.max_setup,
+                                             req->out.data,
+                                             parms->in.params.length,
+                                             parms->in.max_param,
+                                             req->out.data+
+                                             parms->in.params.length,
+                                             parms->in.data.length,
+                                             parms->in.max_data);
+        if (req->subreqs[0] == NULL) {
+                talloc_free(req);
+                return NULL;
+        }
+        tevent_req_set_callback(req->subreqs[0],
+                                smb_raw_nttrans_done,
+                                req);
+        return req;
+}
+static void smb_raw_nttrans_done(struct tevent_req *subreq)
+{
+        struct smbcli_request *req =
+                tevent_req_callback_data(subreq,
+                struct smbcli_request);
+        struct smbcli_transport *transport = req->transport;
+        uint16_t *setup = NULL;
+        uint8_t num_setup = 0;
+        uint8_t *param = NULL;
+        uint32_t num_param = 0;
+        uint8_t *data = NULL;
+        uint32_t num_data = 0;
+        req->status = smb1cli_trans_recv(req->subreqs[0], req,
+                                         &req->flags2,
+                                         &setup,
+, /* min_setup */
+                                         &num_setup,
+                                         &param,
+, /* min_param */
+                                         &num_param,
+                                         &data,
+, /* min_data */
+                                         &num_data);
+        TALLOC_FREE(req->subreqs[0]);
+        if (NT_STATUS_IS_ERR(req->status)) {
+                req->state = SMBCLI_REQUEST_ERROR;
+                transport->error.e.nt_status = req->status;
+                transport->error.etype = ETYPE_SMB;
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+                return;
+        }
+        req->nttrans.out.setup_count = num_setup;
+        req->nttrans.out.setup = (uint8_t *)setup;
+        req->nttrans.out.params.data = param;
+        req->nttrans.out.params.length = num_param;
+        req->nttrans.out.data.data = data;
+        req->nttrans.out.data.length = num_data;
+        transport->error.e.nt_status = req->status;
+        if (NT_STATUS_IS_OK(req->status)) {
+                transport->error.etype = ETYPE_NONE;
+        } else {
+                transport->error.etype = ETYPE_SMB;
+        }
+        req->state = SMBCLI_REQUEST_DONE;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
 NTSTATUS smb_raw_nttrans_recv(struct smbcli_request *req,
 …
                               struct smb_nttrans *parms)
+{
-        struct smb_raw_nttrans_recv_state *state;
         if (!smbcli_request_receive(req) ||
             smbcli_request_is_error(req)) {
 …
+        }
+        state = talloc_get_type(req->recv_helper.private_data,
+                                struct smb_raw_nttrans_recv_state);
+        parms->out = state->io.out;
+        parms->out = req->nttrans.out;
         talloc_steal(mem_ctx, parms->out.setup);
         talloc_steal(mem_ctx, parms->out.params.data);
         talloc_steal(mem_ctx, parms->out.data.data);
-        talloc_free(state);
-        ZERO_STRUCT(req->recv_helper);
 failed:
         return smbcli_request_destroy(req);
+}
-static enum smbcli_request_state smb_raw_nttrans_ship_rest(struct smbcli_request *req,
-                                                           struct smb_raw_nttrans_recv_state *state);
-/*
- * This helper returns SMBCLI_REQUEST_RECV until all data has arrived
- */
-static enum smbcli_request_state smb_raw_nttrans_recv_helper(struct smbcli_request *req)
+{
-        struct smb_raw_nttrans_recv_state *state = talloc_get_type(req->recv_helper.private_data,
-                                                   struct smb_raw_nttrans_recv_state);
-        uint32_t param_count, param_ofs, param_disp;
-        uint32_t data_count, data_ofs, data_disp;
-        uint32_t total_data, total_param;
-        uint8_t setup_count;
-        /*
-         * An NT RPC pipe call can return ERRDOS, ERRmoredata
-         * to a trans call. This is not an error and should not
-         * be treated as such.
-         */
-        if (smbcli_request_is_error(req)) {
-                goto failed;
+        }
-        /* sanity check */
-        if (CVAL(req->in.hdr, HDR_COM) != SMBnttrans) {
-                DEBUG(0,("smb_raw_nttrans_recv_helper: Expected %s response, got command 0x%02x\n",
-                         "SMBnttrans",
-                         CVAL(req->in.hdr,HDR_COM)));
-                req->status = NT_STATUS_INVALID_NETWORK_RESPONSE;
-                goto failed;
+        }
-        if (state->params_left > 0 || state->data_left > 0) {
-                return smb_raw_nttrans_ship_rest(req, state);
+        }
-        /* this is the first packet of the response */
-        SMBCLI_CHECK_MIN_WCT(req, 18);
-        total_param = IVAL(req->in.vwv, 3);
-        total_data  = IVAL(req->in.vwv, 7);
-        setup_count = CVAL(req->in.vwv, 35);
-        param_count = IVAL(req->in.vwv, 11);
-        param_ofs   = IVAL(req->in.vwv, 15);
-        param_disp  = IVAL(req->in.vwv, 19);
-        data_count = IVAL(req->in.vwv, 23);
-        data_ofs   = IVAL(req->in.vwv, 27);
-        data_disp  = IVAL(req->in.vwv, 31);
-        if (!state->got_first) {
-                if (total_param > 0) {
-                        state->io.out.params = data_blob_talloc(state, NULL, total_param);
-                        if (!state->io.out.params.data) {
-                                goto nomem;
+                        }
+                }
-                if (total_data > 0) {
-                        state->io.out.data = data_blob_talloc(state, NULL, total_data);
-                        if (!state->io.out.data.data) {
-                                goto nomem;
+                        }
+                }
-                if (setup_count > 0) {
-                        SMBCLI_CHECK_WCT(req, 18 + setup_count);
-                        state->io.out.setup_count = setup_count;
-                        state->io.out.setup = talloc_array(state, uint8_t,
-                                                           setup_count * VWV(1));
-                        if (!state->io.out.setup) {
-                                goto nomem;
+                        }
-                        memcpy(state->io.out.setup, (uint8_t *)req->out.vwv + VWV(18),
-                               setup_count * VWV(1));
+                }
-                state->got_first = true;
+        }
-        if (total_data > state->io.out.data.length ||
-            total_param > state->io.out.params.length) {
-                /* they must *only* shrink */
-                DEBUG(1,("smb_raw_nttrans_recv_helper: data/params expanded!\n"));
-                req->status = NT_STATUS_BUFFER_TOO_SMALL;
-                goto failed;
+        }
-        state->io.out.data.length = total_data;
-        state->io.out.params.length = total_param;
-        if (data_count + data_disp > total_data ||
-            param_count + param_disp > total_param) {
-                DEBUG(1,("smb_raw_nttrans_recv_helper: Buffer overflow\n"));
-                req->status = NT_STATUS_BUFFER_TOO_SMALL;
-                goto failed;
+        }
-        /* check the server isn't being nasty */
-        if (raw_trans_oob(req, param_ofs, param_count) ||
-            raw_trans_oob(req, data_ofs, data_count)) {
-                DEBUG(1,("smb_raw_nttrans_recv_helper: out of bounds parameters!\n"));
-                req->status = NT_STATUS_BUFFER_TOO_SMALL;
-                goto failed;
+        }
-        if (data_count) {
-                memcpy(state->io.out.data.data + data_disp,
-                       req->in.hdr + data_ofs,
-                       data_count);
+        }
-        if (param_count) {
-                memcpy(state->io.out.params.data + param_disp,
-                       req->in.hdr + param_ofs,
-                       param_count);
+        }
-        state->recvd_param += param_count;
-        state->recvd_data += data_count;
-        if (state->recvd_data < total_data ||
-            state->recvd_param < total_param) {
-                /* we don't need the in buffer any more */
-                talloc_free(req->in.buffer);
-                ZERO_STRUCT(req->in);
-                /* we still wait for more data */
-                DEBUG(10,("smb_raw_nttrans_recv_helper: more data needed\n"));
-                return SMBCLI_REQUEST_RECV;
+        }
-        DEBUG(10,("smb_raw_nttrans_recv_helper: done\n"));
-        return SMBCLI_REQUEST_DONE;
-nomem:
-        req->status = NT_STATUS_NO_MEMORY;
-failed:
-        return SMBCLI_REQUEST_ERROR;
+}
-/****************************************************************************
- nttrans raw - only BLOBs used in this interface.
- at the moment we only handle a single primary request
-****************************************************************************/
-struct smbcli_request *smb_raw_nttrans_send(struct smbcli_tree *tree,
-                                         struct smb_nttrans *parms)
+{
-        struct smbcli_request *req;
-        struct smb_raw_nttrans_recv_state *state;
-        uint32_t ofs;
-        size_t space_left;
-        DATA_BLOB params_chunk;
-        uint32_t params_ofs;
-        DATA_BLOB data_chunk;
-        uint32_t data_ofs;
-        int align = 0;
-        /* only align if there are parameters or data */
-        if (parms->in.params.length || parms->in.data.length) {
-                align = 3;
+        }
-        req = smbcli_request_setup(tree, SMBnttrans,
-+ parms->in.setup_count, align);
-        if (!req) {
-                return NULL;
+        }
-        state = talloc_zero(req, struct smb_raw_nttrans_recv_state);
-        if (!state) {
-                talloc_free(req);
-                return NULL;
+        }
-        /* fill in SMB parameters */
-        if (align != 0) {
-                memset(req->out.data, 0, align);
+        }
-        ofs = PTR_DIFF(req->out.data,req->out.hdr)+align;
-        /* see how much bytes of the params block we can ship in the first request */
-        space_left = raw_trans_space_left(req);
-        params_chunk.length = MIN(parms->in.params.length, space_left);
-        params_chunk.data = parms->in.params.data;
-        params_ofs = ofs;
-        state->params_left = parms->in.params.length - params_chunk.length;
-        if (state->params_left > 0) {
-                /* we copy the whole params block, if needed we can optimize that latter */
-                state->io.in.params = data_blob_talloc(state, NULL, parms->in.params.length);
-                if (!state->io.in.params.data) {
-                        smbcli_request_destroy(req);
-                        return NULL;
+                }
-                memcpy(state->io.in.params.data,
-                       parms->in.params.data,
-                       parms->in.params.length);
+        }
-        /* see how much bytes of the data block we can ship in the first request */
-        space_left -= params_chunk.length;
-#if TORTURE_TRANS_DATA
-        if (space_left > 1) {
-                space_left /= 2;
+        }
-#endif
-        data_chunk.length = MIN(parms->in.data.length, space_left);
-        data_chunk.data = parms->in.data.data;
-        data_ofs = params_ofs + params_chunk.length;
-        state->data_left = parms->in.data.length - data_chunk.length;
-        if (state->data_left > 0) {
-                /* we copy the whole params block, if needed we can optimize that latter */
-                state->io.in.data = data_blob_talloc(state, NULL, parms->in.data.length);
-                if (!state->io.in.data.data) {
-                        smbcli_request_destroy(req);
-                        return NULL;
+                }
-                memcpy(state->io.in.data.data,
-                       parms->in.data.data,
-                       parms->in.data.length);
+        }
-        state->params_total = parms->in.params.length;
-        state->data_total = parms->in.data.length;
-        SCVAL(req->out.vwv,  0, parms->in.max_setup);
-        SSVAL(req->out.vwv,  1, 0); /* reserved */
-        SIVAL(req->out.vwv,  3, parms->in.params.length);
-        SIVAL(req->out.vwv,  7, parms->in.data.length);
-        SIVAL(req->out.vwv, 11, parms->in.max_param);
-        SIVAL(req->out.vwv, 15, parms->in.max_data);
-        SIVAL(req->out.vwv, 19, params_chunk.length);
-        SIVAL(req->out.vwv, 23, params_ofs);
-        SIVAL(req->out.vwv, 27, data_chunk.length);
-        SIVAL(req->out.vwv, 31, data_ofs);
-        SCVAL(req->out.vwv, 35, parms->in.setup_count);
-        SSVAL(req->out.vwv, 36, parms->in.function);
-        memcpy(req->out.vwv + VWV(19), parms->in.setup,
-               sizeof(uint16_t) * parms->in.setup_count);
-        smbcli_req_append_blob(req, &params_chunk);
-        smbcli_req_append_blob(req, &data_chunk);
-        /* add the helper which will check that all multi-part replies are
-           in before an async client callack will be issued */
-        req->recv_helper.fn = smb_raw_nttrans_recv_helper;
-        req->recv_helper.private_data = state;
-        if (!smbcli_request_send(req)) {
-                smbcli_request_destroy(req);
-                return NULL;
+        }
-        return req;
+}
-static enum smbcli_request_state smb_raw_nttrans_ship_next(struct smbcli_request *req,
-                                                           struct smb_raw_nttrans_recv_state *state)
+{
-        struct smbcli_request *req2;
-        size_t space_left;
-        DATA_BLOB params_chunk;
-        uint32_t ofs;
-        uint32_t params_ofs = 0;
-        uint32_t params_disp = 0;
-        DATA_BLOB data_chunk;
-        uint32_t data_ofs = 0;
-        uint32_t data_disp = 0;
-        req2 = smbcli_request_setup(req->tree, SMBnttranss, 18, 0);
-        if (!req2) {
-                goto nomem;
+        }
-        req2->mid = req->mid;
-        SSVAL(req2->out.hdr, HDR_MID, req2->mid);
-        ofs = PTR_DIFF(req2->out.data,req2->out.hdr);
-        /* see how much bytes of the params block we can ship in the first request */
-        space_left = raw_trans_space_left(req2);
-        params_disp = state->io.in.params.length - state->params_left;
-        params_chunk.length = MIN(state->params_left, space_left);
-        params_chunk.data = state->io.in.params.data + params_disp;
-        params_ofs = ofs;
-        state->params_left -= params_chunk.length;
-        /* see how much bytes of the data block we can ship in the first request */
-        space_left -= params_chunk.length;
-#if TORTURE_TRANS_DATA
-        if (space_left > 1) {
-                space_left /= 2;
+        }
-#endif
-        data_disp = state->io.in.data.length - state->data_left;
-        data_chunk.length = MIN(state->data_left, space_left);
-        data_chunk.data = state->io.in.data.data + data_disp;
-        data_ofs = params_ofs+params_chunk.length;
-        state->data_left -= data_chunk.length;
-        SSVAL(req2->out.vwv,0, 0); /* reserved */
-        SCVAL(req2->out.vwv,2, 0); /* reserved */
-        SIVAL(req2->out.vwv,3, state->params_total);
-        SIVAL(req2->out.vwv,7, state->data_total);
-        SIVAL(req2->out.vwv,11, params_chunk.length);
-        SIVAL(req2->out.vwv,15, params_ofs);
-        SIVAL(req2->out.vwv,19, params_disp);
-        SIVAL(req2->out.vwv,23, data_chunk.length);
-        SIVAL(req2->out.vwv,27, data_ofs);
-        SIVAL(req2->out.vwv,31, data_disp);
-        SCVAL(req2->out.vwv,35, 0); /* reserved */
-        smbcli_req_append_blob(req2, &params_chunk);
-        smbcli_req_append_blob(req2, &data_chunk);
-        /*
-         * it's a one way request but we need
-         * the seq_num, so we destroy req2 by hand
-         */
-        if (!smbcli_request_send(req2)) {
-                goto failed;
+        }
-        req->seq_num = req2->seq_num;
-        smbcli_request_destroy(req2);
-        return SMBCLI_REQUEST_RECV;
-nomem:
-        req->status = NT_STATUS_NO_MEMORY;
-failed:
-        if (req2) {
-                req->status = smbcli_request_destroy(req2);
+        }
-        return SMBCLI_REQUEST_ERROR;
+}
-static enum smbcli_request_state smb_raw_nttrans_ship_rest(struct smbcli_request *req,
-                                                           struct smb_raw_nttrans_recv_state *state)
+{
-        enum smbcli_request_state ret = SMBCLI_REQUEST_ERROR;
-        while (state->params_left > 0 || state->data_left > 0) {
-                ret = smb_raw_nttrans_ship_next(req, state);
-                if (ret != SMBCLI_REQUEST_RECV) {
-                        break;
+                }
+        }
-        return ret;
+}
 /****************************************************************************

vendor/current/source4/libcli/raw/signing.h

-              r414
+              r988
 };
-enum smb_signing_state {
-        SMB_SIGNING_OFF, SMB_SIGNING_SUPPORTED,
-        SMB_SIGNING_REQUIRED, SMB_SIGNING_AUTO};
 struct smb_signing_context {
         enum smb_signing_engine_state signing_state;

vendor/current/source4/libcli/raw/smb.h

-              r740
+              r988
 */
 #ifndef _SMB_H
 #define _SMB_H
+#ifndef _RAW_SMB_H
+#define _RAW_SMB_H
 /* deny modes */
 …
 #define NTCREATEX_ACTION_UNKNOWN 5
-#define SMB_MAGIC 0x424D53FF /* 0xFF 'S' 'M' 'B' */
-/* the basic packet size, assuming no words or bytes. Does not include the NBT header */
-#define MIN_SMB_SIZE 35
-/* when using NBT encapsulation every packet has a 4 byte header */
-#define NBT_HDR_SIZE 4
-/* offsets into message header for common items - NOTE: These have
-   changed from being offsets from the base of the NBT packet to the base of the SMB packet.
-   this has reduced all these values by 4
-*/
-#define HDR_COM 4
-#define HDR_RCLS 5
-#define HDR_REH 6
-#define HDR_ERR 7
-#define HDR_FLG 9
-#define HDR_FLG2 10
-#define HDR_PIDHIGH 12
-#define HDR_SS_FIELD 14
-#define HDR_TID 24
-#define HDR_PID 26
-#define HDR_UID 28
-#define HDR_MID 30
-#define HDR_WCT 32
-#define HDR_VWV 33
-/* types of buffers in core SMB protocol */
-#define SMB_DATA_BLOCK 0x1
-#define SMB_ASCII4     0x4
-/* flag defines. CIFS spec 3.1.1 */
-#define FLAG_SUPPORT_LOCKREAD       0x01
-#define FLAG_CLIENT_BUF_AVAIL       0x02
-#define FLAG_RESERVED               0x04
-#define FLAG_CASELESS_PATHNAMES     0x08
-#define FLAG_CANONICAL_PATHNAMES    0x10
-#define FLAG_REQUEST_OPLOCK         0x20
-#define FLAG_REQUEST_BATCH_OPLOCK   0x40
-#define FLAG_REPLY                  0x80
-/* the complete */
-#define SMBmkdir      0x00   /* create directory */
-#define SMBrmdir      0x01   /* delete directory */
-#define SMBopen       0x02   /* open file */
-#define SMBcreate     0x03   /* create file */
-#define SMBclose      0x04   /* close file */
-#define SMBflush      0x05   /* flush file */
-#define SMBunlink     0x06   /* delete file */
-#define SMBmv         0x07   /* rename file */
-#define SMBgetatr     0x08   /* get file attributes */
-#define SMBsetatr     0x09   /* set file attributes */
-#define SMBread       0x0A   /* read from file */
-#define SMBwrite      0x0B   /* write to file */
-#define SMBlock       0x0C   /* lock byte range */
-#define SMBunlock     0x0D   /* unlock byte range */
-#define SMBctemp      0x0E   /* create temporary file */
-#define SMBmknew      0x0F   /* make new file */
-#define SMBchkpth     0x10   /* check directory path */
-#define SMBexit       0x11   /* process exit */
-#define SMBlseek      0x12   /* seek */
-#define SMBtcon       0x70   /* tree connect */
-#define SMBtconX      0x75   /* tree connect and X*/
-#define SMBtdis       0x71   /* tree disconnect */
-#define SMBnegprot    0x72   /* negotiate protocol */
-#define SMBdskattr    0x80   /* get disk attributes */
-#define SMBsearch     0x81   /* search directory */
-#define SMBsplopen    0xC0   /* open print spool file */
-#define SMBsplwr      0xC1   /* write to print spool file */
-#define SMBsplclose   0xC2   /* close print spool file */
-#define SMBsplretq    0xC3   /* return print queue */
-#define SMBsends      0xD0   /* send single block message */
-#define SMBsendb      0xD1   /* send broadcast message */
-#define SMBfwdname    0xD2   /* forward user name */
-#define SMBcancelf    0xD3   /* cancel forward */
-#define SMBgetmac     0xD4   /* get machine name */
-#define SMBsendstrt   0xD5   /* send start of multi-block message */
-#define SMBsendend    0xD6   /* send end of multi-block message */
-#define SMBsendtxt    0xD7   /* send text of multi-block message */
-/* Core+ protocol */
-#define SMBlockread       0x13   /* Lock a range and read */
-#define SMBwriteunlock 0x14 /* write then range then unlock it */
-#define SMBreadbraw   0x1a  /* read a block of data with no smb header */
-#define SMBwritebraw  0x1d  /* write a block of data with no smb header */
-#define SMBwritec     0x20  /* secondary write request */
-#define SMBwriteclose 0x2c  /* write a file then close it */
-/* dos extended protocol */
-#define SMBreadBraw      0x1A   /* read block raw */
-#define SMBreadBmpx      0x1B   /* read block multiplexed */
-#define SMBreadBs        0x1C   /* read block (secondary response) */
-#define SMBwriteBraw     0x1D   /* write block raw */
-#define SMBwriteBmpx     0x1E   /* write block multiplexed */
-#define SMBwriteBs       0x1F   /* write block (secondary request) */
-#define SMBwriteC        0x20   /* write complete response */
-#define SMBsetattrE      0x22   /* set file attributes expanded */
-#define SMBgetattrE      0x23   /* get file attributes expanded */
-#define SMBlockingX      0x24   /* lock/unlock byte ranges and X */
-#define SMBtrans         0x25   /* transaction - name, bytes in/out */
-#define SMBtranss        0x26   /* transaction (secondary request/response) */
-#define SMBioctl         0x27   /* IOCTL */
-#define SMBioctls        0x28   /* IOCTL  (secondary request/response) */
-#define SMBcopy          0x29   /* copy */
-#define SMBmove          0x2A   /* move */
-#define SMBecho          0x2B   /* echo */
-#define SMBopenX         0x2D   /* open and X */
-#define SMBreadX         0x2E   /* read and X */
-#define SMBwriteX        0x2F   /* write and X */
-#define SMBsesssetupX    0x73   /* Session Set Up & X (including User Logon) */
-#define SMBffirst        0x82   /* find first */
-#define SMBfunique       0x83   /* find unique */
-#define SMBfclose        0x84   /* find close */
-#define SMBkeepalive     0x85   /* keepalive */
-#define SMBinvalid       0xFE   /* invalid command */
-/* Extended 2.0 protocol */
-#define SMBtrans2        0x32   /* TRANS2 protocol set */
-#define SMBtranss2       0x33   /* TRANS2 protocol set, secondary command */
-#define SMBfindclose     0x34   /* Terminate a TRANSACT2_FINDFIRST */
-#define SMBfindnclose    0x35   /* Terminate a TRANSACT2_FINDNOTIFYFIRST */
-#define SMBulogoffX      0x74   /* user logoff */
-/* NT SMB extensions. */
-#define SMBnttrans       0xA0   /* NT transact */
-#define SMBnttranss      0xA1   /* NT transact secondary */
-#define SMBntcreateX     0xA2   /* NT create and X */
-#define SMBntcancel      0xA4   /* NT cancel */
-#define SMBntrename      0xA5   /* NT rename */
-/* used to indicate end of chain */
-#define SMB_CHAIN_NONE   0xFF
-/* These are the trans subcommands */
-#define TRANSACT_SETNAMEDPIPEHANDLESTATE  0x01
-#define TRANSACT_DCERPCCMD                0x26
-#define TRANSACT_WAITNAMEDPIPEHANDLESTATE 0x53
-/* These are the NT transact sub commands. */
-#define NT_TRANSACT_CREATE                1
-#define NT_TRANSACT_IOCTL                 2
-#define NT_TRANSACT_SET_SECURITY_DESC     3
-#define NT_TRANSACT_NOTIFY_CHANGE         4
-#define NT_TRANSACT_RENAME                5
-#define NT_TRANSACT_QUERY_SECURITY_DESC   6
-/* this is used on a TConX. I'm not sure the name is very helpful though */
-#define SMB_SUPPORT_SEARCH_BITS        0x0001
-#define SMB_SHARE_IN_DFS               0x0002
 /* Named pipe write mode flags. Used in writeX calls. */
 #define PIPE_RAW_MODE 0x4
 …
 #define DESIRED_ACCESS_PIPE 0x2019f
-/* FileAttributes (search attributes) field */
-#define FILE_ATTRIBUTE_READONLY         0x0001
-#define FILE_ATTRIBUTE_HIDDEN           0x0002
-#define FILE_ATTRIBUTE_SYSTEM           0x0004
-#define FILE_ATTRIBUTE_VOLUME           0x0008
-#define FILE_ATTRIBUTE_DIRECTORY        0x0010
-#define FILE_ATTRIBUTE_ARCHIVE          0x0020
-#define FILE_ATTRIBUTE_DEVICE           0x0040
-#define FILE_ATTRIBUTE_NORMAL           0x0080
-#define FILE_ATTRIBUTE_TEMPORARY        0x0100
-#define FILE_ATTRIBUTE_SPARSE           0x0200
-#define FILE_ATTRIBUTE_REPARSE_POINT    0x0400
-#define FILE_ATTRIBUTE_COMPRESSED       0x0800
-#define FILE_ATTRIBUTE_OFFLINE          0x1000
-#define FILE_ATTRIBUTE_NONINDEXED       0x2000
-#define FILE_ATTRIBUTE_ENCRYPTED        0x4000
-#define FILE_ATTRIBUTE_ALL_MASK         0x7FFF
-/* Flags - combined with attributes. */
-#define FILE_FLAG_WRITE_THROUGH    0x80000000L
-#define FILE_FLAG_NO_BUFFERING     0x20000000L
-#define FILE_FLAG_RANDOM_ACCESS    0x10000000L
-#define FILE_FLAG_SEQUENTIAL_SCAN  0x08000000L
-#define FILE_FLAG_DELETE_ON_CLOSE  0x04000000L
-#define FILE_FLAG_BACKUP_SEMANTICS 0x02000000L /* only if backup/restore privilege? */
-#define FILE_FLAG_POSIX_SEMANTICS  0x01000000L
-/* Responses when opening a file. */
-#define FILE_WAS_SUPERSEDED 0
-#define FILE_WAS_OPENED 1
-#define FILE_WAS_CREATED 2
-#define FILE_WAS_OVERWRITTEN 3
-/* File type flags */
-#define FILE_TYPE_DISK  0
-#define FILE_TYPE_BYTE_MODE_PIPE 1
-#define FILE_TYPE_MESSAGE_MODE_PIPE 2
-#define FILE_TYPE_PRINTER 3
-#define FILE_TYPE_COMM_DEVICE 4
-#define FILE_TYPE_UNKNOWN 0xFFFF
 /* Flag for NT transact rename call. */
 #define RENAME_REPLACE_IF_EXISTS 1
 …
 #define RENAME_FLAG_RENAME                   0x104
 #define RENAME_FLAG_COPY                     0x105
-/* Filesystem Attributes. */
-#define FILE_CASE_SENSITIVE_SEARCH 0x01
-#define FILE_CASE_PRESERVED_NAMES 0x02
-#define FILE_UNICODE_ON_DISK 0x04
-/* According to cifs9f, this is 4, not 8 */
-/* Acconding to testing, this actually sets the security attribute! */
-#define FILE_PERSISTENT_ACLS 0x08
-/* These entries added from cifs9f --tsb */
-#define FILE_FILE_COMPRESSION 0x10
-#define FILE_VOLUME_QUOTAS 0x20
-/* I think this is wrong. JRA #define FILE_DEVICE_IS_MOUNTED 0x20 */
-#define FILE_VOLUME_SPARSE_FILE 0x40
-#define FILE_VOLUME_IS_COMPRESSED 0x8000
 /* ChangeNotify flags. */
 …
 /* where to find the base of the SMB packet proper */
 /* REWRITE TODO: smb_base needs to be removed */
 #define smb_base(buf) (((char *)(buf))+4)
+#define smb_base(buf) (((const char *)(buf))+4)
 /* we don't allow server strings to be longer than 48 characters as
 …
 #define BROWSER_CONSTANT        0xaa55
-/* Sercurity mode bits. */
-#define NEGOTIATE_SECURITY_USER_LEVEL           0x01
-#define NEGOTIATE_SECURITY_CHALLENGE_RESPONSE   0x02
-#define NEGOTIATE_SECURITY_SIGNATURES_ENABLED   0x04
-#define NEGOTIATE_SECURITY_SIGNATURES_REQUIRED  0x08
-/* NT Flags2 bits - cifs6.txt section 3.1.2 */
-#define FLAGS2_LONG_PATH_COMPONENTS    0x0001
-#define FLAGS2_EXTENDED_ATTRIBUTES     0x0002
-#define FLAGS2_SMB_SECURITY_SIGNATURES 0x0004
-#define FLAGS2_IS_LONG_NAME            0x0040
-#define FLAGS2_EXTENDED_SECURITY       0x0800
-#define FLAGS2_DFS_PATHNAMES           0x1000
-#define FLAGS2_READ_PERMIT_EXECUTE     0x2000
-#define FLAGS2_32_BIT_ERROR_CODES      0x4000
-#define FLAGS2_UNICODE_STRINGS         0x8000
-/* CIFS protocol capabilities */
-#define CAP_RAW_MODE            0x00000001
-#define CAP_MPX_MODE            0x00000002
-#define CAP_UNICODE             0x00000004
-#define CAP_LARGE_FILES         0x00000008
-#define CAP_NT_SMBS             0x00000010
-#define CAP_RPC_REMOTE_APIS     0x00000020
-#define CAP_STATUS32            0x00000040
-#define CAP_LEVEL_II_OPLOCKS    0x00000080
-#define CAP_LOCK_AND_READ       0x00000100
-#define CAP_NT_FIND             0x00000200
-#define CAP_DFS                 0x00001000
-#define CAP_W2K_SMBS            0x00002000
-#define CAP_LARGE_READX         0x00004000
-#define CAP_LARGE_WRITEX        0x00008000
-#define CAP_UNIX                0x00800000 /* Capabilities for UNIX extensions. Created by HP. */
-#define CAP_EXTENDED_SECURITY   0x80000000
 /*
  * Global value meaning that the smb_uid field should be
 …
 #define UID_FIELD_INVALID 0
-/* Lock types. */
-#define LOCKING_ANDX_EXCLUSIVE_LOCK  0x00
-#define LOCKING_ANDX_SHARED_LOCK     0x01
-#define LOCKING_ANDX_OPLOCK_RELEASE  0x02
-#define LOCKING_ANDX_CHANGE_LOCKTYPE 0x04
-#define LOCKING_ANDX_CANCEL_LOCK     0x08
-#define LOCKING_ANDX_LARGE_FILES     0x10
-/*
- * Bits we test with.
- */
-#define OPLOCK_NONE      0
-#define OPLOCK_EXCLUSIVE 1
-#define OPLOCK_BATCH     2
-#define OPLOCK_LEVEL_II  4
-#define CORE_OPLOCK_GRANTED (1<<5)
-#define EXTENDED_OPLOCK_GRANTED (1<<15)
-/*
- * Return values for oplock types.
- */
-#define NO_OPLOCK_RETURN 0
-#define EXCLUSIVE_OPLOCK_RETURN 1
-#define BATCH_OPLOCK_RETURN 2
-#define LEVEL_II_OPLOCK_RETURN 3
-/* oplock levels sent in oplock break */
-#define OPLOCK_BREAK_TO_NONE     0
-#define OPLOCK_BREAK_TO_LEVEL_II 1
-#define CMD_REPLY 0x8000
 /* The maximum length of a trust account password.
 …
 #define FS_ATTR_NAMED_STREAMS                     0x00040000
+#define smb_len(buf) (PVAL(buf,3)|(PVAL(buf,2)<<8)|(PVAL(buf,1)<<16))
+#define _smb_setlen(buf,len) do {(buf)[0] = 0; (buf)[1] = ((len)&0x10000)>>16; \
+        (buf)[2] = ((len)&0xFF00)>>8; (buf)[3] = (len)&0xFF;} while (0)
+#define _smb2_setlen(buf,len) do {(buf)[0] = 0; (buf)[1] = ((len)&0xFF0000)>>16; \
+        (buf)[2] = ((len)&0xFF00)>>8; (buf)[3] = (len)&0xFF;} while (0)
+#include "libcli/raw/trans2.h"
+#include "source4/libcli/raw/trans2.h"
 #include "libcli/raw/interfaces.h"
+#endif /* _SMB_H */
+#include "libcli/smb/smb_common.h"
+#endif /* _RAW_SMB_H */

vendor/current/source4/libcli/raw/smb_signing.c

-              r746
+              r988
+}
-/***********************************************************
- SMB signing - Common code before we set a new signing implementation
-************************************************************/
-static bool smbcli_set_smb_signing_common(struct smbcli_transport *transport)
+{
-        if (!set_smb_signing_common(&transport->negotiate.sign_info)) {
-                return false;
+        }
-        if (!(transport->negotiate.sec_mode &
-              (NEGOTIATE_SECURITY_SIGNATURES_REQUIRED|NEGOTIATE_SECURITY_SIGNATURES_ENABLED))) {
-                DEBUG(5, ("SMB Signing is not negotiated by the peer\n"));
-                return false;
+        }
-        /* These calls are INCOMPATIBLE with SMB signing */
-        transport->negotiate.readbraw_supported = false;
-        transport->negotiate.writebraw_supported = false;
-        return true;
+}
 void mark_packet_signed(struct smb_request_buffer *out)
+{
 …
+}
-static void smbcli_req_allocate_seq_num(struct smbcli_request *req)
+{
-        req->seq_num = req->transport->negotiate.sign_info.next_seq_num;
-        /* some requests (eg. NTcancel) are one way, and the sequence number
-           should be increased by 1 not 2 */
-        if (req->sign_single_increment) {
-                req->transport->negotiate.sign_info.next_seq_num += 1;
-        } else {
-                req->transport->negotiate.sign_info.next_seq_num += 2;
+        }
+}
-/***********************************************************
- SMB signing - Simple implementation - calculate a MAC to send.
-************************************************************/
-void smbcli_request_calculate_sign_mac(struct smbcli_request *req)
+{
-#if 0
-        /* enable this when packet signing is preventing you working out why valgrind
-           says that data is uninitialised */
-        file_save("pkt.dat", req->out.buffer, req->out.size);
-#endif
-        switch (req->transport->negotiate.sign_info.signing_state) {
-        case SMB_SIGNING_ENGINE_OFF:
-                break;
-        case SMB_SIGNING_ENGINE_BSRSPYL:
-                /* mark the packet as signed - BEFORE we sign it...*/
-                mark_packet_signed(&req->out);
-                /* I wonder what BSRSPYL stands for - but this is what MS
-                   actually sends! */
-                memcpy((req->out.hdr + HDR_SS_FIELD), "BSRSPYL ", 8);
-                break;
-        case SMB_SIGNING_ENGINE_ON:
-                smbcli_req_allocate_seq_num(req);
-                sign_outgoing_message(&req->out,
-                                      &req->transport->negotiate.sign_info.mac_key,
-                                      req->seq_num);
-                break;
+        }
-        return;
+}
 /**
  SMB signing - NULL implementation
 …
         return true;
+}
-/**
- SMB signing - TEMP implementation - setup the MAC key.
-*/
-bool smbcli_temp_set_signing(struct smbcli_transport *transport)
+{
-        if (!smbcli_set_smb_signing_common(transport)) {
-                return false;
+        }
-        DEBUG(5, ("BSRSPYL SMB signing enabled\n"));
-        smbcli_set_signing_off(&transport->negotiate.sign_info);
-        transport->negotiate.sign_info.mac_key = data_blob(NULL, 0);
-        transport->negotiate.sign_info.signing_state = SMB_SIGNING_ENGINE_BSRSPYL;
-        return true;
+}
-/***********************************************************
- SMB signing - Simple implementation - check a MAC sent by server.
-************************************************************/
-/**
- * Check a packet supplied by the server.
- * @return false if we had an established signing connection
- *         which had a back checksum, true otherwise
- */
-bool smbcli_request_check_sign_mac(struct smbcli_request *req)
+{
-        bool good;
-        if (!req->transport->negotiate.sign_info.doing_signing &&
-            req->sign_caller_checks) {
-                return true;
+        }
-        req->sign_caller_checks = false;
-        switch (req->transport->negotiate.sign_info.signing_state)
+        {
-        case SMB_SIGNING_ENGINE_OFF:
-                return true;
-        case SMB_SIGNING_ENGINE_BSRSPYL:
-                return true;
-        case SMB_SIGNING_ENGINE_ON:
+        {
-                if (req->in.size < (HDR_SS_FIELD + 8)) {
-                        return false;
-                } else {
-                        good = check_signed_incoming_message(&req->in,
-                                                             &req->transport->negotiate.sign_info.mac_key,
-                                                             req->seq_num+1);
-                        return signing_good(&req->transport->negotiate.sign_info,
-                                            req->seq_num+1, good);
+                }
+        }
+        }
-        return false;
+}
 /***********************************************************
 …
+}
-/***********************************************************
- SMB signing - Simple implementation - setup the MAC key.
-************************************************************/
-bool smbcli_transport_simple_set_signing(struct smbcli_transport *transport,
-                                         const DATA_BLOB user_session_key,
-                                         const DATA_BLOB response)
+{
-        if (!smbcli_set_smb_signing_common(transport)) {
-                return false;
+        }
-        return smbcli_simple_set_signing(transport,
-                                         &transport->negotiate.sign_info,
-                                         &user_session_key,
-                                         &response);
+}
-bool smbcli_init_signing(struct smbcli_transport *transport)
+{
-        transport->negotiate.sign_info.next_seq_num = 0;
-        transport->negotiate.sign_info.mac_key = data_blob(NULL, 0);
-        if (!smbcli_set_signing_off(&transport->negotiate.sign_info)) {
-                return false;
+        }
-        switch (transport->options.signing) {
-        case SMB_SIGNING_OFF:
-                transport->negotiate.sign_info.allow_smb_signing = false;
-                break;
-        case SMB_SIGNING_SUPPORTED:
-        case SMB_SIGNING_AUTO:
-                transport->negotiate.sign_info.allow_smb_signing = true;
-                break;
-        case SMB_SIGNING_REQUIRED:
-                transport->negotiate.sign_info.allow_smb_signing = true;
-                transport->negotiate.sign_info.mandatory_signing = true;
-                break;
+        }
-        return true;
+}

vendor/current/source4/libcli/raw/trans2.h

-              r414
+              r988
 #ifndef _TRANS2_H_
 #define _TRANS2_H_
-/* These are the TRANS2 sub commands */
-#define TRANSACT2_OPEN                        0
-#define TRANSACT2_FINDFIRST                   1
-#define TRANSACT2_FINDNEXT                    2
-#define TRANSACT2_QFSINFO                     3
-#define TRANSACT2_SETFSINFO                   4
-#define TRANSACT2_QPATHINFO                   5
-#define TRANSACT2_SETPATHINFO                 6
-#define TRANSACT2_QFILEINFO                   7
-#define TRANSACT2_SETFILEINFO                 8
-#define TRANSACT2_FSCTL                       9
-#define TRANSACT2_IOCTL                     0xA
-#define TRANSACT2_FINDNOTIFYFIRST           0xB
-#define TRANSACT2_FINDNOTIFYNEXT            0xC
-#define TRANSACT2_MKDIR                     0xD
-#define TRANSACT2_SESSION_SETUP             0xE
-#define TRANSACT2_GET_DFS_REFERRAL         0x10
-#define TRANSACT2_REPORT_DFS_INCONSISTANCY 0x11
 …
 #define SMB_QFS_FULL_SIZE_INFORMATION                   1007
 #define SMB_QFS_OBJECTID_INFORMATION                    1008
+#define SMB_QFS_SECTOR_SIZE_INFORMATION                 1011
 …
 #define QFS_TYPE_VIRTUAL                        0x40
+/* SMB_QFS_SECTOR_SIZE_INFORMATION values */
+#define QFS_SSINFO_FLAGS_ALIGNED_DEVICE                 0x00000001
+#define QFS_SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE    0x00000002
+#define QFS_SSINFO_FLAGS_NO_SEEK_PENALTY                0x00000004
+#define QFS_SSINFO_FLAGS_TRIM_ENABLED                   0x00000008
+#define QFS_SSINFO_OFFSET_UNKNOWN                       0xffffffff
 /*
 …
 #define SMB_QFS_MAC_FS_INFO                     0x301
-/* UNIX CIFS Extensions - created by HP */
-/*
- * UNIX CIFS Extensions have the range 0x200 - 0x2FF reserved.
- * Supposedly Microsoft have agreed to this.
- */
-#define MIN_UNIX_INFO_LEVEL 0x200
-#define MAX_UNIX_INFO_LEVEL 0x2FF
-#define INFO_LEVEL_IS_UNIX(level) (((level) >= MIN_UNIX_INFO_LEVEL) && ((level) <= MAX_UNIX_INFO_LEVEL))
-#define SMB_MODE_NO_CHANGE                 0xFFFFFFFF     /* file mode value which */
-                                              /* means "don't change it" */
-#define SMB_UID_NO_CHANGE                  0xFFFFFFFF
-#define SMB_GID_NO_CHANGE                  0xFFFFFFFF
-#define SMB_SIZE_NO_CHANGE_LO              0xFFFFFFFF
-#define SMB_SIZE_NO_CHANGE_HI              0xFFFFFFFF
-#define SMB_TIME_NO_CHANGE_LO              0xFFFFFFFF
-#define SMB_TIME_NO_CHANGE_HI              0xFFFFFFFF
-/*
-UNIX_BASIC  info level:
-Offset Size         Name
-      LARGE_INTEGER EndOfFile                File size
-      LARGE_INTEGER Blocks                   Number of bytes used on disk (st_blocks).
-     LARGE_INTEGER CreationTime             Creation time
-     LARGE_INTEGER LastAccessTime           Last access time
-     LARGE_INTEGER LastModificationTime     Last modification time
-     LARGE_INTEGER Uid                      Numeric user id for the owner
-     LARGE_INTEGER Gid                      Numeric group id of owner
-     ULONG Type                             Enumeration specifying the pathname type:
--- File
--- Directory
--- Symbolic link
--- Character device
--- Block device
--- FIFO (named pipe)
--- Unix domain socket
-     LARGE_INTEGER devmajor                 Major device number if type is device
-     LARGE_INTEGER devminor                 Minor device number if type is device
-     LARGE_INTEGER uniqueid                 This is a server-assigned unique id for the file. The client
-                                              will typically map this onto an inode number. The scope of
-                                              uniqueness is the share.
-     LARGE_INTEGER permissions              Standard UNIX file permissions  - see below.
-     LARGE_INTEGER nlinks                   The number of directory entries that map to this entry
-                                              (number of hard links)
-- end.
-*/
-/*
-SMB_QUERY_FILE_UNIX_INFO2 is SMB_QUERY_FILE_UNIX_BASIC with create
-time and file flags appended. The corresponding info level for
-findfirst/findnext is SMB_FIND_FILE_UNIX_UNIX2.
-Size    Offset  Value
----------------------
-      LARGE_INTEGER EndOfFile          File size
-      LARGE_INTEGER Blocks             Number of blocks used on disk
-     LARGE_INTEGER ChangeTime         Attribute change time
-     LARGE_INTEGER LastAccessTime           Last access time
-     LARGE_INTEGER LastModificationTime     Last modification time
-     LARGE_INTEGER Uid                Numeric user id for the owner
-     LARGE_INTEGER Gid                Numeric group id of owner
-     ULONG Type                       Enumeration specifying the file type
-     LARGE_INTEGER devmajor           Major device number if type is device
-     LARGE_INTEGER devminor           Minor device number if type is device
-     LARGE_INTEGER uniqueid           This is a server-assigned unique id
-     LARGE_INTEGER permissions        Standard UNIX permissions
-     LARGE_INTEGER nlinks             Number of hard link)
-    LARGE_INTEGER CreationTime       Create/birth time
-    ULONG FileFlags                  File flags enumeration
-    ULONG FileFlagsMask              Mask of valid flags
-*/
-/* UNIX filetype mappings. */
-#define UNIX_TYPE_FILE      0
-#define UNIX_TYPE_DIR       1
-#define UNIX_TYPE_SYMLINK   2
-#define UNIX_TYPE_CHARDEV   3
-#define UNIX_TYPE_BLKDEV    4
-#define UNIX_TYPE_FIFO      5
-#define UNIX_TYPE_SOCKET    6
-#define UNIX_TYPE_UNKNOWN   0xFFFFFFFF
-/*
- * Oh this is fun. "Standard UNIX permissions" has no
- * meaning in POSIX. We need to define the mapping onto
- * and off the wire as this was not done in the original HP
- * spec. JRA.
- */
-#define UNIX_X_OTH                      0000001
-#define UNIX_W_OTH                      0000002
-#define UNIX_R_OTH                      0000004
-#define UNIX_X_GRP                      0000010
-#define UNIX_W_GRP                      0000020
-#define UNIX_R_GRP                      0000040
-#define UNIX_X_USR                      0000100
-#define UNIX_W_USR                      0000200
-#define UNIX_R_USR                      0000400
-#define UNIX_STICKY                     0001000
-#define UNIX_SET_GID                    0002000
-#define UNIX_SET_UID                    0004000
-/* Masks for the above */
-#define UNIX_OTH_MASK                   0000007
-#define UNIX_GRP_MASK                   0000070
-#define UNIX_USR_MASK                   0000700
-#define UNIX_PERM_MASK                  0000777
-#define UNIX_EXTRA_MASK                 0007000
-#define UNIX_ALL_MASK                   0007777
-/* Flags for the file_flags field in UNIX_INFO2: */
-#define EXT_SECURE_DELETE               0x00000001
-#define EXT_ENABLE_UNDELETE             0x00000002
-#define EXT_SYNCHRONOUS                 0x00000004
-#define EXT_IMMUTABLE                   0x00000008
-#define EXT_OPEN_APPEND_ONLY            0x00000010
-#define EXT_DO_NOT_BACKUP               0x00000020
-#define EXT_NO_UPDATE_ATIME             0x00000040
-#define EXT_HIDDEN                      0x00000080
-#define SMB_QFILEINFO_UNIX_LINK         0x201
-#define SMB_SFILEINFO_UNIX_LINK         0x201
-#define SMB_SFILEINFO_UNIX_HLINK        0x203
-/*
- Info level for QVOLINFO - returns version of CIFS UNIX extensions, plus
--bits worth of capability fun :-).
-*/
-#define SMB_QUERY_CIFS_UNIX_INFO      0x200
-/* Returns the following.
-  UINT16             major version number
-  UINT16             minor version number
-  LARGE_INTEGER      capability bitfield
-*/
-#define CIFS_UNIX_MAJOR_VERSION 1
-#define CIFS_UNIX_MINOR_VERSION 0
-#define CIFS_UNIX_FCNTL_LOCKS_CAP           0x1
-#define CIFS_UNIX_POSIX_ACLS_CAP            0x2
-/* ... more as we think of them :-). */
 #endif

vendor/current/source4/libcli/resolve/bcast.c

-              r740
+              r988
         struct resolve_bcast_data *data = talloc_get_type(userdata, struct resolve_bcast_data);
         num_interfaces = iface_count(data->ifaces);
+        num_interfaces = iface_list_count(data->ifaces);
         address_list = talloc_array(mem_ctx, const char *, num_interfaces+1);
 …
         for (i=0;i<num_interfaces;i++) {
+                const char *bcast = iface_n_bcast(data->ifaces, i);
+                if (bcast == NULL) continue;
+                bool ipv4 = iface_list_n_is_v4(data->ifaces, i);
+                const char *bcast;
+                if (!ipv4) {
+                        continue;
+                }
+                bcast = iface_list_n_bcast(data->ifaces, i);
+                if (bcast == NULL) {
+                        continue;
+                }
                 address_list[count] = talloc_strdup(address_list, bcast);
                 if (address_list[count] == NULL) {
 …
+{
         struct interface *ifaces;
         load_interfaces(ctx, lpcfg_interfaces(lp_ctx), &ifaces);
+        load_interface_list(ctx, lp_ctx, &ifaces);
         return resolve_context_add_bcast_method(ctx, ifaces, lpcfg_nbt_port(lp_ctx), lpcfg_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
+}

vendor/current/source4/libcli/resolve/dns_ex.c

-              r740
+              r988
    Copyright (C) Andrew Tridgell 2005
    Copyright (C) Stefan Metzmacher 2008
+   Copyright (C) Matthieu Patou 2011
    This program is free software; you can redistribute it and/or modify
 …
 #include "librpc/gen_ndr/ndr_nbt.h"
 #include "libcli/resolve/resolve.h"
+#ifdef class
+#undef class
+#endif
+#include "heimdal/lib/roken/resolve.h"
+#include "lib/util/util_net.h"
+#include "lib/addns/dnsquery.h"
+#include "lib/addns/dns.h"
+#include <arpa/nameser.h>
+#include <resolv.h>
 struct dns_ex_state {
 …
+}
+struct dns_records_container {
+        char **list;
+        uint32_t count;
+};
+static int reply_to_addrs(TALLOC_CTX *mem_ctx, uint32_t *a_num,
+                          char ***cur_addrs, uint32_t total,
+                          struct dns_request *reply, int port)
+{
+        char addrstr[INET6_ADDRSTRLEN];
+        struct dns_rrec *rr;
+        char **addrs;
+        uint32_t i;
+        const char *addr;
+        /* at most we over-allocate here, but not by much */
+        addrs = talloc_realloc(mem_ctx, *cur_addrs, char *,
+                                total + reply->num_answers);
+        if (!addrs) {
+                return 0;
+        }
+        *cur_addrs = addrs;
+        for (i = 0; i < reply->num_answers; i++) {
+                rr = reply->answers[i];
+                /* we are only interested in the IN class */
+                if (rr->r_class != DNS_CLASS_IN) {
+                        continue;
+                }
+                if (rr->type == QTYPE_NS) {
+                        /*
+                         * After the record for NS will come the A or AAAA
+                         * record of the NS.
+                         */
+                        break;
+                }
+                /* verify we actually have a record here */
+                if (!rr->data) {
+                        continue;
+                }
+                /* we are only interested in A and AAAA records */
+                switch (rr->type) {
+                case QTYPE_A:
+                        addr = inet_ntop(AF_INET,
+                                         (struct in_addr *)rr->data,
+                                         addrstr, sizeof(addrstr));
+                        if (addr == NULL) {
+                                continue;
+                        }
+                        break;
+                case QTYPE_AAAA:
+#ifdef HAVE_IPV6
+                        addr = inet_ntop(AF_INET6,
+                                         (struct in6_addr *)rr->data,
+                                         addrstr, sizeof(addrstr));
+#else
+                        addr = NULL;
+#endif
+                        if (addr == NULL) {
+                                continue;
+                        }
+                        break;
+                default:
+                        continue;
+                }
+                addrs[total] = talloc_asprintf(addrs, "%s@%u/%s",
+                                                addrstr, port,
+                                                rr->name->pLabelList->label);
+                if (addrs[total]) {
+                        total++;
+                        if (rr->type == QTYPE_A) {
+                                (*a_num)++;
+                        }
+                }
+        }
+        return total;
+}
+static DNS_ERROR dns_lookup(TALLOC_CTX *mem_ctx, const char* name,
+                            uint16_t q_type, struct dns_request **reply)
+{
+        int len, rlen;
+        uint8_t *answer;
+        bool loop;
+        struct dns_buffer buf;
+        DNS_ERROR err;
+        /* give space for a good sized answer by default */
+        answer = NULL;
+        len = 1500;
+        do {
+                answer = talloc_realloc(mem_ctx, answer, uint8_t, len);
+                if (!answer) {
+                        return ERROR_DNS_NO_MEMORY;
+                }
+                rlen = res_search(name, DNS_CLASS_IN, q_type, answer, len);
+                if (rlen == -1) {
+                        if (len >= 65535) {
+                                return ERROR_DNS_SOCKET_ERROR;
+                        }
+                        /* retry once with max packet size */
+                        len = 65535;
+                        loop = true;
+                } else if (rlen > len) {
+                        len = rlen;
+                        loop = true;
+                } else {
+                        loop = false;
+                }
+        } while(loop);
+        buf.data = answer;
+        buf.size = rlen;
+        buf.offset = 0;
+        buf.error = ERROR_DNS_SUCCESS;
+        err = dns_unmarshall_request(mem_ctx, &buf, reply);
+        TALLOC_FREE(answer);
+        return err;
+}
+static struct dns_records_container get_a_aaaa_records(TALLOC_CTX *mem_ctx,
+                                                        const char* name,
+                                                        int port)
+{
+        struct dns_request *reply;
+        struct dns_records_container ret;
+        char **addrs = NULL;
+        uint32_t a_num, total;
+        uint16_t qtype;
+        TALLOC_CTX *tmp_ctx;
+        DNS_ERROR err;
+        memset(&ret, 0, sizeof(struct dns_records_container));
+        tmp_ctx = talloc_new(mem_ctx);
+        if (!tmp_ctx) {
+                return ret;
+        }
+        qtype = QTYPE_AAAA;
+        /* this is the blocking call we are going to lots of trouble
+           to avoid them in the parent */
+        err = dns_lookup(tmp_ctx, name, qtype, &reply);
+        if (!ERR_DNS_IS_OK(err)) {
+                qtype = QTYPE_A;
+                err = dns_lookup(tmp_ctx, name, qtype, &reply);
+                if (!ERR_DNS_IS_OK(err)) {
+                        goto done;
+                }
+        }
+        a_num = total = 0;
+        total = reply_to_addrs(tmp_ctx, &a_num, &addrs, total, reply, port);
+        if (qtype == QTYPE_AAAA && a_num == 0) {
+                /*
+                * DNS server didn't returned A when asked for AAAA records.
+                * Most of the server do it, let's ask for A specificaly.
+                */
+                err = dns_lookup(tmp_ctx, name, QTYPE_A, &reply);
+                if (!ERR_DNS_IS_OK(err)) {
+                        goto done;
+                }
+                total = reply_to_addrs(tmp_ctx, &a_num, &addrs, total,
+                                        reply, port);
+        }
+        if (total) {
+                talloc_steal(mem_ctx, addrs);
+                ret.count = total;
+                ret.list = addrs;
+        }
+done:
+        TALLOC_FREE(tmp_ctx);
+        return ret;
+}
+static struct dns_records_container get_srv_records(TALLOC_CTX *mem_ctx,
+                                                        const char* name)
+{
+        struct dns_records_container ret;
+        char **addrs = NULL;
+        struct dns_rr_srv *dclist;
+        NTSTATUS status;
+        uint32_t total;
+        unsigned i;
+        int count;
+        memset(&ret, 0, sizeof(struct dns_records_container));
+        /* this is the blocking call we are going to lots of trouble
+           to avoid them in the parent */
+        status = ads_dns_lookup_srv(mem_ctx, name, &dclist, &count);
+        if (!NT_STATUS_IS_OK(status)) {
+                return ret;
+        }
+        total = 0;
+        if (count == 0) {
+                return ret;
+        }
+        /* Loop over all returned records and pick the records */
+        for (i = 0; i < count; i++) {
+                struct dns_records_container c;
+                const char* tmp_str;
+                tmp_str = dclist[i].hostname;
+                if (strchr(tmp_str, '.') && tmp_str[strlen(tmp_str)-1] != '.') {
+                        /* we are asking for a fully qualified name, but the
+                        name doesn't end in a '.'. We need to prevent the
+                        DNS library trying the search domains configured in
+                        resolv.conf */
+                        tmp_str = talloc_asprintf(mem_ctx, "%s.", tmp_str);
+                }
+                c = get_a_aaaa_records(mem_ctx, tmp_str, dclist[i].port);
+                total += c.count;
+                if (addrs == NULL) {
+                        addrs = c.list;
+                } else {
+                        unsigned j;
+                        addrs = talloc_realloc(mem_ctx, addrs, char*, total);
+                        for (j=0; j < c.count; j++) {
+                                addrs[total - j - 1] = talloc_steal(addrs, c.list[j]);
+                        }
+                }
+        }
+        if (total) {
+                ret.count = total;
+                ret.list = addrs;
+        }
+        return ret;
+}
 /*
   the blocking child
 …
 static void run_child_dns_lookup(struct dns_ex_state *state, int fd)
+{
-        struct rk_dns_reply *reply;
-        struct rk_resource_record *rr;
-        uint32_t count = 0;
-        uint32_t srv_valid = 0;
-        struct rk_resource_record **srv_rr;
-        uint32_t addrs_valid = 0;
-        struct rk_resource_record **addrs_rr;
-        char *addrs;
         bool first;
-        uint32_t i;
         bool do_srv = (state->flags & RESOLVE_NAME_FLAG_DNS_SRV);
+        struct dns_records_container c;
+        char* addrs = NULL;
+        unsigned int i;
         if (strchr(state->name.name, '.') && state->name.name[strlen(state->name.name)-1] != '.') {
 …
+        }
-        /* this is the blocking call we are going to lots of trouble
-           to avoid in the parent */
-        reply = rk_dns_lookup(state->name.name, do_srv?"SRV":"A");
-        if (!reply) {
-                goto done;
+        }
         if (do_srv) {
+                rk_dns_srv_order(reply);
+        }
+        /* Loop over all returned records and pick the "srv" records */
+        for (rr=reply->head; rr; rr=rr->next) {
+                /* we are only interested in the IN class */
+                if (rr->class != rk_ns_c_in) {
+                        continue;
+                }
+                if (do_srv) {
+                        /* we are only interested in SRV records */
+                        if (rr->type != rk_ns_t_srv) {
+                                continue;
+                        }
+                        /* verify we actually have a SRV record here */
+                        if (!rr->u.srv) {
+                                continue;
+                        }
+                        /* Verify we got a port */
+                        if (rr->u.srv->port == 0) {
+                                continue;
+                        }
+                } else {
+                        /* we are only interested in A records */
+                        /* TODO: add AAAA support */
+                        if (rr->type != rk_ns_t_a) {
+                                continue;
+                        }
+                        /* verify we actually have a A record here */
+                        if (!rr->u.a) {
+                                continue;
+                        }
+                }
+                count++;
+        }
+        if (count == 0) {
+                goto done;
+        }
+        srv_rr = talloc_zero_array(state,
+                                   struct rk_resource_record *,
+                                   count);
+        if (!srv_rr) {
+                goto done;
+        }
+        addrs_rr = talloc_zero_array(state,
+                                     struct rk_resource_record *,
+                                     count);
+        if (!addrs_rr) {
+                goto done;
+        }
+        /* Loop over all returned records and pick the records */
+        for (rr=reply->head;rr;rr=rr->next) {
+                /* we are only interested in the IN class */
+                if (rr->class != rk_ns_c_in) {
+                        continue;
+                }
+                if (do_srv) {
+                        /* we are only interested in SRV records */
+                        if (rr->type != rk_ns_t_srv) {
+                                continue;
+                        }
+                        /* verify we actually have a srv record here */
+                        if (!rr->u.srv) {
+                                continue;
+                        }
+                        /* Verify we got a port */
+                        if (rr->u.srv->port == 0) {
+                                continue;
+                        }
+                        srv_rr[srv_valid] = rr;
+                        srv_valid++;
+                } else {
+                        /* we are only interested in A records */
+                        /* TODO: add AAAA support */
+                        if (rr->type != rk_ns_t_a) {
+                                continue;
+                        }
+                        /* verify we actually have a A record here */
+                        if (!rr->u.a) {
+                                continue;
+                        }
+                        addrs_rr[addrs_valid] = rr;
+                        addrs_valid++;
+                }
+        }
+        for (i=0; i < srv_valid; i++) {
+                for (rr=reply->head;rr;rr=rr->next) {
+                        if (rr->class != rk_ns_c_in) {
+                                continue;
+                        }
+                        /* we are only interested in A records */
+                        if (rr->type != rk_ns_t_a) {
+                                continue;
+                        }
+                        /* verify we actually have a srv record here */
+                        if (strcmp(&srv_rr[i]->u.srv->target[0], rr->domain) != 0) {
+                                continue;
+                        }
+                        addrs_rr[i] = rr;
+                        addrs_valid++;
+                        break;
+                }
+        }
+        if (addrs_valid == 0) {
+                c = get_srv_records(state, state->name.name);
+        } else {
+                c = get_a_aaaa_records(state, state->name.name, state->port);
+        }
+        /* This line in critical - if we return without writing to the
+         * pipe, this is the signal that the name did not exist */
+        if (c.count == 0) {
                 goto done;
+        }
 …
+        }
         first = true;
+        for (i=0; i < count; i++) {
+                uint16_t port;
+                if (!addrs_rr[i]) {
+                        continue;
+                }
+                if (srv_rr[i] &&
+                    (state->flags & RESOLVE_NAME_FLAG_OVERWRITE_PORT)) {
+                        port = srv_rr[i]->u.srv->port;
+                } else {
+                        port = state->port;
+                }
+                addrs = talloc_asprintf_append_buffer(addrs, "%s%s:%u/%s",
+                                                      first?"":",",
+                                                      inet_ntoa(*addrs_rr[i]->u.a),
+                                                      port,
+                                                      addrs_rr[i]->domain);
+                if (!addrs) {
+                        goto done;
+                }
+        for (i=0; i < c.count; i++) {
+                addrs = talloc_asprintf_append_buffer(addrs, "%s%s",
+                                                        first?"":",",
+                                                        c.list[i]);
                 first = false;
+        }
         if (addrs) {
+                DEBUG(11, ("Addrs = %s\n", addrs));
                 write(fd, addrs, talloc_get_size(addrs));
+        }
 …
         ZERO_STRUCT(hints);
         hints.ai_socktype = SOCK_STREAM;
-        hints.ai_family = AF_INET;/* TODO: add AF_INET6 support */
         hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
 …
                 case EAI_NODATA:
 #endif
+                case EAI_FAIL:
+                        /* Linux returns EAI_NODATA on non-RFC1034-compliant names. FreeBSD returns EAI_FAIL */
                 case EAI_NONAME:
                         /* getaddrinfo() doesn't handle CNAME records */
+                        /* getaddrinfo() doesn't handle CNAME or non-RFC1034 compatible records */
                         run_child_dns_lookup(state, fd);
                         return;
 …
         first = true;
         for (res = res_list; res; res = res->ai_next) {
+                struct sockaddr_in *in;
+                if (res->ai_family != AF_INET) {
+                char addrstr[INET6_ADDRSTRLEN];
+                if (!print_sockaddr_len(addrstr, sizeof(addrstr), (struct sockaddr *)res->ai_addr, res->ai_addrlen)) {
                         continue;
+                }
+                in = (struct sockaddr_in *)res->ai_addr;
+                addrs = talloc_asprintf_append_buffer(addrs, "%s%s:%u/%s",
+                addrs = talloc_asprintf_append_buffer(addrs, "%s%s@%u/%s",
                                                       first?"":",",
                                                       inet_ntoa(in->sin_addr),
+                                                      addrstr,
                                                       state->port,
                                                       state->name.name);
 …
         if (ret <= 0) {
+                /* The check for ret == 0 here is important, if the
+                 * name does not exist, then no bytes are written to
+                 * the pipe */
                 DEBUG(3,("dns child failed to find name '%s' of type %s\n",
                          state->name.name, (state->flags & RESOLVE_NAME_FLAG_DNS_SRV)?"SRV":"A"));
 …
+        }
         /* enusre the address looks good */
+        /* ensure the address looks good */
         address[ret] = 0;
 …
         for (i=0; i < num_addrs; i++) {
                 uint32_t port = 0;
                 char *p = strrchr(addrs[i], ':');
+                char *p = strrchr(addrs[i], '@');
                 char *n;
 …
                 n++;
+                if (strcmp(addrs[i], "0.0.0.0") == 0 ||
+                    inet_addr(addrs[i]) == INADDR_NONE) {
+                if (strcmp(addrs[i], "0.0.0.0") == 0) {
                         composite_error(c, NT_STATUS_OBJECT_NAME_NOT_FOUND);
                         return;
 …
+                }
                 state->addrs[i] = socket_address_from_strings(state->addrs,
                                                               "ipv4",
+                                                              "ip",
                                                               addrs[i],
                                                               port);
 …
         ret = pipe(fd);
         if (ret == -1) {
                 composite_error(c, map_nt_error_from_unix(errno));
+                composite_error(c, map_nt_error_from_unix_common(errno));
                 return c;
+        }
 …
         /* we need to put the child in our event context so
            we know when the dns_lookup() has finished */
         state->fde = event_add_fd(c->event_ctx, c, state->child_fd, EVENT_FD_READ,
+        state->fde = tevent_add_fd(c->event_ctx, c, state->child_fd, TEVENT_FD_READ,
                                   pipe_handler, c);
         if (composite_nomem(state->fde, c)) {
 …
         state->child = fork();
         if (state->child == (pid_t)-1) {
                 composite_error(c, map_nt_error_from_unix(errno));
+                composite_error(c, map_nt_error_from_unix_common(errno));
                 return c;
+        }

vendor/current/source4/libcli/resolve/nbtlist.c

r740	r988
112	112	uint16_t port,
113	113	struct nbt_name *name,
114		const char **address_list,
	114	const char * const *address_list,
115	115	struct interface *ifaces,
116	116	uint16_t nbt_port,

vendor/current/source4/libcli/resolve/resolve.c

-              r740
+              r988
         method->recv_fn = recv_fn;
         method->privdata = userdata;
         DLIST_ADD_END(ctx->methods, method, struct resolve_method *);
+        DLIST_ADD_END(ctx->methods, method);
         return true;
+}
 …
         if (is_ipaddress(state->name.name) ||
             strcasecmp(state->name.name, "localhost") == 0) {
-                struct in_addr ip = interpret_addr2(state->name.name);
                 state->addrs = talloc_array(state, struct socket_address *, 2);
                 if (composite_nomem(state->addrs, c)) return c;
                 state->addrs[0] = socket_address_from_strings(state->addrs, "ipv4",
                                                               inet_ntoa(ip), 0);
+                state->addrs[0] = socket_address_from_strings(state->addrs, "ip",
+                                                              state->name.name, 0);
                 if (composite_nomem(state->addrs[0], c)) return c;
                 state->addrs[1] = NULL;
 …
-/*
-  general name resolution - sync call
- */
-NTSTATUS resolve_name(struct resolve_context *ctx,
-                      struct nbt_name *name,
-                      TALLOC_CTX *mem_ctx,
-                      const char **reply_addr,
-                      struct tevent_context *ev)
+{
-        return resolve_name_ex(ctx, 0, 0, name, mem_ctx, reply_addr, ev);
+}
 /* Initialise a struct nbt_name with a NULL scope */

vendor/current/source4/libcli/resolve/resolve_lp.c

-              r740
+              r988
         for (i = 0; methods != NULL && methods[i] != NULL; i++) {
                 if (!strcmp(methods[i], "wins")) {
+                        resolve_context_add_wins_method_lp(ret, lp_ctx);
+                        if (lpcfg_disable_netbios(lp_ctx) == false) {
+                                resolve_context_add_wins_method_lp(ret, lp_ctx);
+                        }
                 } else if (!strcmp(methods[i], "bcast")) {
+                        resolve_context_add_bcast_method_lp(ret, lp_ctx);
+                } else if (!strcmp(methods[i], "file")) {
+                        resolve_context_add_file_method_lp(ret, lp_ctx);
+                        if (lpcfg_disable_netbios(lp_ctx) == false) {
+                                resolve_context_add_bcast_method_lp(ret, lp_ctx);
+                        }
+                } else if (!strcmp(methods[i], "lmhosts")) {
+                        resolve_context_add_lmhosts_method(ret);
                 } else if (!strcmp(methods[i], "host")) {
                         resolve_context_add_host_method(ret);

vendor/current/source4/libcli/resolve/testsuite.c

r740	r988
24	24	#include "libcli/resolve/resolve.h"
25	25	#include "torture/torture.h"
	26	#include "torture/local/proto.h"
26	27	#include "system/network.h"
27	28	#include "lib/util/util_net.h"

vendor/current/source4/libcli/resolve/wins.c

-              r740
+              r988
 struct resolve_wins_data {
         const char **address_list;
+        char **address_list;
         struct interface *ifaces;
         uint16_t nbt_port;
 …
         if (wins_data->address_list == NULL) return NULL;
         return resolve_name_nbtlist_send(mem_ctx, event_ctx, flags, port, name,
+                                         wins_data->address_list, wins_data->ifaces,
+                                         (const char * const *)wins_data->address_list,
+                                         wins_data->ifaces,
                                          wins_data->nbt_port, wins_data->nbt_timeout,
                                          false, true);
 …
+{
         struct resolve_wins_data *wins_data = talloc(ctx, struct resolve_wins_data);
         wins_data->address_list = (const char **)str_list_copy(wins_data, address_list);
+        wins_data->address_list = str_list_copy(wins_data, address_list);
         wins_data->ifaces = talloc_reference(wins_data, ifaces);
         wins_data->nbt_port = nbt_port;
 …
+{
         struct interface *ifaces;
         load_interfaces(ctx, lpcfg_interfaces(lp_ctx), &ifaces);
+        load_interface_list(ctx, lp_ctx, &ifaces);
         return resolve_context_add_wins_method(ctx, lpcfg_wins_server_list(lp_ctx), ifaces, lpcfg_nbt_port(lp_ctx), lpcfg_parm_int(lp_ctx, NULL, "nbt", "timeout", 1));
+}

vendor/current/source4/libcli/security/tests/sddl.c

r740	r988
23	23	#include "libcli/security/security.h"
24	24	#include "torture/torture.h"
	25	#include "torture/local/proto.h"
25	26	#include "librpc/gen_ndr/ndr_security.h"
26	27

vendor/current/source4/libcli/smb2/cancel.c

-              r740
+              r988
 #include "includes.h"
+#include <tevent.h>
 #include "libcli/raw/libcliraw.h"
 #include "libcli/smb2/smb2.h"
 …
 NTSTATUS smb2_cancel(struct smb2_request *r)
+{
+        NTSTATUS status;
+        struct smb2_request *c;
+        uint32_t old_timeout;
+        uint64_t old_seqnum;
+        bool ok;
+        /*
+         * if we don't get a pending id yet, we just
+         * mark the request for pending, so that we directly
+         * send the cancel after getting the pending id
+         */
+        if (!r->cancel.can_cancel) {
+                r->cancel.do_cancel++;
+        if (r->subreq == NULL) {
                 return NT_STATUS_OK;
+        }
+        /* we don't want a seqmun for a SMB2 Cancel */
+        old_seqnum = r->transport->seqnum;
+        c = smb2_request_init(r->transport, SMB2_OP_CANCEL, 0x04, false, 0);
+        r->transport->seqnum = old_seqnum;
+        NT_STATUS_HAVE_NO_MEMORY(c);
+        c->seqnum = 0;
+        SIVAL(c->out.hdr, SMB2_HDR_FLAGS,       0x00000002);
+        SSVAL(c->out.hdr, SMB2_HDR_CREDIT,      0x0030);
+        SBVAL(c->out.hdr, SMB2_HDR_ASYNC_ID,    r->cancel.async_id);
+        SBVAL(c->out.hdr, SMB2_HDR_MESSAGE_ID,  c->seqnum);
+        if (r->session) {
+                SBVAL(c->out.hdr, SMB2_HDR_SESSION_ID,  r->session->uid);
+        ok = tevent_req_cancel(r->subreq);
+        if (!ok) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        SSVAL(c->out.body, 0x02, 0);
+        old_timeout = c->transport->options.request_timeout;
+        c->transport->options.request_timeout = 0;
+        smb2_transport_send(c);
+        c->transport->options.request_timeout = old_timeout;
+        if (c->state == SMB2_REQUEST_ERROR) {
+                status = c->status;
+        } else {
+                status = NT_STATUS_OK;
+        }
+        talloc_free(c);
+        return status;
+        return NT_STATUS_OK;
+}

vendor/current/source4/libcli/smb2/connect.c

-              r414
+              r988
 #include "includes.h"
+#include <tevent.h>
+#include "lib/util/tevent_ntstatus.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
 …
 #include "libcli/resolve/resolve.h"
 #include "param/param.h"
+#include "auth/credentials/credentials.h"
+#include "../libcli/smb/smbXcli_base.h"
 struct smb2_connect_state {
+        struct tevent_context *ev;
         struct cli_credentials *credentials;
+        uint64_t previous_session_id;
         struct resolve_context *resolve_ctx;
         const char *host;
         const char *share;
+        const char *unc;
         const char **ports;
         const char *socket_options;
+        struct nbt_name calling, called;
         struct gensec_settings *gensec_settings;
         struct smbcli_options options;
+        struct smb2_negprot negprot;
+        struct smb2_tree_connect tcon;
+        struct smb2_transport *transport;
         struct smb2_session *session;
         struct smb2_tree *tree;
 };
+/*
+  continue after tcon reply
+*/
+static void continue_tcon(struct smb2_request *req)
+{
+        struct composite_context *c = talloc_get_type(req->async.private_data,
+                                                      struct composite_context);
+        struct smb2_connect_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_connect_state);
+        c->status = smb2_tree_connect_recv(req, &state->tcon);
+        if (!composite_is_ok(c)) return;
+        state->tree->tid = state->tcon.out.tid;
+        composite_done(c);
+}
+/*
+  continue after a session setup
+*/
+static void continue_session(struct composite_context *creq)
+{
+        struct composite_context *c = talloc_get_type(creq->async.private_data,
+                                                      struct composite_context);
+        struct smb2_connect_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_connect_state);
+        struct smb2_request *req;
+        c->status = smb2_session_setup_spnego_recv(creq);
+        if (!composite_is_ok(c)) return;
+        state->tree = smb2_tree_init(state->session, state, true);
+        if (composite_nomem(state->tree, c)) return;
+        state->tcon.in.reserved = 0;
+        state->tcon.in.path     = talloc_asprintf(state, "\\\\%s\\%s",
+                                                  state->host, state->share);
+        if (composite_nomem(state->tcon.in.path, c)) return;
+        req = smb2_tree_connect_send(state->tree, &state->tcon);
+        if (composite_nomem(req, c)) return;
+        req->async.fn = continue_tcon;
+        req->async.private_data = c;
+}
+/*
+  continue after negprot reply
+*/
+static void continue_negprot(struct smb2_request *req)
+{
+        struct composite_context *c = talloc_get_type(req->async.private_data,
+                                                      struct composite_context);
+        struct smb2_connect_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_connect_state);
+        struct smb2_transport *transport = req->transport;
+        struct composite_context *creq;
+        c->status = smb2_negprot_recv(req, c, &state->negprot);
+        if (!composite_is_ok(c)) return;
+        transport->negotiate.secblob = state->negprot.out.secblob;
+        talloc_steal(transport, transport->negotiate.secblob.data);
+        transport->negotiate.system_time = state->negprot.out.system_time;
+        transport->negotiate.server_start_time = state->negprot.out.server_start_time;
+        transport->negotiate.security_mode = state->negprot.out.security_mode;
+        transport->negotiate.dialect_revision = state->negprot.out.dialect_revision;
+        switch (transport->options.signing) {
+        case SMB_SIGNING_OFF:
+                if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
+                        composite_error(c, NT_STATUS_ACCESS_DENIED);
+                        return;
+                }
+                transport->signing_required = false;
+                break;
+        case SMB_SIGNING_SUPPORTED:
+                if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) {
+                        transport->signing_required = true;
+                } else {
+                        transport->signing_required = false;
+                }
+                break;
+        case SMB_SIGNING_AUTO:
+                if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_ENABLED) {
+                        transport->signing_required = true;
+                } else {
+                        transport->signing_required = false;
+                }
+                break;
+        case SMB_SIGNING_REQUIRED:
+                if (transport->negotiate.security_mode & SMB2_NEGOTIATE_SIGNING_ENABLED) {
+                        transport->signing_required = true;
+                } else {
+                        composite_error(c, NT_STATUS_ACCESS_DENIED);
+                        return;
+                }
+                break;
+        }
+        state->session = smb2_session_init(transport, state->gensec_settings, state, true);
+        if (composite_nomem(state->session, c)) return;
+        creq = smb2_session_setup_spnego_send(state->session, state->credentials);
+        composite_continue(c, creq, continue_session, c);
+}
+/*
+  continue after a socket connect completes
+*/
+static void continue_socket(struct composite_context *creq)
+{
+        struct composite_context *c = talloc_get_type(creq->async.private_data,
+                                                      struct composite_context);
+        struct smb2_connect_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_connect_state);
+        struct smbcli_socket *sock;
+        struct smb2_transport *transport;
+        struct smb2_request *req;
+        uint16_t dialects[3] = {
+                SMB2_DIALECT_REVISION_000,
+                SMB2_DIALECT_REVISION_202,
+                SMB2_DIALECT_REVISION_210
+        };
+        c->status = smbcli_sock_connect_recv(creq, state, &sock);
+        if (!composite_is_ok(c)) return;
+        transport = smb2_transport_init(sock, state, &state->options);
+        if (composite_nomem(transport, c)) return;
+        ZERO_STRUCT(state->negprot);
+        state->negprot.in.dialect_count = sizeof(dialects) / sizeof(dialects[0]);
+        switch (transport->options.signing) {
+        case SMB_SIGNING_OFF:
+                state->negprot.in.security_mode = 0;
+                break;
+        case SMB_SIGNING_SUPPORTED:
+        case SMB_SIGNING_AUTO:
+                state->negprot.in.security_mode = SMB2_NEGOTIATE_SIGNING_ENABLED;
+                break;
+        case SMB_SIGNING_REQUIRED:
+                state->negprot.in.security_mode =
+                        SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED;
+                break;
+        }
+        state->negprot.in.capabilities  = 0;
+        unix_to_nt_time(&state->negprot.in.start_time, time(NULL));
+        state->negprot.in.dialects = dialects;
+        req = smb2_negprot_send(transport, &state->negprot);
+        if (composite_nomem(req, c)) return;
+        req->async.fn = continue_negprot;
+        req->async.private_data = c;
+}
+/*
+  continue after a resolve finishes
+*/
+static void continue_resolve(struct composite_context *creq)
+{
+        struct composite_context *c = talloc_get_type(creq->async.private_data,
+                                                      struct composite_context);
+        struct smb2_connect_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_connect_state);
+        const char *addr;
+        const char **ports;
+        const char *default_ports[] = { "445", NULL };
+        c->status = resolve_name_recv(creq, state, &addr);
+        if (!composite_is_ok(c)) return;
+        if (state->ports == NULL) {
+                ports = default_ports;
+        } else {
+                ports = state->ports;
+        }
+        creq = smbcli_sock_connect_send(state, addr, ports, state->host, state->resolve_ctx, c->event_ctx, state->socket_options);
+        composite_continue(c, creq, continue_socket, c);
+}
+static void smb2_connect_socket_done(struct composite_context *creq);
 /*
 …
   a connected smb2_tree
  */
+struct composite_context *smb2_connect_send(TALLOC_CTX *mem_ctx,
+                                            const char *host,
+                                                const char **ports,
+                                            const char *share,
+                                            struct resolve_context *resolve_ctx,
+                                            struct cli_credentials *credentials,
+                                            struct tevent_context *ev,
+                                            struct smbcli_options *options,
+                                                const char *socket_options,
+                                                struct gensec_settings *gensec_settings)
+{
+        struct composite_context *c;
+struct tevent_req *smb2_connect_send(TALLOC_CTX *mem_ctx,
+                                     struct tevent_context *ev,
+                                     const char *host,
+                                     const char **ports,
+                                     const char *share,
+                                     struct resolve_context *resolve_ctx,
+                                     struct cli_credentials *credentials,
+                                     uint64_t previous_session_id,
+                                     const struct smbcli_options *options,
+                                     const char *socket_options,
+                                     struct gensec_settings *gensec_settings)
+{
+        struct tevent_req *req;
         struct smb2_connect_state *state;
-        struct nbt_name name;
         struct composite_context *creq;
+        c = composite_create(mem_ctx, ev);
+        if (c == NULL) return NULL;
+        state = talloc(c, struct smb2_connect_state);
+        if (composite_nomem(state, c)) return c;
+        c->private_data = state;
+        static const char *default_ports[] = { "445", "139", NULL };
+        req = tevent_req_create(mem_ctx, &state,
+                                struct smb2_connect_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
         state->credentials = credentials;
+        state->previous_session_id = previous_session_id;
         state->options = *options;
+        state->host = talloc_strdup(c, host);
+        if (composite_nomem(state->host, c)) return c;
+        state->ports = talloc_reference(state, ports);
+        state->share = talloc_strdup(c, share);
+        if (composite_nomem(state->share, c)) return c;
+        state->resolve_ctx = talloc_reference(state, resolve_ctx);
+        state->socket_options = talloc_reference(state, socket_options);
+        state->gensec_settings = talloc_reference(state, gensec_settings);
+        ZERO_STRUCT(name);
+        name.name = host;
+        creq = resolve_name_send(resolve_ctx, state, &name, c->event_ctx);
+        composite_continue(c, creq, continue_resolve, c);
+        return c;
+}
+/*
+  receive a connect reply
+*/
+NTSTATUS smb2_connect_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+        state->host = host;
+        state->ports = ports;
+        state->share = share;
+        state->resolve_ctx = resolve_ctx;
+        state->socket_options = socket_options;
+        state->gensec_settings = gensec_settings;
+        if (state->ports == NULL) {
+                state->ports = default_ports;
+        }
+        make_nbt_name_client(&state->calling,
+                             cli_credentials_get_workstation(credentials));
+        nbt_choose_called_name(state, &state->called,
+                               host, NBT_NAME_SERVER);
+        state->unc = talloc_asprintf(state, "\\\\%s\\%s",
+                                    state->host, state->share);
+        if (tevent_req_nomem(state->unc, req)) {
+                return tevent_req_post(req, ev);
+        }
+        creq = smbcli_sock_connect_send(state, NULL, state->ports,
+                                        state->host, state->resolve_ctx,
+                                        state->ev, state->socket_options,
+                                        &state->calling,
+                                        &state->called);
+        if (tevent_req_nomem(creq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        creq->async.fn = smb2_connect_socket_done;
+        creq->async.private_data = req;
+        return req;
+}
+static void smb2_connect_negprot_done(struct tevent_req *subreq);
+static void smb2_connect_socket_done(struct composite_context *creq)
+{
+        struct tevent_req *req =
+                talloc_get_type_abort(creq->async.private_data,
+                struct tevent_req);
+        struct smb2_connect_state *state =
+                tevent_req_data(req,
+                struct smb2_connect_state);
+        struct smbcli_socket *sock;
+        struct tevent_req *subreq;
+        NTSTATUS status;
+        uint32_t timeout_msec;
+        enum protocol_types min_protocol;
+        status = smbcli_sock_connect_recv(creq, state, &sock);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        state->transport = smb2_transport_init(sock, state, &state->options);
+        if (tevent_req_nomem(state->transport, req)) {
+                return;
+        }
+        timeout_msec = state->transport->options.request_timeout * 1000;
+        min_protocol = state->transport->options.min_protocol;
+        if (min_protocol < PROTOCOL_SMB2_02) {
+                min_protocol = PROTOCOL_SMB2_02;
+        }
+        subreq = smbXcli_negprot_send(state, state->ev,
+                                      state->transport->conn, timeout_msec,
+                                      min_protocol,
+                                      state->transport->options.max_protocol);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, smb2_connect_negprot_done, req);
+}
+static void smb2_connect_session_done(struct tevent_req *subreq);
+static void smb2_connect_negprot_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        struct smb2_connect_state *state =
+                tevent_req_data(req,
+                struct smb2_connect_state);
+        struct smb2_transport *transport = state->transport;
+        NTSTATUS status;
+        status = smbXcli_negprot_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        /* This is a hack... */
+        smb2cli_conn_set_max_credits(transport->conn, 30);
+        state->session = smb2_session_init(transport, state->gensec_settings, state);
+        if (tevent_req_nomem(state->session, req)) {
+                return;
+        }
+        subreq = smb2_session_setup_spnego_send(state, state->ev,
+                                                state->session,
+                                                state->credentials,
+                                                state->previous_session_id);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, smb2_connect_session_done, req);
+}
+static void smb2_connect_tcon_done(struct tevent_req *subreq);
+static void smb2_connect_session_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        struct smb2_connect_state *state =
+                tevent_req_data(req,
+                struct smb2_connect_state);
+        NTSTATUS status;
+        uint32_t timeout_msec;
+        status = smb2_session_setup_spnego_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        state->tree = smb2_tree_init(state->session, state, true);
+        if (tevent_req_nomem(state->tree, req)) {
+                return;
+        }
+        timeout_msec = state->transport->options.request_timeout * 1000;
+        subreq = smb2cli_tcon_send(state, state->ev,
+                                   state->transport->conn,
+                                   timeout_msec,
+                                   state->session->smbXcli,
+                                   state->tree->smbXcli,
+, /* flags */
+                                   state->unc);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, smb2_connect_tcon_done, req);
+}
+static void smb2_connect_tcon_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        NTSTATUS status;
+        status = smb2cli_tcon_recv(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS smb2_connect_recv(struct tevent_req *req,
+                           TALLOC_CTX *mem_ctx,
                            struct smb2_tree **tree)
+{
+        NTSTATUS status;
+        struct smb2_connect_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_connect_state);
+        status = composite_wait(c);
+        if (NT_STATUS_IS_OK(status)) {
+                *tree = talloc_steal(mem_ctx, state->tree);
+        }
+        talloc_free(c);
+        return status;
+        struct smb2_connect_state *state =
+                tevent_req_data(req,
+                struct smb2_connect_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                tevent_req_received(req);
+                return status;
+        }
+        *tree = talloc_move(mem_ctx, &state->tree);
+        tevent_req_received(req);
+        return NT_STATUS_OK;
+}
 …
   sync version of smb2_connect
 */
+NTSTATUS smb2_connect(TALLOC_CTX *mem_ctx,
+                      const char *host, const char **ports,
+NTSTATUS smb2_connect_ext(TALLOC_CTX *mem_ctx,
+                          const char *host,
+                          const char **ports,
                           const char *share,
+                          struct resolve_context *resolve_ctx,
+                          struct cli_credentials *credentials,
+                          uint64_t previous_session_id,
+                          struct smb2_tree **tree,
+                          struct tevent_context *ev,
+                          const struct smbcli_options *options,
+                          const char *socket_options,
+                          struct gensec_settings *gensec_settings)
+{
+        struct tevent_req *subreq;
+        NTSTATUS status;
+        bool ok;
+        TALLOC_CTX *frame = talloc_stackframe();
+        if (frame == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        subreq = smb2_connect_send(frame,
+                                   ev,
+                                   host,
+                                   ports,
+                                   share,
+                                   resolve_ctx,
+                                   credentials,
+                                   previous_session_id,
+                                   options,
+                                   socket_options,
+                                   gensec_settings);
+        if (subreq == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ok = tevent_req_poll(subreq, ev);
+        if (!ok) {
+                status = map_nt_error_from_unix_common(errno);
+                TALLOC_FREE(frame);
+                return status;
+        }
+        status = smb2_connect_recv(subreq, mem_ctx, tree);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(frame);
+                return status;
+        }
+        TALLOC_FREE(frame);
+        return NT_STATUS_OK;
+}
+NTSTATUS smb2_connect(TALLOC_CTX *mem_ctx,
+                      const char *host,
+                      const char **ports,
+                      const char *share,
                       struct resolve_context *resolve_ctx,
                       struct cli_credentials *credentials,
 …
                       struct tevent_context *ev,
                       struct smbcli_options *options,
+                          const char *socket_options,
+                          struct gensec_settings *gensec_settings)
+{
+        struct composite_context *c = smb2_connect_send(mem_ctx, host, ports,
+                                                                                                        share, resolve_ctx,
+                                                                                                        credentials, ev, options,
+                                                                                                        socket_options,
+                                                                                                        gensec_settings);
+        return smb2_connect_recv(c, mem_ctx, tree);
+}
+                      const char *socket_options,
+                      struct gensec_settings *gensec_settings)
+{
+        NTSTATUS status;
+        status = smb2_connect_ext(mem_ctx, host, ports, share, resolve_ctx,
+                                  credentials,
+, /* previous_session_id */
+                                  tree, ev, options, socket_options,
+                                  gensec_settings);
+        return status;
+}

vendor/current/source4/libcli/smb2/create.c

-              r740
+              r988
+        }
+        if (io->in.durable_open_v2) {
+                uint8_t data[32];
+                uint32_t flags = 0;
+                DATA_BLOB guid_blob;
+                SIVAL(data, 0, io->in.timeout);
+                if (io->in.persistent_open) {
+                        flags = SMB2_DHANDLE_FLAG_PERSISTENT;
+                }
+                SIVAL(data, 4, flags);
+                SBVAL(data, 8, 0x0); /* reserved */
+                status = GUID_to_ndr_blob(&io->in.create_guid, req, /* TALLOC_CTX */
+                                          &guid_blob);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+                memcpy(data+16, guid_blob.data, 16);
+                status = smb2_create_blob_add(req, &blobs,
+                                              SMB2_CREATE_TAG_DH2Q,
+                                              data_blob_const(data, 32));
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+        }
         if (io->in.durable_handle) {
                 uint8_t data[16];
 …
                 status = smb2_create_blob_add(req, &blobs,
                                               SMB2_CREATE_TAG_DHNC, data_blob_const(data, 16));
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+        }
+        if (io->in.durable_handle_v2) {
+                uint8_t data[36];
+                DATA_BLOB guid_blob;
+                uint32_t flags = 0;
+                smb2_push_handle(data, io->in.durable_handle_v2);
+                status = GUID_to_ndr_blob(&io->in.create_guid, req, /* TALLOC_CTX */
+                                          &guid_blob);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+                memcpy(data+16, guid_blob.data, 16);
+                if (io->in.persistent_open) {
+                        flags = SMB2_DHANDLE_FLAG_PERSISTENT;
+                }
+                SIVAL(data, 32, flags);
+                status = smb2_create_blob_add(req, &blobs,
+                                              SMB2_CREATE_TAG_DH2C,
+                                              data_blob_const(data, 36));
                 if (!NT_STATUS_IS_OK(status)) {
                         talloc_free(req);
 …
                 uint8_t data[32];
+                memcpy(&data[0], &io->in.lease_request->lease_key, 16);
+                SIVAL(data, 16, io->in.lease_request->lease_state);
+                SIVAL(data, 20, io->in.lease_request->lease_flags);
+                SBVAL(data, 24, io->in.lease_request->lease_duration);
+                status = smb2_create_blob_add(req, &blobs,
+                                              SMB2_CREATE_TAG_RQLS,
+                                              data_blob_const(data, 32));
+                if (!smb2_lease_push(io->in.lease_request, data,
+                                     sizeof(data))) {
+                        TALLOC_FREE(req);
+                        return NULL;
+                }
+                status = smb2_create_blob_add(
+                        req, &blobs, SMB2_CREATE_TAG_RQLS,
+                        data_blob_const(data, sizeof(data)));
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+        }
+        if (io->in.lease_request_v2) {
+                uint8_t data[52];
+                if (!smb2_lease_push(io->in.lease_request_v2, data,
+                                     sizeof(data))) {
+                        TALLOC_FREE(req);
+                        return NULL;
+                }
+                status = smb2_create_blob_add(
+                        req, &blobs, SMB2_CREATE_TAG_RQLS,
+                        data_blob_const(data, sizeof(data)));
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+        }
+        if (io->in.app_instance_id) {
+                uint8_t data[20];
+                DATA_BLOB guid_blob;
+                SSVAL(data, 0, 20); /* structure size */
+                SSVAL(data, 2, 0);  /* reserved */
+                status = GUID_to_ndr_blob(io->in.app_instance_id,
+                                          req, /* TALLOC_CTX */
+                                          &guid_blob);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+                memcpy(data+4, guid_blob.data, 16);
+                status = smb2_create_blob_add(req, &blobs,
+                                              SMB2_CREATE_TAG_APP_INSTANCE_ID,
+                                              data_blob_const(data, 20));
                 if (!NT_STATUS_IS_OK(status)) {
                         talloc_free(req);
 …
                 talloc_free(req);
                 return NULL;
+        }
+        if (((io->in.fname == NULL) || (strlen(io->in.fname) == 0)) &&
+            (blob.length == 0)) {
+                struct smb2_request_buffer *buf = &req->out;
+                status = smb2_grow_buffer(buf, 1);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(req);
+                        return NULL;
+                }
+                buf->dynamic[0] = 0;
+                buf->dynamic += 1;
+                buf->body_size += 1;
+                buf->size += 1;
+        }
 …
+                }
                 if (strcmp(io->out.blobs.blobs[i].tag, SMB2_CREATE_TAG_RQLS) == 0) {
+                        struct smb2_lease *ls = NULL;
                         uint8_t *data;
+                        if (io->out.blobs.blobs[i].data.length != 32) {
+                        ZERO_STRUCT(io->out.lease_response);
+                        ZERO_STRUCT(io->out.lease_response_v2);
+                        switch (io->out.blobs.blobs[i].data.length) {
+                        case 32:
+                                ls = &io->out.lease_response;
+                                ls->lease_version = 1;
+                                break;
+                        case 52:
+                                ls = &io->out.lease_response_v2;
+                                ls->lease_version = 2;
+                                break;
+                        default:
                                 smb2_request_destroy(req);
                                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 …
                         data = io->out.blobs.blobs[i].data.data;
+                        memcpy(&io->out.lease_response.lease_key, data, 16);
+                        io->out.lease_response.lease_state = IVAL(data, 16);
+                        io->out.lease_response.lease_flags = IVAL(data, 20);
+                        io->out.lease_response.lease_duration = BVAL(data, 24);
+                        memcpy(&ls->lease_key, data, 16);
+                        ls->lease_state = IVAL(data, 16);
+                        ls->lease_flags = IVAL(data, 20);
+                        ls->lease_duration = BVAL(data, 24);
+                        if (io->out.blobs.blobs[i].data.length == 52) {
+                                memcpy(&ls->parent_lease_key, data+32, 16);
+                                ls->lease_epoch = SVAL(data, 48);
+                        }
+                }
+                if (strcmp(io->out.blobs.blobs[i].tag, SMB2_CREATE_TAG_DHNQ) == 0) {
+                        if (io->out.blobs.blobs[i].data.length != 8) {
+                                smb2_request_destroy(req);
+                                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                        }
+                        io->out.durable_open = true;
+                }
+                if (strcmp(io->out.blobs.blobs[i].tag, SMB2_CREATE_TAG_DH2Q) == 0) {
+                        uint32_t flags;
+                        uint8_t *data;
+                        if (io->out.blobs.blobs[i].data.length != 8) {
+                                smb2_request_destroy(req);
+                                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                        }
+                        io->out.durable_open = false;
+                        io->out.durable_open_v2 = true;
+                        data = io->out.blobs.blobs[i].data.data;
+                        io->out.timeout = IVAL(data, 0);
+                        flags = IVAL(data, 4);
+                        if ((flags & SMB2_DHANDLE_FLAG_PERSISTENT) != 0) {
+                                io->out.persistent_open = true;
+                        }
+                }
+        }

vendor/current/source4/libcli/smb2/find.c

r740	r988
34	34	NTSTATUS status;
35	35
36		req = smb2_request_init_tree(tree, SMB2_OP_~~FIND~~, 0x20, true, 0);
	36	req = smb2_request_init_tree(tree, SMB2_OP_QUERY_DIRECTORY, 0x20, true, 0);
37	37	if (req == NULL) return NULL;
38	38

vendor/current/source4/libcli/smb2/ioctl.c

-              r414
+              r988
 #include "libcli/smb2/smb2.h"
 #include "libcli/smb2/smb2_calls.h"
+#include "librpc/gen_ndr/ioctl.h"
 /*
 …
+}
+/*
+ * 3.3.4.4 Sending an Error Response
+ */
+static bool smb2_ioctl_is_failure(uint32_t ctl_code, NTSTATUS status,
+                                  size_t data_size)
+{
+        if (NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        if (NT_STATUS_EQUAL(status, STATUS_BUFFER_OVERFLOW)
+         && ((ctl_code == FSCTL_PIPE_TRANSCEIVE)
+          || (ctl_code == FSCTL_PIPE_PEEK)
+          || (ctl_code == FSCTL_DFS_GET_REFERRALS))) {
+                return false;
+        }
+        if (((ctl_code == FSCTL_SRV_COPYCHUNK)
+                                || (ctl_code == FSCTL_SRV_COPYCHUNK_WRITE))
+         && (data_size == sizeof(struct srv_copychunk_rsp))) {
+                /*
+                 * copychunk responses may come with copychunk data or error
+                 * response data, independent of status.
+                 */
+                return false;
+        }
+        return true;
+}
 /*
   recv a ioctl reply
 */
 NTSTATUS smb2_ioctl_recv(struct smb2_request *req,
+NTSTATUS smb2_ioctl_recv(struct smb2_request *req,
                          TALLOC_CTX *mem_ctx, struct smb2_ioctl *io)
+{
         NTSTATUS status;
+        if (!smb2_request_receive(req) ||
+            smb2_request_is_error(req)) {
+        if (!smb2_request_receive(req) ||
+            smb2_ioctl_is_failure(io->in.function, req->status,
+                                  req->in.bufinfo.data_size)) {
                 return smb2_request_destroy(req);
+        }

vendor/current/source4/libcli/smb2/logoff.c

r414	r988
36	36	req->session = session;
37	37
38		~~SBVAL(req->out.hdr, SMB2_HDR_SESSION_ID, session->uid);~~
39
40	38	SSVAL(req->out.body, 0x02, 0);
41	39

vendor/current/source4/libcli/smb2/read.c

r414	r988
45	45	SSVAL(req->out.body, 0x2E, io->in.channel_length);
46	46
	47	req->credit_charge = (MAX(io->in.length, 1) - 1)/ 65536 + 1;
	48
47	49	smb2_transport_send(req);
48	50

vendor/current/source4/libcli/smb2/request.c

-              r740
+              r988
+}
-/* destroy a request structure */
-static int smb2_request_destructor(struct smb2_request *req)
+{
-        if (req->transport) {
-                /* remove it from the list of pending requests (a null op if
-                   its not in the list) */
-                DLIST_REMOVE(req->transport->pending_recv, req);
+        }
-        return 0;
+}
 /*
   initialise a smb2 request
 …
+{
         struct smb2_request *req;
-        uint64_t seqnum;
         uint32_t hdr_offset;
-        uint32_t flags = 0;
         bool compound = false;
 …
+        }
         req = talloc(transport, struct smb2_request);
+        req = talloc_zero(transport, struct smb2_request);
         if (req == NULL) return NULL;
-        seqnum = transport->seqnum;
-        if (transport->credits.charge > 0) {
-                transport->seqnum += transport->credits.charge;
-        } else {
-                transport->seqnum += 1;
+        }
         req->state     = SMB2_REQUEST_INIT;
         req->transport = transport;
+        req->session   = NULL;
+        req->tree      = NULL;
+        req->seqnum    = seqnum;
+        req->status    = NT_STATUS_OK;
+        req->async.fn  = NULL;
+        req->next = req->prev = NULL;
+        ZERO_STRUCT(req->cancel);
+        ZERO_STRUCT(req->in);
+        if (transport->compound.missing > 0) {
+                compound = true;
+                transport->compound.missing -= 1;
+                req->out = transport->compound.buffer;
+                ZERO_STRUCT(transport->compound.buffer);
+                if (transport->compound.related) {
+                        flags |= SMB2_HDR_FLAG_CHAINED;
+                }
+        } else {
+                ZERO_STRUCT(req->out);
+        }
+        if (req->out.size > 0) {
+                hdr_offset = req->out.size;
+        } else {
+                hdr_offset = NBT_HDR_SIZE;
+        }
+        hdr_offset = NBT_HDR_SIZE;
         req->out.size      = hdr_offset + SMB2_HDR_BODY + body_fixed_size;
 …
         SIVAL(req->out.hdr, 0,                          SMB2_MAGIC);
         SSVAL(req->out.hdr, SMB2_HDR_LENGTH,            SMB2_HDR_BODY);
         SSVAL(req->out.hdr, SMB2_HDR_EPOCH,             transport->credits.charge);
+        SSVAL(req->out.hdr, SMB2_HDR_CREDIT_CHARGE,     0);
         SIVAL(req->out.hdr, SMB2_HDR_STATUS,            0);
         SSVAL(req->out.hdr, SMB2_HDR_OPCODE,            opcode);
         SSVAL(req->out.hdr, SMB2_HDR_CREDIT,            transport->credits.ask_num);
         SIVAL(req->out.hdr, SMB2_HDR_FLAGS,             flags);
+        SSVAL(req->out.hdr, SMB2_HDR_CREDIT,            0);
+        SIVAL(req->out.hdr, SMB2_HDR_FLAGS,             0);
         SIVAL(req->out.hdr, SMB2_HDR_NEXT_COMMAND,      0);
         SBVAL(req->out.hdr, SMB2_HDR_MESSAGE_ID,        req->seqnum);
+        SBVAL(req->out.hdr, SMB2_HDR_MESSAGE_ID,        0);
         SIVAL(req->out.hdr, SMB2_HDR_PID,               0);
         SIVAL(req->out.hdr, SMB2_HDR_TID,               0);
 …
+        }
-        talloc_set_destructor(req, smb2_request_destructor);
         return req;
+}
 …
         if (req == NULL) return NULL;
-        SBVAL(req->out.hdr,  SMB2_HDR_SESSION_ID, tree->session->uid);
-        SIVAL(req->out.hdr,  SMB2_HDR_PID, tree->session->pid);
-        SIVAL(req->out.hdr,  SMB2_HDR_TID, tree->tid);
         req->session = tree->session;
         req->tree = tree;
 …
         /* keep receiving packets until this one is replied to */
         while (req->state <= SMB2_REQUEST_RECV) {
                 if (event_loop_once(req->transport->socket->event.ctx) != 0) {
+                if (tevent_loop_once(req->transport->ev) != 0) {
                         return false;
+                }
 …
         NTSTATUS status;
         void *vstr;
+        size_t converted_size = 0;
         bool ret;
 …
         ret = convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
                                      blob.data, blob.length, &vstr, NULL, false);
+                                     blob.data, blob.length, &vstr, &converted_size);
         data_blob_free(&blob);
         (*str) = (char *)vstr;
 …
         NTSTATUS status;
         bool ret;
+        void *ptr = NULL;
         if (str == NULL) {
 …
         ret = convert_string_talloc(buf->buffer, CH_UNIX, CH_UTF16,
+                                     str, strlen(str), (void **)&blob.data, &blob.length,
+                                         false);
+                                    str, strlen(str), &ptr, &blob.length);
         if (!ret) {
                 return NT_STATUS_ILLEGAL_CHARACTER;
+        }
+        blob.data = (uint8_t *)ptr;
         status = smb2_push_o16s16_blob(buf, ofs, blob);

vendor/current/source4/libcli/smb2/session.c

-              r740
+              r988
 #include "includes.h"
+#include "system/network.h"
+#include <tevent.h>
+#include "lib/util/tevent_ntstatus.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/smb2/smb2.h"
 #include "libcli/smb2/smb2_calls.h"
-#include "libcli/composite/composite.h"
 #include "auth/gensec/gensec.h"
 #include <unistd.h>
+#include "auth/credentials/credentials.h"
+#include "../libcli/smb/smbXcli_base.h"
 /**
 …
 struct smb2_session *smb2_session_init(struct smb2_transport *transport,
                                        struct gensec_settings *settings,
                                        TALLOC_CTX *parent_ctx, bool primary)
+                                       TALLOC_CTX *parent_ctx)
+{
         struct smb2_session *session;
 …
                 return NULL;
+        }
         if (primary) {
+                session->transport = talloc_steal(session, transport);
         } else {
                 session->transport = talloc_reference(session, transport);
+        }
         session->pid = getpid();
+        session->transport = talloc_steal(session, transport);
+        session->smbXcli = smbXcli_session_create(session, transport->conn);
+        if (session->smbXcli == NULL) {
+                talloc_free(session);
+                return NULL;
+        }
         /* prepare a gensec context for later use */
+        status = gensec_client_start(session, &session->gensec,
+                                     session->transport->socket->event.ctx,
+        status = gensec_client_start(session, &session->gensec,
                                      settings);
         if (!NT_STATUS_IS_OK(status)) {
 …
+}
+/**
+  send a session setup request
+*/
+struct smb2_request *smb2_session_setup_send(struct smb2_session *session,
+                                             struct smb2_session_setup *io)
+{
+        struct smb2_request *req;
+        NTSTATUS status;
+        req = smb2_request_init(session->transport, SMB2_OP_SESSSETUP,
+x18, true, io->in.secblob.length);
+        if (req == NULL) return NULL;
+        SBVAL(req->out.hdr,  SMB2_HDR_SESSION_ID, session->uid);
+        SCVAL(req->out.body, 0x02, io->in.vc_number);
+        SCVAL(req->out.body, 0x03, io->in.security_mode);
+        SIVAL(req->out.body, 0x04, io->in.capabilities);
+        SIVAL(req->out.body, 0x08, io->in.channel);
+        SBVAL(req->out.body, 0x10, io->in.previous_sessionid);
+        req->session = session;
+        status = smb2_push_o16s16_blob(&req->out, 0x0C, io->in.secblob);
+/*
+ * Note: that the caller needs to keep 'transport' around as
+ *       long as the returned session is active!
+ */
+struct smb2_session *smb2_session_channel(struct smb2_transport *transport,
+                                          struct gensec_settings *settings,
+                                          TALLOC_CTX *parent_ctx,
+                                          struct smb2_session *base_session)
+{
+        struct smb2_session *session;
+        NTSTATUS status;
+        session = talloc_zero(parent_ctx, struct smb2_session);
+        if (!session) {
+                return NULL;
+        }
+        session->transport = transport;
+        status = smb2cli_session_create_channel(session,
+                                                base_session->smbXcli,
+                                                transport->conn,
+                                                &session->smbXcli);
         if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(req);
+                return NULL;
+        }
+        smb2_transport_send(req);
+        return req;
+}
+/**
+  recv a session setup reply
+*/
+NTSTATUS smb2_session_setup_recv(struct smb2_request *req, TALLOC_CTX *mem_ctx,
+                                 struct smb2_session_setup *io)
+{
+        NTSTATUS status;
+        if (!smb2_request_receive(req) ||
+            (smb2_request_is_error(req) &&
+             !NT_STATUS_EQUAL(req->status, NT_STATUS_MORE_PROCESSING_REQUIRED))) {
+                return smb2_request_destroy(req);
+        }
+        SMB2_CHECK_PACKET_RECV(req, 0x08, true);
+        io->out.session_flags = SVAL(req->in.body, 0x02);
+        io->out.uid           = BVAL(req->in.hdr,  SMB2_HDR_SESSION_ID);
+        status = smb2_pull_o16s16_blob(&req->in, mem_ctx, req->in.body+0x04, &io->out.secblob);
+                talloc_free(session);
+                return NULL;
+        }
+        session->needs_bind = true;
+        /* prepare a gensec context for later use */
+        status = gensec_client_start(session, &session->gensec,
+                                     settings);
         if (!NT_STATUS_IS_OK(status)) {
+                smb2_request_destroy(req);
+                return status;
+        }
+        return smb2_request_destroy(req);
+}
+/*
+  sync session setup request
+*/
+NTSTATUS smb2_session_setup(struct smb2_session *session,
+                            TALLOC_CTX *mem_ctx, struct smb2_session_setup *io)
+{
+        struct smb2_request *req = smb2_session_setup_send(session, io);
+        return smb2_session_setup_recv(req, mem_ctx, io);
+}
+struct smb2_session_state {
+        struct smb2_session_setup io;
+        struct smb2_request *req;
+                talloc_free(session);
+                return NULL;
+        }
+        gensec_want_feature(session->gensec, GENSEC_FEATURE_SESSION_KEY);
+        return session;
+}
+struct smb2_session_setup_spnego_state {
+        struct tevent_context *ev;
+        struct smb2_session *session;
+        struct cli_credentials *credentials;
+        uint64_t previous_session_id;
+        bool session_bind;
+        bool reauth;
         NTSTATUS gensec_status;
+        DATA_BLOB in_secblob;
+        DATA_BLOB out_secblob;
 };
+/*
+  handle continuations of the spnego session setup
+*/
+static void session_request_handler(struct smb2_request *req)
+{
+        struct composite_context *c = talloc_get_type(req->async.private_data,
+                                                      struct composite_context);
+        struct smb2_session_state *state = talloc_get_type(c->private_data,
+                                                           struct smb2_session_state);
+        struct smb2_session *session = req->session;
+        NTSTATUS session_key_err;
+        DATA_BLOB session_key;
+        NTSTATUS peer_status;
+        c->status = smb2_session_setup_recv(req, c, &state->io);
+        peer_status = c->status;
+        if (NT_STATUS_EQUAL(peer_status, NT_STATUS_MORE_PROCESSING_REQUIRED) ||
+            (NT_STATUS_IS_OK(peer_status) &&
+             NT_STATUS_EQUAL(state->gensec_status, NT_STATUS_MORE_PROCESSING_REQUIRED))) {
+                c->status = gensec_update(session->gensec, c,
+                                          state->io.out.secblob,
+                                          &state->io.in.secblob);
+                state->gensec_status = c->status;
+                session->uid = state->io.out.uid;
+        }
+        if (!NT_STATUS_IS_OK(c->status) &&
+            !NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                composite_error(c, c->status);
+                return;
+        }
+        if (NT_STATUS_EQUAL(peer_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                state->req = smb2_session_setup_send(session, &state->io);
+                if (state->req == NULL) {
+                        composite_error(c, NT_STATUS_NO_MEMORY);
+                        return;
+                }
+                state->req->async.fn = session_request_handler;
+                state->req->async.private_data = c;
+                return;
+        }
+        session_key_err = gensec_session_key(session->gensec, &session_key);
+        if (NT_STATUS_IS_OK(session_key_err)) {
+                session->session_key = session_key;
+        }
+        if (session->transport->signing_required) {
+                if (session->session_key.length == 0) {
+                        DEBUG(0,("Wrong session key length %u for SMB2 signing\n",
+                                 (unsigned)session->session_key.length));
+                        composite_error(c, NT_STATUS_ACCESS_DENIED);
+                        return;
+                }
+                session->signing_active = true;
+        }
+        composite_done(c);
+}
+static void smb2_session_setup_spnego_done(struct tevent_req *subreq);
 /*
   a composite function that does a full SPNEGO session setup
  */
+struct composite_context *smb2_session_setup_spnego_send(struct smb2_session *session,
+                                                         struct cli_credentials *credentials)
+{
+        struct composite_context *c;
+        struct smb2_session_state *state;
+struct tevent_req *smb2_session_setup_spnego_send(
+                                TALLOC_CTX *mem_ctx,
+                                struct tevent_context *ev,
+                                struct smb2_session *session,
+                                struct cli_credentials *credentials,
+                                uint64_t previous_session_id)
+{
+        struct tevent_req *req;
+        struct smb2_session_setup_spnego_state *state;
+        uint64_t current_session_id;
         const char *chosen_oid;
+        c = composite_create(session, session->transport->socket->event.ctx);
+        if (c == NULL) return NULL;
+        state = talloc(c, struct smb2_session_state);
+        if (composite_nomem(state, c)) return c;
+        c->private_data = state;
+        ZERO_STRUCT(state->io);
+        state->io.in.vc_number          = 0;
+        if (session->transport->signing_required) {
+                state->io.in.security_mode =
+                        SMB2_NEGOTIATE_SIGNING_ENABLED | SMB2_NEGOTIATE_SIGNING_REQUIRED;
+        }
+        state->io.in.capabilities       = 0;
+        state->io.in.channel            = 0;
+        state->io.in.previous_sessionid = 0;
+        c->status = gensec_set_credentials(session->gensec, credentials);
+        if (!composite_is_ok(c)) return c;
+        c->status = gensec_set_target_hostname(session->gensec,
+                                               session->transport->socket->hostname);
+        if (!composite_is_ok(c)) return c;
+        c->status = gensec_set_target_service(session->gensec, "cifs");
+        if (!composite_is_ok(c)) return c;
+        if (session->transport->negotiate.secblob.length > 0) {
+        struct tevent_req *subreq;
+        NTSTATUS status;
+        const DATA_BLOB *server_gss_blob;
+        DATA_BLOB negprot_secblob = data_blob_null;
+        uint32_t timeout_msec;
+        uint8_t in_flags = 0;
+        timeout_msec = session->transport->options.request_timeout * 1000;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct smb2_session_setup_spnego_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->session = session;
+        state->credentials = credentials;
+        state->previous_session_id = previous_session_id;
+        current_session_id = smb2cli_session_current_id(state->session->smbXcli);
+        if (state->session->needs_bind) {
+                state->session_bind = true;
+        } else if (current_session_id != 0) {
+                state->reauth = true;
+        }
+        server_gss_blob = smbXcli_conn_server_gss_blob(session->transport->conn);
+        if (server_gss_blob) {
+                negprot_secblob = *server_gss_blob;
+        }
+        status = gensec_set_credentials(session->gensec, credentials);
+        if (tevent_req_nterror(req, status)) {
+                return tevent_req_post(req, ev);
+        }
+        status = gensec_set_target_hostname(session->gensec,
+                                            smbXcli_conn_remote_name(session->transport->conn));
+        if (tevent_req_nterror(req, status)) {
+                return tevent_req_post(req, ev);
+        }
+        status = gensec_set_target_service(session->gensec, "cifs");
+        if (tevent_req_nterror(req, status)) {
+                return tevent_req_post(req, ev);
+        }
+        if (negprot_secblob.length > 0) {
                 chosen_oid = GENSEC_OID_SPNEGO;
         } else {
 …
+        }
+        c->status = gensec_start_mech_by_oid(session->gensec, chosen_oid);
+        if (!composite_is_ok(c)) return c;
+        c->status = gensec_update(session->gensec, c,
+                                  session->transport->negotiate.secblob,
+                                  &state->io.in.secblob);
+        if (!NT_STATUS_EQUAL(c->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                composite_error(c, c->status);
+                return c;
+        }
+        state->gensec_status = c->status;
+        state->req = smb2_session_setup_send(session, &state->io);
+        composite_continue_smb2(c, state->req, session_request_handler, c);
+        return c;
+        status = gensec_start_mech_by_oid(session->gensec, chosen_oid);
+        if (tevent_req_nterror(req, status)) {
+                return tevent_req_post(req, ev);
+        }
+        status = gensec_update_ev(session->gensec, state,
+                               state->ev,
+                               negprot_secblob,
+                               &state->in_secblob);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                tevent_req_nterror(req, status);
+                return tevent_req_post(req, ev);
+        }
+        state->gensec_status = status;
+        if (state->session_bind) {
+                in_flags |= SMB2_SESSION_FLAG_BINDING;
+        }
+        subreq = smb2cli_session_setup_send(state, state->ev,
+                                            session->transport->conn,
+                                            timeout_msec,
+                                            session->smbXcli,
+                                            in_flags,
+, /* in_capabilities */
+, /* in_channel */
+                                            state->previous_session_id,
+                                            &state->in_secblob);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, smb2_session_setup_spnego_done, req);
+        return req;
+}
+/*
+  handle continuations of the spnego session setup
+*/
+static void smb2_session_setup_spnego_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req =
+                tevent_req_callback_data(subreq,
+                struct tevent_req);
+        struct smb2_session_setup_spnego_state *state =
+                tevent_req_data(req,
+                struct smb2_session_setup_spnego_state);
+        struct smb2_session *session = state->session;
+        NTSTATUS peer_status;
+        NTSTATUS status;
+        struct iovec *recv_iov;
+        uint32_t timeout_msec;
+        uint8_t in_flags = 0;
+        timeout_msec = session->transport->options.request_timeout * 1000;
+        status = smb2cli_session_setup_recv(subreq, state,
+                                            &recv_iov,
+                                            &state->out_secblob);
+        if (!NT_STATUS_IS_OK(status) &&
+            !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        peer_status = status;
+        if (NT_STATUS_EQUAL(state->gensec_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                status = gensec_update_ev(session->gensec, state,
+                                       state->ev,
+                                       state->out_secblob,
+                                       &state->in_secblob);
+                state->gensec_status = status;
+        }
+        if (!NT_STATUS_IS_OK(status) &&
+            !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (NT_STATUS_IS_OK(peer_status) && NT_STATUS_IS_OK(state->gensec_status)) {
+                DATA_BLOB session_key;
+                if (state->reauth) {
+                        tevent_req_done(req);
+                        return;
+                }
+                if (cli_credentials_is_anonymous(state->credentials)) {
+                        /*
+                         * Windows server does not set the
+                         * SMB2_SESSION_FLAG_IS_GUEST nor
+                         * SMB2_SESSION_FLAG_IS_NULL flag.
+                         *
+                         * This fix makes sure we do not try
+                         * to verify a signature on the final
+                         * session setup response.
+                         */
+                        tevent_req_done(req);
+                        return;
+                }
+                status = gensec_session_key(session->gensec, state,
+                                            &session_key);
+                if (tevent_req_nterror(req, status)) {
+                        return;
+                }
+                if (state->session_bind) {
+                        status = smb2cli_session_set_channel_key(session->smbXcli,
+                                                                 session_key,
+                                                                 recv_iov);
+                        if (tevent_req_nterror(req, status)) {
+                                return;
+                        }
+                        session->needs_bind = false;
+                } else {
+                        status = smb2cli_session_set_session_key(session->smbXcli,
+                                                                 session_key,
+                                                                 recv_iov);
+                        if (tevent_req_nterror(req, status)) {
+                                return;
+                        }
+                }
+                tevent_req_done(req);
+                return;
+        }
+        if (state->session_bind) {
+                in_flags |= SMB2_SESSION_FLAG_BINDING;
+        }
+        subreq = smb2cli_session_setup_send(state, state->ev,
+                                            session->transport->conn,
+                                            timeout_msec,
+                                            session->smbXcli,
+                                            in_flags,
+, /* in_capabilities */
+, /* in_channel */
+                                            state->previous_session_id,
+                                            &state->in_secblob);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, smb2_session_setup_spnego_done, req);
+}
 …
   receive a composite session setup reply
 */
+NTSTATUS smb2_session_setup_spnego_recv(struct composite_context *c)
+{
+        NTSTATUS status;
+        status = composite_wait(c);
+        talloc_free(c);
+        return status;
+NTSTATUS smb2_session_setup_spnego_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
 */
 NTSTATUS smb2_session_setup_spnego(struct smb2_session *session,
+                                   struct cli_credentials *credentials)
+{
+        struct composite_context *c = smb2_session_setup_spnego_send(session, credentials);
+        return smb2_session_setup_spnego_recv(c);
+}
+                                   struct cli_credentials *credentials,
+                                   uint64_t previous_session_id)
+{
+        struct tevent_req *subreq;
+        NTSTATUS status;
+        bool ok;
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev = session->transport->ev;
+        if (frame == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        subreq = smb2_session_setup_spnego_send(frame, ev,
+                                                session, credentials,
+                                                previous_session_id);
+        if (subreq == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ok = tevent_req_poll(subreq, ev);
+        if (!ok) {
+                status = map_nt_error_from_unix_common(errno);
+                TALLOC_FREE(frame);
+                return status;
+        }
+        status = smb2_session_setup_spnego_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(frame);
+                return status;
+        }
+        TALLOC_FREE(frame);
+        return NT_STATUS_OK;
+}

vendor/current/source4/libcli/smb2/smb2.h

-              r740
+              r988
 struct smb2_handle;
 struct smb2_lease_break;
-/*
-  information returned from the negotiate process
-*/
-struct smb2_negotiate {
-        DATA_BLOB secblob;
-        NTTIME system_time;
-        NTTIME server_start_time;
-        uint16_t security_mode;
-        uint16_t dialect_revision;
-};
 struct smb2_request_buffer {
 …
 /* this is the context for the smb2 transport layer */
 struct smb2_transport {
+        /* socket level info */
+        struct smbcli_socket *socket;
+        struct smb2_negotiate negotiate;
+        /* next seqnum to allocate */
+        uint64_t seqnum;
+        struct tevent_context *ev; /* TODO: remove this !!! */
+        struct smbXcli_conn *conn;
         /* the details for coumpounded requests */
         struct {
-                uint32_t missing;
                 bool related;
                 struct smb2_request_buffer buffer;
+                struct tevent_req **reqs;
         } compound;
-        struct {
-                uint16_t charge;
-                uint16_t ask_num;
-        } credits;
-        /* a list of requests that are pending for receive on this
-           connection */
-        struct smb2_request *pending_recv;
-        /* context of the stream -> packet parser */
-        struct packet_context *packet;
         /* an idle function - if this is defined then it will be
 …
                 void *private_data;
                 unsigned int period;
+                struct tevent_timer *te;
         } idle;
 …
                 void *private_data;
         } lease;
+        struct tevent_req *break_subreq;
         struct smbcli_options options;
-        bool signing_required;
 };
 …
 struct smb2_tree {
         struct smb2_session *session;
         uint32_t tid;
+        struct smbXcli_tcon *smbXcli;
 };
 …
         struct smb2_transport *transport;
         struct gensec_security *gensec;
+        uint64_t uid;
+        uint32_t pid;
+        DATA_BLOB session_key;
+        bool signing_active;
+        struct smbXcli_session *smbXcli;
+        bool needs_bind;
 };
 …
 /* the context for a single SMB2 request */
 struct smb2_request {
-        /* allow a request to be part of a list of requests */
-        struct smb2_request *next, *prev;
         /* each request is in one of 3 possible states */
         enum smb2_request_state state;
+        struct tevent_req *subreq;
         struct smb2_transport *transport;
 …
         struct smb2_tree      *tree;
-        uint64_t seqnum;
         struct {
-                bool do_cancel;
                 bool can_cancel;
-                uint64_t async_id;
         } cancel;
 …
         struct smb2_request_buffer in;
         struct smb2_request_buffer out;
+        struct iovec *recv_iov;
+        uint16_t credit_charge;
         /* information on what to do with a reply when it is received

vendor/current/source4/libcli/smb2/tcon.c

-              r414
+              r988
 #include "libcli/smb2/smb2.h"
 #include "libcli/smb2/smb2_calls.h"
+#include "../libcli/smb/smbXcli_base.h"
 /*
 …
                 tree->session = talloc_reference(tree, session);
+        }
-        return tree;
+}
+/*
+  send a tree connect
+*/
+struct smb2_request *smb2_tree_connect_send(struct smb2_tree *tree,
+                                            struct smb2_tree_connect *io)
+{
+        struct smb2_request *req;
+        NTSTATUS status;
+        req = smb2_request_init(tree->session->transport, SMB2_OP_TCON,
+x08, true, 0);
+        if (req == NULL) return NULL;
+        SBVAL(req->out.hdr,  SMB2_HDR_SESSION_ID, tree->session->uid);
+        req->session = tree->session;
+        SSVAL(req->out.body, 0x02, io->in.reserved);
+        status = smb2_push_o16s16_string(&req->out, 0x04, io->in.path);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(req);
+        tree->smbXcli = smbXcli_tcon_create(tree);
+        if (tree->smbXcli == NULL) {
+                talloc_free(tree);
                 return NULL;
+        }
+        smb2_transport_send(req);
+        return req;
+        return tree;
+}
-/*
-  recv a tree connect reply
-*/
-NTSTATUS smb2_tree_connect_recv(struct smb2_request *req, struct smb2_tree_connect *io)
+{
-        if (!smb2_request_receive(req) ||
-            smb2_request_is_error(req)) {
-                return smb2_request_destroy(req);
+        }
-        SMB2_CHECK_PACKET_RECV(req, 0x10, false);
-        io->out.tid      = IVAL(req->in.hdr,  SMB2_HDR_TID);
-        io->out.share_type  = CVAL(req->in.body, 0x02);
-        io->out.reserved    = CVAL(req->in.body, 0x03);
-        io->out.flags       = IVAL(req->in.body, 0x04);
-        io->out.capabilities= IVAL(req->in.body, 0x08);
-        io->out.access_mask = IVAL(req->in.body, 0x0C);
-        if (io->out.capabilities & ~SMB2_CAP_ALL) {
-                DEBUG(0,("Unknown capabilities mask 0x%x\n", io->out.capabilities));
+        }
-        if (io->out.flags & ~SMB2_SHAREFLAG_ALL) {
-                DEBUG(0,("Unknown tcon shareflag 0x%x\n", io->out.flags));
+        }
-        return smb2_request_destroy(req);
+}
-/*
-  sync tree connect request
-*/
-NTSTATUS smb2_tree_connect(struct smb2_tree *tree, struct smb2_tree_connect *io)
+{
-        struct smb2_request *req = smb2_tree_connect_send(tree, io);
-        return smb2_tree_connect_recv(req, io);
+}

vendor/current/source4/libcli/smb2/transport.c

-              r740
+              r988
 #include "includes.h"
+#include "system/network.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
 …
 #include "lib/socket/socket.h"
 #include "lib/events/events.h"
-#include "lib/stream/packet.h"
 #include "../lib/util/dlinklist.h"
+/*
+  an event has happened on the socket
+*/
+static void smb2_transport_event_handler(struct tevent_context *ev,
+                                         struct tevent_fd *fde,
+                                         uint16_t flags, void *private_data)
+{
+        struct smb2_transport *transport = talloc_get_type(private_data,
+                                                           struct smb2_transport);
+        if (flags & EVENT_FD_READ) {
+                packet_recv(transport->packet);
+                return;
+        }
+        if (flags & EVENT_FD_WRITE) {
+                packet_queue_run(transport->packet);
+        }
+}
+#include "../libcli/smb/smbXcli_base.h"
+#include "librpc/ndr/libndr.h"
 /*
 …
         return 0;
+}
-/*
-  handle receive errors
-*/
-static void smb2_transport_error(void *private_data, NTSTATUS status)
+{
-        struct smb2_transport *transport = talloc_get_type(private_data,
-                                                           struct smb2_transport);
-        smb2_transport_dead(transport, status);
+}
-static NTSTATUS smb2_transport_finish_recv(void *private_data, DATA_BLOB blob);
 /*
 …
         if (!transport) return NULL;
         transport->socket = talloc_steal(transport, sock);
+        transport->ev = sock->event.ctx;
         transport->options = *options;
+        transport->credits.charge = 0;
+        transport->credits.ask_num = 1;
+        /* setup the stream -> packet parser */
+        transport->packet = packet_init(transport);
+        if (transport->packet == NULL) {
+        if (transport->options.max_protocol == PROTOCOL_DEFAULT) {
+                transport->options.max_protocol = PROTOCOL_LATEST;
+        }
+        if (transport->options.max_protocol < PROTOCOL_SMB2_02) {
+                transport->options.max_protocol = PROTOCOL_LATEST;
+        }
+        TALLOC_FREE(sock->event.fde);
+        TALLOC_FREE(sock->event.te);
+        transport->conn = smbXcli_conn_create(transport,
+                                              sock->sock->fd,
+                                              sock->hostname,
+                                              options->signing,
+, /* smb1_capabilities */
+                                              &options->client_guid,
+                                              options->smb2_capabilities);
+        if (transport->conn == NULL) {
                 talloc_free(transport);
                 return NULL;
+        }
+        packet_set_private(transport->packet, transport);
+        packet_set_socket(transport->packet, transport->socket->sock);
+        packet_set_callback(transport->packet, smb2_transport_finish_recv);
+        packet_set_full_request(transport->packet, packet_full_request_nbt);
+        packet_set_error_handler(transport->packet, smb2_transport_error);
+        packet_set_event_context(transport->packet, transport->socket->event.ctx);
+        packet_set_nofree(transport->packet);
+        /* take over event handling from the socket layer - it only
+           handles events up until we are connected */
+        talloc_free(transport->socket->event.fde);
+        transport->socket->event.fde = event_add_fd(transport->socket->event.ctx,
+                                                    transport->socket,
+                                                    socket_get_fd(transport->socket->sock),
+                                                    EVENT_FD_READ,
+                                                    smb2_transport_event_handler,
+                                                    transport);
+        packet_set_fde(transport->packet, transport->socket->event.fde);
+        packet_set_serialise(transport->packet);
+        sock->sock->fd = -1;
+        TALLOC_FREE(sock);
         talloc_set_destructor(transport, transport_destructor);
 …
 void smb2_transport_dead(struct smb2_transport *transport, NTSTATUS status)
+{
-        smbcli_sock_dead(transport->socket);
         if (NT_STATUS_EQUAL(NT_STATUS_UNSUCCESSFUL, status)) {
                 status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
+        }
+        /* kill all pending receives */
+        while (transport->pending_recv) {
+                struct smb2_request *req = transport->pending_recv;
+        if (NT_STATUS_IS_OK(status)) {
+                status = NT_STATUS_LOCAL_DISCONNECT;
+        }
+        smbXcli_conn_disconnect(transport->conn, status);
+}
+static void smb2_request_done(struct tevent_req *subreq);
+static void smb2_transport_break_handler(struct tevent_req *subreq);
+/*
+  put a request into the send queue
+*/
+void smb2_transport_send(struct smb2_request *req)
+{
+        NTSTATUS status;
+        struct smb2_transport *transport = req->transport;
+        struct tevent_req **reqs = transport->compound.reqs;
+        size_t num_reqs = talloc_array_length(reqs);
+        size_t i;
+        uint16_t cmd = SVAL(req->out.hdr, SMB2_HDR_OPCODE);
+        uint32_t additional_flags = IVAL(req->out.hdr, SMB2_HDR_FLAGS);
+        uint32_t clear_flags = 0;
+        struct smbXcli_tcon *tcon = NULL;
+        struct smbXcli_session *session = NULL;
+        bool need_pending_break = false;
+        size_t hdr_ofs;
+        size_t pdu_len;
+        DATA_BLOB body = data_blob_null;
+        DATA_BLOB dyn = data_blob_null;
+        uint32_t timeout_msec = transport->options.request_timeout * 1000;
+        if (transport->oplock.handler) {
+                need_pending_break = true;
+        }
+        if (transport->lease.handler) {
+                need_pending_break = true;
+        }
+        if (transport->break_subreq) {
+                need_pending_break = false;
+        }
+        if (need_pending_break) {
+                struct tevent_req *subreq;
+                subreq = smb2cli_req_create(transport,
+                                            transport->ev,
+                                            transport->conn,
+                                            SMB2_OP_BREAK,
+, /* additional_flags */
+, /*clear_flags */
+, /* timeout_msec */
+                                            NULL, /* tcon */
+                                            NULL, /* session */
+                                            NULL, /* body */
+, /* body_fixed */
+                                            NULL, /* dyn */
+, /* dyn_len */
+); /* max_dyn_len */
+                if (subreq != NULL) {
+                        smbXcli_req_set_pending(subreq);
+                        tevent_req_set_callback(subreq,
+                                                smb2_transport_break_handler,
+                                                transport);
+                        transport->break_subreq = subreq;
+                }
+        }
+        if (req->session) {
+                session = req->session->smbXcli;
+        }
+        if (req->tree) {
+                tcon = req->tree->smbXcli;
+        }
+        if (transport->compound.related) {
+                additional_flags |= SMB2_HDR_FLAG_CHAINED;
+        }
+        hdr_ofs = PTR_DIFF(req->out.hdr, req->out.buffer);
+        pdu_len = req->out.size - hdr_ofs;
+        body.data = req->out.body;
+        body.length = req->out.body_fixed;
+        dyn.data = req->out.body + req->out.body_fixed;
+        dyn.length = pdu_len - (SMB2_HDR_BODY + req->out.body_fixed);
+        req->subreq = smb2cli_req_create(req,
+                                         transport->ev,
+                                         transport->conn,
+                                         cmd,
+                                         additional_flags,
+                                         clear_flags,
+                                         timeout_msec,
+                                         tcon,
+                                         session,
+                                         body.data, body.length,
+                                         dyn.data, dyn.length,
+); /* max_dyn_len */
+        if (req->subreq == NULL) {
                 req->state = SMB2_REQUEST_ERROR;
+                req->status = NT_STATUS_NO_MEMORY;
+                return;
+        }
+        if (!tevent_req_is_in_progress(req->subreq)) {
+                req->state = SMB2_REQUEST_ERROR;
+                req->status = NT_STATUS_INTERNAL_ERROR;/* TODO */
+                return;
+        }
+        tevent_req_set_callback(req->subreq, smb2_request_done, req);
+        smb2cli_req_set_notify_async(req->subreq);
+        if (req->credit_charge) {
+                smb2cli_req_set_credit_charge(req->subreq, req->credit_charge);
+        }
+        ZERO_STRUCT(req->out);
+        req->state = SMB2_REQUEST_RECV;
+        if (num_reqs > 0) {
+                for (i=0; i < num_reqs; i++) {
+                        if (reqs[i] != NULL) {
+                                continue;
+                        }
+                        reqs[i] = req->subreq;
+                        i++;
+                        break;
+                }
+                if (i < num_reqs) {
+                        return;
+                }
+        } else {
+                reqs = &req->subreq;
+                num_reqs = 1;
+        }
+        status = smb2cli_req_compound_submit(reqs, num_reqs);
+        TALLOC_FREE(transport->compound.reqs);
+        transport->compound.related = false;
+        if (!NT_STATUS_IS_OK(status)) {
                 req->status = status;
+                DLIST_REMOVE(transport->pending_recv, req);
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+        }
+}
+static NTSTATUS smb2_handle_oplock_break(struct smb2_transport *transport,
+                                         const DATA_BLOB *blob)
+{
+        uint8_t *hdr;
+                req->state = SMB2_REQUEST_ERROR;
+                smbXcli_conn_disconnect(transport->conn, status);
+        }
+}
+static void smb2_request_done(struct tevent_req *subreq)
+{
+        struct smb2_request *req =
+                tevent_req_callback_data(subreq,
+                struct smb2_request);
+        ssize_t len;
+        size_t i;
+        req->recv_iov = NULL;
+        req->status = smb2cli_req_recv(req->subreq, req, &req->recv_iov, NULL, 0);
+        if (NT_STATUS_EQUAL(req->status, STATUS_PENDING)) {
+                req->cancel.can_cancel = true;
+                return;
+        }
+        TALLOC_FREE(req->subreq);
+        if (!NT_STATUS_IS_OK(req->status)) {
+                if (req->recv_iov == NULL) {
+                        req->state = SMB2_REQUEST_ERROR;
+                        if (req->async.fn) {
+                                req->async.fn(req);
+                        }
+                        return;
+                }
+        }
+        len = req->recv_iov[0].iov_len;
+        for (i=1; i < 3; i++) {
+                uint8_t *p = req->recv_iov[i-1].iov_base;
+                uint8_t *c1 = req->recv_iov[i].iov_base;
+                uint8_t *c2 = p + req->recv_iov[i-1].iov_len;
+                len += req->recv_iov[i].iov_len;
+                if (req->recv_iov[i].iov_len == 0) {
+                        continue;
+                }
+                if (c1 != c2) {
+                        req->status = NT_STATUS_INTERNAL_ERROR;
+                        req->state = SMB2_REQUEST_ERROR;
+                        if (req->async.fn) {
+                                req->async.fn(req);
+                        }
+                        return;
+                }
+        }
+        req->in.buffer = req->recv_iov[0].iov_base;
+        req->in.size = len;
+        req->in.allocated = req->in.size;
+        req->in.hdr        =  req->recv_iov[0].iov_base;
+        req->in.body       =  req->recv_iov[1].iov_base;
+        req->in.dynamic    =  req->recv_iov[2].iov_base;
+        req->in.body_fixed =  req->recv_iov[1].iov_len;
+        req->in.body_size  =  req->in.body_fixed;
+        req->in.body_size  += req->recv_iov[2].iov_len;
+        smb2_setup_bufinfo(req);
+        req->state = SMB2_REQUEST_DONE;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+static void smb2_transport_break_handler(struct tevent_req *subreq)
+{
+        struct smb2_transport *transport =
+                tevent_req_callback_data(subreq,
+                struct smb2_transport);
+        NTSTATUS status;
         uint8_t *body;
         uint16_t len, bloblen;
+        uint16_t len = 0;
         bool lease;
+        hdr = blob->data+NBT_HDR_SIZE;
+        body = hdr+SMB2_HDR_BODY;
+        bloblen = blob->length - SMB2_HDR_BODY;
+        if (bloblen < 2) {
+                DEBUG(1,("Discarding smb2 oplock reply of size %u\n",
+                        (unsigned)blob->length));
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        len = CVAL(body, 0x00);
+        if (len > bloblen) {
+                DEBUG(1,("Discarding smb2 oplock reply,"
+                        "packet claims %u byte body, only %u bytes seen\n",
+                        len, bloblen));
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        struct iovec *recv_iov = NULL;
+        transport->break_subreq = NULL;
+        status = smb2cli_req_recv(subreq, transport, &recv_iov, NULL, 0);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(recv_iov);
+                smb2_transport_dead(transport, status);
+                return;
+        }
+        /*
+         * Setup the subreq to handle the
+         * next incoming SMB2 Break.
+         */
+        subreq = smb2cli_req_create(transport,
+                                    transport->ev,
+                                    transport->conn,
+                                    SMB2_OP_BREAK,
+, /* additional_flags */
+, /*clear_flags */
+, /* timeout_msec */
+                                    NULL, /* tcon */
+                                    NULL, /* session */
+                                    NULL, /* body */
+, /* body_fixed */
+                                    NULL, /* dyn */
+, /* dyn_len */
+); /* max_dyn_len */
+        if (subreq != NULL) {
+                smbXcli_req_set_pending(subreq);
+                tevent_req_set_callback(subreq,
+                                        smb2_transport_break_handler,
+                                        transport);
+                transport->break_subreq = subreq;
+        }
+        body = recv_iov[1].iov_base;
+        len = recv_iov[1].iov_len;
+        if (recv_iov[1].iov_len >= 2) {
+                len = CVAL(body, 0x00);
+                if (len != recv_iov[1].iov_len) {
+                        len = recv_iov[1].iov_len;
+                }
+        }
 …
         } else {
                 DEBUG(1,("Discarding smb2 oplock reply of invalid size %u\n",
+                        (unsigned)blob->length));
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                        (unsigned)len));
+                TALLOC_FREE(recv_iov);
+                status = NT_STATUS_INVALID_NETWORK_RESPONSE;
+                smb2_transport_dead(transport, status);
+                return;
+        }
 …
                 level = CVAL(body, 0x02);
                 smb2_pull_handle(body+0x08, &h);
+                TALLOC_FREE(recv_iov);
                 transport->oplock.handler(transport, &h, level,
 …
                 ZERO_STRUCT(lb);
+                lb.new_epoch =                  SVAL(body, 0x2);
                 lb.break_flags =                SVAL(body, 0x4);
                 memcpy(&lb.current_lease.lease_key, body+0x8,
 …
                 lb.share_mask_hint =            SVAL(body, 0x28);
+                TALLOC_FREE(recv_iov);
                 transport->lease.handler(transport, &lb,
                     transport->lease.private_data);
 …
                         lease ? "lease" : "oplock"));
+        }
+        return NT_STATUS_OK;
+}
+struct smb2_transport_compount_response_state {
+        struct smb2_transport *transport;
+        DATA_BLOB blob;
+};
+static void smb2_transport_compound_response_handler(struct tevent_context *ctx,
+                                                     struct tevent_immediate *im,
+                                                     void *private_data)
+{
+        struct smb2_transport_compount_response_state *state =
+                talloc_get_type_abort(private_data,
+                struct smb2_transport_compount_response_state);
+        struct smb2_transport *transport = state->transport;
+        NTSTATUS status;
+        status = smb2_transport_finish_recv(transport, state->blob);
+        TALLOC_FREE(state);
+        if (!NT_STATUS_IS_OK(status)) {
+                smb2_transport_error(transport, status);
+        }
+}
+/*
+  we have a full request in our receive buffer - match it to a pending request
+  and process
+ */
+static NTSTATUS smb2_transport_finish_recv(void *private_data, DATA_BLOB blob)
+{
+        struct smb2_transport *transport = talloc_get_type(private_data,
+                                                             struct smb2_transport);
+        uint8_t *buffer, *hdr;
+        int len;
+        struct smb2_request *req = NULL;
+        uint64_t seqnum;
+        uint32_t flags;
+        uint16_t buffer_code;
+        uint32_t dynamic_size;
+        uint32_t i;
+        uint16_t opcode;
+        NTSTATUS status;
+        uint32_t next_ofs;
+        buffer = blob.data;
+        len = blob.length;
+        hdr = buffer+NBT_HDR_SIZE;
+        if (len < SMB2_MIN_SIZE) {
+                DEBUG(1,("Discarding smb2 reply of size %d\n", len));
+                goto error;
+        }
+        flags   = IVAL(hdr, SMB2_HDR_FLAGS);
+        seqnum  = BVAL(hdr, SMB2_HDR_MESSAGE_ID);
+        opcode  = SVAL(hdr, SMB2_HDR_OPCODE);
+        /* see MS-SMB2 3.2.5.19 */
+        if (seqnum == UINT64_MAX) {
+                if (opcode != SMB2_OP_BREAK) {
+                        DEBUG(1,("Discarding packet with invalid seqnum, "
+                                "opcode %u\n", opcode));
+                        return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                }
+                return smb2_handle_oplock_break(transport, &blob);
+        }
+        /* match the incoming request against the list of pending requests */
+        for (req=transport->pending_recv; req; req=req->next) {
+                if (req->seqnum == seqnum) break;
+        }
+        if (!req) {
+                DEBUG(1,("Discarding unmatched reply with seqnum 0x%llx op %d\n",
+                         (long long)seqnum, SVAL(hdr, SMB2_HDR_OPCODE)));
+                goto error;
+        }
+        /* fill in the 'in' portion of the matching request */
+        req->in.buffer = buffer;
+        talloc_steal(req, buffer);
+        req->in.size = len;
+        req->in.allocated = req->in.size;
+        req->in.hdr       = hdr;
+        req->in.body      = hdr+SMB2_HDR_BODY;
+        req->in.body_size = req->in.size - (SMB2_HDR_BODY+NBT_HDR_SIZE);
+        req->status       = NT_STATUS(IVAL(hdr, SMB2_HDR_STATUS));
+        if ((flags & SMB2_HDR_FLAG_ASYNC) &&
+            NT_STATUS_EQUAL(req->status, STATUS_PENDING)) {
+                req->cancel.can_cancel = true;
+                req->cancel.async_id = BVAL(hdr, SMB2_HDR_ASYNC_ID);
+                for (i=0; i< req->cancel.do_cancel; i++) {
+                        smb2_cancel(req);
+                }
+                talloc_free(buffer);
+                return NT_STATUS_OK;
+        }
+        next_ofs = IVAL(req->in.hdr, SMB2_HDR_NEXT_COMMAND);
+        if (next_ofs > 0) {
+                if (smb2_oob(&req->in, req->in.hdr + next_ofs, SMB2_HDR_BODY + 2)) {
+                        DEBUG(1,("SMB2 request invalid next offset 0x%x\n",
+                                 next_ofs));
+                        goto error;
+                }
+                req->in.size = NBT_HDR_SIZE + next_ofs;
+                req->in.body_size = req->in.size - (SMB2_HDR_BODY+NBT_HDR_SIZE);
+        }
+        if (req->session && req->session->signing_active) {
+                status = smb2_check_signature(&req->in,
+                                              req->session->session_key);
+                if (!NT_STATUS_IS_OK(status)) {
+                        /* the spec says to ignore packets with a bad signature */
+                        talloc_free(buffer);
+                        return status;
+                }
+        }
+        buffer_code = SVAL(req->in.body, 0);
+        req->in.body_fixed = (buffer_code & ~1);
+        req->in.dynamic = NULL;
+        dynamic_size = req->in.body_size - req->in.body_fixed;
+        if (dynamic_size != 0 && (buffer_code & 1)) {
+                req->in.dynamic = req->in.body + req->in.body_fixed;
+                if (smb2_oob(&req->in, req->in.dynamic, dynamic_size)) {
+                        DEBUG(1,("SMB2 request invalid dynamic size 0x%x\n",
+                                 dynamic_size));
+                        goto error;
+                }
+        }
+        smb2_setup_bufinfo(req);
+        DEBUG(2, ("SMB2 RECV seqnum=0x%llx\n", (long long)req->seqnum));
+        dump_data(5, req->in.body, req->in.body_size);
+        if (next_ofs > 0) {
+                struct tevent_immediate *im;
+                struct smb2_transport_compount_response_state *state;
+                state = talloc(transport,
+                               struct smb2_transport_compount_response_state);
+                if (!state) {
+                        goto error;
+                }
+                state->transport = transport;
+                state->blob = data_blob_talloc(state, NULL,
+                                               blob.length - next_ofs);
+                if (!state->blob.data) {
+                        goto error;
+                }
+                im = tevent_create_immediate(state);
+                if (!im) {
+                        TALLOC_FREE(state);
+                        goto error;
+                }
+                _smb2_setlen(state->blob.data, state->blob.length - NBT_HDR_SIZE);
+                memcpy(state->blob.data + NBT_HDR_SIZE,
+                       req->in.hdr + next_ofs,
+                       req->in.allocated - req->in.size);
+                tevent_schedule_immediate(im, transport->socket->event.ctx,
+                                          smb2_transport_compound_response_handler,
+                                          state);
+        }
+        /* if this request has an async handler then call that to
+           notify that the reply has been received. This might destroy
+           the request so it must happen last */
+        DLIST_REMOVE(transport->pending_recv, req);
+        req->state = SMB2_REQUEST_DONE;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+        return NT_STATUS_OK;
+error:
+        dump_data(5, buffer, len);
+        if (req) {
+                DLIST_REMOVE(transport->pending_recv, req);
+                req->state = SMB2_REQUEST_ERROR;
+                if (req->async.fn) {
+                        req->async.fn(req);
+                }
+        } else {
+                talloc_free(buffer);
+        }
+        return NT_STATUS_UNSUCCESSFUL;
+}
+/*
+  handle timeouts of individual smb requests
+*/
+static void smb2_timeout_handler(struct tevent_context *ev, struct tevent_timer *te,
+                                 struct timeval t, void *private_data)
+{
+        struct smb2_request *req = talloc_get_type(private_data, struct smb2_request);
+        if (req->state == SMB2_REQUEST_RECV) {
+                DLIST_REMOVE(req->transport->pending_recv, req);
+        }
+        req->status = NT_STATUS_IO_TIMEOUT;
+        req->state = SMB2_REQUEST_ERROR;
+        if (req->async.fn) {
+                req->async.fn(req);
+        }
+}
+/*
+  destroy a request
+*/
+static int smb2_request_destructor(struct smb2_request *req)
+{
+        if (req->state == SMB2_REQUEST_RECV) {
+                DLIST_REMOVE(req->transport->pending_recv, req);
+        }
+        return 0;
+}
+static NTSTATUS smb2_transport_raw_send(struct smb2_transport *transport,
+                                        struct smb2_request_buffer *buffer)
+{
+        DATA_BLOB blob;
+        NTSTATUS status;
+        /* check if the transport is dead */
+        if (transport->socket->sock == NULL) {
+                return NT_STATUS_NET_WRITE_FAULT;
+        }
+        _smb2_setlen(buffer->buffer, buffer->size - NBT_HDR_SIZE);
+        blob = data_blob_const(buffer->buffer, buffer->size);
+        status = packet_send(transport->packet, blob);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+}
+/*
+  put a request into the send queue
+*/
+void smb2_transport_send(struct smb2_request *req)
+{
+        NTSTATUS status;
+        DEBUG(2, ("SMB2 send seqnum=0x%llx\n", (long long)req->seqnum));
+        dump_data(5, req->out.body, req->out.body_size);
+        if (req->transport->compound.missing > 0) {
+                off_t next_ofs;
+                size_t pad = 0;
+                uint8_t *end;
+                end = req->out.buffer + req->out.size;
+                /*
+                 * we need to set dynamic otherwise
+                 * smb2_grow_buffer segfaults
+                 */
+                if (req->out.dynamic == NULL) {
+                        req->out.dynamic = end;
+                }
+                next_ofs = end - req->out.hdr;
+                if ((next_ofs % 8) > 0) {
+                        pad = 8 - (next_ofs % 8);
+                }
+                next_ofs += pad;
+                status = smb2_grow_buffer(&req->out, pad);
+                if (!NT_STATUS_IS_OK(status)) {
+                        req->state = SMB2_REQUEST_ERROR;
+                        req->status = status;
+                        return;
+                }
+                req->out.size += pad;
+                SIVAL(req->out.hdr, SMB2_HDR_NEXT_COMMAND, next_ofs);
+        }
+        /* possibly sign the message */
+        if (req->session && req->session->signing_active) {
+                status = smb2_sign_message(&req->out, req->session->session_key);
+                if (!NT_STATUS_IS_OK(status)) {
+                        req->state = SMB2_REQUEST_ERROR;
+                        req->status = status;
+                        return;
+                }
+        }
+        if (req->transport->compound.missing > 0) {
+                req->transport->compound.buffer = req->out;
+        } else {
+                status = smb2_transport_raw_send(req->transport,
+                                                 &req->out);
+                if (!NT_STATUS_IS_OK(status)) {
+                        req->state = SMB2_REQUEST_ERROR;
+                        req->status = status;
+                        return;
+                }
+        }
+        ZERO_STRUCT(req->out);
+        req->state = SMB2_REQUEST_RECV;
+        DLIST_ADD(req->transport->pending_recv, req);
+        /* add a timeout */
+        if (req->transport->options.request_timeout) {
+                event_add_timed(req->transport->socket->event.ctx, req,
+                                timeval_current_ofs(req->transport->options.request_timeout, 0),
+                                smb2_timeout_handler, req);
+        }
+        talloc_set_destructor(req, smb2_request_destructor);
+        TALLOC_FREE(recv_iov);
+}
 …
                                        uint32_t num)
+{
+        TALLOC_FREE(transport->compound.reqs);
         ZERO_STRUCT(transport->compound);
+        transport->compound.missing = num;
+        transport->compound.reqs = talloc_zero_array(transport,
+                                                     struct tevent_req *,
+                                                     num);
+        if (transport->compound.reqs == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
         return NT_STATUS_OK;
+}
 …
                                     uint16_t ask_num)
+{
+        transport->credits.ask_num = ask_num;
+}
+void smb2_transport_credits_set_charge(struct smb2_transport *transport,
+                                       uint16_t charge)
+{
+        transport->credits.charge = charge;
+        smb2cli_conn_set_max_credits(transport->conn, ask_num);
+}
 …
         struct smb2_transport *transport = talloc_get_type(private_data,
                                                            struct smb2_transport);
+        struct timeval next = timeval_add(&t, 0, transport->idle.period);
+        transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
+                                                      transport,
+                                                      next,
+                                                      idle_handler, transport);
+        struct timeval next;
         transport->idle.func(transport, transport->idle.private_data);
+        next = timeval_current_ofs_usec(transport->idle.period);
+        transport->idle.te = tevent_add_timer(transport->ev,
+                                              transport,
+                                              next,
+                                              idle_handler,
+                                              transport);
+}
 …
                                  void *private_data)
+{
+        TALLOC_FREE(transport->idle.te);
         transport->idle.func = idle_func;
         transport->idle.private_data = private_data;
         transport->idle.period = period;
+        if (transport->socket->event.te != NULL) {
+                talloc_free(transport->socket->event.te);
+        }
+        transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
+                                                      transport,
+                                                      timeval_current_ofs(0, period),
+                                                      idle_handler, transport);
+}
+        transport->idle.te = tevent_add_timer(transport->ev,
+                                              transport,
+                                              timeval_current_ofs_usec(period),
+                                              idle_handler,
+                                              transport);
+}

vendor/current/source4/libcli/smb2/util.c

-              r740
+              r988
         return (h1.data[0] == h2.data[0]) && (h1.data[1] == h2.data[1]);
+}
+bool smb2_util_handle_empty(const struct smb2_handle h)
+{
+        struct smb2_handle empty;
+        ZERO_STRUCT(empty);
+        return smb2_util_handle_equal(h, empty);
+}

vendor/current/source4/libcli/smb2/write.c

r414	r988
59	59	{
60	60	if (!smb2_request_receive(req) \|\|
61		~~smb2_request_is_error~~(req)) {
	61	!smb2_request_is_ok(req)) {
62	62	return smb2_request_destroy(req);
63	63	}

vendor/current/source4/libcli/smb2/wscript_build

-              r740
+              r988
 bld.SAMBA_SUBSYSTEM('LIBCLI_SMB2',
         source='transport.c request.c negprot.c session.c tcon.c create.c close.c connect.c getinfo.c write.c read.c setinfo.c find.c ioctl.c logoff.c tdis.c flush.c lock.c notify.c cancel.c keepalive.c break.c util.c signing.c lease_break.c',
+        source='transport.c request.c session.c tcon.c create.c close.c connect.c getinfo.c write.c read.c setinfo.c find.c ioctl.c logoff.c tdis.c flush.c lock.c notify.c cancel.c keepalive.c break.c util.c signing.c lease_break.c',
         autoproto='smb2_proto.h',
+        public_deps='LIBCLI_RAW LIBPACKET gensec'
+        deps='tevent-util cli_smb_common',
+        public_deps='smbclient-raw gensec samba-credentials tevent',
+        private_headers='smb2.h',
+        )

vendor/current/source4/libcli/smb_composite/appendacl.c

r740	r988
248	248	c->private_data = state;
249	249	c->state = COMPOSITE_STATE_IN_PROGRESS;
250		c->event_ctx = tree->session->transport->~~socket->event.ctx~~;
	250	c->event_ctx = tree->session->transport->ev;
251	251
252	252	/* setup structures for opening file */

vendor/current/source4/libcli/smb_composite/connect.c

-              r740
+              r988
 #include "param/param.h"
 #include "lib/util/util_net.h"
+#include "libcli/smb/smbXcli_base.h"
 /* the stages of this call */
 enum connect_stage {CONNECT_SOCKET,
-                    CONNECT_SESSION_REQUEST,
                     CONNECT_NEGPROT,
                     CONNECT_SESSION_SETUP,
 …
         struct smbcli_request *req;
         struct composite_context *creq;
+        struct tevent_req *subreq;
+        struct nbt_name calling, called;
 };
 …
 static void request_handler(struct smbcli_request *);
 static void composite_handler(struct composite_context *);
+static void subreq_handler(struct tevent_req *subreq);
 /*
 …
         status = smb_raw_tcon_recv(state->req, c, state->io_tcon);
         NT_STATUS_NOT_OK_RETURN(status);
+        if (state->io_tcon->tconx.out.options & SMB_EXTENDED_SIGNATURES) {
+                smb1cli_session_protect_session_key(io->out.tree->session->smbXcli);
+        }
         io->out.tree->tid = state->io_tcon->tconx.out.tid;
 …
         /* connect to a share using a tree connect */
         state->io_tcon->generic.level = RAW_TCON_TCONX;
         state->io_tcon->tconx.in.flags = 0;
+        state->io_tcon->tconx.in.flags = TCONX_FLAG_EXTENDED_RESPONSE;
         state->io_tcon->tconx.in.password = data_blob(NULL, 0);
 …
                  * would lead to an invalid uid in the anonymous fallback */
                 state->session->vuid = 0;
-                data_blob_free(&state->session->user_session_key);
                 talloc_free(state->session->gensec);
                 state->session->gensec = NULL;
 …
         /* connect to a share using a tree connect */
         state->io_tcon->generic.level = RAW_TCON_TCONX;
+        state->io_tcon->tconx.in.flags = 0;
+        state->io_tcon->tconx.in.flags = TCONX_FLAG_EXTENDED_RESPONSE;
+        state->io_tcon->tconx.in.flags |= TCONX_FLAG_EXTENDED_SIGNATURES;
         state->io_tcon->tconx.in.password = data_blob(NULL, 0);
 …
         NTSTATUS status;
+        status = smb_raw_negotiate_recv(state->req);
+        status = smb_raw_negotiate_recv(state->subreq);
+        TALLOC_FREE(state->subreq);
         NT_STATUS_NOT_OK_RETURN(status);
 …
         struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
+        state->req = smb_raw_negotiate_send(state->transport, io->in.options.unicode, io->in.options.max_protocol);
+        NT_STATUS_HAVE_NO_MEMORY(state->req);
+        state->req->async.fn = request_handler;
+        state->req->async.private_data = c;
+        /* the socket is up - we can initialise the smbcli transport layer */
+        state->transport = smbcli_transport_init(state->sock, state, true,
+                                                 &io->in.options);
+        NT_STATUS_HAVE_NO_MEMORY(state->transport);
+        state->subreq = smb_raw_negotiate_send(state,
+                                               state->transport->ev,
+                                               state->transport,
+                                               state->transport->options.min_protocol,
+                                               state->transport->options.max_protocol);
+        NT_STATUS_HAVE_NO_MEMORY(state->subreq);
+        tevent_req_set_callback(state->subreq, subreq_handler, c);
         state->stage = CONNECT_NEGPROT;
         return NT_STATUS_OK;
+}
-/*
-  a session request operation has completed
-*/
-static NTSTATUS connect_session_request(struct composite_context *c,
-                                        struct smb_composite_connect *io)
+{
-        struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
-        NTSTATUS status;
-        status = smbcli_transport_connect_recv(state->req);
-        NT_STATUS_NOT_OK_RETURN(status);
-        /* next step is a negprot */
-        return connect_send_negprot(c, io);
+}
 …
         struct connect_state *state = talloc_get_type(c->private_data, struct connect_state);
         NTSTATUS status;
-        struct nbt_name calling, called;
         status = smbcli_sock_connect_recv(state->creq, state, &state->sock);
         NT_STATUS_NOT_OK_RETURN(status);
-        /* the socket is up - we can initialise the smbcli transport layer */
-        state->transport = smbcli_transport_init(state->sock, state, true,
-                                                 &io->in.options);
-        NT_STATUS_HAVE_NO_MEMORY(state->transport);
         if (is_ipaddress(state->sock->hostname) &&
 …
+        }
+        make_nbt_name_client(&calling, cli_credentials_get_workstation(io->in.credentials));
+        nbt_choose_called_name(state, &called, io->in.called_name, NBT_NAME_SERVER);
+        /* we have a connected socket - next step is a session
+           request, if needed. Port 445 doesn't need it, so it goes
+           straight to the negprot */
+        if (state->sock->port == 445) {
+                status = nbt_name_dup(state->transport, &called,
+                                      &state->transport->called);
+                NT_STATUS_NOT_OK_RETURN(status);
+                return connect_send_negprot(c, io);
+        }
+        state->req = smbcli_transport_connect_send(state->transport, &calling, &called);
+        NT_STATUS_HAVE_NO_MEMORY(state->req);
+        state->req->async.fn = request_handler;
+        state->req->async.private_data = c;
+        state->stage = CONNECT_SESSION_REQUEST;
+        return NT_STATUS_OK;
+        /* next step is a negprot */
+        return connect_send_negprot(c, io);
+}
 …
         case CONNECT_SOCKET:
                 c->status = connect_socket(c, state->io);
-                break;
-        case CONNECT_SESSION_REQUEST:
-                c->status = connect_session_request(c, state->io);
                 break;
         case CONNECT_NEGPROT:
 …
 /*
+  handler for completion of a tevent_req sub-request
+*/
+static void subreq_handler(struct tevent_req *subreq)
+{
+        struct composite_context *c =
+                tevent_req_callback_data(subreq,
+                struct composite_context);
+        state_handler(c);
+}
+/*
   a function to establish a smbcli_tree from scratch
 */
 …
         c->state = COMPOSITE_STATE_IN_PROGRESS;
         c->private_data = state;
+        make_nbt_name_client(&state->calling,
+                             cli_credentials_get_workstation(io->in.credentials));
+        nbt_choose_called_name(state, &state->called,
+                               io->in.called_name, NBT_NAME_SERVER);
         state->creq = smbcli_sock_connect_send(state,
 …
                                                io->in.dest_host,
                                                resolve_ctx, c->event_ctx,
+                                               io->in.socket_options);
+                                               io->in.socket_options,
+                                               &state->calling,
+                                               &state->called);
         if (state->creq == NULL) goto failed;

vendor/current/source4/libcli/smb_composite/fsinfo.c

-              r740
+              r988
 struct composite_context *smb_composite_fsinfo_send(struct smbcli_tree *tree,
                                                     struct smb_composite_fsinfo *io,
+                                                    struct resolve_context *resolve_ctx)
+                                                    struct resolve_context *resolve_ctx,
+                                                    struct tevent_context *event_ctx)
+{
         struct composite_context *c;
 …
         if (c == NULL) goto failed;
+        c->event_ctx = event_ctx;
+        if (c->event_ctx == NULL) goto failed;
         state = talloc(c, struct fsinfo_state);
         if (state == NULL) goto failed;
 …
         state->io = io;
         state->connect = talloc(state, struct smb_composite_connect);
+        state->connect = talloc_zero(state, struct smb_composite_connect);
         if (state->connect == NULL) goto failed;
 …
                               TALLOC_CTX *mem_ctx,
                               struct smb_composite_fsinfo *io,
+                              struct resolve_context *resolve_ctx)
+{
+        struct composite_context *c = smb_composite_fsinfo_send(tree, io, resolve_ctx);
+                              struct resolve_context *resolve_ctx,
+                              struct tevent_context *ev)
+{
+        struct composite_context *c = smb_composite_fsinfo_send(tree, io, resolve_ctx, ev);
         return smb_composite_fsinfo_recv(c, mem_ctx);
+}

vendor/current/source4/libcli/smb_composite/loadfile.c

r414	r988
230	230	c->private_data = state;
231	231	c->state = COMPOSITE_STATE_IN_PROGRESS;
232		c->event_ctx = tree->session->transport->~~socket->event.ctx~~;
	232	c->event_ctx = tree->session->transport->ev;
233	233
234	234	/* setup for the open */

vendor/current/source4/libcli/smb_composite/savefile.c

r414	r988
226	226
227	227	c->state = COMPOSITE_STATE_IN_PROGRESS;
228		c->event_ctx = tree->session->transport->~~socket->event.ctx~~;
	228	c->event_ctx = tree->session->transport->ev;
229	229
230	230	state = talloc(c, struct savefile_state);

vendor/current/source4/libcli/smb_composite/sesssetup.c

-              r414
+              r988
 #include "libcli/composite/composite.h"
 #include "libcli/smb_composite/smb_composite.h"
-#include "libcli/smb_composite/proto.h"
 #include "libcli/auth/libcli_auth.h"
 #include "auth/auth.h"
 …
 #include "version.h"
 #include "param/param.h"
+#include "libcli/smb/smbXcli_base.h"
 struct sesssetup_state {
 …
         struct smb_composite_sesssetup *io;
         struct smbcli_request *req;
+        unsigned int logon_retries;
 };
 …
 /*
-  store the user session key for a transport
-*/
-static void set_user_session_key(struct smbcli_session *session,
-                                 const DATA_BLOB *session_key)
+{
-        session->user_session_key = data_blob_talloc(session,
-                                                     session_key->data,
-                                                     session_key->length);
+}
-/*
   handler for completion of a smbcli_request sub-request
 */
 …
         struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
         struct smbcli_session *session = req->session;
-        DATA_BLOB session_key = data_blob(NULL, 0);
         DATA_BLOB null_data_blob = data_blob(NULL, 0);
         NTSTATUS session_key_err, nt_status;
 …
                 state->io->out.vuid = state->setup.nt1.out.vuid;
                 if (NT_STATUS_EQUAL(c->status, NT_STATUS_LOGON_FAILURE)) {
                         /* we neet to reset the vuid for a new try */
+                        /* we need to reset the vuid for a new try */
                         session->vuid = 0;
                         if (cli_credentials_wrong_password(state->io->in.credentials)) {
 …
                 state->io->out.vuid = state->setup.spnego.out.vuid;
                 if (NT_STATUS_EQUAL(c->status, NT_STATUS_LOGON_FAILURE)) {
+                        const char *principal;
                         /* we need to reset the vuid for a new try */
                         session->vuid = 0;
+                        if (cli_credentials_wrong_password(state->io->in.credentials)) {
+                        principal = gensec_get_target_principal(session->gensec);
+                        if (principal == NULL) {
+                                const char *hostname = gensec_get_target_hostname(session->gensec);
+                                const char *service  = gensec_get_target_service(session->gensec);
+                                if (hostname != NULL && service != NULL) {
+                                        principal = talloc_asprintf(state, "%s/%s", service, hostname);
+                                }
+                        }
+                        if (cli_credentials_failed_kerberos_login(state->io->in.credentials, principal, &state->logon_retries) ||
+                            cli_credentials_wrong_password(state->io->in.credentials)) {
                                 nt_status = session_setup_spnego(c, session,
                                                                       state->io,
 …
                          * requirements */
                         state->gensec_status = gensec_update(session->gensec, state,
+                        state->gensec_status = gensec_update_ev(session->gensec, state, c->event_ctx,
                                                          state->setup.spnego.out.secblob,
                                                          &state->setup.spnego.in.secblob);
 …
+                }
+                if (NT_STATUS_IS_OK(state->remote_status)) {
+                if (cli_credentials_is_anonymous(state->io->in.credentials)) {
+                        /*
+                         * anonymous => no signing
+                         */
+                } else if (NT_STATUS_IS_OK(state->remote_status)) {
+                        DATA_BLOB session_key;
                         if (state->setup.spnego.in.secblob.length) {
                                 c->status = NT_STATUS_INTERNAL_ERROR;
                                 break;
+                        }
                         session_key_err = gensec_session_key(session->gensec, &session_key);
+                        session_key_err = gensec_session_key(session->gensec, session, &session_key);
                         if (NT_STATUS_IS_OK(session_key_err)) {
+                                set_user_session_key(session, &session_key);
+                                smbcli_transport_simple_set_signing(session->transport, session_key, null_data_blob);
+                                smb1cli_conn_activate_signing(session->transport->conn,
+                                                              session_key,
+                                                              null_data_blob);
+                        }
+                        c->status = smb1cli_session_set_session_key(session->smbXcli,
+                                                                    session_key);
+                        data_blob_free(&session_key);
+                        if (!NT_STATUS_IS_OK(c->status)) {
+                                break;
+                        }
+                }
 …
                         state->req = smb_raw_sesssetup_send(session, &state->setup);
                         session->vuid = vuid;
+                        if (state->req) {
+                        if (state->req &&
+                            !smb1cli_conn_signing_is_active(state->req->transport->conn)) {
                                 state->req->sign_caller_checks = true;
+                        }
 …
         if (check_req) {
+                bool ok;
                 check_req->sign_caller_checks = false;
+                if (!smbcli_request_check_sign_mac(check_req)) {
+                ok = smb1cli_conn_check_signing(check_req->transport->conn,
+                                                check_req->in.buffer, 1);
+                if (!ok) {
                         c->status = NT_STATUS_ACCESS_DENIED;
+                }
                 talloc_free(check_req);
                 check_req = NULL;
+        }
-        /* enforce the local signing required flag */
-        if (NT_STATUS_IS_OK(c->status) && !cli_credentials_is_anonymous(state->io->in.credentials)) {
-                if (!session->transport->negotiate.sign_info.doing_signing
-                    && session->transport->negotiate.sign_info.mandatory_signing) {
-                        DEBUG(0, ("SMB signing required, but server does not support it\n"));
-                        c->status = NT_STATUS_ACCESS_DENIED;
+                }
+        }
 …
+{
         NTSTATUS nt_status = NT_STATUS_INTERNAL_ERROR;
+        struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
+        DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, session->transport->socket->hostname, cli_credentials_get_domain(io->in.credentials));
+        struct sesssetup_state *state = talloc_get_type(c->private_data,
+                                                        struct sesssetup_state);
+        const char *domain = cli_credentials_get_domain(io->in.credentials);
+        /*
+         * domain controllers tend to reject the NTLM v2 blob
+         * if the netbiosname is not valid (e.g. IP address or FQDN)
+         * so just leave it away (as Windows client do)
+         */
+        DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, NULL, domain);
         DATA_BLOB session_key = data_blob(NULL, 0);
         int flags = CLI_CRED_NTLM_AUTH;
-        smbcli_temp_set_signing(session->transport);
         if (session->options.lanman_auth) {
 …
         if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
+                if (!cli_credentials_is_anonymous(io->in.credentials) &&
+                    session->options.ntlmv2_auth &&
+                    session->transport->options.use_spnego)
+                {
+                        /*
+                         * Don't send an NTLMv2_RESPONSE without NTLMSSP
+                         * if we want to use spnego
+                         */
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
                 nt_status = cli_credentials_get_ntlm_response(io->in.credentials, state,
                                                               &flags,
                                                               session->transport->negotiate.secblob,
+                                                              NULL, /* server_timestamp */
                                                               names_blob,
                                                               &state->setup.nt1.in.password1,
 …
+        }
+        if (NT_STATUS_IS_OK(nt_status)) {
+                smbcli_transport_simple_set_signing(session->transport, session_key,
+                                                    state->setup.nt1.in.password2);
+                set_user_session_key(session, &session_key);
+                data_blob_free(&session_key);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                /*
+                 * plain text => no signing
+                 */
+                return (*req)->status;
+        }
+        if (cli_credentials_is_anonymous(io->in.credentials)) {
+                /*
+                 * anonymous => no signing
+                 */
+                return (*req)->status;
+        }
+        smb1cli_conn_activate_signing(session->transport->conn,
+                                      session_key,
+                                      state->setup.nt1.in.password2);
+        nt_status = smb1cli_session_set_session_key(session->smbXcli,
+                                                    session_key);
+        data_blob_free(&session_key);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+        }
 …
+{
         NTSTATUS nt_status;
+        struct sesssetup_state *state = talloc_get_type(c->private_data, struct sesssetup_state);
+        struct sesssetup_state *state = talloc_get_type(c->private_data,
+                                                        struct sesssetup_state);
         const char *password = cli_credentials_get_password(io->in.credentials);
+        DATA_BLOB names_blob = NTLMv2_generate_names_blob(state, session->transport->socket->hostname, cli_credentials_get_domain(io->in.credentials));
+        /*
+         * domain controllers tend to reject the NTLM v2 blob
+         * if the netbiosname is not valid (e.g. IP address or FQDN)
+         * so just leave it away (as Windows client do)
+         */
         DATA_BLOB session_key;
-        int flags = 0;
-        if (session->options.lanman_auth) {
-                flags |= CLI_CRED_LANMAN_AUTH;
+        }
-        if (session->options.ntlmv2_auth) {
-                flags |= CLI_CRED_NTLMv2_AUTH;
+        }
         state->setup.old.level      = RAW_SESSSETUP_OLD;
 …
         if (session->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
+                DATA_BLOB names_blob = data_blob_null;
+                int flags = 0;
+                if (!cli_credentials_is_anonymous(io->in.credentials) &&
+                    !session->options.lanman_auth)
+                {
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
+                flags |= CLI_CRED_LANMAN_AUTH;
                 nt_status = cli_credentials_get_ntlm_response(io->in.credentials, state,
                                                               &flags,
                                                               session->transport->negotiate.secblob,
+                                                              NULL, /* server_timestamp */
                                                               names_blob,
                                                               &state->setup.old.in.password,
 …
                                                               NULL, &session_key);
                 NT_STATUS_NOT_OK_RETURN(nt_status);
+                set_user_session_key(session, &session_key);
+                nt_status = smb1cli_session_set_session_key(session->smbXcli,
+                                                            session_key);
                 data_blob_free(&session_key);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
         } else if (session->options.plaintext_auth) {
                 state->setup.old.in.password = data_blob_talloc(state, password, strlen(password));
 …
         state->setup.spnego.in.workgroup    = io->in.workgroup;
+        smbcli_temp_set_signing(session->transport);
+        status = gensec_client_start(session, &session->gensec, c->event_ctx,
+        status = gensec_client_start(session, &session->gensec,
                                      io->in.gensec_settings);
         if (!NT_STATUS_IS_OK(status)) {
 …
+        }
+        status = gensec_set_target_hostname(session->gensec, session->transport->socket->hostname);
+        status = gensec_set_target_hostname(session->gensec,
+                        smbXcli_conn_remote_name(session->transport->conn));
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("Failed to start set GENSEC target hostname: %s\n",
 …
+        }
+        if ((const void *)chosen_oid == (const void *)GENSEC_OID_SPNEGO) {
+                status = gensec_update(session->gensec, state,
+        if (strequal(chosen_oid, GENSEC_OID_SPNEGO)) {
+                status = gensec_update_ev(session->gensec, state,
+                                       c->event_ctx,
                                        session->transport->negotiate.secblob,
                                        &state->setup.spnego.in.secblob);
         } else {
+                status = gensec_update(session->gensec, state,
+                status = gensec_update_ev(session->gensec, state,
+                                       c->event_ctx,
                                        data_blob(NULL, 0),
                                        &state->setup.spnego.in.secblob);
 …
          * which comes within the response itself
          */
+        (*req)->sign_caller_checks = true;
+        if (!smb1cli_conn_signing_is_active((*req)->transport->conn)) {
+                (*req)->sign_caller_checks = true;
+        }
         return (*req)->status;
 …
         NTSTATUS status;
         c = composite_create(session, session->transport->socket->event.ctx);
+        c = composite_create(session, session->transport->ev);
         if (c == NULL) return NULL;

vendor/current/source4/libcli/smb_composite/smb2.c

-              r414
+              r988
 #include "includes.h"
+#include <tevent.h>
+#include "lib/util/tevent_ntstatus.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
 …
         struct smb2_request *req;
         ctx = composite_create(tree, tree->session->transport->socket->event.ctx);
+        ctx = composite_create(tree, tree->session->transport->ev);
         if (ctx == NULL) return NULL;
 …
         struct smb2_request *req;
         ctx = composite_create(tree, tree->session->transport->socket->event.ctx);
+        ctx = composite_create(tree, tree->session->transport->ev);
         if (ctx == NULL) return NULL;
 …
         struct smb2_request *req;
         ctx = composite_create(tree, tree->session->transport->socket->event.ctx);
+        ctx = composite_create(tree, tree->session->transport->ev);
         if (ctx == NULL) return NULL;
 …
+}
+/*
+  continue after the setfileinfo in a composite setpathinfo
+ */
+static void continue_setpathinfo_close(struct smb2_request *req)
+{
+        struct composite_context *ctx = talloc_get_type(req->async.private_data,
+                                                        struct composite_context);
+        struct smb2_tree *tree = req->tree;
+        struct smb2_close close_parm;
+        NTSTATUS status;
+        union smb_setfileinfo *io2 = talloc_get_type(ctx->private_data,
+                                                     union smb_setfileinfo);
+        status = smb2_setinfo_recv(req);
+        if (!NT_STATUS_IS_OK(status)) {
+                composite_error(ctx, status);
+                return;
+        }
+        ZERO_STRUCT(close_parm);
+        close_parm.in.file.handle = io2->generic.in.file.handle;
+        req = smb2_close_send(tree, &close_parm);
+        composite_continue_smb2(ctx, req, continue_close, ctx);
+}
+/*
+  continue after the create in a composite setpathinfo
+ */
+static void continue_setpathinfo(struct smb2_request *req)
+{
+        struct composite_context *ctx = talloc_get_type(req->async.private_data,
+                                                        struct composite_context);
+        struct smb2_tree *tree = req->tree;
+        struct smb2_create create_parm;
+        NTSTATUS status;
+        union smb_setfileinfo *io2 = talloc_get_type(ctx->private_data,
+                                                     union smb_setfileinfo);
+        status = smb2_create_recv(req, ctx, &create_parm);
+        if (!NT_STATUS_IS_OK(status)) {
+                composite_error(ctx, status);
+                return;
+        }
+        io2->generic.in.file.handle = create_parm.out.file.handle;
+        req = smb2_setinfo_file_send(tree, io2);
+        composite_continue_smb2(ctx, req, continue_setpathinfo_close, ctx);
+}
+struct smb2_composite_setpathinfo_state {
+        struct smb2_tree *tree;
+        union smb_setfileinfo io;
+        NTSTATUS set_status;
+        struct smb2_create cr;
+        struct smb2_close cl;
+};
+static void smb2_composite_setpathinfo_create_done(struct smb2_request *smb2req);
 /*
   composite SMB2 setpathinfo call
 */
+struct composite_context *smb2_composite_setpathinfo_send(struct smb2_tree *tree,
+                                                          union smb_setfileinfo *io)
+{
+        struct composite_context *ctx;
+        struct smb2_create create_parm;
+        struct smb2_request *req;
+        union smb_setfileinfo *io2;
+        ctx = composite_create(tree, tree->session->transport->socket->event.ctx);
+        if (ctx == NULL) return NULL;
+        ZERO_STRUCT(create_parm);
+        create_parm.in.desired_access     = SEC_FLAG_MAXIMUM_ALLOWED;
+        create_parm.in.create_disposition = NTCREATEX_DISP_OPEN;
+        create_parm.in.share_access =
+struct tevent_req *smb2_composite_setpathinfo_send(TALLOC_CTX *mem_ctx,
+                                                   struct tevent_context *ev,
+                                                   struct smb2_tree *tree,
+                                                   const union smb_setfileinfo *io)
+{
+        struct tevent_req *req;
+        struct smb2_composite_setpathinfo_state *state;
+        struct smb2_request *smb2req;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct smb2_composite_setpathinfo_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->tree = tree;
+        state->io = *io;
+        state->cr.in.desired_access     = SEC_FLAG_MAXIMUM_ALLOWED;
+        state->cr.in.create_disposition = NTCREATEX_DISP_OPEN;
+        state->cr.in.share_access =
                 NTCREATEX_SHARE_ACCESS_DELETE|
                 NTCREATEX_SHARE_ACCESS_READ|
                 NTCREATEX_SHARE_ACCESS_WRITE;
+        create_parm.in.create_options = 0;
+        create_parm.in.fname = io->generic.in.file.path;
+        if (create_parm.in.fname[0] == '\\') {
+                create_parm.in.fname++;
+        }
+        req = smb2_create_send(tree, &create_parm);
+        io2 = talloc(ctx, union smb_setfileinfo);
+        if (composite_nomem(io2, ctx)) {
+                return ctx;
+        }
+        *io2 = *io;
+        ctx->private_data = io2;
+        composite_continue_smb2(ctx, req, continue_setpathinfo, ctx);
+        return ctx;
+}
+        state->cr.in.create_options = 0;
+        state->cr.in.fname = state->io.generic.in.file.path;
+        if (state->cr.in.fname[0] == '\\') {
+                state->cr.in.fname++;
+        }
+        smb2req = smb2_create_send(tree, &state->cr);
+        if (tevent_req_nomem(smb2req, req)) {
+                return tevent_req_post(req, ev);
+        }
+        smb2req->async.fn = smb2_composite_setpathinfo_create_done;
+        smb2req->async.private_data = req;
+        return req;
+}
+static void smb2_composite_setpathinfo_setinfo_done(struct smb2_request *smb2req);
+static void smb2_composite_setpathinfo_create_done(struct smb2_request *smb2req)
+{
+        struct tevent_req *req =
+                talloc_get_type_abort(smb2req->async.private_data,
+                struct tevent_req);
+        struct smb2_composite_setpathinfo_state *state =
+                tevent_req_data(req,
+                struct smb2_composite_setpathinfo_state);
+        NTSTATUS status;
+        status = smb2_create_recv(smb2req, state, &state->cr);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        state->io.generic.in.file.handle = state->cr.out.file.handle;
+        smb2req = smb2_setinfo_file_send(state->tree, &state->io);
+        if (tevent_req_nomem(smb2req, req)) {
+                return;
+        }
+        smb2req->async.fn = smb2_composite_setpathinfo_setinfo_done;
+        smb2req->async.private_data = req;
+}
+static void smb2_composite_setpathinfo_close_done(struct smb2_request *smb2req);
+static void smb2_composite_setpathinfo_setinfo_done(struct smb2_request *smb2req)
+{
+        struct tevent_req *req =
+                talloc_get_type_abort(smb2req->async.private_data,
+                struct tevent_req);
+        struct smb2_composite_setpathinfo_state *state =
+                tevent_req_data(req,
+                struct smb2_composite_setpathinfo_state);
+        NTSTATUS status;
+        status = smb2_setinfo_recv(smb2req);
+        state->set_status = status;
+        state->cl.in.file.handle = state->io.generic.in.file.handle;
+        smb2req = smb2_close_send(state->tree, &state->cl);
+        if (tevent_req_nomem(smb2req, req)) {
+                return;
+        }
+        smb2req->async.fn = smb2_composite_setpathinfo_close_done;
+        smb2req->async.private_data = req;
+}
+static void smb2_composite_setpathinfo_close_done(struct smb2_request *smb2req)
+{
+        struct tevent_req *req =
+                talloc_get_type_abort(smb2req->async.private_data,
+                struct tevent_req);
+        struct smb2_composite_setpathinfo_state *state =
+                tevent_req_data(req,
+                struct smb2_composite_setpathinfo_state);
+        NTSTATUS status;
+        status = smb2_close_recv(smb2req, &state->cl);
+        if (tevent_req_nterror(req, state->set_status)) {
+                return;
+        }
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS smb2_composite_setpathinfo_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                tevent_req_received(req);
+                return status;
+        }
+        tevent_req_received(req);
+        return NT_STATUS_OK;
+}
 /*
 …
 NTSTATUS smb2_composite_setpathinfo(struct smb2_tree *tree, union smb_setfileinfo *io)
+{
+        struct composite_context *c = smb2_composite_setpathinfo_send(tree, io);
+        return composite_wait_free(c);
+}
+        struct tevent_req *subreq;
+        NTSTATUS status;
+        bool ok;
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev = tree->session->transport->ev;
+        if (frame == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        subreq = smb2_composite_setpathinfo_send(frame, ev, tree, io);
+        if (subreq == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ok = tevent_req_poll(subreq, ev);
+        if (!ok) {
+                status = map_nt_error_from_unix_common(errno);
+                TALLOC_FREE(frame);
+                return status;
+        }
+        status = smb2_composite_setpathinfo_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(frame);
+                return status;
+        }
+        TALLOC_FREE(frame);
+        return NT_STATUS_OK;
+}

vendor/current/source4/libcli/smb_composite/smb_composite.h

-              r740
+              r988
 */
+#include "libcli/raw/signing.h"
+#ifndef __SMB_COMPOSITE_H__
+#define __SMB_COMPOSITE_H__
 #include "libcli/raw/libcliraw.h"
 #include "libcli/smb2/smb2.h"
 /*
   a composite open/read(s)/close request that loads a whole file
 …
         } out;
 };
+struct composite_context *smb_composite_loadfile_send(struct smbcli_tree *tree,
+                                                     struct smb_composite_loadfile *io);
+NTSTATUS smb_composite_loadfile_recv(struct composite_context *c, TALLOC_CTX *mem_ctx);
+NTSTATUS smb_composite_loadfile(struct smbcli_tree *tree,
+                                TALLOC_CTX *mem_ctx,
+                                struct smb_composite_loadfile *io);
 struct smb_composite_fetchfile {
 …
 };
+struct composite_context *smb_composite_fetchfile_send(struct smb_composite_fetchfile *io,
+                                                       struct tevent_context *event_ctx);
+NTSTATUS smb_composite_fetchfile_recv(struct composite_context *c,
+                                      TALLOC_CTX *mem_ctx);
+NTSTATUS smb_composite_fetchfile(struct smb_composite_fetchfile *io,
+                                 TALLOC_CTX *mem_ctx);
 /*
   a composite open/write(s)/close request that saves a whole file from
 …
 };
+struct composite_context *smb_composite_savefile_send(struct smbcli_tree *tree,
+                                                      struct smb_composite_savefile *io);
+NTSTATUS smb_composite_savefile_recv(struct composite_context *c);
+NTSTATUS smb_composite_savefile(struct smbcli_tree *tree,
+                                struct smb_composite_savefile *io);
 /*
 …
 };
+struct composite_context *smb_composite_connect_send(struct smb_composite_connect *io,
+                                                     TALLOC_CTX *mem_ctx,
+                                                     struct resolve_context *resolve_ctx,
+                                                     struct tevent_context *event_ctx);
+NTSTATUS smb_composite_connect_recv(struct composite_context *c, TALLOC_CTX *mem_ctx);
+NTSTATUS smb_composite_connect(struct smb_composite_connect *io, TALLOC_CTX *mem_ctx,
+                               struct resolve_context *resolve_ctx,
+                               struct tevent_context *ev);
 /*
 …
         } out;
 };
+struct composite_context *smb_composite_sesssetup_send(struct smbcli_session *session,
+                                                       struct smb_composite_sesssetup *io);
+NTSTATUS smb_composite_sesssetup_recv(struct composite_context *c);
+NTSTATUS smb_composite_sesssetup(struct smbcli_session *session, struct smb_composite_sesssetup *io);
 /*
 …
 };
+struct composite_context *smb_composite_fsinfo_send(struct smbcli_tree *tree,
+                                                    struct smb_composite_fsinfo *io,
+                                                    struct resolve_context *resolve_ctx,
+                                                    struct tevent_context *event_ctx);
+NTSTATUS smb_composite_fsinfo_recv(struct composite_context *c, TALLOC_CTX *mem_ctx);
+NTSTATUS smb_composite_fsinfo(struct smbcli_tree *tree,
+                              TALLOC_CTX *mem_ctx,
+                              struct smb_composite_fsinfo *io,
+                              struct resolve_context *resolve_ctx,
+                              struct tevent_context *ev);
 /*
   composite call for appending new acl to the file's security descriptor and get
 …
         } out;
 };
+struct composite_context *smb_composite_appendacl_send(struct smbcli_tree *tree,
+                                                        struct smb_composite_appendacl *io);
+NTSTATUS smb_composite_appendacl_recv(struct composite_context *c, TALLOC_CTX *mem_ctx);
+NTSTATUS smb_composite_appendacl(struct smbcli_tree *tree,
+                                TALLOC_CTX *mem_ctx,
+                                struct smb_composite_appendacl *io);
 /*
 …
 struct resolve_context;
+#include "libcli/smb_composite/proto.h"
+struct composite_context *smb2_composite_unlink_send(struct smb2_tree *tree,
+                                                     union smb_unlink *io);
+NTSTATUS smb2_composite_unlink(struct smb2_tree *tree, union smb_unlink *io);
+struct composite_context *smb2_composite_mkdir_send(struct smb2_tree *tree,
+                                                     union smb_mkdir *io);
+NTSTATUS smb2_composite_mkdir(struct smb2_tree *tree, union smb_mkdir *io);
+struct composite_context *smb2_composite_rmdir_send(struct smb2_tree *tree,
+                                                    struct smb_rmdir *io);
+NTSTATUS smb2_composite_rmdir(struct smb2_tree *tree, struct smb_rmdir *io);
+struct tevent_req *smb2_composite_setpathinfo_send(TALLOC_CTX *mem_ctx,
+                                                   struct tevent_context *ev,
+                                                   struct smb2_tree *tree,
+                                                   const union smb_setfileinfo *io);
+NTSTATUS smb2_composite_setpathinfo_recv(struct tevent_req *req);
+NTSTATUS smb2_composite_setpathinfo(struct smb2_tree *tree, union smb_setfileinfo *io);
+#endif /* __SMB_COMPOSITE_H__ */

vendor/current/source4/libcli/util/clilsa.c

-              r860
+              r988
 #include "librpc/gen_ndr/ndr_lsa_c.h"
 #include "libcli/util/clilsa.h"
+#include "libcli/smb/smbXcli_base.h"
 struct smblsa_state {
         struct dcerpc_pipe *pipe;
+        struct dcerpc_binding_handle *binding_handle;
         struct smbcli_tree *ipc_tree;
         struct policy_handle handle;
 …
+{
         struct smblsa_state *lsa;
+        struct dcerpc_pipe *lsa_pipe;
         NTSTATUS status;
         struct lsa_OpenPolicy r;
 …
         /* connect to IPC$ */
         tcon.generic.level = RAW_TCON_TCONX;
+        tcon.tconx.in.flags = 0;
+        tcon.tconx.in.flags = TCONX_FLAG_EXTENDED_RESPONSE;
+        tcon.tconx.in.flags |= TCONX_FLAG_EXTENDED_SIGNATURES;
         tcon.tconx.in.password = data_blob(NULL, 0);
         tcon.tconx.in.path = "ipc$";
 …
         lsa->ipc_tree->tid = tcon.tconx.out.tid;
+        lsa->pipe = dcerpc_pipe_init(lsa, cli->transport->socket->event.ctx);
+        if (lsa->pipe == NULL) {
+        if (tcon.tconx.out.options & SMB_EXTENDED_SIGNATURES) {
+                smb1cli_session_protect_session_key(cli->session->smbXcli);
+        }
+        lsa_pipe = dcerpc_pipe_init(lsa, cli->transport->ev);
+        if (lsa_pipe == NULL) {
                 talloc_free(lsa);
                 return NT_STATUS_NO_MEMORY;
 …
         /* open the LSA pipe */
         status = dcerpc_pipe_open_smb(lsa->pipe, lsa->ipc_tree, NDR_LSARPC_NAME);
+        status = dcerpc_pipe_open_smb(lsa_pipe, lsa->ipc_tree, NDR_LSARPC_NAME);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(lsa);
 …
         /* bind to the LSA pipe */
         status = dcerpc_bind_auth_none(lsa->pipe, &ndr_table_lsarpc);
+        status = dcerpc_bind_auth_none(lsa_pipe, &ndr_table_lsarpc);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(lsa);
                 return status;
+        }
+        lsa->binding_handle = lsa_pipe->binding_handle;
         /* open a lsa policy handle */
 …
         r.out.handle = &lsa->handle;
         status = dcerpc_lsa_OpenPolicy_r(lsa->pipe->binding_handle, lsa, &r);
+        status = dcerpc_lsa_OpenPolicy_r(lsa->binding_handle, lsa, &r);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(lsa);
 …
         r.out.rights = rights;
         status = dcerpc_lsa_EnumAccountRights_r(cli->lsa->pipe->binding_handle, mem_ctx, &r);
+        status = dcerpc_lsa_EnumAccountRights_r(cli->lsa->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
         r.out.domains = &domains;
         status = dcerpc_lsa_LookupSids_r(cli->lsa->pipe->binding_handle, mem_ctx2, &r);
+        status = dcerpc_lsa_LookupSids_r(cli->lsa->binding_handle, mem_ctx2, &r);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(mem_ctx2);
 …
         r.out.domains = &domains;
         status = dcerpc_lsa_LookupNames_r(cli->lsa->pipe->binding_handle, mem_ctx2, &r);
+        status = dcerpc_lsa_LookupNames_r(cli->lsa->binding_handle, mem_ctx2, &r);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(mem_ctx2);
 …
         r.in.rights = rights;
         status = dcerpc_lsa_AddAccountRights_r(cli->lsa->pipe->binding_handle, mem_ctx, &r);
+        status = dcerpc_lsa_AddAccountRights_r(cli->lsa->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
         r.in.rights = rights;
         status = dcerpc_lsa_RemoveAccountRights_r(cli->lsa->pipe->binding_handle, mem_ctx, &r);
+        status = dcerpc_lsa_RemoveAccountRights_r(cli->lsa->binding_handle, mem_ctx, &r);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;

vendor/current/source4/libcli/util/pyerrors.h

-              r740
+              r988
 #define PyErr_FromWERROR(err) Py_BuildValue("(i,s)", W_ERROR_V(err), discard_const_p(char, win_errstr(err)))
+#define PyErr_FromHRESULT(err) Py_BuildValue("(i,s)", HRES_ERROR_V(err), discard_const_p(char, hresult_errstr_const(err)))
 #define PyErr_FromNTSTATUS(status) Py_BuildValue("(i,s)", NT_STATUS_V(status), discard_const_p(char, get_friendly_nt_error_msg(status)))
 …
+        }
+#define PyErr_WERROR_IS_ERR_RAISE(status) \
+#define PyErr_NTSTATUS_NOT_OK_RAISE(status) \
+        if (!NT_STATUS_IS_OK(status)) { \
+                PyErr_SetNTSTATUS(status); \
+                return NULL; \
+        }
+#define PyErr_WERROR_NOT_OK_RAISE(status) \
         if (!W_ERROR_IS_OK(status)) { \
                 PyErr_SetWERROR(status); \

vendor/current/source4/libcli/wbclient/wbclient.c

-              r740
+              r988
 #include "includes.h"
 #include <tevent.h>
+#include "lib/util/tevent_unix.h"
 #include "libcli/wbclient/wbclient.h"
+/**
+ * Initialize the wbclient context, talloc_free() when done.
+ *
+ * \param mem_ctx talloc context to allocate memory from
+ * \param msg_ctx message context to use
+ * \param
+ */
+struct wbc_context *wbc_init(TALLOC_CTX *mem_ctx,
+                             struct messaging_context *msg_ctx,
+                             struct tevent_context *event_ctx)
+{
+        struct wbc_context *ctx;
+        ctx = talloc(mem_ctx, struct wbc_context);
+        if (ctx == NULL) return NULL;
+        ctx->event_ctx = event_ctx;
+        ctx->irpc_handle = irpc_binding_handle_by_name(ctx, msg_ctx,
+                                                       "winbind_server",
+                                                       &ndr_table_winbind);
+        if (ctx->irpc_handle == NULL) {
+                talloc_free(ctx);
+#include "nsswitch/wb_reqtrans.h"
+#include "system/network.h"
+#include "libcli/util/error.h"
+#include "libcli/security/dom_sid.h"
+static int wb_simple_trans(struct tevent_context *ev, int fd,
+                           struct winbindd_request *wb_req,
+                           TALLOC_CTX *mem_ctx,
+                           struct winbindd_response **resp, int *err)
+{
+        struct tevent_req *req;
+        bool polled;
+        int ret;
+        req = wb_simple_trans_send(ev, ev, NULL, fd, wb_req);
+        if (req == NULL) {
+                *err = ENOMEM;
+                return -1;
+        }
+        polled = tevent_req_poll(req, ev);
+        if (!polled) {
+                *err = errno;
+                DEBUG(10, ("tevent_req_poll returned %s\n",
+                           strerror(*err)));
+                return -1;
+        }
+        ret = wb_simple_trans_recv(req, mem_ctx, resp, err);
+        TALLOC_FREE(req);
+        return ret;
+}
+static const char *winbindd_socket_dir(void)
+{
+#ifdef SOCKET_WRAPPER
+        const char *env_dir;
+        env_dir = getenv("SELFTEST_WINBINDD_SOCKET_DIR");
+        if (env_dir) {
+                return env_dir;
+        }
+#endif
+        return WINBINDD_SOCKET_DIR;
+}
+static int winbindd_pipe_sock(void)
+{
+        struct sockaddr_un sunaddr = {};
+        int ret, fd;
+        char *path;
+        ret = asprintf(&path, "%s/%s", winbindd_socket_dir(),
+                       WINBINDD_SOCKET_NAME);
+        if (ret == -1) {
+                errno = ENOMEM;
+                return -1;
+        }
+        sunaddr.sun_family = AF_UNIX;
+        strlcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path));
+        free(path);
+        fd = socket(AF_UNIX, SOCK_STREAM, 0);
+        if (fd == -1) {
+                return -1;
+        }
+        ret = connect(fd, (struct sockaddr *)&sunaddr, sizeof(sunaddr));
+        if (ret == -1) {
+                int err = errno;
+                close(fd);
+                errno = err;
+                return -1;
+        }
+        return fd;
+}
+NTSTATUS wbc_sids_to_xids(struct tevent_context *ev, struct id_map *ids,
+                          uint32_t count)
+{
+        TALLOC_CTX *mem_ctx;
+        struct winbindd_request req = {};
+        struct winbindd_response *resp;
+        uint32_t i;
+        int fd, ret, err;
+        char *sids, *p;
+        size_t sidslen;
+        fd = winbindd_pipe_sock();
+        if (fd == -1) {
+                return map_nt_error_from_unix_common(errno);
+        }
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                close(fd);
+                return NT_STATUS_NO_MEMORY;
+        }
+        sidslen = count * (DOM_SID_STR_BUFLEN + 1);
+        sids = talloc_array(mem_ctx, char, sidslen);
+        if (sids == NULL) {
+                close(fd);
+                TALLOC_FREE(mem_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
+        p = sids;
+        for (i=0; i<count; i++) {
+                p += dom_sid_string_buf(ids[i].sid, p, sidslen - (p - sids));
+                *p++ = '\n';
+        }
+        *p++ = '\0';
+        DEBUG(10, ("sids=\n%s", sids));
+        req.length = sizeof(struct winbindd_request);
+        req.cmd = WINBINDD_SIDS_TO_XIDS;
+        req.pid = getpid();
+        req.extra_data.data = sids;
+        req.extra_len = (p - sids);
+        ret = wb_simple_trans(ev, fd, &req, mem_ctx, &resp, &err);
+        if (ret == -1) {
+                return map_nt_error_from_unix_common(err);
+        }
+        close(fd);
+        if (resp->result != WINBINDD_OK || p == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        p = resp->extra_data.data;
+        for (i=0; i<count; i++) {
+                struct unixid *id = &ids[i].xid;
+                char *q;
+                switch (p[0]) {
+                case 'U':
+                        id->type = ID_TYPE_UID;
+                        id->id = strtoul(p+1, &q, 10);
+                        break;
+                case 'G':
+                        id->type = ID_TYPE_GID;
+                        id->id = strtoul(p+1, &q, 10);
+                        break;
+                case 'B':
+                        id->type = ID_TYPE_BOTH;
+                        id->id = strtoul(p+1, &q, 10);
+                        break;
+                default:
+                        id->type = ID_TYPE_NOT_SPECIFIED;
+                        id->id = UINT32_MAX;
+                        q = strchr(p, '\n');
+                        break;
+                };
+                ids[i].status = ID_MAPPED;
+                if (q == NULL || q[0] != '\n') {
+                        TALLOC_FREE(mem_ctx);
+                        return NT_STATUS_INTERNAL_ERROR;
+                }
+                p = q+1;
+        }
+        return NT_STATUS_OK;
+}
+struct wbc_id_to_sid_state {
+        struct winbindd_request wbreq;
+        struct dom_sid sid;
+};
+static void wbc_id_to_sid_done(struct tevent_req *subreq);
+static struct tevent_req *wbc_id_to_sid_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             int fd, const struct unixid *id)
+{
+        struct tevent_req *req, *subreq;
+        struct wbc_id_to_sid_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct wbc_id_to_sid_state);
+        if (req == NULL) {
                 return NULL;
+        }
+        return ctx;
+}
+struct wbc_idmap_state {
+        struct composite_context *ctx;
+        struct winbind_get_idmap *req;
+        switch(id->type) {
+        case ID_TYPE_UID:
+                state->wbreq.cmd = WINBINDD_UID_TO_SID;
+                state->wbreq.data.uid = id->id;
+                break;
+        case ID_TYPE_GID:
+                state->wbreq.cmd = WINBINDD_GID_TO_SID;
+                state->wbreq.data.gid = id->id;
+                break;
+        default:
+                tevent_req_error(req, ENOENT);
+                return tevent_req_post(req, ev);
+        }
+        subreq = wb_simple_trans_send(state, ev, NULL, fd, &state->wbreq);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, wbc_id_to_sid_done, req);
+        return req;
+}
+static void wbc_id_to_sid_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct wbc_id_to_sid_state *state = tevent_req_data(
+                req, struct wbc_id_to_sid_state);
+        struct winbindd_response *wbresp;
+        int ret, err;
+        ret = wb_simple_trans_recv(subreq, state, &wbresp, &err);
+        TALLOC_FREE(subreq);
+        if (ret == -1) {
+                tevent_req_error(req, err);
+                return;
+        }
+        if ((wbresp->result != WINBINDD_OK) ||
+            !dom_sid_parse(wbresp->data.sid.sid, &state->sid)) {
+                tevent_req_error(req, ENOENT);
+                return;
+        }
+        tevent_req_done(req);
+}
+static int wbc_id_to_sid_recv(struct tevent_req *req, struct dom_sid *sid)
+{
+        struct wbc_id_to_sid_state *state = tevent_req_data(
+                req, struct wbc_id_to_sid_state);
+        int err;
+        if (tevent_req_is_unix_error(req, &err)) {
+                return err;
+        }
+        sid_copy(sid, &state->sid);
+        return 0;
+}
+struct wbc_ids_to_sids_state {
+        struct tevent_context *ev;
+        int fd;
         struct id_map *ids;
+        uint32_t count;
+        uint32_t idx;
 };
+static void sids_to_xids_recv_ids(struct tevent_req *subreq);
+struct composite_context *wbc_sids_to_xids_send(struct wbc_context *wbc_ctx,
+                                                TALLOC_CTX *mem_ctx,
+                                                uint32_t count,
+                                                struct id_map *ids)
+{
+        struct composite_context *ctx;
+        struct wbc_idmap_state *state;
+        struct tevent_req *subreq;
+        DEBUG(5, ("wbc_sids_to_xids called\n"));
+        ctx = composite_create(mem_ctx, wbc_ctx->event_ctx);
+        if (ctx == NULL) return NULL;
+        state = talloc(ctx, struct wbc_idmap_state);
+        if (composite_nomem(state, ctx)) return ctx;
+        ctx->private_data = state;
+        state->req = talloc(state, struct winbind_get_idmap);
+        if (composite_nomem(state->req, ctx)) return ctx;
+        state->req->in.count = count;
+        state->req->in.level = WINBIND_IDMAP_LEVEL_SIDS_TO_XIDS;
+        state->req->in.ids = ids;
+        state->ctx = ctx;
+        subreq = dcerpc_winbind_get_idmap_r_send(state,
+                                                 wbc_ctx->event_ctx,
+                                                 wbc_ctx->irpc_handle,
+                                                 state->req);
+        if (composite_nomem(subreq, ctx)) return ctx;
+        tevent_req_set_callback(subreq, sids_to_xids_recv_ids, state);
+        return ctx;
+}
+static void sids_to_xids_recv_ids(struct tevent_req *subreq)
+{
+        struct wbc_idmap_state *state =
+                tevent_req_callback_data(subreq,
+                struct wbc_idmap_state);
+        state->ctx->status = dcerpc_winbind_get_idmap_r_recv(subreq, state);
+static void wbc_ids_to_sids_done(struct tevent_req *subreq);
+static struct tevent_req *wbc_ids_to_sids_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+        int fd, struct id_map *ids, uint32_t count)
+{
+        struct tevent_req *req, *subreq;
+        struct wbc_ids_to_sids_state *state;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct wbc_ids_to_sids_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->fd = fd;
+        state->ids = ids;
+        state->count = count;
+        if (count == 0) {
+                tevent_req_done(req);
+                return tevent_req_post(req, ev);
+        }
+        subreq = wbc_id_to_sid_send(state, state->ev, state->fd,
+                                    &state->ids[state->idx].xid);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, wbc_ids_to_sids_done, req);
+        return req;
+}
+static void wbc_ids_to_sids_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct wbc_ids_to_sids_state *state = tevent_req_data(
+                req, struct wbc_ids_to_sids_state);
+        struct id_map *id;
+        struct dom_sid sid;
+        int ret;
+        ret = wbc_id_to_sid_recv(subreq, &sid);
         TALLOC_FREE(subreq);
+        if (!composite_is_ok(state->ctx)) return;
+        state->ids = state->req->out.ids;
+        composite_done(state->ctx);
+}
+NTSTATUS wbc_sids_to_xids_recv(struct composite_context *ctx,
+                               struct id_map **ids)
+{
+        NTSTATUS status = composite_wait(ctx);
+                DEBUG(5, ("wbc_sids_to_xids_recv called\n"));
+        if (NT_STATUS_IS_OK(status)) {
+                struct wbc_idmap_state *state = talloc_get_type_abort(
+                                                        ctx->private_data,
+                                                        struct wbc_idmap_state);
+                *ids = state->ids;
+        }
+        id = &state->ids[state->idx];
+        if (ret == 0) {
+                id->status = ID_MAPPED;
+                id->sid = dom_sid_dup(state->ids, &sid);
+                if (id->sid == NULL) {
+                        tevent_req_error(req, ENOMEM);
+                        return;
+                }
+        } else {
+                id->status = ID_UNMAPPED;
+                id->sid = NULL;
+        }
+        state->idx += 1;
+        if (state->idx == state->count) {
+                tevent_req_done(req);
+                return;
+        }
+        subreq = wbc_id_to_sid_send(state, state->ev, state->fd,
+                                    &state->ids[state->idx].xid);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, wbc_ids_to_sids_done, req);
+}
+static int wbc_ids_to_sids_recv(struct tevent_req *req)
+{
+        int err;
+        if (tevent_req_is_unix_error(req, &err)) {
+                return err;
+        }
+        return 0;
+}
+NTSTATUS wbc_xids_to_sids(struct tevent_context *ev, struct id_map *ids,
+                          uint32_t count)
+{
+        struct tevent_req *req;
+        NTSTATUS status;
+        bool polled;
+        int ret, fd;
+        DEBUG(5, ("wbc_xids_to_sids called: %u ids\n", (unsigned)count));
+        fd = winbindd_pipe_sock();
+        if (fd == -1) {
+                status = map_nt_error_from_unix_common(errno);
+                DEBUG(10, ("winbindd_pipe_sock returned %s\n",
+                           strerror(errno)));
+                return status;
+        }
+        req = wbc_ids_to_sids_send(ev, ev, fd, ids, count);
+        if (req == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        polled = tevent_req_poll(req, ev);
+        if (!polled) {
+                status = map_nt_error_from_unix_common(errno);
+                DEBUG(10, ("tevent_req_poll returned %s\n",
+                           strerror(errno)));
+                goto done;
+        }
+        ret = wbc_ids_to_sids_recv(req);
+        TALLOC_FREE(req);
+        if (ret != 0) {
+                status = map_nt_error_from_unix_common(ret);
+                DEBUG(10, ("tevent_req_poll returned %s\n",
+                           strerror(ret)));
+        } else {
+                status = NT_STATUS_OK;
+        }
+done:
+        close(fd);
         return status;
+}
-static void xids_to_sids_recv_ids(struct tevent_req *subreq);
-struct composite_context *wbc_xids_to_sids_send(struct wbc_context *wbc_ctx,
-                                                TALLOC_CTX *mem_ctx,
-                                                uint32_t count,
-                                                struct id_map *ids)
+{
-        struct composite_context *ctx;
-        struct wbc_idmap_state *state;
-        struct tevent_req *subreq;
-        DEBUG(5, ("wbc_xids_to_sids called\n"));
-        ctx = composite_create(mem_ctx, wbc_ctx->event_ctx);
-        if (ctx == NULL) return NULL;
-        state = talloc(ctx, struct wbc_idmap_state);
-        if (composite_nomem(state, ctx)) return ctx;
-        ctx->private_data = state;
-        state->req = talloc(state, struct winbind_get_idmap);
-        if (composite_nomem(state->req, ctx)) return ctx;
-        state->req->in.count = count;
-        state->req->in.level = WINBIND_IDMAP_LEVEL_XIDS_TO_SIDS;
-        state->req->in.ids = ids;
-        state->ctx = ctx;
-        subreq = dcerpc_winbind_get_idmap_r_send(state,
-                                                 wbc_ctx->event_ctx,
-                                                 wbc_ctx->irpc_handle,
-                                                 state->req);
-        if (composite_nomem(subreq, ctx)) return ctx;
-        tevent_req_set_callback(subreq, xids_to_sids_recv_ids, state);
-        return ctx;
+}
-static void xids_to_sids_recv_ids(struct tevent_req *subreq)
+{
-        struct wbc_idmap_state *state =
-                tevent_req_callback_data(subreq,
-                struct wbc_idmap_state);
-        state->ctx->status = dcerpc_winbind_get_idmap_r_recv(subreq, state);
-        TALLOC_FREE(subreq);
-        if (!composite_is_ok(state->ctx)) return;
-        state->ids = state->req->out.ids;
-        composite_done(state->ctx);
+}
-NTSTATUS wbc_xids_to_sids_recv(struct composite_context *ctx,
-                               struct id_map **ids)
+{
-        NTSTATUS status = composite_wait(ctx);
-                DEBUG(5, ("wbc_xids_to_sids_recv called\n"));
-        if (NT_STATUS_IS_OK(status)) {
-                struct wbc_idmap_state *state = talloc_get_type_abort(
-                                                        ctx->private_data,
-                                                        struct wbc_idmap_state);
-                *ids = state->ids;
+        }
-        return status;
+}

vendor/current/source4/libcli/wbclient/wbclient.h

-              r740
+              r988
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+#include "lib/messaging/irpc.h"
+#include "libcli/composite/composite.h"
+#include "librpc/gen_ndr/ndr_winbind_c.h"
+#include "librpc/gen_ndr/idmap.h"
+struct wbc_context {
+        struct tevent_context *event_ctx;
+        struct dcerpc_binding_handle *irpc_handle;
+};
+NTSTATUS wbc_sids_to_xids(struct tevent_context *ev, struct id_map *ids,
+                          uint32_t count);
+struct wbc_context *wbc_init(TALLOC_CTX *mem_ctx,
+                             struct messaging_context *msg_ctx,
+                             struct tevent_context *event_ctx);
+struct composite_context *wbc_sids_to_xids_send(struct wbc_context *wbc_ctx,
+                                                TALLOC_CTX *mem_ctx,
+                                                uint32_t count,
+                                                struct id_map *ids);
+NTSTATUS wbc_sids_to_xids_recv(struct composite_context *ctx,
+                               struct id_map **ids);
+struct composite_context *wbc_xids_to_sids_send(struct wbc_context *wbc_ctx,
+                                                TALLOC_CTX *mem_ctx,
+                                                uint32_t count,
+                                                struct id_map *ids);
+NTSTATUS wbc_xids_to_sids_recv(struct composite_context *ctx,
+                               struct id_map **ids);
+NTSTATUS wbc_xids_to_sids(struct tevent_context *ev, struct id_map *ids,
+                          uint32_t count);

vendor/current/source4/libcli/wbclient/wscript_build

-              r740
+              r988
 #!/usr/bin/env python
+bld.SAMBA_SUBSYSTEM('LIBWBCLIENT_OLD',
+        source='wbclient.c',
+        public_deps='errors events',
+        deps='NDR_WINBIND MESSAGING RPC_NDR_WINBIND'
+bld.SAMBA_LIBRARY('LIBWBCLIENT_OLD',
+                  source='wbclient.c',
+                  public_deps='samba-errors events',
+                  cflags='-DWINBINDD_SOCKET_DIR=\"%s\"' % bld.env.WINBINDD_SOCKET_DIR,
+                  deps='WB_REQTRANS NDR_WINBIND MESSAGING RPC_NDR_WINBIND',
+                  private_library=True
+        )

vendor/current/source4/libcli/wrepl/winsrepl.c

-              r740
+              r988
+{
         struct interface *ifaces;
         load_interfaces(lp_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
         return iface_best_ip(ifaces, peer_ip);
+        load_interface_list(lp_ctx, lp_ctx, &ifaces);
+        return iface_list_best_ip(ifaces, peer_ip);
+}
 …
                                                 &state->local_address);
         if (ret != 0) {
                 NTSTATUS status = map_nt_error_from_unix(errno);
+                NTSTATUS status = map_nt_error_from_unix_common(errno);
                 tevent_req_nterror(req, status);
                 return tevent_req_post(req, ev);
 …
                                                 &state->remote_address);
         if (ret != 0) {
                 NTSTATUS status = map_nt_error_from_unix(errno);
+                NTSTATUS status = map_nt_error_from_unix_common(errno);
                 tevent_req_nterror(req, status);
                 return tevent_req_post(req, ev);
 …
                               NULL);
         if (!ok) {
                 tevent_req_nomem(NULL, req);
+                tevent_req_oom(req);
                 return tevent_req_post(req, ev);
+        }
 …
                                             state, &state->stream, NULL);
         if (ret != 0) {
                 NTSTATUS status = map_nt_error_from_unix(sys_errno);
+                NTSTATUS status = map_nt_error_from_unix_common(sys_errno);
                 tevent_req_nterror(req, status);
                 return;
 …
         if (wrepl_socket->stream == NULL) {
                 tevent_req_nterror(req, NT_STATUS_INVALID_CONNECTION);
+                tevent_req_nterror(req, NT_STATUS_CONNECTION_DISCONNECTED);
                 return tevent_req_post(req, ev);
+        }
 …
                               NULL);
         if (!ok) {
                 tevent_req_nomem(NULL, req);
+                tevent_req_oom(req);
                 return tevent_req_post(req, ev);
+        }
 …
         if (state->caller.wrepl_socket->stream == NULL) {
                 tevent_req_nterror(req, NT_STATUS_INVALID_CONNECTION);
+                tevent_req_nterror(req, NT_STATUS_CONNECTION_DISCONNECTED);
                 return;
+        }
 …
         TALLOC_FREE(subreq);
         if (ret == -1) {
                 NTSTATUS status = map_nt_error_from_unix(sys_errno);
+                NTSTATUS status = map_nt_error_from_unix_common(sys_errno);
                 TALLOC_FREE(state->caller.wrepl_socket->stream);
                 tevent_req_nterror(req, status);
 …
         if (state->caller.wrepl_socket->stream == NULL) {
                 tevent_req_nterror(req, NT_STATUS_INVALID_CONNECTION);
+                tevent_req_nterror(req, NT_STATUS_CONNECTION_DISCONNECTED);
                 return;
+        }
 …
         TALLOC_FREE(subreq);
         if (ret == -1) {
                 NTSTATUS status = map_nt_error_from_unix(sys_errno);
+                NTSTATUS status = map_nt_error_from_unix_common(sys_errno);
                 TALLOC_FREE(state->caller.wrepl_socket->stream);
                 tevent_req_nterror(req, status);

vendor/current/source4/libcli/wscript_build

-              r740
+              r988
 bld.RECURSE('wbclient')
-bld.SAMBA_LIBRARY('errors',
-                  source='../../libcli/util/doserr.c util/errormap.c util/nterr.c',
-                  public_headers='../../libcli/util/error.h ../../libcli/util/ntstatus.h ../../libcli/util/doserr.h ../../libcli/util/werror.h',
-                  header_path='core',
-                  deps='talloc',
-                  private_library=True
+                  )
 bld.SAMBA_SUBSYSTEM('LIBSAMBA_TSOCKET',
         source='../../libcli/util/tstream.c',
         public_deps='LIBTSOCKET UTIL_TEVENT'
+        public_deps='LIBTSOCKET tevent-util'
+        )
 …
         source='util/clilsa.c',
         autoproto='util/clilsa.h',
         public_deps='RPC_NDR_LSA',
         deps='security'
+        public_deps='RPC_NDR_LSA dcerpc',
+        deps='samba-security'
+        )
 bld.SAMBA_SUBSYSTEM('LIBCLI_COMPOSITE',
+bld.SAMBA_SUBSYSTEM('cli_composite',
         source='composite/composite.c',
         autoproto='composite/proto.h',
 …
 bld.SAMBA_SUBSYSTEM('LIBCLI_SMB_COMPOSITE',
         source='smb_composite/loadfile.c smb_composite/savefile.c smb_composite/connect.c smb_composite/sesssetup.c smb_composite/fetchfile.c smb_composite/appendacl.c smb_composite/fsinfo.c smb_composite/smb2.c',
         autoproto='smb_composite/proto.h',
         deps='LIBCLI_SMB2',
         public_deps='LIBCLI_COMPOSITE credentials gensec LIBCLI_RESOLVE'
+        deps='LIBCLI_SMB2 tevent-util',
+        public_deps='cli_composite samba-credentials gensec LIBCLI_RESOLVE tevent',
+        private_headers='smb_composite/smb_composite.h',
+        )
+bld.SAMBA_PYTHON('pysmb',
+    source='pysmb.c',
+    deps='LIBCLI_SMB_COMPOSITE LIBCLI_SMB2 tevent-util pyparam_util pytalloc-util',
+        public_deps='cli_composite samba-credentials gensec LIBCLI_RESOLVE tevent param_options',
+    realname='samba/smb.so'
+    )
 bld.SAMBA_SUBSYSTEM('LIBCLI_DGRAM',
 …
         autoproto='resolve/proto.h',
         deps='roken',
         public_deps='NDR_NBT LIBTSOCKET'
+        public_deps='ndr_nbt LIBTSOCKET'
+        )
 bld.SAMBA_SUBSYSTEM('LP_RESOLVE',
         source='resolve/bcast.c resolve/nbtlist.c resolve/wins.c resolve/dns_ex.c resolve/file.c resolve/host.c resolve/resolve_lp.c',
+        source='resolve/bcast.c resolve/nbtlist.c resolve/wins.c resolve/dns_ex.c resolve/host.c resolve/lmhosts.c resolve/resolve_lp.c',
         autoproto='resolve/lp_proto.h',
         deps='cli-nbt samba-hostconfig netif'
+        deps='cli-nbt samba-hostconfig netif addns'
+        )
 bld.SAMBA_SUBSYSTEM('LIBCLI_FINDDCS',
         source='finddcs_nbt.c finddcs_cldap.c',
+        source='finddcs_cldap.c',
         autoproto='finddcs_proto.h',
         public_deps='cli-nbt MESSAGING RPC_NDR_IRPC LIBCLI_CLDAP'
+        public_deps='cli_cldap'
+        )
 …
 bld.SAMBA_SUBSYSTEM('LIBCLI_SMB',
         source='clireadwrite.c cliconnect.c clifile.c clilist.c clitrans2.c climessage.c clideltree.c',
         autoproto='libcli_proto.h',
         public_deps='LIBCLI_RAW errors LIBCLI_AUTH LIBCLI_SMB_COMPOSITE cli-nbt security LIBCLI_RESOLVE LIBCLI_DGRAM LIBCLI_SMB2 LIBCLI_FINDDCS samba_socket'
+        private_headers='libcli.h:smb_cli.h',
+        public_deps='smbclient-raw samba-errors LIBCLI_AUTH LIBCLI_SMB_COMPOSITE cli-nbt samba-security LIBCLI_RESOLVE LIBCLI_DGRAM LIBCLI_SMB2 LIBCLI_FINDDCS samba_socket'
+        )
 bld.SAMBA_SUBSYSTEM('LIBCLI_RAW',
+bld.SAMBA_LIBRARY('smbclient-raw',
         source='raw/rawfile.c raw/smb_signing.c raw/clisocket.c raw/clitransport.c raw/clisession.c raw/clitree.c raw/clierror.c raw/rawrequest.c raw/rawreadwrite.c raw/rawsearch.c raw/rawsetfileinfo.c raw/raweas.c raw/rawtrans.c raw/clioplock.c raw/rawnegotiate.c raw/rawfsinfo.c raw/rawfileinfo.c raw/rawnotify.c raw/rawioctl.c raw/rawacl.c raw/rawdate.c raw/rawlpq.c raw/rawshadow.c',
         autoproto='raw/raw_proto.h',
         public_deps='samba_socket LIBPACKET LIBCRYPTO',
+        deps='LIBCLI_COMPOSITE LIBCLI_RESOLVE security ndr samba-util errors CHARSET talloc LIBCLI_SMB_COMPOSITE tevent NDR_NBT_BUF LIBCLI_SMB_COMMON'
+        deps='cli_composite LIBCLI_RESOLVE samba-security ndr samba-util samba-errors charset talloc LIBCLI_SMB_COMPOSITE tevent cli_smb_common',
+        private_headers='raw/request.h:smb_request.h raw/signing.h:smb_raw_signing.h raw/libcliraw.h:smb_cliraw.h raw/interfaces.h:smb_raw_interfaces.h raw/smb.h:smb_raw.h raw/trans2.h:smb_raw_trans2.h',
+        private_library=True,
+        )

Context Navigation

Legend:

Download in other formats: