Changeset 740 for vendor/current/source3/libsmb

vendor/current/source3/libsmb/async_smb.c

-              r594
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../lib/async_req/async_sock.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "../lib/util/tevent_unix.h"
+#include "async_smb.h"
+#include "smb_crypt.h"
+#include "libsmb/nmblib.h"
 /*
 …
+        }
+        /* if the client uses dos errors, but there is no error,
+           we should return no error here, otherwise it looks
+           like an unknown bad NT_STATUS. jmcd */
+        if (CVAL(buf, smb_rcls) == 0)
+                return NT_STATUS_OK;
+        return NT_STATUS_DOS(CVAL(buf, smb_rcls), SVAL(buf,smb_err));
+        return dos_to_ntstatus(CVAL(buf, smb_rcls), SVAL(buf,smb_err));
+}
 …
         uint32_t seqnum;
         int chain_num;
+        int chain_length;
         struct tevent_req **chained_requests;
 };
 …
         int num_pending = talloc_array_length(cli->pending);
         int i;
+        if (state->mid != 0) {
+                /*
+                 * This is a [nt]trans[2] request which waits
+                 * for more than one reply.
+                 */
+                return;
+        }
         if (num_pending == 1) {
 …
 static int cli_smb_req_destructor(struct tevent_req *req)
+{
+        struct cli_smb_state *state = tevent_req_data(
+                req, struct cli_smb_state);
+        /*
+         * Make sure we really remove it from
+         * the pending array on destruction.
+         */
+        state->mid = 0;
         cli_smb_req_unset_pending(req);
         return 0;
 …
+}
+uint32_t cli_smb_req_seqnum(struct tevent_req *req)
+{
+        struct cli_smb_state *state = tevent_req_data(
+                req, struct cli_smb_state);
+        return state->seqnum;
+}
+void cli_smb_req_set_seqnum(struct tevent_req *req, uint32_t seqnum)
+{
+        struct cli_smb_state *state = tevent_req_data(
+                req, struct cli_smb_state);
+        state->seqnum = seqnum;
+}
 static size_t iov_len(const struct iovec *iov, int count)
+{
 …
         state->iov_count = iov_count + 3;
+        endtime = timeval_current_ofs(0, cli->timeout * 1000);
+        if (!tevent_req_set_endtime(result, ev, endtime)) {
+                tevent_req_nomem(NULL, result);
+        if (cli->timeout) {
+                endtime = timeval_current_ofs(cli->timeout / 1000,
+                                              (cli->timeout % 1000) * 1000);
+                if (!tevent_req_set_endtime(result, ev, endtime)) {
+                        tevent_req_nomem(NULL, result);
+                }
+        }
         return result;
 …
         struct tevent_req *req;
         struct cli_smb_state *state;
-        struct tevent_context *ev;
         NTSTATUS status;
         uint8_t *inbuf;
 …
         req = cli->pending[i];
         state = tevent_req_data(req, struct cli_smb_state);
-        ev = state->ev;
         if (!oplock_break /* oplock breaks are not signed */
 …
                 state->inbuf = talloc_move(state, &inbuf);
                 talloc_set_destructor(req, NULL);
+                cli_smb_req_destructor(req);
+                cli_smb_req_unset_pending(req);
+                state->chain_num = 0;
+                state->chain_length = 1;
                 tevent_req_done(req);
         } else {
 …
                         state->inbuf = inbuf;
                         state->chain_num = i;
+                        state->chain_length = num_chained;
                         tevent_req_done(chain[i]);
+                }
 …
                 req = cli->pending[0];
                 talloc_set_destructor(req, NULL);
                 cli_smb_req_destructor(req);
+                cli_smb_req_unset_pending(req);
                 tevent_req_nterror(req, status);
+        }
+}
+NTSTATUS cli_smb_recv(struct tevent_req *req, uint8_t min_wct,
+                      uint8_t *pwct, uint16_t **pvwv,
+NTSTATUS cli_smb_recv(struct tevent_req *req,
+                      TALLOC_CTX *mem_ctx, uint8_t **pinbuf,
+                      uint8_t min_wct, uint8_t *pwct, uint16_t **pvwv,
                       uint32_t *pnum_bytes, uint8_t **pbytes)
+{
 …
         if (state->inbuf == NULL) {
+                if (min_wct != 0) {
+                        return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                }
+                if (pinbuf) {
+                        *pinbuf = NULL;
+                }
+                if (pwct) {
+                        *pwct = 0;
+                }
+                if (pvwv) {
+                        *pvwv = NULL;
+                }
+                if (pnum_bytes) {
+                        *pnum_bytes = 0;
+                }
+                if (pbytes) {
+                        *pbytes = NULL;
+                }
                 /* This was a request without a reply */
                 return NT_STATUS_OK;
 …
         status = cli_pull_error((char *)state->inbuf);
+        if (!have_andx_command((char *)state->inbuf, wct_ofs)
+            && NT_STATUS_IS_ERR(status)) {
+                /*
+                 * The last command takes the error code. All further commands
+                 * down the requested chain will get a
+                 * NT_STATUS_REQUEST_ABORTED.
+                 */
+                return status;
+        }
+        if (!have_andx_command((char *)state->inbuf, wct_ofs)) {
+                if ((cmd == SMBsesssetupX)
+                    && NT_STATUS_EQUAL(
+                            status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                        /*
+                         * NT_STATUS_MORE_PROCESSING_REQUIRED is a
+                         * valid return code for session setup
+                         */
+                        goto no_err;
+                }
+                if (NT_STATUS_IS_ERR(status)) {
+                        /*
+                         * The last command takes the error code. All
+                         * further commands down the requested chain
+                         * will get a NT_STATUS_REQUEST_ABORTED.
+                         */
+                        return status;
+                }
+        }
+no_err:
         wct = CVAL(state->inbuf, wct_ofs);
 …
                 *pbytes = (uint8_t *)state->inbuf + bytes_offset + 2;
+        }
+        return NT_STATUS_OK;
+        if ((mem_ctx != NULL) && (pinbuf != NULL)) {
+                if (state->chain_num == state->chain_length-1) {
+                        *pinbuf = talloc_move(mem_ctx, &state->inbuf);
+                } else {
+                        *pinbuf = state->inbuf;
+                }
+        }
+        return status;
+}
 …
         uint32_t num_bytes;
         uint8_t *bytes;
+        uint8_t *inbuf;
         NTSTATUS status;
+        status = cli_smb_recv(subreq, 8, &wct, &vwv, &num_bytes, &bytes);
+        status = cli_smb_recv(subreq, state, &inbuf, 8, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
-                TALLOC_FREE(subreq);
                 tevent_req_nterror(req, status);
                 return;

vendor/current/source3/libsmb/cliconnect.c

-              r597
+              r740
    Copyright (C) Andrew Tridgell 1994-1998
    Copyright (C) Andrew Bartlett 2001-2003
+   Copyright (C) Volker Lendecke 2011
+   Copyright (C) Jeremy Allison 2011
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "popt_common.h"
 #include "../libcli/auth/libcli_auth.h"
 #include "../libcli/auth/spnego.h"
 #include "smb_krb5.h"
+#include "../libcli/auth/ntlmssp.h"
+#include "libads/kerberos_proto.h"
+#include "krb5_env.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "libsmb/nmblib.h"
 static const struct {
 …
 #define STAR_SMBSERVER "*SMBSERVER"
+/********************************************************
+ Utility function to ensure we always return at least
+ a valid char * pointer to an empty string for the
+ cli->server_os, cli->server_type and cli->server_domain
+ strings.
+*******************************************************/
+static NTSTATUS smb_bytes_talloc_string(struct cli_state *cli,
+                                        char *inbuf,
+                                        char **dest,
+                                        uint8_t *src,
+                                        size_t srclen,
+                                        ssize_t *destlen)
+{
+        *destlen = clistr_pull_talloc(cli,
+                                inbuf,
+                                SVAL(inbuf, smb_flg2),
+                                dest,
+                                (char *)src,
+                                srclen,
+                                STR_TERMINATE);
+        if (*destlen == -1) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        if (*dest == NULL) {
+                *dest = talloc_strdup(cli, "");
+                if (*dest == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+        }
+        return NT_STATUS_OK;
+}
 /**
  * Set the user session key for a connection
 …
 ****************************************************************************/
+static NTSTATUS cli_session_setup_lanman2(struct cli_state *cli,
+                                          const char *user,
+struct cli_session_setup_lanman2_state {
+        struct cli_state *cli;
+        uint16_t vwv[10];
+        const char *user;
+};
+static void cli_session_setup_lanman2_done(struct tevent_req *subreq);
+static struct tevent_req *cli_session_setup_lanman2_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+        struct cli_state *cli, const char *user,
+        const char *pass, size_t passlen,
+        const char *workgroup)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_session_setup_lanman2_state *state;
+        DATA_BLOB lm_response = data_blob_null;
+        uint16_t *vwv;
+        uint8_t *bytes;
+        char *tmp;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_session_setup_lanman2_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        state->user = user;
+        vwv = state->vwv;
+        /*
+         * LANMAN servers predate NT status codes and Unicode and
+         * ignore those smb flags so we must disable the corresponding
+         * default capabilities that would otherwise cause the Unicode
+         * and NT Status flags to be set (and even returned by the
+         * server)
+         */
+        cli->capabilities &= ~(CAP_UNICODE | CAP_STATUS32);
+        /*
+         * if in share level security then don't send a password now
+         */
+        if (!(cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL)) {
+                passlen = 0;
+        }
+        if (passlen > 0
+            && (cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE)
+            && passlen != 24) {
+                /*
+                 * Encrypted mode needed, and non encrypted password
+                 * supplied.
+                 */
+                lm_response = data_blob(NULL, 24);
+                if (tevent_req_nomem(lm_response.data, req)) {
+                        return tevent_req_post(req, ev);
+                }
+                if (!SMBencrypt(pass, cli->secblob.data,
+                                (uint8_t *)lm_response.data)) {
+                        DEBUG(1, ("Password is > 14 chars in length, and is "
+                                  "therefore incompatible with Lanman "
+                                  "authentication\n"));
+                        tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
+                        return tevent_req_post(req, ev);
+                }
+        } else if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE)
+                   && passlen == 24) {
+                /*
+                 * Encrypted mode needed, and encrypted password
+                 * supplied.
+                 */
+                lm_response = data_blob(pass, passlen);
+                if (tevent_req_nomem(lm_response.data, req)) {
+                        return tevent_req_post(req, ev);
+                }
+        } else if (passlen > 0) {
+                uint8_t *buf;
+                size_t converted_size;
+                /*
+                 * Plaintext mode needed, assume plaintext supplied.
+                 */
+                buf = talloc_array(talloc_tos(), uint8_t, 0);
+                buf = smb_bytes_push_str(buf, cli_ucs2(cli), pass, passlen+1,
+                                         &converted_size);
+                if (tevent_req_nomem(buf, req)) {
+                        return tevent_req_post(req, ev);
+                }
+                lm_response = data_blob(pass, passlen);
+                TALLOC_FREE(buf);
+                if (tevent_req_nomem(lm_response.data, req)) {
+                        return tevent_req_post(req, ev);
+                }
+        }
+        SCVAL(vwv+0, 0, 0xff);
+        SCVAL(vwv+0, 1, 0);
+        SSVAL(vwv+1, 0, 0);
+        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
+        SSVAL(vwv+3, 0, 2);
+        SSVAL(vwv+4, 0, 1);
+        SIVAL(vwv+5, 0, cli->sesskey);
+        SSVAL(vwv+7, 0, lm_response.length);
+        bytes = talloc_array(state, uint8_t, lm_response.length);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        if (lm_response.length != 0) {
+                memcpy(bytes, lm_response.data, lm_response.length);
+        }
+        data_blob_free(&lm_response);
+        tmp = talloc_strdup_upper(talloc_tos(), user);
+        if (tevent_req_nomem(tmp, req)) {
+                return tevent_req_post(req, ev);
+        }
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), tmp, strlen(tmp)+1,
+                                   NULL);
+        TALLOC_FREE(tmp);
+        tmp = talloc_strdup_upper(talloc_tos(), workgroup);
+        if (tevent_req_nomem(tmp, req)) {
+                return tevent_req_post(req, ev);
+        }
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), tmp, strlen(tmp)+1,
+                                   NULL);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "Unix", 5, NULL);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "Samba", 6, NULL);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_smb_send(state, ev, cli, SMBsesssetupX, 0, 10, vwv,
+                              talloc_get_size(bytes), bytes);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_session_setup_lanman2_done, req);
+        return req;
+}
+static void cli_session_setup_lanman2_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_session_setup_lanman2_state *state = tevent_req_data(
+                req, struct cli_session_setup_lanman2_state);
+        struct cli_state *cli = state->cli;
+        uint32_t num_bytes;
+        uint8_t *in;
+        char *inbuf;
+        uint8_t *bytes;
+        uint8_t *p;
+        NTSTATUS status;
+        ssize_t ret;
+        uint8_t wct;
+        uint16_t *vwv;
+        status = cli_smb_recv(subreq, state, &in, 3, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        inbuf = (char *)in;
+        p = bytes;
+        cli->vuid = SVAL(inbuf, smb_uid);
+        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_os,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_type,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_domain,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        if (strstr(cli->server_type, "Samba")) {
+                cli->is_samba = True;
+        }
+        status = cli_set_username(cli, state->user);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+static NTSTATUS cli_session_setup_lanman2_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+static NTSTATUS cli_session_setup_lanman2(struct cli_state *cli, const char *user,
                                           const char *pass, size_t passlen,
                                           const char *workgroup)
+{
+        DATA_BLOB session_key = data_blob_null;
+        DATA_BLOB lm_response = data_blob_null;
+        NTSTATUS status;
+        fstring pword;
+        char *p;
+        if (passlen > sizeof(pword)-1) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        /* LANMAN servers predate NT status codes and Unicode and ignore those
+           smb flags so we must disable the corresponding default capabilities
+           that would otherwise cause the Unicode and NT Status flags to be
+           set (and even returned by the server) */
+        cli->capabilities &= ~(CAP_UNICODE | CAP_STATUS32);
+        /* if in share level security then don't send a password now */
+        if (!(cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL))
+                passlen = 0;
+        if (passlen > 0 && (cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && passlen != 24) {
+                /* Encrypted mode needed, and non encrypted password supplied. */
+                lm_response = data_blob(NULL, 24);
+                if (!SMBencrypt(pass, cli->secblob.data,(uchar *)lm_response.data)) {
+                        DEBUG(1, ("Password is > 14 chars in length, and is therefore incompatible with Lanman authentication\n"));
+                        return NT_STATUS_ACCESS_DENIED;
+                }
+        } else if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) && passlen == 24) {
+                /* Encrypted mode needed, and encrypted password supplied. */
+                lm_response = data_blob(pass, passlen);
+        } else if (passlen > 0) {
+                /* Plaintext mode needed, assume plaintext supplied. */
+                passlen = clistr_push(cli, pword, pass, sizeof(pword), STR_TERMINATE);
+                lm_response = data_blob(pass, passlen);
+        }
+        /* send a session setup command */
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,10, 0, True);
+        SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,cli->max_xmit);
+        SSVAL(cli->outbuf,smb_vwv3,2);
+        SSVAL(cli->outbuf,smb_vwv4,1);
+        SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
+        SSVAL(cli->outbuf,smb_vwv7,lm_response.length);
+        p = smb_buf(cli->outbuf);
+        memcpy(p,lm_response.data,lm_response.length);
+        p += lm_response.length;
+        p += clistr_push(cli, p, user, -1, STR_TERMINATE|STR_UPPER);
+        p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE|STR_UPPER);
+        p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
+        p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
+        cli_setup_bcc(cli, p);
+        if (!cli_send_smb(cli) || !cli_receive_smb(cli)) {
+                return cli_nt_error(cli);
+        }
+        show_msg(cli->inbuf);
+        if (cli_is_error(cli)) {
+                return cli_nt_error(cli);
+        }
+        /* use the returned vuid from now on */
+        cli->vuid = SVAL(cli->inbuf,smb_uid);
+        status = cli_set_username(cli, user);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (session_key.data) {
+                /* Have plaintext orginal */
+                cli_set_session_key(cli, session_key);
+        }
+        return NT_STATUS_OK;
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_session_setup_lanman2_send(frame, ev, cli, user, pass, passlen,
+                                             workgroup);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_session_setup_lanman2_recv(req);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
 struct cli_session_setup_guest_state {
         struct cli_state *cli;
         uint16_t vwv[16];
+        uint16_t vwv[13];
         struct iovec bytes;
 };
 …
         struct cli_state *cli = state->cli;
         uint32_t num_bytes;
+        uint8_t *in;
         char *inbuf;
         uint8_t *bytes;
         uint8_t *p;
         NTSTATUS status;
+        status = cli_smb_recv(subreq, 0, NULL, NULL, &num_bytes, &bytes);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(subreq);
+        ssize_t ret;
+        uint8_t wct;
+        uint16_t *vwv;
+        status = cli_smb_recv(subreq, state, &in, 3, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
                 tevent_req_nterror(req, status);
                 return;
+        }
         inbuf = (char *)cli_smb_inbuf(subreq);
+        inbuf = (char *)in;
         p = bytes;
         cli->vuid = SVAL(inbuf, smb_uid);
+        p += clistr_pull(inbuf, cli->server_os, (char *)p, sizeof(fstring),
+                         bytes+num_bytes-p, STR_TERMINATE);
+        p += clistr_pull(inbuf, cli->server_type, (char *)p, sizeof(fstring),
+                         bytes+num_bytes-p, STR_TERMINATE);
+        p += clistr_pull(inbuf, cli->server_domain, (char *)p, sizeof(fstring),
+                         bytes+num_bytes-p, STR_TERMINATE);
+        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_os,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_type,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_domain,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
         if (strstr(cli->server_type, "Samba")) {
                 cli->is_samba = True;
+        }
-        TALLOC_FREE(subreq);
         status = cli_set_username(cli, "");
 …
 ****************************************************************************/
+static NTSTATUS cli_session_setup_plaintext(struct cli_state *cli,
+                                            const char *user, const char *pass,
+                                            const char *workgroup)
+{
+        uint32 capabilities = cli_session_setup_capabilities(cli);
+        char *p;
+struct cli_session_setup_plain_state {
+        struct cli_state *cli;
+        uint16_t vwv[13];
+        const char *user;
+};
+static void cli_session_setup_plain_done(struct tevent_req *subreq);
+static struct tevent_req *cli_session_setup_plain_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+        struct cli_state *cli,
+        const char *user, const char *pass, const char *workgroup)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_session_setup_plain_state *state;
+        uint16_t *vwv;
+        uint8_t *bytes;
+        size_t passlen;
+        char *version;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_session_setup_plain_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        state->user = user;
+        vwv = state->vwv;
+        SCVAL(vwv+0, 0, 0xff);
+        SCVAL(vwv+0, 1, 0);
+        SSVAL(vwv+1, 0, 0);
+        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
+        SSVAL(vwv+3, 0, 2);
+        SSVAL(vwv+4, 0, cli->pid);
+        SIVAL(vwv+5, 0, cli->sesskey);
+        SSVAL(vwv+7, 0, 0);
+        SSVAL(vwv+8, 0, 0);
+        SSVAL(vwv+9, 0, 0);
+        SSVAL(vwv+10, 0, 0);
+        SIVAL(vwv+11, 0, cli_session_setup_capabilities(cli));
+        bytes = talloc_array(state, uint8_t, 0);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), pass, strlen(pass)+1,
+                                   &passlen);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        SSVAL(vwv + (cli_ucs2(cli) ? 8 : 7), 0, passlen);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   user, strlen(user)+1, NULL);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   workgroup, strlen(workgroup)+1, NULL);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   "Unix", 5, NULL);
+        version = talloc_asprintf(talloc_tos(), "Samba %s",
+                                  samba_version_string());
+        if (tevent_req_nomem(version, req)){
+                return tevent_req_post(req, ev);
+        }
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   version, strlen(version)+1, NULL);
+        TALLOC_FREE(version);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_smb_send(state, ev, cli, SMBsesssetupX, 0, 13, vwv,
+                              talloc_get_size(bytes), bytes);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_session_setup_plain_done, req);
+        return req;
+}
+static void cli_session_setup_plain_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_session_setup_plain_state *state = tevent_req_data(
+                req, struct cli_session_setup_plain_state);
+        struct cli_state *cli = state->cli;
+        uint32_t num_bytes;
+        uint8_t *in;
+        char *inbuf;
+        uint8_t *bytes;
+        uint8_t *p;
         NTSTATUS status;
+        fstring lanman;
+        fstr_sprintf( lanman, "Samba %s", samba_version_string());
+        memset(cli->outbuf, '\0', smb_size);
+        cli_set_message(cli->outbuf,13,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
+        SSVAL(cli->outbuf,smb_vwv3,2);
+        SSVAL(cli->outbuf,smb_vwv4,cli->pid);
+        SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
+        SSVAL(cli->outbuf,smb_vwv8,0);
+        SIVAL(cli->outbuf,smb_vwv11,capabilities);
+        p = smb_buf(cli->outbuf);
+        /* check wether to send the ASCII or UNICODE version of the password */
+        if ( (capabilities & CAP_UNICODE) == 0 ) {
+                p += clistr_push(cli, p, pass, -1, STR_TERMINATE); /* password */
+                SSVAL(cli->outbuf,smb_vwv7,PTR_DIFF(p, smb_buf(cli->outbuf)));
+        }
+        else {
+                /* For ucs2 passwords clistr_push calls ucs2_align, which causes
+                 * the space taken by the unicode password to be one byte too
+                 * long (as we're on an odd byte boundary here). Reduce the
+                 * count by 1 to cope with this. Fixes smbclient against NetApp
+                 * servers which can't cope. Fix from
+                 * bryan.kolodziej@allenlund.com in bug #3840.
+                 */
+                p += clistr_push(cli, p, pass, -1, STR_UNICODE|STR_TERMINATE); /* unicode password */
+                SSVAL(cli->outbuf,smb_vwv8,PTR_DIFF(p, smb_buf(cli->outbuf))-1);
+        }
+        p += clistr_push(cli, p, user, -1, STR_TERMINATE); /* username */
+        p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE); /* workgroup */
+        p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
+        p += clistr_push(cli, p, lanman, -1, STR_TERMINATE);
+        cli_setup_bcc(cli, p);
+        if (!cli_send_smb(cli) || !cli_receive_smb(cli)) {
+                return cli_nt_error(cli);
+        }
+        show_msg(cli->inbuf);
+        if (cli_is_error(cli)) {
+                return cli_nt_error(cli);
+        }
+        cli->vuid = SVAL(cli->inbuf,smb_uid);
+        p = smb_buf(cli->inbuf);
+        p += clistr_pull(cli->inbuf, cli->server_os, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        p += clistr_pull(cli->inbuf, cli->server_type, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        p += clistr_pull(cli->inbuf, cli->server_domain, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        status = cli_set_username(cli, user);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        ssize_t ret;
+        uint8_t wct;
+        uint16_t *vwv;
+        status = cli_smb_recv(subreq, state, &in, 3, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        inbuf = (char *)in;
+        p = bytes;
+        cli->vuid = SVAL(inbuf, smb_uid);
+        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_os,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_type,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_domain,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = cli_set_username(cli, state->user);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
         if (strstr(cli->server_type, "Samba")) {
                 cli->is_samba = True;
+        }
+        return NT_STATUS_OK;
+        tevent_req_done(req);
+}
+static NTSTATUS cli_session_setup_plain_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+static NTSTATUS cli_session_setup_plain(struct cli_state *cli,
+                                        const char *user, const char *pass,
+                                        const char *workgroup)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_session_setup_plain_send(frame, ev, cli, user, pass,
+                                           workgroup);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_session_setup_plain_recv(req);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
 ****************************************************************************/
+static NTSTATUS cli_session_setup_nt1(struct cli_state *cli, const char *user,
+                                      const char *pass, size_t passlen,
+                                      const char *ntpass, size_t ntpasslen,
+                                      const char *workgroup)
+{
+        uint32 capabilities = cli_session_setup_capabilities(cli);
+struct cli_session_setup_nt1_state {
+        struct cli_state *cli;
+        uint16_t vwv[13];
+        DATA_BLOB response;
+        DATA_BLOB session_key;
+        const char *user;
+};
+static void cli_session_setup_nt1_done(struct tevent_req *subreq);
+static struct tevent_req *cli_session_setup_nt1_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+        struct cli_state *cli, const char *user,
+        const char *pass, size_t passlen,
+        const char *ntpass, size_t ntpasslen,
+        const char *workgroup)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_session_setup_nt1_state *state;
         DATA_BLOB lm_response = data_blob_null;
         DATA_BLOB nt_response = data_blob_null;
         DATA_BLOB session_key = data_blob_null;
+        NTSTATUS result;
+        char *p;
+        bool ok;
+        uint16_t *vwv;
+        uint8_t *bytes;
+        char *workgroup_upper;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_session_setup_nt1_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        state->user = user;
+        vwv = state->vwv;
         if (passlen == 0) {
 …
                         DATA_BLOB server_chal;
                         DATA_BLOB names_blob;
+                        server_chal = data_blob(cli->secblob.data, MIN(cli->secblob.length, 8));
+                        /* note that the 'workgroup' here is a best guess - we don't know
+                           the server's domain at this point.  The 'server name' is also
+                           dodgy...
+                        */
+                        names_blob = NTLMv2_generate_names_blob(NULL, cli->called.name, workgroup);
+                        if (!SMBNTLMv2encrypt(NULL, user, workgroup, pass, &server_chal,
+                                              &names_blob,
+                                              &lm_response, &nt_response, NULL, &session_key)) {
+                        server_chal = data_blob(cli->secblob.data,
+                                                MIN(cli->secblob.length, 8));
+                        if (tevent_req_nomem(server_chal.data, req)) {
+                                return tevent_req_post(req, ev);
+                        }
+                        /*
+                         * note that the 'workgroup' here is a best
+                         * guess - we don't know the server's domain
+                         * at this point.  The 'server name' is also
+                         * dodgy...
+                         */
+                        names_blob = NTLMv2_generate_names_blob(
+                                NULL, cli->called.name, workgroup);
+                        if (tevent_req_nomem(names_blob.data, req)) {
+                                return tevent_req_post(req, ev);
+                        }
+                        if (!SMBNTLMv2encrypt(NULL, user, workgroup, pass,
+                                              &server_chal, &names_blob,
+                                              &lm_response, &nt_response,
+                                              NULL, &session_key)) {
                                 data_blob_free(&names_blob);
                                 data_blob_free(&server_chal);
+                                return NT_STATUS_ACCESS_DENIED;
+                                tevent_req_nterror(
+                                        req, NT_STATUS_ACCESS_DENIED);
+                                return tevent_req_post(req, ev);
+                        }
                         data_blob_free(&names_blob);
 …
 #else
                         nt_response = data_blob(NULL, 24);
+                        SMBNTencrypt(pass,cli->secblob.data,nt_response.data);
+                        if (tevent_req_nomem(nt_response.data, req)) {
+                                return tevent_req_post(req, ev);
+                        }
+                        SMBNTencrypt(pass, cli->secblob.data,
+                                     nt_response.data);
 #endif
                         /* non encrypted password supplied. Ignore ntpass. */
                         if (lp_client_lanman_auth()) {
                                 lm_response = data_blob(NULL, 24);
+                                if (!SMBencrypt(pass,cli->secblob.data, lm_response.data)) {
+                                        /* Oops, the LM response is invalid, just put
+                                           the NT response there instead */
+                                if (tevent_req_nomem(lm_response.data, req)) {
+                                        return tevent_req_post(req, ev);
+                                }
+                                if (!SMBencrypt(pass,cli->secblob.data,
+                                                lm_response.data)) {
+                                        /*
+                                         * Oops, the LM response is
+                                         * invalid, just put the NT
+                                         * response there instead
+                                         */
                                         data_blob_free(&lm_response);
+                                        lm_response = data_blob(nt_response.data, nt_response.length);
+                                        lm_response = data_blob(
+                                                nt_response.data,
+                                                nt_response.length);
+                                }
                         } else {
+                                /* LM disabled, place NT# in LM field instead */
+                                lm_response = data_blob(nt_response.data, nt_response.length);
+                                /*
+                                 * LM disabled, place NT# in LM field
+                                 * instead
+                                 */
+                                lm_response = data_blob(
+                                        nt_response.data, nt_response.length);
+                        }
+                        if (tevent_req_nomem(lm_response.data, req)) {
+                                return tevent_req_post(req, ev);
+                        }
                         session_key = data_blob(NULL, 16);
+                        if (tevent_req_nomem(session_key.data, req)) {
+                                return tevent_req_post(req, ev);
+                        }
 #ifdef LANMAN_ONLY
                         E_deshash(pass, session_key.data);
 …
                 lm_response = data_blob(pass, passlen);
+                if (tevent_req_nomem(lm_response.data, req)) {
+                        return tevent_req_post(req, ev);
+                }
                 nt_response = data_blob(ntpass, ntpasslen);
+        }
+        /* send a session setup command */
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,13,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
+        SSVAL(cli->outbuf,smb_vwv3,2);
+        SSVAL(cli->outbuf,smb_vwv4,cli->pid);
+        SIVAL(cli->outbuf,smb_vwv5,cli->sesskey);
+        SSVAL(cli->outbuf,smb_vwv7,lm_response.length);
+        SSVAL(cli->outbuf,smb_vwv8,nt_response.length);
+        SIVAL(cli->outbuf,smb_vwv11,capabilities);
+        p = smb_buf(cli->outbuf);
+        if (lm_response.length) {
+                memcpy(p,lm_response.data, lm_response.length); p += lm_response.length;
+        }
+        if (nt_response.length) {
+                memcpy(p,nt_response.data, nt_response.length); p += nt_response.length;
+        }
+        p += clistr_push(cli, p, user, -1, STR_TERMINATE);
+        /* Upper case here might help some NTLMv2 implementations */
+        p += clistr_push(cli, p, workgroup, -1, STR_TERMINATE|STR_UPPER);
+        p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
+        p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
+        cli_setup_bcc(cli, p);
+        if (!cli_send_smb(cli) || !cli_receive_smb(cli)) {
+                result = cli_nt_error(cli);
+                goto end;
+        }
+        /* show_msg(cli->inbuf); */
+        if (cli_is_error(cli)) {
+                result = cli_nt_error(cli);
+                goto end;
+                if (tevent_req_nomem(nt_response.data, req)) {
+                        return tevent_req_post(req, ev);
+                }
+        }
 #ifdef LANMAN_ONLY
+        ok = cli_simple_set_signing(cli, session_key, lm_response);
+        state->response = data_blob_talloc(
+                state, lm_response.data, lm_response.length);
 #else
+        ok = cli_simple_set_signing(cli, session_key, nt_response);
+        state->response = data_blob_talloc(
+                state, nt_response.data, nt_response.length);
 #endif
+        if (ok) {
+                if (!cli_check_sign_mac(cli, cli->inbuf, 1)) {
+                        result = NT_STATUS_ACCESS_DENIED;
+                        goto end;
+                }
+        }
+        /* use the returned vuid from now on */
+        cli->vuid = SVAL(cli->inbuf,smb_uid);
+        p = smb_buf(cli->inbuf);
+        p += clistr_pull(cli->inbuf, cli->server_os, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        p += clistr_pull(cli->inbuf, cli->server_type, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        p += clistr_pull(cli->inbuf, cli->server_domain, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        if (tevent_req_nomem(state->response.data, req)) {
+                return tevent_req_post(req, ev);
+        }
+        if (session_key.data) {
+                state->session_key = data_blob_talloc(
+                        state, session_key.data, session_key.length);
+                if (tevent_req_nomem(state->session_key.data, req)) {
+                        return tevent_req_post(req, ev);
+                }
+        }
+        data_blob_free(&session_key);
+        SCVAL(vwv+0, 0, 0xff);
+        SCVAL(vwv+0, 1, 0);
+        SSVAL(vwv+1, 0, 0);
+        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
+        SSVAL(vwv+3, 0, 2);
+        SSVAL(vwv+4, 0, cli->pid);
+        SIVAL(vwv+5, 0, cli->sesskey);
+        SSVAL(vwv+7, 0, lm_response.length);
+        SSVAL(vwv+8, 0, nt_response.length);
+        SSVAL(vwv+9, 0, 0);
+        SSVAL(vwv+10, 0, 0);
+        SIVAL(vwv+11, 0, cli_session_setup_capabilities(cli));
+        bytes = talloc_array(state, uint8_t,
+                             lm_response.length + nt_response.length);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        if (lm_response.length != 0) {
+                memcpy(bytes, lm_response.data, lm_response.length);
+        }
+        if (nt_response.length != 0) {
+                memcpy(bytes + lm_response.length,
+                       nt_response.data, nt_response.length);
+        }
+        data_blob_free(&lm_response);
+        data_blob_free(&nt_response);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   user, strlen(user)+1, NULL);
+        /*
+         * Upper case here might help some NTLMv2 implementations
+         */
+        workgroup_upper = talloc_strdup_upper(talloc_tos(), workgroup);
+        if (tevent_req_nomem(workgroup_upper, req)) {
+                return tevent_req_post(req, ev);
+        }
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   workgroup_upper, strlen(workgroup_upper)+1,
+                                   NULL);
+        TALLOC_FREE(workgroup_upper);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "Unix", 5, NULL);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "Samba", 6, NULL);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_smb_send(state, ev, cli, SMBsesssetupX, 0, 13, vwv,
+                              talloc_get_size(bytes), bytes);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_session_setup_nt1_done, req);
+        return req;
+}
+static void cli_session_setup_nt1_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_session_setup_nt1_state *state = tevent_req_data(
+                req, struct cli_session_setup_nt1_state);
+        struct cli_state *cli = state->cli;
+        uint32_t num_bytes;
+        uint8_t *in;
+        char *inbuf;
+        uint8_t *bytes;
+        uint8_t *p;
+        NTSTATUS status;
+        ssize_t ret;
+        uint8_t wct;
+        uint16_t *vwv;
+        status = cli_smb_recv(subreq, state, &in, 3, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        inbuf = (char *)in;
+        p = bytes;
+        cli->vuid = SVAL(inbuf, smb_uid);
+        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_os,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_type,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        inbuf,
+                                        &cli->server_domain,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
         if (strstr(cli->server_type, "Samba")) {
 …
+        }
+        result = cli_set_username(cli, user);
+        if (!NT_STATUS_IS_OK(result)) {
+                goto end;
+        }
+        if (session_key.data) {
+        status = cli_set_username(cli, state->user);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        if (cli_simple_set_signing(cli, state->session_key, state->response)
+            && !cli_check_sign_mac(cli, (char *)in, 1)) {
+                tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
+                return;
+        }
+        if (state->session_key.data) {
                 /* Have plaintext orginal */
+                cli_set_session_key(cli, session_key);
+        }
+        result = NT_STATUS_OK;
+end:
+        data_blob_free(&lm_response);
+        data_blob_free(&nt_response);
+        data_blob_free(&session_key);
+        return result;
+}
+/****************************************************************************
+ Send a extended security session setup blob
+****************************************************************************/
+static bool cli_session_setup_blob_send(struct cli_state *cli, DATA_BLOB blob)
+{
+        uint32 capabilities = cli_session_setup_capabilities(cli);
+        char *p;
+        capabilities |= CAP_EXTENDED_SECURITY;
+        /* send a session setup command */
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,12,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBsesssetupX);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,CLI_BUFFER_SIZE);
+        SSVAL(cli->outbuf,smb_vwv3,2);
+        SSVAL(cli->outbuf,smb_vwv4,1);
+        SIVAL(cli->outbuf,smb_vwv5,0);
+        SSVAL(cli->outbuf,smb_vwv7,blob.length);
+        SIVAL(cli->outbuf,smb_vwv10,capabilities);
+        p = smb_buf(cli->outbuf);
+        memcpy(p, blob.data, blob.length);
+        p += blob.length;
+        p += clistr_push(cli, p, "Unix", -1, STR_TERMINATE);
+        p += clistr_push(cli, p, "Samba", -1, STR_TERMINATE);
+        cli_setup_bcc(cli, p);
+        return cli_send_smb(cli);
+}
+/****************************************************************************
+ Send a extended security session setup blob, returning a reply blob.
+****************************************************************************/
+static DATA_BLOB cli_session_setup_blob_receive(struct cli_state *cli)
+{
+        DATA_BLOB blob2 = data_blob_null;
+        char *p;
+        size_t len;
+        if (!cli_receive_smb(cli))
+                return blob2;
+        show_msg(cli->inbuf);
+        if (cli_is_error(cli) && !NT_STATUS_EQUAL(cli_nt_error(cli),
+                                                  NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                return blob2;
+        }
+        /* use the returned vuid from now on */
+        cli->vuid = SVAL(cli->inbuf,smb_uid);
+        p = smb_buf(cli->inbuf);
+        blob2 = data_blob(p, SVAL(cli->inbuf, smb_vwv3));
+        p += blob2.length;
+        p += clistr_pull(cli->inbuf, cli->server_os, p, sizeof(fstring),
+                         -1, STR_TERMINATE);
+        /* w2k with kerberos doesn't properly null terminate this field */
+        len = smb_bufrem(cli->inbuf, p);
+        if (p + len < cli->inbuf + cli->bufsize+SAFETY_MARGIN - 2) {
+                char *end_of_buf = p + len;
+                SSVAL(p, len, 0);
+                /* Now it's null terminated. */
+                p += clistr_pull(cli->inbuf, cli->server_type, p, sizeof(fstring),
+                        -1, STR_TERMINATE);
+                cli_set_session_key(cli, state->session_key);
+        }
+        tevent_req_done(req);
+}
+static NTSTATUS cli_session_setup_nt1_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+static NTSTATUS cli_session_setup_nt1(struct cli_state *cli, const char *user,
+                                      const char *pass, size_t passlen,
+                                      const char *ntpass, size_t ntpasslen,
+                                      const char *workgroup)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
                 /*
+                 * See if there's another string. If so it's the
+                 * server domain (part of the 'standard' Samba
+                 * server signature).
+                 * Can't use sync call while an async call is in flight
                  */
+                if (p < end_of_buf) {
+                        p += clistr_pull(cli->inbuf, cli->server_domain, p, sizeof(fstring),
+                                -1, STR_TERMINATE);
+                }
+        } else {
+                /*
+                 * No room to null terminate so we can't see if there
+                 * is another string (server_domain) afterwards.
+                 */
+                p += clistr_pull(cli->inbuf, cli->server_type, p, sizeof(fstring),
+                                 len, 0);
+        }
+        return blob2;
+}
+#ifdef HAVE_KRB5
+/****************************************************************************
+ Send a extended security session setup blob, returning a reply blob.
+****************************************************************************/
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_session_setup_nt1_send(frame, ev, cli, user, pass, passlen,
+                                         ntpass, ntpasslen, workgroup);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_session_setup_nt1_recv(req);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 /* The following is calculated from :
 …
 #define BASE_SESSSETUP_BLOB_PACKET_SIZE (35 + 24 + 22)
+static bool cli_session_setup_blob(struct cli_state *cli, DATA_BLOB blob)
+{
+        int32 remaining = blob.length;
+        int32 cur = 0;
+        DATA_BLOB send_blob = data_blob_null;
+        int32 max_blob_size = 0;
+        DATA_BLOB receive_blob = data_blob_null;
+struct cli_sesssetup_blob_state {
+        struct tevent_context *ev;
+        struct cli_state *cli;
+        DATA_BLOB blob;
+        uint16_t max_blob_size;
+        uint16_t vwv[12];
+        uint8_t *buf;
+        NTSTATUS status;
+        char *inbuf;
+        DATA_BLOB ret_blob;
+};
+static bool cli_sesssetup_blob_next(struct cli_sesssetup_blob_state *state,
+                                    struct tevent_req **psubreq);
+static void cli_sesssetup_blob_done(struct tevent_req *subreq);
+static struct tevent_req *cli_sesssetup_blob_send(TALLOC_CTX *mem_ctx,
+                                                  struct tevent_context *ev,
+                                                  struct cli_state *cli,
+                                                  DATA_BLOB blob)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_sesssetup_blob_state *state;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_sesssetup_blob_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->blob = blob;
+        state->cli = cli;
         if (cli->max_xmit < BASE_SESSSETUP_BLOB_PACKET_SIZE + 1) {
+                DEBUG(0,("cli_session_setup_blob: cli->max_xmit too small "
+                        "(was %u, need minimum %u)\n",
+                        (unsigned int)cli->max_xmit,
+                        BASE_SESSSETUP_BLOB_PACKET_SIZE));
+                cli_set_nt_error(cli, NT_STATUS_INVALID_PARAMETER);
+                return False;
+        }
+        max_blob_size = cli->max_xmit - BASE_SESSSETUP_BLOB_PACKET_SIZE;
+        while ( remaining > 0) {
+                if (remaining >= max_blob_size) {
+                        send_blob.length = max_blob_size;
+                        remaining -= max_blob_size;
+                } else {
+                        send_blob.length = remaining;
+                        remaining = 0;
+                }
+                send_blob.data =  &blob.data[cur];
+                cur += send_blob.length;
+                DEBUG(10, ("cli_session_setup_blob: Remaining (%u) sending (%u) current (%u)\n",
+                        (unsigned int)remaining,
+                        (unsigned int)send_blob.length,
+                        (unsigned int)cur ));
+                if (!cli_session_setup_blob_send(cli, send_blob)) {
+                        DEBUG(0, ("cli_session_setup_blob: send failed\n"));
+                        return False;
+                }
+                receive_blob = cli_session_setup_blob_receive(cli);
+                data_blob_free(&receive_blob);
+                if (cli_is_error(cli) &&
+                                !NT_STATUS_EQUAL( cli_get_nt_error(cli),
+                                        NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                        DEBUG(0, ("cli_session_setup_blob: receive failed "
+                                  "(%s)\n", nt_errstr(cli_get_nt_error(cli))));
+                        cli->vuid = 0;
+                        return False;
+                }
+        }
+        return True;
+}
+                DEBUG(1, ("cli_session_setup_blob: cli->max_xmit too small "
+                          "(was %u, need minimum %u)\n",
+                          (unsigned int)cli->max_xmit,
+                          BASE_SESSSETUP_BLOB_PACKET_SIZE));
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
+        state->max_blob_size =
+                MIN(cli->max_xmit - BASE_SESSSETUP_BLOB_PACKET_SIZE, 0xFFFF);
+        if (!cli_sesssetup_blob_next(state, &subreq)) {
+                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_sesssetup_blob_done, req);
+        return req;
+}
+static bool cli_sesssetup_blob_next(struct cli_sesssetup_blob_state *state,
+                                    struct tevent_req **psubreq)
+{
+        struct tevent_req *subreq;
+        uint16_t thistime;
+        SCVAL(state->vwv+0, 0, 0xFF);
+        SCVAL(state->vwv+0, 1, 0);
+        SSVAL(state->vwv+1, 0, 0);
+        SSVAL(state->vwv+2, 0, CLI_BUFFER_SIZE);
+        SSVAL(state->vwv+3, 0, 2);
+        SSVAL(state->vwv+4, 0, 1);
+        SIVAL(state->vwv+5, 0, 0);
+        thistime = MIN(state->blob.length, state->max_blob_size);
+        SSVAL(state->vwv+7, 0, thistime);
+        SSVAL(state->vwv+8, 0, 0);
+        SSVAL(state->vwv+9, 0, 0);
+        SIVAL(state->vwv+10, 0,
+              cli_session_setup_capabilities(state->cli)
+              | CAP_EXTENDED_SECURITY);
+        state->buf = (uint8_t *)talloc_memdup(state, state->blob.data,
+                                              thistime);
+        if (state->buf == NULL) {
+                return false;
+        }
+        state->blob.data += thistime;
+        state->blob.length -= thistime;
+        state->buf = smb_bytes_push_str(state->buf, cli_ucs2(state->cli),
+                                        "Unix", 5, NULL);
+        state->buf = smb_bytes_push_str(state->buf, cli_ucs2(state->cli),
+                                        "Samba", 6, NULL);
+        if (state->buf == NULL) {
+                return false;
+        }
+        subreq = cli_smb_send(state, state->ev, state->cli, SMBsesssetupX, 0,
+, state->vwv,
+                              talloc_get_size(state->buf), state->buf);
+        if (subreq == NULL) {
+                return false;
+        }
+        *psubreq = subreq;
+        return true;
+}
+static void cli_sesssetup_blob_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_sesssetup_blob_state *state = tevent_req_data(
+                req, struct cli_sesssetup_blob_state);
+        struct cli_state *cli = state->cli;
+        uint8_t wct;
+        uint16_t *vwv;
+        uint32_t num_bytes;
+        uint8_t *bytes;
+        NTSTATUS status;
+        uint8_t *p;
+        uint16_t blob_length;
+        uint8_t *inbuf;
+        ssize_t ret;
+        status = cli_smb_recv(subreq, state, &inbuf, 4, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)
+            && !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        state->status = status;
+        TALLOC_FREE(state->buf);
+        state->inbuf = (char *)inbuf;
+        cli->vuid = SVAL(state->inbuf, smb_uid);
+        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
+        blob_length = SVAL(vwv+3, 0);
+        if (blob_length > num_bytes) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                return;
+        }
+        state->ret_blob = data_blob_const(bytes, blob_length);
+        p = bytes + blob_length;
+        status = smb_bytes_talloc_string(cli,
+                                        (char *)inbuf,
+                                        &cli->server_os,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        (char *)inbuf,
+                                        &cli->server_type,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        status = smb_bytes_talloc_string(cli,
+                                        (char *)inbuf,
+                                        &cli->server_domain,
+                                        p,
+                                        bytes+num_bytes-p,
+                                        &ret);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        p += ret;
+        if (strstr(cli->server_type, "Samba")) {
+                cli->is_samba = True;
+        }
+        if (state->blob.length != 0) {
+                /*
+                 * More to send
+                 */
+                if (!cli_sesssetup_blob_next(state, &subreq)) {
+                        tevent_req_nomem(NULL, req);
+                        return;
+                }
+                tevent_req_set_callback(subreq, cli_sesssetup_blob_done, req);
+                return;
+        }
+        tevent_req_done(req);
+}
+static NTSTATUS cli_sesssetup_blob_recv(struct tevent_req *req,
+                                        TALLOC_CTX *mem_ctx,
+                                        DATA_BLOB *pblob,
+                                        char **pinbuf)
+{
+        struct cli_sesssetup_blob_state *state = tevent_req_data(
+                req, struct cli_sesssetup_blob_state);
+        NTSTATUS status;
+        char *inbuf;
+        if (tevent_req_is_nterror(req, &status)) {
+                state->cli->vuid = 0;
+                return status;
+        }
+        inbuf = talloc_move(mem_ctx, &state->inbuf);
+        if (pblob != NULL) {
+                *pblob = state->ret_blob;
+        }
+        if (pinbuf != NULL) {
+                *pinbuf = inbuf;
+        }
+        /* could be NT_STATUS_MORE_PROCESSING_REQUIRED */
+        return state->status;
+}
+#ifdef HAVE_KRB5
 /****************************************************************************
 …
 ****************************************************************************/
 static ADS_STATUS cli_session_setup_kerberos(struct cli_state *cli, const char *principal, const char *workgroup)
+{
+struct cli_session_setup_kerberos_state {
+        struct cli_state *cli;
         DATA_BLOB negTokenTarg;
         DATA_BLOB session_key_krb5;
+        NTSTATUS nt_status;
+        ADS_STATUS ads_status;
+};
+static void cli_session_setup_kerberos_done(struct tevent_req *subreq);
+static struct tevent_req *cli_session_setup_kerberos_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct cli_state *cli,
+        const char *principal, const char *workgroup)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_session_setup_kerberos_state *state;
         int rc;
+        DEBUG(2,("Doing kerberos session setup\n"));
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_session_setup_kerberos_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        state->ads_status = ADS_SUCCESS;
         cli_temp_set_signing(cli);
+        DEBUG(2,("Doing kerberos session setup\n"));
+        /* generate the encapsulated kerberos5 ticket */
+        rc = spnego_gen_negTokenTarg(principal, 0, &negTokenTarg, &session_key_krb5, 0, NULL);
+        /*
+         * Ok, this is cheating: spnego_gen_krb5_negTokenInit can block if
+         * we have to acquire a ticket. To be fixed later :-)
+         */
+        rc = spnego_gen_krb5_negTokenInit(state, principal, 0, &state->negTokenTarg,
+                                     &state->session_key_krb5, 0, NULL);
         if (rc) {
+                DEBUG(1, ("cli_session_setup_kerberos: spnego_gen_negTokenTarg failed: %s\n",
+                        error_message(rc)));
+                return ADS_ERROR_KRB5(rc);
+                DEBUG(1, ("cli_session_setup_kerberos: "
+                          "spnego_gen_krb5_negTokenInit failed: %s\n",
+                          error_message(rc)));
+                state->ads_status = ADS_ERROR_KRB5(rc);
+                tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
+                return tevent_req_post(req, ev);
+        }
 #if 0
+        file_save("negTokenTarg.dat", negTokenTarg.data, negTokenTarg.length);
+        file_save("negTokenTarg.dat", state->negTokenTarg.data,
+                  state->negTokenTarg.length);
 #endif
+        if (!cli_session_setup_blob(cli, negTokenTarg)) {
+                nt_status = cli_nt_error(cli);
+                goto nt_error;
+        }
+        if (cli_is_error(cli)) {
+                nt_status = cli_nt_error(cli);
+                if (NT_STATUS_IS_OK(nt_status)) {
+                        nt_status = NT_STATUS_UNSUCCESSFUL;
+                }
+                goto nt_error;
+        }
+        cli_set_session_key(cli, session_key_krb5);
+        if (cli_simple_set_signing(
+                    cli, session_key_krb5, data_blob_null)) {
+                if (!cli_check_sign_mac(cli, cli->inbuf, 1)) {
+                        nt_status = NT_STATUS_ACCESS_DENIED;
+                        goto nt_error;
+                }
+        }
+        data_blob_free(&negTokenTarg);
+        data_blob_free(&session_key_krb5);
+        return ADS_ERROR_NT(NT_STATUS_OK);
+nt_error:
+        data_blob_free(&negTokenTarg);
+        data_blob_free(&session_key_krb5);
+        cli->vuid = 0;
+        return ADS_ERROR_NT(nt_status);
+        subreq = cli_sesssetup_blob_send(state, ev, cli, state->negTokenTarg);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_session_setup_kerberos_done, req);
+        return req;
+}
+static void cli_session_setup_kerberos_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_session_setup_kerberos_state *state = tevent_req_data(
+                req, struct cli_session_setup_kerberos_state);
+        char *inbuf = NULL;
+        NTSTATUS status;
+        status = cli_sesssetup_blob_recv(subreq, talloc_tos(), NULL, &inbuf);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(subreq);
+                tevent_req_nterror(req, status);
+                return;
+        }
+        cli_set_session_key(state->cli, state->session_key_krb5);
+        if (cli_simple_set_signing(state->cli, state->session_key_krb5,
+                                   data_blob_null)
+            && !cli_check_sign_mac(state->cli, inbuf, 1)) {
+                TALLOC_FREE(subreq);
+                tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
+                return;
+        }
+        TALLOC_FREE(subreq);
+        tevent_req_done(req);
+}
+static ADS_STATUS cli_session_setup_kerberos_recv(struct tevent_req *req)
+{
+        struct cli_session_setup_kerberos_state *state = tevent_req_data(
+                req, struct cli_session_setup_kerberos_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return ADS_ERROR_NT(status);
+        }
+        return state->ads_status;
+}
+static ADS_STATUS cli_session_setup_kerberos(struct cli_state *cli,
+                                             const char *principal,
+                                             const char *workgroup)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        ADS_STATUS status = ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
+        if (cli_has_async_calls(cli)) {
+                return ADS_ERROR_NT(NT_STATUS_INVALID_PARAMETER);
+        }
+        ev = tevent_context_init(talloc_tos());
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_session_setup_kerberos_send(ev, ev, cli, principal,
+                                              workgroup);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll(req, ev)) {
+                status = ADS_ERROR_SYSTEM(errno);
+                goto fail;
+        }
+        status = cli_session_setup_kerberos_recv(req);
+fail:
+        TALLOC_FREE(ev);
+        return status;
+}
 #endif  /* HAVE_KRB5 */
 /****************************************************************************
 …
 ****************************************************************************/
 static NTSTATUS cli_session_setup_ntlmssp(struct cli_state *cli, const char *user,
                                           const char *pass, const char *domain)
+{
+struct cli_session_setup_ntlmssp_state {
+        struct tevent_context *ev;
+        struct cli_state *cli;
         struct ntlmssp_state *ntlmssp_state;
+        NTSTATUS nt_status;
+        int turn = 1;
+        DATA_BLOB msg1;
+        DATA_BLOB blob = data_blob_null;
+        DATA_BLOB blob_in = data_blob_null;
+        DATA_BLOB blob_out = data_blob_null;
+        int turn;
+        DATA_BLOB blob_out;
+};
+static int cli_session_setup_ntlmssp_state_destructor(
+        struct cli_session_setup_ntlmssp_state *state)
+{
+        if (state->ntlmssp_state != NULL) {
+                TALLOC_FREE(state->ntlmssp_state);
+        }
+        return 0;
+}
+static void cli_session_setup_ntlmssp_done(struct tevent_req *req);
+static struct tevent_req *cli_session_setup_ntlmssp_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct cli_state *cli,
+        const char *user, const char *pass, const char *domain)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_session_setup_ntlmssp_state *state;
+        NTSTATUS status;
+        DATA_BLOB blob_out;
+        const char *OIDs_ntlm[] = {OID_NTLMSSP, NULL};
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_session_setup_ntlmssp_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->cli = cli;
+        state->turn = 1;
+        state->ntlmssp_state = NULL;
+        talloc_set_destructor(
+                state, cli_session_setup_ntlmssp_state_destructor);
         cli_temp_set_signing(cli);
+        if (!NT_STATUS_IS_OK(nt_status = ntlmssp_client_start(&ntlmssp_state))) {
+                return nt_status;
+        }
+        ntlmssp_want_feature(ntlmssp_state, NTLMSSP_FEATURE_SESSION_KEY);
+        status = ntlmssp_client_start(state,
+                                      global_myname(),
+                                      lp_workgroup(),
+                                      lp_client_ntlmv2_auth(),
+                                      &state->ntlmssp_state);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        ntlmssp_want_feature(state->ntlmssp_state,
+                             NTLMSSP_FEATURE_SESSION_KEY);
         if (cli->use_ccache) {
+                ntlmssp_want_feature(ntlmssp_state, NTLMSSP_FEATURE_CCACHE);
+        }
+        if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_username(ntlmssp_state, user))) {
+                return nt_status;
+        }
+        if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_domain(ntlmssp_state, domain))) {
+                return nt_status;
+        }
+        if (!NT_STATUS_IS_OK(nt_status = ntlmssp_set_password(ntlmssp_state, pass))) {
+                return nt_status;
+        }
+        do {
+                nt_status = ntlmssp_update(ntlmssp_state,
+                                                  blob_in, &blob_out);
+                data_blob_free(&blob_in);
+                if (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED) || NT_STATUS_IS_OK(nt_status)) {
+                        if (turn == 1) {
+                                /* and wrap it in a SPNEGO wrapper */
+                                msg1 = gen_negTokenInit(OID_NTLMSSP, blob_out);
+                        } else {
+                                /* wrap it in SPNEGO */
+                                msg1 = spnego_gen_auth(blob_out);
+                ntlmssp_want_feature(state->ntlmssp_state,
+                                     NTLMSSP_FEATURE_CCACHE);
+        }
+        status = ntlmssp_set_username(state->ntlmssp_state, user);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        status = ntlmssp_set_domain(state->ntlmssp_state, domain);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        status = ntlmssp_set_password(state->ntlmssp_state, pass);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        status = ntlmssp_update(state->ntlmssp_state, data_blob_null,
+                                &blob_out);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                goto fail;
+        }
+        state->blob_out = spnego_gen_negTokenInit(state, OIDs_ntlm, &blob_out, NULL);
+        data_blob_free(&blob_out);
+        subreq = cli_sesssetup_blob_send(state, ev, cli, state->blob_out);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_session_setup_ntlmssp_done, req);
+        return req;
+fail:
+        tevent_req_nterror(req, status);
+        return tevent_req_post(req, ev);
+}
+static void cli_session_setup_ntlmssp_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_session_setup_ntlmssp_state *state = tevent_req_data(
+                req, struct cli_session_setup_ntlmssp_state);
+        DATA_BLOB blob_in, msg_in, blob_out;
+        char *inbuf = NULL;
+        bool parse_ret;
+        NTSTATUS status;
+        status = cli_sesssetup_blob_recv(subreq, talloc_tos(), &blob_in,
+                                         &inbuf);
+        TALLOC_FREE(subreq);
+        data_blob_free(&state->blob_out);
+        if (NT_STATUS_IS_OK(status)) {
+                if (state->cli->server_domain[0] == '\0') {
+                        TALLOC_FREE(state->cli->server_domain);
+                        state->cli->server_domain = talloc_strdup(state->cli,
+                                                state->ntlmssp_state->server.netbios_domain);
+                        if (state->cli->server_domain == NULL) {
+                                TALLOC_FREE(subreq);
+                                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+                                return;
+                        }
+                        /* now send that blob on its way */
+                        if (!cli_session_setup_blob_send(cli, msg1)) {
+                                DEBUG(3, ("Failed to send NTLMSSP/SPNEGO blob to server!\n"));
+                                nt_status = NT_STATUS_UNSUCCESSFUL;
+                        } else {
+                                blob = cli_session_setup_blob_receive(cli);
+                                nt_status = cli_nt_error(cli);
+                                if (cli_is_error(cli) && NT_STATUS_IS_OK(nt_status)) {
+                                        if (cli->smb_rw_error == SMB_READ_BAD_SIG) {
+                                                nt_status = NT_STATUS_ACCESS_DENIED;
+                                        } else {
+                                                nt_status = NT_STATUS_UNSUCCESSFUL;
+                                        }
+                                }
+                        }
+                        data_blob_free(&msg1);
+                }
+                if (!blob.length) {
+                        if (NT_STATUS_IS_OK(nt_status)) {
+                                nt_status = NT_STATUS_UNSUCCESSFUL;
+                        }
+                } else if ((turn == 1) &&
+                           NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                        DATA_BLOB tmp_blob = data_blob_null;
+                        /* the server might give us back two challenges */
+                        if (!spnego_parse_challenge(blob, &blob_in,
+                                                    &tmp_blob)) {
+                                DEBUG(3,("Failed to parse challenges\n"));
+                                nt_status = NT_STATUS_INVALID_PARAMETER;
+                        }
+                        data_blob_free(&tmp_blob);
+                } else {
+                        if (!spnego_parse_auth_response(blob, nt_status, OID_NTLMSSP,
+                                                        &blob_in)) {
+                                DEBUG(3,("Failed to parse auth response\n"));
+                                if (NT_STATUS_IS_OK(nt_status)
+                                    || NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED))
+                                        nt_status = NT_STATUS_INVALID_PARAMETER;
+                        }
+                }
+                data_blob_free(&blob);
+                data_blob_free(&blob_out);
+                turn++;
+        } while (NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED));
+        data_blob_free(&blob_in);
+        if (NT_STATUS_IS_OK(nt_status)) {
+                if (cli->server_domain[0] == '\0') {
+                        fstrcpy(cli->server_domain, ntlmssp_state->server_domain);
+                }
+                cli_set_session_key(cli, ntlmssp_state->session_key);
+                }
+                cli_set_session_key(
+                        state->cli, state->ntlmssp_state->session_key);
                 if (cli_simple_set_signing(
+                            cli, ntlmssp_state->session_key, data_blob_null)) {
+                        if (!cli_check_sign_mac(cli, cli->inbuf, 1)) {
+                                nt_status = NT_STATUS_ACCESS_DENIED;
+                        }
+                }
+        }
+        /* we have a reference conter on ntlmssp_state, if we are signing
+           then the state will be kept by the signing engine */
+        ntlmssp_end(&ntlmssp_state);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                cli->vuid = 0;
+        }
+        return nt_status;
+                            state->cli, state->ntlmssp_state->session_key,
+                            data_blob_null)
+                    && !cli_check_sign_mac(state->cli, inbuf, 1)) {
+                        TALLOC_FREE(subreq);
+                        tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
+                        return;
+                }
+                TALLOC_FREE(subreq);
+                TALLOC_FREE(state->ntlmssp_state);
+                tevent_req_done(req);
+                return;
+        }
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (blob_in.length == 0) {
+                tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
+                return;
+        }
+        if ((state->turn == 1)
+            && NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                DATA_BLOB tmp_blob = data_blob_null;
+                /* the server might give us back two challenges */
+                parse_ret = spnego_parse_challenge(state, blob_in, &msg_in,
+                                                   &tmp_blob);
+                data_blob_free(&tmp_blob);
+        } else {
+                parse_ret = spnego_parse_auth_response(state, blob_in, status,
+                                                       OID_NTLMSSP, &msg_in);
+        }
+        state->turn += 1;
+        if (!parse_ret) {
+                DEBUG(3,("Failed to parse auth response\n"));
+                if (NT_STATUS_IS_OK(status)
+                    || NT_STATUS_EQUAL(status,
+                                       NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                        tevent_req_nterror(
+                                req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                        return;
+                }
+        }
+        status = ntlmssp_update(state->ntlmssp_state, msg_in, &blob_out);
+        if (!NT_STATUS_IS_OK(status)
+            && !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                TALLOC_FREE(subreq);
+                TALLOC_FREE(state->ntlmssp_state);
+                tevent_req_nterror(req, status);
+                return;
+        }
+        state->blob_out = spnego_gen_auth(state, blob_out);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nomem(state->blob_out.data, req)) {
+                return;
+        }
+        subreq = cli_sesssetup_blob_send(state, state->ev, state->cli,
+                                         state->blob_out);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, cli_session_setup_ntlmssp_done, req);
+}
+static NTSTATUS cli_session_setup_ntlmssp_recv(struct tevent_req *req)
+{
+        struct cli_session_setup_ntlmssp_state *state = tevent_req_data(
+                req, struct cli_session_setup_ntlmssp_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                state->cli->vuid = 0;
+                return status;
+        }
+        return NT_STATUS_OK;
+}
+static NTSTATUS cli_session_setup_ntlmssp(struct cli_state *cli,
+                                          const char *user,
+                                          const char *pass,
+                                          const char *domain)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ev = tevent_context_init(talloc_tos());
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_session_setup_ntlmssp_send(ev, ev, cli, user, pass, domain);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_session_setup_ntlmssp_recv(req);
+fail:
+        TALLOC_FREE(ev);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
          * negprot reply, but right now we do it. If we don't receive one,
          * we try to best guess, then fall back to NTLM.  */
         if (!spnego_parse_negTokenInit(blob, OIDs, &principal) ||
+        if (!spnego_parse_negTokenInit(talloc_tos(), blob, OIDs, &principal, NULL) ||
                         OIDs[0] == NULL) {
                 data_blob_free(&blob);
 …
         status = cli_set_username(cli, user);
         if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(principal);
                 return ADS_ERROR_NT(status);
+        }
 …
                         if (dest_realm) {
                                 realm = SMB_STRDUP(dest_realm);
+                                if (!realm) {
+                                        return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
+                                }
                                 strupper_m(realm);
                         } else {
 …
+                        }
+                        if (realm && *realm) {
+                                principal = talloc_asprintf(talloc_tos(),
+                                                            "cifs/%s@%s",
+                                                            cli->desthost,
+                                                            realm);
+                                if (!principal) {
+                                        SAFE_FREE(realm);
+                        if (realm == NULL || *realm == '\0') {
+                                realm = SMB_STRDUP(lp_realm());
+                                if (!realm) {
                                         return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
+                                }
+                                DEBUG(3,("cli_session_setup_spnego: guessed "
+                                        "server principal=%s\n",
+                                        principal ? principal : "<null>"));
+                                strupper_m(realm);
+                                DEBUG(3,("cli_session_setup_spnego: cannot "
+                                        "get realm from dest_realm %s, "
+                                        "desthost %s. Using default "
+                                        "smb.conf realm %s\n",
+                                        dest_realm ? dest_realm : "<null>",
+                                        cli->desthost,
+                                        realm));
+                        }
+                        principal = talloc_asprintf(talloc_tos(),
+                                                    "cifs/%s@%s",
+                                                    cli->desthost,
+                                                    realm);
+                        if (!principal) {
+                                SAFE_FREE(realm);
+                                return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
+                        }
+                        DEBUG(3,("cli_session_setup_spnego: guessed "
+                                "server principal=%s\n",
+                                principal ? principal : "<null>"));
                         SAFE_FREE(realm);
+                }
 …
+{
         char *p;
         fstring user2;
+        char *user2;
         if (user) {
                 fstrcpy(user2, user);
+                user2 = talloc_strdup(talloc_tos(), user);
         } else {
+                user2[0] ='\0';
+                user2 = talloc_strdup(talloc_tos(), "");
+        }
+        if (user2 == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
 …
                 *p = 0;
                 user = p+1;
+                strupper_m(user2);
                 workgroup = user2;
+        }
 …
         if (cli->protocol < PROTOCOL_NT1) {
                 if (!lp_client_lanman_auth() && passlen != 24 && (*pass)) {
                         DEBUG(1, ("Server requested LM password but 'client lanman auth'"
                                   " is disabled\n"));
+                        DEBUG(1, ("Server requested LM password but 'client lanman auth = no'"
+                                  " or 'client ntlmv2 auth = yes'\n"));
                         return NT_STATUS_ACCESS_DENIED;
+                }
 …
                 if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0 &&
                     !lp_client_plaintext_auth() && (*pass)) {
                         DEBUG(1, ("Server requested plaintext password but "
                                   "'client plaintext auth' is disabled\n"));
+                        DEBUG(1, ("Server requested LM password but 'client plaintext auth = no'"
+                                  " or 'client ntlmv2 auth = yes'\n"));
                         return NT_STATUS_ACCESS_DENIED;
+                }
 …
         if ((cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) == 0)
                 return cli_session_setup_plaintext(cli, user, "", workgroup);
+                return cli_session_setup_plain(cli, user, "", workgroup);
         /* if the server doesn't support encryption then we have to use
 …
         if ((cli->sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0) {
                 if (!lp_client_plaintext_auth() && (*pass)) {
                         DEBUG(1, ("Server requested plaintext password but "
                                   "'client plaintext auth' is disabled\n"));
+                        DEBUG(1, ("Server requested LM password but 'client plaintext auth = no'"
+                                  " or 'client ntlmv2 auth = yes'\n"));
                         return NT_STATUS_ACCESS_DENIED;
+                }
                 return cli_session_setup_plaintext(cli, user, pass, workgroup);
+                return cli_session_setup_plain(cli, user, pass, workgroup);
+        }
 …
 *****************************************************************************/
+bool cli_ulogoff(struct cli_state *cli)
+{
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,2,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBulogoffX);
+        cli_setup_packet(cli);
+        SSVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
+        cli_send_smb(cli);
+        if (!cli_receive_smb(cli))
+                return False;
+        if (cli_is_error(cli)) {
+                return False;
+        }
+        cli->vuid = -1;
+        return True;
+struct cli_ulogoff_state {
+        struct cli_state *cli;
+        uint16_t vwv[3];
+};
+static void cli_ulogoff_done(struct tevent_req *subreq);
+struct tevent_req *cli_ulogoff_send(TALLOC_CTX *mem_ctx,
+                                    struct tevent_context *ev,
+                                    struct cli_state *cli)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_ulogoff_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct cli_ulogoff_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        SCVAL(state->vwv+0, 0, 0xFF);
+        SCVAL(state->vwv+1, 0, 0);
+        SSVAL(state->vwv+2, 0, 0);
+        subreq = cli_smb_send(state, ev, cli, SMBulogoffX, 0, 2, state->vwv,
+, NULL);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_ulogoff_done, req);
+        return req;
+}
+static void cli_ulogoff_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_ulogoff_state *state = tevent_req_data(
+                req, struct cli_ulogoff_state);
+        NTSTATUS status;
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        state->cli->vuid = -1;
+        tevent_req_done(req);
+}
+NTSTATUS cli_ulogoff_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+NTSTATUS cli_ulogoff(struct cli_state *cli)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ev = tevent_context_init(talloc_tos());
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_ulogoff_send(ev, ev, cli);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_ulogoff_recv(req);
+fail:
+        TALLOC_FREE(ev);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
         struct tevent_req *req, *subreq;
         struct cli_tcon_andx_state *state;
         fstring pword;
+        uint8_t p24[24];
         uint16_t *vwv;
         char *tmp = NULL;
 …
         vwv = state->vwv;
+        fstrcpy(cli->share, share);
+        cli->share = talloc_strdup(cli, share);
+        if (!cli->share) {
+                return NULL;
+        }
         /* in user level security don't send a password now */
 …
                         DEBUG(1, ("Server requested LANMAN password "
                                   "(share-level security) but "
                                   "'client lanman auth' is disabled\n"));
+                                  "'client lanman auth = no' or 'client ntlmv2 auth = yes'\n"));
                         goto access_denied;
+                }
 …
                  * encryption.
                  */
+                SMBencrypt(pass, cli->secblob.data, p24);
                 passlen = 24;
                 SMBencrypt(pass, cli->secblob.data, (uchar *)pword);
+                pass = (const char *)p24;
         } else {
                 if((cli->sec_mode & (NEGOTIATE_SECURITY_USER_LEVEL
                                      |NEGOTIATE_SECURITY_CHALLENGE_RESPONSE))
                    == 0) {
+                        char *tmp_pass;
                         if (!lp_client_plaintext_auth() && (*pass)) {
                                 DEBUG(1, ("Server requested plaintext "
                                           "password but 'client plaintext "
                                           "auth' is disabled\n"));
+                                          "password but "
+                                          "'client lanman auth = no' or 'client ntlmv2 auth = yes'\n"));
                                 goto access_denied;
+                        }
 …
                          * before using.
                          */
+                        passlen = clistr_push(cli, pword, pass, sizeof(pword),
+                                              STR_TERMINATE);
+                        tmp_pass = talloc_array(talloc_tos(), char, 128);
+                        if (tmp_pass == NULL) {
+                                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+                                return tevent_req_post(req, ev);
+                        }
+                        passlen = clistr_push(cli,
+                                        tmp_pass,
+                                        pass,
+                                        talloc_get_size(tmp_pass),
+                                        STR_TERMINATE);
                         if (passlen == -1) {
                                 DEBUG(1, ("clistr_push(pword) failed\n"));
                                 goto access_denied;
+                                tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+                                return tevent_req_post(req, ev);
+                        }
+                } else {
+                        if (passlen) {
+                                memcpy(pword, pass, passlen);
+                        }
+                        pass = tmp_pass;
+                }
+        }
 …
         SSVAL(vwv+3, 0, passlen);
         if (passlen) {
                 bytes = (uint8_t *)talloc_memdup(state, pword, passlen);
+        if (passlen && pass) {
+                bytes = (uint8_t *)talloc_memdup(state, pass, passlen);
         } else {
                 bytes = talloc_array(state, uint8_t, 0);
 …
                 req, struct cli_tcon_andx_state);
         struct cli_state *cli = state->cli;
+        char *inbuf = (char *)cli_smb_inbuf(subreq);
+        uint8_t *in;
+        char *inbuf;
         uint8_t wct;
         uint16_t *vwv;
 …
         NTSTATUS status;
+        status = cli_smb_recv(subreq, 0, &wct, &vwv, &num_bytes, &bytes);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(subreq);
+        status = cli_smb_recv(subreq, state, &in, 0, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
                 tevent_req_nterror(req, status);
                 return;
+        }
+        clistr_pull(inbuf, cli->dev, bytes, sizeof(fstring), num_bytes,
+                    STR_TERMINATE|STR_ASCII);
+        inbuf = (char *)in;
+        if (num_bytes) {
+                if (clistr_pull_talloc(cli,
+                                inbuf,
+                                SVAL(inbuf, smb_flg2),
+                                &cli->dev,
+                                bytes,
+                                num_bytes,
+                                STR_TERMINATE|STR_ASCII) == -1) {
+                        tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+                        return;
+                }
+        } else {
+                cli->dev = talloc_strdup(cli, "");
+                if (cli->dev == NULL) {
+                        tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
+                        return;
+                }
+        }
         if ((cli->protocol >= PROTOCOL_NT1) && (num_bytes == 3)) {
 …
 ****************************************************************************/
+bool cli_tdis(struct cli_state *cli)
+{
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,0,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBtdis);
+        SSVAL(cli->outbuf,smb_tid,cli->cnum);
+        cli_setup_packet(cli);
+        cli_send_smb(cli);
+        if (!cli_receive_smb(cli))
+                return False;
+        if (cli_is_error(cli)) {
+                return False;
+        }
+        cli->cnum = -1;
+        return True;
+}
+/****************************************************************************
+ Send a negprot command.
+****************************************************************************/
+void cli_negprot_sendsync(struct cli_state *cli)
+{
+        char *p;
+        int numprots;
+        if (cli->protocol < PROTOCOL_NT1)
+                cli->use_spnego = False;
+        memset(cli->outbuf,'\0',smb_size);
+        /* setup the protocol strings */
+        cli_set_message(cli->outbuf,0,0,True);
+        p = smb_buf(cli->outbuf);
+        for (numprots=0; numprots < ARRAY_SIZE(prots); numprots++) {
+                if (prots[numprots].prot > cli->protocol) {
+                        break;
+                }
+                *p++ = 2;
+                p += clistr_push(cli, p, prots[numprots].name, -1, STR_TERMINATE);
+        }
+        SCVAL(cli->outbuf,smb_com,SMBnegprot);
+        cli_setup_bcc(cli, p);
+        cli_setup_packet(cli);
+        SCVAL(smb_buf(cli->outbuf),0,2);
+        cli_send_smb(cli);
+struct cli_tdis_state {
+        struct cli_state *cli;
+};
+static void cli_tdis_done(struct tevent_req *subreq);
+struct tevent_req *cli_tdis_send(TALLOC_CTX *mem_ctx,
+                                 struct tevent_context *ev,
+                                 struct cli_state *cli)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_tdis_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct cli_tdis_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        subreq = cli_smb_send(state, ev, cli, SMBtdis, 0, 0, NULL, 0, NULL);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_tdis_done, req);
+        return req;
+}
+static void cli_tdis_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_tdis_state *state = tevent_req_data(
+                req, struct cli_tdis_state);
+        NTSTATUS status;
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        state->cli->cnum = -1;
+        tevent_req_done(req);
+}
+NTSTATUS cli_tdis_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+NTSTATUS cli_tdis(struct cli_state *cli)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ev = tevent_context_init(talloc_tos());
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_tdis_send(ev, ev, cli);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_tdis_recv(req);
+fail:
+        TALLOC_FREE(ev);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
         NTSTATUS status;
         uint16_t protnum;
+        status = cli_smb_recv(subreq, 1, &wct, &vwv, &num_bytes, &bytes);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(subreq);
+        uint8_t *inbuf;
+        status = cli_smb_recv(subreq, state, &inbuf, 1, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
                 tevent_req_nterror(req, status);
                 return;
 …
                 /* work out if they sent us a workgroup */
                 if (!(cli->capabilities & CAP_EXTENDED_SECURITY) &&
+                    smb_buflen(cli->inbuf) > 8) {
+                        clistr_pull(cli->inbuf, cli->server_domain,
+                                    bytes+8, sizeof(cli->server_domain),
+                                    num_bytes-8,
+                                    STR_UNICODE|STR_NOALIGN);
+                    smb_buflen(inbuf) > 8) {
+                        ssize_t ret;
+                        status = smb_bytes_talloc_string(
+                                cli, (char *)inbuf, &cli->server_domain,
+                                bytes + 8, num_bytes - 8, &ret);
+                        if (tevent_req_nterror(req, status)) {
+                                return;
+                        }
+                }
 …
                         cli->outbuf = (char *)SMB_MALLOC(CLI_SAMBA_MAX_LARGE_READX_SIZE+LARGE_WRITEX_HDR_SIZE+SAFETY_MARGIN);
                         cli->inbuf = (char *)SMB_MALLOC(CLI_SAMBA_MAX_LARGE_READX_SIZE+LARGE_WRITEX_HDR_SIZE+SAFETY_MARGIN);
+                        if (!cli->outbuf || !cli->inbuf) {
+                                tevent_req_nterror(req,
+                                                NT_STATUS_NO_MEMORY);
+                                return;
+                        }
                         cli->bufsize = CLI_SAMBA_MAX_LARGE_READX_SIZE + LARGE_WRITEX_HDR_SIZE;
+                }
 …
                 cli->serverzone *= 60;
                 /* this time is converted to GMT by make_unix_date */
                 cli->servertime = cli_make_unix_date(
                         cli, (char *)(vwv + 8));
+                cli->servertime = make_unix_date(
+                        (char *)(vwv + 8), cli->serverzone);
                 cli->readbraw_supported = ((SVAL(vwv + 5, 0) & 0x1) != 0);
                 cli->writebraw_supported = ((SVAL(vwv + 5, 0) & 0x2) != 0);
 …
+        }
+        fstrcpy(cli->desthost, host);
+        cli->desthost = talloc_strdup(cli, host);
+        if (cli->desthost == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
         /* allow hostnames of the form NAME#xx and do a netbios lookup */
 …
+        }
         if (!dest_ss || is_zero_addr((struct sockaddr *)dest_ss)) {
+        if (!dest_ss || is_zero_addr(dest_ss)) {
                 NTSTATUS status =resolve_name_list(frame,
                                         cli->desthost,
 …
    @param dest_ss (optional) The the destination IP, NULL for name based lookup
    @param port (optional) The destination port (0 for default)
-   @param retry bool. Did this connection fail with a retryable error ?
 */
 NTSTATUS cli_start_connection(struct cli_state **output_cli,
 …
                               const char *dest_host,
                               struct sockaddr_storage *dest_ss, int port,
+                              int signing_state, int flags,
+                              bool *retry)
+                              int signing_state, int flags)
+{
         NTSTATUS nt_status;
 …
         struct cli_state *cli;
         struct sockaddr_storage ss;
-        if (retry)
-                *retry = False;
         if (!my_name)
 …
                 return nt_status;
+        }
-        if (retry)
-                *retry = True;
         if (!cli_session_request(cli, &calling, &called)) {
 …
    @param domain User's domain
    @param password User's password, unencrypted unix string.
-   @param retry bool. Did this connection fail with a retryable error ?
 */
 …
                              const char *user, const char *domain,
                              const char *password, int flags,
+                             int signing_state,
+                             bool *retry)
+                             int signing_state)
+{
         NTSTATUS nt_status;
 …
         nt_status = cli_start_connection(&cli, my_name, dest_host,
                                          dest_ss, port, signing_state,
                                          flags, retry);
+                                         flags);
         if (!NT_STATUS_IS_OK(nt_status)) {
 …
                       uint16 *max_xmit, uint16 *tid)
+{
+        char *p;
+        struct tevent_req *req;
+        uint16_t *ret_vwv;
+        uint8_t *bytes;
+        NTSTATUS status;
         if (!lp_client_plaintext_auth() && (*pass)) {
 …
+        }
+        memset(cli->outbuf,'\0',smb_size);
+        memset(cli->inbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf, 0, 0, True);
+        SCVAL(cli->outbuf,smb_com,SMBtcon);
+        cli_setup_packet(cli);
+        p = smb_buf(cli->outbuf);
+        *p++ = 4; p += clistr_push(cli, p, service, -1, STR_TERMINATE | STR_NOALIGN);
+        *p++ = 4; p += clistr_push(cli, p, pass, -1, STR_TERMINATE | STR_NOALIGN);
+        *p++ = 4; p += clistr_push(cli, p, dev, -1, STR_TERMINATE | STR_NOALIGN);
+        cli_setup_bcc(cli, p);
+        cli_send_smb(cli);
+        if (!cli_receive_smb(cli)) {
+                return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
+        }
+        if (cli_is_error(cli)) {
+                return cli_nt_error(cli);
+        }
+        *max_xmit = SVAL(cli->inbuf, smb_vwv0);
+        *tid = SVAL(cli->inbuf, smb_vwv1);
+        bytes = talloc_array(talloc_tos(), uint8_t, 0);
+        bytes = smb_bytes_push_bytes(bytes, 4, NULL, 0);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   service, strlen(service)+1, NULL);
+        bytes = smb_bytes_push_bytes(bytes, 4, NULL, 0);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   pass, strlen(pass)+1, NULL);
+        bytes = smb_bytes_push_bytes(bytes, 4, NULL, 0);
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+                                   dev, strlen(dev)+1, NULL);
+        status = cli_smb(talloc_tos(), cli, SMBtcon, 0, 0, NULL,
+                         talloc_get_size(bytes), bytes, &req,
+, NULL, &ret_vwv, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        *max_xmit = SVAL(ret_vwv + 0, 0);
+        *tid = SVAL(ret_vwv + 1, 0);
         return NT_STATUS_OK;
 …
                                         user_info->password ? user_info->password : "",
                                         flags,
                                         Undefined, NULL);
+                                        Undefined);
         if (NT_STATUS_IS_OK(nt_status)) {
 …
 struct cli_state *get_ipc_connect_master_ip(TALLOC_CTX *ctx,
                                 struct ip_service *mb_ip,
+                                struct sockaddr_storage *mb_ip,
                                 const struct user_auth_info *user_info,
                                 char **pp_workgroup_out)
 …
         *pp_workgroup_out = NULL;
         print_sockaddr(addr, sizeof(addr), &mb_ip->ss);
+        print_sockaddr(addr, sizeof(addr), mb_ip);
         DEBUG(99, ("Looking up name of master browser %s\n",
                    addr));
 …
          * MSBROWSE if the wildcard query fails.
          */
         if (!name_status_find("*", 0, 0x1d, &mb_ip->ss, name) &&
             !name_status_find(MSBROWSE, 1, 0x1d, &mb_ip->ss, name)) {
+        if (!name_status_find("*", 0, 0x1d, mb_ip, name) &&
+            !name_status_find(MSBROWSE, 1, 0x1d, mb_ip, name)) {
                 DEBUG(99, ("Could not retrieve name status for %s\n",
 …
                                         char **pp_workgroup_out)
+{
         struct ip_service *ip_list;
+        struct sockaddr_storage *ip_list;
         struct cli_state *cli;
         int i, count;
+        NTSTATUS status;
         *pp_workgroup_out = NULL;
 …
         /* Go looking for workgroups by broadcasting on the local network */
+        if (!NT_STATUS_IS_OK(name_resolve_bcast(MSBROWSE, 1, &ip_list,
+                                                &count))) {
+                DEBUG(99, ("No master browsers responded\n"));
+        status = name_resolve_bcast(MSBROWSE, 1, talloc_tos(),
+                                    &ip_list, &count);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(99, ("No master browsers responded: %s\n",
+                           nt_errstr(status)));
                 return False;
+        }
 …
         for (i = 0; i < count; i++) {
                 char addr[INET6_ADDRSTRLEN];
                 print_sockaddr(addr, sizeof(addr), &ip_list[i].ss);
+                print_sockaddr(addr, sizeof(addr), &ip_list[i]);
                 DEBUG(99, ("Found master browser %s\n", addr));

vendor/current/source3/libsmb/clidfs.c

-              r597
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
+#include "msdfs.h"
+#include "trans2.h"
+#include "libsmb/nmblib.h"
 /********************************************************************
 …
         /* have to open a new connection */
+        if (!(c=cli_initialise_ex(get_cmdline_auth_info_signing_state(auth_info)))) {
+        c = cli_initialise_ex(get_cmdline_auth_info_signing_state(auth_info));
+        if (c == NULL) {
                 d_printf("Connection to %s failed\n", server_n);
-                if (c) {
-                        cli_shutdown(c);
+                }
                 return NULL;
+        }
 …
+        }
         if (referring_cli && referring_cli->posix_capabilities) {
+        if (referring_cli && referring_cli->requested_posix_capabilities) {
                 uint16 major, minor;
                 uint32 caplow, caphigh;
 …
         /* Search to the start of the list. */
         for (p = cli; p; p = p->prev) {
+        for (p = cli; p; p = DLIST_PREV(p)) {
                 if (strequal(server, p->desthost) &&
                                 strequal(share,p->share)) {
 …
 **********************************************************************/
 static void split_dfs_path(TALLOC_CTX *ctx,
+static bool split_dfs_path(TALLOC_CTX *ctx,
                                 const char *nodepath,
                                 char **pp_server,
 …
         path = talloc_strdup(ctx, nodepath);
         if (!path) {
                 return;
+                goto fail;
+        }
         if ( path[0] != '\\' ) {
                 return;
+                goto fail;
+        }
         p = strchr_m( path + 1, '\\' );
         if ( !p ) {
                 return;
+                goto fail;
+        }
 …
                 *pp_extrapath = talloc_strdup(ctx, "");
+        }
+        if (*pp_extrapath == NULL) {
+                goto fail;
+        }
         *pp_share = talloc_strdup(ctx, p);
+        if (*pp_share == NULL) {
+                goto fail;
+        }
         *pp_server = talloc_strdup(ctx, &path[1]);
+        if (*pp_server == NULL) {
+                goto fail;
+        }
+        TALLOC_FREE(path);
+        return true;
+fail:
+        TALLOC_FREE(*pp_share);
+        TALLOC_FREE(*pp_extrapath);
+        TALLOC_FREE(path);
+        return false;
+}
 …
+        }
         if (cli->posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
+        if (cli->requested_posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
                 path_sep = '/';
+        }
 …
 ********************************************************************/
+static bool cli_dfs_check_error( struct cli_state *cli, NTSTATUS status )
+{
+        uint32 flgs2 = SVAL(cli->inbuf,smb_flg2);
+static bool cli_dfs_check_error(struct cli_state *cli, NTSTATUS expected,
+                                NTSTATUS status)
+{
         /* only deal with DS when we negotiated NT_STATUS codes and UNICODE */
+        if (!((flgs2&FLAGS2_32_BIT_ERROR_CODES) &&
+                                (flgs2&FLAGS2_UNICODE_STRINGS)))
+                return false;
+        if (NT_STATUS_EQUAL(status, NT_STATUS(IVAL(cli->inbuf,smb_rcls))))
+        if (!(cli->capabilities & CAP_UNICODE)) {
+                return false;
+        }
+        if (!(cli->capabilities & CAP_STATUS32)) {
+                return false;
+        }
+        if (NT_STATUS_EQUAL(status, expected)) {
                 return true;
+        }
         return false;
+}
 …
 ********************************************************************/
 bool cli_dfs_get_referral(TALLOC_CTX *ctx,
+NTSTATUS cli_dfs_get_referral(TALLOC_CTX *ctx,
                         struct cli_state *cli,
                         const char *path,
                         CLIENT_DFS_REFERRAL**refs,
+                        struct client_dfs_referral **refs,
                         size_t *num_refs,
                         size_t *consumed)
 …
         unsigned int data_len = 0;
         unsigned int param_len = 0;
         uint16 setup = TRANSACT2_GET_DFS_REFERRAL;
         char *param = NULL;
         char *rparam=NULL, *rdata=NULL;
+        uint16 setup[1];
+        uint8_t *param = NULL;
+        uint8_t *rdata = NULL;
         char *p;
         char *endp;
 …
         uint16_t consumed_ucs;
         uint16 num_referrals;
         CLIENT_DFS_REFERRAL *referrals = NULL;
         bool ret = false;
+        struct client_dfs_referral *referrals = NULL;
+        NTSTATUS status;
         *num_refs = 0;
         *refs = NULL;
+        param = SMB_MALLOC_ARRAY(char, 2+pathlen+2);
+        SSVAL(setup, 0, TRANSACT2_GET_DFS_REFERRAL);
+        param = SMB_MALLOC_ARRAY(uint8_t, 2+pathlen+2);
         if (!param) {
+                status = NT_STATUS_NO_MEMORY;
                 goto out;
+        }
         SSVAL(param, 0, 0x03);  /* max referral level */
         p = &param[2];
+        p = (char *)(&param[2]);
         path_ucs = (smb_ucs2_t *)p;
 …
         param_len = PTR_DIFF(p, param);
+        if (!cli_send_trans(cli, SMBtrans2,
+                        NULL,                        /* name */
+                        -1, 0,                          /* fid, flags */
+                        &setup, 1, 0,                   /* setup, length, max */
+                        param, param_len, 2,            /* param, length, max */
+                        NULL, 0, cli->max_xmit /* data, length, max */
+                        )) {
+        status = cli_trans(talloc_tos(), cli, SMBtrans2,
+                           NULL, 0xffff, 0, 0,
+                           setup, 1, 0,
+                           param, param_len, 2,
+                           NULL, 0, cli->max_xmit,
+                           NULL,
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL,
+                           &rdata, 4, &data_len);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto out;
+        }
-        if (!cli_receive_trans(cli, SMBtrans2,
-                &rparam, &param_len,
-                &rdata, &data_len)) {
-                goto out;
+        }
         if (data_len < 4) {
                 goto out;
+        }
         endp = rdata + data_len;
+        endp = (char *)rdata + data_len;
         consumed_ucs  = SVAL(rdata, 0);
 …
                 uint16 node_offset;
                 referrals = TALLOC_ARRAY(ctx, CLIENT_DFS_REFERRAL,
                                 num_referrals);
+                referrals = talloc_array(ctx, struct client_dfs_referral,
+                                         num_referrals);
                 if (!referrals) {
 …
                 /* start at the referrals array */
                 p = rdata+8;
+                p = (char *)rdata+8;
                 for (i=0; i<num_referrals && p < endp; i++) {
                         if (p + 18 > endp) {
 …
+                        }
                         clistr_pull_talloc(ctx, cli->inbuf,
+                                           SVAL(cli->inbuf, smb_flg2),
                                            &referrals[i].dfspath,
                                            p+node_offset, -1,
 …
+        }
-        ret = true;
         *num_refs = num_referrals;
         *refs = referrals;
 …
         TALLOC_FREE(consumed_path);
         SAFE_FREE(param);
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return ret;
+        TALLOC_FREE(rdata);
+        return status;
+}
 …
                         char **pp_targetpath)
+{
         CLIENT_DFS_REFERRAL *refs = NULL;
+        struct client_dfs_referral *refs = NULL;
         size_t num_refs = 0;
         size_t consumed = 0;
 …
         SMB_STRUCT_STAT sbuf;
         uint32 attributes;
+        NTSTATUS status;
         if ( !rootcli || !path || !targetcli ) {
 …
+        }
+        if (cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes)) {
+        status = cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes);
+        if (NT_STATUS_IS_OK(status)) {
                 /* This is an ordinary path, just return it. */
                 *targetcli = rootcli;
 …
         /* Special case where client asked for a path that does not exist */
+        if (cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+        if (cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND,
+                                status)) {
                 *targetcli = rootcli;
                 *pp_targetpath = talloc_strdup(ctx, path);
 …
         /* We got an error, check for DFS referral. */
+        if (!cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED)) {
+        if (!cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED,
+                                 status)) {
                 return false;
+        }
 …
+        }
+        if (!cli_dfs_get_referral(ctx, cli_ipc, dfs_path, &refs,
+                        &num_refs, &consumed) || !num_refs) {
+        status = cli_dfs_get_referral(ctx, cli_ipc, dfs_path, &refs,
+                                      &num_refs, &consumed);
+        if (!NT_STATUS_IS_OK(status) || !num_refs) {
                 return false;
+        }
 …
                 return false;
+        }
+        split_dfs_path(ctx, refs[0].dfspath, &server, &share, &extrapath );
+        if (!server || !share) {
+        if (!split_dfs_path(ctx, refs[0].dfspath, &server, &share,
+                            &extrapath)) {
                 return false;
+        }
 …
                                 const char *domain)
+{
         CLIENT_DFS_REFERRAL *refs = NULL;
+        struct client_dfs_referral *refs = NULL;
         size_t num_refs = 0;
         size_t consumed = 0;
 …
         uint16 cnum;
         char *newextrapath = NULL;
+        NTSTATUS status;
         if (!cli || !sharename) {
 …
         if (force_encrypt) {
                 NTSTATUS status = cli_cm_force_encryption(cli,
+                status = cli_cm_force_encryption(cli,
                                         username,
                                         password,
 …
+        }
+        res = cli_dfs_get_referral(ctx, cli, fullpath, &refs, &num_refs, &consumed);
+        if (!cli_tdis(cli)) {
+        status = cli_dfs_get_referral(ctx, cli, fullpath, &refs,
+                                      &num_refs, &consumed);
+        res = NT_STATUS_IS_OK(status);
+        status = cli_tdis(cli);
+        if (!NT_STATUS_IS_OK(status)) {
                 return false;
+        }
 …
+        }
+        split_dfs_path(ctx, refs[0].dfspath, pp_newserver,
+                        pp_newshare, &newextrapath );
+        if ((*pp_newserver == NULL) || (*pp_newshare == NULL)) {
+        if (!split_dfs_path(ctx, refs[0].dfspath, pp_newserver,
+                            pp_newshare, &newextrapath)) {
                 return false;
+        }

vendor/current/source3/libsmb/clidgram.c

-              r594
+              r740
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "libsmb/clidgram.h"
+#include "libsmb/nmblib.h"
+#include "messages.h"
 /*
 …
  */
+static bool cli_send_mailslot(struct messaging_context *msg_ctx,
+                       bool unique, const char *mailslot,
+static bool cli_prep_mailslot(bool unique, const char *mailslot,
                        uint16 priority,
                        char *buf, int len,
                        const char *srcname, int src_type,
                        const char *dstname, int dest_type,
+                       const struct sockaddr_storage *dest_ss)
+{
+        struct packet_struct p;
+        struct dgram_packet *dgram = &p.packet.dgram;
+                       const struct sockaddr_storage *dest_ss,
+                       int dgm_id,
+                       struct packet_struct *p)
+{
+        struct dgram_packet *dgram = &p->packet.dgram;
         char *ptr, *p2;
         char tmp[4];
-        pid_t nmbd_pid;
         char addr[INET6_ADDRSTRLEN];
+        if ((nmbd_pid = pidfile_pid("nmbd")) == 0) {
+                DEBUG(3, ("No nmbd found\n"));
+                return False;
+        }
+        if (dest_ss->ss_family != AF_INET) {
+                DEBUG(3, ("cli_send_mailslot: can't send to IPv6 address.\n"));
+                return false;
+        }
+        memset((char *)&p, '\0', sizeof(p));
+        ZERO_STRUCTP(p);
         /*
 …
         dgram->header.flags.first = True;
         dgram->header.flags.more = False;
+        dgram->header.dgm_id = ((unsigned)time(NULL)%(unsigned)0x7FFF) +
+                ((unsigned)sys_getpid()%(unsigned)100);
+        dgram->header.dgm_id = dgm_id;
         /* source ip is filled by nmbd */
         dgram->header.dgm_length = 0; /* Let build_dgram() handle this. */
 …
         dgram->datasize = PTR_DIFF(p2,ptr+4); /* +4 for tcp length. */
         p.packet_type = DGRAM_PACKET;
         p.ip = ((const struct sockaddr_in *)dest_ss)->sin_addr;
         p.timestamp = time(NULL);
+        p->packet_type = DGRAM_PACKET;
+        p->ip = ((const struct sockaddr_in *)dest_ss)->sin_addr;
+        p->timestamp = time(NULL);
         DEBUG(4,("send_mailslot: Sending to mailslot %s from %s ",
 …
         DEBUGADD(4,("to %s IP %s\n", nmb_namestr(&dgram->dest_name), addr));
+        return NT_STATUS_IS_OK(messaging_send_buf(msg_ctx,
+                                                  pid_to_procid(nmbd_pid),
+                                                  MSG_SEND_PACKET,
+                                                  (uint8 *)&p, sizeof(p)));
+}
+static const char *mailslot_name(TALLOC_CTX *mem_ctx, struct in_addr dc_ip)
+        return true;
+}
+static char *mailslot_name(TALLOC_CTX *mem_ctx, struct in_addr dc_ip)
+{
         return talloc_asprintf(mem_ctx, "%s%X",
 …
+}
 bool send_getdc_request(TALLOC_CTX *mem_ctx,
                         struct messaging_context *msg_ctx,
                         struct sockaddr_storage *dc_ss,
                         const char *domain_name,
                         const DOM_SID *sid,
                         uint32_t nt_version)
+{
+        struct in_addr dc_ip;
         const char *my_acct_name = NULL;
         const char *my_mailslot = NULL;
+static bool prep_getdc_request(const struct sockaddr_storage *dc_ss,
+                               const char *domain_name,
+                               const struct dom_sid *sid,
+                               uint32_t nt_version,
+                               const char *my_mailslot,
+                               int dgm_id,
+                               struct packet_struct *p)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        const char *my_acct_name;
         struct nbt_netlogon_packet packet;
         struct NETLOGON_SAM_LOGON_REQUEST *s;
         enum ndr_err_code ndr_err;
         DATA_BLOB blob;
+        DATA_BLOB blob = data_blob_null;
         struct dom_sid my_sid;
+        bool ret = false;
         ZERO_STRUCT(packet);
         ZERO_STRUCT(my_sid);
+        if (dc_ss->ss_family != AF_INET) {
+                return false;
+        }
+        if (sid) {
+        if (sid != NULL) {
                 my_sid = *sid;
+        }
+        dc_ip = ((struct sockaddr_in *)dc_ss)->sin_addr;
+        my_mailslot = mailslot_name(mem_ctx, dc_ip);
+        if (!my_mailslot) {
+                return false;
+        }
+        my_acct_name = talloc_asprintf(mem_ctx, "%s$", global_myname());
+        if (!my_acct_name) {
+                return false;
+        my_acct_name = talloc_asprintf(talloc_tos(), "%s$", global_myname());
+        if (my_acct_name == NULL) {
+                goto fail;
+        }
 …
+        }
         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &packet,
+        ndr_err = ndr_push_struct_blob(&blob, talloc_tos(), &packet,
                        (ndr_push_flags_fn_t)ndr_push_nbt_netlogon_packet);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return false;
+        }
         return cli_send_mailslot(msg_ctx,
                                  false, NBT_MAILSLOT_NTLOGON, 0,
                                  (char *)blob.data, blob.length,
                                  global_myname(), 0, domain_name, 0x1c,
+                                 dc_ss);
+}
+bool receive_getdc_response(TALLOC_CTX *mem_ctx,
+                            struct sockaddr_storage *dc_ss,
+                            const char *domain_name,
                             uint32_t *nt_version,
                             const char **dc_name,
                             struct netlogon_samlogon_response **_r)
+{
         struct packet_struct *packet;
         const char *my_mailslot = NULL;
+        struct in_addr dc_ip;
+                goto fail;
+        }
+        ret = cli_prep_mailslot(false, NBT_MAILSLOT_NTLOGON, 0,
+                                (char *)blob.data, blob.length,
+                                global_myname(), 0, domain_name, 0x1c,
+                                dc_ss, dgm_id, p);
+fail:
+        TALLOC_FREE(frame);
+        return ret;
+}
+static bool parse_getdc_response(
+        struct packet_struct *packet,
+        TALLOC_CTX *mem_ctx,
+        const char *domain_name,
+        uint32_t *nt_version,
+        const char **dc_name,
+        struct netlogon_samlogon_response **samlogon_response)
+{
         DATA_BLOB blob;
         struct netlogon_samlogon_response r;
+        struct netlogon_samlogon_response *r;
         union dgram_message_body p;
         enum ndr_err_code ndr_err;
 …
         const char *returned_domain = NULL;
-        if (dc_ss->ss_family != AF_INET) {
-                return false;
+        }
-        dc_ip = ((struct sockaddr_in *)dc_ss)->sin_addr;
-        my_mailslot = mailslot_name(mem_ctx, dc_ip);
-        if (!my_mailslot) {
-                return false;
+        }
-        packet = receive_unexpected(DGRAM_PACKET, 0, my_mailslot);
-        if (packet == NULL) {
-                DEBUG(5, ("Did not receive packet for %s\n", my_mailslot));
-                return False;
+        }
-        DEBUG(5, ("Received packet for %s\n", my_mailslot));
         blob = data_blob_const(packet->packet.dgram.data,
                                packet->packet.dgram.datasize);
         if (blob.length < 4) {
+                DEBUG(0,("invalid length: %d\n", (int)blob.length));
+                free_packet(packet);
+                DEBUG(1, ("invalid length: %d\n", (int)blob.length));
                 return false;
+        }
         if (RIVAL(blob.data,0) != DGRAM_SMB) {
+                DEBUG(0,("invalid packet\n"));
+                free_packet(packet);
+                DEBUG(1, ("invalid packet\n"));
                 return false;
+        }
 …
         blob.length -= 4;
         ndr_err = ndr_pull_union_blob_all(&blob, mem_ctx, NULL, &p, DGRAM_SMB,
+        ndr_err = ndr_pull_union_blob_all(&blob, mem_ctx, &p, DGRAM_SMB,
                        (ndr_pull_flags_fn_t)ndr_pull_dgram_smb_packet);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                DEBUG(0,("failed to parse packet\n"));
+                free_packet(packet);
+                DEBUG(1, ("failed to parse packet\n"));
                 return false;
+        }
         if (p.smb.smb_command != SMB_TRANSACTION) {
+                DEBUG(0,("invalid smb_command: %d\n", p.smb.smb_command));
+                free_packet(packet);
+                DEBUG(1, ("invalid smb_command: %d\n", p.smb.smb_command));
                 return false;
+        }
 …
         blob = p.smb.body.trans.data;
+        ZERO_STRUCT(r);
+        status = pull_netlogon_samlogon_response(&blob, mem_ctx, NULL, &r);
+        r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
+        if (!r) {
+                return false;
+        }
+        status = pull_netlogon_samlogon_response(&blob, r, r);
         if (!NT_STATUS_IS_OK(status)) {
                 free_packet(packet);
                 return false;
+        }
         map_netlogon_samlogon_response(&r);
+                TALLOC_FREE(r);
+                return false;
+        }
+        map_netlogon_samlogon_response(r);
         /* do we still need this ? */
         *nt_version = r.ntver;
         returned_domain = r.data.nt5_ex.domain;
         returned_dc = r.data.nt5_ex.pdc_name;
+        *nt_version = r->ntver;
+        returned_domain = r->data.nt5_ex.domain_name;
+        returned_dc = r->data.nt5_ex.pdc_name;
         if (!strequal(returned_domain, domain_name)) {
                 DEBUG(3, ("GetDC: Expected domain %s, got %s\n",
                           domain_name, returned_domain));
+                free_packet(packet);
+                return false;
+        }
+                TALLOC_FREE(r);
+                return false;
+        }
+        if (*returned_dc == '\\') returned_dc += 1;
+        if (*returned_dc == '\\') returned_dc += 1;
         *dc_name = talloc_strdup(mem_ctx, returned_dc);
         if (!*dc_name) {
+                free_packet(packet);
+                return false;
+        }
+        if (**dc_name == '\\')  *dc_name += 1;
+        if (**dc_name == '\\')  *dc_name += 1;
+        if (_r) {
+                *_r = (struct netlogon_samlogon_response *)talloc_memdup(
+                        mem_ctx, &r, sizeof(struct netlogon_samlogon_response));
+                if (!*_r) {
+                free_packet(packet);
+                        return false;
+                }
+                TALLOC_FREE(r);
+                return false;
+        }
+        if (samlogon_response) {
+                *samlogon_response = r;
+        } else {
+                TALLOC_FREE(r);
+        }
 …
                    *dc_name, returned_domain));
-        free_packet(packet);
         return True;
+}
+struct nbt_getdc_state {
+        struct tevent_context *ev;
+        struct messaging_context *msg_ctx;
+        struct nb_packet_reader *reader;
+        const char *my_mailslot;
+        pid_t nmbd_pid;
+        const struct sockaddr_storage *dc_addr;
+        const char *domain_name;
+        const struct dom_sid *sid;
+        uint32_t nt_version;
+        const char *dc_name;
+        struct netlogon_samlogon_response *samlogon_response;
+        struct packet_struct p;
+};
+static void nbt_getdc_got_reader(struct tevent_req *subreq);
+static void nbt_getdc_got_response(struct tevent_req *subreq);
+struct tevent_req *nbt_getdc_send(TALLOC_CTX *mem_ctx,
+                                  struct tevent_context *ev,
+                                  struct messaging_context *msg_ctx,
+                                  const struct sockaddr_storage *dc_addr,
+                                  const char *domain_name,
+                                  const struct dom_sid *sid,
+                                  uint32_t nt_version)
+{
+        struct tevent_req *req, *subreq;
+        struct nbt_getdc_state *state;
+        uint16_t dgm_id;
+        req = tevent_req_create(mem_ctx, &state, struct nbt_getdc_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->msg_ctx = msg_ctx;
+        state->dc_addr = dc_addr;
+        state->domain_name = domain_name;
+        state->sid = sid;
+        state->nt_version = nt_version;
+        if (dc_addr->ss_family != AF_INET) {
+                tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
+                return tevent_req_post(req, ev);
+        }
+        state->my_mailslot = mailslot_name(
+                state, ((struct sockaddr_in *)dc_addr)->sin_addr);
+        if (tevent_req_nomem(state->my_mailslot, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->nmbd_pid = pidfile_pid("nmbd");
+        if (state->nmbd_pid == 0) {
+                DEBUG(3, ("No nmbd found\n"));
+                tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
+                return tevent_req_post(req, ev);
+        }
+        generate_random_buffer((uint8_t *)(void *)&dgm_id, sizeof(dgm_id));
+        if (!prep_getdc_request(dc_addr, domain_name, sid, nt_version,
+                                state->my_mailslot, dgm_id & 0x7fff,
+                                &state->p)) {
+                DEBUG(3, ("prep_getdc_request failed\n"));
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
+        subreq = nb_packet_reader_send(state, ev, DGRAM_PACKET, -1,
+                                       state->my_mailslot);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, nbt_getdc_got_reader, req);
+        return req;
+}
+static void nbt_getdc_got_reader(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nbt_getdc_state *state = tevent_req_data(
+                req, struct nbt_getdc_state);
+        NTSTATUS status;
+        status = nb_packet_reader_recv(subreq, state, &state->reader);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                DEBUG(10, ("nb_packet_reader_recv returned %s\n",
+                           nt_errstr(status)));
+                return;
+        }
+        status = messaging_send_buf(
+                state->msg_ctx, pid_to_procid(state->nmbd_pid),
+                MSG_SEND_PACKET, (uint8_t *)&state->p, sizeof(state->p));
+        if (tevent_req_nterror(req, status)) {
+                DEBUG(10, ("messaging_send_buf returned %s\n",
+                           nt_errstr(status)));
+                return;
+        }
+        subreq = nb_packet_read_send(state, state->ev, state->reader);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nbt_getdc_got_response, req);
+}
+static void nbt_getdc_got_response(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nbt_getdc_state *state = tevent_req_data(
+                req, struct nbt_getdc_state);
+        struct packet_struct *p;
+        NTSTATUS status;
+        bool ret;
+        status = nb_packet_read_recv(subreq, &p);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        ret = parse_getdc_response(p, state, state->domain_name,
+                                   &state->nt_version, &state->dc_name,
+                                   &state->samlogon_response);
+        free_packet(p);
+        if (!ret) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS nbt_getdc_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                        uint32_t *nt_version, const char **dc_name,
+                        struct netlogon_samlogon_response **samlogon_response)
+{
+        struct nbt_getdc_state *state = tevent_req_data(
+                req, struct nbt_getdc_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (nt_version != NULL) {
+                *nt_version = state->nt_version;
+        }
+        if (dc_name != NULL) {
+                *dc_name = talloc_move(mem_ctx, &state->dc_name);
+        }
+        if (samlogon_response != NULL) {
+                *samlogon_response = talloc_move(
+                        mem_ctx, &state->samlogon_response);
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS nbt_getdc(struct messaging_context *msg_ctx,
+                   const struct sockaddr_storage *dc_addr,
+                   const char *domain_name,
+                   const struct dom_sid *sid,
+                   uint32_t nt_version,
+                   TALLOC_CTX *mem_ctx,
+                   uint32_t *pnt_version,
+                   const char **dc_name,
+                   struct netlogon_samlogon_response **samlogon_response)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        ev = tevent_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = nbt_getdc_send(ev, ev, msg_ctx, dc_addr, domain_name,
+                             sid, nt_version);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = nbt_getdc_recv(req, mem_ctx, pnt_version, dc_name,
+                                samlogon_response);
+ fail:
+        TALLOC_FREE(frame);
+        return status;
+}

vendor/current/source3/libsmb/clientgen.c

-              r427
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "smb_signing.h"
+#include "async_smb.h"
 /*******************************************************************
 …
         /* If the server is not responding, note that now */
         if (len < 0) {
+                DEBUG(0, ("Receiving SMB: Server stopped responding\n"));
+                close(cli->fd);
+                cli->fd = -1;
+                /*
+                 * only log if the connection should still be open and not when
+                 * the connection was closed due to a dropped ip message
+                 */
+                if (cli->fd != -1) {
+                        char addr[INET6_ADDRSTRLEN];
+                        print_sockaddr(addr, sizeof(addr), &cli->dest_ss);
+                        DEBUG(0, ("Receiving SMB: Server %s stopped responding\n",
+                                addr));
+                        close(cli->fd);
+                        cli->fd = -1;
+                }
                 return false;
+        }
 …
+}
-/****************************************************************************
- Read the data portion of a readX smb.
- The timeout is in milliseconds
-****************************************************************************/
-ssize_t cli_receive_smb_data(struct cli_state *cli, char *buffer, size_t len)
+{
-        NTSTATUS status;
-        set_smb_read_error(&cli->smb_rw_error, SMB_READ_OK);
-        status = read_fd_with_timeout(
-                cli->fd, buffer, len, len, cli->timeout, NULL);
-        if (NT_STATUS_IS_OK(status)) {
-                return len;
+        }
-        if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {
-                set_smb_read_error(&cli->smb_rw_error, SMB_READ_EOF);
-                return -1;
+        }
-        if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
-                set_smb_read_error(&cli->smb_rw_error, SMB_READ_TIMEOUT);
-                return -1;
+        }
-        set_smb_read_error(&cli->smb_rw_error, SMB_READ_ERROR);
-        return -1;
+}
 static ssize_t write_socket(int fd, const char *buf, size_t len)
+{
 …
         if (enc_on) {
                 cli_free_enc_buffer(cli, buf_out);
+        }
-        /* Increment the mid so we can tell between responses. */
-        cli->mid++;
-        if (!cli->mid)
-                cli->mid++;
-        return true;
+}
-/****************************************************************************
- Send a "direct" writeX smb to a fd.
-****************************************************************************/
-bool cli_send_smb_direct_writeX(struct cli_state *cli,
-                                const char *p,
-                                size_t extradata)
+{
-        /* First length to send is the offset to the data. */
-        size_t len = SVAL(cli->outbuf,smb_vwv11) + 4;
-        size_t nwritten=0;
-        struct iovec iov[2];
-        /* fd == -1 causes segfaults -- Tom (tom@ninja.nl) */
-        if (cli->fd == -1) {
-                return false;
+        }
-        if (client_is_signing_on(cli)) {
-                DEBUG(0,("cli_send_smb_large: cannot send signed packet.\n"));
-                return false;
+        }
-        iov[0].iov_base = (void *)cli->outbuf;
-        iov[0].iov_len = len;
-        iov[1].iov_base = CONST_DISCARD(void *, p);
-        iov[1].iov_len = extradata;
-        nwritten = write_data_iov(cli->fd, iov, 2);
-        if (nwritten < (len + extradata)) {
-                close(cli->fd);
-                cli->fd = -1;
-                cli->smb_rw_error = SMB_WRITE_ERROR;
-                DEBUG(0,("Error writing %d bytes to client. (%s)\n",
-                         (int)(len+extradata), strerror(errno)));
-                return false;
+        }
 …
 #if defined(DEVELOPER)
         /* just because we over-allocate, doesn't mean it's right to use it */
         clobber_region(FUNCTION_MACRO, __LINE__, cli->outbuf+cli->bufsize, SAFETY_MARGIN);
         clobber_region(FUNCTION_MACRO, __LINE__, cli->inbuf+cli->bufsize, SAFETY_MARGIN);
+        clobber_region(__FUNCTION__, __LINE__, cli->outbuf+cli->bufsize, SAFETY_MARGIN);
+        clobber_region(__FUNCTION__, __LINE__, cli->inbuf+cli->bufsize, SAFETY_MARGIN);
 #endif
 …
 ****************************************************************************/
+void cli_shutdown(struct cli_state *cli)
+{
+        if (cli == NULL) {
+                return;
+        }
+        if (cli->prev == NULL) {
+                /*
+                 * Possible head of a DFS list,
+                 * shutdown all subsidiary DFS
+                 * connections.
+                 */
+                struct cli_state *p, *next;
+                for (p = cli->next; p; p = next) {
+                        next = p->next;
+                        cli_shutdown(p);
+                }
+        } else {
+                /*
+                 * We're a subsidiary connection.
+                 * Just remove ourselves from the
+                 * DFS list.
+                 */
+                DLIST_REMOVE(cli->prev, cli);
+        }
+static void _cli_shutdown(struct cli_state *cli)
+{
         cli_nt_pipes_close(cli);
 …
+}
+void cli_shutdown(struct cli_state *cli)
+{
+        struct cli_state *cli_head;
+        if (cli == NULL) {
+                return;
+        }
+        DLIST_HEAD(cli, cli_head);
+        if (cli_head == cli) {
+                /*
+                 * head of a DFS list, shutdown all subsidiary DFS
+                 * connections.
+                 */
+                struct cli_state *p, *next;
+                for (p = cli_head->next; p; p = next) {
+                        next = p->next;
+                        DLIST_REMOVE(cli_head, p);
+                        _cli_shutdown(p);
+                }
+        } else {
+                DLIST_REMOVE(cli_head, cli);
+        }
+        _cli_shutdown(cli);
+}
 /****************************************************************************
  Set socket options on a open connection.
 …
         cli->case_sensitive = case_sensitive;
         return ret;
+}
-/****************************************************************************
-Send a keepalive packet to the server
-****************************************************************************/
-bool cli_send_keepalive(struct cli_state *cli)
+{
-        if (cli->fd == -1) {
-                DEBUG(3, ("cli_send_keepalive: fd == -1\n"));
-                return false;
+        }
-        if (!send_keepalive(cli->fd)) {
-                close(cli->fd);
-                cli->fd = -1;
-                DEBUG(0,("Error sending keepalive packet to client.\n"));
-                return false;
+        }
-        return true;
+}
 …
         uint32_t num_bytes;
         uint8_t *bytes;
+        status = cli_smb_recv(subreq, 0, NULL, NULL, &num_bytes, &bytes);
+        uint8_t *inbuf;
+        status = cli_smb_recv(subreq, state, &inbuf, 0, NULL, NULL,
+                              &num_bytes, &bytes);
         if (!NT_STATUS_IS_OK(status)) {
                 tevent_req_nterror(req, status);
 …
         return false;
+}
+NTSTATUS cli_smb(TALLOC_CTX *mem_ctx, struct cli_state *cli,
+                 uint8_t smb_command, uint8_t additional_flags,
+                 uint8_t wct, uint16_t *vwv,
+                 uint32_t num_bytes, const uint8_t *bytes,
+                 struct tevent_req **result_parent,
+                 uint8_t min_wct, uint8_t *pwct, uint16_t **pvwv,
+                 uint32_t *pnum_bytes, uint8_t **pbytes)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req = NULL;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ev = tevent_context_init(mem_ctx);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_smb_send(mem_ctx, ev, cli, smb_command, additional_flags,
+                           wct, vwv, num_bytes, bytes);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_smb_recv(req, NULL, NULL, min_wct, pwct, pvwv,
+                              pnum_bytes, pbytes);
+fail:
+        TALLOC_FREE(ev);
+        if (NT_STATUS_IS_OK(status) && (result_parent != NULL)) {
+                *result_parent = req;
+        }
+        return status;
+}

vendor/current/source3/libsmb/clierror.c

r427	r740
21	21
22	22	#include "includes.h"
	23	#include "libsmb/libsmb.h"
23	24
24	25	/*****************************************************

vendor/current/source3/libsmb/clifile.c

-              r414
+              r740
    Copyright (C) Andrew Tridgell 1994-1998
    Copyright (C) Jeremy Allison 2001-2009
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "system/filesys.h"
+#include "libsmb/libsmb.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "libsmb/clirap.h"
+#include "trans2.h"
+#include "ntioctl.h"
 /***********************************************************
 …
+}
+uint8_t *smb_bytes_push_bytes(uint8_t *buf, uint8_t prefix,
+                              const uint8_t *bytes, size_t num_bytes)
+{
+        size_t buflen;
+        if (buf == NULL) {
+                return NULL;
+        }
+        buflen = talloc_get_size(buf);
+        buf = TALLOC_REALLOC_ARRAY(NULL, buf, uint8_t,
+                                   buflen + 1 + num_bytes);
+        if (buf == NULL) {
+                return NULL;
+        }
+        buf[buflen] = prefix;
+        memcpy(&buf[buflen+1], bytes, num_bytes);
+        return buf;
+}
 /***********************************************************
  Same as smb_bytes_push_str(), but without the odd byte
 …
+}
+struct cli_setpathinfo_state {
+        uint16_t setup;
+        uint8_t *param;
+};
+static void cli_setpathinfo_done(struct tevent_req *subreq);
+struct tevent_req *cli_setpathinfo_send(TALLOC_CTX *mem_ctx,
+                                        struct tevent_context *ev,
+                                        struct cli_state *cli,
+                                        uint16_t level,
+                                        const char *path,
+                                        uint8_t *data,
+                                        size_t data_len)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_setpathinfo_state *state;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_setpathinfo_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        /* Setup setup word. */
+        SSVAL(&state->setup, 0, TRANSACT2_SETPATHINFO);
+        /* Setup param array. */
+        state->param = TALLOC_ZERO_ARRAY(state, uint8_t, 6);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        SSVAL(state->param, 0, level);
+        state->param = trans2_bytes_push_str(
+                state->param, cli_ucs2(cli), path, strlen(path)+1, NULL);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_trans_send(
+                state,                  /* mem ctx. */
+                ev,                     /* event ctx. */
+                cli,                    /* cli_state. */
+                SMBtrans2,              /* cmd. */
+                NULL,                   /* pipe name. */
+                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                &state->setup,          /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                state->param,           /* param. */
+                talloc_get_size(state->param),  /* num param. */
+,                      /* max returned param. */
+                data,                   /* data. */
+                data_len,               /* num data. */
+);                     /* max returned data. */
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_setpathinfo_done, req);
+        return req;
+}
+static void cli_setpathinfo_done(struct tevent_req *subreq)
+{
+        NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
+                                         NULL, 0, NULL, NULL, 0, NULL);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
+NTSTATUS cli_setpathinfo_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+NTSTATUS cli_setpathinfo(struct cli_state *cli,
+                         uint16_t level,
+                         const char *path,
+                         uint8_t *data,
+                         size_t data_len)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = tevent_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_setpathinfo_send(ev, ev, cli, level, path, data, data_len);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_setpathinfo_recv(req);
+ fail:
+        TALLOC_FREE(frame);
+        return status;
+}
 /****************************************************************************
  Hard/Symlink a file (UNIX extensions).
 …
 ****************************************************************************/
+struct link_state {
+        uint16_t setup;
+        uint8_t *param;
+struct cli_posix_link_internal_state {
         uint8_t *data;
 };
+static void cli_posix_link_internal_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct link_state *state = tevent_req_data(req, struct link_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+static void cli_posix_link_internal_done(struct tevent_req *subreq);
 static struct tevent_req *cli_posix_link_internal_send(TALLOC_CTX *mem_ctx,
                                         struct event_context *ev,
                                         struct cli_state *cli,
+                                        uint16_t level,
                                         const char *oldname,
+                                        const char *newname,
+                                        bool hardlink)
+                                        const char *newname)
+{
         struct tevent_req *req = NULL, *subreq = NULL;
+        struct link_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state, struct link_state);
+        struct cli_posix_link_internal_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_posix_link_internal_state);
         if (req == NULL) {
                 return NULL;
+        }
-        /* Setup setup word. */
-        SSVAL(&state->setup, 0, TRANSACT2_SETPATHINFO);
-        /* Setup param array. */
-        state->param = talloc_array(state, uint8_t, 6);
-        if (tevent_req_nomem(state->param, req)) {
-                return tevent_req_post(req, ev);
+        }
-        memset(state->param, '\0', 6);
-        SSVAL(state->param,0,hardlink ? SMB_SET_FILE_UNIX_HLINK : SMB_SET_FILE_UNIX_LINK);
-        state->param = trans2_bytes_push_str(state->param, cli_ucs2(cli), newname,
-                                   strlen(newname)+1, NULL);
-        if (tevent_req_nomem(state->param, req)) {
-                return tevent_req_post(req, ev);
+        }
 …
                 return tevent_req_post(req, ev);
+        }
+        state->data = trans2_bytes_push_str(state->data, cli_ucs2(cli), oldname,
+                                   strlen(oldname)+1, NULL);
+        subreq = cli_trans_send(state,                  /* mem ctx. */
+                                ev,                     /* event ctx. */
+                                cli,                    /* cli_state. */
+                                SMBtrans2,              /* cmd. */
+                                NULL,                   /* pipe name. */
+                                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                                &state->setup,          /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                                state->param,           /* param. */
+                                talloc_get_size(state->param),  /* num param. */
+,                      /* max returned param. */
+                                state->data,            /* data. */
+                                talloc_get_size(state->data),   /* num data. */
+);                     /* max returned data. */
+        state->data = trans2_bytes_push_str(
+                state->data, cli_ucs2(cli), oldname, strlen(oldname)+1, NULL);
+        subreq = cli_setpathinfo_send(
+                state, ev, cli, level, newname,
+                state->data, talloc_get_size(state->data));
         if (tevent_req_nomem(subreq, req)) {
                 return tevent_req_post(req, ev);
 …
         tevent_req_set_callback(subreq, cli_posix_link_internal_done, req);
         return req;
+}
+static void cli_posix_link_internal_done(struct tevent_req *subreq)
+{
+        NTSTATUS status = cli_setpathinfo_recv(subreq);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
 …
                                         const char *newname)
+{
         return cli_posix_link_internal_send(mem_ctx, ev, cli,
                         oldname, newname, false);
+        return cli_posix_link_internal_send(
+                mem_ctx, ev, cli, SMB_SET_FILE_UNIX_LINK, oldname, newname);
+}
 NTSTATUS cli_posix_symlink_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
 struct readlink_state {
-        uint16_t setup;
-        uint8_t *param;
         uint8_t *data;
         uint32_t num_data;
 };
+static void cli_posix_readlink_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct readlink_state *state = tevent_req_data(req, struct readlink_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
+                        &state->data, &state->num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (state->num_data == 0) {
+                tevent_req_nterror(req, NT_STATUS_DATA_ERROR);
+                return;
+        }
+        if (state->data[state->num_data-1] != '\0') {
+                tevent_req_nterror(req, NT_STATUS_DATA_ERROR);
+                return;
+        }
+        tevent_req_done(req);
+}
+static void cli_posix_readlink_done(struct tevent_req *subreq);
 struct tevent_req *cli_posix_readlink_send(TALLOC_CTX *mem_ctx,
 …
         uint32_t maxbytelen = (uint32_t)(cli_ucs2(cli) ? len*3 : len);
+        if (maxbytelen < len) {
+        req = tevent_req_create(mem_ctx, &state, struct readlink_state);
+        if (req == NULL) {
                 return NULL;
+        }
+        req = tevent_req_create(mem_ctx, &state, struct readlink_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        /* Setup setup word. */
+        SSVAL(&state->setup, 0, TRANSACT2_QPATHINFO);
+        /* Setup param array. */
+        state->param = talloc_array(state, uint8_t, 6);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        memset(state->param, '\0', 6);
+        SSVAL(state->param,0,SMB_QUERY_FILE_UNIX_LINK);
+        state->param = trans2_bytes_push_str(state->param, cli_ucs2(cli), fname,
+                                   strlen(fname)+1, NULL);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_trans_send(state,                  /* mem ctx. */
+                                ev,                     /* event ctx. */
+                                cli,                    /* cli_state. */
+                                SMBtrans2,              /* cmd. */
+                                NULL,                   /* pipe name. */
+                                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                                &state->setup,          /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                                state->param,           /* param. */
+                                talloc_get_size(state->param),  /* num param. */
+,                      /* max returned param. */
+                                NULL,                   /* data. */
+,                      /* num data. */
+                                maxbytelen);            /* max returned data. */
+        /*
+         * Len is in bytes, we need it in UCS2 units.
+         */
+        if ((2*len < len) || (maxbytelen < len)) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_qpathinfo_send(state, ev, cli, fname,
+                                    SMB_QUERY_FILE_UNIX_LINK, 1, maxbytelen);
         if (tevent_req_nomem(subreq, req)) {
                 return tevent_req_post(req, ev);
 …
         tevent_req_set_callback(subreq, cli_posix_readlink_done, req);
         return req;
+}
+static void cli_posix_readlink_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct readlink_state *state = tevent_req_data(
+                req, struct readlink_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        /*
+         * num_data is > 1, we've given 1 as minimum to cli_qpathinfo_send
+         */
+        if (state->data[state->num_data-1] != '\0') {
+                tevent_req_nterror(req, NT_STATUS_DATA_ERROR);
+                return;
+        }
+        tevent_req_done(req);
+}
 …
+        }
-        /* Len is in bytes, we need it in UCS2 units. */
-        if (2*len < len) {
-                status = NT_STATUS_INVALID_PARAMETER;
-                goto fail;
+        }
         req = cli_posix_readlink_send(frame,
                                 ev,
 …
                                         const char *newname)
+{
         return cli_posix_link_internal_send(mem_ctx, ev, cli,
                         oldname, newname, true);
+        return cli_posix_link_internal_send(
+                mem_ctx, ev, cli, SMB_SET_FILE_UNIX_HLINK, oldname, newname);
+}
 NTSTATUS cli_posix_hardlink_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
 struct getfacl_state {
-        uint16_t setup;
-        uint8_t *param;
         uint32_t num_data;
         uint8_t *data;
 };
+static void cli_posix_getfacl_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct getfacl_state *state = tevent_req_data(req, struct getfacl_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
+                        &state->data, &state->num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+static void cli_posix_getfacl_done(struct tevent_req *subreq);
 struct tevent_req *cli_posix_getfacl_send(TALLOC_CTX *mem_ctx,
 …
+{
         struct tevent_req *req = NULL, *subreq = NULL;
         struct link_state *state = NULL;
+        struct getfacl_state *state = NULL;
         req = tevent_req_create(mem_ctx, &state, struct getfacl_state);
 …
                 return NULL;
+        }
+        /* Setup setup word. */
+        SSVAL(&state->setup, 0, TRANSACT2_QPATHINFO);
+        /* Setup param array. */
+        state->param = talloc_array(state, uint8_t, 6);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        memset(state->param, '\0', 6);
+        SSVAL(state->param, 0, SMB_QUERY_POSIX_ACL);
+        state->param = trans2_bytes_push_str(state->param, cli_ucs2(cli), fname,
+                                   strlen(fname)+1, NULL);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_trans_send(state,                  /* mem ctx. */
+                                ev,                     /* event ctx. */
+                                cli,                    /* cli_state. */
+                                SMBtrans2,              /* cmd. */
+                                NULL,                   /* pipe name. */
+                                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                                &state->setup,          /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                                state->param,           /* param. */
+                                talloc_get_size(state->param),  /* num param. */
+,                      /* max returned param. */
+                                NULL,                   /* data. */
+,                      /* num data. */
+                                cli->max_xmit);         /* max returned data. */
+        subreq = cli_qpathinfo_send(state, ev, cli, fname, SMB_QUERY_POSIX_ACL,
+, cli->max_xmit);
         if (tevent_req_nomem(subreq, req)) {
                 return tevent_req_post(req, ev);
 …
         tevent_req_set_callback(subreq, cli_posix_getfacl_done, req);
         return req;
+}
+static void cli_posix_getfacl_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct getfacl_state *state = tevent_req_data(
+                req, struct getfacl_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
 …
 struct stat_state {
-        uint16_t setup;
-        uint8_t *param;
         uint32_t num_data;
         uint8_t *data;
 };
+static void cli_posix_stat_done(struct tevent_req *subreq);
+struct tevent_req *cli_posix_stat_send(TALLOC_CTX *mem_ctx,
+                                        struct event_context *ev,
+                                        struct cli_state *cli,
+                                        const char *fname)
+{
+        struct tevent_req *req = NULL, *subreq = NULL;
+        struct stat_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state, struct stat_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        subreq = cli_qpathinfo_send(state, ev, cli, fname,
+                                    SMB_QUERY_FILE_UNIX_BASIC, 100, 100);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_posix_stat_done, req);
+        return req;
+}
 static void cli_posix_stat_done(struct tevent_req *subreq)
 …
         NTSTATUS status;
         status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
                         &state->data, &state->num_data);
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
         tevent_req_done(req);
+}
-struct tevent_req *cli_posix_stat_send(TALLOC_CTX *mem_ctx,
-                                        struct event_context *ev,
-                                        struct cli_state *cli,
-                                        const char *fname)
+{
-        struct tevent_req *req = NULL, *subreq = NULL;
-        struct stat_state *state = NULL;
-        req = tevent_req_create(mem_ctx, &state, struct stat_state);
-        if (req == NULL) {
-                return NULL;
+        }
-        /* Setup setup word. */
-        SSVAL(&state->setup, 0, TRANSACT2_QPATHINFO);
-        /* Setup param array. */
-        state->param = talloc_array(state, uint8_t, 6);
-        if (tevent_req_nomem(state->param, req)) {
-                return tevent_req_post(req, ev);
+        }
-        memset(state->param, '\0', 6);
-        SSVAL(state->param, 0, SMB_QUERY_FILE_UNIX_BASIC);
-        state->param = trans2_bytes_push_str(state->param, cli_ucs2(cli), fname,
-                                   strlen(fname)+1, NULL);
-        if (tevent_req_nomem(state->param, req)) {
-                return tevent_req_post(req, ev);
+        }
-        subreq = cli_trans_send(state,                  /* mem ctx. */
-                                ev,                     /* event ctx. */
-                                cli,                    /* cli_state. */
-                                SMBtrans2,              /* cmd. */
-                                NULL,                   /* pipe name. */
-                                -1,                     /* fid. */
-,                      /* function. */
-,                      /* flags. */
-                                &state->setup,          /* setup. */
-,                      /* num setup uint16_t words. */
-,                      /* max returned setup. */
-                                state->param,           /* param. */
-                                talloc_get_size(state->param),  /* num param. */
-,                      /* max returned param. */
-                                NULL,                   /* data. */
-,                      /* num data. */
-);                    /* max returned data. */
-        if (tevent_req_nomem(subreq, req)) {
-                return tevent_req_post(req, ev);
+        }
-        tevent_req_set_callback(subreq, cli_posix_stat_done, req);
-        return req;
+}
 …
         if (tevent_req_is_nterror(req, &status)) {
                 return status;
+        }
-        if (state->num_data != 96) {
-                return NT_STATUS_DATA_ERROR;
+        }
 …
         sbuf->st_ex_ino = (SMB_INO_T)IVAL2_TO_SMB_BIG_UINT(state->data,76);      /* inode */
         sbuf->st_ex_mode |= wire_perms_to_unix(IVAL(state->data,84));     /* protection */
         sbuf->st_ex_nlink = IVAL(state->data,92);    /* number of hard links */
+        sbuf->st_ex_nlink = BIG_UINT(state->data,92); /* number of hard links */
         return NT_STATUS_OK;
 …
 ****************************************************************************/
+struct ch_state {
+        uint16_t setup;
+        uint8_t *param;
+        uint8_t *data;
+struct cli_posix_chown_chmod_internal_state {
+        uint8_t data[100];
 };
+static void cli_posix_chown_chmod_internal_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct ch_state *state = tevent_req_data(req, struct ch_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+static void cli_posix_chown_chmod_internal_done(struct tevent_req *subreq);
 static struct tevent_req *cli_posix_chown_chmod_internal_send(TALLOC_CTX *mem_ctx,
 …
+{
         struct tevent_req *req = NULL, *subreq = NULL;
+        struct ch_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state, struct ch_state);
+        struct cli_posix_chown_chmod_internal_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_posix_chown_chmod_internal_state);
         if (req == NULL) {
                 return NULL;
+        }
-        /* Setup setup word. */
-        SSVAL(&state->setup, 0, TRANSACT2_SETPATHINFO);
-        /* Setup param array. */
-        state->param = talloc_array(state, uint8_t, 6);
-        if (tevent_req_nomem(state->param, req)) {
-                return tevent_req_post(req, ev);
+        }
-        memset(state->param, '\0', 6);
-        SSVAL(state->param,0,SMB_SET_FILE_UNIX_BASIC);
-        state->param = trans2_bytes_push_str(state->param, cli_ucs2(cli), fname,
-                                   strlen(fname)+1, NULL);
-        if (tevent_req_nomem(state->param, req)) {
-                return tevent_req_post(req, ev);
+        }
-        /* Setup data array. */
-        state->data = talloc_array(state, uint8_t, 100);
-        if (tevent_req_nomem(state->data, req)) {
-                return tevent_req_post(req, ev);
+        }
         memset(state->data, 0xff, 40); /* Set all sizes/times to no change. */
         memset(&state->data[40], '\0', 60);
 …
         SIVAL(state->data,84,mode);
+        subreq = cli_trans_send(state,                  /* mem ctx. */
+                                ev,                     /* event ctx. */
+                                cli,                    /* cli_state. */
+                                SMBtrans2,              /* cmd. */
+                                NULL,                   /* pipe name. */
+                                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                                &state->setup,          /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                                state->param,           /* param. */
+                                talloc_get_size(state->param),  /* num param. */
+,                      /* max returned param. */
+                                state->data,            /* data. */
+                                talloc_get_size(state->data),   /* num data. */
+);                     /* max returned data. */
+        subreq = cli_setpathinfo_send(state, ev, cli, SMB_SET_FILE_UNIX_BASIC,
+                                      fname, state->data, sizeof(state->data));
         if (tevent_req_nomem(subreq, req)) {
                 return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_posix_chown_chmod_internal_done, req);
+        tevent_req_set_callback(subreq, cli_posix_chown_chmod_internal_done,
+                                req);
         return req;
+}
+static void cli_posix_chown_chmod_internal_done(struct tevent_req *subreq)
+{
+        NTSTATUS status = cli_setpathinfo_recv(subreq);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
 …
 NTSTATUS cli_posix_chmod_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
 NTSTATUS cli_posix_chown_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
+        }
         SSVAL(state->vwv+0, 0, aSYSTEM | aHIDDEN | aDIR);
+        SSVAL(state->vwv+0, 0, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY);
         bytes = talloc_array(state, uint8_t, 1);
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
+        }
         SSVAL(state->vwv+0, 0 ,aSYSTEM | aHIDDEN | aDIR);
+        SSVAL(state->vwv+0, 0 ,FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY);
         SSVAL(state->vwv+1, 0, rename_flag);
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
 static void cli_nt_delete_on_close_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct doc_state *state = tevent_req_data(req, struct doc_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+        NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
+                                         NULL, 0, NULL, NULL, 0, NULL);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
 …
 NTSTATUS cli_nt_delete_on_close_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
         uint32_t num_bytes;
         uint8_t *bytes;
+        uint8_t *inbuf;
         NTSTATUS status;
         status = cli_smb_recv(subreq, 3, &wct, &vwv, &num_bytes, &bytes);
         if (!NT_STATUS_IS_OK(status)) {
                 TALLOC_FREE(subreq);
                 tevent_req_nterror(req, status);
+        status = cli_smb_recv(subreq, state, &inbuf, 3, &wct, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         SSVAL(state->vwv + 2, 0, 0);  /* no additional info */
         SSVAL(state->vwv + 3, 0, accessmode);
         SSVAL(state->vwv + 4, 0, aSYSTEM | aHIDDEN);
+        SSVAL(state->vwv + 4, 0, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
         SSVAL(state->vwv + 5, 0, 0);
         SIVAL(state->vwv + 6, 0, 0);
 …
         status = cli_smb_req_send(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return tevent_req_post(req, ev);
+        }
 …
         uint8_t wct;
         uint16_t *vwv;
+        uint8_t *inbuf;
         NTSTATUS status;
         status = cli_smb_recv(subreq, 3, &wct, &vwv, NULL, NULL);
         if (!NT_STATUS_IS_OK(status)) {
                 TALLOC_FREE(subreq);
                 tevent_req_nterror(req, status);
+        status = cli_smb_recv(subreq, state, &inbuf, 3, &wct, &vwv, NULL,
+                              NULL);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         status = cli_smb_req_send(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return tevent_req_post(req, ev);
+        }
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
 static void cli_ftruncate_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct ftrunc_state *state = tevent_req_data(req, struct ftrunc_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+        NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
+                                         NULL, 0, NULL, NULL, 0, NULL);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
 …
 NTSTATUS cli_ftruncate_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
                       int timeout, unsigned char locktype)
+{
+        char *p;
+        int saved_timeout = cli->timeout;
+        memset(cli->outbuf,'\0',smb_size);
+        memset(cli->inbuf,'\0', smb_size);
+        cli_set_message(cli->outbuf,8,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBlockingX);
+        SSVAL(cli->outbuf,smb_tid,cli->cnum);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,fnum);
+        SCVAL(cli->outbuf,smb_vwv3,locktype);
+        SIVALS(cli->outbuf, smb_vwv4, timeout);
+        SSVAL(cli->outbuf,smb_vwv6,0);
+        SSVAL(cli->outbuf,smb_vwv7,1);
+        p = smb_buf(cli->outbuf);
+        SSVAL(p, 0, cli->pid);
+        SIVAL(p, 2, offset);
+        SIVAL(p, 6, len);
+        p += 10;
+        cli_setup_bcc(cli, p);
+        cli_send_smb(cli);
+        uint16_t vwv[8];
+        uint8_t bytes[10];
+        NTSTATUS status;
+        int saved_timeout;
+        SCVAL(vwv + 0, 0, 0xff);
+        SCVAL(vwv + 0, 1, 0);
+        SSVAL(vwv + 1, 0, 0);
+        SSVAL(vwv + 2, 0, fnum);
+        SCVAL(vwv + 3, 0, locktype);
+        SCVAL(vwv + 3, 1, 0);
+        SIVALS(vwv + 4, 0, timeout);
+        SSVAL(vwv + 6, 0, 0);
+        SSVAL(vwv + 7, 0, 1);
+        SSVAL(bytes, 0, cli->pid);
+        SIVAL(bytes, 2, offset);
+        SIVAL(bytes, 6, len);
+        saved_timeout = cli->timeout;
         if (timeout != 0) {
+                cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 2*1000);
+        }
+        if (!cli_receive_smb(cli)) {
+                cli->timeout = saved_timeout;
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+                cli->timeout = (timeout == -1)
+                        ? 0x7FFFFFFF : (timeout + 2*1000);
+        }
+        status = cli_smb(talloc_tos(), cli, SMBlockingX, 0, 8, vwv,
+, bytes, NULL, 0, NULL, NULL, NULL, NULL);
         cli->timeout = saved_timeout;
         return cli_nt_error(cli);
+        return status;
+}
 …
 bool cli_lock(struct cli_state *cli, uint16_t fnum,
+              uint32_t offset, uint32_t len, int timeout, enum brl_type lock_type)
+{
+        char *p;
+        int saved_timeout = cli->timeout;
+        memset(cli->outbuf,'\0',smb_size);
+        memset(cli->inbuf,'\0', smb_size);
+        cli_set_message(cli->outbuf,8,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBlockingX);
+        SSVAL(cli->outbuf,smb_tid,cli->cnum);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,fnum);
+        SCVAL(cli->outbuf,smb_vwv3,(lock_type == READ_LOCK? 1 : 0));
+        SIVALS(cli->outbuf, smb_vwv4, timeout);
+        SSVAL(cli->outbuf,smb_vwv6,0);
+        SSVAL(cli->outbuf,smb_vwv7,1);
+        p = smb_buf(cli->outbuf);
+        SSVAL(p, 0, cli->pid);
+        SIVAL(p, 2, offset);
+        SIVAL(p, 6, len);
+        p += 10;
+        cli_setup_bcc(cli, p);
+        cli_send_smb(cli);
+        if (timeout != 0) {
+                cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout*2 + 5*1000);
+        }
+        if (!cli_receive_smb(cli)) {
+                cli->timeout = saved_timeout;
+                return False;
+        }
+        cli->timeout = saved_timeout;
+        if (cli_is_error(cli)) {
+                return False;
+        }
+        return True;
+                  uint32_t offset, uint32_t len, int timeout,
+                  enum brl_type lock_type)
+{
+        NTSTATUS status;
+        status = cli_locktype(cli, fnum, offset, len, timeout,
+                              (lock_type == READ_LOCK? 1 : 0));
+        cli_set_error(cli, status);
+        return NT_STATUS_IS_OK(status);
+}
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
 bool cli_lock64(struct cli_state *cli, uint16_t fnum,
+                uint64_t offset, uint64_t len, int timeout, enum brl_type lock_type)
+{
+        char *p;
+                uint64_t offset, uint64_t len, int timeout,
+                enum brl_type lock_type)
+{
+        uint16_t vwv[8];
+        uint8_t bytes[20];
         int saved_timeout = cli->timeout;
         int ltype;
+        NTSTATUS status;
         if (! (cli->capabilities & CAP_LARGE_FILES)) {
 …
         ltype |= LOCKING_ANDX_LARGE_FILES;
+        memset(cli->outbuf,'\0',smb_size);
+        memset(cli->inbuf,'\0', smb_size);
+        cli_set_message(cli->outbuf,8,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBlockingX);
+        SSVAL(cli->outbuf,smb_tid,cli->cnum);
+        cli_setup_packet(cli);
+        SCVAL(cli->outbuf,smb_vwv0,0xFF);
+        SSVAL(cli->outbuf,smb_vwv2,fnum);
+        SCVAL(cli->outbuf,smb_vwv3,ltype);
+        SIVALS(cli->outbuf, smb_vwv4, timeout);
+        SSVAL(cli->outbuf,smb_vwv6,0);
+        SSVAL(cli->outbuf,smb_vwv7,1);
+        p = smb_buf(cli->outbuf);
+        SIVAL(p, 0, cli->pid);
+        SOFF_T_R(p, 4, offset);
+        SOFF_T_R(p, 12, len);
+        p += 20;
+        cli_setup_bcc(cli, p);
+        cli_send_smb(cli);
+        SCVAL(vwv + 0, 0, 0xff);
+        SCVAL(vwv + 0, 1, 0);
+        SSVAL(vwv + 1, 0, 0);
+        SSVAL(vwv + 2, 0, fnum);
+        SCVAL(vwv + 3, 0, ltype);
+        SCVAL(vwv + 3, 1, 0);
+        SIVALS(vwv + 4, 0, timeout);
+        SSVAL(vwv + 6, 0, 0);
+        SSVAL(vwv + 7, 0, 1);
+        SIVAL(bytes, 0, cli->pid);
+        SOFF_T_R(bytes, 4, offset);
+        SOFF_T_R(bytes, 12, len);
+        saved_timeout = cli->timeout;
         if (timeout != 0) {
+                cli->timeout = (timeout == -1) ? 0x7FFFFFFF : (timeout + 5*1000);
+        }
+        if (!cli_receive_smb(cli)) {
+                cli->timeout = saved_timeout;
+                return False;
+        }
+                cli->timeout = (timeout == -1)
+                        ? 0x7FFFFFFF : (timeout + 2*1000);
+        }
+        status = cli_smb(talloc_tos(), cli, SMBlockingX, 0, 8, vwv,
+, bytes, NULL, 0, NULL, NULL, NULL, NULL);
         cli->timeout = saved_timeout;
+        if (cli_is_error(cli)) {
+                return False;
+        }
+        return True;
+        cli_set_error(cli, status);
+        return NT_STATUS_IS_OK(status);
+}
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
 static void cli_posix_unlock_internal_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                        subreq, struct tevent_req);
+        struct posix_lock_state *state = tevent_req_data(req, struct posix_lock_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+        NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
+                                         NULL, 0, NULL, NULL, 0, NULL);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
 …
 NTSTATUS cli_posix_lock_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
 NTSTATUS cli_posix_unlock_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
         uint8_t wct;
         uint16_t *vwv = NULL;
+        uint8_t *inbuf;
         NTSTATUS status;
+        status = cli_smb_recv(subreq, 11, &wct, &vwv, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        status = cli_smb_recv(subreq, state, &inbuf, 11, &wct, &vwv,
+                              NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         state->write_time = make_unix_date2(vwv+4, state->zone_offset);
-        TALLOC_FREE(subreq);
         tevent_req_done(req);
+}
 …
         uint8_t wct;
         uint16_t *vwv = NULL;
+        uint8_t *inbuf;
         NTSTATUS status;
+        status = cli_smb_recv(subreq, 4, &wct, &vwv, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        status = cli_smb_recv(subreq, state, &inbuf, 4, &wct, &vwv, NULL,
+                              NULL);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         state->write_time = make_unix_date3(vwv+1, state->zone_offset);
-        TALLOC_FREE(subreq);
         tevent_req_done(req);
+}
 …
         SSVAL(state->vwv+0, 0, fnum);
+        cli_put_dos_date2(cli, (char *)&state->vwv[1], 0, change_time);
+        cli_put_dos_date2(cli, (char *)&state->vwv[3], 0, access_time);
+        cli_put_dos_date2(cli, (char *)&state->vwv[5], 0, write_time);
+        push_dos_date2((uint8_t *)&state->vwv[1], 0, change_time,
+                       cli->serverzone);
+        push_dos_date2((uint8_t *)&state->vwv[3], 0, access_time,
+                       cli->serverzone);
+        push_dos_date2((uint8_t *)&state->vwv[5], 0, write_time,
+                       cli->serverzone);
         subreq = cli_smb_send(state, ev, cli, SMBsetattrE, additional_flags,
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         SSVAL(state->vwv+0, 0, attr);
         cli_put_dos_date3(cli, (char *)&state->vwv[1], 0, mtime);
+        push_dos_date3((uint8_t *)&state->vwv[1], 0, mtime, cli->serverzone);
         bytes = talloc_array(state, uint8_t, 1);
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         uint8_t wct;
         uint16_t *vwv = NULL;
+        uint8_t *inbuf;
         NTSTATUS status;
+        status = cli_smb_recv(subreq, 4, &wct, &vwv, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        status = cli_smb_recv(subreq, state, &inbuf, 4, &wct, &vwv, NULL,
+                              NULL);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         state->total = SVAL(vwv+0, 0);
         state->avail = SVAL(vwv+3, 0);
-        TALLOC_FREE(subreq);
         tevent_req_done(req);
+}
 …
         uint32_t num_bytes = 0;
         uint8_t *bytes = NULL;
+        status = cli_smb_recv(subreq, 1, &wcnt, &vwv, &num_bytes, &bytes);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(subreq);
+                tevent_req_nterror(req, status);
+        uint8_t *inbuf;
+        status = cli_smb_recv(subreq, state, &inbuf, 1, &wcnt, &vwv,
+                              &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
         state->fnum = SVAL(vwv+0, 0);
-        TALLOC_FREE(subreq);
         /* From W2K3, the result is just the ASCII name */
 …
 NTSTATUS cli_raw_ioctl(struct cli_state *cli, uint16_t fnum, uint32_t code, DATA_BLOB *blob)
+{
+        memset(cli->outbuf,'\0',smb_size);
+        memset(cli->inbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf, 3, 0, True);
+        SCVAL(cli->outbuf,smb_com,SMBioctl);
+        cli_setup_packet(cli);
+        SSVAL(cli->outbuf, smb_vwv0, fnum);
+        SSVAL(cli->outbuf, smb_vwv1, code>>16);
+        SSVAL(cli->outbuf, smb_vwv2, (code&0xFFFF));
+        cli_send_smb(cli);
+        if (!cli_receive_smb(cli)) {
+                return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
+        }
+        if (cli_is_error(cli)) {
+                return cli_nt_error(cli);
+        }
+        uint16_t vwv[3];
+        NTSTATUS status;
+        SSVAL(vwv+0, 0, fnum);
+        SSVAL(vwv+1, 0, code>>16);
+        SSVAL(vwv+2, 0, (code&0xFFFF));
+        status = cli_smb(talloc_tos(), cli, SMBioctl, 0, 3, vwv, 0, NULL,
+                         NULL, 0, NULL, NULL, NULL, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         *blob = data_blob_null;
         return NT_STATUS_OK;
+}
 …
 *********************************************************/
+static bool cli_set_ea(struct cli_state *cli, uint16_t setup, char *param, unsigned int param_len,
+                        const char *ea_name, const char *ea_val, size_t ea_len)
+{
+static NTSTATUS cli_set_ea(struct cli_state *cli, uint16_t setup_val,
+                           uint8_t *param, unsigned int param_len,
+                           const char *ea_name,
+                           const char *ea_val, size_t ea_len)
+{
+        uint16_t setup[1];
         unsigned int data_len = 0;
+        char *data = NULL;
+        char *rparam=NULL, *rdata=NULL;
+        uint8_t *data = NULL;
         char *p;
         size_t ea_namelen = strlen(ea_name);
+        NTSTATUS status;
+        SSVAL(setup, 0, setup_val);
         if (ea_namelen == 0 && ea_len == 0) {
                 data_len = 4;
                 data = (char *)SMB_MALLOC(data_len);
+                data = (uint8_t *)SMB_MALLOC(data_len);
                 if (!data) {
                         return False;
+                        return NT_STATUS_NO_MEMORY;
+                }
                 p = data;
+                p = (char *)data;
                 SIVAL(p,0,data_len);
         } else {
                 data_len = 4 + 4 + ea_namelen + 1 + ea_len;
                 data = (char *)SMB_MALLOC(data_len);
+                data = (uint8_t *)SMB_MALLOC(data_len);
                 if (!data) {
                         return False;
+                        return NT_STATUS_NO_MEMORY;
+                }
                 p = data;
+                p = (char *)data;
                 SIVAL(p,0,data_len);
                 p += 4;
 …
+        }
+        if (!cli_send_trans(cli, SMBtrans2,
+                        NULL,                        /* name */
+                        -1, 0,                          /* fid, flags */
+                        &setup, 1, 0,                   /* setup, length, max */
+                        param, param_len, 2,            /* param, length, max */
+                        data,  data_len, cli->max_xmit /* data, length, max */
+                        )) {
+                SAFE_FREE(data);
+                return False;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                        &rparam, &param_len,
+                        &rdata, &data_len)) {
+                        SAFE_FREE(data);
+                return false;
+        }
+        status = cli_trans(talloc_tos(), cli, SMBtrans2, NULL, -1, 0, 0,
+                           setup, 1, 0,
+                           param, param_len, 2,
+                           data,  data_len, cli->max_xmit,
+                           NULL,
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL, /* rparam */
+                           NULL, 0, NULL); /* rdata */
         SAFE_FREE(data);
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return True;
+        return status;
+}
 …
 *********************************************************/
+bool cli_set_ea_path(struct cli_state *cli, const char *path, const char *ea_name, const char *ea_val, size_t ea_len)
+{
+        uint16_t setup = TRANSACT2_SETPATHINFO;
+NTSTATUS cli_set_ea_path(struct cli_state *cli, const char *path,
+                         const char *ea_name, const char *ea_val,
+                         size_t ea_len)
+{
         unsigned int param_len = 0;
         char *param;
+        uint8_t *param;
         size_t srclen = 2*(strlen(path)+1);
         char *p;
         bool ret;
         param = SMB_MALLOC_ARRAY(char, 6+srclen+2);
+        NTSTATUS status;
+        param = SMB_MALLOC_ARRAY(uint8_t, 6+srclen+2);
         if (!param) {
                 return false;
+                return NT_STATUS_NO_MEMORY;
+        }
         memset(param, '\0', 6);
         SSVAL(param,0,SMB_INFO_SET_EA);
         p = &param[6];
+        p = (char *)(&param[6]);
         p += clistr_push(cli, p, path, srclen, STR_TERMINATE);
         param_len = PTR_DIFF(p, param);
+        ret = cli_set_ea(cli, setup, param, param_len, ea_name, ea_val, ea_len);
+        status = cli_set_ea(cli, TRANSACT2_SETPATHINFO, param, param_len,
+                            ea_name, ea_val, ea_len);
         SAFE_FREE(param);
         return ret;
+        return status;
+}
 …
 *********************************************************/
+bool cli_set_ea_fnum(struct cli_state *cli, uint16_t fnum, const char *ea_name, const char *ea_val, size_t ea_len)
+{
+        char param[6];
+        uint16_t setup = TRANSACT2_SETFILEINFO;
+NTSTATUS cli_set_ea_fnum(struct cli_state *cli, uint16_t fnum,
+                         const char *ea_name, const char *ea_val,
+                         size_t ea_len)
+{
+        uint8_t param[6];
         memset(param, 0, 6);
 …
         SSVAL(param,2,SMB_INFO_SET_EA);
+        return cli_set_ea(cli, setup, param, 6, ea_name, ea_val, ea_len);
+        return cli_set_ea(cli, TRANSACT2_SETFILEINFO, param, 6,
+                          ea_name, ea_val, ea_len);
+}
 …
 *********************************************************/
+static bool cli_get_ea_list(struct cli_state *cli,
+                uint16_t setup, char *param, unsigned int param_len,
+                TALLOC_CTX *ctx,
+                size_t *pnum_eas,
+                struct ea_struct **pea_list)
+{
+        unsigned int data_len = 0;
+        unsigned int rparam_len, rdata_len;
+        char *rparam=NULL, *rdata=NULL;
+        char *p;
+static bool parse_ea_blob(TALLOC_CTX *ctx, const uint8_t *rdata,
+                          size_t rdata_len,
+                          size_t *pnum_eas, struct ea_struct **pea_list)
+{
+        struct ea_struct *ea_list = NULL;
+        size_t num_eas;
         size_t ea_size;
+        size_t num_eas;
+        bool ret = False;
+        struct ea_struct *ea_list;
+        *pnum_eas = 0;
+        if (pea_list) {
+                *pea_list = NULL;
+        }
+        if (!cli_send_trans(cli, SMBtrans2,
+                        NULL,           /* Name */
+                        -1, 0,          /* fid, flags */
+                        &setup, 1, 0,   /* setup, length, max */
+                        param, param_len, 10, /* param, length, max */
+                        NULL, data_len, cli->max_xmit /* data, length, max */
+                                )) {
+                return False;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                        &rparam, &rparam_len,
+                        &rdata, &rdata_len)) {
+                return False;
+        }
+        if (!rdata || rdata_len < 4) {
+                goto out;
+        const uint8_t *p;
+        if (rdata_len < 4) {
+                return false;
+        }
         ea_size = (size_t)IVAL(rdata,0);
         if (ea_size > rdata_len) {
                 goto out;
+                return false;
+        }
         if (ea_size == 0) {
                 /* No EA's present. */
+                ret = True;
+                goto out;
+                *pnum_eas = 0;
+                *pea_list = NULL;
+                return true;
+        }
 …
                 unsigned int ea_valuelen = SVAL(p,2);
                 if (ea_namelen == 0) {
                         goto out;
+                        return false;
+                }
                 if (4 + ea_namelen + 1 + ea_valuelen > ea_size) {
                         goto out;
+                        return false;
+                }
                 ea_size -= 4 + ea_namelen + 1 + ea_valuelen;
 …
         if (num_eas == 0) {
+                ret = True;
+                goto out;
+                *pnum_eas = 0;
+                *pea_list = NULL;
+                return true;
+        }
 …
         if (!pea_list) {
                 /* Caller only wants number of EA's. */
+                ret = True;
+                goto out;
+                return true;
+        }
         ea_list = TALLOC_ARRAY(ctx, struct ea_struct, num_eas);
         if (!ea_list) {
                 goto out;
+                return false;
+        }
 …
                 unix_ea_name[0] = '\0';
                 pull_ascii_fstring(unix_ea_name, p + 4);
+                ea->name = talloc_strdup(ctx, unix_ea_name);
+                ea->name = talloc_strdup(ea_list, unix_ea_name);
+                if (!ea->name) {
+                        goto fail;
+                }
                 /* Ensure the value is null terminated (in case it's a string). */
                 ea->value = data_blob_talloc(ctx, NULL, ea_valuelen + 1);
+                ea->value = data_blob_talloc(ea_list, NULL, ea_valuelen + 1);
                 if (!ea->value.data) {
                         goto out;
+                        goto fail;
+                }
                 if (ea_valuelen) {
 …
         *pea_list = ea_list;
+        ret = True;
+ out :
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return ret;
+        return true;
+fail:
+        TALLOC_FREE(ea_list);
+        return false;
+}
 …
 *********************************************************/
+bool cli_get_ea_list_path(struct cli_state *cli, const char *path,
+struct cli_get_ea_list_path_state {
+        uint32_t num_data;
+        uint8_t *data;
+};
+static void cli_get_ea_list_path_done(struct tevent_req *subreq);
+struct tevent_req *cli_get_ea_list_path_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             struct cli_state *cli,
+                                             const char *fname)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_get_ea_list_path_state *state;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_get_ea_list_path_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        subreq = cli_qpathinfo_send(state, ev, cli, fname,
+                                    SMB_INFO_QUERY_ALL_EAS, 4,
+                                    cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_get_ea_list_path_done, req);
+        return req;
+}
+static void cli_get_ea_list_path_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct cli_get_ea_list_path_state *state = tevent_req_data(
+                req, struct cli_get_ea_list_path_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_get_ea_list_path_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                                   size_t *pnum_eas, struct ea_struct **peas)
+{
+        struct cli_get_ea_list_path_state *state = tevent_req_data(
+                req, struct cli_get_ea_list_path_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (!parse_ea_blob(mem_ctx, state->data, state->num_data,
+                           pnum_eas, peas)) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_get_ea_list_path(struct cli_state *cli, const char *path,
                 TALLOC_CTX *ctx,
                 size_t *pnum_eas,
                 struct ea_struct **pea_list)
+{
+        uint16_t setup = TRANSACT2_QPATHINFO;
+        unsigned int param_len = 0;
+        char *param;
+        char *p;
+        size_t srclen = 2*(strlen(path)+1);
+        bool ret;
+        param = SMB_MALLOC_ARRAY(char, 6+srclen+2);
+        if (!param) {
+                return false;
+        }
+        p = param;
+        memset(p, 0, 6);
+        SSVAL(p, 0, SMB_INFO_QUERY_ALL_EAS);
+        p += 6;
+        p += clistr_push(cli, p, path, srclen, STR_TERMINATE);
+        param_len = PTR_DIFF(p, param);
+        ret = cli_get_ea_list(cli, setup, param, param_len, ctx, pnum_eas, pea_list);
+        SAFE_FREE(param);
+        return ret;
+}
+/*********************************************************
+ Get an extended attribute list from an fnum.
+*********************************************************/
+bool cli_get_ea_list_fnum(struct cli_state *cli, uint16_t fnum,
+                TALLOC_CTX *ctx,
+                size_t *pnum_eas,
+                struct ea_struct **pea_list)
+{
+        uint16_t setup = TRANSACT2_QFILEINFO;
+        char param[6];
+        memset(param, 0, 6);
+        SSVAL(param,0,fnum);
+        SSVAL(param,2,SMB_INFO_SET_EA);
+        return cli_get_ea_list(cli, setup, param, 6, ctx, pnum_eas, pea_list);
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev = NULL;
+        struct tevent_req *req = NULL;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_get_ea_list_path_send(frame, ev, cli, path);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_get_ea_list_path_recv(req, ctx, pnum_eas, pea_list);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
 #if defined(O_DIRECTORY)
         if (flags & O_DIRECTORY) {
-                ret &= ~(SMB_O_RDONLY|SMB_O_RDWR|SMB_O_WRONLY);
                 ret |= SMB_O_DIRECTORY;
+        }
 …
         uint32_t num_data;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, &data, &num_data);
+        status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
+                                NULL, 0, NULL, &data, 12, &num_data);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (num_data < 12) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         /* Setup data words. */
         if (is_dir) {
-                wire_flags &= ~(SMB_O_RDONLY|SMB_O_RDWR|SMB_O_WRONLY);
                 wire_flags |= SMB_O_DIRECTORY;
+        }
 …
 NTSTATUS cli_posix_mkdir_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
 ****************************************************************************/
+struct unlink_state {
+        uint16_t setup;
+struct cli_posix_unlink_internal_state {
         uint8_t data[2];
 };
+static void cli_posix_unlink_internal_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                                subreq, struct tevent_req);
+        struct unlink_state *state = tevent_req_data(req, struct unlink_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+static void cli_posix_unlink_internal_done(struct tevent_req *subreq);
 static struct tevent_req *cli_posix_unlink_internal_send(TALLOC_CTX *mem_ctx,
 …
                                         struct cli_state *cli,
                                         const char *fname,
                                         bool is_dir)
+                                        uint16_t level)
+{
         struct tevent_req *req = NULL, *subreq = NULL;
         struct unlink_state *state = NULL;
+        uint8_t *param = NULL;
         req = tevent_req_create(mem_ctx, &state, struct unlink_state);
+        struct cli_posix_unlink_internal_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_posix_unlink_internal_state);
         if (req == NULL) {
                 return NULL;
+        }
-        /* Setup setup word. */
-        SSVAL(&state->setup, 0, TRANSACT2_SETPATHINFO);
-        /* Setup param array. */
-        param = talloc_array(state, uint8_t, 6);
-        if (tevent_req_nomem(param, req)) {
-                return tevent_req_post(req, ev);
+        }
-        memset(param, '\0', 6);
-        SSVAL(param, 0, SMB_POSIX_PATH_UNLINK);
-        param = trans2_bytes_push_str(param, cli_ucs2(cli), fname,
-                                   strlen(fname)+1, NULL);
-        if (tevent_req_nomem(param, req)) {
-                return tevent_req_post(req, ev);
+        }
         /* Setup data word. */
+        SSVAL(state->data, 0, is_dir ? SMB_POSIX_UNLINK_DIRECTORY_TARGET :
+                        SMB_POSIX_UNLINK_FILE_TARGET);
+        subreq = cli_trans_send(state,                  /* mem ctx. */
+                                ev,                     /* event ctx. */
+                                cli,                    /* cli_state. */
+                                SMBtrans2,              /* cmd. */
+                                NULL,                   /* pipe name. */
+                                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                                &state->setup,          /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                                param,                  /* param. */
+                                talloc_get_size(param), /* num param. */
+,                      /* max returned param. */
+                                state->data,            /* data. */
+,                      /* num data. */
+);                     /* max returned data. */
+        SSVAL(state->data, 0, level);
+        subreq = cli_setpathinfo_send(state, ev, cli,
+                                      SMB_POSIX_PATH_UNLINK,
+                                      fname,
+                                      state->data, sizeof(state->data));
         if (tevent_req_nomem(subreq, req)) {
                 return tevent_req_post(req, ev);
 …
         tevent_req_set_callback(subreq, cli_posix_unlink_internal_done, req);
         return req;
+}
+static void cli_posix_unlink_internal_done(struct tevent_req *subreq)
+{
+        NTSTATUS status = cli_setpathinfo_recv(subreq);
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
 …
                                         const char *fname)
+{
+        return cli_posix_unlink_internal_send(mem_ctx, ev, cli, fname, false);
+        return cli_posix_unlink_internal_send(mem_ctx, ev, cli, fname,
+                                              SMB_POSIX_UNLINK_FILE_TARGET);
+}
 NTSTATUS cli_posix_unlink_recv(struct tevent_req *req)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
                                         const char *fname)
+{
+        return cli_posix_unlink_internal_send(mem_ctx, ev, cli, fname, true);
+        return cli_posix_unlink_internal_send(
+                mem_ctx, ev, cli, fname,
+                SMB_POSIX_UNLINK_DIRECTORY_TARGET);
+}
 NTSTATUS cli_posix_rmdir_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
+{
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
+}
 …
         uint8_t *params;
         uint32_t i, ofs, num_params;
+        status = cli_trans_recv(subreq, talloc_tos(), NULL, NULL,
+                                &params, &num_params, NULL, NULL);
+        uint16_t flags2;
+        status = cli_trans_recv(subreq, talloc_tos(), &flags2, NULL, 0, NULL,
+                                &params, 0, &num_params, NULL, 0, NULL);
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
+        if (tevent_req_nterror(req, status)) {
                 DEBUG(10, ("cli_trans_recv returned %s\n", nt_errstr(status)));
-                tevent_req_nterror(req, status);
                 return;
+        }
 …
                 state->changes[i].action = IVAL(params, ofs+4);
                 ret = clistr_pull_talloc(params, (char *)params, &name,
                                          params+ofs+12, len,
+                ret = clistr_pull_talloc(params, (char *)params, flags2,
+                                         &name, params+ofs+12, len,
                                          STR_TERMINATE|STR_UNICODE);
                 if (ret == -1) {
 …
         return NT_STATUS_OK;
+}
+struct cli_qpathinfo_state {
+        uint8_t *param;
+        uint8_t *data;
+        uint16_t setup[1];
+        uint32_t min_rdata;
+        uint8_t *rdata;
+        uint32_t num_rdata;
+};
+static void cli_qpathinfo_done(struct tevent_req *subreq);
+struct tevent_req *cli_qpathinfo_send(TALLOC_CTX *mem_ctx,
+                                      struct tevent_context *ev,
+                                      struct cli_state *cli, const char *fname,
+                                      uint16_t level, uint32_t min_rdata,
+                                      uint32_t max_rdata)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_qpathinfo_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->min_rdata = min_rdata;
+        SSVAL(state->setup, 0, TRANSACT2_QPATHINFO);
+        state->param = talloc_zero_array(state, uint8_t, 6);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        SSVAL(state->param, 0, level);
+        state->param = trans2_bytes_push_str(
+                state->param, cli_ucs2(cli), fname, strlen(fname)+1, NULL);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_trans_send(
+                state,                  /* mem ctx. */
+                ev,                     /* event ctx. */
+                cli,                    /* cli_state. */
+                SMBtrans2,              /* cmd. */
+                NULL,                   /* pipe name. */
+                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                state->setup,           /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                state->param,           /* param. */
+                talloc_get_size(state->param),  /* num param. */
+,                      /* max returned param. */
+                NULL,                   /* data. */
+,                      /* num data. */
+                max_rdata);             /* max returned data. */
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_qpathinfo_done, req);
+        return req;
+}
+static void cli_qpathinfo_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_qpathinfo_state *state = tevent_req_data(
+                req, struct cli_qpathinfo_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
+                                NULL, 0, NULL,
+                                &state->rdata, state->min_rdata,
+                                &state->num_rdata);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_qpathinfo_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                            uint8_t **rdata, uint32_t *num_rdata)
+{
+        struct cli_qpathinfo_state *state = tevent_req_data(
+                req, struct cli_qpathinfo_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (rdata != NULL) {
+                *rdata = talloc_move(mem_ctx, &state->rdata);
+        } else {
+                TALLOC_FREE(state->rdata);
+        }
+        if (num_rdata != NULL) {
+                *num_rdata = state->num_rdata;
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_qpathinfo(TALLOC_CTX *mem_ctx, struct cli_state *cli,
+                       const char *fname, uint16_t level, uint32_t min_rdata,
+                       uint32_t max_rdata,
+                       uint8_t **rdata, uint32_t *num_rdata)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_qpathinfo_send(frame, ev, cli, fname, level, min_rdata,
+                                 max_rdata);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_qpathinfo_recv(req, mem_ctx, rdata, num_rdata);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+struct cli_qfileinfo_state {
+        uint16_t setup[1];
+        uint8_t param[4];
+        uint8_t *data;
+        uint32_t min_rdata;
+        uint8_t *rdata;
+        uint32_t num_rdata;
+};
+static void cli_qfileinfo_done(struct tevent_req *subreq);
+struct tevent_req *cli_qfileinfo_send(TALLOC_CTX *mem_ctx,
+                                      struct tevent_context *ev,
+                                      struct cli_state *cli, uint16_t fnum,
+                                      uint16_t level, uint32_t min_rdata,
+                                      uint32_t max_rdata)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_qfileinfo_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct cli_qfileinfo_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->min_rdata = min_rdata;
+        SSVAL(state->param, 0, fnum);
+        SSVAL(state->param, 2, level);
+        SSVAL(state->setup, 0, TRANSACT2_QFILEINFO);
+        subreq = cli_trans_send(
+                state,                  /* mem ctx. */
+                ev,                     /* event ctx. */
+                cli,                    /* cli_state. */
+                SMBtrans2,              /* cmd. */
+                NULL,                   /* pipe name. */
+                -1,                     /* fid. */
+,                      /* function. */
+,                      /* flags. */
+                state->setup,           /* setup. */
+,                      /* num setup uint16_t words. */
+,                      /* max returned setup. */
+                state->param,           /* param. */
+                sizeof(state->param),   /* num param. */
+,                      /* max returned param. */
+                NULL,                   /* data. */
+,                      /* num data. */
+                max_rdata);             /* max returned data. */
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_qfileinfo_done, req);
+        return req;
+}
+static void cli_qfileinfo_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_qfileinfo_state *state = tevent_req_data(
+                req, struct cli_qfileinfo_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
+                                NULL, 0, NULL,
+                                &state->rdata, state->min_rdata,
+                                &state->num_rdata);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_qfileinfo_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                            uint8_t **rdata, uint32_t *num_rdata)
+{
+        struct cli_qfileinfo_state *state = tevent_req_data(
+                req, struct cli_qfileinfo_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (rdata != NULL) {
+                *rdata = talloc_move(mem_ctx, &state->rdata);
+        } else {
+                TALLOC_FREE(state->rdata);
+        }
+        if (num_rdata != NULL) {
+                *num_rdata = state->num_rdata;
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_qfileinfo(TALLOC_CTX *mem_ctx, struct cli_state *cli,
+                       uint16_t fnum, uint16_t level, uint32_t min_rdata,
+                       uint32_t max_rdata,
+                       uint8_t **rdata, uint32_t *num_rdata)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_qfileinfo_send(frame, ev, cli, fnum, level, min_rdata,
+                                 max_rdata);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_qfileinfo_recv(req, mem_ctx, rdata, num_rdata);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+struct cli_flush_state {
+        uint16_t vwv[1];
+};
+static void cli_flush_done(struct tevent_req *subreq);
+struct tevent_req *cli_flush_send(TALLOC_CTX *mem_ctx,
+                                  struct event_context *ev,
+                                  struct cli_state *cli,
+                                  uint16_t fnum)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_flush_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct cli_flush_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        SSVAL(state->vwv + 0, 0, fnum);
+        subreq = cli_smb_send(state, ev, cli, SMBflush, 0, 1, state->vwv,
+, NULL);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_flush_done, req);
+        return req;
+}
+static void cli_flush_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        NTSTATUS status;
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_flush_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+NTSTATUS cli_flush(TALLOC_CTX *mem_ctx, struct cli_state *cli, uint16_t fnum)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_flush_send(frame, ev, cli, fnum);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_flush_recv(req);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+struct cli_shadow_copy_data_state {
+        uint16_t setup[4];
+        uint8_t *data;
+        uint32_t num_data;
+        bool get_names;
+};
+static void cli_shadow_copy_data_done(struct tevent_req *subreq);
+struct tevent_req *cli_shadow_copy_data_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             struct cli_state *cli,
+                                             uint16_t fnum,
+                                             bool get_names)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_shadow_copy_data_state *state;
+        uint32_t ret_size;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_shadow_copy_data_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->get_names = get_names;
+        ret_size = get_names ? cli->max_xmit : 16;
+        SIVAL(state->setup + 0, 0, FSCTL_GET_SHADOW_COPY_DATA);
+        SSVAL(state->setup + 2, 0, fnum);
+        SCVAL(state->setup + 3, 0, 0); /* isFsctl */
+        SCVAL(state->setup + 3, 1, 0); /* compfilter, isFlags (WSSP) */
+        subreq = cli_trans_send(
+                state, ev, cli, SMBnttrans, NULL, 0, NT_TRANSACT_IOCTL, 0,
+                state->setup, ARRAY_SIZE(state->setup), 0,
+                NULL, 0, 0,
+                NULL, 0, ret_size);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_shadow_copy_data_done, req);
+        return req;
+}
+static void cli_shadow_copy_data_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_shadow_copy_data_state *state = tevent_req_data(
+                req, struct cli_shadow_copy_data_state);
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, state, NULL,
+                                NULL, 0, NULL, /* setup */
+                                NULL, 0, NULL, /* param */
+                                &state->data, 12, &state->num_data);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_shadow_copy_data_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                                   char ***pnames, int *pnum_names)
+{
+        struct cli_shadow_copy_data_state *state = tevent_req_data(
+                req, struct cli_shadow_copy_data_state);
+        char **names;
+        int i, num_names;
+        uint32_t dlength;
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        num_names = IVAL(state->data, 4);
+        dlength = IVAL(state->data, 8);
+        if (!state->get_names) {
+                *pnum_names = num_names;
+                return NT_STATUS_OK;
+        }
+        if (dlength+12 > state->num_data) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        names = talloc_array(mem_ctx, char *, num_names);
+        if (names == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        for (i=0; i<num_names; i++) {
+                bool ret;
+                uint8_t *src;
+                size_t converted_size;
+                src = state->data + 12 + i * 2 * sizeof(SHADOW_COPY_LABEL);
+                ret = convert_string_talloc(
+                        names, CH_UTF16LE, CH_UNIX,
+                        src, 2 * sizeof(SHADOW_COPY_LABEL),
+                        &names[i], &converted_size, True);
+                if (!ret) {
+                        TALLOC_FREE(names);
+                        return NT_STATUS_INVALID_NETWORK_RESPONSE;
+                }
+        }
+        *pnum_names = num_names;
+        *pnames = names;
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_shadow_copy_data(TALLOC_CTX *mem_ctx, struct cli_state *cli,
+                              uint16_t fnum, bool get_names,
+                              char ***pnames, int *pnum_names)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_shadow_copy_data_send(frame, ev, cli, fnum, get_names);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_shadow_copy_data_recv(req, mem_ctx, pnames, pnum_names);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}

vendor/current/source3/libsmb/clifsinfo.c

-              r414
+              r740
    Copyright (C) Stefan (metze) Metzmacher      2003
    Copyright (C) Jeremy Allison 2007
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "../libcli/auth/spnego.h"
+#include "../libcli/auth/ntlmssp.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "smb_crypt.h"
+#include "trans2.h"
 /****************************************************************************
 …
 struct cli_unix_extensions_version_state {
+        struct cli_state *cli;
         uint16_t setup[1];
         uint8_t param[2];
 …
                 return NULL;
+        }
+        state->cli = cli;
         SSVAL(state->setup, 0, TRANSACT2_QFSINFO);
         SSVAL(state->param, 0, SMB_QUERY_CIFS_UNIX_INFO);
 …
         NTSTATUS status;
         status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
                                 &data, &num_data);
+        status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
+                                NULL, 0, NULL, &data, 12, &num_data);
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
                 tevent_req_nterror(req, status);
-                return;
+        }
-        if (num_data < 12) {
-                tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
                 return;
+        }
 …
         *pcaplow = state->caplow;
         *pcaphigh = state->caphigh;
+        state->cli->server_posix_capabilities = *pcaplow;
         return NT_STATUS_OK;
+}
 …
         status = cli_unix_extensions_version_recv(req, pmajor, pminor, pcaplow,
                                                   pcaphigh);
-        if (NT_STATUS_IS_OK(status)) {
-                cli->posix_capabilities = *pcaplow;
+        }
  fail:
         TALLOC_FREE(frame);
 …
 ****************************************************************************/
+bool cli_set_unix_extensions_capabilities(struct cli_state *cli, uint16 major, uint16 minor,
+                                        uint32 caplow, uint32 caphigh)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[4];
+        char data[12];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        setup = TRANSACT2_SETFSINFO;
+        SSVAL(param,0,0);
+        SSVAL(param,2,SMB_SET_CIFS_UNIX_INFO);
+        SSVAL(data,0,major);
+        SSVAL(data,2,minor);
+        SIVAL(data,4,caplow);
+        SIVAL(data,8,caphigh);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 4, 0,
+                    data, 12, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_get_fs_attr_info(struct cli_state *cli, uint32 *fs_attr)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        if (!cli||!fs_attr)
+                smb_panic("cli_get_fs_attr_info() called with NULL Pionter!");
+        setup = TRANSACT2_QFSINFO;
+        SSVAL(param,0,SMB_QUERY_FS_ATTRIBUTE_INFO);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if (rdata_count < 12) {
+                goto cleanup;
+        }
+        *fs_attr = IVAL(rdata,0);
+struct cli_set_unix_extensions_capabilities_state {
+        struct cli_state *cli;
+        uint16_t setup[1];
+        uint8_t param[4];
+        uint8_t data[12];
+};
+static void cli_set_unix_extensions_capabilities_done(
+        struct tevent_req *subreq);
+struct tevent_req *cli_set_unix_extensions_capabilities_send(
+        TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct cli_state *cli,
+        uint16_t major, uint16_t minor, uint32_t caplow, uint32_t caphigh)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_set_unix_extensions_capabilities_state *state;
+        req = tevent_req_create(
+                mem_ctx, &state,
+                struct cli_set_unix_extensions_capabilities_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        SSVAL(state->setup+0, 0, TRANSACT2_SETFSINFO);
+        SSVAL(state->param, 0, 0);
+        SSVAL(state->param, 2, SMB_SET_CIFS_UNIX_INFO);
+        SSVAL(state->data, 0, major);
+        SSVAL(state->data, 2, minor);
+        SIVAL(state->data, 4, caplow);
+        SIVAL(state->data, 8, caphigh);
+        subreq = cli_trans_send(state, ev, cli, SMBtrans2,
+                                NULL, 0, 0, 0,
+                                state->setup, 1, 0,
+                                state->param, 4, 0,
+                                state->data, 12, 560);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(
+                subreq, cli_set_unix_extensions_capabilities_done, req);
+        return req;
+}
+static void cli_set_unix_extensions_capabilities_done(
+        struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_set_unix_extensions_capabilities_state *state = tevent_req_data(
+                req, struct cli_set_unix_extensions_capabilities_state);
+        NTSTATUS status = cli_trans_recv(subreq, NULL, NULL, NULL, 0, NULL,
+                                         NULL, 0, NULL, NULL, 0, NULL);
+        if (NT_STATUS_IS_OK(status)) {
+                state->cli->requested_posix_capabilities = IVAL(state->data, 4);
+        }
+        tevent_req_simple_finish_ntstatus(subreq, status);
+}
+NTSTATUS cli_set_unix_extensions_capabilities_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+}
+NTSTATUS cli_set_unix_extensions_capabilities(struct cli_state *cli,
+                                              uint16 major, uint16 minor,
+                                              uint32 caplow, uint32 caphigh)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ev = tevent_context_init(talloc_tos());
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_set_unix_extensions_capabilities_send(
+                ev, ev, cli, major, minor, caplow, caphigh);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_set_unix_extensions_capabilities_recv(req);
+fail:
+        TALLOC_FREE(ev);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+struct cli_get_fs_attr_info_state {
+        uint16_t setup[1];
+        uint8_t param[2];
+        uint32_t fs_attr;
+};
+static void cli_get_fs_attr_info_done(struct tevent_req *subreq);
+struct tevent_req *cli_get_fs_attr_info_send(TALLOC_CTX *mem_ctx,
+                                             struct tevent_context *ev,
+                                             struct cli_state *cli)
+{
+        struct tevent_req *subreq, *req;
+        struct cli_get_fs_attr_info_state *state;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_get_fs_attr_info_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        SSVAL(state->setup+0, 0, TRANSACT2_QFSINFO);
+        SSVAL(state->param+0, 0, SMB_QUERY_FS_ATTRIBUTE_INFO);
+        subreq = cli_trans_send(state, ev, cli, SMBtrans2,
+                                NULL, 0, 0, 0,
+                                state->setup, 1, 0,
+                                state->param, 2, 0,
+                                NULL, 0, 560);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_get_fs_attr_info_done, req);
+        return req;
+}
+static void cli_get_fs_attr_info_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_get_fs_attr_info_state *state = tevent_req_data(
+                req, struct cli_get_fs_attr_info_state);
+        uint8_t *data;
+        uint32_t num_data;
+        NTSTATUS status;
+        status = cli_trans_recv(subreq, talloc_tos(), NULL, NULL, 0, NULL,
+                                NULL, 0, NULL, &data, 12, &num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        state->fs_attr = IVAL(data, 0);
+        TALLOC_FREE(data);
+        tevent_req_done(req);
+}
+NTSTATUS cli_get_fs_attr_info_recv(struct tevent_req *req, uint32_t *fs_attr)
+{
+        struct cli_get_fs_attr_info_state *state = tevent_req_data(
+                req, struct cli_get_fs_attr_info_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        *fs_attr = state->fs_attr;
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_get_fs_attr_info(struct cli_state *cli, uint32_t *fs_attr)
+{
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ev = tevent_context_init(talloc_tos());
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_get_fs_attr_info_send(ev, ev, cli);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_get_fs_attr_info_recv(req, fs_attr);
+fail:
+        TALLOC_FREE(ev);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+NTSTATUS cli_get_fs_volume_info(struct cli_state *cli, fstring volume_name,
+                                uint32 *pserial_number, time_t *pdate)
+{
+        NTSTATUS status;
+        uint16 setup[1];
+        uint8_t param[2];
+        uint8_t *rdata;
+        uint32_t rdata_count;
+        unsigned int nlen;
+        SSVAL(setup, 0, TRANSACT2_QFSINFO);
+        SSVAL(param,0,SMB_QUERY_FS_VOLUME_INFO);
+        status = cli_trans(talloc_tos(), cli, SMBtrans2,
+                           NULL, 0, 0, 0,
+                           setup, 1, 0,
+                           param, 2, 0,
+                           NULL, 0, 560,
+                           NULL,
+                           NULL, 0, NULL,
+                           NULL, 0, NULL,
+                           &rdata, 10, &rdata_count);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (pdate) {
+                struct timespec ts;
+                ts = interpret_long_date((char *)rdata);
+                *pdate = ts.tv_sec;
+        }
+        if (pserial_number) {
+                *pserial_number = IVAL(rdata,8);
+        }
+        nlen = IVAL(rdata,12);
+        clistr_pull(cli->inbuf, volume_name, rdata + 18, sizeof(fstring),
+                    nlen, STR_UNICODE);
         /* todo: but not yet needed
 …
          */
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_get_fs_volume_info_old(struct cli_state *cli, fstring volume_name, uint32 *pserial_number)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        unsigned char nlen;
+        setup = TRANSACT2_QFSINFO;
+        SSVAL(param,0,SMB_INFO_VOLUME);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if (rdata_count < 5) {
+                goto cleanup;
+        }
+        if (pserial_number) {
+                *pserial_number = IVAL(rdata,0);
+        }
+        nlen = CVAL(rdata,l2_vol_cch);
+        clistr_pull(cli->inbuf, volume_name, rdata + l2_vol_szVolLabel,
+                    sizeof(fstring), nlen, STR_NOALIGN);
+        /* todo: but not yet needed
+         *       return the other stuff
+         */
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_get_fs_volume_info(struct cli_state *cli, fstring volume_name, uint32 *pserial_number, time_t *pdate)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        unsigned int nlen;
+        setup = TRANSACT2_QFSINFO;
+        SSVAL(param,0,SMB_QUERY_FS_VOLUME_INFO);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if (rdata_count < 19) {
+                goto cleanup;
+        }
+        if (pdate) {
+                struct timespec ts;
+                ts = interpret_long_date(rdata);
+                *pdate = ts.tv_sec;
+        }
+        if (pserial_number) {
+                *pserial_number = IVAL(rdata,8);
+        }
+        nlen = IVAL(rdata,12);
+        clistr_pull(cli->inbuf, volume_name, rdata + 18, sizeof(fstring),
+                    nlen, STR_UNICODE);
+        /* todo: but not yet needed
+         *       return the other stuff
+         */
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_get_fs_full_size_info(struct cli_state *cli,
+                               uint64_t *total_allocation_units,
+                               uint64_t *caller_allocation_units,
+                               uint64_t *actual_allocation_units,
+                               uint64_t *sectors_per_allocation_unit,
+                               uint64_t *bytes_per_sector)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        setup = TRANSACT2_QFSINFO;
+        SSVAL(param,0,SMB_FS_FULL_SIZE_INFORMATION);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if (rdata_count != 32) {
+                goto cleanup;
+        TALLOC_FREE(rdata);
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_get_fs_full_size_info(struct cli_state *cli,
+                                   uint64_t *total_allocation_units,
+                                   uint64_t *caller_allocation_units,
+                                   uint64_t *actual_allocation_units,
+                                   uint64_t *sectors_per_allocation_unit,
+                                   uint64_t *bytes_per_sector)
+{
+        uint16 setup[1];
+        uint8_t param[2];
+        uint8_t *rdata = NULL;
+        uint32_t rdata_count;
+        NTSTATUS status;
+        SSVAL(setup, 0, TRANSACT2_QFSINFO);
+        SSVAL(param, 0, SMB_FS_FULL_SIZE_INFORMATION);
+        status = cli_trans(talloc_tos(), cli, SMBtrans2,
+                           NULL, 0, 0, 0,
+                           setup, 1, 0, /* setup */
+                           param, 2, 0,  /* param */
+                           NULL, 0, 560, /* data */
+                           NULL,
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL, /* rparam */
+                           &rdata, 32, &rdata_count);  /* rdata */
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
 …
+        }
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_get_posix_fs_info(struct cli_state *cli,
+                           uint32 *optimal_transfer_size,
+                           uint32 *block_size,
+                           uint64_t *total_blocks,
+                           uint64_t *blocks_available,
+                           uint64_t *user_blocks_available,
+                           uint64_t *total_file_nodes,
+                           uint64_t *free_file_nodes,
+                           uint64_t *fs_identifier)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[2];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        setup = TRANSACT2_QFSINFO;
+fail:
+        TALLOC_FREE(rdata);
+        return status;
+}
+NTSTATUS cli_get_posix_fs_info(struct cli_state *cli,
+                               uint32 *optimal_transfer_size,
+                               uint32 *block_size,
+                               uint64_t *total_blocks,
+                               uint64_t *blocks_available,
+                               uint64_t *user_blocks_available,
+                               uint64_t *total_file_nodes,
+                               uint64_t *free_file_nodes,
+                               uint64_t *fs_identifier)
+{
+        uint16 setup[1];
+        uint8_t param[2];
+        uint8_t *rdata = NULL;
+        uint32_t rdata_count;
+        NTSTATUS status;
+        SSVAL(setup, 0, TRANSACT2_QFSINFO);
         SSVAL(param,0,SMB_QUERY_POSIX_FS_INFO);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if (rdata_count != 56) {
+                goto cleanup;
+        status = cli_trans(talloc_tos(), cli, SMBtrans2, NULL, 0, 0, 0,
+                           setup, 1, 0,
+                           param, 2, 0,
+                           NULL, 0, 560,
+                           NULL,
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL, /* rparam */
+                           &rdata, 56, &rdata_count);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
 …
                 *fs_identifier = BIG_UINT(rdata,48);
+        }
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+        return NT_STATUS_OK;
+}
 …
 static NTSTATUS enc_blob_send_receive(struct cli_state *cli, DATA_BLOB *in, DATA_BLOB *out, DATA_BLOB *param_out)
+{
+        uint16 setup;
+        char param[4];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        NTSTATUS status = NT_STATUS_OK;
+        setup = TRANSACT2_SETFSINFO;
+        uint16_t setup[1];
+        uint8_t param[4];
+        uint8_t *rparam=NULL, *rdata=NULL;
+        uint32_t num_rparam, num_rdata;
+        NTSTATUS status;
+        SSVAL(setup+0, 0, TRANSACT2_SETFSINFO);
         SSVAL(param,0,0);
         SSVAL(param,2,SMB_REQUEST_TRANSPORT_ENCRYPTION);
+        if (!cli_send_trans(cli, SMBtrans2,
+                                NULL,
+, 0,
+                                &setup, 1, 0,
+                                param, 4, 0,
+                                (char *)in->data, in->length, CLI_BUFFER_SIZE)) {
+                status = cli_nt_error(cli);
+                goto out;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                                &rparam, &rparam_count,
+                                &rdata, &rdata_count)) {
+                status = cli_nt_error(cli);
+                goto out;
+        }
+        if (cli_is_error(cli)) {
+                status = cli_nt_error(cli);
+                if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                        goto out;
+                }
+        }
+        *out = data_blob(rdata, rdata_count);
+        *param_out = data_blob(rparam, rparam_count);
+  out:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        status = cli_trans(talloc_tos(), cli, SMBtrans2, NULL, 0, 0, 0,
+                           setup, 1, 0,
+                           param, 4, 2,
+                           (uint8_t *)in->data, in->length, CLI_BUFFER_SIZE,
+                           NULL,          /* recv_flags */
+                           NULL, 0, NULL, /* rsetup */
+                           &rparam, 0, &num_rparam,
+                           &rdata, 0, &num_rdata);
+        if (!NT_STATUS_IS_OK(status) &&
+            !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                return status;
+        }
+        *out = data_blob(rdata, num_rdata);
+        *param_out = data_blob(rparam, num_rparam);
+        TALLOC_FREE(rparam);
+        TALLOC_FREE(rdata);
         return status;
+}
 …
                 return NT_STATUS_NO_MEMORY;
+        }
+        status = ntlmssp_client_start(&es->s.ntlmssp_state);
+        status = ntlmssp_client_start(NULL,
+                                      global_myname(),
+                                      lp_workgroup(),
+                                      lp_client_ntlmv2_auth(),
+                                      &es->s.ntlmssp_state);
         if (!NT_STATUS_IS_OK(status)) {
                 goto fail;
 …
 ******************************************************************************/
+static NTSTATUS make_cli_gss_blob(struct smb_trans_enc_state *es,
+static NTSTATUS make_cli_gss_blob(TALLOC_CTX *ctx,
+                                struct smb_trans_enc_state *es,
                                 const char *service,
                                 const char *host,
 …
         } else {
                 /* Remove the SPNEGO wrapper */
                 if (!spnego_parse_auth_response(spnego_blob_in, status_in, OID_KERBEROS5, &blob_in)) {
+                if (!spnego_parse_auth_response(ctx, spnego_blob_in, status_in, OID_KERBEROS5, &blob_in)) {
                         status = NT_STATUS_UNSUCCESSFUL;
                         goto fail;
 …
+        }
         blob_out = data_blob(tok_out.value, tok_out.length);
+        blob_out = data_blob_talloc(ctx, tok_out.value, tok_out.length);
         /* Wrap in an SPNEGO wrapper */
         *p_blob_out = gen_negTokenTarg(krb_mechs, blob_out);
+        *p_blob_out = spnego_gen_negTokenInit(ctx, krb_mechs, &blob_out, NULL);
   fail:
 …
         servicename = "cifs";
         status = make_cli_gss_blob(es, servicename, fqdn, NT_STATUS_OK, blob_recv, &blob_send);
+        status = make_cli_gss_blob(talloc_tos(), es, servicename, fqdn, NT_STATUS_OK, blob_recv, &blob_send);
         if (!NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED)) {
                 servicename = "host";
                 status = make_cli_gss_blob(es, servicename, fqdn, NT_STATUS_OK, blob_recv, &blob_send);
+                status = make_cli_gss_blob(talloc_tos(), es, servicename, fqdn, NT_STATUS_OK, blob_recv, &blob_send);
                 if (!NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED)) {
                         goto fail;
 …
+                }
                 data_blob_free(&blob_send);
                 status = make_cli_gss_blob(es, servicename, fqdn, status, blob_recv, &blob_send);
+                status = make_cli_gss_blob(talloc_tos(), es, servicename, fqdn, status, blob_recv, &blob_send);
         } while (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED));
         data_blob_free(&blob_recv);

vendor/current/source3/libsmb/clikrb5.c

-              r594
+              r740
 #include "includes.h"
 #include "smb_krb5.h"
+#include "authdata.h"
+#include "../librpc/gen_ndr/krb5pac.h"
+#include "../lib/util/asn1.h"
+#include "libsmb/nmblib.h"
+#ifndef KRB5_AUTHDATA_WIN2K_PAC
+#define KRB5_AUTHDATA_WIN2K_PAC 128
+#endif
+#ifndef KRB5_AUTHDATA_IF_RELEVANT
+#define KRB5_AUTHDATA_IF_RELEVANT 1
+#endif
 #ifdef HAVE_KRB5
 …
         asn1_start_tag(data, ASN1_CONTEXT(2));
         asn1_read_OctetString(data, talloc_autofree_context(), &edata_contents);
+        asn1_read_OctetString(data, talloc_tos(), &edata_contents);
         asn1_end_tag(data);
         asn1_end_tag(data);
 …
         asn1_end_tag(data);
         asn1_start_tag(data, ASN1_CONTEXT(1));
         asn1_read_OctetString(data, talloc_autofree_context(), &pac_contents);
+        asn1_read_OctetString(data, talloc_tos(), &pac_contents);
         asn1_end_tag(data);
         asn1_end_tag(data);
 …
 /*
   get a kerberos5 ticket for the given service
+  get a kerberos5 ticket for the given service
 */
+int cli_krb5_get_ticket(const char *principal, time_t time_offset,
+                        DATA_BLOB *ticket, DATA_BLOB *session_key_krb5,
+                        uint32 extra_ap_opts, const char *ccname,
+int cli_krb5_get_ticket(TALLOC_CTX *mem_ctx,
+                        const char *principal, time_t time_offset,
+                        DATA_BLOB *ticket, DATA_BLOB *session_key_krb5,
+                        uint32_t extra_ap_opts, const char *ccname,
                         time_t *tgs_expire,
                         const char *impersonate_princ_s)
 …
         krb5_auth_context auth_context = NULL;
         krb5_enctype enc_types[] = {
-#ifdef ENCTYPE_ARCFOUR_HMAC
                 ENCTYPE_ARCFOUR_HMAC,
+#endif
+                ENCTYPE_DES_CBC_MD5,
+                ENCTYPE_DES_CBC_CRC,
+                ENCTYPE_DES_CBC_MD5,
+                ENCTYPE_DES_CBC_CRC,
                 ENCTYPE_NULL};
 …
         retval = krb5_init_context(&context);
         if (retval) {
                 DEBUG(1,("cli_krb5_get_ticket: krb5_init_context failed (%s)\n",
+                DEBUG(1, ("krb5_init_context failed (%s)\n",
                          error_message(retval)));
                 goto failed;
 …
         if ((retval = krb5_cc_resolve(context, ccname ?
                         ccname : krb5_cc_default_name(context), &ccdef))) {
                 DEBUG(1,("cli_krb5_get_ticket: krb5_cc_default failed (%s)\n",
+                DEBUG(1, ("krb5_cc_default failed (%s)\n",
                          error_message(retval)));
                 goto failed;
 …
         if ((retval = krb5_set_default_tgs_ktypes(context, enc_types))) {
                 DEBUG(1,("cli_krb5_get_ticket: krb5_set_default_tgs_ktypes failed (%s)\n",
+                DEBUG(1, ("krb5_set_default_tgs_ktypes failed (%s)\n",
                          error_message(retval)));
                 goto failed;
+        }
+        if ((retval = ads_krb5_mk_req(context,
+                                        &auth_context,
+                                        AP_OPTS_USE_SUBKEY | (krb5_flags)extra_ap_opts,
+                                        principal,
+                                        ccdef, &packet,
+                                        tgs_expire,
+                                        impersonate_princ_s))) {
+        retval = ads_krb5_mk_req(context, &auth_context,
+                                AP_OPTS_USE_SUBKEY | (krb5_flags)extra_ap_opts,
+                                principal, ccdef, &packet,
+                                tgs_expire, impersonate_princ_s);
+        if (retval) {
                 goto failed;
+        }
+        get_krb5_smb_session_key(context, auth_context, session_key_krb5, False);
+        *ticket = data_blob(packet.data, packet.length);
+        kerberos_free_data_contents(context, &packet);
+        get_krb5_smb_session_key(mem_ctx, context, auth_context,
+                                 session_key_krb5, false);
+        *ticket = data_blob_talloc(mem_ctx, packet.data, packet.length);
+        kerberos_free_data_contents(context, &packet);
 failed:
         if ( context ) {
+        if (context) {
                 if (ccdef)
                         krb5_cc_close(context, ccdef);
 …
                 krb5_free_context(context);
+        }
         return retval;
+}
+ bool get_krb5_smb_session_key(krb5_context context, krb5_auth_context auth_context, DATA_BLOB *session_key, bool remote)
+ {
+bool get_krb5_smb_session_key(TALLOC_CTX *mem_ctx,
+                              krb5_context context,
+                              krb5_auth_context auth_context,
+                              DATA_BLOB *session_key, bool remote)
+{
         krb5_keyblock *skey = NULL;
         krb5_error_code err = 0;
 …
         if (remote) {
+                err = krb5_auth_con_getremotesubkey(context, auth_context, &skey);
+                err = krb5_auth_con_getremotesubkey(context,
+                                                    auth_context, &skey);
         } else {
+                err = krb5_auth_con_getlocalsubkey(context, auth_context, &skey);
+                err = krb5_auth_con_getlocalsubkey(context,
+                                                   auth_context, &skey);
+        }
 …
+        }
+        DEBUG(10, ("Got KRB5 session key of length %d\n",  (int)KRB5_KEY_LENGTH(skey)));
+        *session_key = data_blob(KRB5_KEY_DATA(skey), KRB5_KEY_LENGTH(skey));
+        dump_data_pw("KRB5 Session Key:\n", session_key->data, session_key->length);
+        DEBUG(10, ("Got KRB5 session key of length %d\n",
+                   (int)KRB5_KEY_LENGTH(skey)));
+        *session_key = data_blob_talloc(mem_ctx,
+                                         KRB5_KEY_DATA(skey),
+                                         KRB5_KEY_LENGTH(skey));
+        dump_data_pw("KRB5 Session Key:\n",
+                     session_key->data,
+                     session_key->length);
         ret = true;
  done:
+done:
         if (skey) {
                 krb5_free_keyblock(context, skey);
 …
         return ret;
+ }
+}
 …
 #else /* HAVE_KRB5 */
  /* this saves a few linking headaches */
+ int cli_krb5_get_ticket(const char *principal, time_t time_offset,
+                        DATA_BLOB *ticket, DATA_BLOB *session_key_krb5, uint32 extra_ap_opts,
+ int cli_krb5_get_ticket(TALLOC_CTX *mem_ctx,
+                        const char *principal, time_t time_offset,
+                        DATA_BLOB *ticket, DATA_BLOB *session_key_krb5,
+                        uint32_t extra_ap_opts,
                         const char *ccname, time_t *tgs_expire,
                         const char *impersonate_princ_s)
 …
+}
+#endif
+bool unwrap_pac(TALLOC_CTX *mem_ctx, DATA_BLOB *auth_data, DATA_BLOB *unwrapped_pac_data)
+{
+        DEBUG(0,("NO KERBEROS SUPPORT\n"));
+        return false;
+}
+#endif /* HAVE_KRB5 */

vendor/current/source3/libsmb/clilist.c

-              r414
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "trans2.h"
 /****************************************************************************
 …
                                         struct cli_state *cli,
                                         int level,
+                                        const char *base_ptr,
+                                        uint16_t recv_flags2,
                                         const char *p,
                                         const char *pdata_end,
                                         file_info *finfo,
+                                        struct file_info *finfo,
                                         uint32 *p_resume_key,
                                         DATA_BLOB *p_last_name_raw)
 …
+        }
         ZERO_STRUCTP(finfo);
-        finfo->cli = cli;
         switch (level) {
 …
                                 return pdata_end - base;
+                        }
+                        finfo->ctime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+4));
+                        finfo->atime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+8));
+                        finfo->mtime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+12));
+                        finfo->ctime_ts = convert_time_t_to_timespec(
+                                make_unix_date2(p+4, cli->serverzone));
+                        finfo->atime_ts = convert_time_t_to_timespec(
+                                make_unix_date2(p+8, cli->serverzone));
+                        finfo->mtime_ts = convert_time_t_to_timespec(
+                                make_unix_date2(p+12, cli->serverzone));
                         finfo->size = IVAL(p,16);
                         finfo->mode = CVAL(p,24);
                         len = CVAL(p, 26);
                         p += 27;
                         p += clistr_align_in(cli, p, 0);
+                        p += align_string(base_ptr, p, 0);
                         /* We can safely use len here (which is required by OS/2)
 …
                            (tridge) */
                         ret = clistr_pull_talloc(ctx,
+                                                cli->inbuf,
+                                                base_ptr,
+                                                recv_flags2,
                                                 &finfo->name,
                                                 p,
 …
                                 return pdata_end - base;
+                        }
+                        finfo->ctime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+4));
+                        finfo->atime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+8));
+                        finfo->mtime_ts = convert_time_t_to_timespec(cli_make_unix_date2(cli, p+12));
+                        finfo->ctime_ts = convert_time_t_to_timespec(
+                                make_unix_date2(p+4, cli->serverzone));
+                        finfo->atime_ts = convert_time_t_to_timespec(
+                                make_unix_date2(p+8, cli->serverzone));
+                        finfo->mtime_ts = convert_time_t_to_timespec(
+                                make_unix_date2(p+12, cli->serverzone));
                         finfo->size = IVAL(p,16);
                         finfo->mode = CVAL(p,24);
 …
+                        }
                         ret = clistr_pull_talloc(ctx,
+                                                cli->inbuf,
+                                                base_ptr,
+                                                recv_flags2,
                                                 &finfo->name,
                                                 p,
 …
                                 int flags = 0;
                                 if (p[1] == 0 && namelen > 1) flags |= STR_UNICODE;
                                 clistr_pull(cli->inbuf, finfo->short_name, p,
+                                clistr_pull(base_ptr, finfo->short_name, p,
                                             sizeof(finfo->short_name),
                                             slen, flags);
 …
+                        }
                         ret = clistr_pull_talloc(ctx,
+                                                cli->inbuf,
+                                                base_ptr,
+                                                recv_flags2,
                                                 &finfo->name,
                                                 p,
 …
 /****************************************************************************
- Do a directory listing, calling fn on each file found.
-****************************************************************************/
-int cli_list_new(struct cli_state *cli,const char *Mask,uint16 attribute,
-                 void (*fn)(const char *, file_info *, const char *, void *), void *state)
+{
-#if 1
-        int max_matches = 1366; /* Match W2k - was 512. */
-#else
-        int max_matches = 512;
-#endif
-        int info_level;
-        char *p, *p2, *rdata_end;
-        char *mask = NULL;
-        file_info finfo;
-        int i;
-        char *dirlist = NULL;
-        int dirlist_len = 0;
-        int total_received = -1;
-        bool First = True;
-        int ff_searchcount=0;
-        int ff_eos=0;
-        int ff_dir_handle=0;
-        int loop_count = 0;
-        char *rparam=NULL, *rdata=NULL;
-        unsigned int param_len, data_len;
-        uint16 setup;
-        char *param;
-        uint32 resume_key = 0;
-        TALLOC_CTX *frame = talloc_stackframe();
-        DATA_BLOB last_name_raw = data_blob(NULL, 0);
-        /* NT uses SMB_FIND_FILE_BOTH_DIRECTORY_INFO,
-           OS/2 uses SMB_FIND_EA_SIZE. Both accept SMB_FIND_INFO_STANDARD. */
-        info_level = (cli->capabilities&CAP_NT_SMBS)?
-                SMB_FIND_FILE_BOTH_DIRECTORY_INFO : SMB_FIND_INFO_STANDARD;
-        mask = SMB_STRDUP(Mask);
-        if (!mask) {
-                TALLOC_FREE(frame);
-                return -1;
+        }
-        while (ff_eos == 0) {
-                size_t nlen = 2*(strlen(mask)+1);
-                loop_count++;
-                if (loop_count > 200) {
-                        DEBUG(0,("Error: Looping in FIND_NEXT??\n"));
-                        break;
+                }
-                param = SMB_MALLOC_ARRAY(char, 12+nlen+last_name_raw.length+2);
-                if (!param) {
-                        break;
+                }
-                if (First) {
-                        setup = TRANSACT2_FINDFIRST;
-                        SSVAL(param,0,attribute); /* attribute */
-                        SSVAL(param,2,max_matches); /* max count */
-                        SSVAL(param,4,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END)); /* resume required + close on end */
-                        SSVAL(param,6,info_level);
-                        SIVAL(param,8,0);
-                        p = param+12;
-                        p += clistr_push(cli, param+12, mask,
-                                         nlen, STR_TERMINATE);
-                } else {
-                        setup = TRANSACT2_FINDNEXT;
-                        SSVAL(param,0,ff_dir_handle);
-                        SSVAL(param,2,max_matches); /* max count */
-                        SSVAL(param,4,info_level);
-                        /* For W2K servers serving out FAT filesystems we *must* set the
-                           resume key. If it's not FAT then it's returned as zero. */
-                        SIVAL(param,6,resume_key); /* ff_resume_key */
-                        /* NB. *DON'T* use continue here. If you do it seems that W2K and bretheren
-                           can miss filenames. Use last filename continue instead. JRA */
-                        SSVAL(param,10,(FLAG_TRANS2_FIND_REQUIRE_RESUME|FLAG_TRANS2_FIND_CLOSE_IF_END));        /* resume required + close on end */
-                        p = param+12;
-                        if (last_name_raw.length) {
-                                memcpy(p, last_name_raw.data, last_name_raw.length);
-                                p += last_name_raw.length;
-                        } else {
-                                p += clistr_push(cli, param+12, mask,
-                                                nlen, STR_TERMINATE);
+                        }
+                }
-                param_len = PTR_DIFF(p, param);
-                if (!cli_send_trans(cli, SMBtrans2,
-                                    NULL,                   /* Name */
-                                    -1, 0,                  /* fid, flags */
-                                    &setup, 1, 0,           /* setup, length, max */
-                                    param, param_len, 10,   /* param, length, max */
-                                    NULL, 0,
-#if 0
-                                    /* w2k value. */
-                                    MIN(16384,cli->max_xmit) /* data, length, max. */
-#else
-                                    cli->max_xmit           /* data, length, max. */
-#endif
-                                    )) {
-                        SAFE_FREE(param);
-                        TALLOC_FREE(frame);
-                        break;
+                }
-                SAFE_FREE(param);
-                if (!cli_receive_trans(cli, SMBtrans2,
-                                       &rparam, &param_len,
-                                       &rdata, &data_len) &&
-                    cli_is_dos_error(cli)) {
-                        /* We need to work around a Win95 bug - sometimes
-                           it gives ERRSRV/ERRerror temprarily */
-                        uint8 eclass;
-                        uint32 ecode;
-                        SAFE_FREE(rdata);
-                        SAFE_FREE(rparam);
-                        cli_dos_error(cli, &eclass, &ecode);
-                        /*
-                         * OS/2 might return "no more files",
-                         * which just tells us, that searchcount is zero
-                         * in this search.
-                         * Guenter Kukkukk <linux@kukkukk.com>
-                         */
-                        if (eclass == ERRDOS && ecode == ERRnofiles) {
-                                ff_searchcount = 0;
-                                cli_reset_error(cli);
-                                break;
+                        }
-                        if (eclass != ERRSRV || ecode != ERRerror)
-                                break;
-                        smb_msleep(100);
-                        continue;
+                }
-                if (cli_is_error(cli) || !rdata || !rparam) {
-                        SAFE_FREE(rdata);
-                        SAFE_FREE(rparam);
-                        break;
+                }
-                if (total_received == -1)
-                        total_received = 0;
-                /* parse out some important return info */
-                p = rparam;
-                if (First) {
-                        ff_dir_handle = SVAL(p,0);
-                        ff_searchcount = SVAL(p,2);
-                        ff_eos = SVAL(p,4);
-                } else {
-                        ff_searchcount = SVAL(p,0);
-                        ff_eos = SVAL(p,2);
+                }
-                if (ff_searchcount == 0) {
-                        SAFE_FREE(rdata);
-                        SAFE_FREE(rparam);
-                        break;
+                }
-                /* point to the data bytes */
-                p = rdata;
-                rdata_end = rdata + data_len;
-                /* we might need the lastname for continuations */
-                for (p2=p,i=0;i<ff_searchcount && p2 < rdata_end;i++) {
-                        if ((info_level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO) &&
-                                        (i == ff_searchcount-1)) {
-                                /* Last entry - fixup the last offset length. */
-                                SIVAL(p2,0,PTR_DIFF((rdata + data_len),p2));
+                        }
-                        p2 += interpret_long_filename(frame,
-                                                        cli,
-                                                        info_level,
-                                                        p2,
-                                                        rdata_end,
-                                                        &finfo,
-                                                        &resume_key,
-                                                        &last_name_raw);
-                        if (!finfo.name) {
-                                DEBUG(0,("cli_list_new: Error: unable to parse name from info level %d\n",
-                                        info_level));
-                                ff_eos = 1;
-                                break;
+                        }
-                        if (!First && *mask && strcsequal(finfo.name, mask)) {
-                                DEBUG(0,("Error: Looping in FIND_NEXT as name %s has already been seen?\n",
-                                        finfo.name));
-                                ff_eos = 1;
-                                break;
+                        }
+                }
-                SAFE_FREE(mask);
-                if (ff_searchcount > 0 && ff_eos == 0 && finfo.name) {
-                        mask = SMB_STRDUP(finfo.name);
-                } else {
-                        mask = SMB_STRDUP("");
+                }
-                if (!mask) {
-                        SAFE_FREE(rdata);
-                        SAFE_FREE(rparam);
-                        break;
+                }
-                /* grab the data for later use */
-                /* and add them to the dirlist pool */
-                dirlist = (char *)SMB_REALLOC(dirlist,dirlist_len + data_len);
-                if (!dirlist) {
-                        DEBUG(0,("cli_list_new: Failed to expand dirlist\n"));
-                        SAFE_FREE(rdata);
-                        SAFE_FREE(rparam);
-                        break;
+                }
-                memcpy(dirlist+dirlist_len,p,data_len);
-                dirlist_len += data_len;
-                total_received += ff_searchcount;
-                SAFE_FREE(rdata);
-                SAFE_FREE(rparam);
-                DEBUG(3,("received %d entries (eos=%d)\n",
-                         ff_searchcount,ff_eos));
-                if (ff_searchcount > 0)
-                        loop_count = 0;
-                First = False;
+        }
-        /* see if the server disconnected or the connection otherwise failed */
-        if (cli_is_error(cli)) {
-                total_received = -1;
-        } else {
-                /* no connection problem.  let user function add each entry */
-                rdata_end = dirlist + dirlist_len;
-                for (p=dirlist,i=0;i<total_received;i++) {
-                        p += interpret_long_filename(frame,
-                                                        cli,
-                                                        info_level,
-                                                        p,
-                                                        rdata_end,
-                                                        &finfo,
-                                                        NULL,
-                                                        NULL);
-                        if (!finfo.name) {
-                                DEBUG(0,("cli_list_new: unable to parse name from info level %d\n",
-                                        info_level));
-                                break;
+                        }
-                        fn(cli->dfs_mountpoint, &finfo, Mask, state);
+                }
+        }
-        /* free up the dirlist buffer and last name raw blob */
-        SAFE_FREE(dirlist);
-        data_blob_free(&last_name_raw);
-        SAFE_FREE(mask);
-        TALLOC_FREE(frame);
-        return(total_received);
+}
-/****************************************************************************
  Interpret a short filename structure.
  The length of the structure is returned.
 …
                                 struct cli_state *cli,
                                 char *p,
                                 file_info *finfo)
+                                struct file_info *finfo)
+{
         size_t ret;
         ZERO_STRUCTP(finfo);
-        finfo->cli = cli;
         finfo->mode = CVAL(p,21);
         /* this date is converted to GMT by make_unix_date */
         finfo->ctime_ts.tv_sec = cli_make_unix_date(cli, p+22);
+        finfo->ctime_ts.tv_sec = make_unix_date(p+22, cli->serverzone);
         finfo->ctime_ts.tv_nsec = 0;
         finfo->mtime_ts.tv_sec = finfo->atime_ts.tv_sec = finfo->ctime_ts.tv_sec;
 …
         ret = clistr_pull_talloc(ctx,
                         cli->inbuf,
+                        SVAL(cli->inbuf, smb_flg2),
                         &finfo->name,
                         p+30,
 …
+        }
         return true;
+        return(DIR_STRUCT_SIZE);
+}
+/****************************************************************************
+ Do a directory listing, calling fn on each file found.
+ this uses the old SMBsearch interface. It is needed for testing Samba,
+ but should otherwise not be used.
+****************************************************************************/
+int cli_list_old(struct cli_state *cli,const char *Mask,uint16 attribute,
+                 void (*fn)(const char *, file_info *, const char *, void *), void *state)
+{
+}
+struct cli_list_old_state {
+        struct tevent_context *ev;
+        struct cli_state *cli;
+        uint16_t vwv[2];
+        char *mask;
+        int num_asked;
+        uint16_t attribute;
+        uint8_t search_status[23];
+        bool first;
+        bool done;
+        uint8_t *dirlist;
+};
+static void cli_list_old_done(struct tevent_req *subreq);
+static struct tevent_req *cli_list_old_send(TALLOC_CTX *mem_ctx,
+                                            struct tevent_context *ev,
+                                            struct cli_state *cli,
+                                            const char *mask,
+                                            uint16_t attribute)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_list_old_state *state;
+        uint8_t *bytes;
+        static const uint16_t zero = 0;
+        req = tevent_req_create(mem_ctx, &state, struct cli_list_old_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->cli = cli;
+        state->attribute = attribute;
+        state->first = true;
+        state->mask = talloc_strdup(state, mask);
+        if (tevent_req_nomem(state->mask, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->num_asked = (cli->max_xmit - 100) / DIR_STRUCT_SIZE;
+        SSVAL(state->vwv + 0, 0, state->num_asked);
+        SSVAL(state->vwv + 1, 0, state->attribute);
+        bytes = talloc_array(state, uint8_t, 1);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        bytes[0] = 4;
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), mask,
+                                   strlen(mask)+1, NULL);
+        bytes = smb_bytes_push_bytes(bytes, 5, (uint8_t *)&zero, 2);
+        if (tevent_req_nomem(bytes, req)) {
+                return tevent_req_post(req, ev);
+        }
+        subreq = cli_smb_send(state, state->ev, state->cli, SMBsearch,
+, 2, state->vwv, talloc_get_size(bytes), bytes);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_list_old_done, req);
+        return req;
+}
+static void cli_list_old_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_list_old_state *state = tevent_req_data(
+                req, struct cli_list_old_state);
+        NTSTATUS status;
+        uint8_t cmd;
+        uint8_t wct;
+        uint16_t *vwv;
+        uint32_t num_bytes;
+        uint8_t *bytes;
+        uint16_t received;
+        size_t dirlist_len;
+        uint8_t *tmp;
+        status = cli_smb_recv(subreq, state, NULL, 0, &wct, &vwv, &num_bytes,
+                              &bytes);
+        if (!NT_STATUS_IS_OK(status)
+            && !NT_STATUS_EQUAL(status, NT_STATUS_DOS(ERRDOS, ERRnofiles))
+            && !NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
+                TALLOC_FREE(subreq);
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (NT_STATUS_EQUAL(status, NT_STATUS_DOS(ERRDOS, ERRnofiles))
+            || NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES)) {
+                received = 0;
+        } else {
+                if (wct < 1) {
+                        TALLOC_FREE(subreq);
+                        tevent_req_nterror(
+                                req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                        return;
+                }
+                received = SVAL(vwv + 0, 0);
+        }
+        if (received > 0) {
+                /*
+                 * I don't think this can wrap. received is
+                 * initialized from a 16-bit value.
+                 */
+                if (num_bytes < (received * DIR_STRUCT_SIZE + 3)) {
+                        TALLOC_FREE(subreq);
+                        tevent_req_nterror(
+                                req, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                        return;
+                }
+                dirlist_len = talloc_get_size(state->dirlist);
+                tmp = TALLOC_REALLOC_ARRAY(
+                        state, state->dirlist, uint8_t,
+                        dirlist_len + received * DIR_STRUCT_SIZE);
+                if (tevent_req_nomem(tmp, req)) {
+                        return;
+                }
+                state->dirlist = tmp;
+                memcpy(state->dirlist + dirlist_len, bytes + 3,
+                       received * DIR_STRUCT_SIZE);
+                SSVAL(state->search_status, 0, 21);
+                memcpy(state->search_status + 2,
+                       bytes + 3 + (received-1)*DIR_STRUCT_SIZE, 21);
+                cmd = SMBsearch;
+        } else {
+                if (state->first || state->done) {
+                        tevent_req_done(req);
+                        return;
+                }
+                state->done = true;
+                state->num_asked = 0;
+                cmd = SMBfclose;
+        }
+        TALLOC_FREE(subreq);
+        state->first = false;
+        SSVAL(state->vwv + 0, 0, state->num_asked);
+        SSVAL(state->vwv + 1, 0, state->attribute);
+        bytes = talloc_array(state, uint8_t, 1);
+        if (tevent_req_nomem(bytes, req)) {
+                return;
+        }
+        bytes[0] = 4;
+        bytes = smb_bytes_push_str(bytes, cli_ucs2(state->cli), "",
+, NULL);
+        bytes = smb_bytes_push_bytes(bytes, 5, state->search_status,
+                                     sizeof(state->search_status));
+        if (tevent_req_nomem(bytes, req)) {
+                return;
+        }
+        subreq = cli_smb_send(state, state->ev, state->cli, cmd, 0,
+, state->vwv, talloc_get_size(bytes), bytes);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, cli_list_old_done, req);
+}
+static NTSTATUS cli_list_old_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                                  struct file_info **pfinfo)
+{
+        struct cli_list_old_state *state = tevent_req_data(
+                req, struct cli_list_old_state);
+        NTSTATUS status;
+        size_t i, num_received;
+        struct file_info *finfo;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        num_received = talloc_array_length(state->dirlist) / DIR_STRUCT_SIZE;
+        finfo = TALLOC_ARRAY(mem_ctx, struct file_info, num_received);
+        if (finfo == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        for (i=0; i<num_received; i++) {
+                if (!interpret_short_filename(
+                            finfo, state->cli,
+                            (char *)state->dirlist + i * DIR_STRUCT_SIZE,
+                            &finfo[i])) {
+                        TALLOC_FREE(finfo);
+                        return NT_STATUS_NO_MEMORY;
+                }
+        }
+        *pfinfo = finfo;
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_list_old(struct cli_state *cli, const char *mask,
+                      uint16 attribute,
+                      NTSTATUS (*fn)(const char *, struct file_info *,
+                                 const char *, void *), void *state)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        struct file_info *finfo;
+        size_t i, num_finfo;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_list_old_send(frame, ev, cli, mask, attribute);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll(req, ev)) {
+                status = map_nt_error_from_unix(errno);
+                goto fail;
+        }
+        status = cli_list_old_recv(req, frame, &finfo);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        num_finfo = talloc_array_length(finfo);
+        for (i=0; i<num_finfo; i++) {
+                status = fn(cli->dfs_mountpoint, &finfo[i], mask, state);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto fail;
+                }
+        }
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+struct cli_list_trans_state {
+        struct tevent_context *ev;
+        struct cli_state *cli;
+        char *mask;
+        uint16_t attribute;
+        uint16_t info_level;
+        int loop_count;
+        int total_received;
+        uint16_t max_matches;
+        bool first;
+        int ff_eos;
+        int ff_dir_handle;
+        uint16_t setup[1];
+        uint8_t *param;
+        struct file_info *finfo;
+};
+static void cli_list_trans_done(struct tevent_req *subreq);
+static struct tevent_req *cli_list_trans_send(TALLOC_CTX *mem_ctx,
+                                              struct tevent_context *ev,
+                                              struct cli_state *cli,
+                                              const char *mask,
+                                              uint16_t attribute,
+                                              uint16_t info_level)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_list_trans_state *state;
+        size_t nlen, param_len;
         char *p;
+        int received = 0;
+        bool first = True;
+        char status[21];
+        int num_asked = (cli->max_xmit - 100)/DIR_STRUCT_SIZE;
+        int num_received = 0;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_list_trans_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->cli = cli;
+        state->mask = talloc_strdup(state, mask);
+        if (tevent_req_nomem(state->mask, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->attribute = attribute;
+        state->info_level = info_level;
+        state->loop_count = 0;
+        state->first = true;
+        state->max_matches = 1366; /* Match W2k */
+        SSVAL(&state->setup[0], 0, TRANSACT2_FINDFIRST);
+        nlen = 2*(strlen(mask)+1);
+        state->param = TALLOC_ARRAY(state, uint8_t, 12+nlen+2);
+        if (tevent_req_nomem(state->param, req)) {
+                return tevent_req_post(req, ev);
+        }
+        SSVAL(state->param, 0, state->attribute);
+        SSVAL(state->param, 2, state->max_matches);
+        SSVAL(state->param, 4,
+              FLAG_TRANS2_FIND_REQUIRE_RESUME
+              |FLAG_TRANS2_FIND_CLOSE_IF_END);
+        SSVAL(state->param, 6, state->info_level);
+        SIVAL(state->param, 8, 0);
+        p = ((char *)state->param)+12;
+        p += clistr_push(state->cli, p, state->mask, nlen,
+                         STR_TERMINATE);
+        param_len = PTR_DIFF(p, state->param);
+        subreq = cli_trans_send(state, state->ev, state->cli,
+                                SMBtrans2, NULL, -1, 0, 0,
+                                state->setup, 1, 0,
+                                state->param, param_len, 10,
+                                NULL, 0, cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_list_trans_done, req);
+        return req;
+}
+static void cli_list_trans_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_list_trans_state *state = tevent_req_data(
+                req, struct cli_list_trans_state);
+        NTSTATUS status;
+        uint8_t *param;
+        uint32_t num_param;
+        uint8_t *data;
+        char *data_end;
+        uint32_t num_data;
+        uint32_t min_param;
+        struct file_info *tmp;
+        size_t old_num_finfo;
+        uint16_t recv_flags2;
+        int ff_searchcount;
+        bool ff_eos;
+        char *p, *p2;
+        uint32_t resume_key = 0;
         int i;
+        char *dirlist = NULL;
+        char *mask = NULL;
+        TALLOC_CTX *frame = NULL;
+        ZERO_ARRAY(status);
+        mask = SMB_STRDUP(Mask);
+        if (!mask) {
+                return -1;
+        }
+        while (1) {
+                memset(cli->outbuf,'\0',smb_size);
+                memset(cli->inbuf,'\0',smb_size);
+                cli_set_message(cli->outbuf,2,0,True);
+                SCVAL(cli->outbuf,smb_com,SMBsearch);
+                SSVAL(cli->outbuf,smb_tid,cli->cnum);
+                cli_setup_packet(cli);
+                SSVAL(cli->outbuf,smb_vwv0,num_asked);
+                SSVAL(cli->outbuf,smb_vwv1,attribute);
+                p = smb_buf(cli->outbuf);
+                *p++ = 4;
+                p += clistr_push(cli, p, first?mask:"",
+                                cli->bufsize - PTR_DIFF(p,cli->outbuf),
+                                STR_TERMINATE);
+                *p++ = 5;
+                if (first) {
+                        SSVAL(p,0,0);
+                        p += 2;
+                } else {
+                        SSVAL(p,0,21);
+                        p += 2;
+                        memcpy(p,status,21);
+                        p += 21;
+                }
+                cli_setup_bcc(cli, p);
+                cli_send_smb(cli);
+                if (!cli_receive_smb(cli)) break;
+                received = SVAL(cli->inbuf,smb_vwv0);
+                if (received <= 0) break;
+                /* Ensure we received enough data. */
+                if ((cli->inbuf+4+smb_len(cli->inbuf) - (smb_buf(cli->inbuf)+3)) <
+                                received*DIR_STRUCT_SIZE) {
+        DATA_BLOB last_name_raw;
+        struct file_info *finfo = NULL;
+        size_t nlen, param_len;
+        min_param = (state->first ? 6 : 4);
+        status = cli_trans_recv(subreq, talloc_tos(), &recv_flags2,
+                                NULL, 0, NULL,
+                                &param, min_param, &num_param,
+                                &data, 0, &num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                /*
+                 * TODO: retry, OS/2 nofiles
+                 */
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if (state->first) {
+                state->ff_dir_handle = SVAL(param, 0);
+                ff_searchcount = SVAL(param, 2);
+                ff_eos = SVAL(param, 4) != 0;
+        } else {
+                ff_searchcount = SVAL(param, 0);
+                ff_eos = SVAL(param, 2) != 0;
+        }
+        old_num_finfo = talloc_array_length(state->finfo);
+        tmp = TALLOC_REALLOC_ARRAY(state, state->finfo, struct file_info,
+                                   old_num_finfo + ff_searchcount);
+        if (tevent_req_nomem(tmp, req)) {
+                return;
+        }
+        state->finfo = tmp;
+        p2 = p = (char *)data;
+        data_end = (char *)data + num_data;
+        last_name_raw = data_blob_null;
+        for (i=0; i<ff_searchcount; i++) {
+                if (p2 >= data_end) {
+                        ff_eos = true;
                         break;
+                }
+                first = False;
+                dirlist = (char *)SMB_REALLOC(
+                        dirlist,(num_received + received)*DIR_STRUCT_SIZE);
+                if (!dirlist) {
+                        DEBUG(0,("cli_list_old: failed to expand dirlist"));
+                        SAFE_FREE(mask);
+                        return 0;
+                }
+                p = smb_buf(cli->inbuf) + 3;
+                memcpy(dirlist+num_received*DIR_STRUCT_SIZE,
+                       p,received*DIR_STRUCT_SIZE);
+                memcpy(status,p + ((received-1)*DIR_STRUCT_SIZE),21);
+                num_received += received;
+                if (cli_is_error(cli)) break;
+        }
+        if (!first) {
+                memset(cli->outbuf,'\0',smb_size);
+                memset(cli->inbuf,'\0',smb_size);
+                cli_set_message(cli->outbuf,2,0,True);
+                SCVAL(cli->outbuf,smb_com,SMBfclose);
+                SSVAL(cli->outbuf,smb_tid,cli->cnum);
+                cli_setup_packet(cli);
+                SSVAL(cli->outbuf, smb_vwv0, 0); /* find count? */
+                SSVAL(cli->outbuf, smb_vwv1, attribute);
+                p = smb_buf(cli->outbuf);
+                *p++ = 4;
+                fstrcpy(p, "");
+                p += strlen(p) + 1;
+                *p++ = 5;
+                SSVAL(p, 0, 21);
+                p += 2;
+                memcpy(p,status,21);
+                p += 21;
+                cli_setup_bcc(cli, p);
+                cli_send_smb(cli);
+                if (!cli_receive_smb(cli)) {
+                        DEBUG(0,("Error closing search: %s\n",cli_errstr(cli)));
+                }
+        }
+        frame = talloc_stackframe();
+        for (p=dirlist,i=0;i<num_received;i++) {
+                file_info finfo;
+                if (!interpret_short_filename(frame, cli, p, &finfo)) {
+                if ((state->info_level == SMB_FIND_FILE_BOTH_DIRECTORY_INFO)
+                    && (i == ff_searchcount-1)) {
+                        /* Last entry - fixup the last offset length. */
+                        SIVAL(p2, 0, PTR_DIFF((data + num_data), p2));
+                }
+                data_blob_free(&last_name_raw);
+                finfo = &state->finfo[old_num_finfo + i];
+                p2 += interpret_long_filename(
+                        state->finfo, /* Stick fname to the array as such */
+                        state->cli, state->info_level,
+                        (char *)data, recv_flags2, p2,
+                        data_end, finfo, &resume_key, &last_name_raw);
+                if (finfo->name == NULL) {
+                        DEBUG(1, ("cli_list: Error: unable to parse name from "
+                                  "info level %d\n", state->info_level));
+                        ff_eos = true;
                         break;
+                }
+                p += DIR_STRUCT_SIZE;
+                fn("\\", &finfo, Mask, state);
+        }
+                if (!state->first && (state->mask[0] != '\0') &&
+                    strcsequal(finfo->name, state->mask)) {
+                        DEBUG(1, ("Error: Looping in FIND_NEXT as name %s has "
+                                  "already been seen?\n", finfo->name));
+                        ff_eos = true;
+                        break;
+                }
+        }
+        if (ff_searchcount == 0) {
+                ff_eos = true;
+        }
+        TALLOC_FREE(param);
+        TALLOC_FREE(data);
+        /*
+         * Shrink state->finfo to the real length we received
+         */
+        tmp = TALLOC_REALLOC_ARRAY(state, state->finfo, struct file_info,
+                                   old_num_finfo + i);
+        if (tevent_req_nomem(tmp, req)) {
+                return;
+        }
+        state->finfo = tmp;
+        state->first = false;
+        if (ff_eos) {
+                data_blob_free(&last_name_raw);
+                tevent_req_done(req);
+                return;
+        }
+        TALLOC_FREE(state->mask);
+        state->mask = talloc_strdup(state, finfo->name);
+        if (tevent_req_nomem(state->mask, req)) {
+                return;
+        }
+        SSVAL(&state->setup[0], 0, TRANSACT2_FINDNEXT);
+        nlen = 2*(strlen(state->mask) + 1);
+        param = TALLOC_REALLOC_ARRAY(state, state->param, uint8_t,
++ nlen + last_name_raw.length + 2);
+        if (tevent_req_nomem(param, req)) {
+                return;
+        }
+        state->param = param;
+        SSVAL(param, 0, state->ff_dir_handle);
+        SSVAL(param, 2, state->max_matches); /* max count */
+        SSVAL(param, 4, state->info_level);
+        /*
+         * For W2K servers serving out FAT filesystems we *must* set
+         * the resume key. If it's not FAT then it's returned as zero.
+         */
+        SIVAL(param, 6, resume_key); /* ff_resume_key */
+        /*
+         * NB. *DON'T* use continue here. If you do it seems that W2K
+         * and bretheren can miss filenames. Use last filename
+         * continue instead. JRA
+         */
+        SSVAL(param, 10, (FLAG_TRANS2_FIND_REQUIRE_RESUME
+                          |FLAG_TRANS2_FIND_CLOSE_IF_END));
+        p = ((char *)param)+12;
+        if (last_name_raw.length) {
+                memcpy(p, last_name_raw.data, last_name_raw.length);
+                p += last_name_raw.length;
+                data_blob_free(&last_name_raw);
+        } else {
+                p += clistr_push(state->cli, p, state->mask, nlen,
+                                 STR_TERMINATE);
+        }
+        param_len = PTR_DIFF(p, param);
+        subreq = cli_trans_send(state, state->ev, state->cli,
+                                SMBtrans2, NULL, -1, 0, 0,
+                                state->setup, 1, 0,
+                                state->param, param_len, 10,
+                                NULL, 0, state->cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, cli_list_trans_done, req);
+}
+static NTSTATUS cli_list_trans_recv(struct tevent_req *req,
+                                    TALLOC_CTX *mem_ctx,
+                                    struct file_info **finfo)
+{
+        struct cli_list_trans_state *state = tevent_req_data(
+                req, struct cli_list_trans_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        *finfo = talloc_move(mem_ctx, &state->finfo);
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_list_trans(struct cli_state *cli, const char *mask,
+                        uint16_t attribute, int info_level,
+                        NTSTATUS (*fn)(const char *mnt, struct file_info *finfo,
+                                   const char *mask, void *private_data),
+                        void *private_data)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        int i, num_finfo;
+        struct file_info *finfo = NULL;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_list_trans_send(frame, ev, cli, mask, attribute, info_level);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_list_trans_recv(req, frame, &finfo);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        num_finfo = talloc_array_length(finfo);
+        for (i=0; i<num_finfo; i++) {
+                status = fn(cli->dfs_mountpoint, &finfo[i], mask, private_data);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto fail;
+                }
+        }
+ fail:
         TALLOC_FREE(frame);
+        SAFE_FREE(mask);
+        SAFE_FREE(dirlist);
+        return(num_received);
+}
+/****************************************************************************
+ Do a directory listing, calling fn on each file found.
+ This auto-switches between old and new style.
+****************************************************************************/
+int cli_list(struct cli_state *cli,const char *Mask,uint16 attribute,
+             void (*fn)(const char *, file_info *, const char *, void *), void *state)
+{
+        if (cli->protocol <= PROTOCOL_LANMAN1)
+                return cli_list_old(cli, Mask, attribute, fn, state);
+        return cli_list_new(cli, Mask, attribute, fn, state);
+}
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+struct cli_list_state {
+        NTSTATUS (*recv_fn)(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                            struct file_info **finfo);
+        struct file_info *finfo;
+};
+static void cli_list_done(struct tevent_req *subreq);
+struct tevent_req *cli_list_send(TALLOC_CTX *mem_ctx,
+                                 struct tevent_context *ev,
+                                 struct cli_state *cli,
+                                 const char *mask,
+                                 uint16_t attribute,
+                                 uint16_t info_level)
+{
+        struct tevent_req *req, *subreq;
+        struct cli_list_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct cli_list_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        if (cli->protocol <= PROTOCOL_LANMAN1) {
+                subreq = cli_list_old_send(state, ev, cli, mask, attribute);
+                state->recv_fn = cli_list_old_recv;
+        } else {
+                subreq = cli_list_trans_send(state, ev, cli, mask, attribute,
+                                             info_level);
+                state->recv_fn = cli_list_trans_recv;
+        }
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_list_done, req);
+        return req;
+}
+static void cli_list_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_list_state *state = tevent_req_data(
+                req, struct cli_list_state);
+        NTSTATUS status;
+        status = state->recv_fn(subreq, state, &state->finfo);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_list_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                       struct file_info **finfo, size_t *num_finfo)
+{
+        struct cli_list_state *state = tevent_req_data(
+                req, struct cli_list_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        *num_finfo = talloc_array_length(state->finfo);
+        *finfo = talloc_move(mem_ctx, &state->finfo);
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_list(struct cli_state *cli, const char *mask, uint16 attribute,
+                  NTSTATUS (*fn)(const char *, struct file_info *, const char *,
+                             void *), void *state)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        struct file_info *finfo;
+        size_t i, num_finfo;
+        uint16_t info_level;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        info_level = (cli->capabilities & CAP_NT_SMBS)
+                ? SMB_FIND_FILE_BOTH_DIRECTORY_INFO : SMB_FIND_INFO_STANDARD;
+        req = cli_list_send(frame, ev, cli, mask, attribute, info_level);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll(req, ev)) {
+                status = map_nt_error_from_unix(errno);
+                goto fail;
+        }
+        status = cli_list_recv(req, frame, &finfo, &num_finfo);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        for (i=0; i<num_finfo; i++) {
+                status = fn(cli->dfs_mountpoint, &finfo[i], mask, state);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto fail;
+                }
+        }
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}

vendor/current/source3/libsmb/climessage.c

-              r587
+              r740
 #include "includes.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "libsmb/libsmb.h"
 struct cli_message_start_state {
 …
         uint8_t wct;
         uint16_t *vwv;
+        status = cli_smb_recv(subreq, 0, &wct, &vwv, NULL, NULL);
+        uint8_t *inbuf;
+        status = cli_smb_recv(subreq, state, &inbuf, 0, &wct, &vwv,
+                              NULL, NULL);
+        TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
                 TALLOC_FREE(subreq);
 …
                 state->grp = 0;
+        }
-        TALLOC_FREE(subreq);
         tevent_req_done(req);
+}
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {

vendor/current/source3/libsmb/clioplock.c

-              r414
+              r740
 #include "includes.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "libsmb/libsmb.h"
 /****************************************************************************
 …
         struct cli_oplock_ack_state *state;
         req = tevent_req_create(mem_ctx, &state, struct cli_oplock_ack_state);;
+        req = tevent_req_create(mem_ctx, &state, struct cli_oplock_ack_state);
         if (req == NULL) {
                 return NULL;
 …
         NTSTATUS status;
         status = cli_smb_recv(subreq, 0, NULL, NULL, NULL, NULL);
+        status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
         TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(status)) {

vendor/current/source3/libsmb/cliprint.c

-              r414
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
 /*****************************************************************************
 …
                           char *rdata, int rdrcnt)
+{
+        unsigned int offset;
         if (datap == 0) {
                 /* turn NULL pointers into zero length strings */
                 return "";
+        } else {
+                unsigned int offset = datap - converter;
+        }
+                if (offset >= rdrcnt) {
+                        DEBUG(1,("bad char ptr: datap=%u, converter=%u rdrcnt=%d>",
+                                 datap, converter, rdrcnt));
+                        return "<ERROR>";
+                } else {
+                        return &rdata[offset];
+                }
+        offset = datap - converter;
+        if (offset >= rdrcnt) {
+                DEBUG(1,("bad char ptr: datap=%u, converter=%u rdrcnt=%d>",
+                         datap, converter, rdrcnt));
+                return "<ERROR>";
+        }
+        return &rdata[offset];
+}
 …
                                         fix_char_ptr(SVAL(p,4), converter,
                                                      rdata, rdrcnt));
+                                job.t = cli_make_unix_date3(cli, p + 12);
+                                job.t = make_unix_date3(
+                                        p + 12, cli->serverzone);
                                 job.size = IVAL(p,16);
                                 fstrcpy(job.name,fix_char_ptr(SVAL(p,24),
 …
         return ret;
+}
-/****************************************************************************
- Open a spool file
-****************************************************************************/
-int cli_spl_open(struct cli_state *cli, const char *fname, int flags, int share_mode)
+{
-        char *p;
-        unsigned openfn=0;
-        unsigned accessmode=0;
-        if (flags & O_CREAT)
-                openfn |= (1<<4);
-        if (!(flags & O_EXCL)) {
-                if (flags & O_TRUNC)
-                        openfn |= (1<<1);
-                else
-                        openfn |= (1<<0);
+        }
-        accessmode = (share_mode<<4);
-        if ((flags & O_ACCMODE) == O_RDWR) {
-                accessmode |= 2;
-        } else if ((flags & O_ACCMODE) == O_WRONLY) {
-                accessmode |= 1;
+        }
-#if defined(O_SYNC)
-        if ((flags & O_SYNC) == O_SYNC) {
-                accessmode |= (1<<14);
+        }
-#endif /* O_SYNC */
-        if (share_mode == DENY_FCB) {
-                accessmode = 0xFF;
+        }
-        memset(cli->outbuf,'\0',smb_size);
-        memset(cli->inbuf,'\0',smb_size);
-        cli_set_message(cli->outbuf,15,0,True);
-        SCVAL(cli->outbuf,smb_com,SMBsplopen);
-        SSVAL(cli->outbuf,smb_tid,cli->cnum);
-        cli_setup_packet(cli);
-        SSVAL(cli->outbuf,smb_vwv0,0xFF);
-        SSVAL(cli->outbuf,smb_vwv2,0);  /* no additional info */
-        SSVAL(cli->outbuf,smb_vwv3,accessmode);
-        SSVAL(cli->outbuf,smb_vwv4,aSYSTEM | aHIDDEN);
-        SSVAL(cli->outbuf,smb_vwv5,0);
-        SSVAL(cli->outbuf,smb_vwv8,openfn);
-        if (cli->use_oplocks) {
-                /* if using oplocks then ask for a batch oplock via
-                   core and extended methods */
-                SCVAL(cli->outbuf,smb_flg, CVAL(cli->outbuf,smb_flg)|
-                        FLAG_REQUEST_OPLOCK|FLAG_REQUEST_BATCH_OPLOCK);
-                SSVAL(cli->outbuf,smb_vwv2,SVAL(cli->outbuf,smb_vwv2) | 6);
+        }
-        p = smb_buf(cli->outbuf);
-        p += clistr_push(cli, p, fname, -1, STR_TERMINATE);
-        cli_setup_bcc(cli, p);
-        cli_send_smb(cli);
-        if (!cli_receive_smb(cli)) {
-                return -1;
+        }
-        if (cli_is_error(cli)) {
-                return -1;
+        }
-        return SVAL(cli->inbuf,smb_vwv2);
+}
-/****************************************************************************
- Close a file.
-****************************************************************************/
-bool cli_spl_close(struct cli_state *cli, uint16_t fnum)
+{
-        memset(cli->outbuf,'\0',smb_size);
-        memset(cli->inbuf,'\0',smb_size);
-        cli_set_message(cli->outbuf,3,0,True);
-        SCVAL(cli->outbuf,smb_com,SMBsplclose);
-        SSVAL(cli->outbuf,smb_tid,cli->cnum);
-        cli_setup_packet(cli);
-        SSVAL(cli->outbuf,smb_vwv0,fnum);
-        SIVALS(cli->outbuf,smb_vwv1,-1);
-        cli_send_smb(cli);
-        if (!cli_receive_smb(cli)) {
-                return False;
+        }
-        return !cli_is_error(cli);
+}

vendor/current/source3/libsmb/cliquota.c

-              r581
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "fake_file.h"
+#include "../libcli/security/security.h"
+#include "trans2.h"
 NTSTATUS cli_get_quota_handle(struct cli_state *cli, uint16_t *quota_fnum)
 …
+}
+static bool parse_user_quota_record(const char *rdata, unsigned int rdata_count, unsigned int *offset, SMB_NTQUOTA_STRUCT *pqt)
+static bool parse_user_quota_record(const uint8_t *rdata,
+                                    unsigned int rdata_count,
+                                    unsigned int *offset,
+                                    SMB_NTQUOTA_STRUCT *pqt)
+{
         int sid_len;
 …
         /* the used space 8 bytes (uint64_t)*/
+        qt.usedspace = (uint64_t)IVAL(rdata,16);
+#ifdef LARGE_SMB_OFF_T
+        qt.usedspace |= (((uint64_t)IVAL(rdata,20)) << 32);
+#else /* LARGE_SMB_OFF_T */
+        if ((IVAL(rdata,20) != 0)&&
+                ((qt.usedspace != 0xFFFFFFFF)||
+                 (IVAL(rdata,20)!=0xFFFFFFFF))) {
+                /* more than 32 bits? */
+                return False;
+        }
+#endif /* LARGE_SMB_OFF_T */
+        qt.usedspace = BVAL(rdata,16);
         /* the soft quotas 8 bytes (uint64_t)*/
+        qt.softlim = (uint64_t)IVAL(rdata,24);
+#ifdef LARGE_SMB_OFF_T
+        qt.softlim |= (((uint64_t)IVAL(rdata,28)) << 32);
+#else /* LARGE_SMB_OFF_T */
+        if ((IVAL(rdata,28) != 0)&&
+                ((qt.softlim != 0xFFFFFFFF)||
+                 (IVAL(rdata,28)!=0xFFFFFFFF))) {
+                /* more than 32 bits? */
+                return False;
+        }
+#endif /* LARGE_SMB_OFF_T */
+        qt.softlim = BVAL(rdata,24);
         /* the hard quotas 8 bytes (uint64_t)*/
+        qt.hardlim = (uint64_t)IVAL(rdata,32);
+#ifdef LARGE_SMB_OFF_T
+        qt.hardlim |= (((uint64_t)IVAL(rdata,36)) << 32);
+#else /* LARGE_SMB_OFF_T */
+        if ((IVAL(rdata,36) != 0)&&
+                ((qt.hardlim != 0xFFFFFFFF)||
+                 (IVAL(rdata,36)!=0xFFFFFFFF))) {
+                /* more than 32 bits? */
+                return False;
+        }
+#endif /* LARGE_SMB_OFF_T */
+        if (!sid_parse(rdata+40,sid_len,&qt.sid)) {
+        qt.hardlim = BVAL(rdata,32);
+        if (!sid_parse((char *)rdata+40,sid_len,&qt.sid)) {
                 return false;
+        }
 …
+}
+bool cli_get_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
+{
+        bool ret = False;
         uint16 setup;
         char params[16];
+NTSTATUS cli_get_user_quota(struct cli_state *cli, int quota_fnum,
+                            SMB_NTQUOTA_STRUCT *pqt)
+{
+        uint16_t setup[1];
+        uint8_t params[16];
         unsigned int data_len;
         char data[SID_MAX_SIZE+8];
         char *rparam=NULL, *rdata=NULL;
         unsigned int rparam_count=0, rdata_count=0;
+        uint8_t data[SID_MAX_SIZE+8];
+        uint8_t *rparam, *rdata;
+        uint32_t rparam_count, rdata_count;
         unsigned int sid_len;
         unsigned int offset;
+        NTSTATUS status;
         if (!cli||!pqt) {
 …
+        }
         setup = NT_TRANSACT_GET_USER_QUOTA;
+        SSVAL(setup + 0, 0, NT_TRANSACT_GET_USER_QUOTA);
         SSVAL(params, 0,quota_fnum);
 …
         SIVAL(params,12,0x00000024);
         sid_len = ndr_size_dom_sid(&pqt->sid, NULL, 0);
+        sid_len = ndr_size_dom_sid(&pqt->sid, 0);
         data_len = sid_len+8;
         SIVAL(data, 0, 0x00000000);
         SIVAL(data, 4, sid_len);
+        sid_linearize(data+8, sid_len, &pqt->sid);
+        if (!cli_send_nt_trans(cli,
+                               NT_TRANSACT_GET_USER_QUOTA,
+,
+                               &setup, 1, 0,
+                               params, 16, 4,
+                               data, data_len, 112)) {
+                DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
+                goto cleanup;
+        }
+        if (!cli_receive_nt_trans(cli,
+                                  &rparam, &rparam_count,
+                                  &rdata, &rdata_count)) {
+                DEBUG(1,("Failed to recv NT_TRANSACT_GET_USER_QUOTA\n"));
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if ((rparam&&rdata)&&(rparam_count>=4&&rdata_count>=8)) {
+                ret = parse_user_quota_record(rdata, rdata_count, &offset, pqt);
+        } else {
+        sid_linearize((char *)data+8, sid_len, &pqt->sid);
+        status = cli_trans(talloc_tos(), cli, SMBnttrans,
+                           NULL, -1, /* name, fid */
+                           NT_TRANSACT_GET_USER_QUOTA, 0,
+                           setup, 1, 0, /* setup */
+                           params, 16, 4, /* params */
+                           data, data_len, 112, /* data */
+                           NULL,                /* recv_flags2 */
+                           NULL, 0, NULL,       /* rsetup */
+                           &rparam, 4, &rparam_count,
+                           &rdata, 8, &rdata_count);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("NT_TRANSACT_GET_USER_QUOTA failed: %s\n",
+                          nt_errstr(status)));
+                return status;
+        }
+        if (!parse_user_quota_record(rdata, rdata_count, &offset, pqt)) {
+                status = NT_STATUS_INVALID_NETWORK_RESPONSE;
                 DEBUG(0,("Got INVALID NT_TRANSACT_GET_USER_QUOTA reply.\n"));
+                ret = False;
+        }
+ cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_set_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
+{
+        bool ret = False;
+        uint16 setup;
+        char params[2];
+        char data[112];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        }
+        TALLOC_FREE(rparam);
+        TALLOC_FREE(rdata);
+        return status;
+}
+NTSTATUS cli_set_user_quota(struct cli_state *cli, int quota_fnum,
+                            SMB_NTQUOTA_STRUCT *pqt)
+{
+        uint16_t setup[1];
+        uint8_t params[2];
+        uint8_t data[112];
         unsigned int sid_len;
+        NTSTATUS status;
         memset(data,'\0',112);
 …
+        }
         setup = NT_TRANSACT_SET_USER_QUOTA;
+        SSVAL(setup + 0, 0, NT_TRANSACT_SET_USER_QUOTA);
         SSVAL(params,0,quota_fnum);
         sid_len = ndr_size_dom_sid(&pqt->sid, NULL, 0);
+        sid_len = ndr_size_dom_sid(&pqt->sid, 0);
         SIVAL(data,0,0);
         SIVAL(data,4,sid_len);
 …
         SBIG_UINT(data,24,pqt->softlim);
         SBIG_UINT(data,32,pqt->hardlim);
+        sid_linearize(data+40, sid_len, &pqt->sid);
+        if (!cli_send_nt_trans(cli,
+                               NT_TRANSACT_SET_USER_QUOTA,
+,
+                               &setup, 1, 0,
+                               params, 2, 0,
+                               data, 112, 0)) {
+                DEBUG(1,("Failed to send NT_TRANSACT_SET_USER_QUOTA\n"));
+                goto cleanup;
+        }
+        if (!cli_receive_nt_trans(cli,
+                                  &rparam, &rparam_count,
+                                  &rdata, &rdata_count)) {
+                DEBUG(1,("NT_TRANSACT_SET_USER_QUOTA failed\n"));
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+  cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_list_user_quota(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_LIST **pqt_list)
+{
+        bool ret = False;
+        uint16 setup;
+        char params[16];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        sid_linearize((char *)data+40, sid_len, &pqt->sid);
+        status = cli_trans(talloc_tos(), cli, SMBnttrans,
+                           NULL, -1, /* name, fid */
+                           NT_TRANSACT_SET_USER_QUOTA, 0,
+                           setup, 1, 0, /* setup */
+                           params, 2, 0, /* params */
+                           data, 112, 0, /* data */
+                           NULL,                /* recv_flags2 */
+                           NULL, 0, NULL,       /* rsetup */
+                           NULL, 0, NULL,       /* rparams */
+                           NULL, 0, NULL);      /* rdata */
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("NT_TRANSACT_SET_USER_QUOTA failed: %s\n",
+                          nt_errstr(status)));
+        }
+        return status;
+}
+NTSTATUS cli_list_user_quota(struct cli_state *cli, int quota_fnum,
+                             SMB_NTQUOTA_LIST **pqt_list)
+{
+        uint16_t setup[1];
+        uint8_t params[16];
+        uint8_t *rparam=NULL, *rdata=NULL;
+        uint32_t rparam_count=0, rdata_count=0;
         unsigned int offset;
         const char *curdata = NULL;
+        const uint8_t *curdata = NULL;
         unsigned int curdata_count = 0;
         TALLOC_CTX *mem_ctx = NULL;
         SMB_NTQUOTA_STRUCT qt;
         SMB_NTQUOTA_LIST *tmp_list_ent;
+        NTSTATUS status;
         if (!cli||!pqt_list) {
 …
+        }
         setup = NT_TRANSACT_GET_USER_QUOTA;
+        SSVAL(setup + 0, 0, NT_TRANSACT_GET_USER_QUOTA);
         SSVAL(params, 0,quota_fnum);
 …
         SIVAL(params,12,0x00000000);
+        if (!cli_send_nt_trans(cli,
+                               NT_TRANSACT_GET_USER_QUOTA,
+,
+                               &setup, 1, 0,
+                               params, 16, 4,
+                               NULL, 0, 2048)) {
+                DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
+        status = cli_trans(talloc_tos(), cli, SMBnttrans,
+                           NULL, -1, /* name, fid */
+                           NT_TRANSACT_GET_USER_QUOTA, 0,
+                           setup, 1, 0, /* setup */
+                           params, 16, 4, /* params */
+                           NULL, 0, 2048, /* data */
+                           NULL,                /* recv_flags2 */
+                           NULL, 0, NULL,       /* rsetup */
+                           &rparam, 0, &rparam_count,
+                           &rdata, 0, &rdata_count);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("NT_TRANSACT_GET_USER_QUOTA failed: %s\n",
+                          nt_errstr(status)));
                 goto cleanup;
+        }
-        if (!cli_receive_nt_trans(cli,
-                                  &rparam, &rparam_count,
-                                  &rdata, &rdata_count)) {
-                DEBUG(1,("Failed to recv NT_TRANSACT_GET_USER_QUOTA\n"));
-                goto cleanup;
+        }
-        if (cli_is_error(cli)) {
-                ret = False;
-                goto cleanup;
-        } else {
-                ret = True;
+        }
         if (rdata_count == 0) {
                 *pqt_list = NULL;
                 return True;
+                return NT_STATUS_OK;
+        }
         if ((mem_ctx=talloc_init("SMB_USER_QUOTA_LIST"))==NULL) {
                 DEBUG(0,("talloc_init() failed\n"));
                 return (-1);
+                return NT_STATUS_NO_MEMORY;
+        }
 …
                 curdata +=offset,curdata_count -= offset) {
                 ZERO_STRUCT(qt);
+                if (!parse_user_quota_record(curdata, curdata_count, &offset, &qt)) {
+                if (!parse_user_quota_record((uint8_t *)curdata, curdata_count,
+                                             &offset, &qt)) {
                         DEBUG(1,("Failed to parse the quota record\n"));
                         goto cleanup;
 …
                         DEBUG(0,("TALLOC_ZERO() failed\n"));
                         talloc_destroy(mem_ctx);
                         return (-1);
+                        return NT_STATUS_NO_MEMORY;
+                }
 …
                         DEBUG(0,("TALLOC_ZERO() failed\n"));
                         talloc_destroy(mem_ctx);
                         return (-1);
+                        return NT_STATUS_NO_MEMORY;
+                }
 …
         SSVAL(params, 2,TRANSACT_GET_USER_QUOTA_LIST_CONTINUE);
         while(1) {
+                if (!cli_send_nt_trans(cli,
+                                       NT_TRANSACT_GET_USER_QUOTA,
+,
+                                       &setup, 1, 0,
+                                       params, 16, 4,
+                                       NULL, 0, 2048)) {
+                        DEBUG(1,("Failed to send NT_TRANSACT_GET_USER_QUOTA\n"));
+                TALLOC_FREE(rparam);
+                TALLOC_FREE(rdata);
+                status = cli_trans(talloc_tos(), cli, SMBnttrans,
+                                   NULL, -1, /* name, fid */
+                                   NT_TRANSACT_GET_USER_QUOTA, 0,
+                                   setup, 1, 0, /* setup */
+                                   params, 16, 4, /* params */
+                                   NULL, 0, 2048, /* data */
+                                   NULL,                /* recv_flags2 */
+                                   NULL, 0, NULL,       /* rsetup */
+                                   &rparam, 0, &rparam_count,
+                                   &rdata, 0, &rdata_count);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(1, ("NT_TRANSACT_GET_USER_QUOTA failed: %s\n",
+                                  nt_errstr(status)));
                         goto cleanup;
+                }
-                SAFE_FREE(rparam);
-                SAFE_FREE(rdata);
-                if (!cli_receive_nt_trans(cli,
-                                          &rparam, &rparam_count,
-                                          &rdata, &rdata_count)) {
-                        DEBUG(1,("Failed to recv NT_TRANSACT_GET_USER_QUOTA\n"));
-                        goto cleanup;
+                }
-                if (cli_is_error(cli)) {
-                        ret = False;
-                        goto cleanup;
-                } else {
-                        ret = True;
+                }
                 if (rdata_count == 0) {
                         break;
+                        break;
+                }
 …
                         curdata +=offset,curdata_count -= offset) {
                         ZERO_STRUCT(qt);
+                        if (!parse_user_quota_record(curdata, curdata_count, &offset, &qt)) {
+                        if (!parse_user_quota_record((uint8_t *)curdata,
+                                                     curdata_count, &offset,
+                                                     &qt)) {
                                 DEBUG(1,("Failed to parse the quota record\n"));
                                 goto cleanup;
 …
+        }
-        ret = True;
  cleanup:
         SAFE_FREE(rparam);
         SAFE_FREE(rdata);
         return ret;
+}
+bool cli_get_fs_quota_info(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
+{
+        bool ret = False;
         uint16 setup;
         char param[2];
         char *rparam=NULL, *rdata=NULL;
         unsigned int rparam_count=0, rdata_count=0;
+        TALLOC_FREE(rparam);
+        TALLOC_FREE(rdata);
+        return status;
+}
+NTSTATUS cli_get_fs_quota_info(struct cli_state *cli, int quota_fnum,
+                               SMB_NTQUOTA_STRUCT *pqt)
+{
+        uint16_t setup[1];
+        uint8_t param[2];
+        uint8_t *rdata=NULL;
+        uint32_t rdata_count=0;
         SMB_NTQUOTA_STRUCT qt;
+        NTSTATUS status;
         ZERO_STRUCT(qt);
 …
+        }
         setup = TRANSACT2_QFSINFO;
+        SSVAL(setup + 0, 0, TRANSACT2_QFSINFO);
         SSVAL(param,0,SMB_FS_QUOTA_INFORMATION);
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 2, 0,
+                    NULL, 0, 560)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+        if (rdata_count < 48) {
+                goto cleanup;
+        status = cli_trans(talloc_tos(), cli, SMBtrans2,
+                           NULL, -1, /* name, fid */
+, 0,     /* function, flags */
+                           setup, 1, 0, /* setup */
+                           param, 2, 0, /* param */
+                           NULL, 0, 560, /* data */
+                           NULL,         /* recv_flags2 */
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL, /* rparam */
+                           &rdata, 48, &rdata_count);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("SMB_FS_QUOTA_INFORMATION failed: %s\n",
+                          nt_errstr(status)));
+                return status;
+        }
 …
         /* the soft quotas 8 bytes (uint64_t)*/
+        qt.softlim = (uint64_t)IVAL(rdata,24);
+#ifdef LARGE_SMB_OFF_T
+        qt.softlim |= (((uint64_t)IVAL(rdata,28)) << 32);
+#else /* LARGE_SMB_OFF_T */
+        if ((IVAL(rdata,28) != 0)&&
+                ((qt.softlim != 0xFFFFFFFF)||
+                 (IVAL(rdata,28)!=0xFFFFFFFF))) {
+                /* more than 32 bits? */
+                goto cleanup;
+        }
+#endif /* LARGE_SMB_OFF_T */
+        qt.softlim = BVAL(rdata,24);
         /* the hard quotas 8 bytes (uint64_t)*/
+        qt.hardlim = (uint64_t)IVAL(rdata,32);
+#ifdef LARGE_SMB_OFF_T
+        qt.hardlim |= (((uint64_t)IVAL(rdata,36)) << 32);
+#else /* LARGE_SMB_OFF_T */
+        if ((IVAL(rdata,36) != 0)&&
+                ((qt.hardlim != 0xFFFFFFFF)||
+                 (IVAL(rdata,36)!=0xFFFFFFFF))) {
+                /* more than 32 bits? */
+                goto cleanup;
+        }
+#endif /* LARGE_SMB_OFF_T */
+        qt.hardlim = BVAL(rdata,32);
         /* quota_flags 2 bytes **/
 …
         *pqt = qt;
+        ret = True;
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+bool cli_set_fs_quota_info(struct cli_state *cli, int quota_fnum, SMB_NTQUOTA_STRUCT *pqt)
+{
+        bool ret = False;
+        uint16 setup;
+        char param[4];
+        char data[48];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        TALLOC_FREE(rdata);
+        return status;
+}
+NTSTATUS cli_set_fs_quota_info(struct cli_state *cli, int quota_fnum,
+                               SMB_NTQUOTA_STRUCT *pqt)
+{
+        uint16_t setup[1];
+        uint8_t param[4];
+        uint8_t data[48];
         SMB_NTQUOTA_STRUCT qt;
+        NTSTATUS status;
         ZERO_STRUCT(qt);
         memset(data,'\0',48);
 …
+        }
         setup = TRANSACT2_SETFSINFO;
+        SSVAL(setup + 0, 0,TRANSACT2_SETFSINFO);
         SSVAL(param,0,quota_fnum);
 …
         /* Unknown3 6 NULL bytes */
+        if (!cli_send_trans(cli, SMBtrans2,
+                    NULL,
+, 0,
+                    &setup, 1, 0,
+                    param, 4, 0,
+                    data, 48, 0)) {
+                goto cleanup;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                              &rparam, &rparam_count,
+                              &rdata, &rdata_count)) {
+                goto cleanup;
+        }
+        if (cli_is_error(cli)) {
+                ret = False;
+                goto cleanup;
+        } else {
+                ret = True;
+        }
+cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return ret;
+}
+static const char *quota_str_static(uint64_t val, bool special, bool _numeric)
+{
+        const char *result;
+        if (!_numeric&&special&&(val == SMB_NTQUOTAS_NO_LIMIT)) {
+                return "NO LIMIT";
+        }
+        result = talloc_asprintf(talloc_tos(), "%"PRIu64, val);
+        SMB_ASSERT(result != NULL);
+        return result;
+}
+void dump_ntquota(SMB_NTQUOTA_STRUCT *qt, bool _verbose, bool _numeric, void (*_sidtostring)(fstring str, DOM_SID *sid, bool _numeric))
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        if (!qt) {
+                smb_panic("dump_ntquota() called with NULL pointer");
+        }
+        switch (qt->qtype) {
+                case SMB_USER_FS_QUOTA_TYPE:
+                        {
+                                d_printf("File System QUOTAS:\n");
+                                d_printf("Limits:\n");
+                                d_printf(" Default Soft Limit: %15s\n",quota_str_static(qt->softlim,True,_numeric));
+                                d_printf(" Default Hard Limit: %15s\n",quota_str_static(qt->hardlim,True,_numeric));
+                                d_printf("Quota Flags:\n");
+                                d_printf(" Quotas Enabled: %s\n",
+                                        ((qt->qflags&QUOTAS_ENABLED)||(qt->qflags&QUOTAS_DENY_DISK))?"On":"Off");
+                                d_printf(" Deny Disk:      %s\n",(qt->qflags&QUOTAS_DENY_DISK)?"On":"Off");
+                                d_printf(" Log Soft Limit: %s\n",(qt->qflags&QUOTAS_LOG_THRESHOLD)?"On":"Off");
+                                d_printf(" Log Hard Limit: %s\n",(qt->qflags&QUOTAS_LOG_LIMIT)?"On":"Off");
+                        }
+                        break;
+                case SMB_USER_QUOTA_TYPE:
+                        {
+                                fstring username_str = {0};
+                                if (_sidtostring) {
+                                        _sidtostring(username_str,&qt->sid,_numeric);
+                                } else {
+                                        sid_to_fstring(username_str, &qt->sid);
+                                }
+                                if (_verbose) {
+                                        d_printf("Quotas for User: %s\n",username_str);
+                                        d_printf("Used Space: %15s\n",quota_str_static(qt->usedspace,False,_numeric));
+                                        d_printf("Soft Limit: %15s\n",quota_str_static(qt->softlim,True,_numeric));
+                                        d_printf("Hard Limit: %15s\n",quota_str_static(qt->hardlim,True,_numeric));
+                                } else {
+                                        d_printf("%-30s: ",username_str);
+                                        d_printf("%15s/",quota_str_static(qt->usedspace,False,_numeric));
+                                        d_printf("%15s/",quota_str_static(qt->softlim,True,_numeric));
+                                        d_printf("%15s\n",quota_str_static(qt->hardlim,True,_numeric));
+                                }
+                        }
+                        break;
+                default:
+                        d_printf("dump_ntquota() invalid qtype(%d)\n",qt->qtype);
+        }
+        TALLOC_FREE(frame);
+        return;
+}
+void dump_ntquota_list(SMB_NTQUOTA_LIST **qtl, bool _verbose, bool _numeric, void (*_sidtostring)(fstring str, DOM_SID *sid, bool _numeric))
+{
+        SMB_NTQUOTA_LIST *cur;
+        for (cur = *qtl;cur;cur = cur->next) {
+                if (cur->quotas)
+                        dump_ntquota(cur->quotas,_verbose,_numeric,_sidtostring);
+        }
+}
+        status = cli_trans(talloc_tos(), cli, SMBtrans2,
+                           NULL, -1, /* name, fid */
+, 0,     /* function, flags */
+                           setup, 1, 0, /* setup */
+                           param, 8, 0, /* param */
+                           data, 48, 0, /* data */
+                           NULL,         /* recv_flags2 */
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL, /* rparam */
+                           NULL, 0, NULL); /* rdata */
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("SMB_FS_QUOTA_INFORMATION failed: %s\n",
+                          nt_errstr(status)));
+        }
+        return status;
+}

vendor/current/source3/libsmb/clirap.c

-              r414
+              r740
 #include "includes.h"
 #include "../libcli/auth/libcli_auth.h"
+#include "../librpc/gen_ndr/rap.h"
+#include "../lib/crypto/arcfour.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
+#include "trans2.h"
+#define PIPE_LANMAN   "\\PIPE\\LANMAN"
 /****************************************************************************
 …
              char **rdata, unsigned int *rdrcnt)
+{
+        cli_send_trans(cli,SMBtrans,
+                 PIPE_LANMAN,             /* Name */
+,0,                     /* fid, flags */
+                 NULL,0,0,                /* Setup, length, max */
+                 param, prcnt, mprcnt,    /* Params, length, max */
+                 data, drcnt, mdrcnt      /* Data, length, max */
+                );
+        return (cli_receive_trans(cli,SMBtrans,
+                            rparam, rprcnt,
+                            rdata, rdrcnt));
+        NTSTATUS status;
+        uint8_t *my_rparam, *my_rdata;
+        uint32_t num_my_rparam, num_my_rdata;
+        status = cli_trans(talloc_tos(), cli, SMBtrans,
+                           PIPE_LANMAN, 0, /* name, fid */
+, 0,           /* function, flags */
+                           NULL, 0, 0,     /* setup */
+                           (uint8_t *)param, prcnt, mprcnt, /* Params, length, max */
+                           (uint8_t *)data, drcnt, mdrcnt,  /* Data, length, max */
+                           NULL,                 /* recv_flags2 */
+                           NULL, 0, NULL,        /* rsetup */
+                           &my_rparam, 0, &num_my_rparam,
+                           &my_rdata, 0, &num_my_rdata);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        /*
+         * I know this memcpy massively hurts, but there are just tons
+         * of callers of cli_api that eventually need changing to
+         * talloc
+         */
+        *rparam = (char *)memdup(my_rparam, num_my_rparam);
+        if (*rparam == NULL) {
+                goto fail;
+        }
+        *rprcnt = num_my_rparam;
+        TALLOC_FREE(my_rparam);
+        *rdata = (char *)memdup(my_rdata, num_my_rdata);
+        if (*rdata == NULL) {
+                goto fail;
+        }
+        *rdrcnt = num_my_rdata;
+        TALLOC_FREE(my_rdata);
+        return true;
+fail:
+        TALLOC_FREE(my_rdata);
+        TALLOC_FREE(my_rparam);
+        *rparam = NULL;
+        *rprcnt = 0;
+        *rdata = NULL;
+        *rdrcnt = 0;
+        return false;
+}
 …
         data_len = 532;
+        if (cli_send_trans(cli,SMBtrans,
+                    PIPE_LANMAN,                          /* name */
+,0,                                  /* fid, flags */
+                    NULL,0,0,                             /* setup, length, max */
+                    param,param_len,2,                    /* param, length, max */
+                    (char *)data,data_len,0                       /* data, length, max */
+                   ) == False) {
+        if (!cli_api(cli,
+                     param, param_len, 4,               /* param, length, max */
+                     (char *)data, data_len, 0,         /* data, length, max */
+                     &rparam, &rprcnt,
+                     &rdata, &rdrcnt)) {
                 DEBUG(0,("cli_oem_change_password: Failed to send password change for user %s\n",
                         user ));
 …
+        }
-        if (!cli_receive_trans(cli,SMBtrans,
-                       &rparam, &rprcnt,
-                       &rdata, &rdrcnt)) {
-                DEBUG(0,("cli_oem_change_password: Failed to recieve reply to password change for user %s\n",
-                        user ));
-                return False;
+        }
         if (rparam) {
                 cli->rap_error = SVAL(rparam,0);
 …
 ****************************************************************************/
+bool cli_qpathinfo(struct cli_state *cli,
+struct cli_qpathinfo1_state {
+        struct cli_state *cli;
+        uint32_t num_data;
+        uint8_t *data;
+};
+static void cli_qpathinfo1_done(struct tevent_req *subreq);
+struct tevent_req *cli_qpathinfo1_send(TALLOC_CTX *mem_ctx,
+                                       struct event_context *ev,
+                                       struct cli_state *cli,
+                                       const char *fname)
+{
+        struct tevent_req *req = NULL, *subreq = NULL;
+        struct cli_qpathinfo1_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo1_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->cli = cli;
+        subreq = cli_qpathinfo_send(state, ev, cli, fname, SMB_INFO_STANDARD,
+, cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_qpathinfo1_done, req);
+        return req;
+}
+static void cli_qpathinfo1_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_qpathinfo1_state *state = tevent_req_data(
+                req, struct cli_qpathinfo1_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_qpathinfo1_recv(struct tevent_req *req,
+                             time_t *change_time,
+                             time_t *access_time,
+                             time_t *write_time,
+                             SMB_OFF_T *size,
+                             uint16 *mode)
+{
+        struct cli_qpathinfo1_state *state = tevent_req_data(
+                req, struct cli_qpathinfo1_state);
+        NTSTATUS status;
+        time_t (*date_fn)(const void *buf, int serverzone);
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (state->cli->win95) {
+                date_fn = make_unix_date;
+        } else {
+                date_fn = make_unix_date2;
+        }
+        if (change_time) {
+                *change_time = date_fn(state->data+0, state->cli->serverzone);
+        }
+        if (access_time) {
+                *access_time = date_fn(state->data+4, state->cli->serverzone);
+        }
+        if (write_time) {
+                *write_time = date_fn(state->data+8, state->cli->serverzone);
+        }
+        if (size) {
+                *size = IVAL(state->data, 12);
+        }
+        if (mode) {
+                *mode = SVAL(state->data, l1_attrFile);
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_qpathinfo1(struct cli_state *cli,
                         const char *fname,
                         time_t *change_time,
 …
                         uint16 *mode)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        unsigned int rparam_len, rdata_len;
+        uint16 setup = TRANSACT2_QPATHINFO;
+        char *param;
+        char *rparam=NULL, *rdata=NULL;
+        int count=8;
+        bool ret;
+        time_t (*date_fn)(struct cli_state *, const void *);
+        char *p;
+        size_t nlen = 2*(strlen(fname)+1);
+        param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
+        if (!param) {
+                return false;
+        }
+        p = param;
+        memset(p, '\0', 6);
+        SSVAL(p, 0, SMB_INFO_STANDARD);
+        p += 6;
+        p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
+        param_len = PTR_DIFF(p, param);
+        do {
+                ret = (cli_send_trans(cli, SMBtrans2,
+                                      NULL,           /* Name */
+                                      -1, 0,          /* fid, flags */
+                                      &setup, 1, 0,   /* setup, length, max */
+                                      param, param_len, 10, /* param, length, max */
+                                      NULL, data_len, cli->max_xmit /* data, length, max */
+                                      ) &&
+                       cli_receive_trans(cli, SMBtrans2,
+                                         &rparam, &rparam_len,
+                                         &rdata, &rdata_len));
+                if (!cli_is_dos_error(cli)) break;
+                if (!ret) {
+                        /* we need to work around a Win95 bug - sometimes
+                           it gives ERRSRV/ERRerror temprarily */
+                        uint8 eclass;
+                        uint32 ecode;
+                        cli_dos_error(cli, &eclass, &ecode);
+                        if (eclass != ERRSRV || ecode != ERRerror) break;
+                        smb_msleep(100);
+                }
+        } while (count-- && ret==False);
+        SAFE_FREE(param);
+        if (!ret || !rdata || rdata_len < 22) {
+                return False;
+        }
+        if (cli->win95) {
+                date_fn = cli_make_unix_date;
+        } else {
+                date_fn = cli_make_unix_date2;
+        }
+        if (change_time) {
+                *change_time = date_fn(cli, rdata+0);
+        }
+        if (access_time) {
+                *access_time = date_fn(cli, rdata+4);
+        }
+        if (write_time) {
+                *write_time = date_fn(cli, rdata+8);
+        }
+        if (size) {
+                *size = IVAL(rdata, 12);
+        }
+        if (mode) {
+                *mode = SVAL(rdata,l1_attrFile);
+        }
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return True;
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_qpathinfo1_send(frame, ev, cli, fname);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_qpathinfo1_recv(req, change_time, access_time,
+                                     write_time, size, mode);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
 ****************************************************************************/
 bool cli_setpathinfo(struct cli_state *cli, const char *fname,
                      time_t create_time,
                      time_t access_time,
                      time_t write_time,
                      time_t change_time,
                      uint16 mode)
+NTSTATUS cli_setpathinfo_basic(struct cli_state *cli, const char *fname,
+                               time_t create_time,
+                               time_t access_time,
+                               time_t write_time,
+                               time_t change_time,
+                               uint16 mode)
+{
         unsigned int data_len = 0;
-        unsigned int param_len = 0;
-        unsigned int rparam_len, rdata_len;
-        uint16 setup = TRANSACT2_SETPATHINFO;
-        char *param;
         char data[40];
-        char *rparam=NULL, *rdata=NULL;
-        int count=8;
-        bool ret;
         char *p;
-        size_t nlen = 2*(strlen(fname)+1);
-        param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
-        if (!param) {
-                return false;
+        }
-        memset(param, '\0', 6);
-        memset(data, 0, sizeof(data));
-        p = param;
-        /* Add the information level */
-        SSVAL(p, 0, SMB_FILE_BASIC_INFORMATION);
-        /* Skip reserved */
-        p += 6;
-        /* Add the file name */
-        p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
-        param_len = PTR_DIFF(p, param);
         p = data;
 …
         data_len = PTR_DIFF(p, data);
+        do {
+                ret = (cli_send_trans(cli, SMBtrans2,
+                                      NULL,           /* Name */
+                                      -1, 0,          /* fid, flags */
+                                      &setup, 1, 0,   /* setup, length, max */
+                                      param, param_len, 10, /* param, length, max */
+                                      data, data_len, cli->max_xmit /* data, length, max */
+                                      ) &&
+                       cli_receive_trans(cli, SMBtrans2,
+                                         &rparam, &rparam_len,
+                                         &rdata, &rdata_len));
+                if (!cli_is_dos_error(cli)) break;
+                if (!ret) {
+                        /* we need to work around a Win95 bug - sometimes
+                           it gives ERRSRV/ERRerror temprarily */
+                        uint8 eclass;
+                        uint32 ecode;
+                        cli_dos_error(cli, &eclass, &ecode);
+                        if (eclass != ERRSRV || ecode != ERRerror) break;
+                        smb_msleep(100);
+                }
+        } while (count-- && ret==False);
+        SAFE_FREE(param);
+        if (!ret) {
+                return False;
+        }
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return True;
+        return cli_setpathinfo(cli, SMB_FILE_BASIC_INFORMATION, fname,
+                               (uint8_t *)data, data_len);
+}
 …
 ****************************************************************************/
+bool cli_qpathinfo2(struct cli_state *cli, const char *fname,
+                    struct timespec *create_time,
+                    struct timespec *access_time,
+                    struct timespec *write_time,
+                    struct timespec *change_time,
+                    SMB_OFF_T *size, uint16 *mode,
+                    SMB_INO_T *ino)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        uint16 setup = TRANSACT2_QPATHINFO;
+        char *param;
+        char *rparam=NULL, *rdata=NULL;
+        char *p;
+        size_t nlen = 2*(strlen(fname)+1);
+        param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
+        if (!param) {
+                return false;
+        }
+        p = param;
+        memset(param, '\0', 6);
+        SSVAL(p, 0, SMB_QUERY_FILE_ALL_INFO);
+        p += 6;
+        p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
+        param_len = PTR_DIFF(p, param);
+        if (!cli_send_trans(cli, SMBtrans2,
+                            NULL,                         /* name */
+                            -1, 0,                        /* fid, flags */
+                            &setup, 1, 0,                 /* setup, length, max */
+                            param, param_len, 10,         /* param, length, max */
+                            NULL, data_len, cli->max_xmit /* data, length, max */
+                           )) {
+                SAFE_FREE(param);
+                return False;
+        }
+        SAFE_FREE(param);
+        if (!cli_receive_trans(cli, SMBtrans2,
+                               &rparam, &param_len,
+                               &rdata, &data_len)) {
+                return False;
+        }
+        if (!rdata || data_len < 22) {
+                return False;
+struct cli_qpathinfo2_state {
+        uint32_t num_data;
+        uint8_t *data;
+};
+static void cli_qpathinfo2_done(struct tevent_req *subreq);
+struct tevent_req *cli_qpathinfo2_send(TALLOC_CTX *mem_ctx,
+                                       struct event_context *ev,
+                                       struct cli_state *cli,
+                                       const char *fname)
+{
+        struct tevent_req *req = NULL, *subreq = NULL;
+        struct cli_qpathinfo2_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state, struct cli_qpathinfo2_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        subreq = cli_qpathinfo_send(state, ev, cli, fname,
+                                    SMB_QUERY_FILE_ALL_INFO,
+, cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_qpathinfo2_done, req);
+        return req;
+}
+static void cli_qpathinfo2_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_qpathinfo2_state *state = tevent_req_data(
+                req, struct cli_qpathinfo2_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_qpathinfo2_recv(struct tevent_req *req,
+                             struct timespec *create_time,
+                             struct timespec *access_time,
+                             struct timespec *write_time,
+                             struct timespec *change_time,
+                             SMB_OFF_T *size, uint16 *mode,
+                             SMB_INO_T *ino)
+{
+        struct cli_qpathinfo2_state *state = tevent_req_data(
+                req, struct cli_qpathinfo2_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
         if (create_time) {
                 *create_time = interpret_long_date(rdata+0);
+                *create_time = interpret_long_date((char *)state->data+0);
+        }
         if (access_time) {
                 *access_time = interpret_long_date(rdata+8);
+                *access_time = interpret_long_date((char *)state->data+8);
+        }
         if (write_time) {
                 *write_time = interpret_long_date(rdata+16);
+                *write_time = interpret_long_date((char *)state->data+16);
+        }
         if (change_time) {
                 *change_time = interpret_long_date(rdata+24);
+                *change_time = interpret_long_date((char *)state->data+24);
+        }
         if (mode) {
                 *mode = SVAL(rdata, 32);
+                *mode = SVAL(state->data, 32);
+        }
         if (size) {
                 *size = IVAL2_TO_SMB_BIG_UINT(rdata,48);
+                *size = IVAL2_TO_SMB_BIG_UINT(state->data,48);
+        }
         if (ino) {
+                *ino = IVAL(rdata, 64);
+        }
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return True;
+                *ino = IVAL(state->data, 64);
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_qpathinfo2(struct cli_state *cli, const char *fname,
+                        struct timespec *create_time,
+                        struct timespec *access_time,
+                        struct timespec *write_time,
+                        struct timespec *change_time,
+                        SMB_OFF_T *size, uint16 *mode,
+                        SMB_INO_T *ino)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_qpathinfo2_send(frame, ev, cli, fname);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_qpathinfo2_recv(req, create_time, access_time,
+                                     write_time, change_time, size, mode, ino);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
 ****************************************************************************/
+bool cli_qpathinfo_streams(struct cli_state *cli, const char *fname,
+                           TALLOC_CTX *mem_ctx,
+                           unsigned int *pnum_streams,
+                           struct stream_struct **pstreams)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        uint16 setup = TRANSACT2_QPATHINFO;
+        char *param;
+        char *rparam=NULL, *rdata=NULL;
+        char *p;
+static bool parse_streams_blob(TALLOC_CTX *mem_ctx, const uint8_t *data,
+                               size_t data_len,
+                               unsigned int *pnum_streams,
+                               struct stream_struct **pstreams);
+struct cli_qpathinfo_streams_state {
+        uint32_t num_data;
+        uint8_t *data;
+};
+static void cli_qpathinfo_streams_done(struct tevent_req *subreq);
+struct tevent_req *cli_qpathinfo_streams_send(TALLOC_CTX *mem_ctx,
+                                              struct tevent_context *ev,
+                                              struct cli_state *cli,
+                                              const char *fname)
+{
+        struct tevent_req *req = NULL, *subreq = NULL;
+        struct cli_qpathinfo_streams_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_qpathinfo_streams_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        subreq = cli_qpathinfo_send(state, ev, cli, fname,
+                                    SMB_FILE_STREAM_INFORMATION,
+, cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_qpathinfo_streams_done, req);
+        return req;
+}
+static void cli_qpathinfo_streams_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_qpathinfo_streams_state *state = tevent_req_data(
+                req, struct cli_qpathinfo_streams_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_qpathinfo_streams_recv(struct tevent_req *req,
+                                    TALLOC_CTX *mem_ctx,
+                                    unsigned int *pnum_streams,
+                                    struct stream_struct **pstreams)
+{
+        struct cli_qpathinfo_streams_state *state = tevent_req_data(
+                req, struct cli_qpathinfo_streams_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (!parse_streams_blob(mem_ctx, state->data, state->num_data,
+                                pnum_streams, pstreams)) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_qpathinfo_streams(struct cli_state *cli, const char *fname,
+                               TALLOC_CTX *mem_ctx,
+                               unsigned int *pnum_streams,
+                               struct stream_struct **pstreams)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_qpathinfo_streams_send(frame, ev, cli, fname);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_qpathinfo_streams_recv(req, mem_ctx, pnum_streams,
+                                            pstreams);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
+static bool parse_streams_blob(TALLOC_CTX *mem_ctx, const uint8_t *rdata,
+                               size_t data_len,
+                               unsigned int *pnum_streams,
+                               struct stream_struct **pstreams)
+{
         unsigned int num_streams;
         struct stream_struct *streams;
         unsigned int ofs;
-        size_t namelen = 2*(strlen(fname)+1);
-        param = SMB_MALLOC_ARRAY(char, 6+namelen+2);
-        if (param == NULL) {
-                return false;
+        }
-        p = param;
-        memset(p, 0, 6);
-        SSVAL(p, 0, SMB_FILE_STREAM_INFORMATION);
-        p += 6;
-        p += clistr_push(cli, p, fname, namelen, STR_TERMINATE);
-        param_len = PTR_DIFF(p, param);
-        if (!cli_send_trans(cli, SMBtrans2,
-                            NULL,                     /* name */
-                            -1, 0,                    /* fid, flags */
-                            &setup, 1, 0,             /* setup, len, max */
-                            param, param_len, 10,     /* param, len, max */
-                            NULL, data_len, cli->max_xmit /* data, len, max */
-                           )) {
-                return false;
+        }
-        if (!cli_receive_trans(cli, SMBtrans2,
-                               &rparam, &param_len,
-                               &rdata, &data_len)) {
-                return false;
+        }
-        if (!rdata) {
-                SAFE_FREE(rparam);
-                return false;
+        }
         num_streams = 0;
 …
+        }
-        SAFE_FREE(rdata);
-        SAFE_FREE(rparam);
         *pnum_streams = num_streams;
         *pstreams = streams;
 …
  fail:
         TALLOC_FREE(streams);
-        SAFE_FREE(rdata);
-        SAFE_FREE(rparam);
         return false;
+}
 …
 ****************************************************************************/
+bool cli_qfilename(struct cli_state *cli, uint16_t fnum, char *name, size_t namelen)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        uint16 setup = TRANSACT2_QFILEINFO;
+        char param[4];
+        char *rparam=NULL, *rdata=NULL;
+        param_len = 4;
+        SSVAL(param, 0, fnum);
+        SSVAL(param, 2, SMB_QUERY_FILE_NAME_INFO);
+        if (!cli_send_trans(cli, SMBtrans2,
+                            NULL,                         /* name */
+                            -1, 0,                        /* fid, flags */
+                            &setup, 1, 0,                 /* setup, length, max */
+                            param, param_len, 2,          /* param, length, max */
+                            NULL, data_len, cli->max_xmit /* data, length, max */
+                           )) {
+                return False;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                               &rparam, &param_len,
+                               &rdata, &data_len)) {
+                return False;
+        }
+        if (!rdata || data_len < 4) {
+                SAFE_FREE(rparam);
+                SAFE_FREE(rdata);
+                return False;
+NTSTATUS cli_qfilename(struct cli_state *cli, uint16_t fnum, char *name,
+                       size_t namelen)
+{
+        uint8_t *rdata;
+        uint32_t num_rdata;
+        NTSTATUS status;
+        status = cli_qfileinfo(talloc_tos(), cli, fnum,
+                               SMB_QUERY_FILE_NAME_INFO,
+, cli->max_xmit,
+                               &rdata, &num_rdata);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         clistr_pull(cli->inbuf, name, rdata+4, namelen, IVAL(rdata, 0),
                     STR_UNICODE);
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return True;
+        TALLOC_FREE(rdata);
+        return NT_STATUS_OK;
+}
 …
 ****************************************************************************/
+bool cli_qfileinfo(struct cli_state *cli, uint16_t fnum,
+                   uint16 *mode, SMB_OFF_T *size,
+                   struct timespec *create_time,
+                   struct timespec *access_time,
+                   struct timespec *write_time,
+                   struct timespec *change_time,
+                   SMB_INO_T *ino)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        uint16 setup;
+        uint8_t param[4];
+        uint8_t *rparam=NULL, *rdata=NULL;
+NTSTATUS cli_qfileinfo_basic(struct cli_state *cli, uint16_t fnum,
+                             uint16 *mode, SMB_OFF_T *size,
+                             struct timespec *create_time,
+                             struct timespec *access_time,
+                             struct timespec *write_time,
+                             struct timespec *change_time,
+                             SMB_INO_T *ino)
+{
+        uint8_t *rdata;
+        uint32_t num_rdata;
         NTSTATUS status;
         /* if its a win95 server then fail this - win95 totally screws it
            up */
+        if (cli->win95) return False;
+        param_len = 4;
+        SSVAL(param, 0, fnum);
+        SSVAL(param, 2, SMB_QUERY_FILE_ALL_INFO);
+        SSVAL(&setup, 0, TRANSACT2_QFILEINFO);
+        status = cli_trans(talloc_tos(), cli, SMBtrans2,
+                           NULL, -1, 0, 0, /* name, fid, function, flags */
+                           &setup, 1, 0,          /* setup, length, max */
+                           param, param_len, 2,   /* param, length, max */
+                           NULL, 0, MIN(cli->max_xmit, 0xffff), /* data, length, max */
+                           NULL, NULL, /* rsetup, length */
+                           &rparam, &param_len, /* rparam, length */
+                           &rdata, &data_len);
+        if (cli->win95) {
+                return NT_STATUS_NOT_SUPPORTED;
+        }
+        status = cli_qfileinfo(talloc_tos(), cli, fnum,
+                               SMB_QUERY_FILE_ALL_INFO,
+, MIN(cli->max_xmit, 0xffff),
+                               &rdata, &num_rdata);
         if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        if (!rdata || data_len < 68) {
+                return False;
+                return status;
+        }
 …
         TALLOC_FREE(rdata);
+        TALLOC_FREE(rparam);
+        return True;
+        return NT_STATUS_OK;
+}
 …
 ****************************************************************************/
+bool cli_qpathinfo_basic( struct cli_state *cli, const char *name,
+                          SMB_STRUCT_STAT *sbuf, uint32 *attributes )
+{
+        unsigned int param_len = 0;
+        unsigned int data_len = 0;
+        uint16 setup = TRANSACT2_QPATHINFO;
+        char *param;
+        char *rparam=NULL, *rdata=NULL;
+        char *p;
+        char *path;
+        int len;
+        size_t nlen;
+struct cli_qpathinfo_basic_state {
+        uint32_t num_data;
+        uint8_t *data;
+};
+static void cli_qpathinfo_basic_done(struct tevent_req *subreq);
+struct tevent_req *cli_qpathinfo_basic_send(TALLOC_CTX *mem_ctx,
+                                            struct event_context *ev,
+                                            struct cli_state *cli,
+                                            const char *fname)
+{
+        struct tevent_req *req = NULL, *subreq = NULL;
+        struct cli_qpathinfo_basic_state *state = NULL;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct cli_qpathinfo_basic_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        subreq = cli_qpathinfo_send(state, ev, cli, fname,
+                                    SMB_QUERY_FILE_BASIC_INFO,
+, cli->max_xmit);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, cli_qpathinfo_basic_done, req);
+        return req;
+}
+static void cli_qpathinfo_basic_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct cli_qpathinfo_basic_state *state = tevent_req_data(
+                req, struct cli_qpathinfo_basic_state);
+        NTSTATUS status;
+        status = cli_qpathinfo_recv(subreq, state, &state->data,
+                                    &state->num_data);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS cli_qpathinfo_basic_recv(struct tevent_req *req,
+                                  SMB_STRUCT_STAT *sbuf, uint32 *attributes)
+{
+        struct cli_qpathinfo_basic_state *state = tevent_req_data(
+                req, struct cli_qpathinfo_basic_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        sbuf->st_ex_atime = interpret_long_date((char *)state->data+8);
+        sbuf->st_ex_mtime = interpret_long_date((char *)state->data+16);
+        sbuf->st_ex_ctime = interpret_long_date((char *)state->data+24);
+        *attributes = IVAL(state->data, 32);
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_qpathinfo_basic(struct cli_state *cli, const char *name,
+                             SMB_STRUCT_STAT *sbuf, uint32 *attributes)
+{
         TALLOC_CTX *frame = talloc_stackframe();
+        path = talloc_strdup(frame, name);
+        if (!path) {
+                TALLOC_FREE(frame);
+                return false;
+        }
+        /* cleanup */
+        len = strlen(path);
+        if ( path[len-1] == '\\' || path[len-1] == '/') {
+                path[len-1] = '\0';
+        }
+        nlen = 2*(strlen(path)+1);
+        param = TALLOC_ARRAY(frame,char,6+nlen+2);
+        if (!param) {
+                return false;
+        }
+        p = param;
+        memset(param, '\0', 6);
+        SSVAL(p, 0, SMB_QUERY_FILE_BASIC_INFO);
+        p += 6;
+        p += clistr_push(cli, p, path, nlen, STR_TERMINATE);
+        param_len = PTR_DIFF(p, param);
+        if (!cli_send_trans(cli, SMBtrans2,
+                        NULL,                        /* name */
+                        -1, 0,                       /* fid, flags */
+                        &setup, 1, 0,                /* setup, length, max */
+                        param, param_len, 2,         /* param, length, max */
+                        NULL,  0, cli->max_xmit      /* data, length, max */
+                        )) {
+                TALLOC_FREE(frame);
+                return False;
+        }
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_qpathinfo_basic_send(frame, ev, cli, name);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = cli_qpathinfo_basic_recv(req, sbuf, attributes);
+ fail:
         TALLOC_FREE(frame);
+        if (!cli_receive_trans(cli, SMBtrans2,
+                &rparam, &param_len,
+                &rdata, &data_len)) {
+                        return False;
+        }
+        if (data_len < 36) {
+                SAFE_FREE(rdata);
+                SAFE_FREE(rparam);
+                return False;
+        }
+        sbuf->st_ex_atime = interpret_long_date( rdata+8 ); /* Access time. */
+        sbuf->st_ex_mtime = interpret_long_date( rdata+16 ); /* Write time. */
+        sbuf->st_ex_ctime = interpret_long_date( rdata+24 ); /* Change time. */
+        *attributes = IVAL( rdata, 32 );
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        return True;
+}
+/****************************************************************************
+ Send a qfileinfo call.
+****************************************************************************/
+bool cli_qfileinfo_test(struct cli_state *cli, uint16_t fnum, int level, char **poutdata, uint32 *poutlen)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        uint16 setup = TRANSACT2_QFILEINFO;
+        char param[4];
+        char *rparam=NULL, *rdata=NULL;
+        *poutdata = NULL;
+        *poutlen = 0;
+        /* if its a win95 server then fail this - win95 totally screws it
+           up */
+        if (cli->win95)
+                return False;
+        param_len = 4;
+        SSVAL(param, 0, fnum);
+        SSVAL(param, 2, level);
+        if (!cli_send_trans(cli, SMBtrans2,
+                            NULL,                           /* name */
+                            -1, 0,                          /* fid, flags */
+                            &setup, 1, 0,                   /* setup, length, max */
+                            param, param_len, 2,            /* param, length, max */
+                            NULL, data_len, cli->max_xmit   /* data, length, max */
+                           )) {
+                return False;
+        }
+        if (!cli_receive_trans(cli, SMBtrans2,
+                               &rparam, &param_len,
+                               &rdata, &data_len)) {
+                return False;
+        }
+        *poutdata = (char *)memdup(rdata, data_len);
+        if (!*poutdata) {
+                SAFE_FREE(rdata);
+                SAFE_FREE(rparam);
+                return False;
+        }
+        *poutlen = data_len;
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        return True;
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
 NTSTATUS cli_qpathinfo_alt_name(struct cli_state *cli, const char *fname, fstring alt_name)
+{
+        unsigned int data_len = 0;
+        unsigned int param_len = 0;
+        uint16 setup = TRANSACT2_QPATHINFO;
+        char *param;
+        char *rparam=NULL, *rdata=NULL;
+        int count=8;
+        char *p;
+        bool ret;
+        uint8_t *rdata;
+        uint32_t num_rdata;
         unsigned int len;
+        size_t nlen = 2*(strlen(fname)+1);
+        param = SMB_MALLOC_ARRAY(char, 6+nlen+2);
+        if (!param) {
+        char *converted = NULL;
+        size_t converted_size = 0;
+        NTSTATUS status;
+        status = cli_qpathinfo(talloc_tos(), cli, fname,
+                               SMB_QUERY_FILE_ALT_NAME_INFO,
+, cli->max_xmit, &rdata, &num_rdata);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        len = IVAL(rdata, 0);
+        if (len > num_rdata - 4) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        /* The returned data is a pushed string, not raw data. */
+        if (!convert_string_talloc(talloc_tos(),
+                                   cli_ucs2(cli) ? CH_UTF16LE : CH_DOS,
+                                   CH_UNIX,
+                                   rdata + 4,
+                                   len,
+                                   &converted,
+                                   &converted_size,
+                                   true)) {
                 return NT_STATUS_NO_MEMORY;
+        }
+        p = param;
+        memset(param, '\0', 6);
+        SSVAL(p, 0, SMB_QUERY_FILE_ALT_NAME_INFO);
+        p += 6;
+        p += clistr_push(cli, p, fname, nlen, STR_TERMINATE);
+        param_len = PTR_DIFF(p, param);
+        do {
+                ret = (cli_send_trans(cli, SMBtrans2,
+                                      NULL,           /* Name */
+                                      -1, 0,          /* fid, flags */
+                                      &setup, 1, 0,   /* setup, length, max */
+                                      param, param_len, 10, /* param, length, max */
+                                      NULL, data_len, cli->max_xmit /* data, length, max */
+                                      ) &&
+                       cli_receive_trans(cli, SMBtrans2,
+                                         &rparam, &param_len,
+                                         &rdata, &data_len));
+                if (!ret && cli_is_dos_error(cli)) {
+                        /* we need to work around a Win95 bug - sometimes
+                           it gives ERRSRV/ERRerror temprarily */
+                        uint8 eclass;
+                        uint32 ecode;
+                        cli_dos_error(cli, &eclass, &ecode);
+                        if (eclass != ERRSRV || ecode != ERRerror) break;
+                        smb_msleep(100);
+                }
+        } while (count-- && ret==False);
+        SAFE_FREE(param);
+        if (!ret || !rdata || data_len < 4) {
+                return NT_STATUS_UNSUCCESSFUL;
+        }
+        len = IVAL(rdata, 0);
+        if (len > data_len - 4) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        clistr_pull(cli->inbuf, alt_name, rdata+4, sizeof(fstring), len,
+                    STR_UNICODE);
+        SAFE_FREE(rdata);
+        SAFE_FREE(rparam);
+        fstrcpy(alt_name, converted);
+        TALLOC_FREE(converted);
+        TALLOC_FREE(rdata);
         return NT_STATUS_OK;

vendor/current/source3/libsmb/clirap2.c

-              r597
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../librpc/gen_ndr/rap.h"
+#include "../librpc/gen_ndr/svcctl.h"
+#include "libsmb/clirap.h"
 #define WORDSIZE 2
 …
 ****************************************************************************/
 int cli_NetGroupAdd(struct cli_state *cli, RAP_GROUP_INFO_1 *grinfo)
+int cli_NetGroupAdd(struct cli_state *cli, struct rap_group_info_1 *grinfo)
+{
         char *rparam = NULL;
 …
         p = data;
         PUTSTRINGF(p, grinfo->group_name, RAP_GROUPNAME_LEN);
+        PUTSTRINGF(p, (const char *)grinfo->group_name, RAP_GROUPNAME_LEN);
         PUTBYTE(p, 0); /* pad byte 0 */
         PUTSTRINGP(p, grinfo->comment, data, soffset);
 …
 ****************************************************************************/
 int cli_NetUserAdd(struct cli_state *cli, RAP_USER_INFO_1 * userinfo )
+int cli_NetUserAdd(struct cli_state *cli, struct rap_user_info_1 * userinfo )
+{
         char *rparam = NULL;
 …
         PUTWORD(p, 0); /* pwencrypt */
         if(userinfo->passwrd)
                 PUTWORD(p,MIN(strlen(userinfo->passwrd), RAP_UPASSWD_LEN));
+                PUTWORD(p,MIN(strlen((const char *)userinfo->passwrd), RAP_UPASSWD_LEN));
         else
                 PUTWORD(p, 0); /* password length */
 …
         memset(data, '\0', soffset);
         PUTSTRINGF(p, userinfo->user_name, RAP_USERNAME_LEN);
+        PUTSTRINGF(p, (const char *)userinfo->user_name, RAP_USERNAME_LEN);
         PUTBYTE(p, 0); /* pad byte 0 */
         PUTSTRINGF(p, userinfo->passwrd, RAP_UPASSWD_LEN);
+        PUTSTRINGF(p, (const char *)userinfo->passwrd, RAP_UPASSWD_LEN);
         PUTDWORD(p, 0); /* pw age - n.a. on user add */
         PUTWORD(p, userinfo->priv);
 …
 ****************************************************************************/
 int cli_NetShareAdd(struct cli_state *cli, RAP_SHARE_INFO_2 * sinfo )
+int cli_NetShareAdd(struct cli_state *cli, struct rap_share_info_2 * sinfo )
+{
         char *rparam = NULL;
 …
         p = data;
         PUTSTRINGF(p, sinfo->share_name, RAP_SHARENAME_LEN);
+        PUTSTRINGF(p, (const char *)sinfo->share_name, RAP_SHARENAME_LEN);
         PUTBYTE(p, 0); /* pad byte 0 */
 …
         PUTWORD(p, sinfo->active_users);
         PUTSTRINGP(p, sinfo->path, data, soffset);
         PUTSTRINGF(p, sinfo->password, RAP_SPASSWD_LEN);
+        PUTSTRINGF(p, (const char *)sinfo->password, RAP_SPASSWD_LEN);
         SCVAL(p,-1,0x0A); /* required 0x0A at end of password */
 …
 int cli_NetPrintQEnum(struct cli_state *cli,
                 void (*qfn)(const char*,uint16,uint16,uint16,const char*,const char*,const char*,const char*,const char*,uint16,uint16),
                 void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,uint_t,uint_t,const char*))
+                void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,unsigned int,unsigned int,const char*))
+{
         char param[WORDSIZE                         /* api number    */
 …
 int cli_NetPrintQGetInfo(struct cli_state *cli, const char *printer,
         void (*qfn)(const char*,uint16,uint16,uint16,const char*,const char*,const char*,const char*,const char*,uint16,uint16),
         void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,uint_t,uint_t,const char*))
+        void (*jfn)(uint16,const char*,const char*,const char*,const char*,uint16,uint16,const char*,unsigned int,unsigned int,const char*))
+{
         char param[WORDSIZE                         /* api number    */
 …
 ****************************************************************************/
 int cli_NetSessionEnum(struct cli_state *cli, void (*fn)(char *, char *, uint16, uint16, uint16, uint_t, uint_t, uint_t, char *))
+int cli_NetSessionEnum(struct cli_state *cli, void (*fn)(char *, char *, uint16, uint16, uint16, unsigned int, unsigned int, unsigned int, char *))
+{
         char param[WORDSIZE                       /* api number    */
 …
 int cli_NetSessionGetInfo(struct cli_state *cli, const char *workstation,
                 void (*fn)(const char *, const char *, uint16, uint16, uint16, uint_t, uint_t, uint_t, const char *))
+                void (*fn)(const char *, const char *, uint16, uint16, uint16, unsigned int, unsigned int, unsigned int, const char *))
+{
         char param[WORDSIZE                          /* api number    */

vendor/current/source3/libsmb/clireadwrite.c

-              r594
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
+#include "trans2.h"
 /****************************************************************************
 …
 static size_t cli_read_max_bufsize(struct cli_state *cli)
+{
+        size_t data_offset = smb_size - 4;
+        size_t wct = 12;
+        size_t useable_space;
         if (!client_is_signing_on(cli) && !cli_encryption_on(cli)
             && (cli->posix_capabilities & CIFS_UNIX_LARGE_READ_CAP)) {
+            && (cli->server_posix_capabilities & CIFS_UNIX_LARGE_READ_CAP)) {
                 return CLI_SAMBA_MAX_POSIX_LARGE_READX_SIZE;
+        }
 …
                         : CLI_WINDOWS_MAX_LARGE_READX_SIZE;
+        }
+        return (cli->max_xmit - (smb_size+32)) & ~1023;
+        data_offset += wct * sizeof(uint16_t);
+        data_offset += 1; /* pad */
+        useable_space = cli->max_xmit - data_offset;
+        return useable_space;
+}
 …
   Calculate the recommended write buffer size
 ****************************************************************************/
+static size_t cli_write_max_bufsize(struct cli_state *cli, uint16_t write_mode)
+static size_t cli_write_max_bufsize(struct cli_state *cli,
+                                    uint16_t write_mode,
+                                    uint8_t wct)
+{
         if (write_mode == 0 &&
             !client_is_signing_on(cli) &&
             !cli_encryption_on(cli) &&
             (cli->posix_capabilities & CIFS_UNIX_LARGE_WRITE_CAP) &&
+            (cli->server_posix_capabilities & CIFS_UNIX_LARGE_WRITE_CAP) &&
             (cli->capabilities & CAP_LARGE_FILES)) {
                 /* Only do massive writes if we can do them direct
 …
             || client_is_signing_on(cli)
             || strequal(cli->dev, "LPT1:")) {
+                /*
+                 * Printer devices are restricted to max_xmit writesize in
+                 * Vista and XPSP3 as are signing connections.
+                 */
+                return (cli->max_xmit - (smb_size+32)) & ~1023;
+                size_t data_offset = smb_size - 4;
+                size_t useable_space;
+                data_offset += wct * sizeof(uint16_t);
+                data_offset += 1; /* pad */
+                useable_space = cli->max_xmit - data_offset;
+                return useable_space;
+        }
 …
         struct tevent_req *req, *subreq;
         struct cli_read_andx_state *state;
-        bool bigoffset = False;
         uint8_t wct = 10;
 …
         if ((uint64_t)offset >> 32) {
-                bigoffset = true;
                 SIVAL(state->vwv + 10, 0,
                       (((uint64_t)offset)>>32) & 0xffffffff);
 …
         status = cli_smb_req_send(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return tevent_req_post(req, ev);
+        }
 …
         uint8_t *bytes;
+        state->status = cli_smb_recv(subreq, 12, &wct, &vwv, &num_bytes,
+                                     &bytes);
+        state->status = cli_smb_recv(subreq, state, &inbuf, 12, &wct, &vwv,
+                                     &num_bytes, &bytes);
+        TALLOC_FREE(subreq);
         if (NT_STATUS_IS_ERR(state->status)) {
                 tevent_req_nterror(req, state->status);
 …
+        }
-        inbuf = cli_smb_inbuf(subreq);
         state->buf = (uint8_t *)smb_base(inbuf) + SVAL(vwv+6, 0);
 …
         status = cli_read_andx_recv(subreq, &received, &buf);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
         char *result;
         result = tevent_req_print(mem_ctx, req);
+        result = tevent_req_default_print(req, mem_ctx);
         if (result == NULL) {
                 return NULL;
 …
                 status = state->sink((char *)top_subreq->buf,
                                      top_subreq->received, state->priv);
+                if (!NT_STATUS_IS_OK(status)) {
+                        tevent_req_nterror(state->req, status);
+                if (tevent_req_nterror(state->req, status)) {
                         return;
+                }
 …
 /****************************************************************************
- Issue a single SMBwrite and don't wait for a reply.
-****************************************************************************/
-static bool cli_issue_write(struct cli_state *cli,
-                                uint16_t fnum,
-                                off_t offset,
-                                uint16 mode,
-                                const char *buf,
-                                size_t size)
+{
-        char *p;
-        bool large_writex = false;
-        /* We can only do direct writes if not signing and not encrypting. */
-        bool direct_writes = !client_is_signing_on(cli) && !cli_encryption_on(cli);
-        if (!direct_writes && size + 1 > cli->bufsize) {
-                cli->outbuf = (char *)SMB_REALLOC(cli->outbuf, size + 1024);
-                if (!cli->outbuf) {
-                        return False;
+                }
-                cli->inbuf = (char *)SMB_REALLOC(cli->inbuf, size + 1024);
-                if (cli->inbuf == NULL) {
-                        SAFE_FREE(cli->outbuf);
-                        return False;
+                }
-                cli->bufsize = size + 1024;
+        }
-        memset(cli->outbuf,'\0',smb_size);
-        memset(cli->inbuf,'\0',smb_size);
-        if (cli->capabilities & CAP_LARGE_FILES) {
-                large_writex = True;
+        }
-        if (large_writex) {
-                cli_set_message(cli->outbuf,14,0,True);
-        } else {
-                cli_set_message(cli->outbuf,12,0,True);
+        }
-        SCVAL(cli->outbuf,smb_com,SMBwriteX);
-        SSVAL(cli->outbuf,smb_tid,cli->cnum);
-        cli_setup_packet(cli);
-        SCVAL(cli->outbuf,smb_vwv0,0xFF);
-        SSVAL(cli->outbuf,smb_vwv2,fnum);
-        SIVAL(cli->outbuf,smb_vwv3,offset);
-        SIVAL(cli->outbuf,smb_vwv5,0);
-        SSVAL(cli->outbuf,smb_vwv7,mode);
-        SSVAL(cli->outbuf,smb_vwv8,(mode & 0x0008) ? size : 0);
-        /*
-         * According to CIFS-TR-1p00, this following field should only
-         * be set if CAP_LARGE_WRITEX is set. We should check this
-         * locally. However, this check might already have been
-         * done by our callers.
-         */
-        SSVAL(cli->outbuf,smb_vwv9,(size>>16));
-        SSVAL(cli->outbuf,smb_vwv10,size);
-        /* +1 is pad byte. */
-        SSVAL(cli->outbuf,smb_vwv11,
-              smb_buf(cli->outbuf) - smb_base(cli->outbuf) + 1);
-        if (large_writex) {
-                SIVAL(cli->outbuf,smb_vwv12,(((uint64_t)offset)>>32) & 0xffffffff);
+        }
-        p = smb_base(cli->outbuf) + SVAL(cli->outbuf,smb_vwv11) -1;
-        *p++ = '\0'; /* pad byte. */
-        if (!direct_writes) {
-                memcpy(p, buf, size);
+        }
-        if (size > 0x1FFFF) {
-                /* This is a POSIX 14 word large write. */
-                set_message_bcc(cli->outbuf, 0); /* Set bcc to zero. */
-                _smb_setlen_large(cli->outbuf,smb_size + 28 + 1 /* pad */ + size - 4);
-        } else {
-                cli_setup_bcc(cli, p+size);
+        }
-        show_msg(cli->outbuf);
-        if (direct_writes) {
-                /* For direct writes we now need to write the data
-                 * directly out of buf. */
-                return cli_send_smb_direct_writeX(cli, buf, size);
-        } else {
-                return cli_send_smb(cli);
+        }
+}
-/****************************************************************************
-  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 cli_write(struct cli_state *cli,
-                 uint16_t fnum, uint16 write_mode,
-                 const char *buf, off_t offset, size_t size)
+{
-        ssize_t bwritten = 0;
-        unsigned int issued = 0;
-        unsigned int received = 0;
-        int mpx = 1;
-        size_t writesize;
-        int blocks;
-        if(cli->max_mux > 1) {
-                mpx = cli->max_mux-1;
-        } else {
-                mpx = 1;
+        }
-        writesize = cli_write_max_bufsize(cli, write_mode);
-        blocks = (size + (writesize-1)) / writesize;
-        while (received < blocks) {
-                while ((issued - received < mpx) && (issued < blocks)) {
-                        ssize_t bsent = issued * writesize;
-                        ssize_t size1 = MIN(writesize, size - bsent);
-                        if (!cli_issue_write(cli, fnum, offset + bsent,
-                                        write_mode,
-                                        buf + bsent,
-                                        size1))
-                                return -1;
-                        issued++;
+                }
-                if (!cli_receive_smb(cli)) {
-                        return bwritten;
+                }
-                received++;
-                if (cli_is_error(cli))
-                        break;
-                bwritten += SVAL(cli->inbuf, smb_vwv2);
-                if (writesize > 0xFFFF) {
-                        bwritten += (((int)(SVAL(cli->inbuf, smb_vwv4)))<<16);
+                }
+        }
-        while (received < issued && cli_receive_smb(cli)) {
-                received++;
+        }
-        return bwritten;
+}
-/****************************************************************************
   write to a file using a SMBwrite and not bypassing 0 byte writes
 ****************************************************************************/
 ssize_t cli_smbwrite(struct cli_state *cli,
                      uint16_t fnum, char *buf, off_t offset, size_t size1)
+{
         char *p;
+NTSTATUS cli_smbwrite(struct cli_state *cli, uint16_t fnum, char *buf,
+                      off_t offset, size_t size1, size_t *ptotal)
+{
+        uint8_t *bytes;
         ssize_t total = 0;
+        /*
+         * 3 bytes prefix
+         */
+        bytes = TALLOC_ARRAY(talloc_tos(), uint8_t, 3);
+        if (bytes == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        bytes[0] = 1;
         do {
                 size_t size = MIN(size1, cli->max_xmit - 48);
+                memset(cli->outbuf,'\0',smb_size);
+                memset(cli->inbuf,'\0',smb_size);
+                cli_set_message(cli->outbuf,5, 0,True);
+                SCVAL(cli->outbuf,smb_com,SMBwrite);
+                SSVAL(cli->outbuf,smb_tid,cli->cnum);
+                cli_setup_packet(cli);
+                SSVAL(cli->outbuf,smb_vwv0,fnum);
+                SSVAL(cli->outbuf,smb_vwv1,size);
+                SIVAL(cli->outbuf,smb_vwv2,offset);
+                SSVAL(cli->outbuf,smb_vwv4,0);
+                p = smb_buf(cli->outbuf);
+                *p++ = 1;
+                SSVAL(p, 0, size); p += 2;
+                memcpy(p, buf + total, size); p += size;
+                cli_setup_bcc(cli, p);
+                if (!cli_send_smb(cli))
+                        return -1;
+                if (!cli_receive_smb(cli))
+                        return -1;
+                if (cli_is_error(cli))
+                        return -1;
+                size = SVAL(cli->inbuf,smb_vwv0);
+                if (size == 0)
+                struct tevent_req *req;
+                uint16_t vwv[5];
+                uint16_t *ret_vwv;
+                NTSTATUS status;
+                SSVAL(vwv+0, 0, fnum);
+                SSVAL(vwv+1, 0, size);
+                SIVAL(vwv+2, 0, offset);
+                SSVAL(vwv+4, 0, 0);
+                bytes = TALLOC_REALLOC_ARRAY(talloc_tos(), bytes, uint8_t,
+                                             size+3);
+                if (bytes == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                SSVAL(bytes, 1, size);
+                memcpy(bytes + 3, buf + total, size);
+                status = cli_smb(talloc_tos(), cli, SMBwrite, 0, 5, vwv,
+                                 size+3, bytes, &req, 1, NULL, &ret_vwv,
+                                 NULL, NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        TALLOC_FREE(bytes);
+                        return status;
+                }
+                size = SVAL(ret_vwv+0, 0);
+                TALLOC_FREE(req);
+                if (size == 0) {
                         break;
+                }
                 size1 -= size;
                 total += size;
 …
         } while (size1);
+        return total;
+        TALLOC_FREE(bytes);
+        if (ptotal != NULL) {
+                *ptotal = total;
+        }
+        return NT_STATUS_OK;
+}
 …
         bool bigoffset = ((cli->capabilities & CAP_LARGE_FILES) != 0);
         uint8_t wct = bigoffset ? 14 : 12;
         size_t max_write = cli_write_max_bufsize(cli, mode);
+        size_t max_write = cli_write_max_bufsize(cli, mode, wct);
         uint16_t *vwv;
 …
         status = cli_smb_req_send(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return tevent_req_post(req, ev);
+        }
 …
         uint8_t wct;
         uint16_t *vwv;
+        NTSTATUS status;
+        status = cli_smb_recv(subreq, 6, &wct, &vwv, NULL, NULL);
+        uint8_t *inbuf;
+        NTSTATUS status;
+        status = cli_smb_recv(subreq, state, &inbuf, 6, &wct, &vwv,
+                              NULL, NULL);
+        TALLOC_FREE(subreq);
         if (NT_STATUS_IS_ERR(status)) {
-                TALLOC_FREE(subreq);
                 tevent_req_nterror(req, status);
                 return;
 …
         status = cli_write_andx_recv(subreq, &written);
         TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }
 …
+}
+static NTSTATUS cli_writeall_recv(struct tevent_req *req)
+{
+        return tevent_req_simple_recv_ntstatus(req);
+static NTSTATUS cli_writeall_recv(struct tevent_req *req,
+                                  size_t *pwritten)
+{
+        struct cli_writeall_state *state = tevent_req_data(
+                req, struct cli_writeall_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        if (pwritten != NULL) {
+                *pwritten = state->written;
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS cli_writeall(struct cli_state *cli, uint16_t fnum, uint16_t mode,
+                      const uint8_t *buf, off_t offset, size_t size,
+                      size_t *pwritten)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        if (cli_has_async_calls(cli)) {
+                /*
+                 * Can't use sync call while an async call is in flight
+                 */
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto fail;
+        }
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = cli_writeall_send(frame, ev, cli, fnum, mode, buf, offset, size);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll(req, ev)) {
+                status = map_nt_error_from_unix(errno);
+                goto fail;
+        }
+        status = cli_writeall_recv(req, pwritten);
+ fail:
+        TALLOC_FREE(frame);
+        if (!NT_STATUS_IS_OK(status)) {
+                cli_set_error(cli, status);
+        }
+        return status;
+}
 …
         state->next_offset = start_offset;
         state->chunk_size = cli_write_max_bufsize(cli, mode);
+        state->chunk_size = cli_write_max_bufsize(cli, mode, 14);
         if (window_size == 0) {
 …
         state->pending -= 1;
         status = cli_writeall_recv(subreq);
+        status = cli_writeall_recv(subreq, NULL);
         TALLOC_FREE(subreq);
         TALLOC_FREE(substate);
+        if (!NT_STATUS_IS_OK(status)) {
+                tevent_req_nterror(req, status);
+        if (tevent_req_nterror(req, status)) {
                 return;
+        }

vendor/current/source3/libsmb/clisecdesc.c

-              r414
+              r740
    client security descriptor functions
    Copyright (C) Andrew Tridgell 2000
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 /****************************************************************************
   query the security descriptor for a open file
  ****************************************************************************/
+SEC_DESC *cli_query_secdesc(struct cli_state *cli, uint16_t fnum,
+struct security_descriptor *cli_query_secdesc(struct cli_state *cli, uint16_t fnum,
                             TALLOC_CTX *mem_ctx)
+{
         uint8_t param[8];
         uint8_t *rparam=NULL, *rdata=NULL;
         unsigned int rparam_count=0, rdata_count=0;
         SEC_DESC *psd = NULL;
+        uint8_t *rdata=NULL;
+        uint32_t rdata_count=0;
+        struct security_descriptor *psd = NULL;
         NTSTATUS status;
 …
                            param, 8, 4, /* param, length, max */
                            NULL, 0, 0x10000, /* data, length, max */
+                           NULL, NULL, /* rsetup, length */
+                           &rparam, &rparam_count,
+                           &rdata, &rdata_count);
+                           NULL,             /* recv_flags2 */
+                           NULL, 0, NULL, /* rsetup, length */
+                           NULL, 0, NULL,
+                           &rdata, 0, &rdata_count);
         if (!NT_STATUS_IS_OK(status)) {
 …
  cleanup:
-        TALLOC_FREE(rparam);
         TALLOC_FREE(rdata);
 …
   set the security descriptor for a open file
  ****************************************************************************/
+bool cli_set_secdesc(struct cli_state *cli, uint16_t fnum, SEC_DESC *sd)
+NTSTATUS cli_set_secdesc(struct cli_state *cli, uint16_t fnum,
+                         struct security_descriptor *sd)
+{
+        char param[8];
+        char *rparam=NULL, *rdata=NULL;
+        unsigned int rparam_count=0, rdata_count=0;
+        uint8_t param[8];
         uint32 sec_info = 0;
-        TALLOC_CTX *frame = talloc_stackframe();
-        bool ret = False;
         uint8 *data;
         size_t len;
 …
                 DEBUG(10, ("marshall_sec_desc failed: %s\n",
                            nt_errstr(status)));
                 goto cleanup;
+                return status;
+        }
 …
         if (sd->dacl)
                 sec_info |= DACL_SECURITY_INFORMATION;
+                sec_info |= SECINFO_DACL;
         if (sd->owner_sid)
                 sec_info |= OWNER_SECURITY_INFORMATION;
+                sec_info |= SECINFO_OWNER;
         if (sd->group_sid)
                 sec_info |= GROUP_SECURITY_INFORMATION;
+                sec_info |= SECINFO_GROUP;
         SSVAL(param, 4, sec_info);
+        if (!cli_send_nt_trans(cli,
+                               NT_TRANSACT_SET_SECURITY_DESC,
+,
+                               NULL, 0, 0,
+                               param, 8, 0,
+                               (char *)data, len, 0)) {
+                DEBUG(1,("Failed to send NT_TRANSACT_SET_SECURITY_DESC\n"));
+                goto cleanup;
+        status = cli_trans(talloc_tos(), cli, SMBnttrans,
+                           NULL, -1, /* name, fid */
+                           NT_TRANSACT_SET_SECURITY_DESC, 0,
+                           NULL, 0, 0, /* setup */
+                           param, 8, 0, /* param */
+                           data, len, 0, /* data */
+                           NULL,         /* recv_flags2 */
+                           NULL, 0, NULL, /* rsetup */
+                           NULL, 0, NULL, /* rparam */
+                           NULL, 0, NULL); /* rdata */
+        TALLOC_FREE(data);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("Failed to send NT_TRANSACT_SET_SECURITY_DESC: %s\n",
+                          nt_errstr(status)));
+        }
+        if (!cli_receive_nt_trans(cli,
+                                  &rparam, &rparam_count,
+                                  &rdata, &rdata_count)) {
+                DEBUG(1,("NT_TRANSACT_SET_SECURITY_DESC failed\n"));
+                goto cleanup;
+        }
+        ret = True;
+  cleanup:
+        SAFE_FREE(rparam);
+        SAFE_FREE(rdata);
+        TALLOC_FREE(frame);
+        return ret;
+        return status;
+}

vendor/current/source3/libsmb/clisigning.c

r414	r740
21	21
22	22	#include "includes.h"
	23	#include "libsmb/libsmb.h"
	24	#include "smb_signing.h"
23	25
24	26	bool cli_simple_set_signing(struct cli_state *cli,

vendor/current/source3/libsmb/clispnego.c

-              r587
+              r740
    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002
    Copyright (C) Luke Howard     2003
+   Copyright (C) Jeremy Allison 2010
    This program is free software; you can redistribute it and/or modify
 …
 #include "../libcli/auth/spnego.h"
 #include "smb_krb5.h"
+/*
+  generate a negTokenInit packet given a GUID, a list of supported
+  OIDs (the mechanisms) and a principal name string
+*/
+DATA_BLOB spnego_gen_negTokenInit(char guid[16],
+                                  const char *OIDs[],
+#include "../lib/util/asn1.h"
+/*
+  generate a negTokenInit packet given a list of supported
+  OIDs (the mechanisms) a blob, and a principal name string
+*/
+DATA_BLOB spnego_gen_negTokenInit(TALLOC_CTX *ctx,
+                                  const char *OIDs[],
+                                  DATA_BLOB *psecblob,
                                   const char *principal)
+{
 …
+        }
-        asn1_write(data, guid, 16);
         asn1_push_tag(data,ASN1_APPLICATION(0));
         asn1_write_OID(data,OID_SPNEGO);
 …
         asn1_pop_tag(data);
+        asn1_push_tag(data, ASN1_CONTEXT(3));
+        asn1_push_tag(data, ASN1_SEQUENCE(0));
+        asn1_push_tag(data, ASN1_CONTEXT(0));
+        asn1_write_GeneralString(data,principal);
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        if (psecblob && psecblob->length && psecblob->data) {
+                asn1_push_tag(data, ASN1_CONTEXT(2));
+                asn1_write_OctetString(data,psecblob->data,
+                        psecblob->length);
+                asn1_pop_tag(data);
+        }
+        if (principal) {
+                asn1_push_tag(data, ASN1_CONTEXT(3));
+                asn1_push_tag(data, ASN1_SEQUENCE(0));
+                asn1_push_tag(data, ASN1_CONTEXT(0));
+                asn1_write_GeneralString(data,principal);
+                asn1_pop_tag(data);
+                asn1_pop_tag(data);
+                asn1_pop_tag(data);
+        }
         asn1_pop_tag(data);
 …
+        }
+        ret = data_blob(data->data, data->length);
+        asn1_free(data);
+        return ret;
+}
+/*
+  Generate a negTokenInit as used by the client side ... It has a mechType
+  (OID), and a mechToken (a security blob) ...
+  Really, we need to break out the NTLMSSP stuff as well, because it could be
+  raw in the packets!
+*/
+DATA_BLOB gen_negTokenInit(const char *OID, DATA_BLOB blob)
+{
+        ASN1_DATA *data;
+        DATA_BLOB ret;
+        data = asn1_init(talloc_tos());
+        if (data == NULL) {
+                return data_blob_null;
+        }
+        asn1_push_tag(data, ASN1_APPLICATION(0));
+        asn1_write_OID(data,OID_SPNEGO);
+        asn1_push_tag(data, ASN1_CONTEXT(0));
+        asn1_push_tag(data, ASN1_SEQUENCE(0));
+        asn1_push_tag(data, ASN1_CONTEXT(0));
+        asn1_push_tag(data, ASN1_SEQUENCE(0));
+        asn1_write_OID(data, OID);
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        asn1_push_tag(data, ASN1_CONTEXT(2));
+        asn1_write_OctetString(data,blob.data,blob.length);
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        if (data->has_error) {
+                DEBUG(1,("Failed to build negTokenInit at offset %d\n", (int)data->ofs));
+        }
+        ret = data_blob(data->data, data->length);
+        ret = data_blob_talloc(ctx, data->data, data->length);
         asn1_free(data);
 …
   OIDs (the mechanisms) and a principal name string
 */
+bool spnego_parse_negTokenInit(DATA_BLOB blob,
+bool spnego_parse_negTokenInit(TALLOC_CTX *ctx,
+                               DATA_BLOB blob,
                                char *OIDs[ASN1_MAX_OIDS],
+                               char **principal)
+                               char **principal,
+                               DATA_BLOB *secblob)
+{
         int i;
 …
         asn1_start_tag(data,ASN1_SEQUENCE(0));
         for (i=0; asn1_tag_remaining(data) > 0 && i < ASN1_MAX_OIDS-1; i++) {
+                const char *oid_str = NULL;
+                asn1_read_OID(data,talloc_autofree_context(),&oid_str);
+                OIDs[i] = CONST_DISCARD(char *, oid_str);
+                asn1_read_OID(data,ctx, &OIDs[i]);
+        }
         OIDs[i] = NULL;
 …
         asn1_end_tag(data);
+        *principal = NULL;
+        if (principal) {
+                *principal = NULL;
+        }
+        if (secblob) {
+                *secblob = data_blob_null;
+        }
         /*
 …
         if (asn1_peek_tag(data, ASN1_CONTEXT(2))) {
+                DATA_BLOB sblob = data_blob_null;
                 /* mechToken [2] OCTET STRING  OPTIONAL */
-                DATA_BLOB token;
                 asn1_start_tag(data, ASN1_CONTEXT(2));
+                asn1_read_OctetString(data, talloc_autofree_context(),
+                        &token);
+                asn1_end_tag(data);
+                /* Throw away the token - not used. */
+                data_blob_free(&token);
+                asn1_read_OctetString(data, ctx, &sblob);
+                asn1_end_tag(data);
+                if (secblob) {
+                        *secblob = sblob;
+                } else {
+                        data_blob_free(&sblob);
+                }
+        }
         if (asn1_peek_tag(data, ASN1_CONTEXT(3))) {
+                char *princ = NULL;
                 /* mechListMIC [3] OCTET STRING  OPTIONAL */
                 asn1_start_tag(data, ASN1_CONTEXT(3));
                 asn1_start_tag(data, ASN1_SEQUENCE(0));
                 asn1_start_tag(data, ASN1_CONTEXT(0));
+                asn1_read_GeneralString(data,talloc_autofree_context(),
+                        principal);
+                asn1_end_tag(data);
+                asn1_end_tag(data);
+                asn1_end_tag(data);
+                asn1_read_GeneralString(data, ctx, &princ);
+                asn1_end_tag(data);
+                asn1_end_tag(data);
+                asn1_end_tag(data);
+                if (principal) {
+                        *principal = princ;
+                } else {
+                        TALLOC_FREE(princ);
+                }
+        }
 …
         if (data->has_error) {
                 int j;
+                TALLOC_FREE(*principal);
+                if (principal) {
+                        TALLOC_FREE(*principal);
+                }
+                if (secblob) {
+                        data_blob_free(secblob);
+                }
                 for(j = 0; j < i && j < ASN1_MAX_OIDS-1; j++) {
                         TALLOC_FREE(OIDs[j]);
 …
 /*
-  generate a negTokenTarg packet given a list of OIDs and a security blob
-*/
-DATA_BLOB gen_negTokenTarg(const char *OIDs[], DATA_BLOB blob)
+{
-        int i;
-        ASN1_DATA *data;
-        DATA_BLOB ret;
-        data = asn1_init(talloc_tos());
-        if (data == NULL) {
-                return data_blob_null;
+        }
-        asn1_push_tag(data, ASN1_APPLICATION(0));
-        asn1_write_OID(data,OID_SPNEGO);
-        asn1_push_tag(data, ASN1_CONTEXT(0));
-        asn1_push_tag(data, ASN1_SEQUENCE(0));
-        asn1_push_tag(data, ASN1_CONTEXT(0));
-        asn1_push_tag(data, ASN1_SEQUENCE(0));
-        for (i=0; OIDs[i]; i++) {
-                asn1_write_OID(data,OIDs[i]);
+        }
-        asn1_pop_tag(data);
-        asn1_pop_tag(data);
-        asn1_push_tag(data, ASN1_CONTEXT(2));
-        asn1_write_OctetString(data,blob.data,blob.length);
-        asn1_pop_tag(data);
-        asn1_pop_tag(data);
-        asn1_pop_tag(data);
-        asn1_pop_tag(data);
-        if (data->has_error) {
-                DEBUG(1,("Failed to build negTokenTarg at offset %d\n", (int)data->ofs));
+        }
-        ret = data_blob(data->data, data->length);
-        asn1_free(data);
-        return ret;
+}
-/*
-  parse a negTokenTarg packet giving a list of OIDs and a security blob
-*/
-bool parse_negTokenTarg(DATA_BLOB blob, char *OIDs[ASN1_MAX_OIDS], DATA_BLOB *secblob)
+{
-        int i;
-        ASN1_DATA *data;
-        data = asn1_init(talloc_tos());
-        if (data == NULL) {
-                return false;
+        }
-        asn1_load(data, blob);
-        asn1_start_tag(data, ASN1_APPLICATION(0));
-        asn1_check_OID(data,OID_SPNEGO);
-        asn1_start_tag(data, ASN1_CONTEXT(0));
-        asn1_start_tag(data, ASN1_SEQUENCE(0));
-        asn1_start_tag(data, ASN1_CONTEXT(0));
-        asn1_start_tag(data, ASN1_SEQUENCE(0));
-        for (i=0; asn1_tag_remaining(data) > 0 && i < ASN1_MAX_OIDS-1; i++) {
-                const char *oid_str = NULL;
-                asn1_read_OID(data,talloc_autofree_context(),&oid_str);
-                OIDs[i] = CONST_DISCARD(char *, oid_str);
+        }
-        OIDs[i] = NULL;
-        asn1_end_tag(data);
-        asn1_end_tag(data);
-        /* Skip any optional req_flags that are sent per RFC 4178 */
-        if (asn1_peek_tag(data, ASN1_CONTEXT(1))) {
-                uint8 flags;
-                asn1_start_tag(data, ASN1_CONTEXT(1));
-                asn1_start_tag(data, ASN1_BIT_STRING);
-                while (asn1_tag_remaining(data) > 0)
-                        asn1_read_uint8(data, &flags);
-                asn1_end_tag(data);
-                asn1_end_tag(data);
+        }
-        asn1_start_tag(data, ASN1_CONTEXT(2));
-        asn1_read_OctetString(data,talloc_autofree_context(),secblob);
-        asn1_end_tag(data);
-        asn1_end_tag(data);
-        asn1_end_tag(data);
-        asn1_end_tag(data);
-        if (data->has_error) {
-                int j;
-                data_blob_free(secblob);
-                for(j = 0; j < i && j < ASN1_MAX_OIDS-1; j++) {
-                        TALLOC_FREE(OIDs[j]);
+                }
-                DEBUG(1,("Failed to parse negTokenTarg at offset %d\n", (int)data->ofs));
-                asn1_free(data);
-                return False;
+        }
-        asn1_free(data);
-        return True;
+}
-/*
   generate a krb5 GSS-API wrapper packet given a ticket
 */
 DATA_BLOB spnego_gen_krb5_wrap(const DATA_BLOB ticket, const uint8 tok_id[2])
+DATA_BLOB spnego_gen_krb5_wrap(TALLOC_CTX *ctx, const DATA_BLOB ticket, const uint8 tok_id[2])
+{
         ASN1_DATA *data;
 …
+        }
         ret = data_blob(data->data, data->length);
+        ret = data_blob_talloc(ctx, data->data, data->length);
         asn1_free(data);
 …
   parse a krb5 GSS-API wrapper packet giving a ticket
 */
 bool spnego_parse_krb5_wrap(DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
+bool spnego_parse_krb5_wrap(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *ticket, uint8 tok_id[2])
+{
         bool ret;
 …
                 asn1_read(data, tok_id, 2);
                 data_remaining -= 2;
                 *ticket = data_blob(NULL, data_remaining);
+                *ticket = data_blob_talloc(ctx, NULL, data_remaining);
                 asn1_read(data, ticket->data, ticket->length);
+        }
 …
 /*
+   generate a SPNEGO negTokenTarg packet, ready for a EXTENDED_SECURITY
+   kerberos session setup
+*/
+int spnego_gen_negTokenTarg(const char *principal, int time_offset,
+                            DATA_BLOB *targ,
+   generate a SPNEGO krb5 negTokenInit packet, ready for a EXTENDED_SECURITY
+   kerberos session setup
+*/
+int spnego_gen_krb5_negTokenInit(TALLOC_CTX *ctx,
+                            const char *principal, int time_offset,
+                            DATA_BLOB *targ,
                             DATA_BLOB *session_key_krb5, uint32 extra_ap_opts,
                             time_t *expire_time)
 …
         /* get a kerberos ticket for the service and extract the session key */
         retval = cli_krb5_get_ticket(principal, time_offset,
                                         &tkt, session_key_krb5, extra_ap_opts, NULL,
                                         expire_time, NULL);
         if (retval)
+        retval = cli_krb5_get_ticket(ctx, principal, time_offset,
+                                          &tkt, session_key_krb5,
+                                          extra_ap_opts, NULL,
+                                          expire_time, NULL);
+        if (retval) {
                 return retval;
+        }
         /* wrap that up in a nice GSS-API wrapping */
         tkt_wrapped = spnego_gen_krb5_wrap(tkt, TOK_ID_KRB_AP_REQ);
+        tkt_wrapped = spnego_gen_krb5_wrap(ctx, tkt, TOK_ID_KRB_AP_REQ);
         /* and wrap that in a shiny SPNEGO wrapper */
         *targ = gen_negTokenTarg(krb_mechs, tkt_wrapped);
+        *targ = spnego_gen_negTokenInit(ctx, krb_mechs, &tkt_wrapped, NULL);
         data_blob_free(&tkt_wrapped);
 …
   parse a spnego NTLMSSP challenge packet giving two security blobs
 */
 bool spnego_parse_challenge(const DATA_BLOB blob,
+bool spnego_parse_challenge(TALLOC_CTX *ctx, const DATA_BLOB blob,
                             DATA_BLOB *chal1, DATA_BLOB *chal2)
+{
 …
         asn1_start_tag(data,ASN1_CONTEXT(2));
         asn1_read_OctetString(data, talloc_autofree_context(), chal1);
+        asn1_read_OctetString(data, ctx, chal1);
         asn1_end_tag(data);
 …
         if (asn1_tag_remaining(data)) {
                 asn1_start_tag(data,ASN1_CONTEXT(3));
                 asn1_read_OctetString(data, talloc_autofree_context(), chal2);
+                asn1_read_OctetString(data, ctx, chal2);
                 asn1_end_tag(data);
+        }
 …
  generate a SPNEGO auth packet. This will contain the encrypted passwords
 */
 DATA_BLOB spnego_gen_auth(DATA_BLOB blob)
+DATA_BLOB spnego_gen_auth(TALLOC_CTX *ctx, DATA_BLOB blob)
+{
         ASN1_DATA *data;
 …
         asn1_pop_tag(data);
         ret = data_blob(data->data, data->length);
+        ret = data_blob_talloc(ctx, data->data, data->length);
         asn1_free(data);
 …
  parse a SPNEGO auth packet. This contains the encrypted passwords
 */
+bool spnego_parse_auth(DATA_BLOB blob, DATA_BLOB *auth)
+bool spnego_parse_auth_and_mic(TALLOC_CTX *ctx, DATA_BLOB blob,
+                                DATA_BLOB *auth, DATA_BLOB *signature)
+{
         ssize_t len;
 …
+        }
         *auth = data_blob_talloc(talloc_tos(),
+        *auth = data_blob_talloc(ctx,
                                  token.negTokenTarg.responseToken.data,
                                  token.negTokenTarg.responseToken.length);
+        if (!signature) {
+                goto done;
+        }
+        *signature = data_blob_talloc(ctx,
+                                 token.negTokenTarg.mechListMIC.data,
+                                 token.negTokenTarg.mechListMIC.length);
+done:
         spnego_free_data(&token);
 …
+}
+bool spnego_parse_auth(TALLOC_CTX *ctx, DATA_BLOB blob, DATA_BLOB *auth)
+{
+        return spnego_parse_auth_and_mic(ctx, blob, auth, NULL);
+}
 /*
   generate a minimal SPNEGO response packet.  Doesn't contain much.
 */
+DATA_BLOB spnego_gen_auth_response(DATA_BLOB *reply, NTSTATUS nt_status,
+                                   const char *mechOID)
+DATA_BLOB spnego_gen_auth_response_and_mic(TALLOC_CTX *ctx,
+                                           NTSTATUS nt_status,
+                                           const char *mechOID,
+                                           DATA_BLOB *reply,
+                                           DATA_BLOB *mechlistMIC)
+{
         ASN1_DATA *data;
 …
+        }
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        ret = data_blob(data->data, data->length);
+        if (mechlistMIC && mechlistMIC->data != NULL) {
+                asn1_push_tag(data, ASN1_CONTEXT(3));
+                asn1_write_OctetString(data,
+                                        mechlistMIC->data,
+                                        mechlistMIC->length);
+                asn1_pop_tag(data);
+        }
+        asn1_pop_tag(data);
+        asn1_pop_tag(data);
+        ret = data_blob_talloc(ctx, data->data, data->length);
         asn1_free(data);
         return ret;
+}
+DATA_BLOB spnego_gen_auth_response(TALLOC_CTX *ctx, DATA_BLOB *reply,
+                                   NTSTATUS nt_status, const char *mechOID)
+{
+        return spnego_gen_auth_response_and_mic(ctx, nt_status,
+                                                mechOID, reply, NULL);
+}
 /*
  parse a SPNEGO auth packet. This contains the encrypted passwords
 */
+bool spnego_parse_auth_response(DATA_BLOB blob, NTSTATUS nt_status,
+bool spnego_parse_auth_response(TALLOC_CTX *ctx,
+                                DATA_BLOB blob, NTSTATUS nt_status,
                                 const char *mechOID,
                                 DATA_BLOB *auth)
 …
                 if (asn1_tag_remaining(data)) {
                         asn1_start_tag(data,ASN1_CONTEXT(2));
                         asn1_read_OctetString(data, talloc_autofree_context(), auth);
+                        asn1_read_OctetString(data, ctx, auth);
                         asn1_end_tag(data);
+                }
 …
                 DATA_BLOB mechList = data_blob_null;
                 asn1_start_tag(data, ASN1_CONTEXT(3));
                 asn1_read_OctetString(data, talloc_autofree_context(), &mechList);
+                asn1_read_OctetString(data, ctx, &mechList);
                 asn1_end_tag(data);
                 data_blob_free(&mechList);
 …
         return True;
+}
+bool spnego_mech_list_blob(TALLOC_CTX *mem_ctx,
+                           char **oid_list, DATA_BLOB *raw_data)
+{
+        ASN1_DATA *data;
+        unsigned int idx;
+        if (!oid_list || !oid_list[0] || !raw_data) {
+                return false;
+        }
+        data = asn1_init(talloc_tos());
+        if (data == NULL) {
+                return false;
+        }
+        asn1_push_tag(data, ASN1_SEQUENCE(0));
+        for (idx = 0; oid_list[idx]; idx++) {
+                asn1_write_OID(data, oid_list[idx]);
+        }
+        asn1_pop_tag(data);
+        if (data->has_error) {
+                DEBUG(3, (__location__ " failed at %d\n", (int)data->ofs));
+                asn1_free(data);
+                return false;
+        }
+        *raw_data = data_blob_talloc(mem_ctx, data->data, data->length);
+        if (!raw_data->data) {
+                DEBUG(3, (__location__": data_blob_talloc() failed!\n"));
+                asn1_free(data);
+                return false;
+        }
+        asn1_free(data);
+        return true;
+}

vendor/current/source3/libsmb/clistr.c

-              r414
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
 size_t clistr_push_fn(const char *function,
 …
                         return push_string_base(function, line,
                                                 cli->outbuf,
                                                 SVAL(cli->outbuf, smb_flg2),
+                                                (uint16_t)(cli_ucs2(cli) ? FLAGS2_UNICODE_STRINGS : 0),
                                                 dest, src, -1, flags);
+                }
                 return push_string_base(function, line,
                                         cli->outbuf,
                                         SVAL(cli->outbuf, smb_flg2),
+                                        (uint16_t)(cli_ucs2(cli) ? FLAGS2_UNICODE_STRINGS : 0),
                                         dest, src, cli->bufsize - buf_used,
                                         flags);
 …
         return push_string_base(function, line,
                                 cli->outbuf,
                                 SVAL(cli->outbuf, smb_flg2),
+                                (uint16_t)(cli_ucs2(cli) ? FLAGS2_UNICODE_STRINGS : 0),
                                 dest, src, dest_len, flags);
+}
 …
                                 unsigned int line,
                                 TALLOC_CTX *ctx,
+                                const char *inbuf,
+                                const char *base,
+                                uint16_t flags2,
                                 char **pp_dest,
                                 const void *src,
 …
                                         line,
                                         ctx,
                                         inbuf,
                                         SVAL(inbuf, smb_flg2),
+                                        base,
+                                        flags2,
                                         pp_dest,
                                         src,
 …
         return align_string(cli->outbuf, (const char *)p, flags);
+}
-size_t clistr_align_in(struct cli_state *cli, const void *p, int flags)
+{
-        return align_string(cli->inbuf, (const char *)p, flags);
+}

vendor/current/source3/libsmb/clitrans.c

-              r414
+              r740
 #include "includes.h"
+/****************************************************************************
+ Send a SMB trans or trans2 request.
+****************************************************************************/
+bool cli_send_trans(struct cli_state *cli, int trans,
+                    const char *pipe_name,
+                    int fid, int flags,
+                    uint16 *setup, unsigned int lsetup, unsigned int msetup,
+                    const char *param, unsigned int lparam, unsigned int mparam,
+                    const char *data, unsigned int ldata, unsigned int mdata)
+{
+        unsigned int i;
+        unsigned int this_ldata,this_lparam;
+        unsigned int tot_data=0,tot_param=0;
+        char *outdata,*outparam;
+        char *p;
+        int pipe_name_len=0;
+        uint16 mid;
+        this_lparam = MIN(lparam,cli->max_xmit - (500+lsetup*2)); /* hack */
+        this_ldata = MIN(ldata,cli->max_xmit - (500+lsetup*2+this_lparam));
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,14+lsetup,0,True);
+        SCVAL(cli->outbuf,smb_com,trans);
+        SSVAL(cli->outbuf,smb_tid, cli->cnum);
+        cli_setup_packet(cli);
+        /*
+         * Save the mid we're using. We need this for finding
+         * signing replies.
+         */
+        mid = cli->mid;
+        if (pipe_name) {
+                pipe_name_len = clistr_push(cli, smb_buf(cli->outbuf), pipe_name, -1, STR_TERMINATE);
+        }
+        outparam = smb_buf(cli->outbuf)+(trans==SMBtrans ? pipe_name_len : 3);
+        outdata = outparam+this_lparam;
+        /* primary request */
+        SSVAL(cli->outbuf,smb_tpscnt,lparam);   /* tpscnt */
+        SSVAL(cli->outbuf,smb_tdscnt,ldata);    /* tdscnt */
+        SSVAL(cli->outbuf,smb_mprcnt,mparam);   /* mprcnt */
+        SSVAL(cli->outbuf,smb_mdrcnt,mdata);    /* mdrcnt */
+        SCVAL(cli->outbuf,smb_msrcnt,msetup);   /* msrcnt */
+        SSVAL(cli->outbuf,smb_flags,flags);     /* flags */
+        SIVAL(cli->outbuf,smb_timeout,0);               /* timeout */
+        SSVAL(cli->outbuf,smb_pscnt,this_lparam);       /* pscnt */
+        SSVAL(cli->outbuf,smb_psoff,smb_offset(outparam,cli->outbuf)); /* psoff */
+        SSVAL(cli->outbuf,smb_dscnt,this_ldata);        /* dscnt */
+        SSVAL(cli->outbuf,smb_dsoff,smb_offset(outdata,cli->outbuf)); /* dsoff */
+        SCVAL(cli->outbuf,smb_suwcnt,lsetup);   /* suwcnt */
+        for (i=0;i<lsetup;i++)          /* setup[] */
+                SSVAL(cli->outbuf,smb_setup+i*2,setup[i]);
+        p = smb_buf(cli->outbuf);
+        if (trans != SMBtrans) {
+                *p++ = 0;  /* put in a null smb_name */
+                *p++ = 'D'; *p++ = ' '; /* observed in OS/2 */
+        }
+        if (this_lparam)                        /* param[] */
+                memcpy(outparam,param,this_lparam);
+        if (this_ldata)                 /* data[] */
+                memcpy(outdata,data,this_ldata);
+        cli_setup_bcc(cli, outdata+this_ldata);
+        show_msg(cli->outbuf);
+        if (!cli_send_smb(cli)) {
+                return False;
+        }
+        cli_state_seqnum_persistent(cli, mid);
+        if (this_ldata < ldata || this_lparam < lparam) {
+                /* receive interim response */
+                if (!cli_receive_smb(cli) || cli_is_error(cli)) {
+                        cli_state_seqnum_remove(cli, mid);
+                        return(False);
+                }
+                tot_data = this_ldata;
+                tot_param = this_lparam;
+                while (tot_data < ldata || tot_param < lparam)  {
+                        this_lparam = MIN(lparam-tot_param,cli->max_xmit - 500); /* hack */
+                        this_ldata = MIN(ldata-tot_data,cli->max_xmit - (500+this_lparam));
+                        cli_set_message(cli->outbuf,trans==SMBtrans?8:9,0,True);
+                        SCVAL(cli->outbuf,smb_com,(trans==SMBtrans ? SMBtranss : SMBtranss2));
+                        outparam = smb_buf(cli->outbuf);
+                        outdata = outparam+this_lparam;
+                        /* secondary request */
+                        SSVAL(cli->outbuf,smb_tpscnt,lparam);   /* tpscnt */
+                        SSVAL(cli->outbuf,smb_tdscnt,ldata);    /* tdscnt */
+                        SSVAL(cli->outbuf,smb_spscnt,this_lparam);      /* pscnt */
+                        SSVAL(cli->outbuf,smb_spsoff,smb_offset(outparam,cli->outbuf)); /* psoff */
+                        SSVAL(cli->outbuf,smb_spsdisp,tot_param);       /* psdisp */
+                        SSVAL(cli->outbuf,smb_sdscnt,this_ldata);       /* dscnt */
+                        SSVAL(cli->outbuf,smb_sdsoff,smb_offset(outdata,cli->outbuf)); /* dsoff */
+                        SSVAL(cli->outbuf,smb_sdsdisp,tot_data);        /* dsdisp */
+                        if (trans==SMBtrans2)
+                                SSVALS(cli->outbuf,smb_sfid,fid);               /* fid */
+                        if (this_lparam)                        /* param[] */
+                                memcpy(outparam,param+tot_param,this_lparam);
+                        if (this_ldata)                 /* data[] */
+                                memcpy(outdata,data+tot_data,this_ldata);
+                        cli_setup_bcc(cli, outdata+this_ldata);
+                        show_msg(cli->outbuf);
+                        cli->mid = mid;
+                        if (!cli_send_smb(cli)) {
+                                cli_state_seqnum_remove(cli, mid);
+                                return False;
+                        }
+                        tot_data += this_ldata;
+                        tot_param += this_lparam;
+                }
+        }
+        return(True);
+}
+/****************************************************************************
+ Receive a SMB trans or trans2 response allocating the necessary memory.
+****************************************************************************/
+bool cli_receive_trans(struct cli_state *cli,int trans,
+                              char **param, unsigned int *param_len,
+                              char **data, unsigned int *data_len)
+{
+        unsigned int total_data=0;
+        unsigned int total_param=0;
+        unsigned int this_data,this_param;
+        NTSTATUS status;
+        bool ret = False;
+        uint16_t mid;
+        *data_len = *param_len = 0;
+        mid = SVAL(cli->outbuf,smb_mid);
+        if (!cli_receive_smb(cli)) {
+                cli_state_seqnum_remove(cli, mid);
+                return False;
+        }
+        show_msg(cli->inbuf);
+        /* sanity check */
+        if (CVAL(cli->inbuf,smb_com) != trans) {
+                DEBUG(0,("Expected %s response, got command 0x%02x\n",
+                         trans==SMBtrans?"SMBtrans":"SMBtrans2",
+                         CVAL(cli->inbuf,smb_com)));
+                cli_state_seqnum_remove(cli, mid);
+                return False;
+        }
+        /*
+         * 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. Note that STATUS_NO_MORE_FILES is
+         * returned when a trans2 findfirst/next finishes.
+         * When setting up an encrypted transport we can also
+         * see NT_STATUS_MORE_PROCESSING_REQUIRED here.
+         *
+         * Vista returns NT_STATUS_INACCESSIBLE_SYSTEM_SHORTCUT if the folder
+         * "<share>/Users/All Users" is enumerated.  This is a special pseudo
+         * folder, and the response does not have parameters (nor a parameter
+         * length).
+         */
+        status = cli_nt_error(cli);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                if (NT_STATUS_IS_ERR(status) ||
+                    NT_STATUS_EQUAL(status,STATUS_NO_MORE_FILES) ||
+                    NT_STATUS_EQUAL(status,NT_STATUS_INACCESSIBLE_SYSTEM_SHORTCUT)) {
+                        goto out;
+                }
+        }
+        /* parse out the lengths */
+        total_data = SVAL(cli->inbuf,smb_tdrcnt);
+        total_param = SVAL(cli->inbuf,smb_tprcnt);
+        /* allocate it */
+        if (total_data!=0) {
+                /* We know adding 2 is safe as total_data is an
+                 * SVAL <= 0xFFFF. */
+                *data = (char *)SMB_REALLOC(*data,total_data+2);
+                if (!(*data)) {
+                        DEBUG(0,("cli_receive_trans: failed to enlarge data buffer\n"));
+                        goto out;
+                }
+        }
+        if (total_param!=0) {
+                /* We know adding 2 is safe as total_param is an
+                 * SVAL <= 0xFFFF. */
+                *param = (char *)SMB_REALLOC(*param,total_param+2);
+                if (!(*param)) {
+                        DEBUG(0,("cli_receive_trans: failed to enlarge param buffer\n"));
+                        goto out;
+                }
+        }
+        for (;;)  {
+                this_data = SVAL(cli->inbuf,smb_drcnt);
+                this_param = SVAL(cli->inbuf,smb_prcnt);
+                if (this_data + *data_len > total_data ||
+                    this_param + *param_len > total_param) {
+                        DEBUG(1,("Data overflow in cli_receive_trans\n"));
+                        goto out;
+                }
+                if (this_data + *data_len < this_data ||
+                                this_data + *data_len < *data_len ||
+                                this_param + *param_len < this_param ||
+                                this_param + *param_len < *param_len) {
+                        DEBUG(1,("Data overflow in cli_receive_trans\n"));
+                        goto out;
+                }
+                if (this_data) {
+                        unsigned int data_offset_out = SVAL(cli->inbuf,smb_drdisp);
+                        unsigned int data_offset_in = SVAL(cli->inbuf,smb_droff);
+                        if (data_offset_out > total_data ||
+                                        data_offset_out + this_data > total_data ||
+                                        data_offset_out + this_data < data_offset_out ||
+                                        data_offset_out + this_data < this_data) {
+                                DEBUG(1,("Data overflow in cli_receive_trans\n"));
+                                goto out;
+                        }
+                        if (data_offset_in > cli->bufsize ||
+                                        data_offset_in + this_data >  cli->bufsize ||
+                                        data_offset_in + this_data < data_offset_in ||
+                                        data_offset_in + this_data < this_data) {
+                                DEBUG(1,("Data overflow in cli_receive_trans\n"));
+                                goto out;
+                        }
+                        memcpy(*data + data_offset_out, smb_base(cli->inbuf) + data_offset_in, this_data);
+                }
+                if (this_param) {
+                        unsigned int param_offset_out = SVAL(cli->inbuf,smb_prdisp);
+                        unsigned int param_offset_in = SVAL(cli->inbuf,smb_proff);
+                        if (param_offset_out > total_param ||
+                                        param_offset_out + this_param > total_param ||
+                                        param_offset_out + this_param < param_offset_out ||
+                                        param_offset_out + this_param < this_param) {
+                                DEBUG(1,("Param overflow in cli_receive_trans\n"));
+                                goto out;
+                        }
+                        if (param_offset_in > cli->bufsize ||
+                                        param_offset_in + this_param >  cli->bufsize ||
+                                        param_offset_in + this_param < param_offset_in ||
+                                        param_offset_in + this_param < this_param) {
+                                DEBUG(1,("Param overflow in cli_receive_trans\n"));
+                                goto out;
+                        }
+                        memcpy(*param + param_offset_out, smb_base(cli->inbuf) + param_offset_in, this_param);
+                }
+                *data_len += this_data;
+                *param_len += this_param;
+                if (total_data <= *data_len && total_param <= *param_len) {
+                        ret = True;
+                        break;
+                }
+                if (!cli_receive_smb(cli)) {
+                        goto out;
+                }
+                show_msg(cli->inbuf);
+                /* sanity check */
+                if (CVAL(cli->inbuf,smb_com) != trans) {
+                        DEBUG(0,("Expected %s response, got command 0x%02x\n",
+                                 trans==SMBtrans?"SMBtrans":"SMBtrans2",
+                                 CVAL(cli->inbuf,smb_com)));
+                        goto out;
+                }
+                if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                        if (NT_STATUS_IS_ERR(cli_nt_error(cli))) {
+                                goto out;
+                        }
+                }
+                /* parse out the total lengths again - they can shrink! */
+                if (SVAL(cli->inbuf,smb_tdrcnt) < total_data)
+                        total_data = SVAL(cli->inbuf,smb_tdrcnt);
+                if (SVAL(cli->inbuf,smb_tprcnt) < total_param)
+                        total_param = SVAL(cli->inbuf,smb_tprcnt);
+                if (total_data <= *data_len && total_param <= *param_len) {
+                        ret = True;
+                        break;
+                }
+        }
+  out:
+        cli_state_seqnum_remove(cli, mid);
+        if (ret) {
+                /* Ensure the last 2 bytes of param and data are 2 null
+                 * bytes. These are malloc'ed, but not included in any
+                 * length counts. This allows cli_XX string reading functions
+                 * to safely null terminate. */
+                if (total_data) {
+                        SSVAL(*data,total_data,0);
+                }
+                if (total_param) {
+                        SSVAL(*param,total_param,0);
+                }
+        }
+        return ret;
+}
+/****************************************************************************
+ Send a SMB nttrans request.
+****************************************************************************/
+bool cli_send_nt_trans(struct cli_state *cli,
+                       int function,
+                       int flags,
+                       uint16 *setup, unsigned int lsetup, unsigned int msetup,
+                       char *param, unsigned int lparam, unsigned int mparam,
+                       char *data, unsigned int ldata, unsigned int mdata)
+{
+        unsigned int i;
+        unsigned int this_ldata,this_lparam;
+        unsigned int tot_data=0,tot_param=0;
+        uint16 mid;
+        char *outdata,*outparam;
+        this_lparam = MIN(lparam,cli->max_xmit - (500+lsetup*2)); /* hack */
+        this_ldata = MIN(ldata,cli->max_xmit - (500+lsetup*2+this_lparam));
+        memset(cli->outbuf,'\0',smb_size);
+        cli_set_message(cli->outbuf,19+lsetup,0,True);
+        SCVAL(cli->outbuf,smb_com,SMBnttrans);
+        SSVAL(cli->outbuf,smb_tid, cli->cnum);
+        cli_setup_packet(cli);
+        /*
+         * Save the mid we're using. We need this for finding
+         * signing replies.
+         */
+        mid = cli->mid;
+        outparam = smb_buf(cli->outbuf)+3;
+        outdata = outparam+this_lparam;
+        /* primary request */
+        SCVAL(cli->outbuf,smb_nt_MaxSetupCount,msetup);
+        SCVAL(cli->outbuf,smb_nt_Flags,flags);
+        SIVAL(cli->outbuf,smb_nt_TotalParameterCount, lparam);
+        SIVAL(cli->outbuf,smb_nt_TotalDataCount, ldata);
+        SIVAL(cli->outbuf,smb_nt_MaxParameterCount, mparam);
+        SIVAL(cli->outbuf,smb_nt_MaxDataCount, mdata);
+        SIVAL(cli->outbuf,smb_nt_ParameterCount, this_lparam);
+        SIVAL(cli->outbuf,smb_nt_ParameterOffset, smb_offset(outparam,cli->outbuf));
+        SIVAL(cli->outbuf,smb_nt_DataCount, this_ldata);
+        SIVAL(cli->outbuf,smb_nt_DataOffset, smb_offset(outdata,cli->outbuf));
+        SIVAL(cli->outbuf,smb_nt_SetupCount, lsetup);
+        SIVAL(cli->outbuf,smb_nt_Function, function);
+        for (i=0;i<lsetup;i++)          /* setup[] */
+                SSVAL(cli->outbuf,smb_nt_SetupStart+i*2,setup[i]);
+        if (this_lparam)                        /* param[] */
+                memcpy(outparam,param,this_lparam);
+        if (this_ldata)                 /* data[] */
+                memcpy(outdata,data,this_ldata);
+        cli_setup_bcc(cli, outdata+this_ldata);
+        show_msg(cli->outbuf);
+        if (!cli_send_smb(cli)) {
+                return False;
+        }
+        cli_state_seqnum_persistent(cli, mid);
+        if (this_ldata < ldata || this_lparam < lparam) {
+                /* receive interim response */
+                if (!cli_receive_smb(cli) || cli_is_error(cli)) {
+                        cli_state_seqnum_remove(cli, mid);
+                        return(False);
+                }
+                tot_data = this_ldata;
+                tot_param = this_lparam;
+                while (tot_data < ldata || tot_param < lparam)  {
+                        this_lparam = MIN(lparam-tot_param,cli->max_xmit - 500); /* hack */
+                        this_ldata = MIN(ldata-tot_data,cli->max_xmit - (500+this_lparam));
+                        cli_set_message(cli->outbuf,18,0,True);
+                        SCVAL(cli->outbuf,smb_com,SMBnttranss);
+                        /* XXX - these should probably be aligned */
+                        outparam = smb_buf(cli->outbuf);
+                        outdata = outparam+this_lparam;
+                        /* secondary request */
+                        SIVAL(cli->outbuf,smb_nts_TotalParameterCount,lparam);
+                        SIVAL(cli->outbuf,smb_nts_TotalDataCount,ldata);
+                        SIVAL(cli->outbuf,smb_nts_ParameterCount,this_lparam);
+                        SIVAL(cli->outbuf,smb_nts_ParameterOffset,smb_offset(outparam,cli->outbuf));
+                        SIVAL(cli->outbuf,smb_nts_ParameterDisplacement,tot_param);
+                        SIVAL(cli->outbuf,smb_nts_DataCount,this_ldata);
+                        SIVAL(cli->outbuf,smb_nts_DataOffset,smb_offset(outdata,cli->outbuf));
+                        SIVAL(cli->outbuf,smb_nts_DataDisplacement,tot_data);
+                        if (this_lparam)                        /* param[] */
+                                memcpy(outparam,param+tot_param,this_lparam);
+                        if (this_ldata)                 /* data[] */
+                                memcpy(outdata,data+tot_data,this_ldata);
+                        cli_setup_bcc(cli, outdata+this_ldata);
+                        show_msg(cli->outbuf);
+                        cli->mid = mid;
+                        if (!cli_send_smb(cli)) {
+                                cli_state_seqnum_remove(cli, mid);
+                                return False;
+                        }
+                        tot_data += this_ldata;
+                        tot_param += this_lparam;
+                }
+        }
+        return(True);
+}
+/****************************************************************************
+ Receive a SMB nttrans response allocating the necessary memory.
+****************************************************************************/
+bool cli_receive_nt_trans(struct cli_state *cli,
+                          char **param, unsigned int *param_len,
+                          char **data, unsigned int *data_len)
+{
+        unsigned int total_data=0;
+        unsigned int total_param=0;
+        unsigned int this_data,this_param;
+        uint8 eclass;
+        uint32 ecode;
+        bool ret = False;
+        uint16_t mid;
+        *data_len = *param_len = 0;
+        mid = SVAL(cli->outbuf,smb_mid);
+        if (!cli_receive_smb(cli)) {
+                cli_state_seqnum_remove(cli, mid);
+                return False;
+        }
+        show_msg(cli->inbuf);
+        /* sanity check */
+        if (CVAL(cli->inbuf,smb_com) != SMBnttrans) {
+                DEBUG(0,("Expected SMBnttrans response, got command 0x%02x\n",
+                         CVAL(cli->inbuf,smb_com)));
+                cli_state_seqnum_remove(cli, mid);
+                return(False);
+        }
+        /*
+         * 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 (cli_is_dos_error(cli)) {
+                cli_dos_error(cli, &eclass, &ecode);
+                if (!(eclass == ERRDOS && ecode == ERRmoredata)) {
+                        goto out;
+                }
+        }
+        /*
+         * Likewise for NT_STATUS_BUFFER_TOO_SMALL
+         */
+        if (cli_is_nt_error(cli)) {
+                if (!NT_STATUS_EQUAL(cli_nt_error(cli),
+                                     NT_STATUS_BUFFER_TOO_SMALL)) {
+                        goto out;
+                }
+        }
+        /* parse out the lengths */
+        total_data = IVAL(cli->inbuf,smb_ntr_TotalDataCount);
+        total_param = IVAL(cli->inbuf,smb_ntr_TotalParameterCount);
+        /* Only allow 16 megs. */
+        if (total_param > 16*1024*1024) {
+                DEBUG(0,("cli_receive_nt_trans: param buffer too large %d\n",
+                                        total_param));
+                goto out;
+        }
+        if (total_data > 16*1024*1024) {
+                DEBUG(0,("cli_receive_nt_trans: data buffer too large %d\n",
+                                        total_data));
+                goto out;
+        }
+        /* allocate it */
+        if (total_data) {
+                /* We know adding 2 is safe as total_data is less
+                 * than 16mb (above). */
+                *data = (char *)SMB_REALLOC(*data,total_data+2);
+                if (!(*data)) {
+                        DEBUG(0,("cli_receive_nt_trans: failed to enlarge data buffer to %d\n",total_data));
+                        goto out;
+                }
+        }
+        if (total_param) {
+                /* We know adding 2 is safe as total_param is less
+                 * than 16mb (above). */
+                *param = (char *)SMB_REALLOC(*param,total_param+2);
+                if (!(*param)) {
+                        DEBUG(0,("cli_receive_nt_trans: failed to enlarge param buffer to %d\n", total_param));
+                        goto out;
+                }
+        }
+        while (1)  {
+                this_data = SVAL(cli->inbuf,smb_ntr_DataCount);
+                this_param = SVAL(cli->inbuf,smb_ntr_ParameterCount);
+                if (this_data + *data_len > total_data ||
+                    this_param + *param_len > total_param) {
+                        DEBUG(1,("Data overflow in cli_receive_nt_trans\n"));
+                        goto out;
+                }
+                if (this_data + *data_len < this_data ||
+                                this_data + *data_len < *data_len ||
+                                this_param + *param_len < this_param ||
+                                this_param + *param_len < *param_len) {
+                        DEBUG(1,("Data overflow in cli_receive_nt_trans\n"));
+                        goto out;
+                }
+                if (this_data) {
+                        unsigned int data_offset_out = SVAL(cli->inbuf,smb_ntr_DataDisplacement);
+                        unsigned int data_offset_in = SVAL(cli->inbuf,smb_ntr_DataOffset);
+                        if (data_offset_out > total_data ||
+                                        data_offset_out + this_data > total_data ||
+                                        data_offset_out + this_data < data_offset_out ||
+                                        data_offset_out + this_data < this_data) {
+                                DEBUG(1,("Data overflow in cli_receive_nt_trans\n"));
+                                goto out;
+                        }
+                        if (data_offset_in > cli->bufsize ||
+                                        data_offset_in + this_data >  cli->bufsize ||
+                                        data_offset_in + this_data < data_offset_in ||
+                                        data_offset_in + this_data < this_data) {
+                                DEBUG(1,("Data overflow in cli_receive_nt_trans\n"));
+                                goto out;
+                        }
+                        memcpy(*data + data_offset_out, smb_base(cli->inbuf) + data_offset_in, this_data);
+                }
+                if (this_param) {
+                        unsigned int param_offset_out = SVAL(cli->inbuf,smb_ntr_ParameterDisplacement);
+                        unsigned int param_offset_in = SVAL(cli->inbuf,smb_ntr_ParameterOffset);
+                        if (param_offset_out > total_param ||
+                                        param_offset_out + this_param > total_param ||
+                                        param_offset_out + this_param < param_offset_out ||
+                                        param_offset_out + this_param < this_param) {
+                                DEBUG(1,("Param overflow in cli_receive_nt_trans\n"));
+                                goto out;
+                        }
+                        if (param_offset_in > cli->bufsize ||
+                                        param_offset_in + this_param >  cli->bufsize ||
+                                        param_offset_in + this_param < param_offset_in ||
+                                        param_offset_in + this_param < this_param) {
+                                DEBUG(1,("Param overflow in cli_receive_nt_trans\n"));
+                                goto out;
+                        }
+                        memcpy(*param + param_offset_out, smb_base(cli->inbuf) + param_offset_in, this_param);
+                }
+                *data_len += this_data;
+                *param_len += this_param;
+                if (total_data <= *data_len && total_param <= *param_len) {
+                        ret = True;
+                        break;
+                }
+                if (!cli_receive_smb(cli)) {
+                        goto out;
+                }
+                show_msg(cli->inbuf);
+                /* sanity check */
+                if (CVAL(cli->inbuf,smb_com) != SMBnttrans) {
+                        DEBUG(0,("Expected SMBnttrans response, got command 0x%02x\n",
+                                 CVAL(cli->inbuf,smb_com)));
+                        goto out;
+                }
+                if (cli_is_dos_error(cli)) {
+                        cli_dos_error(cli, &eclass, &ecode);
+                        if(!(eclass == ERRDOS && ecode == ERRmoredata)) {
+                                goto out;
+                        }
+                }
+                /*
+                 * Likewise for NT_STATUS_BUFFER_TOO_SMALL
+                 */
+                if (cli_is_nt_error(cli)) {
+                        if (!NT_STATUS_EQUAL(cli_nt_error(cli),
+                                             NT_STATUS_BUFFER_TOO_SMALL)) {
+                                goto out;
+                        }
+                }
+                /* parse out the total lengths again - they can shrink! */
+                if (IVAL(cli->inbuf,smb_ntr_TotalDataCount) < total_data)
+                        total_data = IVAL(cli->inbuf,smb_ntr_TotalDataCount);
+                if (IVAL(cli->inbuf,smb_ntr_TotalParameterCount) < total_param)
+                        total_param = IVAL(cli->inbuf,smb_ntr_TotalParameterCount);
+                if (total_data <= *data_len && total_param <= *param_len) {
+                        ret = True;
+                        break;
+                }
+        }
+  out:
+        cli_state_seqnum_remove(cli, mid);
+        if (ret) {
+                /* Ensure the last 2 bytes of param and data are 2 null
+                 * bytes. These are malloc'ed, but not included in any
+                 * length counts. This allows cli_XX string reading functions
+                 * to safely null terminate. */
+                if (total_data) {
+                        SSVAL(*data,total_data,0);
+                }
+                if (total_param) {
+                        SSVAL(*param,total_param,0);
+                }
+        }
+        return ret;
+}
+#include "libsmb/libsmb.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "async_smb.h"
 struct trans_recvblob {
 …
         uint8_t cmd;
         uint16_t mid;
-        uint32_t seqnum;
         const char *pipe_name;
         uint8_t *pipe_name_conv;
 …
         struct trans_recvblob rparam;
         struct trans_recvblob rdata;
+        TALLOC_CTX *secondary_request_ctx;
+        struct iovec iov[4];
+        uint16_t recv_flags2;
+        struct iovec iov[6];
         uint8_t pad[4];
+        uint8_t zero_pad[4];
         uint16_t vwv[32];
+        struct tevent_req *primary_subreq;
 };
+static void cli_trans_cleanup_primary(struct cli_trans_state *state)
+{
+        if (state->primary_subreq) {
+                cli_smb_req_set_mid(state->primary_subreq, 0);
+                cli_smb_req_unset_pending(state->primary_subreq);
+                TALLOC_FREE(state->primary_subreq);
+        }
+}
+static int cli_trans_state_destructor(struct cli_trans_state *state)
+{
+        cli_trans_cleanup_primary(state);
+        return 0;
+}
 static NTSTATUS cli_pull_trans(uint8_t *inbuf,
 …
         uint8_t *pad = state->pad;
         uint16_t *vwv = state->vwv;
+        uint16_t param_offset;
+        uint16_t this_param = 0;
+        uint16_t this_data = 0;
+        uint32_t param_offset;
+        uint32_t this_param = 0;
+        uint32_t param_pad;
+        uint32_t data_offset;
+        uint32_t this_data = 0;
+        uint32_t data_pad;
         uint32_t useable_space;
         uint8_t cmd;
 …
+        }
+        useable_space = state->cli->max_xmit - smb_size - sizeof(uint16_t)*wct;
+        param_offset += wct * sizeof(uint16_t);
+        useable_space = state->cli->max_xmit - param_offset;
+        param_pad = param_offset % 4;
+        if (param_pad > 0) {
+                param_pad = MIN(param_pad, useable_space);
+                iov[0].iov_base = (void *)state->zero_pad;
+                iov[0].iov_len = param_pad;
+                iov += 1;
+                param_offset += param_pad;
+        }
+        useable_space = state->cli->max_xmit - param_offset;
         if (state->param_sent < state->num_param) {
 …
+        }
+        data_offset = param_offset + this_param;
+        useable_space = state->cli->max_xmit - data_offset;
+        data_pad = data_offset % 4;
+        if (data_pad > 0) {
+                data_pad = MIN(data_pad, useable_space);
+                iov[0].iov_base = (void *)state->zero_pad;
+                iov[0].iov_len = data_pad;
+                iov += 1;
+                data_offset += data_pad;
+        }
+        useable_space = state->cli->max_xmit - data_offset;
         if (state->data_sent < state->num_data) {
                 this_data = MIN(state->num_data - state->data_sent,
                                 useable_space - this_param);
+                                useable_space);
                 iov[0].iov_base = (void *)(state->data + state->data_sent);
                 iov[0].iov_len = this_data;
 …
+        }
-        param_offset += wct * sizeof(uint16_t);
         DEBUG(10, ("num_setup=%u, max_setup=%u, "
                    "param_total=%u, this_param=%u, max_param=%u, "
                    "data_total=%u, this_data=%u, max_data=%u, "
+                   "param_offset=%u, param_disp=%u, data_disp=%u\n",
+                   "param_offset=%u, param_pad=%u, param_disp=%u, "
+                   "data_offset=%u, data_pad=%u, data_disp=%u\n",
                    (unsigned)state->num_setup, (unsigned)state->max_setup,
                    (unsigned)state->num_param, (unsigned)this_param,
 …
                    (unsigned)state->num_data, (unsigned)this_data,
                    (unsigned)state->rdata.max,
+                   (unsigned)param_offset,
+                   (unsigned)state->param_sent, (unsigned)state->data_sent));
+                   (unsigned)param_offset, (unsigned)param_pad,
+                   (unsigned)state->param_sent,
+                   (unsigned)data_offset, (unsigned)data_pad,
+                   (unsigned)state->data_sent));
         switch (cmd) {
 …
                 SSVAL(vwv +10, 0, param_offset);
                 SSVAL(vwv +11, 0, this_data);
                 SSVAL(vwv +12, 0, param_offset + this_param);
+                SSVAL(vwv +12, 0, data_offset);
                 SCVAL(vwv +13, 0, state->num_setup);
                 SCVAL(vwv +13, 1, 0);   /* reserved */
 …
                 SSVAL(vwv + 4, 0, state->param_sent);
                 SSVAL(vwv + 5, 0, this_data);
                 SSVAL(vwv + 6, 0, param_offset + this_param);
+                SSVAL(vwv + 6, 0, data_offset);
                 SSVAL(vwv + 7, 0, state->data_sent);
                 if (cmd == SMBtranss2) {
 …
                 break;
         case SMBnttrans:
                 SCVAL(vwv,  0, state->max_setup);
                 SSVAL(vwv,  1, 0); /* reserved */
                 SIVAL(vwv,  3, state->num_param);
                 SIVAL(vwv,  7, state->num_data);
                 SIVAL(vwv, 11, state->rparam.max);
                 SIVAL(vwv, 15, state->rdata.max);
                 SIVAL(vwv, 19, this_param);
                 SIVAL(vwv, 23, param_offset);
                 SIVAL(vwv, 27, this_data);
                 SIVAL(vwv, 31, param_offset + this_param);
                 SCVAL(vwv, 35, state->num_setup);
                 SSVAL(vwv, 36, state->function);
+                SCVAL(vwv + 0, 0, state->max_setup);
+                SSVAL(vwv + 0, 1, 0); /* reserved */
+                SIVAL(vwv + 1, 1, state->num_param);
+                SIVAL(vwv + 3, 1, state->num_data);
+                SIVAL(vwv + 5, 1, state->rparam.max);
+                SIVAL(vwv + 7, 1, state->rdata.max);
+                SIVAL(vwv + 9, 1, this_param);
+                SIVAL(vwv +11, 1, param_offset);
+                SIVAL(vwv +13, 1, this_data);
+                SIVAL(vwv +15, 1, data_offset);
+                SCVAL(vwv +17, 1, state->num_setup);
+                SSVAL(vwv +18, 0, state->function);
                 memcpy(vwv + 19, state->setup,
                        sizeof(uint16_t) * state->num_setup);
                 break;
         case SMBnttranss:
                 SSVAL(vwv,  0, 0); /* reserved */
                 SCVAL(vwv,  2, 0); /* reserved */
                 SIVAL(vwv,  3, state->num_param);
                 SIVAL(vwv,  7, state->num_data);
                 SIVAL(vwv, 11, this_param);
                 SIVAL(vwv, 15, param_offset);
                 SIVAL(vwv, 19, state->param_sent);
                 SIVAL(vwv, 23, this_data);
                 SIVAL(vwv, 27, param_offset + this_param);
                 SIVAL(vwv, 31, state->data_sent);
                 SCVAL(vwv, 35, 0); /* reserved */
+                SSVAL(vwv + 0, 0, 0); /* reserved */
+                SCVAL(vwv + 1, 0, 0); /* reserved */
+                SIVAL(vwv + 1, 1, state->num_param);
+                SIVAL(vwv + 3, 1, state->num_data);
+                SIVAL(vwv + 5, 1, this_param);
+                SIVAL(vwv + 7, 1, param_offset);
+                SIVAL(vwv + 9, 1, state->param_sent);
+                SIVAL(vwv +11, 1, this_data);
+                SIVAL(vwv +13, 1, data_offset);
+                SIVAL(vwv +15, 1, state->data_sent);
+                SCVAL(vwv +17, 1, 0); /* reserved */
                 break;
+        }
 …
                 return tevent_req_post(req, ev);
+        }
-        state->mid = cli_smb_req_mid(subreq);
         status = cli_smb_req_send(subreq);
         if (!NT_STATUS_IS_OK(status)) {
 …
                 return tevent_req_post(req, state->ev);
+        }
-        cli_state_seqnum_persistent(cli, state->mid);
         tevent_req_set_callback(subreq, cli_trans_done, req);
+        /*
+         * Now get the MID of the primary request
+         * and mark it as persistent. This means
+         * we will able to send and receive multiple
+         * SMB pdus using this MID in both directions
+         * (including correct SMB signing).
+         */
+        state->mid = cli_smb_req_mid(subreq);
+        cli_smb_req_set_mid(subreq, state->mid);
+        state->primary_subreq = subreq;
+        talloc_set_destructor(state, cli_trans_state_destructor);
         return req;
+}
+static void cli_trans_done2(struct tevent_req *subreq);
 static void cli_trans_done(struct tevent_req *subreq)
 …
         uint32_t num_bytes;
         uint8_t *bytes;
+        uint8_t *inbuf;
         uint8_t num_setup       = 0;
         uint16_t *setup         = NULL;
 …
         uint8_t *data           = NULL;
+        status = cli_smb_recv(subreq, 0, &wct, &vwv, &num_bytes, &bytes);
+        status = cli_smb_recv(subreq, state, &inbuf, 0, &wct, &vwv,
+                              &num_bytes, &bytes);
+        /*
+         * Do not TALLOC_FREE(subreq) here, we might receive more than
+         * one response for the same mid.
+         */
         /*
 …
         status = cli_pull_trans(
                 cli_smb_inbuf(subreq), wct, vwv, num_bytes, bytes,
+                inbuf, wct, vwv, num_bytes, bytes,
                 state->cmd, !sent_all, &num_setup, &setup,
                 &total_param, &num_param, &param_disp, &param,
 …
         if (!sent_all) {
                 int iov_count;
+                TALLOC_FREE(subreq);
+                struct tevent_req *subreq2;
                 cli_trans_format(state, &wct, &iov_count);
                 subreq = cli_smb_req_create(state, state->ev, state->cli,
                                             state->cmd + 1, 0, wct, state->vwv,
                                             iov_count, state->iov);
                 if (tevent_req_nomem(subreq, req)) {
+                subreq2 = cli_smb_req_create(state, state->ev, state->cli,
+                                             state->cmd + 1, 0, wct, state->vwv,
+                                             iov_count, state->iov);
+                if (tevent_req_nomem(subreq2, req)) {
                         return;
+                }
                 cli_smb_req_set_mid(subreq, state->mid);
                 status = cli_smb_req_send(subreq);
+                cli_smb_req_set_mid(subreq2, state->mid);
+                status = cli_smb_req_send(subreq2);
                 if (!NT_STATUS_IS_OK(status)) {
                         goto fail;
+                }
+                tevent_req_set_callback(subreq, cli_trans_done, req);
+                tevent_req_set_callback(subreq2, cli_trans_done2, req);
                 return;
+        }
 …
         if ((state->rparam.total == state->rparam.received)
             && (state->rdata.total == state->rdata.received)) {
                 TALLOC_FREE(subreq);
                 cli_state_seqnum_remove(state->cli, state->mid);
+                state->recv_flags2 = SVAL(inbuf, smb_flg2);
+                cli_trans_cleanup_primary(state);
                 tevent_req_done(req);
                 return;
+        }
+        if (!cli_smb_req_set_pending(subreq)) {
+                status = NT_STATUS_NO_MEMORY;
+                goto fail;
+        }
+        TALLOC_FREE(inbuf);
         return;
  fail:
+        cli_state_seqnum_remove(state->cli, state->mid);
+        TALLOC_FREE(subreq);
+        cli_trans_cleanup_primary(state);
         tevent_req_nterror(req, status);
+}
+NTSTATUS cli_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                        uint16_t **setup, uint8_t *num_setup,
+                        uint8_t **param, uint32_t *num_param,
+                        uint8_t **data, uint32_t *num_data)
+{
+static void cli_trans_done2(struct tevent_req *subreq2)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq2, struct tevent_req);
         struct cli_trans_state *state = tevent_req_data(
                 req, struct cli_trans_state);
         NTSTATUS status;
+        bool sent_all;
+        uint8_t wct;
+        uint32_t seqnum;
+        /*
+         * First backup the seqnum of the secondary request
+         * and attach it to the primary request.
+         */
+        seqnum = cli_smb_req_seqnum(subreq2);
+        cli_smb_req_set_seqnum(state->primary_subreq, seqnum);
+        status = cli_smb_recv(subreq2, state, NULL, 0, &wct, NULL,
+                              NULL, NULL);
+        TALLOC_FREE(subreq2);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto fail;
+        }
+        if (wct != 0) {
+                status = NT_STATUS_INVALID_NETWORK_RESPONSE;
+                goto fail;
+        }
+        sent_all = ((state->param_sent == state->num_param)
+                    && (state->data_sent == state->num_data));
+        if (!sent_all) {
+                int iov_count;
+                cli_trans_format(state, &wct, &iov_count);
+                subreq2 = cli_smb_req_create(state, state->ev, state->cli,
+                                             state->cmd + 1, 0, wct, state->vwv,
+                                             iov_count, state->iov);
+                if (tevent_req_nomem(subreq2, req)) {
+                        return;
+                }
+                cli_smb_req_set_mid(subreq2, state->mid);
+                status = cli_smb_req_send(subreq2);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto fail;
+                }
+                tevent_req_set_callback(subreq2, cli_trans_done2, req);
+                return;
+        }
+        return;
+ fail:
+        cli_trans_cleanup_primary(state);
+        tevent_req_nterror(req, status);
+}
+NTSTATUS cli_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                        uint16_t *recv_flags2,
+                        uint16_t **setup, uint8_t min_setup,
+                        uint8_t *num_setup,
+                        uint8_t **param, uint32_t min_param,
+                        uint32_t *num_param,
+                        uint8_t **data, uint32_t min_data,
+                        uint32_t *num_data)
+{
+        struct cli_trans_state *state = tevent_req_data(
+                req, struct cli_trans_state);
+        NTSTATUS status;
+        cli_trans_cleanup_primary(state);
         if (tevent_req_is_nterror(req, &status)) {
                 return status;
+        }
+        if ((state->num_rsetup < min_setup)
+            || (state->rparam.total < min_param)
+            || (state->rdata.total < min_data)) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        if (recv_flags2 != NULL) {
+                *recv_flags2 = state->recv_flags2;
+        }
 …
                    uint8_t *param, uint32_t num_param, uint32_t max_param,
                    uint8_t *data, uint32_t num_data, uint32_t max_data,
+                   uint16_t **rsetup, uint8_t *num_rsetup,
+                   uint8_t **rparam, uint32_t *num_rparam,
+                   uint8_t **rdata, uint32_t *num_rdata)
+                   uint16_t *recv_flags2,
+                   uint16_t **rsetup, uint8_t min_rsetup, uint8_t *num_rsetup,
+                   uint8_t **rparam, uint32_t min_rparam, uint32_t *num_rparam,
+                   uint8_t **rdata, uint32_t min_rdata, uint32_t *num_rdata)
+{
         TALLOC_CTX *frame = talloc_stackframe();
 …
+        }
+        status = cli_trans_recv(req, mem_ctx, rsetup, num_rsetup,
+                                rparam, num_rparam, rdata, num_rdata);
+        status = cli_trans_recv(req, mem_ctx, recv_flags2,
+                                rsetup, min_rsetup, num_rsetup,
+                                rparam, min_rparam, num_rparam,
+                                rdata, min_rdata, num_rdata);
  fail:
         TALLOC_FREE(frame);

vendor/current/source3/libsmb/conncache.c

r414	r740
98	98	static NTSTATUS negative_conn_cache_valuedecode(const char *value)
99	99	{
100		unsigned int v = NT_STATUS_V(NT_STATUS_INTERNAL_ERROR);;
	100	unsigned int v = NT_STATUS_V(NT_STATUS_INTERNAL_ERROR);
101	101
102	102	if (value != NULL) {

vendor/current/source3/libsmb/dsgetdcname.c

-              r414
+              r740
 #include "includes.h"
+#define DSGETDCNAME_FMT "DSGETDCNAME/DOMAIN/%s"
+#include "libads/sitename_cache.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "libads/cldap.h"
+#include "libads/dns.h"
+#include "libsmb/clidgram.h"
 /* 15 minutes */
 #define DSGETDCNAME_CACHE_TTL   60*15
 …
+        }
+        return talloc_asprintf_strupper_m(mem_ctx, DSGETDCNAME_FMT, domain);
+        return talloc_asprintf_strupper_m(mem_ctx, "DSGETDCNAME/DOMAIN/%s",
+                                          domain);
+}
 …
         r->sockaddr.pdc_ip = talloc_strdup(mem_ctx, addr);
         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, r,
+        ndr_err = ndr_push_struct_blob(&blob, mem_ctx, r,
                        (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
+        }
         if (r->domain) {
                 status = dsgetdcname_cache_store(mem_ctx, r->domain, &blob);
+        if (r->domain_name) {
+                status = dsgetdcname_cache_store(mem_ctx, r->domain_name, &blob);
                 if (!NT_STATUS_IS_OK(status)) {
                         goto done;
+                }
                 if (r->client_site) {
                         sitename_store(r->domain, r->client_site);
+                        sitename_store(r->domain_name, r->client_site);
+                }
+        }
 …
+        }
         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &r,
+        ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
                       (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
 …
         dclist = TALLOC_ZERO_ARRAY(mem_ctx, struct ip_service_name, count);
         if (!dclist) {
+                SAFE_FREE(iplist);
                 return NT_STATUS_NO_MEMORY;
+        }
 …
                 r->hostname = talloc_strdup(mem_ctx, addr);
                 if (!r->hostname) {
+                        SAFE_FREE(iplist);
                         return NT_STATUS_NO_MEMORY;
+                }
 …
         *returned_dclist = dclist;
         *returned_count = count;
+        SAFE_FREE(iplist);
         return NT_STATUS_OK;
 …
                  * anything about the DC's   -- jerry */
                 if (!is_zero_addr((struct sockaddr *)(void *)&r->ss)) {
+                if (!is_zero_addr(&r->ss)) {
                         count++;
                         continue;
 …
                 info->forest_name = talloc_strdup(mem_ctx, forest_name);
                 NT_STATUS_HAVE_NO_MEMORY(info->forest_name);
                 flags |= DS_DNS_FOREST;
+                flags |= DS_DNS_FOREST_ROOT;
+        }
 …
         map_dc_and_domain_names(flags,
                                 r->pdc_name,
                                 r->domain,
+                                r->domain_name,
                                 r->pdc_dns_name,
                                 r->dns_domain,
 …
 /****************************************************************
 ****************************************************************/
-static struct event_context *ev_context(void)
+{
-        static struct event_context *ctx;
-        if (!ctx && !(ctx = event_context_init(NULL))) {
-                smb_panic("Could not init event context");
+        }
-        return ctx;
+}
-/****************************************************************
-****************************************************************/
-static struct messaging_context *msg_context(TALLOC_CTX *mem_ctx)
+{
-        static struct messaging_context *ctx;
-        if (!ctx && !(ctx = messaging_init(mem_ctx, server_id_self(),
-                                           ev_context()))) {
-                smb_panic("Could not init messaging context");
+        }
-        return ctx;
+}
 /****************************************************************
 …
                               NETLOGON_NT_VERSION_5EX_WITH_IP;
         if (!msg_ctx) {
                 msg_ctx = msg_context(mem_ctx);
+        if (msg_ctx == NULL) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
 …
         for (i=0; i<num_dcs; i++) {
+                uint16_t val;
+                int dgm_id;
+                generate_random_buffer((uint8_t *)&val, 2);
+                dgm_id = val;
                 ip_list.ss = dclist[i].ss;
 …
+                }
+                if (send_getdc_request(mem_ctx, msg_ctx,
+                                       &dclist[i].ss, domain_name,
+                                       NULL, nt_version))
+                {
+                        int k;
+                        smb_msleep(300);
+                        for (k=0; k<5; k++) {
+                                if (receive_getdc_response(mem_ctx,
+                                                           &dclist[i].ss,
+                                                           domain_name,
+                                                           &nt_version,
+                                                           &dc_name,
+                                                           &r)) {
+                                        store_cache = true;
+                                        namecache_store(dc_name, NBT_NAME_SERVER, 1, &ip_list);
+                                        goto make_reply;
+                                }
+                                smb_msleep(1500);
+                        }
+                status = nbt_getdc(msg_ctx, &dclist[i].ss, domain_name,
+                                   NULL, nt_version,
+                                   mem_ctx, &nt_version, &dc_name, &r);
+                if (NT_STATUS_IS_OK(status)) {
+                        store_cache = true;
+                        namecache_store(dc_name, NBT_NAME_SERVER, 1, &ip_list);
+                        goto make_reply;
+                }
 …
                         logon1.nt_version = nt_version;
                         logon1.server = tmp_dc_name;
                         logon1.domain = talloc_strdup_upper(mem_ctx, domain_name);
                         NT_STATUS_HAVE_NO_MEMORY(logon1.domain);
+                        logon1.pdc_name = tmp_dc_name;
+                        logon1.domain_name = talloc_strdup_upper(mem_ctx, domain_name);
+                        NT_STATUS_HAVE_NO_MEMORY(logon1.domain_name);
                         r->data.nt4 = logon1;

vendor/current/source3/libsmb/errormap.c

-              r414
+              r740
 #include "includes.h"
+#include "nsswitch/libwbclient/wbclient.h"
+#if HAVE_GSSAPI_GSSAPI_H
+#include <gssapi/gssapi.h>
+#elif HAVE_GSSAPI_GSSAPI_GENERIC_H
+#include <gssapi/gssapi_generic.h>
+#elif HAVE_GSSAPI_H
+#include <gssapi.h>
+#endif
 /* This map was extracted by the ERRMAPEXTRACT smbtorture command.
 …
 */
         {ERRSRV,        ERRbadpw,       NT_STATUS_WRONG_PASSWORD},
+        {ERRSRV,        ERRbaduid,      NT_STATUS_USER_SESSION_DELETED},
         {ERRHRD,        ERRgeneral,     NT_STATUS_ILL_FORMED_PASSWORD},
         {ERRHRD,        ERRgeneral,     NT_STATUS_PASSWORD_RESTRICTION},
 …
         {ERRDOS,        1022,   NT_STATUS(0x0000010c)},
         {ERRSRV,        ERRbadpw,       NT_STATUS_WRONG_PASSWORD},
+        {ERRSRV,        ERRbaduid,      NT_STATUS_USER_SESSION_DELETED},
         {ERRSRV,        ERRbadtype,     NT_STATUS_BAD_DEVICE_TYPE},
         {ERRSRV,        ERRaccess,      NT_STATUS_NETWORK_ACCESS_DENIED},
 …
+{
         int i;
         if (eclass == 0 && ecode == 0) return NT_STATUS_OK;
+        if (eclass == 0) return NT_STATUS_OK;
         for (i=0; NT_STATUS_V(dos_to_ntstatus_map[i].ntstatus); i++) {
                 if (eclass == dos_to_ntstatus_map[i].dos_class &&
 …
+}
-/*******************************************************************************
- Map between wbcErr and NT status.
-*******************************************************************************/
-static const struct {
-        wbcErr wbc_err;
-        NTSTATUS nt_status;
-} wbcErr_ntstatus_map[] = {
-        { WBC_ERR_SUCCESS,               NT_STATUS_OK },
-        { WBC_ERR_NOT_IMPLEMENTED,       NT_STATUS_NOT_IMPLEMENTED },
-        { WBC_ERR_UNKNOWN_FAILURE,       NT_STATUS_UNSUCCESSFUL },
-        { WBC_ERR_NO_MEMORY,             NT_STATUS_NO_MEMORY },
-        { WBC_ERR_INVALID_SID,           NT_STATUS_INVALID_SID },
-        { WBC_ERR_INVALID_PARAM,         NT_STATUS_INVALID_PARAMETER },
-        { WBC_ERR_WINBIND_NOT_AVAILABLE, NT_STATUS_SERVER_DISABLED },
-        { WBC_ERR_DOMAIN_NOT_FOUND,      NT_STATUS_NO_SUCH_DOMAIN },
-        { WBC_ERR_INVALID_RESPONSE,      NT_STATUS_INVALID_NETWORK_RESPONSE },
-        { WBC_ERR_NSS_ERROR,             NT_STATUS_INTERNAL_ERROR },
-        { WBC_ERR_AUTH_ERROR,            NT_STATUS_LOGON_FAILURE },
-        { WBC_ERR_UNKNOWN_USER,          NT_STATUS_NO_SUCH_USER },
-        { WBC_ERR_UNKNOWN_GROUP,         NT_STATUS_NO_SUCH_GROUP },
-        { WBC_ERR_PWD_CHANGE_FAILED,     NT_STATUS_PASSWORD_RESTRICTION }
-};
-NTSTATUS map_nt_error_from_wbcErr(wbcErr wbc_err)
+{
-        int i;
-        /* Look through list */
-        for (i=0;i<ARRAY_SIZE(wbcErr_ntstatus_map);i++) {
-                if (wbcErr_ntstatus_map[i].wbc_err == wbc_err) {
-                        return wbcErr_ntstatus_map[i].nt_status;
+                }
+        }
-        /* Default return */
-        return NT_STATUS_UNSUCCESSFUL;
+}
 #if defined(HAVE_GSSAPI)

vendor/current/source3/libsmb/libsmb_cache.c

-              r414
+              r740
    Copyright (C) John Terpstra 2000
    Copyright (C) Tom Jansen (Ninja ISD) 2002
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
 …
         char *username;
         SMBCSRV *server;
         struct smbc_server_cache *next, *prev;
 };
 …
+{
         struct smbc_server_cache * srvcache = NULL;
         if (!(srvcache = SMB_MALLOC_P(struct smbc_server_cache))) {
                 errno = ENOMEM;
 …
                 return 1;
+        }
         ZERO_STRUCTP(srvcache);
         srvcache->server = newsrv;
         srvcache->server_name = SMB_STRDUP(server);
         if (!srvcache->server_name) {
 …
                 goto failed;
+        }
         srvcache->share_name = SMB_STRDUP(share);
         if (!srvcache->share_name) {
 …
                 goto failed;
+        }
         srvcache->workgroup = SMB_STRDUP(workgroup);
         if (!srvcache->workgroup) {
 …
                 goto failed;
+        }
         srvcache->username = SMB_STRDUP(username);
         if (!srvcache->username) {
 …
                 goto failed;
+        }
         DLIST_ADD(context->internal->server_cache, srvcache);
         return 0;
 failed:
         SAFE_FREE(srvcache->server_name);
 …
         SAFE_FREE(srvcache->username);
         SAFE_FREE(srvcache);
         return 1;
+}
 …
+{
         struct smbc_server_cache * srv = NULL;
         /* Search the cache lines */
         for (srv = context->internal->server_cache; srv; srv = srv->next) {
                 if (strcmp(server,srv->server_name)  == 0 &&
                     strcmp(workgroup,srv->workgroup) == 0 &&
                     strcmp(user, srv->username)  == 0) {
                         /* If the share name matches, we're cool */
                         if (strcmp(share, srv->share_name) == 0) {
                                 return srv->server;
+                        }
                         /*
                          * We only return an empty share name or the attribute
 …
                         if (*share == '\0' || strcmp(share, "*IPC$") == 0)
                                 continue;
                         /*
                          * Never return an empty share name or the attribute
 …
                             strcmp(srv->share_name, "*IPC$") == 0)
                                 continue;
                         /*
                          * If we're only allowing one share per server, then
 …
                          */
                         if (smbc_getOptionOneSharePerServer(context)) {
+                                NTSTATUS status;
                                 /*
                                  * The currently connected share name
 …
                                  * disconnect from the current share.
                                  */
+                                if (! cli_tdis(srv->server->cli)) {
+                                status = cli_tdis(srv->server->cli);
+                                if (!NT_STATUS_IS_OK(status)) {
                                         /* Sigh. Couldn't disconnect. */
                                         cli_shutdown(srv->server->cli);
 …
                                         continue;
+                                }
                                 /*
                                  * Save the new share name.  We've
 …
                                         continue;
+                                }
                                 return srv->server;
+                        }
+                }
+        }
         return NULL;
+}
 …
+{
         struct smbc_server_cache * srv = NULL;
         for (srv = context->internal->server_cache; srv; srv = srv->next) {
                 if (server == srv->server) {
                         /* remove this sucker */
                         DLIST_REMOVE(context->internal->server_cache, srv);
 …
         struct smbc_server_cache * next;
         int could_not_purge_all = 0;
         for (srv = context->internal->server_cache,
                      next = (srv ? srv->next :NULL);
 …
              srv = next,
                      next = (srv ? srv->next : NULL)) {
                 if (SMBC_remove_unused_server(context, srv->server)) {
                         /* could not be removed */

vendor/current/source3/libsmb/libsmb_compat.c

-              r414
+              r740
    Copyright (C) Tom Jansen (Ninja ISD) 2002
    Copyright (C) Derrell Lipman 2003, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
+{
         struct smbc_compat_fdlist * f = smbc_compat_fd_avail;
         if (f) {
                 /* We found one that's available */
                 DLIST_REMOVE(smbc_compat_fd_avail, f);
         } else {
                 /*
 …
                         return -1;
+                }
                 f = SMB_MALLOC_P(struct smbc_compat_fdlist);
                 if (!f) {
 …
                         return -1;
+                }
                 f->fd = SMBC_BASE_FD + smbc_compat_nextfd++;
+        }
         f->file = file;
         DLIST_ADD(smbc_compat_fd_in_use, f);
         return f->fd;
+}
 …
+{
         struct smbc_compat_fdlist * f = smbc_compat_fd_in_use;
         while (f) {
                 if (f->fd == fd)
 …
                 f = f->next;
+        }
         if (f) {
                 /* found */
 …
                 if (!statcont)
                         return -1;
                 smbc_setDebug(statcont, debug);
                 smbc_setFunctionAuthData(statcont, fn);
                 if (!smbc_init_context(statcont)) {
                         smbc_free_context(statcont, False);
                         return -1;
+                }
                 smbc_compat_initialized = 1;
                 return 0;
+        }
 …
+{
         SMBCCTX *old_context = statcont;
         if (context) {
                 /* Save provided context.  It must have been initialized! */
                 statcont = context;
                 /* You'd better know what you're doing.  We won't help you. */
                 smbc_compat_initialized = 1;
+        }
         return old_context;
+}
 …
         SMBCFILE * file;
         int fd;
         file = smbc_getFunctionOpen(statcont)(statcont, furl, flags, mode);
         if (!file)
                 return -1;
         fd = add_fd(file);
         if (fd == -1)
 …
         SMBCFILE * file;
         int fd;
         file = smbc_getFunctionCreat(statcont)(statcont, furl, mode);
         if (!file)
                 return -1;
         fd = add_fd(file);
         if (fd == -1) {
 …
         SMBCFILE * file;
         int fd;
         file = smbc_getFunctionOpendir(statcont)(statcont, durl);
         if (!file)
                 return -1;
         fd = add_fd(file);
         if (fd == -1)
                 smbc_getFunctionClosedir(statcont)(statcont, file);
         return fd;
+}
 …
+{
         struct timeval tv[2];
         if (utbuf == NULL)
                 return smbc_getFunctionUtimes(statcont)(statcont, fname, NULL);
         tv[0].tv_sec = utbuf->actime;
         tv[1].tv_sec = utbuf->modtime;
         tv[0].tv_usec = tv[1].tv_usec = 0;
         return smbc_getFunctionUtimes(statcont)(statcont, fname, tv);
+}
 …
+{
         SMBCFILE * file;
         file = smbc_getFunctionOpenPrintJob(statcont)(statcont, fname);
         if (!file) return -1;

vendor/current/source3/libsmb/libsmb_context.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
+#include "secrets.h"
 …
     char *home = NULL;
     TALLOC_CTX *frame = talloc_stackframe();
     load_case_tables();
     setup_logging("libsmbclient", True);
+    load_case_tables_library();
+    setup_logging("libsmbclient", DEBUG_STDOUT);
     /* Here we would open the smb.conf file if needed ... */
     lp_set_in_client(True);
     home = getenv("HOME");
     if (home) {
 …
+        }
+    }
     if (!conf_loaded) {
         /*
 …
          * defaults ...
          */
         if (!lp_load(get_dyn_CONFIGFILE(), True, False, False, False)) {
             DEBUG(5, ("Could not load config file: %s\n",
 …
+        }
+    }
     load_interfaces();  /* Load the list of interfaces ... */
     reopen_logs();  /* Get logging working ... */
     /*
      * Block SIGPIPE (from lib/util_sock.c: write())
 …
      */
     BlockSignals(True, SIGPIPE);
     /* Create the mutex we'll use to protect initialized_ctx_count */
     if (SMB_THREAD_CREATE_MUTEX("initialized_ctx_count_mutex",
 …
+{
         SMBCCTX *context;
         /* The first call to this function should initialize the module */
         SMB_THREAD_ONCE(&SMBC_initialized, SMBC_module_init, NULL);
 …
                 return NULL;
+        }
         ZERO_STRUCTP(context);
         context->internal = SMB_MALLOC_P(struct SMBC_internal_data);
         if (!context->internal) {
 …
                 return NULL;
+        }
         /* Initialize the context and establish reasonable defaults */
         ZERO_STRUCTP(context->internal);
         smbc_setDebug(context, 0);
         smbc_setTimeout(context, 20000);
         smbc_setOptionFullTimeNames(context, False);
         smbc_setOptionOpenShareMode(context, SMBC_SHAREMODE_DENY_NONE);
 …
                 smbc_setOptionUseCCache(context, true);
+        }
         smbc_setFunctionAuthData(context, SMBC_get_auth_data);
         smbc_setFunctionCheckServer(context, SMBC_check_server);
         smbc_setFunctionRemoveUnusedServer(context, SMBC_remove_unused_server);
         smbc_setOptionUserData(context, NULL);
         smbc_setFunctionAddCachedServer(context, SMBC_add_cached_server);
 …
         smbc_setFunctionRemoveCachedServer(context, SMBC_remove_cached_server);
         smbc_setFunctionPurgeCachedServers(context, SMBC_purge_cached_servers);
         smbc_setFunctionOpen(context, SMBC_open_ctx);
         smbc_setFunctionCreat(context, SMBC_creat_ctx);
 …
         smbc_setFunctionRemovexattr(context, SMBC_removexattr_ctx);
         smbc_setFunctionListxattr(context, SMBC_listxattr_ctx);
         smbc_setFunctionOpenPrintJob(context, SMBC_open_print_job_ctx);
         smbc_setFunctionPrintFile(context, SMBC_print_file_ctx);
         smbc_setFunctionListPrintJobs(context, SMBC_list_print_jobs_ctx);
         smbc_setFunctionUnlinkPrintJob(context, SMBC_unlink_print_job_ctx);
         return context;
+}
 …
                 return 1;
+        }
         if (shutdown_ctx) {
                 SMBCFILE * f;
                 DEBUG(1,("Performing aggressive shutdown.\n"));
                 f = context->internal->files;
                 while (f) {
 …
+                }
                 context->internal->files = NULL;
                 /* First try to remove the servers the nice way. */
                 if (smbc_getFunctionPurgeCachedServers(context)(context)) {
 …
+                }
+        }
         /* Things we have to clean up */
         smbc_setWorkgroup(context, NULL);
         smbc_setNetbiosName(context, NULL);
         smbc_setUser(context, NULL);
         DEBUG(3, ("Context %p successfully freed\n", context));
 …
                 smb_panic("error unlocking 'initialized_ctx_count'");
+        }
         return 0;
+}
 …
                 const char *s;
         } option_value;
         va_start(ap, option_name);
         if (strcmp(option_name, "debug_to_stderr") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
                 smbc_setOptionDebugToStderr(context, option_value.b);
         } else if (strcmp(option_name, "full_time_names") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
                 smbc_setOptionFullTimeNames(context, option_value.b);
         } else if (strcmp(option_name, "open_share_mode") == 0) {
                 option_value.i = va_arg(ap, int);
                 smbc_setOptionOpenShareMode(context, option_value.i);
         } else if (strcmp(option_name, "auth_function") == 0) {
                 option_value.auth_fn =
                         va_arg(ap, smbc_get_auth_data_with_context_fn);
                 smbc_setFunctionAuthDataWithContext(context, option_value.auth_fn);
         } else if (strcmp(option_name, "user_data") == 0) {
                 option_value.v = va_arg(ap, void *);
                 smbc_setOptionUserData(context, option_value.v);
         } else if (strcmp(option_name, "smb_encrypt_level") == 0) {
                 option_value.s = va_arg(ap, const char *);
 …
                                                          SMBC_ENCRYPTLEVEL_REQUIRE);
+                }
         } else if (strcmp(option_name, "browse_max_lmb_count") == 0) {
                 option_value.i = va_arg(ap, int);
                 smbc_setOptionBrowseMaxLmbCount(context, option_value.i);
         } else if (strcmp(option_name, "urlencode_readdir_entries") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
                 smbc_setOptionUrlEncodeReaddirEntries(context, option_value.b);
         } else if (strcmp(option_name, "one_share_per_server") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
                 smbc_setOptionOneSharePerServer(context, option_value.b);
         } else if (strcmp(option_name, "use_kerberos") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
                 smbc_setOptionUseKerberos(context, option_value.b);
         } else if (strcmp(option_name, "fallback_after_kerberos") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
                 smbc_setOptionFallbackAfterKerberos(context, option_value.b);
         } else if (strcmp(option_name, "use_ccache") == 0) {
                 option_value.b = (bool) va_arg(ap, int);
 …
                 smbc_setOptionNoAutoAnonymousLogin(context, option_value.b);
+        }
         va_end(ap);
+}
 …
                 return (void *) smbc_getOptionDebugToStderr(context);
 #endif
         } else if (strcmp(option_name, "full_time_names") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) smbc_getOptionFullTimeNames(context);
 #endif
         } else if (strcmp(option_name, "open_share_mode") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) smbc_getOptionOpenShareMode(context);
 #endif
         } else if (strcmp(option_name, "auth_function") == 0) {
                 return (void *) smbc_getFunctionAuthDataWithContext(context);
         } else if (strcmp(option_name, "user_data") == 0) {
                 return smbc_getOptionUserData(context);
         } else if (strcmp(option_name, "smb_encrypt_level") == 0) {
                 switch(smbc_getOptionSmbEncryptionLevel(context))
 …
                         return (void *) "require";
+                }
         } else if (strcmp(option_name, "smb_encrypt_on") == 0) {
                 SMBCSRV *s;
                 unsigned int num_servers = 0;
                 for (s = context->internal->servers; s; s = s->next) {
                         num_servers++;
 …
                 return (void *) (bool) (num_servers > 0);
 #endif
         } else if (strcmp(option_name, "browse_max_lmb_count") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) smbc_getOptionBrowseMaxLmbCount(context);
 #endif
         } else if (strcmp(option_name, "urlencode_readdir_entries") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) (bool) smbc_getOptionUrlEncodeReaddirEntries(context);
 #endif
         } else if (strcmp(option_name, "one_share_per_server") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) (bool) smbc_getOptionOneSharePerServer(context);
 #endif
         } else if (strcmp(option_name, "use_kerberos") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) (bool) smbc_getOptionUseKerberos(context);
 #endif
         } else if (strcmp(option_name, "fallback_after_kerberos") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
                 return (void *) (bool) smbc_getOptionFallbackAfterKerberos(context);
 #endif
         } else if (strcmp(option_name, "use_ccache") == 0) {
 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
 …
 #endif
+        }
         return NULL;
+}
 …
+{
         int pid;
         if (!context) {
                 errno = EBADF;
                 return NULL;
+        }
         /* Do not initialise the same client twice */
         if (context->internal->initialized) {
                 return NULL;
+        }
+        if (context->internal->debug_stderr) {
+            /*
+             * Hmmm... Do we want a unique dbf per-thread? For now, we'll just
+             * leave it up to the user. If any one context spefies debug to
+             * stderr then all will be.
+             */
+            dbf = x_stderr;
+            x_setbuf(x_stderr, NULL);
+        }
         if ((!smbc_getFunctionAuthData(context) &&
              !smbc_getFunctionAuthDataWithContext(context)) ||
             smbc_getDebug(context) < 0 ||
             smbc_getDebug(context) > 100) {
                 errno = EINVAL;
                 return NULL;
+        }
+        }
         if (!smbc_getUser(context)) {
                 /*
                  * FIXME: Is this the best way to get the user info?
                  */
                 char *user = getenv("USER");
+                char *user = getenv("USER");
                 /* walk around as "guest" if no username can be found */
                 if (!user) {
 …
                 SAFE_FREE(user);
                 if (!smbc_getUser(context)) {
+                if (!smbc_getUser(context)) {
                         errno = ENOMEM;
                         return NULL;
+                }
+        }
         if (!smbc_getNetbiosName(context)) {
                 /*
 …
                         return NULL;
+                }
                 smbc_setNetbiosName(context, netbios_name);
                 SAFE_FREE(netbios_name);
 …
+                }
+        }
         DEBUG(1, ("Using netbios name %s.\n", smbc_getNetbiosName(context)));
         if (!smbc_getWorkgroup(context)) {
                 char *workgroup;
 …
+                }
+        }
         DEBUG(1, ("Using workgroup %s.\n", smbc_getWorkgroup(context)));
         /* shortest timeout is 1 second */
         if (smbc_getTimeout(context) > 0 && smbc_getTimeout(context) < 1000)
                 smbc_setTimeout(context, 1000);
         context->internal->initialized = True;
 …
                 smb_panic("error unlocking 'initialized_ctx_count'");
+        }
         return context;
+}

vendor/current/source3/libsmb/libsmb_dir.c

-              r414
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
+#include "popt_common.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
+#include "../librpc/gen_ndr/cli_srvsvc.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
+#include "libsmb/nmblib.h"
 /*
 …
         if (add_dirent(dir, name, comment, dirent_type) < 0) {
                 /* An error occurred, what do we do? */
                 /* FIXME: Add some code here */
+                /* Change cli_NetServerEnum to take a fn
+                   returning NTSTATUS... JRA. */
+        }
 …
         if (add_dirent(dir, name, comment, dirent_type) < 0) {
                 /* An error occurred, what do we do? */
                 /* FIXME: Add some code here */
+        }
+}
+static void
+                /* Change cli_NetServerEnum to take a fn
+                   returning NTSTATUS... JRA. */
+        }
+}
+static NTSTATUS
 dir_list_fn(const char *mnt,
             file_info *finfo,
+            struct file_info *finfo,
             const char *mask,
             void *state)
 …
         if (add_dirent((SMBCFILE *)state, finfo->name, "",
+                       (finfo->mode&aDIR?SMBC_DIR:SMBC_FILE)) < 0) {
+                /* Handle an error ... */
+                /* FIXME: Add some code ... */
+        }
+                       (finfo->mode&FILE_ATTRIBUTE_DIRECTORY?SMBC_DIR:SMBC_FILE)) < 0) {
+                SMBCFILE *dir = (SMBCFILE *)state;
+                return map_nt_error_from_unix(dir->dir_error);
+        }
+        return NT_STATUS_OK;
+}
 …
         uint32_t resume_handle = 0;
         uint32_t total_entries = 0;
+        struct dcerpc_binding_handle *b;
         /* Open the server service pipe */
 …
         info_ctr.ctr.ctr1 = &ctr1;
+        b = pipe_hnd->binding_handle;
         /* Issue the NetShareEnum RPC call and retrieve the response */
         nt_status = rpccli_srvsvc_NetShareEnumAll(pipe_hnd, talloc_tos(),
+        nt_status = dcerpc_srvsvc_NetShareEnumAll(b, talloc_tos(),
                                                   pipe_hnd->desthost,
                                                   &info_ctr,
 …
         /* Was it successful? */
+        if (!NT_STATUS_IS_OK(nt_status) || !W_ERROR_IS_OK(result) ||
+            total_entries == 0) {
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                /*  Nope.  Go clean up. */
+                result = ntstatus_to_werror(nt_status);
+                goto done;
+        }
+        if (!W_ERROR_IS_OK(result)) {
                 /*  Nope.  Go clean up. */
                 goto done;
+        }
+        if (total_entries == 0) {
+                /*  Nope.  Go clean up. */
+                result = WERR_GENERAL_FAILURE;
+                goto done;
+        }
         /* For each returned entry... */
 …
         if (!context || !context->internal->initialized) {
                 DEBUG(4, ("no valid context\n"));
+                TALLOC_FREE(frame);
                 errno = EINVAL + 8192;
-                TALLOC_FREE(frame);
                 return NULL;
 …
         if (!fname) {
                 DEBUG(4, ("no valid fname\n"));
+                TALLOC_FREE(frame);
                 errno = EINVAL + 8193;
-                TALLOC_FREE(frame);
                 return NULL;
+        }
 …
                             &options)) {
                 DEBUG(4, ("no valid path\n"));
+                TALLOC_FREE(frame);
                 errno = EINVAL + 8194;
-                TALLOC_FREE(frame);
                 return NULL;
+        }
 …
         if (SMBC_check_options(server, share, path, options)) {
                 DEBUG(4, ("unacceptable options (%s)\n", options));
+                TALLOC_FREE(frame);
                 errno = EINVAL + 8195;
-                TALLOC_FREE(frame);
                 return NULL;
+        }
 …
                 user = talloc_strdup(frame, smbc_getUser(context));
                 if (!user) {
+                        TALLOC_FREE(frame);
                         errno = ENOMEM;
-                        TALLOC_FREE(frame);
                         return NULL;
+                }
 …
         if (!dir) {
+                TALLOC_FREE(frame);
                 errno = ENOMEM;
-                TALLOC_FREE(frame);
                 return NULL;
+        }
 …
                 int count;
                 int max_lmb_count;
                 struct ip_service *ip_list;
                 struct ip_service server_addr;
+                struct sockaddr_storage *ip_list;
+                struct sockaddr_storage server_addr;
                 struct user_auth_info u_info;
+                NTSTATUS status;
                 if (share[0] != (char)0 || path[0] != (char)0) {
-                        errno = EINVAL + 8196;
                         if (dir) {
                                 SAFE_FREE(dir->fname);
 …
+                        }
                         TALLOC_FREE(frame);
+                        errno = EINVAL + 8196;
                         return NULL;
+                }
 …
                 ip_list = NULL;
+                if (!NT_STATUS_IS_OK(name_resolve_bcast(MSBROWSE, 1, &ip_list,
+                                                        &count)))
+                status = name_resolve_bcast(MSBROWSE, 1, talloc_tos(),
+                                            &ip_list, &count);
+                if (!NT_STATUS_IS_OK(status))
+                {
                         SAFE_FREE(ip_list);
                         if (!find_master_ip(workgroup, &server_addr.ss)) {
+                        TALLOC_FREE(ip_list);
+                        if (!find_master_ip(workgroup, &server_addr)) {
                                 if (dir) {
 …
                                         SAFE_FREE(dir);
+                                }
+                                TALLOC_FREE(frame);
                                 errno = ENOENT;
-                                TALLOC_FREE(frame);
                                 return NULL;
+                        }
+                        ip_list = (struct ip_service *)memdup(
+                                &server_addr, sizeof(server_addr));
+                        ip_list = (struct sockaddr_storage *)talloc_memdup(
+                                talloc_tos(), &server_addr,
+                                sizeof(server_addr));
                         if (ip_list == NULL) {
+                                if (dir) {
+                                        SAFE_FREE(dir->fname);
+                                        SAFE_FREE(dir);
+                                }
+                                TALLOC_FREE(frame);
                                 errno = ENOMEM;
-                                TALLOC_FREE(frame);
                                 return NULL;
+                        }
 …
                         struct cli_state *cli = NULL;
                         print_sockaddr(addr, sizeof(addr), &ip_list[i].ss);
+                        print_sockaddr(addr, sizeof(addr), &ip_list[i]);
                         DEBUG(99, ("Found master browser %d of %d: %s\n",
                                    i+1, MAX(count, max_lmb_count),
 …
                         if (!workgroup || !server) {
+                                if (dir) {
+                                        SAFE_FREE(dir->fname);
+                                        SAFE_FREE(dir);
+                                }
+                                TALLOC_FREE(frame);
                                 errno = ENOMEM;
-                                TALLOC_FREE(frame);
                                 return NULL;
+                        }
 …
+                }
                 SAFE_FREE(ip_list);
+                TALLOC_FREE(ip_list);
         } else {
                 /*
 …
                                 /* Should not have empty share with path */
-                                errno = EINVAL + 8197;
                                 if (dir) {
                                         SAFE_FREE(dir->fname);
 …
+                                }
                                 TALLOC_FREE(frame);
+                                errno = EINVAL + 8197;
                                 return NULL;
 …
                                                 SAFE_FREE(dir);
+                                        }
+                                        TALLOC_FREE(frame);
                                         errno = EPERM;
-                                        TALLOC_FREE(frame);
                                         return NULL;
 …
                         char *targetpath;
                         struct cli_state *targetcli;
+                        NTSTATUS status;
                         /* We connect to the server and list the directory */
 …
+                        }
                         if (cli_list(targetcli, targetpath,
                                      aDIR | aSYSTEM | aHIDDEN,
+                                     dir_list_fn, (void *)dir) < 0) {
+                        status = cli_list(targetcli, targetpath,
+                                          FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
+                                          dir_list_fn, (void *)dir);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 if (dir) {
                                         SAFE_FREE(dir->fname);
 …
+                                }
+                                TALLOC_FREE(frame);
                                 errno = saved_errno;
-                                TALLOC_FREE(frame);
                                 return NULL;
+                        }
 …
         while ((dirlist = dir->dir_next)) {
                 struct smbc_dirent *dirent;
+                struct smbc_dirent *currentEntry = (struct smbc_dirent *)ndir;
                 if (!dirlist->dirent) {
 …
+                }
+                memcpy(ndir, dirent, reqd); /* Copy the data in ... */
+                ((struct smbc_dirent *)ndir)->comment =
+                        (char *)(&((struct smbc_dirent *)ndir)->name +
+                                 dirent->namelen +
+);
+                memcpy(currentEntry, dirent, reqd); /* Copy the data in ... */
+                currentEntry->comment = &currentEntry->name[0] +
+                                                dirent->namelen + 1;
                 ndir += reqd;
                 rem -= reqd;
+                /* Try and align the struct for the next entry
+                   on a valid pointer boundary by appending zeros */
+                while((rem > 0) && ((unsigned long long)ndir & (sizeof(void*) - 1))) {
+                        *ndir = '\0';
+                        rem--;
+                        ndir++;
+                        currentEntry->dirlen++;
+                }
                 dir->dir_next = dirlist = dirlist -> next;
 …
  */
 static void
+static NTSTATUS
 rmdir_list_fn(const char *mnt,
               file_info *finfo,
+              struct file_info *finfo,
               const char *mask,
               void *state)
 …
                 *smbc_rmdir_dirempty = false;
+        }
+        return NT_STATUS_OK;
+}
 …
                         char *lpath;
                         bool smbc_rmdir_dirempty = true;
+                        NTSTATUS status;
                         lpath = talloc_asprintf(frame, "%s\\*",
 …
+                        }
+                        if (cli_list(targetcli, lpath,
+                                     aDIR | aSYSTEM | aHIDDEN,
+                                     rmdir_list_fn,
+                                     &smbc_rmdir_dirempty) < 0) {
+                        status = cli_list(targetcli, lpath,
+                                          FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
+                                          rmdir_list_fn,
+                                          &smbc_rmdir_dirempty);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 /* Fix errno to ignore latest error ... */
                                 DEBUG(5, ("smbc_rmdir: "
 …
         mode = 0;
         if (!(newmode & (S_IWUSR | S_IWGRP | S_IWOTH))) mode |= aRONLY;
         if ((newmode & S_IXUSR) && lp_map_archive(-1)) mode |= aARCH;
         if ((newmode & S_IXGRP) && lp_map_system(-1)) mode |= aSYSTEM;
         if ((newmode & S_IXOTH) && lp_map_hidden(-1)) mode |= aHIDDEN;
+        if (!(newmode & (S_IWUSR | S_IWGRP | S_IWOTH))) mode |= FILE_ATTRIBUTE_READONLY;
+        if ((newmode & S_IXUSR) && lp_map_archive(-1)) mode |= FILE_ATTRIBUTE_ARCHIVE;
+        if ((newmode & S_IXGRP) && lp_map_system(-1)) mode |= FILE_ATTRIBUTE_SYSTEM;
+        if ((newmode & S_IXOTH) && lp_map_hidden(-1)) mode |= FILE_ATTRIBUTE_HIDDEN;
         if (!NT_STATUS_IS_OK(cli_setatr(targetcli, targetpath, mode, 0))) {
 …
         /*d_printf(">>>unlink: resolved path as %s\n", targetpath);*/
         if (!NT_STATUS_IS_OK(cli_unlink(targetcli, targetpath, aSYSTEM | aHIDDEN))) {
+        if (!NT_STATUS_IS_OK(cli_unlink(targetcli, targetpath, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN))) {
                 errno = SMBC_errno(context, targetcli);
 …
                 if (eno != EEXIST ||
                     !NT_STATUS_IS_OK(cli_unlink(targetcli1, targetpath2, aSYSTEM | aHIDDEN)) ||
+                    !NT_STATUS_IS_OK(cli_unlink(targetcli1, targetpath2, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN)) ||
                     !NT_STATUS_IS_OK(cli_rename(targetcli1, targetpath1, targetpath2))) {

vendor/current/source3/libsmb/libsmb_file.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
 …
         NTSTATUS status = NT_STATUS_OBJECT_PATH_INVALID;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;  /* Best I can think of ... */
                 TALLOC_FREE(frame);
                 return NULL;
+        }
+        }
         if (!fname) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return NULL;
+        }
+        }
         if (SMBC_parse_path(frame,
                             context,
 …
                 return NULL;
+        }
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
         if (!srv) {
                 if (errno == EPERM) errno = EACCES;
 …
                 return NULL;  /* SMBC_server sets errno */
+        }
         /* Hmmm, the test for a directory is suspect here ... FIXME */
         if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') {
                 status = NT_STATUS_OBJECT_PATH_INVALID;
         } else {
                 file = SMB_MALLOC_P(SMBCFILE);
                 if (!file) {
                         errno = ENOMEM;
 …
                         return NULL;
+                }
                 ZERO_STRUCTP(file);
                 /*d_printf(">>>open: resolving %s\n", path);*/
                 if (!cli_resolve_path(frame, "", context->internal->auth_info,
 …
+                }
                 /*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/
                 status = cli_open(targetcli, targetpath, flags,
                                    context->internal->share_mode, &fd);
                 if (!NT_STATUS_IS_OK(status)) {
                         /* Handle the error ... */
                         SAFE_FREE(file);
                         errno = SMBC_errno(context, targetcli);
                         TALLOC_FREE(frame);
                         return NULL;
+                }
                 /* Fill in file struct */
                 file->cli_fd  = fd;
                 file->fname   = SMB_STRDUP(fname);
 …
                 file->offset  = 0;
                 file->file    = True;
                 DLIST_ADD(context->internal->files, file);
                 /*
                  * If the file was opened in O_APPEND mode, all write
 …
+                        }
+                }
                 TALLOC_FREE(frame);
                 return file;
+        }
+        }
         /* Check if opendir needed ... */
         if (!NT_STATUS_IS_OK(status)) {
                 int eno = 0;
                 eno = SMBC_errno(context, srv->cli);
                 file = smbc_getFunctionOpendir(context)(context, fname);
 …
                 TALLOC_FREE(frame);
                 return file;
+        }
+        }
         errno = EINVAL; /* FIXME, correct errno ? */
         TALLOC_FREE(frame);
         return NULL;
+}
 …
                mode_t mode)
+{
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;
                 return NULL;
+        }
+        }
         return SMBC_open_ctx(context, path,
                              O_WRONLY | O_CREAT | O_TRUNC, mode);
 …
         struct cli_state *targetcli = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         /*
          * offset:
 …
          */
         off_t offset;
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         DEBUG(4, ("smbc_read(%p, %d)\n", file, (int)count));
         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
                 errno = EBADF;
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         offset = file->offset;
         /* Check that the buffer exists ... */
         if (buf == NULL) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         /*d_printf(">>>read: parsing %s\n", file->fname);*/
         if (SMBC_parse_path(frame,
 …
                 return -1;
+        }
         /*d_printf(">>>read: resolving %s\n", path);*/
         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 …
+        }
         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
         ret = cli_read(targetcli, file->cli_fd, (char *)buf, offset, count);
         if (ret < 0) {
                 errno = SMBC_errno(context, targetcli);
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         file->offset += ret;
         DEBUG(4, ("  --> %d\n", ret));
         TALLOC_FREE(frame);
         return ret;  /* Success, ret bytes of data ... */
+}
 …
                size_t count)
+{
-        int ret;
         off_t offset;
         char *server = NULL, *share = NULL, *user = NULL, *password = NULL;
 …
         struct cli_state *targetcli = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
+        NTSTATUS status;
         /* First check all pointers before dereferencing them */
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
                 errno = EBADF;
 …
                 return -1;
+        }
         /* Check that the buffer exists ... */
         if (buf == NULL) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         offset = file->offset; /* See "offset" comment in SMBC_read_ctx() */
         /*d_printf(">>>write: parsing %s\n", file->fname);*/
         if (SMBC_parse_path(frame,
 …
+        }
         /*d_printf(">>>write: resolved path as %s\n", targetpath);*/
+        ret = cli_write(targetcli, file->cli_fd,
+, (char *)buf, offset, count);
+        if (ret <= 0) {
+                errno = SMBC_errno(context, targetcli);
+                TALLOC_FREE(frame);
+                return -1;
+        }
+        file->offset += ret;
+        status = cli_writeall(targetcli, file->cli_fd,
+, (uint8_t *)buf, offset, count, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                errno = map_errno_from_nt_status(status);
+                TALLOC_FREE(frame);
+                return -1;
+        }
+        file->offset += count;
         TALLOC_FREE(frame);
         return ret;  /* Success, 0 bytes of data ... */
+        return count;  /* Success, 0 bytes of data ... */
+}
 …
         struct cli_state *targetcli = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
                 errno = EBADF;
 …
                 return -1;
+        }
         /* IS a dir ... */
         if (!file->file) {
 …
                 return smbc_getFunctionClosedir(context)(context, file);
+        }
         /*d_printf(">>>close: parsing %s\n", file->fname);*/
         if (SMBC_parse_path(frame,
 …
                 return -1;
+        }
         /*d_printf(">>>close: resolving %s\n", path);*/
         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 …
+        }
         /*d_printf(">>>close: resolved path as %s\n", targetpath);*/
         if (!NT_STATUS_IS_OK(cli_close(targetcli, file->cli_fd))) {
                 DEBUG(3, ("cli_close failed on %s. purging server.\n",
                           file->fname));
 …
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         DLIST_REMOVE(context->internal->files, file);
         SAFE_FREE(file->fname);
         SAFE_FREE(file);
         TALLOC_FREE(frame);
         return 0;
+}
 …
         time_t write_time;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return False;
+        }
         /* path fixup for . and .. */
         if (strequal(path, ".") || strequal(path, "..")) {
 …
+        }
         DEBUG(4,("SMBC_getatr: sending qpathinfo\n"));
         if (!cli_resolve_path(frame, "", context->internal->auth_info,
                         srv->cli, fixedpath,
 …
                 return False;
+        }
         if (!srv->no_pathinfo2 &&
             cli_qpathinfo2(targetcli, targetpath,
+            NT_STATUS_IS_OK(cli_qpathinfo2(targetcli, targetpath,
                            create_time_ts,
                            access_time_ts,
                            write_time_ts,
                            change_time_ts,
                            size, mode, ino)) {
+                           size, mode, ino))) {
                 TALLOC_FREE(frame);
                 return True;
+        }
         /* if this is NT then don't bother with the getatr */
         if (targetcli->capabilities & CAP_NT_SMBS) {
 …
                 return False;
+        }
         if (NT_STATUS_IS_OK(cli_getatr(targetcli, targetpath, mode, size, &write_time))) {
                 struct timespec w_time_ts;
                 w_time_ts = convert_time_t_to_timespec(write_time);
                 if (write_time_ts != NULL) {
                         *write_time_ts = w_time_ts;
+                }
                 if (create_time_ts != NULL) {
                         *create_time_ts = w_time_ts;
+                }
                 if (access_time_ts != NULL) {
                         *access_time_ts = w_time_ts;
+                }
                 if (change_time_ts != NULL) {
                         *change_time_ts = w_time_ts;
+                }
                 srv->no_pathinfo2 = True;
                 TALLOC_FREE(frame);
                 return True;
+        }
         errno = EPERM;
         TALLOC_FREE(frame);
         return False;
+}
 …
         int ret;
         TALLOC_CTX *frame = talloc_stackframe();
         /*
          * First, try setpathinfo (if qpathinfo succeeded), for it is the
 …
          */
         if (srv->no_pathinfo ||
             ! cli_setpathinfo(srv->cli, path,
                               create_time,
                               access_time,
                               write_time,
                               change_time,
                               mode)) {
+            !NT_STATUS_IS_OK(cli_setpathinfo_basic(srv->cli, path,
+                                                   create_time,
+                                                   access_time,
+                                                   write_time,
+                                                   change_time,
+                                                   mode))) {
                 /*
                  * setpathinfo is not supported; go to plan B.
 …
                  * supports both times.
                  */
                 /* Don't try {q,set}pathinfo() again, with this server */
                 srv->no_pathinfo = True;
                 /* Open the file */
                 if (!NT_STATUS_IS_OK(cli_open(srv->cli, path, O_RDWR, DENY_NONE, &fd))) {
                         errno = SMBC_errno(context, srv->cli);
                         TALLOC_FREE(frame);
                         return -1;
+                }
                 /* Set the new attributes */
                 ret = NT_STATUS_IS_OK(cli_setattrE(srv->cli, fd,
 …
                                    access_time,
                                    write_time));
                 /* Close the file */
                 cli_close(srv->cli, fd);
                 /*
                  * Unfortunately, setattrE() doesn't have a provision for
 …
                         ret = NT_STATUS_IS_OK(cli_setatr(srv->cli, path, mode, 0));
+                }
                 if (! ret) {
                         errno = SMBC_errno(context, srv->cli);
 …
+                }
+        }
         TALLOC_FREE(frame);
         return True;
 …
         struct cli_state *targetcli = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
                 errno = EBADF;
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         if (!file->file) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return -1;      /* Can't lseek a dir ... */
+        }
+        }
         switch (whence) {
         case SEEK_SET:
                 file->offset = offset;
                 break;
         case SEEK_CUR:
                 file->offset += offset;
                 break;
         case SEEK_END:
                 /*d_printf(">>>lseek: parsing %s\n", file->fname);*/
 …
                         return -1;
+                }
                 /*d_printf(">>>lseek: resolving %s\n", path);*/
                 if (!cli_resolve_path(frame, "", context->internal->auth_info,
 …
                         return -1;
+                }
                 /*d_printf(">>>lseek: resolved path as %s\n", targetpath);*/
                 if (!cli_qfileinfo(targetcli, file->cli_fd, NULL,
+                                   &size, NULL, NULL, NULL, NULL, NULL))
+                {
+                if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
+                                             targetcli, file->cli_fd, NULL,
+                                             &size, NULL, NULL, NULL, NULL,
+                                             NULL))) {
                         SMB_OFF_T b_size = size;
                         if (!NT_STATUS_IS_OK(cli_getattrE(targetcli, file->cli_fd,
 …
                 file->offset = size + offset;
                 break;
         default:
                 errno = EINVAL;
                 break;
+        }
+        }
         TALLOC_FREE(frame);
         return file->offset;
+}
 …
         struct cli_state *targetcli = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
                 errno = EBADF;
 …
                 return -1;
+        }
         if (!file->file) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         /*d_printf(">>>fstat: parsing %s\n", file->fname);*/
         if (SMBC_parse_path(frame,
 …
                 return -1;
+        }
         /*d_printf(">>>fstat: resolving %s\n", path);*/
         if (!cli_resolve_path(frame, "", context->internal->auth_info,
 …
+        }
         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
         if (!NT_STATUS_IS_OK(cli_ftruncate(targetcli, file->cli_fd, (uint64_t)size))) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         TALLOC_FREE(frame);
         return 0;
+}

vendor/current/source3/libsmb/libsmb_misc.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
 …
+{
         int ret = cli_errno(c);
         if (cli_is_dos_error(c)) {
                 uint8 eclass;
                 uint32 ecode;
                 cli_dos_error(c, &eclass, &ecode);
                 DEBUG(3,("smbc_error %d %d (0x%x) -> %d\n",
                          (int)eclass, (int)ecode, (int)ecode, ret));
         } else {
                 NTSTATUS status;
                 status = cli_nt_error(c);
                 DEBUG(3,("smbc errno %s -> %d\n",
                          nt_errstr(status), ret));
+        }
         return ret;
+}

vendor/current/source3/libsmb/libsmb_path.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
         size_t newlen = 1;
         char *p, *dest;
         if (old_length == 0) {
                 return 0;
+        }
         *pp_dest = NULL;
         for (i = 0; i < old_length; ) {
                 unsigned char character = src[i++];
                 if (character == '%') {
                         int a = i+1 < old_length ? hex2int(src[i]) : -1;
                         int b = i+1 < old_length ? hex2int(src[i+1]) : -1;
                         /* Replace valid sequence */
                         if (a != -1 && b != -1) {
 …
                 newlen++;
+        }
         dest = TALLOC_ARRAY(ctx, char, newlen);
         if (!dest) {
                 return err_count;
+        }
         err_count = 0;
         for (p = dest, i = 0; i < old_length; ) {
                 unsigned char character = src[i++];
                 if (character == '%') {
                         int a = i+1 < old_length ? hex2int(src[i]) : -1;
                         int b = i+1 < old_length ? hex2int(src[i+1]) : -1;
                         /* Replace valid sequence */
                         if (a != -1 && b != -1) {
 …
                 *p++ = character;
+        }
         *p = '\0';
         *pp_dest = dest;
 …
         char *pdest;
         int ret = urldecode_talloc(frame, &pdest, src);
         if (pdest) {
                 strlcpy(dest, pdest, max_dest_len);
 …
+{
         char hex[] = "0123456789ABCDEF";
         for (; *src != '\0' && max_dest_len >= 3; src++) {
                 if ((*src < '0' &&
                      *src != '-' &&
 …
+                }
+        }
         *dest++ = '\0';
         max_dest_len--;
         return max_dest_len;
+}
 …
         char *workgroup = NULL;
         int len;
         /* Ensure these returns are at least valid pointers. */
         *pp_server = talloc_strdup(ctx, "");
 …
         *pp_user = talloc_strdup(ctx, "");
         *pp_password = talloc_strdup(ctx, "");
         if (!*pp_server || !*pp_share || !*pp_path ||
             !*pp_user || !*pp_password) {
                 return -1;
+        }
         /*
          * Assume we wont find an authentication domain to parse, so default
 …
                         talloc_strdup(ctx, smbc_getWorkgroup(context));
+        }
         if (pp_options) {
                 *pp_options = talloc_strdup(ctx, "");
+        }
         s = talloc_strdup(ctx, fname);
         /* see if it has the right prefix */
         len = strlen(SMBC_PREFIX);
 …
                 return -1; /* What about no smb: ? */
+        }
         p = s + len;
         /* Watch the test below, we are testing to see if we should exit */
         if (strncmp(p, "//", 2) && strncmp(p, "\\\\", 2)) {
                 DEBUG(1, ("Invalid path (does not begin with smb://"));
                 return -1;
+        }
         p += 2;  /* Skip the double slash */
         /* See if any options were specified */
         if ((q = strrchr(p, '?')) != NULL ) {
                 /* There are options.  Null terminate here and point to them */
                 *q++ = '\0';
                 DEBUG(4, ("Found options '%s'", q));
                 /* Copy the options */
                 if (pp_options && *pp_options != NULL) {
 …
+                }
+        }
         if (*p == '\0') {
                 goto decoding;
+        }
         if (*p == '/') {
                 int wl = strlen(smbc_getWorkgroup(context));
                 if (wl > 16) {
                         wl = 16;
+                }
                 *pp_server = talloc_strdup(ctx, smbc_getWorkgroup(context));
                 if (!*pp_server) {
 …
                 return 0;
+        }
         /*
          * ok, its for us. Now parse out the server, share etc.
 …
          * exists ...
          */
         /* check that '@' occurs before '/', if '/' exists at all */
         q = strchr_m(p, '@');
 …
                 char *userinfo = NULL;
                 const char *u;
                 next_token_no_ltrim_talloc(ctx, &p, &userinfo, "@");
                 if (!userinfo) {
 …
+                }
                 u = userinfo;
                 if (strchr_m(u, ';')) {
                         next_token_no_ltrim_talloc(ctx, &u, &workgroup, ";");
 …
+                        }
+                }
                 if (strchr_m(u, ':')) {
                         next_token_no_ltrim_talloc(ctx, &u, pp_user, ":");
 …
+                }
+        }
         if (!next_token_talloc(ctx, &p, pp_server, "/")) {
                 return -1;
+        }
         if (*p == (char)0) {
                 goto decoding;  /* That's it ... */
+        }
         if (!next_token_talloc(ctx, &p, pp_share, "/")) {
                 return -1;
+        }
         /*
          * Prepend a leading slash if there's a file path, as required by
 …
+        }
         string_replace(*pp_path, '/', '\\');
 decoding:
         (void) urldecode_talloc(ctx, pp_path, *pp_path);
         (void) urldecode_talloc(ctx, pp_server, *pp_server);
 …
                                            *pp_user,
                                            *pp_password);
         return 0;
+}

vendor/current/source3/libsmb/libsmb_printjob.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
 …
         char *path = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return NULL;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return NULL;
+        }
         DEBUG(4, ("SMBC_open_print_job_ctx(%s)\n", fname));
         if (SMBC_parse_path(frame,
                             context,
 …
                 return NULL;
+        }
         /* What if the path is empty, or the file exists? */
         TALLOC_FREE(frame);
         return smbc_getFunctionOpen(context)(context, fname, O_WRONLY, 666);
 …
         char buf[4096];
         TALLOC_CTX *frame = talloc_stackframe();
         if (!c_file || !c_file->internal->initialized ||
             !c_print || !c_print->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!fname && !printq) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         /* Try to open the file for reading ... */
         if ((long)(fid1 = smbc_getFunctionOpen(c_file)(c_file, fname,
                                                        O_RDONLY, 0666)) < 0) {
 …
                 return -1;  /* smbc_open sets errno */
+        }
         /* Now, try to open the printer file for writing */
         if ((long)(fid2 = smbc_getFunctionOpenPrintJob(c_print)(c_print,
                                                                 printq)) < 0) {
                 saverr = errno;  /* Save errno */
                 smbc_getFunctionClose(c_file)(c_file, fid1);
 …
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         while ((bytes = smbc_getFunctionRead(c_file)(c_file, fid1,
                                                      buf, sizeof(buf))) > 0) {
                 tot_bytes += bytes;
                 if ((smbc_getFunctionWrite(c_print)(c_print, fid2,
                                                     buf, bytes)) < 0) {
                         saverr = errno;
                         smbc_getFunctionClose(c_file)(c_file, fid1);
                         smbc_getFunctionClose(c_print)(c_print, fid2);
                         errno = saverr;
+                }
+        }
+        }
         saverr = errno;
         smbc_getFunctionClose(c_file)(c_file, fid1);
         smbc_getFunctionClose(c_print)(c_print, fid2);
         if (bytes < 0) {
                 errno = saverr;
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         TALLOC_FREE(frame);
         return tot_bytes;
+}
 …
         char *path = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         DEBUG(4, ("smbc_list_print_jobs(%s)\n", fname));
         if (SMBC_parse_path(frame,
                             context,
 …
                 return -1;
+        }
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
         if (!srv) {
                 TALLOC_FREE(frame);
                 return -1;  /* errno set by SMBC_server */
+        }
         if (cli_print_queue(srv->cli,
                             (void (*)(struct print_job_info *))fn) < 0) {
 …
                 return -1;
+        }
         TALLOC_FREE(frame);
         return 0;
+}
 …
         int err;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
+                errno = EINVAL;
+                TALLOC_FREE(frame);
+                return -1;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         DEBUG(4, ("smbc_unlink_print_job(%s)\n", fname));
         if (SMBC_parse_path(frame,
                             context,
 …
                 return -1;
+        }
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
         if (!srv) {
                 TALLOC_FREE(frame);
                 return -1;  /* errno set by SMBC_server */
+        }
+        }
         if ((err = cli_printjob_del(srv->cli, id)) != 0) {
                 if (err < 0)
                         errno = SMBC_errno(context, srv->cli);
 …
                 TALLOC_FREE(frame);
                 return -1;
+        }
+        }
         TALLOC_FREE(frame);
         return 0;
+}

vendor/current/source3/libsmb/libsmb_server.c

-              r414
+              r740
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
+#include "../librpc/gen_ndr/ndr_lsa.h"
+#include "rpc_client/cli_pipe.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "libcli/security/security.h"
+#include "libsmb/nmblib.h"
 /*
 …
                                 DEBUG(4,
                                       ("IPC$ so ignore case sensitivity\n"));
                         } else if (!cli_get_fs_attr_info(c, &fs_attrs)) {
+                        } else if (!NT_STATUS_IS_OK(cli_get_fs_attr_info(c, &fs_attrs))) {
                                 DEBUG(4, ("Could not retrieve "
                                           "case sensitivity flag: %s.\n",
 …
         if (is_ipc) {
                 DEBUG(4, ("IPC$ so ignore case sensitivity\n"));
         } else if (!cli_get_fs_attr_info(c, &fs_attrs)) {
+        } else if (!NT_STATUS_IS_OK(cli_get_fs_attr_info(c, &fs_attrs))) {
                 DEBUG(4, ("Could not retrieve case sensitivity flag: %s.\n",
                           cli_errstr(c)));
 …
                                                 *pp_password,
                                                 flags,
                                                 Undefined, NULL);
+                                                Undefined);
                 if (! NT_STATUS_IS_OK(nt_status)) {
                         DEBUG(1,("cli_full_connection failed! (%s)\n",

vendor/current/source3/libsmb/libsmb_setget.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 smbc_setDebug(SMBCCTX *c, int debug)
+{
+        char buf[32];
+        snprintf(buf, sizeof(buf), "%d", debug);
         c->debug = debug;
+        DEBUGLEVEL = debug;
+        lp_set_cmdline("log level", buf);
+}
 …
 smbc_getOptionDebugToStderr(SMBCCTX *c)
+{
+        return c->internal->debug_stderr;
+}
+/** Set whether to log to standard error instead of standard output */
+        /* Because this is a global concept, it is better to check
+         * what is really set, rather than what we wanted set
+         * (particularly as you cannot go back to stdout). */
+        return debug_get_output_is_stderr();
+}
+/** Set whether to log to standard error instead of standard output.
+ * This option is 'sticky' - once set to true, it cannot be set to
+ * false again, as it is global to the process, as once we have been
+ * told that it is not safe to safe to write to stdout, we shouldn't
+ * go back as we don't know it was this context that set it that way.
+ */
 void
 smbc_setOptionDebugToStderr(SMBCCTX *c, smbc_bool b)
+{
+        c->internal->debug_stderr = b;
+        if (b) {
+                /*
+                 * We do not have a unique per-thread debug state? For
+                 * now, we'll just leave it up to the user. If any one
+                 * context spefies debug to stderr then all will be (and
+                 * will stay that way, as it is unsafe to flip back if
+                 * stdout is in use for other things)
+                 */
+                setup_logging("libsmbclient", DEBUG_STDERR);
+        }
+}

vendor/current/source3/libsmb/libsmb_stat.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
 …
+{
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;
                 return -1;
+        }
+        }
         if (!*name) return 2; /* FIXME, why 2 ??? */
         return (ino_t)str_checksum(name);
+}
 …
+{
         TALLOC_CTX *frame = talloc_stackframe();
         st->st_mode = 0;
         if (IS_DOS_DIR(mode)) {
                 st->st_mode = SMBC_DIR_MODE;
 …
                 st->st_mode = SMBC_FILE_MODE;
+        }
         if (IS_DOS_ARCHIVE(mode)) st->st_mode |= S_IXUSR;
         if (IS_DOS_SYSTEM(mode)) st->st_mode |= S_IXGRP;
         if (IS_DOS_HIDDEN(mode)) st->st_mode |= S_IXOTH;
         if (!IS_DOS_READONLY(mode)) st->st_mode |= S_IWUSR;
         st->st_size = size;
 #ifdef HAVE_STAT_ST_BLKSIZE
 …
         st->st_uid = getuid();
         st->st_gid = getgid();
         if (IS_DOS_DIR(mode)) {
                 st->st_nlink = 2;
 …
                 st->st_nlink = 1;
+        }
         if (st->st_ino == 0) {
                 st->st_ino = generate_inode(context, fname);
+        }
         TALLOC_FREE(frame);
         return True;  /* FIXME: Is this needed ? */
+}
 …
         SMB_INO_T ino = 0;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;  /* Best I can think of ... */
                 TALLOC_FREE(frame);
                 return -1;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         DEBUG(4, ("smbc_stat(%s)\n", fname));
         if (SMBC_parse_path(frame,
                             context,
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
         if (!srv) {
                 TALLOC_FREE(frame);
                 return -1;  /* errno set by SMBC_server */
+        }
         if (!SMBC_getatr(context, srv, path, &mode, &size,
                          NULL,
 …
                 return -1;
+        }
         st->st_ino = ino;
         setup_stat(context, st, (char *) fname, size, mode);
         st->st_atime = convert_timespec_to_time_t(access_time_ts);
         st->st_ctime = convert_timespec_to_time_t(change_time_ts);
         st->st_mtime = convert_timespec_to_time_t(write_time_ts);
         st->st_dev   = srv->dev;
         TALLOC_FREE(frame);
         return 0;
+}
 …
         SMB_INO_T ino = 0;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;
                 TALLOC_FREE(frame);
                 return -1;
+        }
         if (!file || !SMBC_dlist_contains(context->internal->files, file)) {
                 errno = EBADF;
 …
                 return -1;
+        }
         if (!file->file) {
                 TALLOC_FREE(frame);
                 return smbc_getFunctionFstatdir(context)(context, file, st);
+        }
         /*d_printf(">>>fstat: parsing %s\n", file->fname);*/
         if (SMBC_parse_path(frame,
 …
                 return -1;
+        }
         /*d_printf(">>>fstat: resolving %s\n", path);*/
         if (!cli_resolve_path(frame, "", context->internal->auth_info,
                         file->srv->cli, path,
                         &targetcli, &targetpath)) {
+                              file->srv->cli, path,
+                              &targetcli, &targetpath)) {
                 d_printf("Could not resolve %s\n", path);
                 errno = ENOENT;
 …
+        }
         /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/
         if (!cli_qfileinfo(targetcli, file->cli_fd, &mode, &size,
                            NULL,
                            &access_time_ts,
                            &write_time_ts,
                            &change_time_ts,
+                           &ino)) {
+        if (!NT_STATUS_IS_OK(cli_qfileinfo_basic(
+                                     targetcli, file->cli_fd, &mode, &size,
+                                     NULL,
+                                     &access_time_ts,
+                                     &write_time_ts,
+                                     &change_time_ts,
+                                     &ino))) {
                 time_t change_time, access_time, write_time;
                 if (!NT_STATUS_IS_OK(cli_getattrE(targetcli, file->cli_fd, &mode, &size,
                                   &change_time, &access_time, &write_time))) {
                         errno = EINVAL;
                         TALLOC_FREE(frame);
                         return -1;
+                }
                 change_time_ts = convert_time_t_to_timespec(change_time);
                 access_time_ts = convert_time_t_to_timespec(access_time);
                 write_time_ts = convert_time_t_to_timespec(write_time);
+        }
         st->st_ino = ino;
         setup_stat(context, st, file->fname, size, mode);
         st->st_atime = convert_timespec_to_time_t(access_time_ts);
         st->st_ctime = convert_timespec_to_time_t(change_time_ts);
         st->st_mtime = convert_timespec_to_time_t(write_time_ts);
         st->st_dev = file->srv->dev;
         TALLOC_FREE(frame);
         return 0;
+}
 …
         uint32 fs_attrs = 0;
         struct cli_state *cli = file->srv->cli;
         /* Initialize all fields (at least until we actually use them) */
 …
                 uint64_t sectors_per_allocation_unit;
                 uint64_t bytes_per_sector;
+                NTSTATUS status;
                 /* Nope. If size data is available... */
+                if (cli_get_fs_full_size_info(cli,
+                                              &total_allocation_units,
+                                              &caller_allocation_units,
+                                              &actual_allocation_units,
+                                              &sectors_per_allocation_unit,
+                                              &bytes_per_sector)) {
+                status = cli_get_fs_full_size_info(cli,
+                                                   &total_allocation_units,
+                                                   &caller_allocation_units,
+                                                   &actual_allocation_units,
+                                                   &sectors_per_allocation_unit,
+                                                   &bytes_per_sector);
+                if (NT_STATUS_IS_OK(status)) {
                         /* ... then provide it */
 …
                 uint64_t free_file_nodes;
                 uint64_t fs_identifier;
+                NTSTATUS status;
                 /* Has UNIXCIFS. If POSIX filesystem info is available... */
+                if (cli_get_posix_fs_info(cli,
+                                          &optimal_transfer_size,
+                                          &block_size,
+                                          &total_blocks,
+                                          &blocks_available,
+                                          &user_blocks_available,
+                                          &total_file_nodes,
+                                          &free_file_nodes,
+                                          &fs_identifier)) {
+                status = cli_get_posix_fs_info(cli,
+                                               &optimal_transfer_size,
+                                               &block_size,
+                                               &total_blocks,
+                                               &blocks_available,
+                                               &user_blocks_available,
+                                               &total_file_nodes,
+                                               &free_file_nodes,
+                                               &fs_identifier);
+                if (NT_STATUS_IS_OK(status)) {
                         /* ... then what's provided here takes precedence. */
 …
         /* See if the share is case sensitive */
         if (!cli_get_fs_attr_info(cli, &fs_attrs)) {
+        if (!NT_STATUS_IS_OK(cli_get_fs_attr_info(cli, &fs_attrs))) {
                 /*
                  * We can't determine the case sensitivity of

vendor/current/source3/libsmb/libsmb_xattr.c

-              r414
+              r740
    Copyright (C) Derrell Lipman 2003-2008
    Copyright (C) Jeremy Allison 2007, 2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libsmb/libsmb.h"
 #include "libsmbclient.h"
 #include "libsmb_internal.h"
+#include "../librpc/gen_ndr/ndr_lsa.h"
+#include "rpc_client/rpc_client.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "../libcli/security/security.h"
 /*
 …
+{
         struct rpc_pipe_client *pipe_hnd;
         for (pipe_hnd = ipc_cli->pipe_list;
              pipe_hnd;
              pipe_hnd = pipe_hnd->next) {
                 if (ndr_syntax_id_equal(&pipe_hnd->abstract_syntax,
                                         &ndr_table_lsarpc.syntax_id)) {
 …
+                }
+        }
         return NULL;
+}
 …
 static int
 ace_compare(SEC_ACE *ace1,
             SEC_ACE *ace2)
+ace_compare(struct security_ace *ace1,
+            struct security_ace *ace2)
+{
         bool b1;
         bool b2;
         /* If the ACEs are equal, we have nothing more to do. */
         if (sec_ace_equal(ace1, ace2)) {
                 return 0;
+        }
         /* Inherited follow non-inherited */
         b1 = ((ace1->flags & SEC_ACE_FLAG_INHERITED_ACE) != 0);
 …
                 return (b1 ? 1 : -1);
+        }
         /*
          * What shall we do with AUDITs and ALARMs?  It's undefined.  We'll
 …
                 return (b1 ? 1 : -1);
+        }
         /* Allowed ACEs follow denied ACEs */
         b1 = (ace1->type == SEC_ACE_TYPE_ACCESS_ALLOWED ||
 …
                 return (b1 ? 1 : -1);
+        }
         /*
          * ACEs applying to an entity's object follow those applying to the
 …
                 return (b1 ? 1 : -1);
+        }
         /*
          * If we get this far, the ACEs are similar as far as the
 …
          * just seems reasonable.
          */
         if (ace1->type != ace2->type) {
                 return ace2->type - ace1->type;
+        }
         if (sid_compare(&ace1->trustee, &ace2->trustee)) {
                 return sid_compare(&ace1->trustee, &ace2->trustee);
+        }
+        if (dom_sid_compare(&ace1->trustee, &ace2->trustee)) {
+                return dom_sid_compare(&ace1->trustee, &ace2->trustee);
+        }
         if (ace1->flags != ace2->flags) {
                 return ace1->flags - ace2->flags;
+        }
         if (ace1->access_mask != ace2->access_mask) {
                 return ace1->access_mask - ace2->access_mask;
+        }
         if (ace1->size != ace2->size) {
                 return ace1->size - ace2->size;
+        }
         return memcmp(ace1, ace2, sizeof(SEC_ACE));
+        return memcmp(ace1, ace2, sizeof(struct security_ace));
+}
 static void
 sort_acl(SEC_ACL *the_acl)
+sort_acl(struct security_acl *the_acl)
+{
         uint32 i;
         if (!the_acl) return;
+        qsort(the_acl->aces, the_acl->num_aces, sizeof(the_acl->aces[0]),
+              QSORT_CAST ace_compare);
+        TYPESAFE_QSORT(the_acl->aces, the_acl->num_aces, ace_compare);
         for (i=1;i<the_acl->num_aces;) {
                 if (sec_ace_equal(&the_acl->aces[i-1], &the_acl->aces[i])) {
 …
                       fstring str,
                       bool numeric,
                       DOM_SID *sid)
+                      struct dom_sid *sid)
+{
         char **domains = NULL;
 …
         struct rpc_pipe_client *pipe_hnd = find_lsa_pipe_hnd(ipc_cli);
         TALLOC_CTX *ctx;
         sid_to_fstring(str, sid);
         if (numeric) {
                 return;     /* no lookup desired */
+        }
         if (!pipe_hnd) {
                 return;
+        }
         /* Ask LSA to convert the sid to a name */
         ctx = talloc_stackframe();
         if (!NT_STATUS_IS_OK(rpccli_lsa_lookup_sids(pipe_hnd, ctx,
                                                     pol, 1, sid, &domains,
 …
                 return;
+        }
         /* Converted OK */
         slprintf(str, sizeof(fstring) - 1, "%s%s%s",
                  domains[0], lp_winbind_separator(),
 …
                       struct policy_handle *pol,
                       bool numeric,
                       DOM_SID *sid,
+                      struct dom_sid *sid,
                       const char *str)
+{
         enum lsa_SidType *types = NULL;
         DOM_SID *sids = NULL;
+        struct dom_sid *sids = NULL;
         bool result = True;
         TALLOC_CTX *ctx = NULL;
         struct rpc_pipe_client *pipe_hnd = find_lsa_pipe_hnd(ipc_cli);
         if (!pipe_hnd) {
                 return False;
+        }
         if (numeric) {
                 if (strncmp(str, "S-", 2) == 0) {
                         return string_to_sid(sid, str);
+                }
                 result = False;
                 goto done;
+        }
         ctx = talloc_stackframe();
         if (!NT_STATUS_IS_OK(rpccli_lsa_lookup_names(pipe_hnd, ctx,
 …
                 goto done;
+        }
         sid_copy(sid, &sids[0]);
 done:
         TALLOC_FREE(ctx);
         return result;
 …
 /* parse an ACE in the same format as print_ace() */
+/* parse an struct security_ace in the same format as print_ace() */
 static bool
 parse_ace(struct cli_state *ipc_cli,
           struct policy_handle *pol,
           SEC_ACE *ace,
+          struct security_ace *ace,
           bool numeric,
           char *str)
 …
         unsigned int aflags;
         unsigned int amask;
         DOM_SID sid;
+        struct dom_sid sid;
         uint32_t mask;
         const struct perm_value *v;
 …
         };
         TALLOC_CTX *frame = talloc_stackframe();
         /* These values discovered by inspection */
         static const struct perm_value special_values[] = {
 …
                 { "", 0 },
         };
         static const struct perm_value standard_values[] = {
                 { "READ",   0x001200a9 },
 …
                 { "", 0 },
         };
         ZERO_STRUCTP(ace);
         p = strchr_m(str,':');
 …
         p++;
         /* Try to parse numeric form */
         if (sscanf(p, "%i/%i/%i", &atype, &aflags, &amask) == 3 &&
             convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
                 goto done;
+        }
         /* Try to parse text form */
         if (!convert_string_to_sid(ipc_cli, pol, numeric, &sid, str)) {
                 TALLOC_FREE(frame);
                 return false;
+        }
         cp = p;
         if (!next_token_talloc(frame, &cp, &tok, "/")) {
 …
                 return false;
+        }
         if (StrnCaseCmp(tok, "ALLOWED", strlen("ALLOWED")) == 0) {
                 atype = SEC_ACE_TYPE_ACCESS_ALLOWED;
 …
                 return false;
+        }
         /* Only numeric form accepted for flags at present */
         if (!(next_token_talloc(frame, &cp, &tok, "/") &&
               sscanf(tok, "%i", &aflags))) {
 …
                 return false;
+        }
         if (!next_token_talloc(frame, &cp, &tok, "/")) {
                 TALLOC_FREE(frame);
                 return false;
+        }
         if (strncmp(tok, "0x", 2) == 0) {
                 if (sscanf(tok, "%i", &amask) != 1) {
 …
                 goto done;
+        }
         for (v = standard_values; v->perm; v++) {
                 if (strcmp(tok, v->perm) == 0) {
 …
+                }
+        }
         p = tok;
         while(*p) {
                 bool found = False;
                 for (v = special_values; v->perm; v++) {
                         if (v->perm[0] == *p) {
 …
+                        }
+                }
                 if (!found) {
                         TALLOC_FREE(frame);
 …
                 p++;
+        }
         if (*p) {
                 TALLOC_FREE(frame);
                 return false;
+        }
 done:
         mask = amask;
 …
+}
 /* add an ACE to a list of ACEs in a SEC_ACL */
+/* add an struct security_ace to a list of struct security_aces in a struct security_acl */
 static bool
 add_ace(SEC_ACL **the_acl,
         SEC_ACE *ace,
+add_ace(struct security_acl **the_acl,
+        struct security_ace *ace,
         TALLOC_CTX *ctx)
+{
         SEC_ACL *newacl;
         SEC_ACE *aces;
+        struct security_acl *newacl;
+        struct security_ace *aces;
         if (! *the_acl) {
                 (*the_acl) = make_sec_acl(ctx, 3, 1, ace);
                 return True;
+        }
         if ((aces = SMB_CALLOC_ARRAY(SEC_ACE,
+        if ((aces = SMB_CALLOC_ARRAY(struct security_ace,
 +(*the_acl)->num_aces)) == NULL) {
                 return False;
+        }
         memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(SEC_ACE));
         memcpy(aces+(*the_acl)->num_aces, ace, sizeof(SEC_ACE));
+        memcpy(aces, (*the_acl)->aces, (*the_acl)->num_aces * sizeof(struct security_ace));
+        memcpy(aces+(*the_acl)->num_aces, ace, sizeof(struct security_ace));
         newacl = make_sec_acl(ctx, (*the_acl)->revision,
 +(*the_acl)->num_aces, aces);
 …
 /* parse a ascii version of a security descriptor */
 static SEC_DESC *
+static struct security_descriptor *
 sec_desc_parse(TALLOC_CTX *ctx,
                struct cli_state *ipc_cli,
 …
         const char *p = str;
         char *tok;
         SEC_DESC *ret = NULL;
+        struct security_descriptor *ret = NULL;
         size_t sd_size;
         DOM_SID *group_sid=NULL;
         DOM_SID *owner_sid=NULL;
         SEC_ACL *dacl=NULL;
+        struct dom_sid *group_sid=NULL;
+        struct dom_sid *owner_sid=NULL;
+        struct security_acl *dacl=NULL;
         int revision=1;
         while (next_token_talloc(ctx, &p, &tok, "\t,\r\n")) {
                 if (StrnCaseCmp(tok,"REVISION:", 9) == 0) {
                         revision = strtol(tok+9, NULL, 16);
                         continue;
+                }
                 if (StrnCaseCmp(tok,"OWNER:", 6) == 0) {
                         if (owner_sid) {
 …
                                 goto done;
+                        }
                         owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
+                        owner_sid = SMB_CALLOC_ARRAY(struct dom_sid, 1);
                         if (!owner_sid ||
                             !convert_string_to_sid(ipc_cli, pol,
 …
                         continue;
+                }
                 if (StrnCaseCmp(tok,"OWNER+:", 7) == 0) {
                         if (owner_sid) {
 …
                                 goto done;
+                        }
                         owner_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
+                        owner_sid = SMB_CALLOC_ARRAY(struct dom_sid, 1);
                         if (!owner_sid ||
                             !convert_string_to_sid(ipc_cli, pol,
 …
                         continue;
+                }
                 if (StrnCaseCmp(tok,"GROUP:", 6) == 0) {
                         if (group_sid) {
 …
                                 goto done;
+                        }
                         group_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
+                        group_sid = SMB_CALLOC_ARRAY(struct dom_sid, 1);
                         if (!group_sid ||
                             !convert_string_to_sid(ipc_cli, pol,
 …
                         continue;
+                }
                 if (StrnCaseCmp(tok,"GROUP+:", 7) == 0) {
                         if (group_sid) {
 …
                                 goto done;
+                        }
                         group_sid = SMB_CALLOC_ARRAY(DOM_SID, 1);
+                        group_sid = SMB_CALLOC_ARRAY(struct dom_sid, 1);
                         if (!group_sid ||
                             !convert_string_to_sid(ipc_cli, pol,
 …
                         continue;
+                }
                 if (StrnCaseCmp(tok,"ACL:", 4) == 0) {
                         SEC_ACE ace;
+                        struct security_ace ace;
                         if (!parse_ace(ipc_cli, pol, &ace, numeric, tok+4)) {
                                 DEBUG(5, ("Failed to parse ACL %s\n", tok));
 …
                         continue;
+                }
                 if (StrnCaseCmp(tok,"ACL+:", 5) == 0) {
                         SEC_ACE ace;
+                        struct security_ace ace;
                         if (!parse_ace(ipc_cli, pol, &ace, False, tok+5)) {
                                 DEBUG(5, ("Failed to parse ACL %s\n", tok));
 …
                         continue;
+                }
                 DEBUG(5, ("Failed to parse security descriptor\n"));
                 goto done;
+        }
         ret = make_sec_desc(ctx, revision, SEC_DESC_SELF_RELATIVE,
                             owner_sid, group_sid, NULL, dacl, &sd_size);
 done:
         SAFE_FREE(group_sid);
         SAFE_FREE(owner_sid);
         return ret;
+}
 …
         SMB_INO_T inode = 0;
         DOS_ATTR_DESC *ret;
         ret = TALLOC_P(ctx, DOS_ATTR_DESC);
         if (!ret) {
 …
                 return NULL;
+        }
         /* Obtain the DOS attributes */
         if (!SMBC_getatr(context, srv, CONST_DISCARD(char *, filename),
 …
                 return NULL;
+        }
         ret->mode = mode;
         ret->size = size;
 …
         ret->change_time = convert_timespec_to_time_t(change_time_ts);
         ret->inode = inode;
         return ret;
+}
 …
                 const char * change_time_attr;
         } attr_strings;
         /* Determine whether to use old-style or new-style attribute names */
         if (context->internal->full_time_names) {
 …
                 attr_strings.change_time_attr = "C_TIME";
+        }
         /* if this is to set the entire ACL... */
         if (*str == '*') {
 …
+                }
+        }
         frame = talloc_stackframe();
         while (next_token_talloc(frame, &p, &tok, "\t,\r\n")) {
 …
                         continue;
+                }
                 if (StrnCaseCmp(tok, "SIZE:", 5) == 0) {
                         dad->size = (SMB_OFF_T)atof(tok+5);
                         continue;
+                }
                 n = strlen(attr_strings.access_time_attr);
                 if (StrnCaseCmp(tok, attr_strings.access_time_attr, n) == 0) {
 …
                         continue;
+                }
                 n = strlen(attr_strings.change_time_attr);
                 if (StrnCaseCmp(tok, attr_strings.change_time_attr, n) == 0) {
 …
                         continue;
+                }
                 n = strlen(attr_strings.write_time_attr);
                 if (StrnCaseCmp(tok, attr_strings.write_time_attr, n) == 0) {
 …
                         continue;
+                }
                 if (attr_strings.create_time_attr != NULL) {
                         n = strlen(attr_strings.create_time_attr);
 …
+                        }
+                }
                 if (StrnCaseCmp(tok, "INODE:", 6) == 0) {
                         dad->inode = (SMB_INO_T)atof(tok+6);
 …
         bool determine_size = (bufsize == 0);
         uint16_t fnum;
         SEC_DESC *sd;
+        struct security_descriptor *sd;
         fstring sidstr;
         fstring name_sandbox;
 …
                 const char * change_time_attr;
         } excl_attr_strings;
         /* Determine whether to use old-style or new-style attribute names */
         if (context->internal->full_time_names) {
 …
                 attr_strings.write_time_attr = "WRITE_TIME";
                 attr_strings.change_time_attr = "CHANGE_TIME";
                 excl_attr_strings.create_time_attr = "CREATE_TIME";
                 excl_attr_strings.access_time_attr = "ACCESS_TIME";
 …
                 attr_strings.write_time_attr = "M_TIME";
                 attr_strings.change_time_attr = "C_TIME";
                 excl_attr_strings.create_time_attr = NULL;
                 excl_attr_strings.access_time_attr = "dos_attr.A_TIME";
 …
                 excl_attr_strings.change_time_attr = "dos_attr.C_TIME";
+        }
         /* Copy name so we can strip off exclusions (if any are specified) */
         strncpy(name_sandbox, attr_name, sizeof(name_sandbox) - 1);
         /* Ensure name is null terminated */
         name_sandbox[sizeof(name_sandbox) - 1] = '\0';
         /* Play in the sandbox */
         name = name_sandbox;
         /* If there are any exclusions, point to them and mask them from name */
         if ((pExclude = strchr(name, '!')) != NULL)
 …
                 *pExclude++ = '\0';
+        }
         all = (StrnCaseCmp(name, "system.*", 8) == 0);
         all_nt = (StrnCaseCmp(name, "system.nt_sec_desc.*", 20) == 0);
 …
         some_dos = (StrnCaseCmp(name, "system.dos_attr.", 16) == 0);
         numeric = (* (name + strlen(name) - 1) != '+');
         /* Look for exclusions from "all" requests */
         if (all || all_nt || all_dos) {
                 /* Exclusions are delimited by '!' */
                 for (;
                      pExclude != NULL;
                      pExclude = (p == NULL ? NULL : p + 1)) {
                         /* Find end of this exclusion name */
                         if ((p = strchr(pExclude, '!')) != NULL)
 …
                                 *p = '\0';
+                        }
                         /* Which exclusion name is this? */
                         if (StrCaseCmp(pExclude,
 …
+                }
+        }
         n_used = 0;
         /*
          * If we are (possibly) talking to an NT or new system and some NT
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_nt_owner) {
                         /* Get owner and group sid */
 …
                                 fstrcpy(sidstr, "");
+                        }
                         if (all || all_nt) {
                                 if (determine_size) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_nt_group) {
                         if (sd->group_sid) {
 …
                                 fstrcpy(sidstr, "");
+                        }
                         if (all || all_nt) {
                                 if (determine_size) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_nt_acl) {
                         /* Add aces to value buffer  */
                         for (i = 0; sd->dacl && i < sd->dacl->num_aces; i++) {
                                 SEC_ACE *ace = &sd->dacl->aces[i];
+                                struct security_ace *ace = &sd->dacl->aces[i];
                                 convert_sid_to_string(ipc_cli, pol,
                                                       sidstr, numeric,
                                                       &ace->trustee);
                                 if (all || all_nt) {
                                         if (determine_size) {
 …
+                        }
+                }
                 /* Restore name pointer to its original value */
                 name -= 19;
+        }
         if (all || some_dos) {
                 /* Point to the portion after "system.dos_attr." */
                 name += 16;     /* if (all) this will be invalid but unused */
                 /* Obtain the DOS attributes */
                 if (!SMBC_getatr(context, srv, filename, &mode, &size,
 …
                                  &change_time_ts,
                                  &ino)) {
                         errno = SMBC_errno(context, srv->cli);
                         return -1;
+                }
+                }
                 create_time = convert_timespec_to_time_t(create_time_ts);
                 access_time = convert_timespec_to_time_t(access_time_ts);
                 write_time = convert_timespec_to_time_t(write_time_ts);
                 change_time = convert_timespec_to_time_t(change_time_ts);
                 if (! exclude_dos_mode) {
                         if (all || all_dos) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_dos_size) {
                         if (all || all_dos) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_dos_create_time &&
                     attr_strings.create_time_attr != NULL) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_dos_access_time) {
                         if (all || all_dos) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_dos_write_time) {
                         if (all || all_dos) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_dos_change_time) {
                         if (all || all_dos) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 if (! exclude_dos_inode) {
                         if (all || all_dos) {
 …
+                                }
+                        }
                         if (!determine_size && n > bufsize) {
                                 errno = ERANGE;
 …
                         n = 0;
+                }
                 /* Restore name pointer to its original value */
                 name -= 16;
+        }
         if (n_used == 0) {
                 errno = ENOATTR;
                 return -1;
+        }
         return n_used;
+}
 …
         uint16_t fnum = (uint16_t)-1;
         int err = 0;
         SEC_DESC *sd = NULL, *old;
         SEC_ACL *dacl = NULL;
         DOM_SID *owner_sid = NULL;
         DOM_SID *group_sid = NULL;
+        struct security_descriptor *sd = NULL, *old;
+        struct security_acl *dacl = NULL;
+        struct dom_sid *owner_sid = NULL;
+        struct dom_sid *group_sid = NULL;
         uint32 i, j;
         size_t sd_size;
 …
         char *targetpath = NULL;
         struct cli_state *targetcli = NULL;
+        NTSTATUS status;
         /* the_acl will be null for REMOVE_ALL operations */
 …
                            p > the_acl &&
                            p[-1] != '+');
                 /* if this is to set the entire ACL... */
                 if (*the_acl == '*') {
 …
                         the_acl = p + 1;
+                }
                 sd = sec_desc_parse(ctx, ipc_cli, pol, numeric, the_acl);
                 if (!sd) {
                         errno = EINVAL;
 …
+                }
+        }
         /* SMBC_XATTR_MODE_REMOVE_ALL is the only caller
            that doesn't deref sd */
         if (!sd && (mode != SMBC_XATTR_MODE_REMOVE_ALL)) {
                 errno = EINVAL;
 …
+                                }
+                        }
                         if (!found) {
                                 err = ENOATTR;
 …
+                }
                 break;
         case SMBC_XATTR_MODE_ADD:
                 for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
                         bool found = False;
                         for (j=0;old->dacl && j<old->dacl->num_aces;j++) {
                                 if (sid_equal(&sd->dacl->aces[i].trustee,
+                                if (dom_sid_equal(&sd->dacl->aces[i].trustee,
                                               &old->dacl->aces[j].trustee)) {
                                         if (!(flags & SMBC_XATTR_FLAG_CREATE)) {
 …
+                                }
+                        }
                         if (!found && (flags & SMBC_XATTR_FLAG_REPLACE)) {
                                 err = ENOATTR;
 …
                                 goto failed;
+                        }
                         for (i=0;sd->dacl && i<sd->dacl->num_aces;i++) {
                                 add_ace(&old->dacl, &sd->dacl->aces[i], ctx);
 …
                 dacl = old->dacl;
                 break;
         case SMBC_XATTR_MODE_SET:
                 old = sd;
 …
                 dacl = old->dacl;
                 break;
         case SMBC_XATTR_MODE_CHOWN:
                 owner_sid = sd->owner_sid;
                 break;
         case SMBC_XATTR_MODE_CHGRP:
                 group_sid = sd->group_sid;
                 break;
+        }
         /* Denied ACE entries must come before allowed ones */
         sort_acl(old->dacl);
         /* Create new security descriptor and set it */
         sd = make_sec_desc(ctx, old->revision, SEC_DESC_SELF_RELATIVE,
                            owner_sid, group_sid, NULL, dacl, &sd_size);
         if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetpath, 0,
                              WRITE_DAC_ACCESS | WRITE_OWNER_ACCESS, 0,
 …
                 return -1;
+        }
+        if (!cli_set_secdesc(targetcli, fnum, sd)) {
+        status = cli_set_secdesc(targetcli, fnum, sd);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(5, ("ERROR: secdesc set failed: %s\n",
                         cli_errstr(targetcli)));
+                          nt_errstr(status)));
                 ret = -1;
+        }
         /* Clean up */
 failed:
         cli_close(targetcli, fnum);
         if (err != 0) {
                 errno = err;
+        }
         return ret;
+}
 …
         } attr_strings;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;  /* Best I can think of ... */
                 TALLOC_FREE(frame);
                 return -1;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         DEBUG(4, ("smbc_setxattr(%s, %s, %.*s)\n",
                   fname, name, (int) size, (const char*)value));
         if (SMBC_parse_path(frame,
                             context,
 …
                 return -1;
+        }
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
 …
                 return -1;  /* errno set by SMBC_server */
+        }
         if (! srv->no_nt_session) {
                 ipc_srv = SMBC_attr_server(frame, context, server, share,
 …
                 ipc_srv = NULL;
+        }
         /*
          * Are they asking to set the entire set of known attributes?
 …
                         return -1;
+                }
                 if (ipc_srv) {
                         ret = cacl_set(context, talloc_tos(), srv->cli,
 …
                         ret = 0;
+                }
                 /* get a DOS Attribute Descriptor with current attributes */
                 dad = dos_attr_query(context, talloc_tos(), path, srv);
 …
                         /* Overwrite old with new, using what was provided */
                         dos_attr_parse(context, dad, srv, namevalue);
                         /* Set the new DOS attributes */
                         if (! SMBC_setatr(context, srv, path,
 …
                                           dad->change_time,
                                           dad->mode)) {
                                 /* cause failure if NT failed too */
                                 dad = NULL;
+                        }
+                }
                 /* we only fail if both NT and DOS sets failed */
                 if (ret < 0 && ! dad) {
 …
                         ret = 0;
+                }
                 TALLOC_FREE(frame);
                 return ret;
+        }
         /*
          * Are they asking to set an access control element or to set
 …
             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
                 /* Yup. */
                 char *namevalue =
                         talloc_asprintf(talloc_tos(), "%s:%s",
                                         name+19, (const char *) value);
                 if (! ipc_srv) {
                         ret = -1; /* errno set by SMBC_server() */
 …
                 return ret;
+        }
         /*
          * Are they asking to set the owner?
 …
         if (StrCaseCmp(name, "system.nt_sec_desc.owner") == 0 ||
             StrCaseCmp(name, "system.nt_sec_desc.owner+") == 0) {
                 /* Yup. */
                 char *namevalue =
                         talloc_asprintf(talloc_tos(), "%s:%s",
                                         name+19, (const char *) value);
                 if (! ipc_srv) {
                         ret = -1; /* errno set by SMBC_server() */
 …
                 return ret;
+        }
         /*
          * Are they asking to set the group?
 …
         if (StrCaseCmp(name, "system.nt_sec_desc.group") == 0 ||
             StrCaseCmp(name, "system.nt_sec_desc.group+") == 0) {
                 /* Yup. */
                 char *namevalue =
                         talloc_asprintf(talloc_tos(), "%s:%s",
                                         name+19, (const char *) value);
                 if (! ipc_srv) {
                         /* errno set by SMBC_server() */
 …
                 return ret;
+        }
         /* Determine whether to use old-style or new-style attribute names */
         if (context->internal->full_time_names) {
 …
                 attr_strings.change_time_attr = "system.dos_attr.C_TIME";
+        }
         /*
          * Are they asking to set a DOS attribute?
 …
             StrCaseCmp(name, attr_strings.write_time_attr) == 0 ||
             StrCaseCmp(name, attr_strings.change_time_attr) == 0) {
                 /* get a DOS Attribute Descriptor with current attributes */
                 dad = dos_attr_query(context, talloc_tos(), path, srv);
 …
                                 /* Overwrite old with provided new params */
                                 dos_attr_parse(context, dad, srv, namevalue);
                                 /* Set the new DOS attributes */
                                 ret2 = SMBC_setatr(context, srv, path,
 …
                                                    dad->change_time,
                                                    dad->mode);
                                 /* ret2 has True (success) / False (failure) */
                                 if (ret2) {
 …
                         ret = -1;
+                }
                 TALLOC_FREE(frame);
                 return ret;
+        }
         /* Unsupported attribute name */
         errno = EINVAL;
 …
         } attr_strings;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;  /* Best I can think of ... */
                 TALLOC_FREE(frame);
                 return -1;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         DEBUG(4, ("smbc_getxattr(%s, %s)\n", fname, name));
         if (SMBC_parse_path(frame,
                             context,
 …
                 return -1;
+        }
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
 …
                 return -1;  /* errno set by SMBC_server */
+        }
         if (! srv->no_nt_session) {
                 ipc_srv = SMBC_attr_server(frame, context, server, share,
 …
                 ipc_srv = NULL;
+        }
         /* Determine whether to use old-style or new-style attribute names */
         if (context->internal->full_time_names) {
 …
                 attr_strings.change_time_attr = "system.dos_attr.C_TIME";
+        }
         /* Are they requesting a supported attribute? */
         if (StrCaseCmp(name, "system.*") == 0 ||
 …
             StrCaseCmp(name, attr_strings.change_time_attr) == 0 ||
             StrCaseCmp(name, "system.dos_attr.inode") == 0) {
                 /* Yup. */
                 char *filename = (char *) name;
 …
                 return ret;
+        }
         /* Unsupported attribute name */
         errno = EINVAL;
 …
         char *path = NULL;
         TALLOC_CTX *frame = talloc_stackframe();
         if (!context || !context->internal->initialized) {
                 errno = EINVAL;  /* Best I can think of ... */
                 TALLOC_FREE(frame);
                 return -1;
+        }
         if (!fname) {
                 errno = EINVAL;
 …
                 return -1;
+        }
         DEBUG(4, ("smbc_removexattr(%s, %s)\n", fname, name));
         if (SMBC_parse_path(frame,
                             context,
 …
                 return -1;
+        }
         if (!user || user[0] == (char)0) {
                 user = talloc_strdup(frame, smbc_getUser(context));
 …
+                }
+        }
         srv = SMBC_server(frame, context, True,
                           server, share, &workgroup, &user, &password);
 …
                 return -1;  /* errno set by SMBC_server */
+        }
         if (! srv->no_nt_session) {
                 ipc_srv = SMBC_attr_server(frame, context, server, share,
 …
                 ipc_srv = NULL;
+        }
         if (! ipc_srv) {
                 TALLOC_FREE(frame);
                 return -1; /* errno set by SMBC_attr_server */
+        }
         /* Are they asking to set the entire ACL? */
         if (StrCaseCmp(name, "system.nt_sec_desc.*") == 0 ||
             StrCaseCmp(name, "system.nt_sec_desc.*+") == 0) {
                 /* Yup. */
                 ret = cacl_set(context, talloc_tos(), srv->cli,
 …
                 return ret;
+        }
         /*
          * Are they asking to remove one or more spceific security descriptor
 …
             StrnCaseCmp(name, "system.nt_sec_desc.acl", 22) == 0 ||
             StrnCaseCmp(name, "system.nt_sec_desc.acl+", 23) == 0) {
                 /* Yup. */
                 ret = cacl_set(context, talloc_tos(), srv->cli,
 …
                 return ret;
+        }
         /* Unsupported attribute name */
         errno = EINVAL;
 …
+                ;
         const char * supported;
         if (context->internal->full_time_names) {
                 supported = supported_new;
 …
                 retsize = sizeof(supported_old);
+        }
         if (size == 0) {
                 return retsize;
+        }
         if (retsize > size) {
                 errno = ERANGE;
                 return -1;
+        }
         /* this can't be strcpy() because there are embedded null characters */
         memcpy(list, supported, retsize);

vendor/current/source3/libsmb/namecache.c

-              r414
+              r740
 #define NBTKEY_FMT  "NBT/%s#%02X"
-/**
- * Initialise namecache system. Function calls gencache
- * initialisation function to perform necessary actions
+ *
- * @return true upon successful initialisation of the cache or
- *         false on failure
- **/
-bool namecache_enable(void)
+{
-        /*
-         * Check if name caching disabled by setting the name cache
-         * timeout to zero.
-         */
-        if (lp_name_cache_timeout() == 0) {
-                DEBUG(5, ("namecache_enable: disabling netbios name cache\n"));
-                return False;
+        }
-        /* I leave it for now, though I don't think we really
-         * need this (mimir, 27.09.2002) */
-        DEBUG(5, ("namecache_enable: enabling netbios namecache, timeout %d "
-                  "seconds\n", lp_name_cache_timeout()));
-        return True;
+}
 /**
 …
                 SAFE_FREE(key);
                 return False;
         } else {
+                DEBUG(5, ("name %s#%02X found.\n", name, name_type));
+        }
+        }
+        DEBUG(5, ("name %s#%02X found.\n", name, name_type));
         /*

vendor/current/source3/libsmb/namequery.c

-              r414
+              r740
 #include "includes.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "libads/sitename_cache.h"
+#include "libads/dns.h"
+#include "../libcli/netlogon/netlogon.h"
+#include "lib/async_req/async_sock.h"
+#include "libsmb/nmblib.h"
 /* nmbd.c sets this to True. */
 …
 ****************************************************************************/
 static NODE_STATUS_STRUCT *parse_node_status(char *p,
+static struct node_status *parse_node_status(TALLOC_CTX *mem_ctx, char *p,
                                 int *num_names,
                                 struct node_status_extra *extra)
+{
         NODE_STATUS_STRUCT *ret;
+        struct node_status *ret;
         int i;
 …
                 return NULL;
         ret = SMB_MALLOC_ARRAY(NODE_STATUS_STRUCT,*num_names);
+        ret = TALLOC_ARRAY(mem_ctx, struct node_status,*num_names);
         if (!ret)
                 return NULL;
 …
+}
+struct sock_packet_read_state {
+        struct tevent_context *ev;
+        enum packet_type type;
+        int trn_id;
+        struct nb_packet_reader *reader;
+        struct tevent_req *reader_req;
+        int sock;
+        struct tevent_req *socket_req;
+        uint8_t buf[1024];
+        struct sockaddr_storage addr;
+        socklen_t addr_len;
+        bool (*validator)(struct packet_struct *p,
+                          void *private_data);
+        void *private_data;
+        struct packet_struct *packet;
+};
+static int sock_packet_read_state_destructor(struct sock_packet_read_state *s);
+static void sock_packet_read_got_packet(struct tevent_req *subreq);
+static void sock_packet_read_got_socket(struct tevent_req *subreq);
+static struct tevent_req *sock_packet_read_send(
+        TALLOC_CTX *mem_ctx,
+        struct tevent_context *ev,
+        int sock, /* dgram socket */
+        struct nb_packet_reader *reader,
+        enum packet_type type,
+        int trn_id,
+        bool (*validator)(struct packet_struct *p, void *private_data),
+        void *private_data)
+{
+        struct tevent_req *req;
+        struct sock_packet_read_state *state;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct sock_packet_read_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        talloc_set_destructor(state, sock_packet_read_state_destructor);
+        state->ev = ev;
+        state->reader = reader;
+        state->sock = sock;
+        state->type = type;
+        state->trn_id = trn_id;
+        state->validator = validator;
+        state->private_data = private_data;
+        if (reader != NULL) {
+                state->reader_req = nb_packet_read_send(state, ev, reader);
+                if (tevent_req_nomem(state->reader_req, req)) {
+                        return tevent_req_post(req, ev);
+                }
+                tevent_req_set_callback(
+                        state->reader_req, sock_packet_read_got_packet, req);
+        }
+        state->addr_len = sizeof(state->addr);
+        state->socket_req = recvfrom_send(state, ev, sock,
+                                          state->buf, sizeof(state->buf), 0,
+                                          &state->addr, &state->addr_len);
+        if (tevent_req_nomem(state->socket_req, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(state->socket_req, sock_packet_read_got_socket,
+                                req);
+        return req;
+}
+static int sock_packet_read_state_destructor(struct sock_packet_read_state *s)
+{
+        if (s->packet != NULL) {
+                free_packet(s->packet);
+                s->packet = NULL;
+        }
+        return 0;
+}
+static void sock_packet_read_got_packet(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct sock_packet_read_state *state = tevent_req_data(
+                req, struct sock_packet_read_state);
+        NTSTATUS status;
+        status = nb_packet_read_recv(subreq, &state->packet);
+        TALLOC_FREE(state->reader_req);
+        if (!NT_STATUS_IS_OK(status)) {
+                if (state->socket_req != NULL) {
+                        /*
+                         * Still waiting for socket
+                         */
+                        return;
+                }
+                /*
+                 * Both socket and packet reader failed
+                 */
+                tevent_req_nterror(req, status);
+                return;
+        }
+        if ((state->validator != NULL) &&
+            !state->validator(state->packet, state->private_data)) {
+                DEBUG(10, ("validator failed\n"));
+                free_packet(state->packet);
+                state->packet = NULL;
+                state->reader_req = nb_packet_read_send(state, state->ev,
+                                                        state->reader);
+                if (tevent_req_nomem(state->reader_req, req)) {
+                        return;
+                }
+                tevent_req_set_callback(
+                        state->reader_req, sock_packet_read_got_packet, req);
+                return;
+        }
+        TALLOC_FREE(state->socket_req);
+        tevent_req_done(req);
+}
+static void sock_packet_read_got_socket(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct sock_packet_read_state *state = tevent_req_data(
+                req, struct sock_packet_read_state);
+        struct sockaddr_in *in_addr;
+        ssize_t received;
+        int err;
+        received = recvfrom_recv(subreq, &err);
+        TALLOC_FREE(state->socket_req);
+        if (received == -1) {
+                if (state->reader_req != NULL) {
+                        /*
+                         * Still waiting for reader
+                         */
+                        return;
+                }
+                /*
+                 * Both socket and reader failed
+                 */
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                return;
+        }
+        if (state->addr.ss_family != AF_INET) {
+                goto retry;
+        }
+        in_addr = (struct sockaddr_in *)(void *)&state->addr;
+        state->packet = parse_packet((char *)state->buf, received, state->type,
+                                     in_addr->sin_addr, in_addr->sin_port);
+        if (state->packet == NULL) {
+                DEBUG(10, ("parse_packet failed\n"));
+                goto retry;
+        }
+        if ((state->trn_id != -1) &&
+            (state->trn_id != packet_trn_id(state->packet))) {
+                DEBUG(10, ("Expected transaction id %d, got %d\n",
+                           state->trn_id, packet_trn_id(state->packet)));
+                goto retry;
+        }
+        if ((state->validator != NULL) &&
+            !state->validator(state->packet, state->private_data)) {
+                DEBUG(10, ("validator failed\n"));
+                goto retry;
+        }
+        tevent_req_done(req);
+        return;
+retry:
+        if (state->packet != NULL) {
+                free_packet(state->packet);
+                state->packet = NULL;
+        }
+        state->socket_req = recvfrom_send(state, state->ev, state->sock,
+                                          state->buf, sizeof(state->buf), 0,
+                                          &state->addr, &state->addr_len);
+        if (tevent_req_nomem(state->socket_req, req)) {
+                return;
+        }
+        tevent_req_set_callback(state->socket_req, sock_packet_read_got_socket,
+                                req);
+}
+static NTSTATUS sock_packet_read_recv(struct tevent_req *req,
+                                      struct packet_struct **ppacket)
+{
+        struct sock_packet_read_state *state = tevent_req_data(
+                req, struct sock_packet_read_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        *ppacket = state->packet;
+        state->packet = NULL;
+        return NT_STATUS_OK;
+}
+struct nb_trans_state {
+        struct tevent_context *ev;
+        int sock;
+        struct nb_packet_reader *reader;
+        const struct sockaddr_storage *dst_addr;
+        uint8_t *buf;
+        size_t buflen;
+        enum packet_type type;
+        int trn_id;
+        bool (*validator)(struct packet_struct *p,
+                          void *private_data);
+        void *private_data;
+        struct packet_struct *packet;
+};
+static int nb_trans_state_destructor(struct nb_trans_state *s);
+static void nb_trans_got_reader(struct tevent_req *subreq);
+static void nb_trans_done(struct tevent_req *subreq);
+static void nb_trans_sent(struct tevent_req *subreq);
+static void nb_trans_send_next(struct tevent_req *subreq);
+static struct tevent_req *nb_trans_send(
+        TALLOC_CTX *mem_ctx,
+        struct tevent_context *ev,
+        const struct sockaddr_storage *my_addr,
+        const struct sockaddr_storage *dst_addr,
+        bool bcast,
+        uint8_t *buf, size_t buflen,
+        enum packet_type type, int trn_id,
+        bool (*validator)(struct packet_struct *p,
+                          void *private_data),
+        void *private_data)
+{
+        struct tevent_req *req, *subreq;
+        struct nb_trans_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct nb_trans_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        talloc_set_destructor(state, nb_trans_state_destructor);
+        state->ev = ev;
+        state->dst_addr = dst_addr;
+        state->buf = buf;
+        state->buflen = buflen;
+        state->type = type;
+        state->trn_id = trn_id;
+        state->validator = validator;
+        state->private_data = private_data;
+        state->sock = open_socket_in(SOCK_DGRAM, 0, 3, my_addr, True);
+        if (state->sock == -1) {
+                tevent_req_nterror(req, map_nt_error_from_unix(errno));
+                DEBUG(10, ("open_socket_in failed: %s\n", strerror(errno)));
+                return tevent_req_post(req, ev);
+        }
+        if (bcast) {
+                set_socket_options(state->sock,"SO_BROADCAST");
+        }
+        subreq = nb_packet_reader_send(state, ev, type, state->trn_id, NULL);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, nb_trans_got_reader, req);
+        return req;
+}
+static int nb_trans_state_destructor(struct nb_trans_state *s)
+{
+        if (s->sock != -1) {
+                close(s->sock);
+                s->sock = -1;
+        }
+        if (s->packet != NULL) {
+                free_packet(s->packet);
+                s->packet = NULL;
+        }
+        return 0;
+}
+static void nb_trans_got_reader(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_trans_state *state = tevent_req_data(
+                req, struct nb_trans_state);
+        NTSTATUS status;
+        status = nb_packet_reader_recv(subreq, state, &state->reader);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10, ("nmbd not around\n"));
+                state->reader = NULL;
+        }
+        subreq = sock_packet_read_send(
+                state, state->ev, state->sock,
+                state->reader, state->type, state->trn_id,
+                state->validator, state->private_data);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nb_trans_done, req);
+        subreq = sendto_send(state, state->ev, state->sock,
+                             state->buf, state->buflen, 0, state->dst_addr);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nb_trans_sent, req);
+}
+static void nb_trans_sent(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_trans_state *state = tevent_req_data(
+                req, struct nb_trans_state);
+        ssize_t sent;
+        int err;
+        sent = sendto_recv(subreq, &err);
+        TALLOC_FREE(subreq);
+        if (sent == -1) {
+                DEBUG(10, ("sendto failed: %s\n", strerror(err)));
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                return;
+        }
+        subreq = tevent_wakeup_send(state, state->ev,
+                                    timeval_current_ofs(1, 0));
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nb_trans_send_next, req);
+}
+static void nb_trans_send_next(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_trans_state *state = tevent_req_data(
+                req, struct nb_trans_state);
+        bool ret;
+        ret = tevent_wakeup_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (!ret) {
+                tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+                return;
+        }
+        subreq = sendto_send(state, state->ev, state->sock,
+                             state->buf, state->buflen, 0, state->dst_addr);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nb_trans_sent, req);
+}
+static void nb_trans_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_trans_state *state = tevent_req_data(
+                req, struct nb_trans_state);
+        NTSTATUS status;
+        status = sock_packet_read_recv(subreq, &state->packet);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+static NTSTATUS nb_trans_recv(struct tevent_req *req,
+                              struct packet_struct **ppacket)
+{
+        struct nb_trans_state *state = tevent_req_data(
+                req, struct nb_trans_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        *ppacket = state->packet;
+        state->packet = NULL;
+        return NT_STATUS_OK;
+}
 /****************************************************************************
 …
 **************************************************************************/
+NODE_STATUS_STRUCT *node_status_query(int fd,
+                                        struct nmb_name *name,
+                                        const struct sockaddr_storage *to_ss,
+                                        int *num_names,
+                                        struct node_status_extra *extra)
+{
+        bool found=False;
+        int retries = 2;
+        int retry_time = 2000;
+        struct timeval tval;
+struct node_status_query_state {
+        struct sockaddr_storage my_addr;
+        struct sockaddr_storage addr;
+        uint8_t buf[1024];
+        ssize_t buflen;
+        struct packet_struct *packet;
+};
+static int node_status_query_state_destructor(
+        struct node_status_query_state *s);
+static bool node_status_query_validator(struct packet_struct *p,
+                                        void *private_data);
+static void node_status_query_done(struct tevent_req *subreq);
+struct tevent_req *node_status_query_send(TALLOC_CTX *mem_ctx,
+                                          struct tevent_context *ev,
+                                          struct nmb_name *name,
+                                          const struct sockaddr_storage *addr)
+{
+        struct tevent_req *req, *subreq;
+        struct node_status_query_state *state;
         struct packet_struct p;
-        struct packet_struct *p2;
         struct nmb_packet *nmb = &p.packet.nmb;
+        NODE_STATUS_STRUCT *ret;
+        struct sockaddr_in *in_addr;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct node_status_query_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        talloc_set_destructor(state, node_status_query_state_destructor);
+        if (addr->ss_family != AF_INET) {
+                /* Can't do node status to IPv6 */
+                tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
+                return tevent_req_post(req, ev);
+        }
+        state->addr = *addr;
+        in_addr = (struct sockaddr_in *)(void *)&state->addr;
+        in_addr->sin_port = htons(NMB_PORT);
+        if (!interpret_string_addr(&state->my_addr, lp_socket_address(),
+                                   AI_NUMERICHOST|AI_PASSIVE)) {
+                zero_sockaddr(&state->my_addr);
+        }
         ZERO_STRUCT(p);
-        if (to_ss->ss_family != AF_INET) {
-                /* Can't do node status to IPv6 */
-                return NULL;
+        }
         nmb->header.name_trn_id = generate_trn_id();
         nmb->header.opcode = 0;
 …
         nmb->question.question_class = 0x1;
+        p.ip = ((const struct sockaddr_in *)to_ss)->sin_addr;
+        p.port = NMB_PORT;
+        p.recv_fd = -1;
+        p.send_fd = fd;
+        p.timestamp = time(NULL);
+        p.packet_type = NMB_PACKET;
+        GetTimeOfDay(&tval);
+        if (!send_packet(&p))
+                return NULL;
+        retries--;
+        while (1) {
+                struct timeval tval2;
+                GetTimeOfDay(&tval2);
+                if (TvalDiff(&tval,&tval2) > retry_time) {
+                        if (!retries)
+                                break;
+                        if (!found && !send_packet(&p))
+                                return NULL;
+                        GetTimeOfDay(&tval);
+                        retries--;
+                }
+                if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
+                        struct nmb_packet *nmb2 = &p2->packet.nmb;
+                        debug_nmb_packet(p2);
+                        if (nmb2->header.opcode != 0 ||
+                            nmb2->header.nm_flags.bcast ||
+                            nmb2->header.rcode ||
+                            !nmb2->header.ancount ||
+                            nmb2->answers->rr_type != 0x21) {
+                                /* XXXX what do we do with this? could be a
+                                   redirect, but we'll discard it for the
+                                   moment */
+                                free_packet(p2);
+                                continue;
+                        }
+                        ret = parse_node_status(&nmb2->answers->rdata[0],
+                                        num_names, extra);
+                        free_packet(p2);
+                        return ret;
+                }
+        }
+        return NULL;
+        state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
+                                     &p);
+        if (state->buflen == 0) {
+                tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+                DEBUG(10, ("build_packet failed\n"));
+                return tevent_req_post(req, ev);
+        }
+        subreq = nb_trans_send(state, ev, &state->my_addr, &state->addr, false,
+                               state->buf, state->buflen,
+                               NMB_PACKET, nmb->header.name_trn_id,
+                               node_status_query_validator, NULL);
+        if (tevent_req_nomem(subreq, req)) {
+                DEBUG(10, ("nb_trans_send failed\n"));
+                return tevent_req_post(req, ev);
+        }
+        if (!tevent_req_set_endtime(req, ev, timeval_current_ofs(10, 0))) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, node_status_query_done, req);
+        return req;
+}
+static bool node_status_query_validator(struct packet_struct *p,
+                                        void *private_data)
+{
+        struct nmb_packet *nmb = &p->packet.nmb;
+        debug_nmb_packet(p);
+        if (nmb->header.opcode != 0 ||
+            nmb->header.nm_flags.bcast ||
+            nmb->header.rcode ||
+            !nmb->header.ancount ||
+            nmb->answers->rr_type != 0x21) {
+                /*
+                 * XXXX what do we do with this? could be a redirect,
+                 * but we'll discard it for the moment
+                 */
+                return false;
+        }
+        return true;
+}
+static int node_status_query_state_destructor(
+        struct node_status_query_state *s)
+{
+        if (s->packet != NULL) {
+                free_packet(s->packet);
+                s->packet = NULL;
+        }
+        return 0;
+}
+static void node_status_query_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct node_status_query_state *state = tevent_req_data(
+                req, struct node_status_query_state);
+        NTSTATUS status;
+        status = nb_trans_recv(subreq, &state->packet);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS node_status_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                                struct node_status **pnode_status,
+                                int *pnum_names,
+                                struct node_status_extra *extra)
+{
+        struct node_status_query_state *state = tevent_req_data(
+                req, struct node_status_query_state);
+        struct node_status *node_status;
+        int num_names;
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        node_status = parse_node_status(
+                mem_ctx, &state->packet->packet.nmb.answers->rdata[0],
+                &num_names, extra);
+        if (node_status == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        *pnode_status = node_status;
+        *pnum_names = num_names;
+        return NT_STATUS_OK;
+}
+NTSTATUS node_status_query(TALLOC_CTX *mem_ctx, struct nmb_name *name,
+                           const struct sockaddr_storage *addr,
+                           struct node_status **pnode_status,
+                           int *pnum_names,
+                           struct node_status_extra *extra)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        ev = tevent_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = node_status_query_send(ev, ev, name, addr);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = node_status_query_recv(req, mem_ctx, pnode_status,
+                                        pnum_names, extra);
+ fail:
+        TALLOC_FREE(frame);
+        return status;
+}
 …
         char addr[INET6_ADDRSTRLEN];
         struct sockaddr_storage ss;
         NODE_STATUS_STRUCT *status = NULL;
+        struct node_status *addrs = NULL;
         struct nmb_name nname;
         int count, i;
-        int sock;
         bool result = false;
+        NTSTATUS status;
         if (lp_disable_netbios()) {
 …
+        }
-        sock = open_socket_in(SOCK_DGRAM, 0, 3, &ss, True);
-        if (sock == -1)
-                goto done;
         /* W2K PDC's seem not to respond to '*'#0. JRA */
         make_nmb_name(&nname, q_name, q_type);
         status = node_status_query(sock, &nname, to_ss, &count, NULL);
         close(sock);
         if (!status)
+        status = node_status_query(talloc_tos(), &nname, to_ss,
+                                   &addrs, &count, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto done;
+        }
         for (i=0;i<count;i++) {
                 /* Find first one of the requested type that's not a GROUP. */
                 if (status[i].type == type && ! (status[i].flags & 0x80))
+                if (addrs[i].type == type && ! (addrs[i].flags & 0x80))
                         break;
+        }
 …
                 goto done;
         pull_ascii_nstring(name, sizeof(fstring), status[i].name);
+        pull_ascii_nstring(name, sizeof(fstring), addrs[i].name);
         /* Store the result in the cache. */
 …
  done:
         SAFE_FREE(status);
+        TALLOC_FREE(addrs);
         DEBUG(10, ("name_status_find: name %sfound", result ? "" : "not "));
 …
 */
 static int addr_compare(const struct sockaddr *ss1,
                 const struct sockaddr *ss2)
+static int addr_compare(const struct sockaddr_storage *ss1,
+                        const struct sockaddr_storage *ss2)
+{
         int max_bits1=0, max_bits2=0;
 …
         /* Sort IPv4 addresses first. */
         if (ss1->sa_family != ss2->sa_family) {
                 if (ss2->sa_family == AF_INET) {
+        if (ss1->ss_family != ss2->ss_family) {
+                if (ss2->ss_family == AF_INET) {
                         return 1;
                 } else {
 …
                 int bits1, bits2;
                 if (pss->ss_family != ss1->sa_family) {
+                if (pss->ss_family != ss1->ss_family) {
                         /* Ignore interfaces of the wrong type. */
                         continue;
 …
         /* Bias towards directly reachable IPs */
         if (iface_local(ss1)) {
                 if (ss1->sa_family == AF_INET) {
+        if (iface_local((struct sockaddr *)ss1)) {
+                if (ss1->ss_family == AF_INET) {
                         max_bits1 += 32;
                 } else {
 …
+                }
+        }
         if (iface_local(ss2)) {
                 if (ss2->sa_family == AF_INET) {
+        if (iface_local((struct sockaddr *)ss2)) {
+                if (ss2->ss_family == AF_INET) {
                         max_bits2 += 32;
                 } else {
 …
         int result;
         if ((result = addr_compare((struct sockaddr *)&ss1->ss, (struct sockaddr *)&ss2->ss)) != 0) {
+        if ((result = addr_compare(&ss1->ss, &ss2->ss)) != 0) {
                 return result;
+        }
 …
+        }
+        qsort(sslist, count, sizeof(struct sockaddr_storage),
+                        QSORT_CAST addr_compare);
+        TYPESAFE_QSORT(sslist, count, addr_compare);
+}
 …
+        }
+        qsort(servlist, count, sizeof(struct ip_service),
+                        QSORT_CAST ip_service_compare);
+        TYPESAFE_QSORT(servlist, count, ip_service_compare);
+}
 …
         /* one loop to remove duplicates */
         for ( i=0; i<count; i++ ) {
                 if ( is_zero_addr((struct sockaddr *)&iplist[i].ss)) {
+                if ( is_zero_addr(&iplist[i].ss)) {
                         continue;
+                }
 …
         /* first ip should never be a zero_ip() */
         for (i = 0; i<count; ) {
                 if (is_zero_addr((struct sockaddr *)&iplist[i].ss) ) {
+                if (is_zero_addr(&iplist[i].ss) ) {
                         if (i != count-1) {
                                 memmove(&iplist[i], &iplist[i+1],
 …
 ****************************************************************************/
+struct sockaddr_storage *name_query(int fd,
+                        const char *name,
+                        int name_type,
+                        bool bcast,
+                        bool recurse,
+                        const struct sockaddr_storage *to_ss,
+                        int *count,
+                        int *flags,
+                        bool *timed_out)
+{
+        bool found=false;
+        int i, retries = 3;
+        int retry_time = bcast?250:2000;
+        struct timeval tval;
+struct name_query_state {
+        struct sockaddr_storage my_addr;
+        struct sockaddr_storage addr;
+        bool bcast;
+        uint8_t buf[1024];
+        ssize_t buflen;
+        NTSTATUS validate_error;
+        uint8_t flags;
+        struct sockaddr_storage *addrs;
+        int num_addrs;
+};
+static bool name_query_validator(struct packet_struct *p, void *private_data);
+static void name_query_done(struct tevent_req *subreq);
+struct tevent_req *name_query_send(TALLOC_CTX *mem_ctx,
+                                   struct tevent_context *ev,
+                                   const char *name, int name_type,
+                                   bool bcast, bool recurse,
+                                   const struct sockaddr_storage *addr)
+{
+        struct tevent_req *req, *subreq;
+        struct name_query_state *state;
         struct packet_struct p;
-        struct packet_struct *p2;
         struct nmb_packet *nmb = &p.packet.nmb;
+        struct sockaddr_storage *ss_list = NULL;
+        struct sockaddr_in *in_addr;
+        req = tevent_req_create(mem_ctx, &state, struct name_query_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->bcast = bcast;
+        if (addr->ss_family != AF_INET) {
+                /* Can't do node status to IPv6 */
+                tevent_req_nterror(req, NT_STATUS_INVALID_ADDRESS);
+                return tevent_req_post(req, ev);
+        }
         if (lp_disable_netbios()) {
                 DEBUG(5,("name_query(%s#%02x): netbios is disabled\n",
                                         name, name_type));
+                return NULL;
+        }
+        if (to_ss->ss_family != AF_INET) {
+                return NULL;
+        }
+        if (timed_out) {
+                *timed_out = false;
+        }
+        memset((char *)&p,'\0',sizeof(p));
+        (*count) = 0;
+        (*flags) = 0;
+                tevent_req_nterror(req, NT_STATUS_NOT_SUPPORTED);
+                return tevent_req_post(req, ev);
+        }
+        state->addr = *addr;
+        in_addr = (struct sockaddr_in *)(void *)&state->addr;
+        in_addr->sin_port = htons(NMB_PORT);
+        if (!interpret_string_addr(&state->my_addr, lp_socket_address(),
+                                   AI_NUMERICHOST|AI_PASSIVE)) {
+                zero_sockaddr(&state->my_addr);
+        }
+        ZERO_STRUCT(p);
         nmb->header.name_trn_id = generate_trn_id();
         nmb->header.opcode = 0;
 …
         nmb->question.question_class = 0x1;
+        p.ip = ((struct sockaddr_in *)to_ss)->sin_addr;
+        p.port = NMB_PORT;
+        p.recv_fd = -1;
+        p.send_fd = fd;
+        p.timestamp = time(NULL);
+        p.packet_type = NMB_PACKET;
+        GetTimeOfDay(&tval);
+        if (!send_packet(&p))
+                return NULL;
+        retries--;
+        while (1) {
+                struct timeval tval2;
+                GetTimeOfDay(&tval2);
+                if (TvalDiff(&tval,&tval2) > retry_time) {
+                        if (!retries)
+        state->buflen = build_packet((char *)state->buf, sizeof(state->buf),
+                                     &p);
+        if (state->buflen == 0) {
+                tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
+                DEBUG(10, ("build_packet failed\n"));
+                return tevent_req_post(req, ev);
+        }
+        subreq = nb_trans_send(state, ev, &state->my_addr, &state->addr, bcast,
+                               state->buf, state->buflen,
+                               NMB_PACKET, nmb->header.name_trn_id,
+                               name_query_validator, state);
+        if (tevent_req_nomem(subreq, req)) {
+                DEBUG(10, ("nb_trans_send failed\n"));
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, name_query_done, req);
+        return req;
+}
+static bool name_query_validator(struct packet_struct *p, void *private_data)
+{
+        struct name_query_state *state = talloc_get_type_abort(
+                private_data, struct name_query_state);
+        struct nmb_packet *nmb = &p->packet.nmb;
+        struct sockaddr_storage *tmp_addrs;
+        bool got_unique_netbios_name = false;
+        int i;
+        debug_nmb_packet(p);
+        /*
+         * If we get a Negative Name Query Response from a WINS
+         * server, we should report it and give up.
+         */
+        if( 0 == nmb->header.opcode     /* A query response   */
+            && !state->bcast            /* from a WINS server */
+            && nmb->header.rcode        /* Error returned     */
+                ) {
+                if( DEBUGLVL( 3 ) ) {
+                        /* Only executed if DEBUGLEVEL >= 3 */
+                        dbgtext( "Negative name query "
+                                 "response, rcode 0x%02x: ",
+                                 nmb->header.rcode );
+                        switch( nmb->header.rcode ) {
+                        case 0x01:
+                                dbgtext("Request was invalidly formatted.\n");
                                 break;
+                        if (!found && !send_packet(&p))
+                                return NULL;
+                        GetTimeOfDay(&tval);
+                        retries--;
+                }
+                if ((p2=receive_nmb_packet(fd,90,nmb->header.name_trn_id))) {
+                        struct nmb_packet *nmb2 = &p2->packet.nmb;
+                        debug_nmb_packet(p2);
+                        /* If we get a Negative Name Query Response from a WINS
+                         * server, we should report it and give up.
+                         */
+                        if( 0 == nmb2->header.opcode    /* A query response   */
+                            && !(bcast)                 /* from a WINS server */
+                            && nmb2->header.rcode       /* Error returned     */
+                                ) {
+                                if( DEBUGLVL( 3 ) ) {
+                                        /* Only executed if DEBUGLEVEL >= 3 */
+                                        dbgtext( "Negative name query "
+                                                "response, rcode 0x%02x: ",
+                                                nmb2->header.rcode );
+                                        switch( nmb2->header.rcode ) {
+                                        case 0x01:
+                                                dbgtext( "Request "
+                                                "was invalidly formatted.\n" );
+                                                break;
+                                        case 0x02:
+                                                dbgtext( "Problem with NBNS, "
+                                                "cannot process name.\n");
+                                                break;
+                                        case 0x03:
+                                                dbgtext( "The name requested "
+                                                "does not exist.\n" );
+                                                break;
+                                        case 0x04:
+                                                dbgtext( "Unsupported request "
+                                                "error.\n" );
+                                                break;
+                                        case 0x05:
+                                                dbgtext( "Query refused "
+                                                "error.\n" );
+                                                break;
+                                        default:
+                                                dbgtext( "Unrecognized error "
+                                                "code.\n" );
+                                                break;
+                                        }
+                                }
+                                free_packet(p2);
+                                return( NULL );
+                        case 0x02:
+                                dbgtext("Problem with NBNS, cannot process "
+                                        "name.\n");
+                                break;
+                        case 0x03:
+                                dbgtext("The name requested does not "
+                                        "exist.\n");
+                                break;
+                        case 0x04:
+                                dbgtext("Unsupported request error.\n");
+                                break;
+                        case 0x05:
+                                dbgtext("Query refused error.\n");
+                                break;
+                        default:
+                                dbgtext("Unrecognized error code.\n" );
+                                break;
+                        }
+                        if (nmb2->header.opcode != 0 ||
+                            nmb2->header.nm_flags.bcast ||
+                            nmb2->header.rcode ||
+                            !nmb2->header.ancount) {
+                                /*
+                                 * XXXX what do we do with this? Could be a
+                                 * redirect, but we'll discard it for the
+                                 * moment.
+                                 */
+                                free_packet(p2);
+                                continue;
+                }
+                /*
+                 * We accept this packet as valid, but tell the upper
+                 * layers that it's a negative response.
+                 */
+                state->validate_error = NT_STATUS_NOT_FOUND;
+                return true;
+        }
+        if (nmb->header.opcode != 0 ||
+            nmb->header.nm_flags.bcast ||
+            nmb->header.rcode ||
+            !nmb->header.ancount) {
+                /*
+                 * XXXX what do we do with this? Could be a redirect,
+                 * but we'll discard it for the moment.
+                 */
+                return false;
+        }
+        tmp_addrs = TALLOC_REALLOC_ARRAY(
+                state, state->addrs, struct sockaddr_storage,
+                state->num_addrs + nmb->answers->rdlength/6);
+        if (tmp_addrs == NULL) {
+                state->validate_error = NT_STATUS_NO_MEMORY;
+                return true;
+        }
+        state->addrs = tmp_addrs;
+        DEBUG(2,("Got a positive name query response "
+                 "from %s ( ", inet_ntoa(p->ip)));
+        for (i=0; i<nmb->answers->rdlength/6; i++) {
+                uint16_t flags;
+                struct in_addr ip;
+                struct sockaddr_storage addr;
+                int j;
+                flags = RSVAL(&nmb->answers->rdata[i*6], 0);
+                got_unique_netbios_name |= ((flags & 0x8000) == 0);
+                putip((char *)&ip,&nmb->answers->rdata[2+i*6]);
+                in_addr_to_sockaddr_storage(&addr, ip);
+                for (j=0; j<state->num_addrs; j++) {
+                        if (sockaddr_equal(
+                                    (struct sockaddr *)&addr,
+                                    (struct sockaddr *)&state->addrs[j])) {
+                                break;
+                        }
+                        ss_list = SMB_REALLOC_ARRAY(ss_list,
+                                                struct sockaddr_storage,
+                                                (*count) +
+                                                nmb2->answers->rdlength/6);
+                        if (!ss_list) {
+                                DEBUG(0,("name_query: Realloc failed.\n"));
+                                free_packet(p2);
+                                return NULL;
+                        }
+                        DEBUG(2,("Got a positive name query response "
+                                        "from %s ( ",
+                                        inet_ntoa(p2->ip)));
+                        for (i=0;i<nmb2->answers->rdlength/6;i++) {
+                                struct in_addr ip;
+                                putip((char *)&ip,&nmb2->answers->rdata[2+i*6]);
+                                in_addr_to_sockaddr_storage(&ss_list[(*count)],
+                                                ip);
+                                DEBUGADD(2,("%s ",inet_ntoa(ip)));
+                                (*count)++;
+                        }
+                        DEBUGADD(2,(")\n"));
+                        found=true;
+                        retries=0;
+                        /* We add the flags back ... */
+                        if (nmb2->header.response)
+                                (*flags) |= NM_FLAGS_RS;
+                        if (nmb2->header.nm_flags.authoritative)
+                                (*flags) |= NM_FLAGS_AA;
+                        if (nmb2->header.nm_flags.trunc)
+                                (*flags) |= NM_FLAGS_TC;
+                        if (nmb2->header.nm_flags.recursion_desired)
+                                (*flags) |= NM_FLAGS_RD;
+                        if (nmb2->header.nm_flags.recursion_available)
+                                (*flags) |= NM_FLAGS_RA;
+                        if (nmb2->header.nm_flags.bcast)
+                                (*flags) |= NM_FLAGS_B;
+                        free_packet(p2);
+                        /*
+                         * If we're doing a unicast lookup we only
+                         * expect one reply. Don't wait the full 2
+                         * seconds if we got one. JRA.
+                         */
+                        if(!bcast && found)
+                                break;
+                }
+        }
+        /* only set timed_out if we didn't fund what we where looking for*/
+        if ( !found && timed_out ) {
+                *timed_out = true;
+        }
+        /* sort the ip list so we choose close servers first if possible */
+        sort_addr_list(ss_list, *count);
+        return ss_list;
+                }
+                if (j < state->num_addrs) {
+                        /* Already got it */
+                        continue;
+                }
+                DEBUGADD(2,("%s ",inet_ntoa(ip)));
+                state->addrs[state->num_addrs] = addr;
+                state->num_addrs += 1;
+        }
+        DEBUGADD(2,(")\n"));
+        /* We add the flags back ... */
+        if (nmb->header.response)
+                state->flags |= NM_FLAGS_RS;
+        if (nmb->header.nm_flags.authoritative)
+                state->flags |= NM_FLAGS_AA;
+        if (nmb->header.nm_flags.trunc)
+                state->flags |= NM_FLAGS_TC;
+        if (nmb->header.nm_flags.recursion_desired)
+                state->flags |= NM_FLAGS_RD;
+        if (nmb->header.nm_flags.recursion_available)
+                state->flags |= NM_FLAGS_RA;
+        if (nmb->header.nm_flags.bcast)
+                state->flags |= NM_FLAGS_B;
+        if (state->bcast) {
+                /*
+                 * We have to collect all entries coming in from broadcast
+                 * queries. If we got a unique name, we're done.
+                 */
+                return got_unique_netbios_name;
+        }
+        /*
+         * WINS responses are accepted when they are received
+         */
+        return true;
+}
+static void name_query_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct name_query_state *state = tevent_req_data(
+                req, struct name_query_state);
+        NTSTATUS status;
+        struct packet_struct *p = NULL;
+        status = nb_trans_recv(subreq, &p);
+        TALLOC_FREE(subreq);
+        if (tevent_req_nterror(req, status)) {
+                return;
+        }
+        if (!NT_STATUS_IS_OK(state->validate_error)) {
+                tevent_req_nterror(req, state->validate_error);
+                return;
+        }
+        if (p != NULL) {
+                /*
+                 * Free the packet here, we've collected the response in the
+                 * validator
+                 */
+                free_packet(p);
+        }
+        tevent_req_done(req);
+}
+NTSTATUS name_query_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                         struct sockaddr_storage **addrs, int *num_addrs,
+                         uint8_t *flags)
+{
+        struct name_query_state *state = tevent_req_data(
+                req, struct name_query_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)
+            && !NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+                return status;
+        }
+        if (state->num_addrs == 0) {
+                return NT_STATUS_NOT_FOUND;
+        }
+        *addrs = talloc_move(mem_ctx, &state->addrs);
+        sort_addr_list(*addrs, state->num_addrs);
+        *num_addrs = state->num_addrs;
+        if (flags != NULL) {
+                *flags = state->flags;
+        }
+        return NT_STATUS_OK;
+}
+NTSTATUS name_query(const char *name, int name_type,
+                    bool bcast, bool recurse,
+                    const struct sockaddr_storage *to_ss,
+                    TALLOC_CTX *mem_ctx,
+                    struct sockaddr_storage **addrs,
+                    int *num_addrs, uint8_t *flags)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct tevent_context *ev;
+        struct tevent_req *req;
+        struct timeval timeout;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
+        ev = tevent_context_init(frame);
+        if (ev == NULL) {
+                goto fail;
+        }
+        req = name_query_send(ev, ev, name, name_type, bcast, recurse, to_ss);
+        if (req == NULL) {
+                goto fail;
+        }
+        if (bcast) {
+                timeout = timeval_current_ofs(0, 250000);
+        } else {
+                timeout = timeval_current_ofs(2, 0);
+        }
+        if (!tevent_req_set_endtime(req, ev, timeout)) {
+                goto fail;
+        }
+        if (!tevent_req_poll_ntstatus(req, ev, &status)) {
+                goto fail;
+        }
+        status = name_query_recv(req, mem_ctx, addrs, num_addrs, flags);
+ fail:
+        TALLOC_FREE(frame);
+        return status;
+}
 …
 NTSTATUS name_resolve_bcast(const char *name,
                         int name_type,
+                        struct ip_service **return_iplist,
+                        TALLOC_CTX *mem_ctx,
+                        struct sockaddr_storage **return_iplist,
                         int *return_count)
+{
         int sock, i;
+        int i;
         int num_interfaces = iface_count();
         struct sockaddr_storage *ss_list;
+        struct sockaddr_storage ss;
+        NTSTATUS status;
+        NTSTATUS status = NT_STATUS_NOT_FOUND;
         if (lp_disable_netbios()) {
 …
                 "for name %s<0x%x>\n", name, name_type));
-        if (!interpret_string_addr(&ss, lp_socket_address(),
-                                AI_NUMERICHOST|AI_PASSIVE)) {
-                zero_sockaddr(&ss);
+        }
-        sock = open_socket_in( SOCK_DGRAM, 0, 3, &ss, true );
-        if (sock == -1) {
-                return NT_STATUS_UNSUCCESSFUL;
+        }
-        set_socket_options(sock,"SO_BROADCAST");
         /*
          * Lookup the name on all the interfaces, return on
 …
         for( i = num_interfaces-1; i >= 0; i--) {
                 const struct sockaddr_storage *pss = iface_n_bcast(i);
-                int flags;
                 /* Done this way to fix compiler error on IRIX 5.x */
 …
                         continue;
+                }
+                ss_list = name_query(sock, name, name_type, true,
+                                    true, pss, return_count, &flags, NULL);
+                if (ss_list) {
+                status = name_query(name, name_type, true, true, pss,
+                                    talloc_tos(), &ss_list, return_count,
+                                    NULL);
+                if (NT_STATUS_IS_OK(status)) {
                         goto success;
+                }
 …
         /* failed - no response */
+        close(sock);
+        return NT_STATUS_UNSUCCESSFUL;
+        return status;
 success:
+        status = NT_STATUS_OK;
+        if (!convert_ss2service(return_iplist, ss_list, *return_count) )
+                status = NT_STATUS_INVALID_PARAMETER;
+        SAFE_FREE(ss_list);
+        close(sock);
+        *return_iplist = ss_list;
         return status;
+}
 …
                 int *return_count)
+{
         int sock, t, i;
+        int t, i;
         char **wins_tags;
         struct sockaddr_storage src_ss, *ss_list = NULL;
 …
                         struct sockaddr_storage wins_ss;
                         struct in_addr wins_ip;
-                        int flags;
-                        bool timed_out;
                         wins_ip = wins_srv_ip_tag(wins_tags[t], src_ip);
 …
                                 inet_ntoa(wins_ip), wins_tags[t]));
-                        sock = open_socket_in(SOCK_DGRAM, 0, 3, &src_ss, true);
-                        if (sock == -1) {
-                                continue;
+                        }
                         in_addr_to_sockaddr_storage(&wins_ss, wins_ip);
+                        ss_list = name_query(sock,
+                                                name,
+                        status = name_query(name,
                                                 name_type,
                                                 false,
                                                 true,
                                                 &wins_ss,
+                                                talloc_tos(),
+                                                &ss_list,
                                                 return_count,
+                                                &flags,
+                                                &timed_out);
+                                                NULL);
                         /* exit loop if we got a list of addresses */
                         if (ss_list)
+                        if (NT_STATUS_IS_OK(status)) {
                                 goto success;
+                        close(sock);
+                        if (timed_out) {
+                                /* Timed out wating for WINS server to respond.
+                        }
+                        if (NT_STATUS_EQUAL(status,
+                                            NT_STATUS_IO_TIMEOUT)) {
+                                /* Timed out waiting for WINS server to
+                                 * respond.
                                  * Mark it dead. */
                                 wins_srv_died(wins_ip, src_ip);
                         } else {
                                 /* The name definately isn't in this
+                                /* The name definitely isn't in this
                                    group of WINS servers.
                                    goto the next group  */
 …
                 status = NT_STATUS_INVALID_PARAMETER;
         SAFE_FREE(ss_list);
+        TALLOC_FREE(ss_list);
         wins_srv_tags_free(wins_tags);
-        close(sock);
         return status;
 …
          * "lmhosts" means parse the local lmhosts file.
          */
+        XFILE *fp;
+        char *lmhost_name = NULL;
+        int name_type2;
+        struct sockaddr_storage return_ss;
+        struct sockaddr_storage *ss_list;
         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
         TALLOC_CTX *ctx = NULL;
 …
                 name, name_type));
-        fp = startlmhosts(get_dyn_LMHOSTSFILE());
-        if ( fp == NULL )
-                return NT_STATUS_NO_SUCH_FILE;
         ctx = talloc_init("resolve_lmhosts");
         if (!ctx) {
-                endlmhosts(fp);
                 return NT_STATUS_NO_MEMORY;
+        }
+        while (getlmhostsent(ctx, fp, &lmhost_name, &name_type2, &return_ss)) {
+                if (!strequal(name, lmhost_name)) {
+                        TALLOC_FREE(lmhost_name);
+                        continue;
+                }
+                if ((name_type2 != -1) && (name_type != name_type2)) {
+                        TALLOC_FREE(lmhost_name);
+                        continue;
+                }
+                *return_iplist = SMB_REALLOC_ARRAY((*return_iplist),
+                                        struct ip_service,
+                                        (*return_count)+1);
+                if ((*return_iplist) == NULL) {
+                        TALLOC_FREE(ctx);
+                        endlmhosts(fp);
+                        DEBUG(3,("resolve_lmhosts: malloc fail !\n"));
+        status = resolve_lmhosts_file_as_sockaddr(get_dyn_LMHOSTSFILE(),
+                                                  name, name_type,
+                                                  ctx,
+                                                  &ss_list,
+                                                  return_count);
+        if (NT_STATUS_IS_OK(status)) {
+                if (convert_ss2service(return_iplist,
+                                       ss_list,
+                                       *return_count)) {
+                        talloc_free(ctx);
+                        return NT_STATUS_OK;
+                } else {
+                        talloc_free(ctx);
                         return NT_STATUS_NO_MEMORY;
+                }
+                (*return_iplist)[*return_count].ss = return_ss;
+                (*return_iplist)[*return_count].port = PORT_NONE;
+                *return_count += 1;
+                /* we found something */
+                status = NT_STATUS_OK;
+                /* Multiple names only for DC lookup */
+                if (name_type != 0x1c)
+                        break;
+        }
+        TALLOC_FREE(ctx);
+        endlmhosts(fp);
+        }
+        talloc_free(ctx);
         return status;
+}
 …
  Resolve via "ADS" method.
 *********************************************************/
+/* Special name type used to cause a _kerberos DNS lookup. */
+#define KDC_NAME_TYPE 0xDCDC
 static NTSTATUS resolve_ads(const char *name,
 …
                  * doesn't know anything about the DC's   -- jerry */
                 if (!is_zero_addr((struct sockaddr *)&r->ss)) {
+                if (!is_zero_addr(&r->ss)) {
                         (*return_count)++;
+                }
 …
+                        }
                 } else if(strequal( tok, "bcast")) {
+                        status = name_resolve_bcast(name, name_type,
+                                                    return_iplist,
+                                                    return_count);
+                        struct sockaddr_storage *ss_list;
+                        status = name_resolve_bcast(
+                                name, name_type, talloc_tos(),
+                                &ss_list, return_count);
                         if (NT_STATUS_IS_OK(status)) {
+                                if (!convert_ss2service(return_iplist,
+                                                        ss_list,
+                                                        *return_count)) {
+                                        status = NT_STATUS_NO_MEMORY;
+                                }
                                 goto done;
+                        }
 …
                 if (prefer_ipv4) {
                         for (i=0; i<count; i++) {
                                 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
+                                if (!is_zero_addr(&ss_list[i].ss) &&
                                                 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss) &&
                                                 (ss_list[i].ss.ss_family == AF_INET)) {
 …
                 /* only return valid addresses for TCP connections */
                 for (i=0; i<count; i++) {
                         if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
+                        if (!is_zero_addr(&ss_list[i].ss) &&
                                         !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
                                 *return_ss = ss_list[i].ss;
 …
         /* only return valid addresses for TCP connections */
         for (i=0, num_entries = 0; i<count; i++) {
                 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
+                if (!is_zero_addr(&ss_list[i].ss) &&
                                 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
                         num_entries++;
 …
         for (i=0, num_entries = 0; i<count; i++) {
                 if (!is_zero_addr((struct sockaddr *)&ss_list[i].ss) &&
+                if (!is_zero_addr(&ss_list[i].ss) &&
                                 !is_broadcast_addr((struct sockaddr *)&ss_list[i].ss)) {
                         (*return_ss_arr)[num_entries++] = ss_list[i].ss;
 …
         if (strequal(domain, lp_workgroup()) || strequal(domain, lp_realm())) {
                 pserver = talloc_asprintf(NULL, "%s, %s",
+                pserver = talloc_asprintf(ctx, "%s, %s",
                         saf_servername ? saf_servername : "",
                         lp_passwordserver());
         } else {
                 pserver = talloc_asprintf(NULL, "%s, *",
+                pserver = talloc_asprintf(ctx, "%s, *",
                         saf_servername ? saf_servername : "");
+        }

vendor/current/source3/libsmb/namequery_dc.c

-              r478
+              r740
    Copyright (C) Andrew Bartlett 2002
    Copyright (C) Gerald Carter 2003
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "libads/sitename_cache.h"
+#include "ads.h"
+#include "../librpc/gen_ndr/nbt.h"
 /**********************************************************************
 …
  Find the name and IP address for a server in the realm/domain
  *************************************************************************/
 static bool ads_dc_name(const char *domain,
                         const char *realm,
 …
+                }
 #ifdef HAVE_KRB5
+#ifdef HAVE_ADS
                 if (is_our_primary_domain(domain) && (ads->config.flags & NBT_SERVER_KDC)) {
                         if (ads_closest_dc(ads)) {
 …
         for (i = 0; i < count; i++) {
                 if (is_zero_addr((struct sockaddr *)&ip_list[i].ss))
+                if (is_zero_addr(&ip_list[i].ss))
                         continue;

vendor/current/source3/libsmb/nmblib.c

-              r594
+              r740
 #include "includes.h"
+#include "libsmb/nmblib.h"
 static const struct opcode_names {
 …
+}
+int packet_trn_id(struct packet_struct *p)
+{
+        int result;
+        switch (p->packet_type) {
+        case NMB_PACKET:
+                result = p->packet.nmb.header.name_trn_id;
+                break;
+        case DGRAM_PACKET:
+                result = p->packet.dgram.header.dgm_id;
+                break;
+        default:
+                result = -1;
+        }
+        return result;
+}
 /*******************************************************************
  Parse a packet buffer into a packet structure.
 …
 /****************************************************************************
- Receive a packet with timeout on a open UDP filedescriptor.
- The timeout is in milliseconds
-***************************************************************************/
-struct packet_struct *receive_packet(int fd,enum packet_type type,int t)
+{
-        fd_set fds;
-        struct timeval timeout;
-        int ret;
-        if (fd < 0 || fd >= FD_SETSIZE) {
-                errno = EBADF;
-                return NULL;
+        }
-        FD_ZERO(&fds);
-        FD_SET(fd,&fds);
-        timeout.tv_sec = t/1000;
-        timeout.tv_usec = 1000*(t%1000);
-        if ((ret = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout)) == -1) {
-                /* errno should be EBADF or EINVAL. */
-                DEBUG(0,("select returned -1, errno = %s (%d)\n",
-                                        strerror(errno), errno));
-                return NULL;
+        }
-        if (ret == 0) /* timeout */
-                return NULL;
-        if (FD_ISSET(fd,&fds))
-                return(read_packet(fd,type));
-        return(NULL);
+}
-/****************************************************************************
- Receive a UDP/137 packet either via UDP or from the unexpected packet
- queue. The packet must be a reply packet and have the specified trn_id.
- The timeout is in milliseconds.
-***************************************************************************/
-struct packet_struct *receive_nmb_packet(int fd, int t, int trn_id)
+{
-        struct packet_struct *p;
-        p = receive_packet(fd, NMB_PACKET, t);
-        if (p && p->packet.nmb.header.response &&
-                        p->packet.nmb.header.name_trn_id == trn_id) {
-                return p;
+        }
-        if (p)
-                free_packet(p);
-        /* try the unexpected packet queue */
-        return receive_unexpected(NMB_PACKET, trn_id, NULL);
+}
-/****************************************************************************
  Receive a UDP/138 packet either via UDP or from the unexpected packet
  queue. The packet must be a reply packet and have the specified mailslot name
  The timeout is in milliseconds.
 ***************************************************************************/
-struct packet_struct *receive_dgram_packet(int fd, int t,
-                const char *mailslot_name)
+{
-        struct packet_struct *p;
-        p = receive_packet(fd, DGRAM_PACKET, t);
-        if (p && match_mailslot_name(p, mailslot_name)) {
-                return p;
+        }
-        if (p)
-                free_packet(p);
-        /* try the unexpected packet queue */
-        return receive_unexpected(DGRAM_PACKET, 0, mailslot_name);
+}
 /****************************************************************************
 …
         putip(sort_ip, (char *)&ip);
+        /* TODO:
+           this can't use TYPESAFE_QSORT() as the types are wrong.
+           It should be fixed to use a real type instead of char*
+        */
         qsort(data, n, 6, QSORT_CAST name_query_comp);
+}

vendor/current/source3/libsmb/nterr.c

-              r414
+              r740
 /*
+/*
  *  Unix SMB/CIFS implementation.
  *  RPC Pipe client / server routines
  *  Copyright (C) Luke Kenneth Casson Leighton 1997-2001.
+ *
+ *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 3 of the License, or
  *  (at your option) any later version.
+ *
+ *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
 …
 #include "includes.h"
+#include "smb_ldap.h"
+#undef strcasecmp
+#if !defined(N_)
+#define N_(string) string
+#endif
 typedef struct
 …
+{
         { "NT_STATUS_OK", NT_STATUS_OK },
+        { "STATUS_NO_MORE_FILES", STATUS_NO_MORE_FILES },
+        { "STATUS_NO_MORE_EAS", STATUS_NO_MORE_EAS },
+        { "STATUS_INVALID_EA_NAME", STATUS_INVALID_EA_NAME },
+        { "STATUS_EA_LIST_INCONSISTENT", STATUS_EA_LIST_INCONSISTENT },
+        { "STATUS_INVALID_EA_FLAG", STATUS_INVALID_EA_FLAG },
         { "NT_STATUS_UNSUCCESSFUL", NT_STATUS_UNSUCCESSFUL },
         { "NT_STATUS_NOT_IMPLEMENTED", NT_STATUS_NOT_IMPLEMENTED },
 …
         { "NT_STATUS_DS_NO_MORE_RIDS", NT_STATUS_DS_NO_MORE_RIDS },
         { "NT_STATUS_NOT_A_REPARSE_POINT", NT_STATUS_NOT_A_REPARSE_POINT },
+        { "NT_STATUS_NO_MORE_ENTRIES", NT_STATUS_NO_MORE_ENTRIES },
+        { "NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED", NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED },
+        { "NT_STATUS_RPC_UNSUPPORTED_NAME_SYNTAX", NT_STATUS_RPC_UNSUPPORTED_NAME_SYNTAX },
+        { "NT_STATUS_RPC_UNKNOWN_IF", NT_STATUS_RPC_UNKNOWN_IF },
+        { "NT_STATUS_RPC_CALL_FAILED", NT_STATUS_RPC_CALL_FAILED },
+        { "NT_STATUS_RPC_PROTOCOL_ERROR", NT_STATUS_RPC_PROTOCOL_ERROR },
+        { "NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE", NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE },
+        { "NT_STATUS_RPC_CANNOT_SUPPORT", NT_STATUS_RPC_CANNOT_SUPPORT },
+        { "NT_STATUS_RPC_SEC_PKG_ERROR", NT_STATUS_RPC_SEC_PKG_ERROR },
+        { "NT_STATUS_RPC_SS_CONTEXT_MISMATCH", NT_STATUS_RPC_SS_CONTEXT_MISMATCH },
+        { "NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE", NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE },
+        { "NT_STATUS_RPC_BAD_STUB_DATA", NT_STATUS_RPC_BAD_STUB_DATA },
+        { "NT_STATUS_RPC_INVALID_PIPE_OBJECT", NT_STATUS_RPC_INVALID_PIPE_OBJECT },
+        { "NT_STATUS_RPC_INVALID_PIPE_OPERATION", NT_STATUS_RPC_INVALID_PIPE_OPERATION },
+        { "NT_STATUS_RPC_WRONG_PIPE_VERSION", NT_STATUS_RPC_WRONG_PIPE_VERSION },
+        { "NT_STATUS_RPC_PIPE_CLOSED", NT_STATUS_RPC_PIPE_CLOSED },
+        { "NT_STATUS_RPC_PIPE_DISCIPLINE_ERROR", NT_STATUS_RPC_PIPE_DISCIPLINE_ERROR },
+        { "NT_STATUS_RPC_PIPE_EMPTY", NT_STATUS_RPC_PIPE_EMPTY },
+        { "NT_STATUS_CURRENT_DOMAIN_NOT_ALLOWED", NT_STATUS_CURRENT_DOMAIN_NOT_ALLOWED },
+        { "NT_STATUS_OBJECTID_NOT_FOUND", NT_STATUS_OBJECTID_NOT_FOUND },
         { "NT_STATUS_DOWNGRADE_DETECTED", NT_STATUS_DOWNGRADE_DETECTED },
+        { "NT_STATUS_NO_MORE_ENTRIES", NT_STATUS_NO_MORE_ENTRIES },
+        { "NT_STATUS_NO_S4U_PROT_SUPPORT", NT_STATUS_NO_S4U_PROT_SUPPORT },
+        { "NT_STATUS_CROSSREALM_DELEGATION_FAILURE", NT_STATUS_CROSSREALM_DELEGATION_FAILURE },
+        { "NT_STATUS_INVALID_LOCK_RANGE", NT_STATUS_INVALID_LOCK_RANGE },
+        { "NT_STATUS_ERROR_DS_OBJ_STRING_NAME_EXISTS", NT_STATUS_ERROR_DS_OBJ_STRING_NAME_EXISTS },
+        { "NT_STATUS_ERROR_DS_INCOMPATIBLE_VERSION", NT_STATUS_ERROR_DS_INCOMPATIBLE_VERSION },
         { "STATUS_MORE_ENTRIES", STATUS_MORE_ENTRIES },
         { "STATUS_SOME_UNMAPPED", STATUS_SOME_UNMAPPED },
+        { "STATUS_NO_MORE_FILES", STATUS_NO_MORE_FILES },
+        { "NT_STATUS_RPC_CANNOT_SUPPORT", NT_STATUS_RPC_CANNOT_SUPPORT },
+        { "NT_STATUS_RPC_NT_CALL_FAILED", NT_STATUS_RPC_NT_CALL_FAILED },
+        { "NT_STATUS_RPC_NT_PROTOCOL_ERROR", NT_STATUS_RPC_NT_PROTOCOL_ERROR },
+        { "NT_STATUS_RPC_NT_PROCNUM_OUT_OF_RANGE", NT_STATUS_RPC_NT_PROCNUM_OUT_OF_RANGE },
+        { "NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED", NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED },
+        { "STATUS_NOTIFY_CLEANUP", STATUS_NOTIFY_CLEANUP },
+        { "STATUS_NOTIFY_ENUM_DIR", STATUS_NOTIFY_ENUM_DIR },
         { NULL, NT_STATUS(0) }
 };
 …
 /* These need sorting..... */
 nt_err_code_struct nt_err_desc[] =
+static const nt_err_code_struct nt_err_desc[] =
+{
+        { "Success",                            NT_STATUS_OK },
+        { "Undetermined error",                 NT_STATUS_UNSUCCESSFUL },
+        { "Access denied",                      NT_STATUS_ACCESS_DENIED },
+        { "Account locked out",                 NT_STATUS_ACCOUNT_LOCKED_OUT },
+        { "Must change password",               NT_STATUS_PASSWORD_MUST_CHANGE },
+        { "Password is too short",              NT_STATUS_PWD_TOO_SHORT },
+        { "Password is too recent",             NT_STATUS_PWD_TOO_RECENT },
+        { "Password history conflict",          NT_STATUS_PWD_HISTORY_CONFLICT },
+        { "No logon servers",                   NT_STATUS_NO_LOGON_SERVERS },
+        { "Improperly formed account name",     NT_STATUS_INVALID_ACCOUNT_NAME },
+        { "User exists",                        NT_STATUS_USER_EXISTS },
+        { "No such user",                       NT_STATUS_NO_SUCH_USER },
+        { "Group exists",                       NT_STATUS_GROUP_EXISTS },
+        { "No such group",                      NT_STATUS_NO_SUCH_GROUP },
+        { "Member not in group",                NT_STATUS_MEMBER_NOT_IN_GROUP },
+        { "Wrong Password",                     NT_STATUS_WRONG_PASSWORD },
+        { "Ill formed password",                NT_STATUS_ILL_FORMED_PASSWORD },
+        { "Password restriction",               NT_STATUS_PASSWORD_RESTRICTION },
+        { "Logon failure",                      NT_STATUS_LOGON_FAILURE },
+        { "Account restriction",                NT_STATUS_ACCOUNT_RESTRICTION },
+        { "Invalid logon hours",                NT_STATUS_INVALID_LOGON_HOURS },
+        { "Invalid workstation",                NT_STATUS_INVALID_WORKSTATION },
+        { "Password expired",                   NT_STATUS_PASSWORD_EXPIRED },
+        { "Account disabled",                   NT_STATUS_ACCOUNT_DISABLED },
+        { "Memory allocation error",            NT_STATUS_NO_MEMORY },
+        { "No domain controllers located",      NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND },
+        { "Named pipe not available",           NT_STATUS_PIPE_NOT_AVAILABLE },
+        { "Not implemented",                    NT_STATUS_NOT_IMPLEMENTED },
+        { "Invalid information class",          NT_STATUS_INVALID_INFO_CLASS },
+        { "Information length mismatch",        NT_STATUS_INFO_LENGTH_MISMATCH },
+        { "Access violation",                   NT_STATUS_ACCESS_VIOLATION },
+        { "Invalid handle",                     NT_STATUS_INVALID_HANDLE },
+        { "Invalid parameter",                  NT_STATUS_INVALID_PARAMETER },
+        { "No memory",                          NT_STATUS_NO_MEMORY },
+        { "Buffer too small",                   NT_STATUS_BUFFER_TOO_SMALL },
+        { "Revision mismatch",                  NT_STATUS_REVISION_MISMATCH },
+        { "No such logon session",              NT_STATUS_NO_SUCH_LOGON_SESSION },
+        { "No such privilege",                  NT_STATUS_NO_SUCH_PRIVILEGE },
+        { "Procedure not found",                NT_STATUS_PROCEDURE_NOT_FOUND },
+        { "Server disabled",                    NT_STATUS_SERVER_DISABLED },
+        { "Invalid pipe state",                 NT_STATUS_INVALID_PIPE_STATE },
+        { "Named pipe busy",                    NT_STATUS_PIPE_BUSY },
+        { "Illegal function",                   NT_STATUS_ILLEGAL_FUNCTION },
+        { "Named pipe dicconnected",            NT_STATUS_PIPE_DISCONNECTED },
+        { "Named pipe closing",                 NT_STATUS_PIPE_CLOSING },
+        { "Remote host not listening",          NT_STATUS_REMOTE_NOT_LISTENING },
+        { "Duplicate name on network",          NT_STATUS_DUPLICATE_NAME },
+        { "Print queue is full",                NT_STATUS_PRINT_QUEUE_FULL },
+        { "No print spool space available",     NT_STATUS_NO_SPOOL_SPACE },
+        { "The network name cannot be found",   NT_STATUS_BAD_NETWORK_NAME },
+        { "The connection was refused",         NT_STATUS_CONNECTION_REFUSED },
+        { "Too many names",                     NT_STATUS_TOO_MANY_NAMES },
+        { "Too many sessions",                  NT_STATUS_TOO_MANY_SESSIONS },
+        { "Invalid server state",               NT_STATUS_INVALID_SERVER_STATE },
+        { "Invalid domain state",               NT_STATUS_INVALID_DOMAIN_STATE },
+        { "Invalid domain role",                NT_STATUS_INVALID_DOMAIN_ROLE },
+        { "No such domain",                     NT_STATUS_NO_SUCH_DOMAIN },
+        { "Domain exists",                      NT_STATUS_DOMAIN_EXISTS },
+        { "Domain limit exceeded",              NT_STATUS_DOMAIN_LIMIT_EXCEEDED },
+        { "Bad logon session state",            NT_STATUS_BAD_LOGON_SESSION_STATE },
+        { "Logon session collision",            NT_STATUS_LOGON_SESSION_COLLISION },
+        { "Invalid logon type",                 NT_STATUS_INVALID_LOGON_TYPE },
+        { "Cancelled",                          NT_STATUS_CANCELLED },
+        { "Invalid computer name",              NT_STATUS_INVALID_COMPUTER_NAME },
+        { "Logon server conflict",              NT_STATUS_LOGON_SERVER_CONFLICT },
+        { "Time difference at domain controller", NT_STATUS_TIME_DIFFERENCE_AT_DC },
+        { "Pipe broken",                        NT_STATUS_PIPE_BROKEN },
+        { "Registry corrupt",                   NT_STATUS_REGISTRY_CORRUPT },
+        { "Too many secrets",                   NT_STATUS_TOO_MANY_SECRETS },
+        { "Too many SIDs",                      NT_STATUS_TOO_MANY_SIDS },
+        { "Lanmanager cross encryption required", NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED },
+        { "Log file full",                      NT_STATUS_LOG_FILE_FULL },
+        { "No trusted LSA secret",              NT_STATUS_NO_TRUST_LSA_SECRET },
+        { "No trusted SAM account",             NT_STATUS_NO_TRUST_SAM_ACCOUNT },
+        { "Trusted domain failure",             NT_STATUS_TRUSTED_DOMAIN_FAILURE },
+        { "Trust relationship failure",         NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE },
+        { "Trust failure",                      NT_STATUS_TRUST_FAILURE },
+        { "Netlogon service not started",       NT_STATUS_NETLOGON_NOT_STARTED },
+        { "Account expired",                    NT_STATUS_ACCOUNT_EXPIRED },
+        { "Network credential conflict",        NT_STATUS_NETWORK_CREDENTIAL_CONFLICT },
+        { "Remote session limit",               NT_STATUS_REMOTE_SESSION_LIMIT },
+        { "No logon interdomain trust account", NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT },
+        { "No logon workstation trust account", NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT },
+        { "No logon server trust account",      NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT },
+        { "Domain trust inconsistent",          NT_STATUS_DOMAIN_TRUST_INCONSISTENT },
+        { "No user session key available",      NT_STATUS_NO_USER_SESSION_KEY },
+        { "User session deleted",               NT_STATUS_USER_SESSION_DELETED },
+        { "Insufficient server resources",      NT_STATUS_INSUFF_SERVER_RESOURCES },
+        { "Insufficient logon information",     NT_STATUS_INSUFFICIENT_LOGON_INFO },
+        { "License quota exceeded",             NT_STATUS_LICENSE_QUOTA_EXCEEDED },
+        { "No more files",                      STATUS_NO_MORE_FILES },
+        { N_("Success"),                                NT_STATUS_OK },
+        { N_("Undetermined error"),             NT_STATUS_UNSUCCESSFUL },
+        { N_("Access denied"),                  NT_STATUS_ACCESS_DENIED },
+        { N_("Account locked out"),             NT_STATUS_ACCOUNT_LOCKED_OUT },
+        { N_("Must change password"),           NT_STATUS_PASSWORD_MUST_CHANGE },
+        { N_("Password is too short"),          NT_STATUS_PWD_TOO_SHORT },
+        { N_("Password is too recent"),                 NT_STATUS_PWD_TOO_RECENT },
+        { N_("Password history conflict"),              NT_STATUS_PWD_HISTORY_CONFLICT },
+        { N_("No logon servers"),                       NT_STATUS_NO_LOGON_SERVERS },
+        { N_("Improperly formed account name"),         NT_STATUS_INVALID_ACCOUNT_NAME },
+        { N_("User exists"),                    NT_STATUS_USER_EXISTS },
+        { N_("No such user"),                   NT_STATUS_NO_SUCH_USER },
+        { N_("Group exists"),                   NT_STATUS_GROUP_EXISTS },
+        { N_("No such group"),                  NT_STATUS_NO_SUCH_GROUP },
+        { N_("Member not in group"),            NT_STATUS_MEMBER_NOT_IN_GROUP },
+        { N_("Wrong Password"),                         NT_STATUS_WRONG_PASSWORD },
+        { N_("Ill formed password"),            NT_STATUS_ILL_FORMED_PASSWORD },
+        { N_("Password restriction"),           NT_STATUS_PASSWORD_RESTRICTION },
+        { N_("Logon failure"),                  NT_STATUS_LOGON_FAILURE },
+        { N_("Account restriction"),            NT_STATUS_ACCOUNT_RESTRICTION },
+        { N_("Invalid logon hours"),            NT_STATUS_INVALID_LOGON_HOURS },
+        { N_("Invalid workstation"),            NT_STATUS_INVALID_WORKSTATION },
+        { N_("Password expired"),                       NT_STATUS_PASSWORD_EXPIRED },
+        { N_("Account disabled"),                       NT_STATUS_ACCOUNT_DISABLED },
+        { N_("Unexpected information received"),        NT_STATUS_INVALID_PARAMETER },
+        { N_("Memory allocation error"),                NT_STATUS_NO_MEMORY },
+        { N_("No domain controllers located"),  NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND },
+        { N_("Account locked out"),             NT_STATUS_ACCOUNT_LOCKED_OUT },
+        { N_("Named pipe not available"),               NT_STATUS_PIPE_NOT_AVAILABLE },
+        { N_("Not implemented"),                        NT_STATUS_NOT_IMPLEMENTED },
+        { N_("Invalid information class"),              NT_STATUS_INVALID_INFO_CLASS },
+        { N_("Information length mismatch"),    NT_STATUS_INFO_LENGTH_MISMATCH },
+        { N_("Access violation"),                       NT_STATUS_ACCESS_VIOLATION },
+        { N_("Invalid handle"),                         NT_STATUS_INVALID_HANDLE },
+        { N_("Invalid parameter"),                      NT_STATUS_INVALID_PARAMETER },
+        { N_("No memory"),                              NT_STATUS_NO_MEMORY },
+        { N_("Buffer too small"),                       NT_STATUS_BUFFER_TOO_SMALL },
+        { N_("Revision mismatch"),                      NT_STATUS_REVISION_MISMATCH },
+        { N_("No logon servers"),                       NT_STATUS_NO_LOGON_SERVERS },
+        { N_("No such logon session"),          NT_STATUS_NO_SUCH_LOGON_SESSION },
+        { N_("No such privilege"),                      NT_STATUS_NO_SUCH_PRIVILEGE },
+        { N_("Procedure not found"),            NT_STATUS_PROCEDURE_NOT_FOUND },
+        { N_("Server disabled"),                        NT_STATUS_SERVER_DISABLED },
+        { N_("Invalid pipe state"),             NT_STATUS_INVALID_PIPE_STATE },
+        { N_("Named pipe busy"),                        NT_STATUS_PIPE_BUSY },
+        { N_("Illegal function"),                       NT_STATUS_ILLEGAL_FUNCTION },
+        { N_("Named pipe disconnected"),                NT_STATUS_PIPE_DISCONNECTED },
+        { N_("Named pipe closing"),             NT_STATUS_PIPE_CLOSING },
+        { N_("Remote host not listening"),              NT_STATUS_REMOTE_NOT_LISTENING },
+        { N_("Duplicate name on network"),              NT_STATUS_DUPLICATE_NAME },
+        { N_("Print queue is full"),            NT_STATUS_PRINT_QUEUE_FULL },
+        { N_("No print spool space available"),         NT_STATUS_NO_SPOOL_SPACE },
+        { N_("The network name cannot be found"),   NT_STATUS_BAD_NETWORK_NAME },
+        { N_("The connection was refused"),         NT_STATUS_CONNECTION_REFUSED },
+        { N_("Too many names"),                         NT_STATUS_TOO_MANY_NAMES },
+        { N_("Too many sessions"),                      NT_STATUS_TOO_MANY_SESSIONS },
+        { N_("Invalid server state"),           NT_STATUS_INVALID_SERVER_STATE },
+        { N_("Invalid domain state"),           NT_STATUS_INVALID_DOMAIN_STATE },
+        { N_("Invalid domain role"),            NT_STATUS_INVALID_DOMAIN_ROLE },
+        { N_("No such domain"),                         NT_STATUS_NO_SUCH_DOMAIN },
+        { N_("Domain exists"),                  NT_STATUS_DOMAIN_EXISTS },
+        { N_("Domain limit exceeded"),          NT_STATUS_DOMAIN_LIMIT_EXCEEDED },
+        { N_("Bad logon session state"),                NT_STATUS_BAD_LOGON_SESSION_STATE },
+        { N_("Logon session collision"),                NT_STATUS_LOGON_SESSION_COLLISION },
+        { N_("Invalid logon type"),             NT_STATUS_INVALID_LOGON_TYPE },
+        { N_("Cancelled"),                              NT_STATUS_CANCELLED },
+        { N_("Invalid computer name"),          NT_STATUS_INVALID_COMPUTER_NAME },
+        { N_("Logon server conflict"),          NT_STATUS_LOGON_SERVER_CONFLICT },
+        { N_("Time difference at domain controller"), NT_STATUS_TIME_DIFFERENCE_AT_DC },
+        { N_("Pipe broken"),                    NT_STATUS_PIPE_BROKEN },
+        { N_("Registry corrupt"),                       NT_STATUS_REGISTRY_CORRUPT },
+        { N_("Too many secrets"),                       NT_STATUS_TOO_MANY_SECRETS },
+        { N_("Too many SIDs"),                  NT_STATUS_TOO_MANY_SIDS },
+        { N_("Lanmanager cross encryption required"), NT_STATUS_LM_CROSS_ENCRYPTION_REQUIRED },
+        { N_("Log file full"),                  NT_STATUS_LOG_FILE_FULL },
+        { N_("No trusted LSA secret"),          NT_STATUS_NO_TRUST_LSA_SECRET },
+        { N_("No trusted SAM account"),                 NT_STATUS_NO_TRUST_SAM_ACCOUNT },
+        { N_("Trusted domain failure"),                 NT_STATUS_TRUSTED_DOMAIN_FAILURE },
+        { N_("Trust relationship failure"),     NT_STATUS_TRUSTED_RELATIONSHIP_FAILURE },
+        { N_("Trust failure"),                  NT_STATUS_TRUST_FAILURE },
+        { N_("Netlogon service not started"),   NT_STATUS_NETLOGON_NOT_STARTED },
+        { N_("Account expired"),                        NT_STATUS_ACCOUNT_EXPIRED },
+        { N_("Network credential conflict"),    NT_STATUS_NETWORK_CREDENTIAL_CONFLICT },
+        { N_("Remote session limit"),           NT_STATUS_REMOTE_SESSION_LIMIT },
+        { N_("No logon interdomain trust account"), NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT },
+        { N_("No logon workstation trust account"), NT_STATUS_NOLOGON_WORKSTATION_TRUST_ACCOUNT },
+        { N_("No logon server trust account"),  NT_STATUS_NOLOGON_SERVER_TRUST_ACCOUNT },
+        { N_("Domain trust inconsistent"),              NT_STATUS_DOMAIN_TRUST_INCONSISTENT },
+        { N_("No user session key available"),  NT_STATUS_NO_USER_SESSION_KEY },
+        { N_("User session deleted"),           NT_STATUS_USER_SESSION_DELETED },
+        { N_("Insufficient server resources"),  NT_STATUS_INSUFF_SERVER_RESOURCES },
+        { N_("Insufficient logon information"),         NT_STATUS_INSUFFICIENT_LOGON_INFO },
+        { N_("License quota exceeded"),                 NT_STATUS_LICENSE_QUOTA_EXCEEDED },
+        { N_("No more files"),                  STATUS_NO_MORE_FILES },
         { NULL, NT_STATUS(0) }
 …
 const char *nt_errstr(NTSTATUS nt_code)
+{
         int idx = 0;
+        int idx = 0;
         char *result;
 #ifdef HAVE_LDAP
         if (NT_STATUS_IS_LDAP(nt_code)) {
                 return ldap_err2string(NT_STATUS_LDAP_CODE(nt_code));
+        if (NT_STATUS_IS_LDAP(nt_code)) {
+                return ldap_err2string(NT_STATUS_LDAP_CODE(nt_code));
+        }
 #endif
 …
         while (nt_errs[idx].nt_errstr != NULL) {
+                if (NT_STATUS_EQUAL(nt_errs[idx].nt_errcode, nt_code)) {
+                        return nt_errs[idx].nt_errstr;
+                if (NT_STATUS_V(nt_errs[idx].nt_errcode) ==
+                    NT_STATUS_V(nt_code)) {
+                        return nt_errs[idx].nt_errstr;
+                }
                 idx++;
 …
  Print friendler version fo NT error code
  ***********************************************************************/
 const char *get_friendly_nt_error_msg(NTSTATUS nt_code)
+{
         int idx = 0;
+        int idx = 0;
         while (nt_err_desc[idx].nt_errstr != NULL) {
                 if (NT_STATUS_V(nt_err_desc[idx].nt_errcode) == NT_STATUS_V(nt_code)) {
                         return nt_err_desc[idx].nt_errstr;
+                        return nt_err_desc[idx].nt_errstr;
+                }
                 idx++;
+        }
         /* fall back to NT_STATUS_XXX string */
         return nt_errstr(nt_code);
+}
 …
+{
         char *result;
         int idx = 0;
+        int idx = 0;
         while (nt_errs[idx].nt_errstr != NULL) {
                 if (NT_STATUS_V(nt_errs[idx].nt_errcode) ==
                     NT_STATUS_V(nt_code)) {
                         return nt_errs[idx].nt_errstr;
+                if (NT_STATUS_V(nt_errs[idx].nt_errcode) ==
+                    NT_STATUS_V(nt_code)) {
+                        return nt_errs[idx].nt_errstr;
+                }
                 idx++;
 …
 NTSTATUS nt_status_string_to_code(const char *nt_status_str)
+{
         int idx = 0;
+        int idx = 0;
         while (nt_errs[idx].nt_errstr != NULL) {
                 if (strcmp(nt_errs[idx].nt_errstr, nt_status_str) == 0) {
                         return nt_errs[idx].nt_errcode;
+                if (strcasecmp(nt_errs[idx].nt_errstr, nt_status_str) == 0) {
+                        return nt_errs[idx].nt_errcode;
+                }
                 idx++;
 …
  * Squash an NT_STATUS in line with security requirements.
  * In an attempt to avoid giving the whole game away when users
  * are authenticating, NT replaces both NT_STATUS_NO_SUCH_USER and
  * NT_STATUS_WRONG_PASSWORD with NT_STATUS_LOGON_FAILURE in certain situations
+ * are authenticating, NT replaces both NT_STATUS_NO_SUCH_USER and
+ * NT_STATUS_WRONG_PASSWORD with NT_STATUS_LOGON_FAILURE in certain situations
  * (session setups in particular).
+ *
 …
+{
         if NT_STATUS_IS_OK(nt_status) {
                 return nt_status;
+                return nt_status;
         } else if NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_SUCH_USER) {
                 /* Match WinXP and don't give the game away */
                 return NT_STATUS_LOGON_FAILURE;
         } else if NT_STATUS_EQUAL(nt_status, NT_STATUS_WRONG_PASSWORD) {
                 /* Match WinXP and don't give the game away */
 …
         } else {
                 return nt_status;
+        }
+        }
+}

vendor/current/source3/libsmb/ntlmssp.c

-              r414
+              r740
    Copyright (C) Andrew Tridgell      2001
    Copyright (C) Andrew Bartlett 2001-2003
    Copyright (C) Andrew Bartlett 2005 (Updated from gensec).
+   Copyright (C) Andrew Bartlett 2001-2010
+   Copyright (C) Stefan Metzmacher 2005
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
+#include "../libcli/auth/ntlmssp.h"
+#include "../libcli/auth/ntlmssp_private.h"
 #include "../libcli/auth/libcli_auth.h"
 #include "../librpc/gen_ndr/ndr_ntlmssp.h"
+#include "libsmb/ntlmssp_ndr.h"
+#include "../libcli/auth/ntlmssp_ndr.h"
+#include "../lib/crypto/md5.h"
+#include "../lib/crypto/arcfour.h"
+#include "../lib/crypto/hmacmd5.h"
+#include "../nsswitch/libwbclient/wbclient.h"
 static NTSTATUS ntlmssp_client_initial(struct ntlmssp_state *ntlmssp_state,
+                                       TALLOC_CTX *out_mem_ctx, /* Unused at this time */
                                        DATA_BLOB reply, DATA_BLOB *next_request);
-static NTSTATUS ntlmssp_server_negotiate(struct ntlmssp_state *ntlmssp_state,
-                                         const DATA_BLOB in, DATA_BLOB *out);
 static NTSTATUS ntlmssp_client_challenge(struct ntlmssp_state *ntlmssp_state,
+                                         TALLOC_CTX *out_mem_ctx, /* Unused at this time */
                                          const DATA_BLOB reply, DATA_BLOB *next_request);
-static NTSTATUS ntlmssp_server_auth(struct ntlmssp_state *ntlmssp_state,
-                                    const DATA_BLOB request, DATA_BLOB *reply);
 /**
  * Callbacks for NTLMSSP - for both client and server operating modes
 …
 static const struct ntlmssp_callbacks {
         enum NTLMSSP_ROLE role;
         enum NTLM_MESSAGE_TYPE ntlmssp_command;
+        enum ntlmssp_role role;
+        enum ntlmssp_message_type ntlmssp_command;
         NTSTATUS (*fn)(struct ntlmssp_state *ntlmssp_state,
+                       TALLOC_CTX *out_mem_ctx,
                        DATA_BLOB in, DATA_BLOB *out);
 } ntlmssp_callbacks[] = {
 …
 /**
- * Print out the NTLMSSP flags for debugging
- * @param neg_flags The flags from the packet
- */
-void debug_ntlmssp_flags(uint32 neg_flags)
+{
-        DEBUG(3,("Got NTLMSSP neg_flags=0x%08x\n", neg_flags));
-        if (neg_flags & NTLMSSP_NEGOTIATE_UNICODE)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_UNICODE\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_OEM)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_OEM\n"));
-        if (neg_flags & NTLMSSP_REQUEST_TARGET)
-                DEBUGADD(4, ("  NTLMSSP_REQUEST_TARGET\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_SIGN)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_SIGN\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_SEAL)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_SEAL\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_DATAGRAM)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_DATAGRAM\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_LM_KEY)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_LM_KEY\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_NETWARE)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NETWARE\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_NTLM)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NTLM\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_THIS_IS_LOCAL_CALL\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_ALWAYS_SIGN\n"));
-        if (neg_flags & NTLMSSP_REQUEST_NON_NT_SESSION_KEY)
-                DEBUGADD(4, ("  NTLMSSP_REQUEST_NON_NT_SESSION_KEY\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_NTLM2)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_NTLM2\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_TARGET_INFO)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_TARGET_INFO\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_VERSION)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_VERSION\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_128)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_128\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_KEY_EXCH\n"));
-        if (neg_flags & NTLMSSP_NEGOTIATE_56)
-                DEBUGADD(4, ("  NTLMSSP_NEGOTIATE_56\n"));
+}
-/**
  * Default challenge generation code.
+ *
  */
 static void get_challenge(const struct ntlmssp_state *ntlmssp_state,
                           uint8_t chal[8])
+static NTSTATUS get_challenge(const struct ntlmssp_state *ntlmssp_state,
+                              uint8_t chal[8])
+{
         generate_random_buffer(chal, 8);
+        return NT_STATUS_OK;
+}
 …
  */
 NTSTATUS ntlmssp_set_username(NTLMSSP_STATE *ntlmssp_state, const char *user)
+NTSTATUS ntlmssp_set_username(struct ntlmssp_state *ntlmssp_state, const char *user)
+{
         ntlmssp_state->user = talloc_strdup(ntlmssp_state, user ? user : "" );
 …
+ *
  */
 NTSTATUS ntlmssp_set_hashes(NTLMSSP_STATE *ntlmssp_state,
                 const unsigned char lm_hash[16],
                 const unsigned char nt_hash[16])
+{
         ntlmssp_state->lm_hash = (unsigned char *)
+NTSTATUS ntlmssp_set_hashes(struct ntlmssp_state *ntlmssp_state,
+                            const uint8_t lm_hash[16],
+                            const uint8_t nt_hash[16])
+{
+        ntlmssp_state->lm_hash = (uint8_t *)
                 TALLOC_MEMDUP(ntlmssp_state, lm_hash, 16);
         ntlmssp_state->nt_hash = (unsigned char *)
+        ntlmssp_state->nt_hash = (uint8_t *)
                 TALLOC_MEMDUP(ntlmssp_state, nt_hash, 16);
         if (!ntlmssp_state->lm_hash || !ntlmssp_state->nt_hash) {
 …
+ *
  */
 NTSTATUS ntlmssp_set_password(NTLMSSP_STATE *ntlmssp_state, const char *password)
+NTSTATUS ntlmssp_set_password(struct ntlmssp_state *ntlmssp_state, const char *password)
+{
         if (!password) {
 …
                 ntlmssp_state->nt_hash = NULL;
         } else {
                 unsigned char lm_hash[16];
                 unsigned char nt_hash[16];
+                uint8_t lm_hash[16];
+                uint8_t nt_hash[16];
                 E_deshash(password, lm_hash);
 …
+ *
  */
 NTSTATUS ntlmssp_set_domain(NTLMSSP_STATE *ntlmssp_state, const char *domain)
+NTSTATUS ntlmssp_set_domain(struct ntlmssp_state *ntlmssp_state, const char *domain)
+{
         ntlmssp_state->domain = talloc_strdup(ntlmssp_state,
 …
 /**
- * Set a workstation on an NTLMSSP context - ensures it is talloc()ed
+ *
- */
-NTSTATUS ntlmssp_set_workstation(NTLMSSP_STATE *ntlmssp_state, const char *workstation)
+{
-        ntlmssp_state->workstation = talloc_strdup(ntlmssp_state, workstation);
-        if (!ntlmssp_state->workstation) {
-                return NT_STATUS_NO_MEMORY;
+        }
-        return NT_STATUS_OK;
+}
-/**
- *  Store a DATA_BLOB containing an NTLMSSP response, for use later.
- *  This copies the data blob
- */
-NTSTATUS ntlmssp_store_response(NTLMSSP_STATE *ntlmssp_state,
-                                DATA_BLOB response)
+{
-        ntlmssp_state->stored_response = data_blob_talloc(ntlmssp_state,
-                                                          response.data,
-                                                          response.length);
-        return NT_STATUS_OK;
+}
-/**
  * Request features for the NTLMSSP negotiation
+ *
 …
  * @param feature_list List of space seperated features requested from NTLMSSP.
  */
 void ntlmssp_want_feature_list(NTLMSSP_STATE *ntlmssp_state, char *feature_list)
+void ntlmssp_want_feature_list(struct ntlmssp_state *ntlmssp_state, char *feature_list)
+{
         /*
 …
  * @param feature Bit flag specifying the requested feature
  */
 void ntlmssp_want_feature(NTLMSSP_STATE *ntlmssp_state, uint32 feature)
+void ntlmssp_want_feature(struct ntlmssp_state *ntlmssp_state, uint32_t feature)
+{
         /* As per JRA's comment above */
 …
  */
+NTSTATUS ntlmssp_update(NTLMSSP_STATE *ntlmssp_state,
+                        const DATA_BLOB in, DATA_BLOB *out)
+{
+        DATA_BLOB input;
+        uint32 ntlmssp_command;
+NTSTATUS ntlmssp_update(struct ntlmssp_state *ntlmssp_state,
+                        const DATA_BLOB input, DATA_BLOB *out)
+{
+        uint32_t ntlmssp_command;
         int i;
 …
         *out = data_blob_null;
-        if (!in.length && ntlmssp_state->stored_response.length) {
-                input = ntlmssp_state->stored_response;
-                /* we only want to read the stored response once - overwrite it */
-                ntlmssp_state->stored_response = data_blob_null;
-        } else {
-                input = in;
+        }
         if (!input.length) {
 …
                         ntlmssp_command = NTLMSSP_NEGOTIATE;
                         break;
+                default:
+                        DEBUG(1, ("Invalid role: %d\n", ntlmssp_state->role));
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
         } else {
 …
                 if (ntlmssp_callbacks[i].role == ntlmssp_state->role
                     && ntlmssp_callbacks[i].ntlmssp_command == ntlmssp_command) {
                         return ntlmssp_callbacks[i].fn(ntlmssp_state, input, out);
+                        return ntlmssp_callbacks[i].fn(ntlmssp_state, ntlmssp_state, input, out);
+                }
+        }
 …
 /**
- * End an NTLMSSP state machine
+ *
- * @param ntlmssp_state NTLMSSP State, free()ed by this function
- */
-void ntlmssp_end(NTLMSSP_STATE **ntlmssp_state)
+{
-        (*ntlmssp_state)->ref_count--;
-        if ((*ntlmssp_state)->ref_count == 0) {
-                data_blob_free(&(*ntlmssp_state)->chal);
-                data_blob_free(&(*ntlmssp_state)->lm_resp);
-                data_blob_free(&(*ntlmssp_state)->nt_resp);
-                TALLOC_FREE(*ntlmssp_state);
+        }
-        *ntlmssp_state = NULL;
-        return;
+}
-/**
- * Determine correct target name flags for reply, given server role
- * and negotiated flags
+ *
- * @param ntlmssp_state NTLMSSP State
- * @param neg_flags The flags from the packet
- * @param chal_flags The flags to be set in the reply packet
- * @return The 'target name' string.
- */
-static const char *ntlmssp_target_name(struct ntlmssp_state *ntlmssp_state,
-                                       uint32 neg_flags, uint32 *chal_flags)
+{
-        if (neg_flags & NTLMSSP_REQUEST_TARGET) {
-                *chal_flags |= NTLMSSP_NEGOTIATE_TARGET_INFO;
-                *chal_flags |= NTLMSSP_REQUEST_TARGET;
-                if (ntlmssp_state->server_role == ROLE_STANDALONE) {
-                        *chal_flags |= NTLMSSP_TARGET_TYPE_SERVER;
-                        return ntlmssp_state->get_global_myname();
-                } else {
-                        *chal_flags |= NTLMSSP_TARGET_TYPE_DOMAIN;
-                        return ntlmssp_state->get_domain();
-                };
-        } else {
-                return "";
+        }
+}
-static void ntlmssp_handle_neg_flags(struct ntlmssp_state *ntlmssp_state,
-                                      uint32 neg_flags, bool allow_lm) {
-        if (neg_flags & NTLMSSP_NEGOTIATE_UNICODE) {
-                ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_UNICODE;
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_OEM;
-                ntlmssp_state->unicode = True;
-        } else {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_UNICODE;
-                ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_OEM;
-                ntlmssp_state->unicode = False;
+        }
-        if ((neg_flags & NTLMSSP_NEGOTIATE_LM_KEY) && allow_lm) {
-                /* other end forcing us to use LM */
-                ntlmssp_state->neg_flags |= NTLMSSP_NEGOTIATE_LM_KEY;
-                ntlmssp_state->use_ntlmv2 = False;
-        } else {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_ALWAYS_SIGN)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_ALWAYS_SIGN;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_NTLM2)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_NTLM2;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_128)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_128;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_56)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_56;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_KEY_EXCH;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_SIGN)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_SIGN;
+        }
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_SEAL)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_SEAL;
+        }
-        /* Woop Woop - unknown flag for Windows compatibility...
-           What does this really do ? JRA. */
-        if (!(neg_flags & NTLMSSP_NEGOTIATE_VERSION)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_VERSION;
+        }
-        if ((neg_flags & NTLMSSP_REQUEST_TARGET)) {
-                ntlmssp_state->neg_flags |= NTLMSSP_REQUEST_TARGET;
+        }
+}
-/**
- Weaken NTLMSSP keys to cope with down-level clients and servers.
- We probably should have some parameters to control this, but as
- it only occours for LM_KEY connections, and this is controlled
- by the client lanman auth/lanman auth parameters, it isn't too bad.
-*/
-DATA_BLOB ntlmssp_weaken_keys(NTLMSSP_STATE *ntlmssp_state, TALLOC_CTX *mem_ctx)
+{
-        DATA_BLOB weakened_key = data_blob_talloc(mem_ctx,
-                                        ntlmssp_state->session_key.data,
-                                        ntlmssp_state->session_key.length);
-        /* Nothing to weaken.  We certainly don't want to 'extend' the length... */
-        if (weakened_key.length < 16) {
-                /* perhaps there was no key? */
-                return weakened_key;
+        }
-        /* Key weakening not performed on the master key for NTLM2
-           and does not occour for NTLM1.  Therefore we only need
-           to do this for the LM_KEY.
-        */
-        if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY) {
-                /* LM key doesn't support 128 bit crypto, so this is
-                 * the best we can do.  If you negotiate 128 bit, but
-                 * not 56, you end up with 40 bit... */
-                if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_56) {
-                        weakened_key.data[7] = 0xa0;
-                } else { /* forty bits */
-                        weakened_key.data[5] = 0xe5;
-                        weakened_key.data[6] = 0x38;
-                        weakened_key.data[7] = 0xb0;
+                }
-                weakened_key.length = 8;
+        }
-        return weakened_key;
+}
-/**
- * Next state function for the Negotiate packet
+ *
- * @param ntlmssp_state NTLMSSP State
- * @param request The request, as a DATA_BLOB
- * @param request The reply, as an allocated DATA_BLOB, caller to free.
- * @return Errors or MORE_PROCESSING_REQUIRED if a reply is sent.
- */
-static NTSTATUS ntlmssp_server_negotiate(struct ntlmssp_state *ntlmssp_state,
-                                         const DATA_BLOB request, DATA_BLOB *reply)
+{
-        DATA_BLOB struct_blob;
-        const char *dnsname;
-        char *dnsdomname = NULL;
-        uint32 neg_flags = 0;
-        uint32 ntlmssp_command, chal_flags;
-        uint8_t cryptkey[8];
-        const char *target_name;
-        struct NEGOTIATE_MESSAGE negotiate;
-        struct CHALLENGE_MESSAGE challenge;
-        /* parse the NTLMSSP packet */
-#if 0
-        file_save("ntlmssp_negotiate.dat", request.data, request.length);
-#endif
-        if (request.length) {
-                if ((request.length < 16) || !msrpc_parse(ntlmssp_state, &request, "Cdd",
-                                                          "NTLMSSP",
-                                                          &ntlmssp_command,
-                                                          &neg_flags)) {
-                        DEBUG(1, ("ntlmssp_server_negotiate: failed to parse NTLMSSP Negotiate of length %u\n",
-                                (unsigned int)request.length));
-                        dump_data(2, request.data, request.length);
-                        return NT_STATUS_INVALID_PARAMETER;
+                }
-                debug_ntlmssp_flags(neg_flags);
-                if (DEBUGLEVEL >= 10) {
-                        if (NT_STATUS_IS_OK(ntlmssp_pull_NEGOTIATE_MESSAGE(&request,
-                                                       ntlmssp_state,
-                                                       NULL,
-                                                       &negotiate)))
+                        {
-                                NDR_PRINT_DEBUG(NEGOTIATE_MESSAGE, &negotiate);
+                        }
+                }
+        }
-        ntlmssp_handle_neg_flags(ntlmssp_state, neg_flags, lp_lanman_auth());
-        /* Ask our caller what challenge they would like in the packet */
-        ntlmssp_state->get_challenge(ntlmssp_state, cryptkey);
-        /* Check if we may set the challenge */
-        if (!ntlmssp_state->may_set_challenge(ntlmssp_state)) {
-                ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_NTLM2;
+        }
-        /* The flags we send back are not just the negotiated flags,
-         * they are also 'what is in this packet'.  Therfore, we
-         * operate on 'chal_flags' from here on
-         */
-        chal_flags = ntlmssp_state->neg_flags;
-        /* get the right name to fill in as 'target' */
-        target_name = ntlmssp_target_name(ntlmssp_state,
-                                          neg_flags, &chal_flags);
-        if (target_name == NULL)
-                return NT_STATUS_INVALID_PARAMETER;
-        ntlmssp_state->chal = data_blob_talloc(ntlmssp_state, cryptkey, 8);
-        ntlmssp_state->internal_chal = data_blob_talloc(ntlmssp_state,
-                                                        cryptkey, 8);
-        /* This should be a 'netbios domain -> DNS domain' mapping */
-        dnsdomname = get_mydnsdomname(ntlmssp_state);
-        if (!dnsdomname) {
-                dnsdomname = talloc_strdup(ntlmssp_state, "");
+        }
-        if (!dnsdomname) {
-                return NT_STATUS_NO_MEMORY;
+        }
-        strlower_m(dnsdomname);
-        dnsname = get_mydnsfullname();
-        if (!dnsname) {
-                dnsname = "";
+        }
-        /* This creates the 'blob' of names that appears at the end of the packet */
-        if (chal_flags & NTLMSSP_NEGOTIATE_TARGET_INFO)
+        {
-                msrpc_gen(ntlmssp_state, &struct_blob, "aaaaa",
-                          MsvAvNbDomainName, target_name,
-                          MsvAvNbComputerName, ntlmssp_state->get_global_myname(),
-                          MsvAvDnsDomainName, dnsdomname,
-                          MsvAvDnsComputerName, dnsname,
-                          MsvAvEOL, "");
-        } else {
-                struct_blob = data_blob_null;
+        }
+        {
-                /* Marshel the packet in the right format, be it unicode or ASCII */
-                const char *gen_string;
-                if (ntlmssp_state->unicode) {
-                        gen_string = "CdUdbddB";
-                } else {
-                        gen_string = "CdAdbddB";
+                }
-                msrpc_gen(ntlmssp_state, reply, gen_string,
-                          "NTLMSSP",
-                          NTLMSSP_CHALLENGE,
-                          target_name,
-                          chal_flags,
-                          cryptkey, 8,
-, 0,
-                          struct_blob.data, struct_blob.length);
-                if (DEBUGLEVEL >= 10) {
-                        if (NT_STATUS_IS_OK(ntlmssp_pull_CHALLENGE_MESSAGE(reply,
-                                                       ntlmssp_state,
-                                                       NULL,
-                                                       &challenge)))
+                        {
-                                NDR_PRINT_DEBUG(CHALLENGE_MESSAGE, &challenge);
+                        }
+                }
+        }
-        data_blob_free(&struct_blob);
-        ntlmssp_state->expected_state = NTLMSSP_AUTH;
-        return NT_STATUS_MORE_PROCESSING_REQUIRED;
+}
-/**
- * Next state function for the Authenticate packet
+ *
- * @param ntlmssp_state NTLMSSP State
- * @param request The request, as a DATA_BLOB
- * @param request The reply, as an allocated DATA_BLOB, caller to free.
- * @return Errors or NT_STATUS_OK.
- */
-static NTSTATUS ntlmssp_server_auth(struct ntlmssp_state *ntlmssp_state,
-                                    const DATA_BLOB request, DATA_BLOB *reply)
+{
-        DATA_BLOB encrypted_session_key = data_blob_null;
-        DATA_BLOB user_session_key = data_blob_null;
-        DATA_BLOB lm_session_key = data_blob_null;
-        DATA_BLOB session_key = data_blob_null;
-        uint32 ntlmssp_command, auth_flags;
-        NTSTATUS nt_status = NT_STATUS_OK;
-        struct AUTHENTICATE_MESSAGE authenticate;
-        /* used by NTLM2 */
-        bool doing_ntlm2 = False;
-        uchar session_nonce[16];
-        uchar session_nonce_hash[16];
-        const char *parse_string;
-        /* parse the NTLMSSP packet */
-        *reply = data_blob_null;
-#if 0
-        file_save("ntlmssp_auth.dat", request.data, request.length);
-#endif
-        if (ntlmssp_state->unicode) {
-                parse_string = "CdBBUUUBd";
-        } else {
-                parse_string = "CdBBAAABd";
+        }
-        data_blob_free(&ntlmssp_state->lm_resp);
-        data_blob_free(&ntlmssp_state->nt_resp);
-        ntlmssp_state->user = NULL;
-        ntlmssp_state->domain = NULL;
-        ntlmssp_state->workstation = NULL;
-        /* now the NTLMSSP encoded auth hashes */
-        if (!msrpc_parse(ntlmssp_state, &request, parse_string,
-                         "NTLMSSP",
-                         &ntlmssp_command,
-                         &ntlmssp_state->lm_resp,
-                         &ntlmssp_state->nt_resp,
-                         &ntlmssp_state->domain,
-                         &ntlmssp_state->user,
-                         &ntlmssp_state->workstation,
-                         &encrypted_session_key,
-                         &auth_flags)) {
-                auth_flags = 0;
-                /* Try again with a shorter string (Win9X truncates this packet) */
-                if (ntlmssp_state->unicode) {
-                        parse_string = "CdBBUUU";
-                } else {
-                        parse_string = "CdBBAAA";
+                }
-                /* now the NTLMSSP encoded auth hashes */
-                if (!msrpc_parse(ntlmssp_state, &request, parse_string,
-                                 "NTLMSSP",
-                                 &ntlmssp_command,
-                                 &ntlmssp_state->lm_resp,
-                                 &ntlmssp_state->nt_resp,
-                                 &ntlmssp_state->domain,
-                                 &ntlmssp_state->user,
-                                 &ntlmssp_state->workstation)) {
-                        DEBUG(1, ("ntlmssp_server_auth: failed to parse NTLMSSP (tried both formats):\n"));
-                        dump_data(2, request.data, request.length);
-                        return NT_STATUS_INVALID_PARAMETER;
+                }
+        }
-        if (auth_flags)
-                ntlmssp_handle_neg_flags(ntlmssp_state, auth_flags, lp_lanman_auth());
-        if (DEBUGLEVEL >= 10) {
-                if (NT_STATUS_IS_OK(ntlmssp_pull_AUTHENTICATE_MESSAGE(&request,
-                                                  ntlmssp_state,
-                                                  NULL,
-                                                  &authenticate)))
+                {
-                        NDR_PRINT_DEBUG(AUTHENTICATE_MESSAGE, &authenticate);
+                }
+        }
-        DEBUG(3,("Got user=[%s] domain=[%s] workstation=[%s] len1=%lu len2=%lu\n",
-                 ntlmssp_state->user, ntlmssp_state->domain, ntlmssp_state->workstation, (unsigned long)ntlmssp_state->lm_resp.length, (unsigned long)ntlmssp_state->nt_resp.length));
-#if 0
-        file_save("nthash1.dat",  &ntlmssp_state->nt_resp.data,  &ntlmssp_state->nt_resp.length);
-        file_save("lmhash1.dat",  &ntlmssp_state->lm_resp.data,  &ntlmssp_state->lm_resp.length);
-#endif
-        /* NTLM2 uses a 'challenge' that is made of up both the server challenge, and a
-           client challenge
-           However, the NTLM2 flag may still be set for the real NTLMv2 logins, be careful.
-        */
-        if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
-                if (ntlmssp_state->nt_resp.length == 24 && ntlmssp_state->lm_resp.length == 24) {
-                        struct MD5Context md5_session_nonce_ctx;
-                        SMB_ASSERT(ntlmssp_state->internal_chal.data && ntlmssp_state->internal_chal.length == 8);
-                        doing_ntlm2 = True;
-                        memcpy(session_nonce, ntlmssp_state->internal_chal.data, 8);
-                        memcpy(&session_nonce[8], ntlmssp_state->lm_resp.data, 8);
-                        MD5Init(&md5_session_nonce_ctx);
-                        MD5Update(&md5_session_nonce_ctx, session_nonce, 16);
-                        MD5Final(session_nonce_hash, &md5_session_nonce_ctx);
-                        ntlmssp_state->chal = data_blob_talloc(
-                                ntlmssp_state, session_nonce_hash, 8);
-                        /* LM response is no longer useful */
-                        data_blob_free(&ntlmssp_state->lm_resp);
-                        /* We changed the effective challenge - set it */
-                        if (!NT_STATUS_IS_OK(nt_status = ntlmssp_state->set_challenge(ntlmssp_state, &ntlmssp_state->chal))) {
-                                data_blob_free(&encrypted_session_key);
-                                return nt_status;
+                        }
-                        /* LM Key is incompatible. */
-                        ntlmssp_state->neg_flags &= ~NTLMSSP_NEGOTIATE_LM_KEY;
+                }
+        }
-        /*
-         * Note we don't check here for NTLMv2 auth settings. If NTLMv2 auth
-         * is required (by "ntlm auth = no" and "lm auth = no" being set in the
-         * smb.conf file) and no NTLMv2 response was sent then the password check
-         * will fail here. JRA.
-         */
-        /* Finally, actually ask if the password is OK */
-        if (!NT_STATUS_IS_OK(nt_status = ntlmssp_state->check_password(ntlmssp_state,
-                                                                       &user_session_key, &lm_session_key))) {
-                data_blob_free(&encrypted_session_key);
-                return nt_status;
+        }
-        dump_data_pw("NT session key:\n", user_session_key.data, user_session_key.length);
-        dump_data_pw("LM first-8:\n", lm_session_key.data, lm_session_key.length);
-        /* Handle the different session key derivation for NTLM2 */
-        if (doing_ntlm2) {
-                if (user_session_key.data && user_session_key.length == 16) {
-                        session_key = data_blob_talloc(ntlmssp_state,
-                                                       NULL, 16);
-                        hmac_md5(user_session_key.data, session_nonce,
-                                 sizeof(session_nonce), session_key.data);
-                        DEBUG(10,("ntlmssp_server_auth: Created NTLM2 session key.\n"));
-                        dump_data_pw("NTLM2 session key:\n", session_key.data, session_key.length);
-                } else {
-                        DEBUG(10,("ntlmssp_server_auth: Failed to create NTLM2 session key.\n"));
-                        session_key = data_blob_null;
+                }
-        } else if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_LM_KEY) {
-                if (lm_session_key.data && lm_session_key.length >= 8) {
-                        if (ntlmssp_state->lm_resp.data && ntlmssp_state->lm_resp.length == 24) {
-                                session_key = data_blob_talloc(ntlmssp_state,
-                                                               NULL, 16);
-                                if (session_key.data == NULL) {
-                                        return NT_STATUS_NO_MEMORY;
+                                }
-                                SMBsesskeygen_lm_sess_key(lm_session_key.data, ntlmssp_state->lm_resp.data,
-                                                          session_key.data);
-                                DEBUG(10,("ntlmssp_server_auth: Created NTLM session key.\n"));
-                        } else {
-                                uint8 zeros[24];
-                                ZERO_STRUCT(zeros);
-                                session_key = data_blob_talloc(
-                                        ntlmssp_state, NULL, 16);
-                                if (session_key.data == NULL) {
-                                        return NT_STATUS_NO_MEMORY;
+                                }
-                                SMBsesskeygen_lm_sess_key(
-                                        lm_session_key.data, zeros,
-                                        session_key.data);
+                        }
-                        dump_data_pw("LM session key:\n", session_key.data,
-                                     session_key.length);
-                } else {
-                        DEBUG(10,("ntlmssp_server_auth: Failed to create NTLM session key.\n"));
-                        session_key = data_blob_null;
+                }
-        } else if (user_session_key.data) {
-                session_key = user_session_key;
-                DEBUG(10,("ntlmssp_server_auth: Using unmodified nt session key.\n"));
-                dump_data_pw("unmodified session key:\n", session_key.data, session_key.length);
-        } else if (lm_session_key.data) {
-                session_key = lm_session_key;
-                DEBUG(10,("ntlmssp_server_auth: Using unmodified lm session key.\n"));
-                dump_data_pw("unmodified session key:\n", session_key.data, session_key.length);
-        } else {
-                DEBUG(10,("ntlmssp_server_auth: Failed to create unmodified session key.\n"));
-                session_key = data_blob_null;
+        }
-        /* With KEY_EXCH, the client supplies the proposed session key,
-           but encrypts it with the long-term key */
-        if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
-                if (!encrypted_session_key.data || encrypted_session_key.length != 16) {
-                        data_blob_free(&encrypted_session_key);
-                        DEBUG(1, ("Client-supplied KEY_EXCH session key was of invalid length (%u)!\n",
-                                  (unsigned int)encrypted_session_key.length));
-                        return NT_STATUS_INVALID_PARAMETER;
-                } else if (!session_key.data || session_key.length != 16) {
-                        DEBUG(5, ("server session key is invalid (len == %u), cannot do KEY_EXCH!\n",
-                                  (unsigned int)session_key.length));
-                        ntlmssp_state->session_key = session_key;
-                } else {
-                        dump_data_pw("KEY_EXCH session key (enc):\n", encrypted_session_key.data, encrypted_session_key.length);
-                        arcfour_crypt_blob(encrypted_session_key.data,
-                                           encrypted_session_key.length,
-                                           &session_key);
-                        ntlmssp_state->session_key = data_blob_talloc(
-                                ntlmssp_state, encrypted_session_key.data,
-                                encrypted_session_key.length);
-                        dump_data_pw("KEY_EXCH session key:\n", encrypted_session_key.data,
-                                     encrypted_session_key.length);
+                }
-        } else {
-                ntlmssp_state->session_key = session_key;
+        }
-        if (!NT_STATUS_IS_OK(nt_status)) {
-                ntlmssp_state->session_key = data_blob_null;
-        } else if (ntlmssp_state->session_key.length) {
-                nt_status = ntlmssp_sign_init(ntlmssp_state);
+        }
-        data_blob_free(&encrypted_session_key);
-        /* Only one authentication allowed per server state. */
-        ntlmssp_state->expected_state = NTLMSSP_DONE;
-        return nt_status;
+}
-/**
  * Create an NTLMSSP state machine
+ *
 …
  */
+NTSTATUS ntlmssp_server_start(NTLMSSP_STATE **ntlmssp_state)
+{
+        *ntlmssp_state = TALLOC_ZERO_P(NULL, NTLMSSP_STATE);
+        if (!*ntlmssp_state) {
+                DEBUG(0,("ntlmssp_server_start: talloc failed!\n"));
+                talloc_destroy(*ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        (*ntlmssp_state)->role = NTLMSSP_SERVER;
+        (*ntlmssp_state)->get_challenge = get_challenge;
+        (*ntlmssp_state)->set_challenge = set_challenge;
+        (*ntlmssp_state)->may_set_challenge = may_set_challenge;
+        (*ntlmssp_state)->get_global_myname = global_myname;
+        (*ntlmssp_state)->get_domain = lp_workgroup;
+        (*ntlmssp_state)->server_role = ROLE_DOMAIN_MEMBER; /* a good default */
+        (*ntlmssp_state)->expected_state = NTLMSSP_NEGOTIATE;
+        (*ntlmssp_state)->ref_count = 1;
+        (*ntlmssp_state)->neg_flags =
+NTSTATUS ntlmssp_server_start(TALLOC_CTX *mem_ctx,
+                              bool is_standalone,
+                              const char *netbios_name,
+                              const char *netbios_domain,
+                              const char *dns_name,
+                              const char *dns_domain,
+                              struct ntlmssp_state **_ntlmssp_state)
+{
+        struct ntlmssp_state *ntlmssp_state;
+        if (!netbios_name) {
+                netbios_name = "";
+        }
+        if (!netbios_domain) {
+                netbios_domain = "";
+        }
+        if (!dns_domain) {
+                dns_domain = "";
+        }
+        if (!dns_name) {
+                dns_name = "";
+        }
+        ntlmssp_state = talloc_zero(mem_ctx, struct ntlmssp_state);
+        if (!ntlmssp_state) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        ntlmssp_state->role = NTLMSSP_SERVER;
+        ntlmssp_state->get_challenge = get_challenge;
+        ntlmssp_state->set_challenge = set_challenge;
+        ntlmssp_state->may_set_challenge = may_set_challenge;
+        ntlmssp_state->server.is_standalone = is_standalone;
+        ntlmssp_state->expected_state = NTLMSSP_NEGOTIATE;
+        ntlmssp_state->allow_lm_key = lp_lanman_auth();
+        ntlmssp_state->neg_flags =
                 NTLMSSP_NEGOTIATE_128 |
                 NTLMSSP_NEGOTIATE_56 |
 …
                 NTLMSSP_NEGOTIATE_SEAL;
+        ntlmssp_state->server.netbios_name = talloc_strdup(ntlmssp_state, netbios_name);
+        if (!ntlmssp_state->server.netbios_name) {
+                talloc_free(ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ntlmssp_state->server.netbios_domain = talloc_strdup(ntlmssp_state, netbios_domain);
+        if (!ntlmssp_state->server.netbios_domain) {
+                talloc_free(ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ntlmssp_state->server.dns_name = talloc_strdup(ntlmssp_state, dns_name);
+        if (!ntlmssp_state->server.dns_name) {
+                talloc_free(ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ntlmssp_state->server.dns_domain = talloc_strdup(ntlmssp_state, dns_domain);
+        if (!ntlmssp_state->server.dns_domain) {
+                talloc_free(ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        *_ntlmssp_state = ntlmssp_state;
         return NT_STATUS_OK;
+}
 …
 static NTSTATUS ntlmssp_client_initial(struct ntlmssp_state *ntlmssp_state,
+                                  TALLOC_CTX *out_mem_ctx, /* Unused at this time */
                                   DATA_BLOB reply, DATA_BLOB *next_request)
+{
         struct NEGOTIATE_MESSAGE negotiate;
+        NTSTATUS status;
         if (ntlmssp_state->unicode) {
 …
         /* generate the ntlmssp negotiate packet */
         msrpc_gen(ntlmssp_state, next_request, "CddAA",
+        status = msrpc_gen(ntlmssp_state, next_request, "CddAA",
                   "NTLMSSP",
                   NTLMSSP_NEGOTIATE,
                   ntlmssp_state->neg_flags,
+                  ntlmssp_state->get_domain(),
+                  ntlmssp_state->get_global_myname());
+                  ntlmssp_state->client.netbios_domain,
+                  ntlmssp_state->client.netbios_name);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("ntlmssp_client_initial: failed to generate "
+                        "ntlmssp negotiate packet\n"));
+                return status;
+        }
         if (DEBUGLEVEL >= 10) {
+                if (NT_STATUS_IS_OK(ntlmssp_pull_NEGOTIATE_MESSAGE(next_request,
+                                               ntlmssp_state,
+                                               NULL,
+                                               &negotiate)))
+                {
+                        NDR_PRINT_DEBUG(NEGOTIATE_MESSAGE, &negotiate);
+                struct NEGOTIATE_MESSAGE *negotiate = talloc(
+                        talloc_tos(), struct NEGOTIATE_MESSAGE);
+                if (negotiate != NULL) {
+                        status = ntlmssp_pull_NEGOTIATE_MESSAGE(
+                                next_request, negotiate, negotiate);
+                        if (NT_STATUS_IS_OK(status)) {
+                                NDR_PRINT_DEBUG(NEGOTIATE_MESSAGE,
+                                                negotiate);
+                        }
+                        TALLOC_FREE(negotiate);
+                }
+        }
 …
 static NTSTATUS ntlmssp_client_challenge(struct ntlmssp_state *ntlmssp_state,
+                                         TALLOC_CTX *out_mem_ctx, /* Unused at this time */
                                          const DATA_BLOB reply, DATA_BLOB *next_request)
+{
         uint32 chal_flags, ntlmssp_command, unkn1, unkn2;
+        uint32_t chal_flags, ntlmssp_command, unkn1, unkn2;
         DATA_BLOB server_domain_blob;
         DATA_BLOB challenge_blob;
 …
         DATA_BLOB encrypted_session_key = data_blob_null;
         NTSTATUS nt_status = NT_STATUS_OK;
-        struct CHALLENGE_MESSAGE challenge;
-        struct AUTHENTICATE_MESSAGE authenticate;
         if (ntlmssp_state->use_ccache) {
 …
                 wbc_status = wbcCredentialCache(&params, &info, &error);
+                if (error != NULL) {
+                        wbcFreeMemory(error);
+                }
+                wbcFreeMemory(error);
                 if (!WBC_ERROR_IS_OK(wbc_status)) {
                         goto noccache;
 …
         if (DEBUGLEVEL >= 10) {
+                if (NT_STATUS_IS_OK(ntlmssp_pull_CHALLENGE_MESSAGE(&reply,
+                                               ntlmssp_state,
+                                               NULL,
+                                               &challenge)))
+                {
+                        NDR_PRINT_DEBUG(CHALLENGE_MESSAGE, &challenge);
+                struct CHALLENGE_MESSAGE *challenge = talloc(
+                        talloc_tos(), struct CHALLENGE_MESSAGE);
+                if (challenge != NULL) {
+                        NTSTATUS status;
+                        challenge->NegotiateFlags = chal_flags;
+                        status = ntlmssp_pull_CHALLENGE_MESSAGE(
+                                &reply, challenge, challenge);
+                        if (NT_STATUS_IS_OK(status)) {
+                                NDR_PRINT_DEBUG(CHALLENGE_MESSAGE,
+                                                challenge);
+                        }
+                        TALLOC_FREE(challenge);
+                }
+        }
 …
+        }
+        ntlmssp_state->server_domain = server_domain;
+        if (chal_flags & NTLMSSP_TARGET_TYPE_SERVER) {
+                ntlmssp_state->server.is_standalone = true;
+        } else {
+                ntlmssp_state->server.is_standalone = false;
+        }
+        /* TODO: parse struct_blob and fill in the rest */
+        ntlmssp_state->server.netbios_name = "";
+        ntlmssp_state->server.netbios_domain = server_domain;
+        ntlmssp_state->server.dns_name = "";
+        ntlmssp_state->server.dns_domain = "";
         if (challenge_blob.length != 8) {
 …
         if (!ntlmssp_state->nt_hash || !ntlmssp_state->lm_hash) {
                 uchar zeros[16];
+                static const uint8_t zeros[16] = {0, };
                 /* do nothing - blobs are zero length */
-                ZERO_STRUCT(zeros);
                 /* session key is all zeros */
 …
         } else if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_NTLM2) {
                 struct MD5Context md5_session_nonce_ctx;
                 uchar session_nonce[16];
                 uchar session_nonce_hash[16];
                 uchar user_session_key[16];
+                uint8_t session_nonce[16];
+                uint8_t session_nonce_hash[16];
+                uint8_t user_session_key[16];
                 lm_response = data_blob_talloc(ntlmssp_state, NULL, 24);
 …
         if (ntlmssp_state->neg_flags & NTLMSSP_NEGOTIATE_KEY_EXCH) {
                 /* Make up a new session key */
                 uint8 client_session_key[16];
+                uint8_t client_session_key[16];
                 generate_random_buffer(client_session_key, sizeof(client_session_key));
 …
         /* this generates the actual auth packet */
         if (!msrpc_gen(ntlmssp_state, next_request, auth_gen_string,
+        nt_status = msrpc_gen(ntlmssp_state, next_request, auth_gen_string,
                        "NTLMSSP",
                        NTLMSSP_AUTH,
 …
                        ntlmssp_state->domain,
                        ntlmssp_state->user,
                        ntlmssp_state->get_global_myname(),
+                       ntlmssp_state->client.netbios_name,
                        encrypted_session_key.data, encrypted_session_key.length,
+                       ntlmssp_state->neg_flags)) {
+                       ntlmssp_state->neg_flags);
+        if (!NT_STATUS_IS_OK(nt_status)) {
                 return NT_STATUS_NO_MEMORY;
+        }
         if (DEBUGLEVEL >= 10) {
+                if (NT_STATUS_IS_OK(ntlmssp_pull_AUTHENTICATE_MESSAGE(next_request,
+                                                  ntlmssp_state,
+                                                  NULL,
+                                                  &authenticate)))
+                {
+                        NDR_PRINT_DEBUG(AUTHENTICATE_MESSAGE, &authenticate);
+                struct AUTHENTICATE_MESSAGE *authenticate = talloc(
+                        talloc_tos(), struct AUTHENTICATE_MESSAGE);
+                if (authenticate != NULL) {
+                        NTSTATUS status;
+                        authenticate->NegotiateFlags =
+                                ntlmssp_state->neg_flags;
+                        status = ntlmssp_pull_AUTHENTICATE_MESSAGE(
+                                next_request, authenticate, authenticate);
+                        if (NT_STATUS_IS_OK(status)) {
+                                NDR_PRINT_DEBUG(AUTHENTICATE_MESSAGE,
+                                                authenticate);
+                        }
+                        TALLOC_FREE(authenticate);
+                }
+        }
 …
+}
+NTSTATUS ntlmssp_client_start(NTLMSSP_STATE **ntlmssp_state)
+{
+        *ntlmssp_state = TALLOC_ZERO_P(NULL, NTLMSSP_STATE);
+        if (!*ntlmssp_state) {
+                DEBUG(0,("ntlmssp_client_start: talloc failed!\n"));
+                talloc_destroy(*ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        (*ntlmssp_state)->role = NTLMSSP_CLIENT;
+        (*ntlmssp_state)->get_global_myname = global_myname;
+        (*ntlmssp_state)->get_domain = lp_workgroup;
+        (*ntlmssp_state)->unicode = True;
+        (*ntlmssp_state)->use_ntlmv2 = lp_client_ntlmv2_auth();
+        (*ntlmssp_state)->expected_state = NTLMSSP_INITIAL;
+        (*ntlmssp_state)->ref_count = 1;
+        (*ntlmssp_state)->neg_flags =
+NTSTATUS ntlmssp_client_start(TALLOC_CTX *mem_ctx,
+                              const char *netbios_name,
+                              const char *netbios_domain,
+                              bool use_ntlmv2,
+                              struct ntlmssp_state **_ntlmssp_state)
+{
+        struct ntlmssp_state *ntlmssp_state;
+        if (!netbios_name) {
+                netbios_name = "";
+        }
+        if (!netbios_domain) {
+                netbios_domain = "";
+        }
+        ntlmssp_state = talloc_zero(mem_ctx, struct ntlmssp_state);
+        if (!ntlmssp_state) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        ntlmssp_state->role = NTLMSSP_CLIENT;
+        ntlmssp_state->unicode = True;
+        ntlmssp_state->use_ntlmv2 = use_ntlmv2;
+        ntlmssp_state->expected_state = NTLMSSP_INITIAL;
+        ntlmssp_state->neg_flags =
                 NTLMSSP_NEGOTIATE_128 |
                 NTLMSSP_NEGOTIATE_ALWAYS_SIGN |
 …
                 NTLMSSP_REQUEST_TARGET;
+        ntlmssp_state->client.netbios_name = talloc_strdup(ntlmssp_state, netbios_name);
+        if (!ntlmssp_state->client.netbios_name) {
+                talloc_free(ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ntlmssp_state->client.netbios_domain = talloc_strdup(ntlmssp_state, netbios_domain);
+        if (!ntlmssp_state->client.netbios_domain) {
+                talloc_free(ntlmssp_state);
+                return NT_STATUS_NO_MEMORY;
+        }
+        *_ntlmssp_state = ntlmssp_state;
         return NT_STATUS_OK;
+}

vendor/current/source3/libsmb/passchange.c

-              r414
+              r740
 #include "includes.h"
+#include "../librpc/gen_ndr/ndr_samr.h"
+#include "rpc_client/cli_pipe.h"
+#include "rpc_client/cli_samr.h"
+#include "libsmb/libsmb.h"
+#include "libsmb/clirap.h"
+#include "libsmb/nmblib.h"
 /*************************************************************
 …
                         if (asprintf(err_str, "SAMR connection to machine %s "
                                  "failed. Error was %s, but LANMAN password "
                                  "changed are disabled\n",
+                                 "changes are disabled\n",
                                 nt_errstr(result), remote_machine) == -1) {
                                 *err_str = NULL;

vendor/current/source3/libsmb/samlogon_cache.c

-              r414
+              r740
 #include "includes.h"
+#include "system/filesys.h"
 #include "librpc/gen_ndr/ndr_krb5pac.h"
+#include "../libcli/security/security.h"
+#include "util_tdb.h"
 #define NETSAMLOGON_TDB "netsamlogon_cache.tdb"
 …
         path = cache_path(NETSAMLOGON_TDB);
 again:
         tdb = tdb_open_log(path, 0, TDB_DEFAULT,
+        tdb = tdb_open_log(path, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH,
                            O_RDWR | O_CREAT, 0600);
         if (tdb == NULL) {
 …
         DEBUG(0,("retry after CLEAR_IF_FIRST for '%s'\n", path));
         tdb = tdb_open_log(path, 0, TDB_CLEAR_IF_FIRST,
+        tdb = tdb_open_log(path, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
                            O_RDWR | O_CREAT, 0600);
         if (tdb) {
 …
 ***********************************************************************/
+void netsamlogon_clear_cached_user(struct netr_SamInfo3 *info3)
+{
+        DOM_SID user_sid;
+        fstring keystr, tmp;
+        if (!info3) {
+                return;
+        }
+void netsamlogon_clear_cached_user(const struct dom_sid *user_sid)
+{
+        fstring keystr;
         if (!netsamlogon_cache_init()) {
 …
                 return;
+        }
-        sid_copy(&user_sid, info3->base.domain_sid);
-        sid_append_rid(&user_sid, info3->base.rid);
         /* Prepare key as DOMAIN-SID/USER-RID string */
         slprintf(keystr, sizeof(keystr), "%s", sid_to_fstring(tmp, &user_sid));
+        sid_to_fstring(keystr, user_sid);
         DEBUG(10,("netsamlogon_clear_cached_user: SID [%s]\n", keystr));
 …
+{
         TDB_DATA data;
         fstring keystr, tmp;
+        fstring keystr;
         bool result = false;
         DOM_SID user_sid;
+        struct dom_sid  user_sid;
         time_t t = time(NULL);
         TALLOC_CTX *mem_ctx;
 …
+        }
+        sid_copy(&user_sid, info3->base.domain_sid);
+        sid_append_rid(&user_sid, info3->base.rid);
+        sid_compose(&user_sid, info3->base.domain_sid, info3->base.rid);
         /* Prepare key as DOMAIN-SID/USER-RID string */
         slprintf(keystr, sizeof(keystr), "%s", sid_to_fstring(tmp, &user_sid));
+        sid_to_fstring(keystr, &user_sid);
         DEBUG(10,("netsamlogon_cache_store: SID [%s]\n", keystr));
 …
+        }
         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, &r,
+        ndr_err = ndr_push_struct_blob(&blob, mem_ctx, &r,
                                        (ndr_push_flags_fn_t)ndr_push_netsamlogoncache_entry);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
 ***********************************************************************/
 struct netr_SamInfo3 *netsamlogon_cache_get(TALLOC_CTX *mem_ctx, const DOM_SID *user_sid)
+struct netr_SamInfo3 *netsamlogon_cache_get(TALLOC_CTX *mem_ctx, const struct dom_sid *user_sid)
+{
         struct netr_SamInfo3 *info3 = NULL;
 …
         blob = data_blob_const(data.dptr, data.dsize);
         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &r,
+        ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
                                       (ndr_pull_flags_fn_t)ndr_pull_netsamlogoncache_entry);
 …
+}
 bool netsamlogon_cache_have(const DOM_SID *user_sid)
+bool netsamlogon_cache_have(const struct dom_sid *user_sid)
+{
         TALLOC_CTX *mem_ctx = talloc_init("netsamlogon_cache_have");

vendor/current/source3/libsmb/smb_seal.c

-              r414
+              r740
 #include "includes.h"
+#include "../libcli/auth/ntlmssp.h"
+#include "smb_crypt.h"
+#include "libsmb/libsmb.h"
 /******************************************************************************
 …
 ******************************************************************************/
 NTSTATUS common_ntlm_decrypt_buffer(NTLMSSP_STATE *ntlmssp_state, char *buf)
+NTSTATUS common_ntlm_decrypt_buffer(struct ntlmssp_state *ntlmssp_state, char *buf)
+{
         NTSTATUS status;
 …
 ******************************************************************************/
 NTSTATUS common_ntlm_encrypt_buffer(NTLMSSP_STATE *ntlmssp_state,
+NTSTATUS common_ntlm_encrypt_buffer(struct ntlmssp_state *ntlmssp_state,
                                 uint16 enc_ctx_num,
                                 char *buf,
 …
         size_t data_len = smb_len(buf) - 4; /* Ignore the 0xFF SMB bytes. */
         DATA_BLOB sig;
+        TALLOC_CTX *frame;
         *ppbuf_out = NULL;
 …
+        }
+        frame = talloc_stackframe();
         /*
          * We know smb_len can't return a value > 128k, so no int overflow
 …
         status = ntlmssp_seal_packet(ntlmssp_state,
+                                     frame,
                 (unsigned char *)buf_out + 8 + NTLMSSP_SIG_SIZE, /* 4 byte len + 0xFF 'S' <enc> <ctx> */
                 data_len,
 …
         if (!NT_STATUS_IS_OK(status)) {
                 data_blob_free(&sig);
+                talloc_free(frame);
                 SAFE_FREE(buf_out);
                 return status;
 …
         /* First 16 data bytes are signature for SSPI compatibility. */
         memcpy(buf_out + 8, sig.data, NTLMSSP_SIG_SIZE);
         data_blob_free(&sig);
+        talloc_free(frame);
         *ppbuf_out = buf_out;
         return NT_STATUS_OK;
 …
         if (es->smb_enc_type == SMB_TRANS_ENC_NTLM) {
                 if (es->s.ntlmssp_state) {
                         ntlmssp_end(&es->s.ntlmssp_state);
+                        TALLOC_FREE(es->s.ntlmssp_state);
+                }
+        }

vendor/current/source3/libsmb/smb_share_modes.c

-              r414
+              r740
 #include "includes.h"
+#include "system/filesys.h"
 #include "smb_share_modes.h"
+#include <tdb.h>
 /* Database context handle. */
 …
         smb_db->smb_tdb = tdb_open(db_path,
 , TDB_DEFAULT|TDB_CLEAR_IF_FIRST,
+, TDB_DEFAULT|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
                                 O_RDWR|O_CREAT,
 );
 …
 static void create_share_mode_entry(struct share_mode_entry *out,
+                                const struct smb_share_mode_entry *in)
+                                const struct smb_share_mode_entry *in,
+                                uint32_t name_hash)
+{
         memset(out, '\0', sizeof(struct share_mode_entry));
 …
         out->uid = (uint32)geteuid();
         out->flags = 0;
+        out->name_hash = name_hash;
+}
 …
+        }
         *p_delete_on_close = ld->u.s.delete_on_close;
+        *p_delete_on_close = ld->u.s.num_delete_token_entries != 0;
         *pp_list = list;
         free(db_data.dptr);
         return list_num;
+}
+static uint32_t smb_name_hash(const char *sharepath, const char *filename, int *err)
+{
+        TDB_DATA key;
+        char *fullpath = NULL;
+        size_t sharepath_size = strlen(sharepath);
+        size_t filename_size = strlen(filename);
+        uint32_t name_hash;
+        *err = 0;
+        fullpath = (char *)malloc(sharepath_size + filename_size + 2);
+        if (fullpath == NULL) {
+                *err = 1;
+                return 0;
+        }
+        memcpy(fullpath, sharepath, sharepath_size);
+        fullpath[sharepath_size] = '/';
+        memcpy(&fullpath[sharepath_size + 1], filename, filename_size + 1);
+        key.dptr = (uint8_t *)fullpath;
+        key.dsize = strlen(fullpath) + 1;
+        name_hash = tdb_jenkins_hash(&key);
+        free(fullpath);
+        return name_hash;
+}
 …
         uint8 *new_data_p = NULL;
         size_t new_data_size = 0;
+        int err = 0;
+        uint32_t name_hash = smb_name_hash(sharepath, filename, &err);
+        if (err) {
+                return -1;
+        }
         db_data = tdb_fetch(db_ctx->smb_tdb, locking_key);
 …
                 memset(ld, '\0', sizeof(struct locking_data));
                 ld->u.s.num_share_mode_entries = 1;
+                ld->u.s.delete_on_close = 0;
+                ld->u.s.delete_token_size = 0;
+                ld->u.s.num_delete_token_entries = 0;
                 shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));
                 create_share_mode_entry(shares, new_entry);
+                create_share_mode_entry(shares, new_entry, name_hash);
                 memcpy(db_data.dptr + sizeof(struct locking_data) + sizeof(struct share_mode_entry),
 …
                         (orig_num_share_modes * sizeof(struct share_mode_entry)));
         create_share_mode_entry(shares, new_entry);
+        create_share_mode_entry(shares, new_entry, name_hash);
         ld = (struct locking_data *)new_data_p;
         ld->u.s.num_share_mode_entries++;
         /* Append the original delete_token and filenames. */
+        /* Append the original delete_tokens and filenames. */
         memcpy(new_data_p + sizeof(struct locking_data) + (ld->u.s.num_share_mode_entries * sizeof(struct share_mode_entry)),
                 db_data.dptr + sizeof(struct locking_data) + (orig_num_share_modes * sizeof(struct share_mode_entry)),
 …
+        }
         /* Copy any delete token plus the terminating filenames. */
+        /* Copy any delete tokens plus the terminating filenames. */
         remaining_ptr = db_data.dptr + sizeof(struct locking_data) + (orig_num_share_modes * sizeof(struct share_mode_entry));
         remaining_size = db_data.dsize - (remaining_ptr - db_data.dptr);
 …
                 if (share_mode_entry_equal(set_entry, share)) {
                         create_share_mode_entry(share, new_entry);
+                        create_share_mode_entry(share, new_entry, share->name_hash);
                         found_entry = 1;
                         break;

vendor/current/source3/libsmb/smb_signing.c

-              r414
+              r740
 #include "includes.h"
+#include "../lib/crypto/md5.h"
+#include "smb_signing.h"
 /* Used by the SMB signing functions. */
 …
         /* the next expected seqnum */
         uint32_t seqnum;
+        TALLOC_CTX *mem_ctx;
+        void *(*alloc_fn)(TALLOC_CTX *mem_ctx, size_t len);
+        void (*free_fn)(TALLOC_CTX *mem_ctx, void *ptr);
 };
 …
         si->active = false;
         si->bsrspyl = false;
-        data_blob_free(&si->mac_key);
         si->seqnum = 0;
+        if (si->free_fn) {
+                si->free_fn(si->mem_ctx, si->mac_key.data);
+        } else {
+                talloc_free(si->mac_key.data);
+        }
+        si->mac_key.data = NULL;
+        si->mac_key.length = 0;
+}
+struct smb_signing_state *smb_signing_init_ex(TALLOC_CTX *mem_ctx,
+                                              bool allowed,
+                                              bool mandatory,
+                                              void *(*alloc_fn)(TALLOC_CTX *, size_t),
+                                              void (*free_fn)(TALLOC_CTX *, void *))
+{
+        struct smb_signing_state *si;
+        if (alloc_fn) {
+                void *p = alloc_fn(mem_ctx, sizeof(struct smb_signing_state));
+                if (p == NULL) {
+                        return NULL;
+                }
+                memset(p, 0, sizeof(struct smb_signing_state));
+                si = (struct smb_signing_state *)p;
+                si->mem_ctx = mem_ctx;
+                si->alloc_fn = alloc_fn;
+                si->free_fn = free_fn;
+        } else {
+                si = talloc_zero(mem_ctx, struct smb_signing_state);
+                if (si == NULL) {
+                        return NULL;
+                }
+        }
+        if (mandatory) {
+                allowed = true;
+        }
+        si->allowed = allowed;
+        si->mandatory = mandatory;
+        return si;
+}
 …
                                            bool mandatory)
+{
+        struct smb_signing_state *si;
+        si = talloc_zero(mem_ctx, struct smb_signing_state);
+        if (si == NULL) {
+                return NULL;
+        }
+        if (mandatory) {
+                allowed = true;
+        }
+        si->allowed = allowed;
+        si->mandatory = mandatory;
+        return si;
+        return smb_signing_init_ex(mem_ctx, allowed, mandatory, NULL, NULL);
+}
 …
         len = response.length + user_session_key.length;
+        si->mac_key = data_blob_talloc(si, NULL, len);
+        if (si->alloc_fn) {
+                si->mac_key.data = (uint8_t *)si->alloc_fn(si->mem_ctx, len);
+                if (si->mac_key.data == NULL) {
+                        return false;
+                }
+        } else {
+                si->mac_key.data = (uint8_t *)talloc_size(si, len);
+                if (si->mac_key.data == NULL) {
+                        return false;
+                }
+        }
+        si->mac_key.length = len;
         ofs = 0;

vendor/current/source3/libsmb/smberr.c

-              r414
+              r740
    Unix SMB/CIFS implementation.
    Copyright (C) Andrew Tridgell 1998
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
         char *result;
         int i,j;
         for (i=0;err_classes[i].e_class;i++)
                 if (err_classes[i].code == e_class) {
 …
                         return result;
+                }
         result = talloc_asprintf(talloc_tos(), "Error: Unknown error class "
                                  "(%d,%d)", e_class,num);

vendor/current/source3/libsmb/smbsock_connect.c

-              r600
+              r740
 #include "includes.h"
+#include "../lib/async_req/async_sock.h"
+#include "../lib/util/tevent_ntstatus.h"
+#include "client.h"
 #include "async_smb.h"
+#include "libsmb/nmblib.h"
 struct nb_connect_state {
 …
         const struct sockaddr_storage *addr;
         const char *called_name;
+        uint8_t called_type;
         const char *calling_name;
+        uint8_t calling_type;
         struct tevent_req *req_139;
         struct tevent_req *req_445;
 …
                                         struct tevent_context *ev,
                                         const struct sockaddr_storage *addr,
+                                        uint16_t port,
                                         const char *called_name,
+                                        const char *calling_name)
+                                        int called_type,
+                                        const char *calling_name,
+                                        int calling_type)
+{
         struct tevent_req *req, *subreq;
 …
         state->called_name =
                 (called_name != NULL) ? called_name : "*SMBSERVER";
+        state->called_type =
+                (called_type != -1) ? called_type : 0x20;
         state->calling_name =
                 (calling_name != NULL) ? calling_name : global_myname();
+        state->calling_type =
+                (calling_type != -1) ? calling_type : 0x00;
         talloc_set_destructor(state, smbsock_connect_state_destructor);
+        if (port == 139) {
+                subreq = tevent_wakeup_send(state, ev, timeval_set(0, 0));
+                if (tevent_req_nomem(subreq, req)) {
+                        return tevent_req_post(req, ev);
+                }
+                tevent_req_set_callback(subreq, smbsock_connect_do_139, req);
+                return req;
+        }
+        if (port != 0) {
+                state->req_445 = open_socket_out_send(state, ev, addr, port,
+);
+                if (tevent_req_nomem(state->req_445, req)) {
+                        return tevent_req_post(req, ev);
+                }
+                tevent_req_set_callback(
+                        state->req_445, smbsock_connect_connected, req);
+                return req;
+        }
+        /*
+         * port==0, try both
+         */
         state->req_445 = open_socket_out_send(state, ev, addr, 445, 5000);
 …
         if (state->sock != -1) {
                 close(state->sock);
+                state->sock = -1;
+        }
         return 0;
 …
+        }
         state->req_139 = nb_connect_send(state, state->ev, state->addr,
+                                         state->called_name, 0x20,
+                                         state->calling_name, 0x0);
+                                         state->called_name,
+                                         state->called_type,
+                                         state->calling_name,
+                                         state->calling_type);
         if (tevent_req_nomem(state->req_139, req)) {
                 return;
 …
 NTSTATUS smbsock_connect_recv(struct tevent_req *req, int *sock,
                           uint16_t *port)
+                              uint16_t *ret_port)
+{
         struct smbsock_connect_state *state = tevent_req_data(
 …
         *sock = state->sock;
         state->sock = -1;
         if (port != NULL) {
                 *port = state->port;
+        if (ret_port != NULL) {
+                *ret_port = state->port;
+        }
         return NT_STATUS_OK;
+}
+NTSTATUS smbsock_connect(const struct sockaddr_storage *addr,
+                         const char *called_name, const char *calling_name,
+                         int *pfd, uint16_t *port)
+NTSTATUS smbsock_connect(const struct sockaddr_storage *addr, uint16_t port,
+                         const char *called_name, int called_type,
+                         const char *calling_name, int calling_type,
+                         int *pfd, uint16_t *ret_port, int sec_timeout)
+{
         TALLOC_CTX *frame = talloc_stackframe();
 …
                 goto fail;
+        }
+        req = smbsock_connect_send(frame, ev, addr, called_name, calling_name);
+        req = smbsock_connect_send(frame, ev, addr, port,
+                                   called_name, called_type,
+                                   calling_name, calling_type);
         if (req == NULL) {
                 goto fail;
+        }
+        if ((sec_timeout != 0) &&
+            !tevent_req_set_endtime(
+                    req, ev, timeval_current_ofs(sec_timeout, 0))) {
+                goto fail;
+        }
         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
                 goto fail;
+        }
         status = smbsock_connect_recv(req, pfd, port);
+        status = smbsock_connect_recv(req, pfd, ret_port);
  fail:
         TALLOC_FREE(frame);
 …
         const struct sockaddr_storage *addrs;
         const char **called_names;
+        int *called_types;
+        const char **calling_names;
+        int *calling_types;
         size_t num_addrs;
+        uint16_t port;
         struct tevent_req **requests;
 …
         int fd;
         uint16_t port;
+        uint16_t chosen_port;
         size_t chosen_index;
 };
 …
                                             const struct sockaddr_storage *addrs,
                                             const char **called_names,
+                                            size_t num_addrs)
+                                            int *called_types,
+                                            const char **calling_names,
+                                            int *calling_types,
+                                            size_t num_addrs, uint16_t port)
+{
         struct tevent_req *req, *subreq;
 …
         state->num_addrs = num_addrs;
         state->called_names = called_names;
+        state->called_types = called_types;
+        state->calling_names = calling_names;
+        state->calling_types = calling_types;
+        state->port = port;
         if (num_addrs == 0) {
 …
         subreq = smbsock_connect_send(
                 state->requests, state->ev, &state->addrs[state->num_sent],
+                state->port,
                 (state->called_names != NULL)
                 ? state->called_names[state->num_sent] : NULL,
+                NULL);
+                (state->called_types != NULL)
+                ? state->called_types[state->num_sent] : -1,
+                (state->calling_names != NULL)
+                ? state->calling_names[state->num_sent] : NULL,
+                (state->calling_types != NULL)
+                ? state->calling_types[state->num_sent] : -1);
         if (tevent_req_nomem(subreq, req)) {
                 return false;
 …
         NTSTATUS status;
         int fd;
         uint16_t port;
+        uint16_t chosen_port;
         size_t i;
         size_t chosen_index = 0;
 …
+        }
         status = smbsock_connect_recv(subreq, &fd, &port);
+        status = smbsock_connect_recv(subreq, &fd, &chosen_port);
         TALLOC_FREE(subreq);
 …
                 TALLOC_FREE(state->requests);
                 state->fd = fd;
                 state->port = port;
+                state->chosen_port = chosen_port;
                 state->chosen_index = chosen_index;
                 tevent_req_done(req);
 …
 NTSTATUS smbsock_any_connect_recv(struct tevent_req *req, int *pfd,
+                                  size_t *chosen_index, uint16_t *port)
+                                  size_t *chosen_index,
+                                  uint16_t *chosen_port)
+{
         struct smbsock_any_connect_state *state = tevent_req_data(
 …
                 *chosen_index = state->chosen_index;
+        }
         if (port != NULL) {
                 *port = state->port;
+        if (chosen_port != NULL) {
+                *chosen_port = state->chosen_port;
+        }
         return NT_STATUS_OK;
 …
 NTSTATUS smbsock_any_connect(const struct sockaddr_storage *addrs,
+                             const char **called_names, size_t num_addrs,
+                             int *pfd, size_t *chosen_index, uint16_t *port)
+                             const char **called_names,
+                             int *called_types,
+                             const char **calling_names,
+                             int *calling_types,
+                             size_t num_addrs,
+                             uint16_t port,
+                             int sec_timeout,
+                             int *pfd, size_t *chosen_index,
+                             uint16_t *chosen_port)
+{
         TALLOC_CTX *frame = talloc_stackframe();
 …
                 goto fail;
+        }
+        req = smbsock_any_connect_send(frame, ev, addrs, called_names,
+                                       num_addrs);
+        req = smbsock_any_connect_send(frame, ev, addrs,
+                                       called_names, called_types,
+                                       calling_names, calling_types,
+                                       num_addrs, port);
         if (req == NULL) {
                 goto fail;
+        }
+        if ((sec_timeout != 0) &&
+            !tevent_req_set_endtime(
+                    req, ev, timeval_current_ofs(sec_timeout, 0))) {
+                goto fail;
+        }
         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
                 goto fail;
+        }
         status = smbsock_any_connect_recv(req, pfd, chosen_index, port);
+        status = smbsock_any_connect_recv(req, pfd, chosen_index, chosen_port);
  fail:
         TALLOC_FREE(frame);

vendor/current/source3/libsmb/trustdom_cache.c

-              r414
+              r740
 #include "includes.h"
+#include "../libcli/security/security.h"
 #undef DBGC_CLASS
 …
  **/
 bool trustdom_cache_store(char* name, char* alt_name, const DOM_SID *sid,
+bool trustdom_cache_store(char* name, char* alt_name, const struct dom_sid *sid,
                           time_t timeout)
+{
 …
  **/
 bool trustdom_cache_fetch(const char* name, DOM_SID* sid)
+bool trustdom_cache_fetch(const char* name, struct dom_sid* sid)
+{
         char *key = NULL, *value = NULL;
 …
+        }
         /* convert sid string representation into DOM_SID structure */
+        /* convert sid string representation into struct dom_sid structure */
         if(! string_to_sid(sid, value)) {
                 sid = NULL;
 …
+{
         char **domain_names;
         DOM_SID *dom_sids;
+        struct dom_sid *dom_sids;
         uint32 num_domains;
         uint32 last_check;

vendor/current/source3/libsmb/trusts_util.c

-              r414
+              r740
 #include "includes.h"
 #include "../libcli/auth/libcli_auth.h"
+#include "../librpc/gen_ndr/cli_lsa.h"
+#include "../librpc/gen_ndr/ndr_lsa_c.h"
+#include "rpc_client/cli_lsarpc.h"
+#include "rpc_client/cli_netlogon.h"
+#include "rpc_client/cli_pipe.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "secrets.h"
+#include "passdb.h"
+#include "libsmb/libsmb.h"
 /*********************************************************
 …
 bool enumerate_domain_trusts( TALLOC_CTX *mem_ctx, const char *domain,
                                      char ***domain_names, uint32 *num_domains,
                                      DOM_SID **sids )
+                                     struct dom_sid **sids )
+{
         struct policy_handle    pol;
         NTSTATUS        result = NT_STATUS_UNSUCCESSFUL;
+        NTSTATUS status, result;
         fstring         dc_name;
         struct sockaddr_storage dc_ss;
 …
         struct cli_state *cli = NULL;
         struct rpc_pipe_client *lsa_pipe = NULL;
-        bool            retry;
         struct lsa_DomainList dom_list;
         int i;
+        struct dcerpc_binding_handle *b = NULL;
         *domain_names = NULL;
 …
         /* setup the anonymous connection */
         result = cli_full_connection( &cli, global_myname(), dc_name, &dc_ss, 0, "IPC$", "IPC",
                 "", "", "", 0, Undefined, &retry);
         if ( !NT_STATUS_IS_OK(result) )
+        status = cli_full_connection( &cli, global_myname(), dc_name, &dc_ss, 0, "IPC$", "IPC",
+                "", "", "", 0, Undefined);
+        if ( !NT_STATUS_IS_OK(status) )
                 goto done;
         /* open the LSARPC_PIPE */
         result = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
+        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
                                           &lsa_pipe);
+        if (!NT_STATUS_IS_OK(result)) {
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        b = lsa_pipe->binding_handle;
         /* get a handle */
         result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, True,
+        status = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, True,
                 LSA_POLICY_VIEW_LOCAL_INFORMATION, &pol);
         if ( !NT_STATUS_IS_OK(result) )
+        if ( !NT_STATUS_IS_OK(status) )
                 goto done;
         /* Lookup list of trusted domains */
         result = rpccli_lsa_EnumTrustDom(lsa_pipe, mem_ctx,
+        status = dcerpc_lsa_EnumTrustDom(b, mem_ctx,
                                          &pol,
                                          &enum_ctx,
                                          &dom_list,
+                                         (uint32_t)-1);
+        if ( !NT_STATUS_IS_OK(result) )
+                goto done;
+                                         (uint32_t)-1,
+                                         &result);
+        if ( !NT_STATUS_IS_OK(status) )
+                goto done;
+        if (!NT_STATUS_IS_OK(result)) {
+                status = result;
+                goto done;
+        }
         *num_domains = dom_list.count;
 …
         *domain_names = TALLOC_ZERO_ARRAY(mem_ctx, char *, *num_domains);
         if (!*domain_names) {
                 result = NT_STATUS_NO_MEMORY;
                 goto done;
+        }
         *sids = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID, *num_domains);
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        *sids = TALLOC_ZERO_ARRAY(mem_ctx, struct dom_sid, *num_domains);
         if (!*sids) {
                 result = NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
                 goto done;
+        }
 …
+        }
         return NT_STATUS_IS_OK(result);
+        return NT_STATUS_IS_OK(status);
+}
+NTSTATUS change_trust_account_password( const char *domain, const char *remote_machine)
+{
+        NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
+        struct sockaddr_storage pdc_ss;
+        fstring dc_name;
+        struct cli_state *cli = NULL;
+        struct rpc_pipe_client *netlogon_pipe = NULL;
+        DEBUG(5,("change_trust_account_password: Attempting to change trust account password in domain %s....\n",
+                domain));
+        if (remote_machine == NULL || !strcmp(remote_machine, "*")) {
+                /* Use the PDC *only* for this */
+                if ( !get_pdc_ip(domain, &pdc_ss) ) {
+                        DEBUG(0,("Can't get IP for PDC for domain %s\n", domain));
+                        goto failed;
+                }
+                if ( !name_status_find( domain, 0x1b, 0x20, &pdc_ss, dc_name) )
+                        goto failed;
+        } else {
+                /* supoport old deprecated "smbpasswd -j DOMAIN -r MACHINE" behavior */
+                fstrcpy( dc_name, remote_machine );
+        }
+        /* if this next call fails, then give up.  We can't do
+           password changes on BDC's  --jerry */
+        if (!NT_STATUS_IS_OK(cli_full_connection(&cli, global_myname(), dc_name,
+                                           NULL, 0,
+                                           "IPC$", "IPC",
+                                           "", "",
+                                           "", 0, Undefined))) {
+                DEBUG(0,("modify_trust_password: Connection to %s failed!\n", dc_name));
+                nt_status = NT_STATUS_UNSUCCESSFUL;
+                goto failed;
+        }
+        /*
+         * Ok - we have an anonymous connection to the IPC$ share.
+         * Now start the NT Domain stuff :-).
+         */
+        /* Shouldn't we open this with schannel ? JRA. */
+        nt_status = cli_rpc_pipe_open_noauth(
+                cli, &ndr_table_netlogon.syntax_id, &netlogon_pipe);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                DEBUG(0,("modify_trust_password: unable to open the domain client session to machine %s. Error was : %s.\n",
+                        dc_name, nt_errstr(nt_status)));
+                cli_shutdown(cli);
+                cli = NULL;
+                goto failed;
+        }
+        nt_status = trust_pw_find_change_and_store_it(
+                netlogon_pipe, netlogon_pipe, domain);
+        cli_shutdown(cli);
+        cli = NULL;
+failed:
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                DEBUG(0,("%s : change_trust_account_password: Failed to change password for domain %s.\n",
+                        current_timestring(talloc_tos(), False), domain));
+        }
+        else
+                DEBUG(5,("change_trust_account_password: sucess!\n"));
+        return nt_status;
+}

vendor/current/source3/libsmb/unexpected.c

-              r414
+              r740
 #include "includes.h"
+static TDB_CONTEXT *tdbd = NULL;
+/* the key type used in the unexpected packet database */
+struct unexpected_key {
+        enum packet_type packet_type;
+        time_t timestamp;
+        int count;
+#include "../lib/util/tevent_ntstatus.h"
+#include "lib/async_req/async_sock.h"
+#include "libsmb/nmblib.h"
+static const char *nmbd_socket_dir(void)
+{
+        return lp_parm_const_string(-1, "nmbd", "socket dir",
+                                    get_dyn_NMBDSOCKETDIR());
+}
+struct nb_packet_query {
+        enum packet_type type;
+        size_t mailslot_namelen;
+        int trn_id;
 };
+/****************************************************************************
+ All unexpected packets are passed in here, to be stored in a unexpected
+ packet database. This allows nmblookup and other tools to receive packets
+ erroneously sent to the wrong port by broken MS systems.
+**************************************************************************/
+void unexpected_packet(struct packet_struct *p)
+{
+        static int count;
+        TDB_DATA kbuf, dbuf;
+        struct unexpected_key key;
+        char buf[1024];
+        int len=0;
+        uint32_t enc_ip;
+        if (!tdbd) {
+                tdbd = tdb_open_log(lock_path("unexpected.tdb"), 0,
+                               TDB_CLEAR_IF_FIRST|TDB_DEFAULT,
+                               O_RDWR | O_CREAT, 0644);
+                if (!tdbd) {
+                        DEBUG(0,("Failed to open unexpected.tdb\n"));
+struct nb_packet_client;
+struct nb_packet_server {
+        struct tevent_context *ev;
+        int listen_sock;
+        int max_clients;
+        int num_clients;
+        struct nb_packet_client *clients;
+};
+struct nb_packet_client {
+        struct nb_packet_client *prev, *next;
+        struct nb_packet_server *server;
+        enum packet_type type;
+        int trn_id;
+        char *mailslot_name;
+        int sock;
+        struct tevent_req *read_req;
+        struct tevent_queue *out_queue;
+};
+static int nb_packet_server_destructor(struct nb_packet_server *s);
+static void nb_packet_server_listener(struct tevent_context *ev,
+                                      struct tevent_fd *fde,
+                                      uint16_t flags,
+                                      void *private_data);
+NTSTATUS nb_packet_server_create(TALLOC_CTX *mem_ctx,
+                                 struct tevent_context *ev,
+                                 int max_clients,
+                                 struct nb_packet_server **presult)
+{
+        struct nb_packet_server *result;
+        struct tevent_fd *fde;
+        NTSTATUS status;
+        result = TALLOC_ZERO_P(mem_ctx, struct nb_packet_server);
+        if (result == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto fail;
+        }
+        result->ev = ev;
+        result->max_clients = max_clients;
+        result->listen_sock = create_pipe_sock(
+                nmbd_socket_dir(), "unexpected", 0755);
+        if (result->listen_sock == -1) {
+                status = map_nt_error_from_unix(errno);
+                goto fail;
+        }
+        talloc_set_destructor(result, nb_packet_server_destructor);
+        fde = tevent_add_fd(ev, result, result->listen_sock, TEVENT_FD_READ,
+                            nb_packet_server_listener, result);
+        if (fde == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto fail;
+        }
+        *presult = result;
+        return NT_STATUS_OK;
+fail:
+        TALLOC_FREE(result);
+        return status;
+}
+static int nb_packet_server_destructor(struct nb_packet_server *s)
+{
+        if (s->listen_sock != -1) {
+                close(s->listen_sock);
+                s->listen_sock = -1;
+        }
+        return 0;
+}
+static int nb_packet_client_destructor(struct nb_packet_client *c);
+static ssize_t nb_packet_client_more(uint8_t *buf, size_t buflen,
+                                     void *private_data);
+static void nb_packet_got_query(struct tevent_req *req);
+static void nb_packet_client_read_done(struct tevent_req *req);
+static void nb_packet_server_listener(struct tevent_context *ev,
+                                      struct tevent_fd *fde,
+                                      uint16_t flags,
+                                      void *private_data)
+{
+        struct nb_packet_server *server = talloc_get_type_abort(
+                private_data, struct nb_packet_server);
+        struct nb_packet_client *client;
+        struct tevent_req *req;
+        struct sockaddr_un sunaddr;
+        socklen_t len;
+        int sock;
+        len = sizeof(sunaddr);
+        sock = accept(server->listen_sock, (struct sockaddr *)(void *)&sunaddr,
+                      &len);
+        if (sock == -1) {
+                return;
+        }
+        DEBUG(6,("accepted socket %d\n", sock));
+        client = TALLOC_ZERO_P(server, struct nb_packet_client);
+        if (client == NULL) {
+                DEBUG(10, ("talloc failed\n"));
+                close(sock);
+                return;
+        }
+        client->sock = sock;
+        client->server = server;
+        talloc_set_destructor(client, nb_packet_client_destructor);
+        client->out_queue = tevent_queue_create(
+                client, "unexpected packet output");
+        if (client->out_queue == NULL) {
+                DEBUG(10, ("tevent_queue_create failed\n"));
+                TALLOC_FREE(client);
+                return;
+        }
+        req = read_packet_send(client, ev, client->sock,
+                               sizeof(struct nb_packet_query),
+                               nb_packet_client_more, NULL);
+        if (req == NULL) {
+                DEBUG(10, ("read_packet_send failed\n"));
+                TALLOC_FREE(client);
+                return;
+        }
+        tevent_req_set_callback(req, nb_packet_got_query, client);
+        DLIST_ADD(server->clients, client);
+        server->num_clients += 1;
+        if (server->num_clients > server->max_clients) {
+                DEBUG(10, ("Too many clients, dropping oldest\n"));
+                /*
+                 * no TALLOC_FREE here, don't mess with the list structs
+                 */
+                talloc_free(server->clients->prev);
+        }
+}
+static ssize_t nb_packet_client_more(uint8_t *buf, size_t buflen,
+                                     void *private_data)
+{
+        struct nb_packet_query q;
+        if (buflen > sizeof(struct nb_packet_query)) {
+                return 0;
+        }
+        /* Take care of alignment */
+        memcpy(&q, buf, sizeof(q));
+        if (q.mailslot_namelen > 1024) {
+                DEBUG(10, ("Got invalid mailslot namelen %d\n",
+                           (int)q.mailslot_namelen));
+                return -1;
+        }
+        return q.mailslot_namelen;
+}
+static int nb_packet_client_destructor(struct nb_packet_client *c)
+{
+        if (c->sock != -1) {
+                close(c->sock);
+                c->sock = -1;
+        }
+        DLIST_REMOVE(c->server->clients, c);
+        c->server->num_clients -= 1;
+        return 0;
+}
+static void nb_packet_got_query(struct tevent_req *req)
+{
+        struct nb_packet_client *client = tevent_req_callback_data(
+                req, struct nb_packet_client);
+        struct nb_packet_query q;
+        uint8_t *buf;
+        ssize_t nread, nwritten;
+        int err;
+        char c;
+        nread = read_packet_recv(req, talloc_tos(), &buf, &err);
+        TALLOC_FREE(req);
+        if (nread < (ssize_t)sizeof(struct nb_packet_query)) {
+                DEBUG(10, ("read_packet_recv returned %d (%s)\n",
+                           (int)nread,
+                           (nread == -1) ? strerror(err) : "wrong length"));
+                TALLOC_FREE(client);
+                return;
+        }
+        /* Take care of alignment */
+        memcpy(&q, buf, sizeof(q));
+        if (nread != sizeof(struct nb_packet_query) + q.mailslot_namelen) {
+                DEBUG(10, ("nb_packet_got_query: Invalid mailslot namelength\n"));
+                TALLOC_FREE(client);
+                return;
+        }
+        client->trn_id = q.trn_id;
+        client->type = q.type;
+        if (q.mailslot_namelen > 0) {
+                client->mailslot_name = talloc_strndup(
+                        client, (char *)buf + sizeof(q),
+                        q.mailslot_namelen);
+                if (client->mailslot_name == NULL) {
+                        TALLOC_FREE(client);
                         return;
+                }
+        }
+        memset(buf,'\0',sizeof(buf));
+        /* Encode the ip addr and port. */
+        enc_ip = ntohl(p->ip.s_addr);
+        SIVAL(buf,0,enc_ip);
+        SSVAL(buf,4,p->port);
+        len = build_packet(&buf[6], sizeof(buf)-6, p) + 6;
+        ZERO_STRUCT(key);       /* needed for potential alignment */
+        key.packet_type = p->packet_type;
+        key.timestamp = p->timestamp;
+        key.count = count++;
+        kbuf.dptr = (uint8_t *)&key;
+        kbuf.dsize = sizeof(key);
+        dbuf.dptr = (uint8_t *)buf;
+        dbuf.dsize = len;
+        tdb_store(tdbd, kbuf, dbuf, TDB_REPLACE);
+}
+static time_t lastt;
+/****************************************************************************
+ Delete the record if it is too old.
+**************************************************************************/
+static int traverse_fn(TDB_CONTEXT *ttdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
+{
+        struct unexpected_key key;
+        if (kbuf.dsize != sizeof(key)) {
+                tdb_delete(ttdb, kbuf);
+        }
+        memcpy(&key, kbuf.dptr, sizeof(key));
+        if (lastt - key.timestamp > NMBD_UNEXPECTED_TIMEOUT) {
+                tdb_delete(ttdb, kbuf);
+        }
+        /*
+         * Yes, this is a blocking write of 1 byte into a unix
+         * domain socket that has never been written to. Highly
+         * unlikely that this actually blocks.
+         */
+        c = 0;
+        nwritten = sys_write(client->sock, &c, sizeof(c));
+        if (nwritten != sizeof(c)) {
+                DEBUG(10, ("Could not write success indicator to client: %s\n",
+                           strerror(errno)));
+                TALLOC_FREE(client);
+                return;
+        }
+        client->read_req = read_packet_send(client, client->server->ev,
+                                            client->sock, 1, NULL, NULL);
+        if (client->read_req == NULL) {
+                DEBUG(10, ("Could not activate reader for client exit "
+                           "detection\n"));
+                TALLOC_FREE(client);
+                return;
+        }
+        tevent_req_set_callback(client->read_req, nb_packet_client_read_done,
+                                client);
+}
+static void nb_packet_client_read_done(struct tevent_req *req)
+{
+        struct nb_packet_client *client = tevent_req_callback_data(
+                req, struct nb_packet_client);
+        ssize_t nread;
+        uint8_t *buf;
+        int err;
+        nread = read_packet_recv(req, talloc_tos(), &buf, &err);
+        TALLOC_FREE(req);
+        if (nread == 1) {
+                DEBUG(10, ("Protocol error, received data on write-only "
+                           "unexpected socket: 0x%2.2x\n", (*buf)));
+        }
+        TALLOC_FREE(client);
+}
+static void nb_packet_client_send(struct nb_packet_client *client,
+                                  struct packet_struct *p);
+void nb_packet_dispatch(struct nb_packet_server *server,
+                        struct packet_struct *p)
+{
+        struct nb_packet_client *c;
+        uint16_t trn_id;
+        switch (p->packet_type) {
+        case NMB_PACKET:
+                trn_id = p->packet.nmb.header.name_trn_id;
+                break;
+        case DGRAM_PACKET:
+                trn_id = p->packet.dgram.header.dgm_id;
+                break;
+        default:
+                DEBUG(10, ("Got invalid packet type %d\n",
+                           (int)p->packet_type));
+                return;
+        }
+        for (c = server->clients; c != NULL; c = c->next) {
+                if (c->type != p->packet_type) {
+                        DEBUG(10, ("client expects packet %d, got %d\n",
+                                   c->type, p->packet_type));
+                        continue;
+                }
+                if (p->packet_type == NMB_PACKET) {
+                        /*
+                         * See if the client specified transaction
+                         * ID. Filter if it did.
+                         */
+                        if ((c->trn_id != -1) &&
+                            (c->trn_id != trn_id)) {
+                                DEBUG(10, ("client expects trn %d, got %d\n",
+                                           c->trn_id, trn_id));
+                                continue;
+                        }
+                } else {
+                        /*
+                         * See if the client specified a mailslot
+                         * name. Filter if it did.
+                         */
+                        if ((c->mailslot_name != NULL) &&
+                            !match_mailslot_name(p, c->mailslot_name)) {
+                                continue;
+                        }
+                }
+                nb_packet_client_send(c, p);
+        }
+}
+struct nb_packet_client_header {
+        size_t len;
+        enum packet_type type;
+        time_t timestamp;
+        struct in_addr ip;
+        int port;
+};
+struct nb_packet_client_state {
+        struct nb_packet_client *client;
+        struct iovec iov[2];
+        struct nb_packet_client_header hdr;
+        char buf[1024];
+};
+static void nb_packet_client_send_done(struct tevent_req *req);
+static void nb_packet_client_send(struct nb_packet_client *client,
+                                  struct packet_struct *p)
+{
+        struct nb_packet_client_state *state;
+        struct tevent_req *req;
+        if (tevent_queue_length(client->out_queue) > 10) {
+                /*
+                 * Skip clients that don't listen anyway, some form of DoS
+                 * protection
+                 */
+                return;
+        }
+        state = TALLOC_ZERO_P(client, struct nb_packet_client_state);
+        if (state == NULL) {
+                DEBUG(10, ("talloc failed\n"));
+                return;
+        }
+        state->client = client;
+        state->hdr.ip = p->ip;
+        state->hdr.port = p->port;
+        state->hdr.timestamp = p->timestamp;
+        state->hdr.type = p->packet_type;
+        state->hdr.len = build_packet(state->buf, sizeof(state->buf), p);
+        state->iov[0].iov_base = (char *)&state->hdr;
+        state->iov[0].iov_len = sizeof(state->hdr);
+        state->iov[1].iov_base = state->buf;
+        state->iov[1].iov_len = state->hdr.len;
+        TALLOC_FREE(client->read_req);
+        req = writev_send(client, client->server->ev, client->out_queue,
+                          client->sock, true, state->iov, 2);
+        if (req == NULL) {
+                DEBUG(10, ("writev_send failed\n"));
+                return;
+        }
+        tevent_req_set_callback(req, nb_packet_client_send_done, state);
+}
+static void nb_packet_client_send_done(struct tevent_req *req)
+{
+        struct nb_packet_client_state *state = tevent_req_callback_data(
+                req, struct nb_packet_client_state);
+        struct nb_packet_client *client = state->client;
+        ssize_t nwritten;
+        int err;
+        nwritten = writev_recv(req, &err);
+        TALLOC_FREE(req);
+        TALLOC_FREE(state);
+        if (nwritten == -1) {
+                DEBUG(10, ("writev failed: %s\n", strerror(err)));
+                TALLOC_FREE(client);
+        }
+        if (tevent_queue_length(client->out_queue) == 0) {
+                client->read_req = read_packet_send(client, client->server->ev,
+                                                    client->sock, 1,
+                                                    NULL, NULL);
+                if (client->read_req == NULL) {
+                        DEBUG(10, ("Could not activate reader for client exit "
+                                   "detection\n"));
+                        TALLOC_FREE(client);
+                        return;
+                }
+                tevent_req_set_callback(client->read_req,
+                                        nb_packet_client_read_done,
+                                        client);
+        }
+}
+struct nb_packet_reader {
+        int sock;
+};
+struct nb_packet_reader_state {
+        struct tevent_context *ev;
+        struct sockaddr_un addr;
+        struct nb_packet_query query;
+        const char *mailslot_name;
+        struct iovec iov[2];
+        char c;
+        struct nb_packet_reader *reader;
+};
+static int nb_packet_reader_destructor(struct nb_packet_reader *r);
+static void nb_packet_reader_connected(struct tevent_req *subreq);
+static void nb_packet_reader_sent_query(struct tevent_req *subreq);
+static void nb_packet_reader_got_ack(struct tevent_req *subreq);
+struct tevent_req *nb_packet_reader_send(TALLOC_CTX *mem_ctx,
+                                         struct tevent_context *ev,
+                                         enum packet_type type,
+                                         int trn_id,
+                                         const char *mailslot_name)
+{
+        struct tevent_req *req, *subreq;
+        struct nb_packet_reader_state *state;
+        char *path;
+        req = tevent_req_create(mem_ctx, &state,
+                                struct nb_packet_reader_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        state->ev = ev;
+        state->query.trn_id = trn_id;
+        state->query.type = type;
+        state->mailslot_name = mailslot_name;
+        if (mailslot_name != NULL) {
+                state->query.mailslot_namelen = strlen(mailslot_name);
+        }
+        state->reader = TALLOC_ZERO_P(state, struct nb_packet_reader);
+        if (tevent_req_nomem(state->reader, req)) {
+                return tevent_req_post(req, ev);
+        }
+        path = talloc_asprintf(talloc_tos(), "%s/%s", nmbd_socket_dir(),
+                               "unexpected");
+        if (tevent_req_nomem(path, req)) {
+                return tevent_req_post(req, ev);
+        }
+        state->addr.sun_family = AF_UNIX;
+        strlcpy(state->addr.sun_path, path, sizeof(state->addr.sun_path));
+        TALLOC_FREE(path);
+        state->reader->sock = socket(AF_UNIX, SOCK_STREAM, 0);
+        if (state->reader->sock == -1) {
+                tevent_req_nterror(req, map_nt_error_from_unix(errno));
+                return tevent_req_post(req, ev);
+        }
+        talloc_set_destructor(state->reader, nb_packet_reader_destructor);
+        subreq = async_connect_send(state, ev, state->reader->sock,
+                                    (struct sockaddr *)(void *)&state->addr,
+                                    sizeof(state->addr));
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, nb_packet_reader_connected, req);
+        return req;
+}
+static int nb_packet_reader_destructor(struct nb_packet_reader *r)
+{
+        if (r->sock != -1) {
+                close(r->sock);
+                r->sock = -1;
+        }
         return 0;
+}
+/****************************************************************************
+ Delete all old unexpected packets.
+**************************************************************************/
+void clear_unexpected(time_t t)
+{
+        if (!tdbd) return;
+        if ((lastt != 0) && (t < lastt + NMBD_UNEXPECTED_TIMEOUT))
+                return;
+        lastt = t;
+        tdb_traverse(tdbd, traverse_fn, NULL);
+}
+struct receive_unexpected_state {
+        struct packet_struct *matched_packet;
+        int match_id;
+        enum packet_type match_type;
+        const char *match_name;
+static void nb_packet_reader_connected(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_packet_reader_state *state = tevent_req_data(
+                req, struct nb_packet_reader_state);
+        int res, err;
+        int num_iovecs = 1;
+        res = async_connect_recv(subreq, &err);
+        TALLOC_FREE(subreq);
+        if (res == -1) {
+                DEBUG(10, ("async_connect failed: %s\n", strerror(err)));
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                return;
+        }
+        state->iov[0].iov_base = (char *)&state->query;
+        state->iov[0].iov_len = sizeof(state->query);
+        if (state->mailslot_name != NULL) {
+                num_iovecs = 2;
+                state->iov[1].iov_base = discard_const_p(
+                        char, state->mailslot_name);
+                state->iov[1].iov_len = state->query.mailslot_namelen;
+        }
+        subreq = writev_send(state, state->ev, NULL, state->reader->sock,
+                             true, state->iov, num_iovecs);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nb_packet_reader_sent_query, req);
+}
+static void nb_packet_reader_sent_query(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_packet_reader_state *state = tevent_req_data(
+                req, struct nb_packet_reader_state);
+        ssize_t written;
+        int err;
+        written = writev_recv(subreq, &err);
+        TALLOC_FREE(subreq);
+        if (written == -1) {
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                return;
+        }
+        if (written != sizeof(state->query) + state->query.mailslot_namelen) {
+                tevent_req_nterror(req, NT_STATUS_UNEXPECTED_IO_ERROR);
+                return;
+        }
+        subreq = read_packet_send(state, state->ev, state->reader->sock,
+                                  sizeof(state->c), NULL, NULL);
+        if (tevent_req_nomem(subreq, req)) {
+                return;
+        }
+        tevent_req_set_callback(subreq, nb_packet_reader_got_ack, req);
+}
+static void nb_packet_reader_got_ack(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_packet_reader_state *state = tevent_req_data(
+                req, struct nb_packet_reader_state);
+        ssize_t nread;
+        int err;
+        uint8_t *buf;
+        nread = read_packet_recv(subreq, state, &buf, &err);
+        TALLOC_FREE(subreq);
+        if (nread == -1) {
+                DEBUG(10, ("read_packet_recv returned %s\n",
+                           strerror(err)));
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                return;
+        }
+        if (nread != sizeof(state->c)) {
+                DEBUG(10, ("read = %d, expected %d\n", (int)nread,
+                           (int)sizeof(state->c)));
+                tevent_req_nterror(req, NT_STATUS_UNEXPECTED_IO_ERROR);
+                return;
+        }
+        tevent_req_done(req);
+}
+NTSTATUS nb_packet_reader_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
+                               struct nb_packet_reader **preader)
+{
+        struct nb_packet_reader_state *state = tevent_req_data(
+                req, struct nb_packet_reader_state);
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        *preader = talloc_move(mem_ctx, &state->reader);
+        return NT_STATUS_OK;
+}
+struct nb_packet_read_state {
+        struct nb_packet_client_header hdr;
+        uint8_t *buf;
+        size_t buflen;
 };
+/****************************************************************************
+ tdb traversal fn to find a matching 137 packet.
+**************************************************************************/
+static int traverse_match(TDB_CONTEXT *ttdb, TDB_DATA kbuf, TDB_DATA dbuf,
+                          void *private_data)
+{
+        struct receive_unexpected_state *state =
+                (struct receive_unexpected_state *)private_data;
+        struct unexpected_key key;
+        struct in_addr ip;
+        uint32_t enc_ip;
+        int port;
+        struct packet_struct *p;
+        if (kbuf.dsize != sizeof(key)) {
+static ssize_t nb_packet_read_more(uint8_t *buf, size_t buflen, void *p);
+static void nb_packet_read_done(struct tevent_req *subreq);
+struct tevent_req *nb_packet_read_send(TALLOC_CTX *mem_ctx,
+                                       struct tevent_context *ev,
+                                       struct nb_packet_reader *reader)
+{
+        struct tevent_req *req, *subreq;
+        struct nb_packet_read_state *state;
+        req = tevent_req_create(mem_ctx, &state, struct nb_packet_read_state);
+        if (req == NULL) {
+                return NULL;
+        }
+        subreq = read_packet_send(state, ev, reader->sock,
+                                  sizeof(struct nb_packet_client_header),
+                                  nb_packet_read_more, state);
+        if (tevent_req_nomem(subreq, req)) {
+                return tevent_req_post(req, ev);
+        }
+        tevent_req_set_callback(subreq, nb_packet_read_done, req);
+        return req;
+}
+static ssize_t nb_packet_read_more(uint8_t *buf, size_t buflen, void *p)
+{
+        struct nb_packet_read_state *state = talloc_get_type_abort(
+                p, struct nb_packet_read_state);
+        if (buflen > sizeof(struct nb_packet_client_header)) {
+                /*
+                 * Been here, done
+                 */
                 return 0;
+        }
+        memcpy(&key, kbuf.dptr, sizeof(key));
+        if (key.packet_type != state->match_type) return 0;
+        if (dbuf.dsize < 6) {
+                return 0;
+        }
+        /* Decode the ip addr and port. */
+        enc_ip = IVAL(dbuf.dptr,0);
+        ip.s_addr = htonl(enc_ip);
+        port = SVAL(dbuf.dptr,4);
+        p = parse_packet((char *)&dbuf.dptr[6],
+                        dbuf.dsize-6,
+                        state->match_type,
+                        ip,
+                        port);
+        if (!p)
+                return 0;
+        if ((state->match_type == NMB_PACKET &&
+             p->packet.nmb.header.name_trn_id == state->match_id) ||
+            (state->match_type == DGRAM_PACKET &&
+             match_mailslot_name(p, state->match_name))) {
+                state->matched_packet = p;
+                return -1;
+        }
+        free_packet(p);
+        return 0;
+}
+/****************************************************************************
+ Check for a particular packet in the unexpected packet queue.
+**************************************************************************/
+struct packet_struct *receive_unexpected(enum packet_type packet_type, int id,
+                                         const char *mailslot_name)
+{
+        TDB_CONTEXT *tdb2;
+        struct receive_unexpected_state state;
+        tdb2 = tdb_open_log(lock_path("unexpected.tdb"), 0, 0, O_RDONLY, 0);
+        if (!tdb2) return NULL;
+        state.matched_packet = NULL;
+        state.match_id = id;
+        state.match_type = packet_type;
+        state.match_name = mailslot_name;
+        tdb_traverse(tdb2, traverse_match, &state);
+        tdb_close(tdb2);
+        return state.matched_packet;
+}
+        memcpy(&state->hdr, buf, sizeof(struct nb_packet_client_header));
+        return state->hdr.len;
+}
+static void nb_packet_read_done(struct tevent_req *subreq)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        struct nb_packet_read_state *state = tevent_req_data(
+                req, struct nb_packet_read_state);
+        ssize_t nread;
+        int err;
+        nread = read_packet_recv(subreq, state, &state->buf, &err);
+        if (nread == -1) {
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                return;
+        }
+        state->buflen = nread;
+        tevent_req_done(req);
+}
+NTSTATUS nb_packet_read_recv(struct tevent_req *req,
+                             struct packet_struct **ppacket)
+{
+        struct nb_packet_read_state *state = tevent_req_data(
+                req, struct nb_packet_read_state);
+        struct nb_packet_client_header hdr;
+        struct packet_struct *packet;
+        NTSTATUS status;
+        if (tevent_req_is_nterror(req, &status)) {
+                return status;
+        }
+        memcpy(&hdr, state->buf, sizeof(hdr));
+        packet = parse_packet(
+                (char *)state->buf + sizeof(struct nb_packet_client_header),
+                state->buflen - sizeof(struct nb_packet_client_header),
+                state->hdr.type, state->hdr.ip, state->hdr.port);
+        if (packet == NULL) {
+                return NT_STATUS_INVALID_NETWORK_RESPONSE;
+        }
+        *ppacket = packet;
+        return NT_STATUS_OK;
+}

Context Navigation

Legend:

Download in other formats: