s3-libsmb: Fix error messages to correctly mention PLAINTEXT not LM
[nivanova/samba-autobuild/.git] / source3 / libsmb / cliconnect.c
index 5881d0cdb89cdc6be5e09b76baa82673fa65a444..f46ce06e4c3ebc96493da6884a01bf2452f63d8f 100644 (file)
 
 #include "includes.h"
 #include "libsmb/libsmb.h"
-#include "popt_common.h"
+#include "auth_info.h"
 #include "../libcli/auth/libcli_auth.h"
 #include "../libcli/auth/spnego.h"
 #include "smb_krb5.h"
-#include "../libcli/auth/ntlmssp.h"
+#include "../auth/ntlmssp/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"
-#include "read_smb.h"
-
-static const struct {
-       int prot;
-       const char name[24];
-} prots[10] = {
-       {PROTOCOL_CORE,         "PC NETWORK PROGRAM 1.0"},
-       {PROTOCOL_COREPLUS,     "MICROSOFT NETWORKS 1.03"},
-       {PROTOCOL_LANMAN1,      "MICROSOFT NETWORKS 3.0"},
-       {PROTOCOL_LANMAN1,      "LANMAN1.0"},
-       {PROTOCOL_LANMAN2,      "LM1.2X002"},
-       {PROTOCOL_LANMAN2,      "DOS LANMAN2.1"},
-       {PROTOCOL_LANMAN2,      "LANMAN2.1"},
-       {PROTOCOL_LANMAN2,      "Samba"},
-       {PROTOCOL_NT1,          "NT LANMAN 1.0"},
-       {PROTOCOL_NT1,          "NT LM 0.12"},
-};
+#include "librpc/ndr/libndr.h"
+#include "../libcli/smb/smbXcli_base.h"
+#include "smb2cli.h"
 
 #define STAR_SMBSERVER "*SMBSERVER"
 
@@ -60,15 +46,15 @@ static const struct {
 *******************************************************/
 
 static NTSTATUS smb_bytes_talloc_string(TALLOC_CTX *mem_ctx,
-                                       char *inbuf,
+                                       const uint8_t *hdr,
                                        char **dest,
                                        uint8_t *src,
                                        size_t srclen,
                                        ssize_t *destlen)
 {
        *destlen = clistr_pull_talloc(mem_ctx,
-                               inbuf,
-                               SVAL(inbuf, smb_flg2),
+                               (const char *)hdr,
+                               SVAL(hdr, HDR_FLG2),
                                dest,
                                (char *)src,
                                srclen,
@@ -122,7 +108,7 @@ static struct tevent_req *cli_session_setup_lanman2_send(
        uint16_t *vwv;
        uint8_t *bytes;
        char *tmp;
-       uint16_t sec_mode = cli_state_security_mode(cli);
+       uint16_t sec_mode = smb1cli_conn_server_security_mode(cli->conn);
 
        req = tevent_req_create(mem_ctx, &state,
                                struct cli_session_setup_lanman2_state);
@@ -133,16 +119,6 @@ static struct tevent_req *cli_session_setup_lanman2_send(
        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
         */
@@ -162,7 +138,7 @@ static struct tevent_req *cli_session_setup_lanman2_send(
                        return tevent_req_post(req, ev);
                }
 
-               if (!SMBencrypt(pass, cli->secblob.data,
+               if (!SMBencrypt(pass, smb1cli_conn_server_challenge(cli->conn),
                                (uint8_t *)lm_response.data)) {
                        DEBUG(1, ("Password is > 14 chars in length, and is "
                                  "therefore incompatible with Lanman "
@@ -187,7 +163,7 @@ static struct tevent_req *cli_session_setup_lanman2_send(
                 * 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,
+               buf = smb_bytes_push_str(buf, smbXcli_conn_use_unicode(cli->conn), pass, passlen+1,
                                         &converted_size);
                if (tevent_req_nomem(buf, req)) {
                        return tevent_req_post(req, ev);
@@ -205,7 +181,7 @@ static struct tevent_req *cli_session_setup_lanman2_send(
        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
        SSVAL(vwv+3, 0, 2);
        SSVAL(vwv+4, 0, 1);
-       SIVAL(vwv+5, 0, cli_state_server_session_key(cli));
+       SIVAL(vwv+5, 0, smb1cli_conn_server_session_key(cli->conn));
        SSVAL(vwv+7, 0, lm_response.length);
 
        bytes = talloc_array(state, uint8_t, lm_response.length);
@@ -221,7 +197,7 @@ static struct tevent_req *cli_session_setup_lanman2_send(
        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,
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), tmp, strlen(tmp)+1,
                                   NULL);
        TALLOC_FREE(tmp);
 
@@ -229,10 +205,10 @@ static struct tevent_req *cli_session_setup_lanman2_send(
        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,
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), 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);
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "Unix", 5, NULL);
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "Samba", 6, NULL);
 
        if (tevent_req_nomem(bytes, req)) {
                return tevent_req_post(req, ev);
@@ -256,7 +232,7 @@ static void cli_session_setup_lanman2_done(struct tevent_req *subreq)
        struct cli_state *cli = state->cli;
        uint32_t num_bytes;
        uint8_t *in;
-       char *inbuf;
+       uint8_t *inhdr;
        uint8_t *bytes;
        uint8_t *p;
        NTSTATUS status;
@@ -272,14 +248,14 @@ static void cli_session_setup_lanman2_done(struct tevent_req *subreq)
                return;
        }
 
-       inbuf = (char *)in;
+       inhdr = in + NBT_HDR_SIZE;
        p = bytes;
 
-       cli_state_set_uid(state->cli, SVAL(inbuf, smb_uid));
+       cli_state_set_uid(state->cli, SVAL(inhdr, HDR_UID));
        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_os,
                                        p,
                                        bytes+num_bytes-p,
@@ -292,7 +268,7 @@ static void cli_session_setup_lanman2_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_type,
                                        p,
                                        bytes+num_bytes-p,
@@ -305,7 +281,7 @@ static void cli_session_setup_lanman2_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_domain,
                                        p,
                                        bytes+num_bytes-p,
@@ -317,9 +293,6 @@ static void cli_session_setup_lanman2_done(struct tevent_req *subreq)
        }
        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;
@@ -341,7 +314,7 @@ static NTSTATUS cli_session_setup_lanman2(struct cli_state *cli, const char *use
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                /*
                 * Can't use sync call while an async call is in flight
                 */
@@ -370,18 +343,31 @@ static NTSTATUS cli_session_setup_lanman2(struct cli_state *cli, const char *use
  Work out suitable capabilities to offer the server.
 ****************************************************************************/
 
-static uint32 cli_session_setup_capabilities(struct cli_state *cli)
+static uint32_t cli_session_setup_capabilities(struct cli_state *cli,
+                                              uint32_t sesssetup_capabilities)
 {
-       uint32 capabilities = CAP_NT_SMBS;
+       uint32_t client_capabilities = smb1cli_conn_capabilities(cli->conn);
 
-       if (!cli->force_dos_errors)
-               capabilities |= CAP_STATUS32;
+       /*
+        * We only send capabilities based on the mask for:
+        * - client only flags
+        * - flags used in both directions
+        *
+        * We do not echo the server only flags.
+        */
+       client_capabilities &= (SMB_CAP_BOTH_MASK | SMB_CAP_CLIENT_MASK);
 
-       if (cli->use_level_II_oplocks)
-               capabilities |= CAP_LEVEL_II_OPLOCKS;
+       /*
+        * Session Setup specific flags CAP_DYNAMIC_REAUTH
+        * and CAP_EXTENDED_SECURITY are passed by the caller.
+        * We need that in order to do guest logins even if
+        * CAP_EXTENDED_SECURITY is negotiated.
+        */
+       client_capabilities &= ~(CAP_DYNAMIC_REAUTH|CAP_EXTENDED_SECURITY);
+       sesssetup_capabilities &= (CAP_DYNAMIC_REAUTH|CAP_EXTENDED_SECURITY);
+       client_capabilities |= sesssetup_capabilities;
 
-       capabilities |= (cli_state_capabilities(cli) & (CAP_UNICODE|CAP_LARGE_FILES|CAP_LARGE_READX|CAP_LARGE_WRITEX|CAP_DFS));
-       return capabilities;
+       return client_capabilities;
 }
 
 /****************************************************************************
@@ -420,21 +406,21 @@ struct tevent_req *cli_session_setup_guest_create(TALLOC_CTX *mem_ctx,
        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
        SSVAL(vwv+3, 0, 2);
        SSVAL(vwv+4, 0, cli_state_get_vc_num(cli));
-       SIVAL(vwv+5, 0, cli_state_server_session_key(cli));
+       SIVAL(vwv+5, 0, smb1cli_conn_server_session_key(cli->conn));
        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));
+       SIVAL(vwv+11, 0, cli_session_setup_capabilities(cli, 0));
 
        bytes = talloc_array(state, uint8_t, 0);
 
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "",  1, /* username */
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "",  1, /* username */
                                   NULL);
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), "", 1, /* workgroup */
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "", 1, /* workgroup */
                                   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);
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "Unix", 5, NULL);
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "Samba", 6, NULL);
 
        if (bytes == NULL) {
                TALLOC_FREE(req);
@@ -467,7 +453,7 @@ struct tevent_req *cli_session_setup_guest_send(TALLOC_CTX *mem_ctx,
                return NULL;
        }
 
-       status = cli_smb_req_send(subreq);
+       status = smb1cli_req_chain_submit(&subreq, 1);
        if (NT_STATUS_IS_OK(status)) {
                tevent_req_nterror(req, status);
                return tevent_req_post(req, ev);
@@ -484,7 +470,7 @@ static void cli_session_setup_guest_done(struct tevent_req *subreq)
        struct cli_state *cli = state->cli;
        uint32_t num_bytes;
        uint8_t *in;
-       char *inbuf;
+       uint8_t *inhdr;
        uint8_t *bytes;
        uint8_t *p;
        NTSTATUS status;
@@ -500,14 +486,14 @@ static void cli_session_setup_guest_done(struct tevent_req *subreq)
                return;
        }
 
-       inbuf = (char *)in;
+       inhdr = in + NBT_HDR_SIZE;
        p = bytes;
 
-       cli_state_set_uid(state->cli, SVAL(inbuf, smb_uid));
+       cli_state_set_uid(state->cli, SVAL(inhdr, HDR_UID));
        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_os,
                                        p,
                                        bytes+num_bytes-p,
@@ -520,7 +506,7 @@ static void cli_session_setup_guest_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_type,
                                        p,
                                        bytes+num_bytes-p,
@@ -533,7 +519,7 @@ static void cli_session_setup_guest_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_domain,
                                        p,
                                        bytes+num_bytes-p,
@@ -545,10 +531,6 @@ static void cli_session_setup_guest_done(struct tevent_req *subreq)
        }
        p += ret;
 
-       if (strstr(cli->server_type, "Samba")) {
-               cli->is_samba = True;
-       }
-
        status = cli_set_username(cli, "");
        if (!NT_STATUS_IS_OK(status)) {
                tevent_req_nterror(req, status);
@@ -569,7 +551,7 @@ static NTSTATUS cli_session_setup_guest(struct cli_state *cli)
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_OK;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                /*
                 * Can't use sync call while an async call is in flight
                 */
@@ -639,26 +621,26 @@ static struct tevent_req *cli_session_setup_plain_send(
        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
        SSVAL(vwv+3, 0, 2);
        SSVAL(vwv+4, 0, cli_state_get_vc_num(cli));
-       SIVAL(vwv+5, 0, cli_state_server_session_key(cli));
+       SIVAL(vwv+5, 0, smb1cli_conn_server_session_key(cli->conn));
        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));
+       SIVAL(vwv+11, 0, cli_session_setup_capabilities(cli, 0));
 
        bytes = talloc_array(state, uint8_t, 0);
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), pass, strlen(pass)+1,
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), 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);
+       SSVAL(vwv + (smbXcli_conn_use_unicode(cli->conn) ? 8 : 7), 0, passlen);
 
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   user, strlen(user)+1, NULL);
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   workgroup, strlen(workgroup)+1, NULL);
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   "Unix", 5, NULL);
 
        version = talloc_asprintf(talloc_tos(), "Samba %s",
@@ -666,7 +648,7 @@ static struct tevent_req *cli_session_setup_plain_send(
        if (tevent_req_nomem(version, req)){
                return tevent_req_post(req, ev);
        }
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   version, strlen(version)+1, NULL);
        TALLOC_FREE(version);
 
@@ -692,7 +674,7 @@ static void cli_session_setup_plain_done(struct tevent_req *subreq)
        struct cli_state *cli = state->cli;
        uint32_t num_bytes;
        uint8_t *in;
-       char *inbuf;
+       uint8_t *inhdr;
        uint8_t *bytes;
        uint8_t *p;
        NTSTATUS status;
@@ -707,14 +689,14 @@ static void cli_session_setup_plain_done(struct tevent_req *subreq)
                return;
        }
 
-       inbuf = (char *)in;
+       inhdr = in + NBT_HDR_SIZE;
        p = bytes;
 
-       cli_state_set_uid(state->cli, SVAL(inbuf, smb_uid));
+       cli_state_set_uid(state->cli, SVAL(inhdr, HDR_UID));
        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_os,
                                        p,
                                        bytes+num_bytes-p,
@@ -727,7 +709,7 @@ static void cli_session_setup_plain_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_type,
                                        p,
                                        bytes+num_bytes-p,
@@ -740,7 +722,7 @@ static void cli_session_setup_plain_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_domain,
                                        p,
                                        bytes+num_bytes-p,
@@ -756,9 +738,7 @@ static void cli_session_setup_plain_done(struct tevent_req *subreq)
        if (tevent_req_nterror(req, status)) {
                return;
        }
-       if (strstr(cli->server_type, "Samba")) {
-               cli->is_samba = True;
-       }
+
        tevent_req_done(req);
 }
 
@@ -776,7 +756,7 @@ static NTSTATUS cli_session_setup_plain(struct cli_state *cli,
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                /*
                 * Can't use sync call while an async call is in flight
                 */
@@ -853,11 +833,9 @@ static struct tevent_req *cli_session_setup_nt1_send(
                        DATA_BLOB server_chal;
                        DATA_BLOB names_blob;
 
-                       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);
-                       }
+                       server_chal =
+                               data_blob_const(smb1cli_conn_server_challenge(cli->conn),
+                                               8);
 
                        /*
                         * note that the 'workgroup' here is a best
@@ -877,13 +855,11 @@ static struct tevent_req *cli_session_setup_nt1_send(
                                              &lm_response, &nt_response,
                                              NULL, &session_key)) {
                                data_blob_free(&names_blob);
-                               data_blob_free(&server_chal);
                                tevent_req_nterror(
                                        req, NT_STATUS_ACCESS_DENIED);
                                return tevent_req_post(req, ev);
                        }
                        data_blob_free(&names_blob);
-                       data_blob_free(&server_chal);
 
                } else {
                        uchar nt_hash[16];
@@ -897,7 +873,7 @@ static struct tevent_req *cli_session_setup_nt1_send(
                                return tevent_req_post(req, ev);
                        }
 
-                       SMBNTencrypt(pass, cli->secblob.data,
+                       SMBNTencrypt(pass, smb1cli_conn_server_challenge(cli->conn),
                                     nt_response.data);
 #endif
                        /* non encrypted password supplied. Ignore ntpass. */
@@ -908,7 +884,8 @@ static struct tevent_req *cli_session_setup_nt1_send(
                                        return tevent_req_post(req, ev);
                                }
 
-                               if (!SMBencrypt(pass,cli->secblob.data,
+                               if (!SMBencrypt(pass,
+                                               smb1cli_conn_server_challenge(cli->conn),
                                                lm_response.data)) {
                                        /*
                                         * Oops, the LM response is
@@ -986,12 +963,12 @@ static struct tevent_req *cli_session_setup_nt1_send(
        SSVAL(vwv+2, 0, CLI_BUFFER_SIZE);
        SSVAL(vwv+3, 0, 2);
        SSVAL(vwv+4, 0, cli_state_get_vc_num(cli));
-       SIVAL(vwv+5, 0, cli_state_server_session_key(cli));
+       SIVAL(vwv+5, 0, smb1cli_conn_server_session_key(cli->conn));
        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));
+       SIVAL(vwv+11, 0, cli_session_setup_capabilities(cli, 0));
 
        bytes = talloc_array(state, uint8_t,
                             lm_response.length + nt_response.length);
@@ -1008,7 +985,7 @@ static struct tevent_req *cli_session_setup_nt1_send(
        data_blob_free(&lm_response);
        data_blob_free(&nt_response);
 
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   user, strlen(user)+1, NULL);
 
        /*
@@ -1018,13 +995,13 @@ static struct tevent_req *cli_session_setup_nt1_send(
        if (tevent_req_nomem(workgroup_upper, req)) {
                return tevent_req_post(req, ev);
        }
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   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);
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "Unix", 5, NULL);
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), "Samba", 6, NULL);
        if (tevent_req_nomem(bytes, req)) {
                return tevent_req_post(req, ev);
        }
@@ -1047,7 +1024,7 @@ static void cli_session_setup_nt1_done(struct tevent_req *subreq)
        struct cli_state *cli = state->cli;
        uint32_t num_bytes;
        uint8_t *in;
-       char *inbuf;
+       uint8_t *inhdr;
        uint8_t *bytes;
        uint8_t *p;
        NTSTATUS status;
@@ -1063,14 +1040,14 @@ static void cli_session_setup_nt1_done(struct tevent_req *subreq)
                return;
        }
 
-       inbuf = (char *)in;
+       inhdr = in + NBT_HDR_SIZE;
        p = bytes;
 
-       cli_state_set_uid(state->cli, SVAL(inbuf, smb_uid));
+       cli_state_set_uid(state->cli, SVAL(inhdr, HDR_UID));
        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_os,
                                        p,
                                        bytes+num_bytes-p,
@@ -1082,7 +1059,7 @@ static void cli_session_setup_nt1_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_type,
                                        p,
                                        bytes+num_bytes-p,
@@ -1094,7 +1071,7 @@ static void cli_session_setup_nt1_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       inbuf,
+                                       inhdr,
                                        &cli->server_domain,
                                        p,
                                        bytes+num_bytes-p,
@@ -1105,16 +1082,12 @@ static void cli_session_setup_nt1_done(struct tevent_req *subreq)
        }
        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;
        }
-       if (cli_simple_set_signing(cli, state->session_key, state->response)
-           && !cli_check_sign_mac(cli, (char *)in, 1)) {
+       if (smb1cli_conn_activate_signing(cli->conn, state->session_key, state->response)
+           && !smb1cli_conn_check_signing(cli->conn, (uint8_t *)in, 1)) {
                tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
                return;
        }
@@ -1140,7 +1113,7 @@ static NTSTATUS cli_session_setup_nt1(struct cli_state *cli, const char *user,
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                /*
                 * Can't use sync call while an async call is in flight
                 */
@@ -1182,8 +1155,11 @@ struct cli_sesssetup_blob_state {
        uint16_t vwv[12];
        uint8_t *buf;
 
+       DATA_BLOB smb2_blob;
+       struct iovec *recv_iov;
+
        NTSTATUS status;
-       char *inbuf;
+       uint8_t *inbuf;
        DATA_BLOB ret_blob;
 };
 
@@ -1209,8 +1185,12 @@ static struct tevent_req *cli_sesssetup_blob_send(TALLOC_CTX *mem_ctx,
        state->blob = blob;
        state->cli = cli;
 
-       usable_space = cli_state_available_size(cli,
+       if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+               usable_space = UINT16_MAX;
+       } else {
+               usable_space = cli_state_available_size(cli,
                                BASE_SESSSETUP_BLOB_PACKET_SIZE);
+       }
 
        if (usable_space == 0) {
                DEBUG(1, ("cli_session_setup_blob: cli->max_xmit too small "
@@ -1235,6 +1215,32 @@ static bool cli_sesssetup_blob_next(struct cli_sesssetup_blob_state *state,
        struct tevent_req *subreq;
        uint16_t thistime;
 
+       thistime = MIN(state->blob.length, state->max_blob_size);
+
+       if (smbXcli_conn_protocol(state->cli->conn) >= PROTOCOL_SMB2_02) {
+
+               state->smb2_blob.data = state->blob.data;
+               state->smb2_blob.length = thistime;
+
+               state->blob.data += thistime;
+               state->blob.length -= thistime;
+
+               subreq = smb2cli_session_setup_send(state, state->ev,
+                                                   state->cli->conn,
+                                                   state->cli->timeout,
+                                                   state->cli->smb2.session,
+                                                   0, /* in_flags */
+                                                   SMB2_CAP_DFS, /* in_capabilities */
+                                                   0, /* in_channel */
+                                                   0, /* in_previous_session_id */
+                                                   &state->smb2_blob);
+               if (subreq == NULL) {
+                       return false;
+               }
+               *psubreq = subreq;
+               return true;
+       }
+
        SCVAL(state->vwv+0, 0, 0xFF);
        SCVAL(state->vwv+0, 1, 0);
        SSVAL(state->vwv+1, 0, 0);
@@ -1243,14 +1249,12 @@ static bool cli_sesssetup_blob_next(struct cli_sesssetup_blob_state *state,
        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);
+               cli_session_setup_capabilities(state->cli, CAP_EXTENDED_SECURITY));
 
        state->buf = (uint8_t *)talloc_memdup(state, state->blob.data,
                                              thistime);
@@ -1260,9 +1264,9 @@ static bool cli_sesssetup_blob_next(struct cli_sesssetup_blob_state *state,
        state->blob.data += thistime;
        state->blob.length -= thistime;
 
-       state->buf = smb_bytes_push_str(state->buf, cli_ucs2(state->cli),
+       state->buf = smb_bytes_push_str(state->buf, smbXcli_conn_use_unicode(state->cli->conn),
                                        "Unix", 5, NULL);
-       state->buf = smb_bytes_push_str(state->buf, cli_ucs2(state->cli),
+       state->buf = smb_bytes_push_str(state->buf, smbXcli_conn_use_unicode(state->cli->conn),
                                        "Samba", 6, NULL);
        if (state->buf == NULL) {
                return false;
@@ -1291,11 +1295,19 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
        NTSTATUS status;
        uint8_t *p;
        uint16_t blob_length;
-       uint8_t *inbuf;
+       uint8_t *in;
+       uint8_t *inhdr;
        ssize_t ret;
 
-       status = cli_smb_recv(subreq, state, &inbuf, 4, &wct, &vwv,
-                             &num_bytes, &bytes);
+       if (smbXcli_conn_protocol(state->cli->conn) >= PROTOCOL_SMB2_02) {
+               status = smb2cli_session_setup_recv(subreq, state,
+                                                   &state->recv_iov,
+                                                   &state->ret_blob);
+       } else {
+               status = cli_smb_recv(subreq, state, &in, 4, &wct, &vwv,
+                                     &num_bytes, &bytes);
+               TALLOC_FREE(state->buf);
+       }
        TALLOC_FREE(subreq);
        if (!NT_STATUS_IS_OK(status)
            && !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
@@ -1304,10 +1316,14 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
        }
 
        state->status = status;
-       TALLOC_FREE(state->buf);
 
-       state->inbuf = (char *)inbuf;
-       cli_state_set_uid(state->cli, SVAL(inbuf, smb_uid));
+       if (smbXcli_conn_protocol(state->cli->conn) >= PROTOCOL_SMB2_02) {
+               goto next;
+       }
+
+       state->inbuf = in;
+       inhdr = in + NBT_HDR_SIZE;
+       cli_state_set_uid(state->cli, SVAL(inhdr, HDR_UID));
        cli->is_guestlogin = ((SVAL(vwv+2, 0) & 1) != 0);
 
        blob_length = SVAL(vwv+3, 0);
@@ -1320,7 +1336,7 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
        p = bytes + blob_length;
 
        status = smb_bytes_talloc_string(cli,
-                                       (char *)inbuf,
+                                       inhdr,
                                        &cli->server_os,
                                        p,
                                        bytes+num_bytes-p,
@@ -1333,7 +1349,7 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       (char *)inbuf,
+                                       inhdr,
                                        &cli->server_type,
                                        p,
                                        bytes+num_bytes-p,
@@ -1346,7 +1362,7 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
        p += ret;
 
        status = smb_bytes_talloc_string(cli,
-                                       (char *)inbuf,
+                                       inhdr,
                                        &cli->server_domain,
                                        p,
                                        bytes+num_bytes-p,
@@ -1358,10 +1374,7 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
        }
        p += ret;
 
-       if (strstr(cli->server_type, "Samba")) {
-               cli->is_samba = True;
-       }
-
+next:
        if (state->blob.length != 0) {
                /*
                 * More to send
@@ -1379,25 +1392,32 @@ static void cli_sesssetup_blob_done(struct tevent_req *subreq)
 static NTSTATUS cli_sesssetup_blob_recv(struct tevent_req *req,
                                        TALLOC_CTX *mem_ctx,
                                        DATA_BLOB *pblob,
-                                       char **pinbuf)
+                                       uint8_t **pinbuf,
+                                       struct iovec **precv_iov)
 {
        struct cli_sesssetup_blob_state *state = tevent_req_data(
                req, struct cli_sesssetup_blob_state);
        NTSTATUS status;
-       char *inbuf;
+       uint8_t *inbuf;
+       struct iovec *recv_iov;
 
        if (tevent_req_is_nterror(req, &status)) {
+               TALLOC_FREE(state->cli->smb2.session);
                cli_state_set_uid(state->cli, UID_FIELD_INVALID);
                return status;
        }
 
        inbuf = talloc_move(mem_ctx, &state->inbuf);
+       recv_iov = talloc_move(mem_ctx, &state->recv_iov);
        if (pblob != NULL) {
                *pblob = state->ret_blob;
        }
        if (pinbuf != NULL) {
                *pinbuf = inbuf;
        }
+       if (precv_iov != NULL) {
+               *precv_iov = recv_iov;
+       }
         /* could be NT_STATUS_MORE_PROCESSING_REQUIRED */
        return state->status;
 }
@@ -1463,6 +1483,14 @@ static struct tevent_req *cli_session_setup_kerberos_send(
                  state->negTokenTarg.length);
 #endif
 
+       if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+               state->cli->smb2.session = smbXcli_session_create(cli,
+                                                                 cli->conn);
+               if (tevent_req_nomem(state->cli->smb2.session, req)) {
+                       return tevent_req_post(req, ev);
+               }
+       }
+
        subreq = cli_sesssetup_blob_send(state, ev, cli, state->negTokenTarg);
        if (tevent_req_nomem(subreq, req)) {
                return tevent_req_post(req, ev);
@@ -1477,26 +1505,37 @@ static void cli_session_setup_kerberos_done(struct tevent_req *subreq)
                subreq, struct tevent_req);
        struct cli_session_setup_kerberos_state *state = tevent_req_data(
                req, struct cli_session_setup_kerberos_state);
-       char *inbuf = NULL;
+       uint8_t *inbuf = NULL;
+       struct iovec *recv_iov = NULL;
        NTSTATUS status;
 
-       status = cli_sesssetup_blob_recv(subreq, talloc_tos(), NULL, &inbuf);
+       status = cli_sesssetup_blob_recv(subreq, state,
+                                        NULL, &inbuf, &recv_iov);
+       TALLOC_FREE(subreq);
        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;
+       if (smbXcli_conn_protocol(state->cli->conn) >= PROTOCOL_SMB2_02) {
+               struct smbXcli_session *session = state->cli->smb2.session;
+               status = smb2cli_session_set_session_key(session,
+                                               state->session_key_krb5,
+                                               recv_iov);
+               if (tevent_req_nterror(req, status)) {
+                       return;
+               }
+       } else {
+               if (smb1cli_conn_activate_signing(state->cli->conn, state->session_key_krb5,
+                                          data_blob_null)
+                   && !smb1cli_conn_check_signing(state->cli->conn, inbuf, 1)) {
+                       tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
+                       return;
+               }
        }
-       TALLOC_FREE(subreq);
+
        tevent_req_done(req);
 }
 
@@ -1519,7 +1558,7 @@ static ADS_STATUS cli_session_setup_kerberos(struct cli_state *cli,
        struct tevent_req *req;
        ADS_STATUS status = ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                return ADS_ERROR_NT(NT_STATUS_INVALID_PARAMETER);
        }
        ev = tevent_context_init(talloc_tos());
@@ -1622,6 +1661,14 @@ static struct tevent_req *cli_session_setup_ntlmssp_send(
        state->blob_out = spnego_gen_negTokenInit(state, OIDs_ntlm, &blob_out, NULL);
        data_blob_free(&blob_out);
 
+       if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+               state->cli->smb2.session = smbXcli_session_create(cli,
+                                                                 cli->conn);
+               if (tevent_req_nomem(state->cli->smb2.session, req)) {
+                       return tevent_req_post(req, ev);
+               }
+       }
+
        subreq = cli_sesssetup_blob_send(state, ev, cli, state->blob_out);
        if (tevent_req_nomem(subreq, req)) {
                return tevent_req_post(req, ev);
@@ -1640,12 +1687,13 @@ static void cli_session_setup_ntlmssp_done(struct tevent_req *subreq)
        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;
+       uint8_t *inbuf = NULL;
+       struct iovec *recv_iov = NULL;
        bool parse_ret;
        NTSTATUS status;
 
        status = cli_sesssetup_blob_recv(subreq, talloc_tos(), &blob_in,
-                                        &inbuf);
+                                        &inbuf, &recv_iov);
        TALLOC_FREE(subreq);
        data_blob_free(&state->blob_out);
 
@@ -1655,7 +1703,6 @@ static void cli_session_setup_ntlmssp_done(struct tevent_req *subreq)
                        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;
                        }
@@ -1663,15 +1710,39 @@ static void cli_session_setup_ntlmssp_done(struct tevent_req *subreq)
                cli_set_session_key(
                        state->cli, state->ntlmssp_state->session_key);
 
-               if (cli_simple_set_signing(
-                           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;
+               if (smbXcli_conn_protocol(state->cli->conn) >= PROTOCOL_SMB2_02) {
+                       struct smbXcli_session *session = state->cli->smb2.session;
+
+                       if (ntlmssp_is_anonymous(state->ntlmssp_state)) {
+                               /*
+                                * Windows server does not set the
+                                * SMB2_SESSION_FLAG_IS_GUEST nor
+                                * SMB2_SESSION_FLAG_IS_NULL flag.
+                                *
+                                * This fix makes sure we do not try
+                                * to verify a signature on the final
+                                * session setup response.
+                                */
+                               TALLOC_FREE(state->ntlmssp_state);
+                               tevent_req_done(req);
+                               return;
+                       }
+
+                       status = smb2cli_session_set_session_key(session,
+                                               state->ntlmssp_state->session_key,
+                                               recv_iov);
+                       if (tevent_req_nterror(req, status)) {
+                               return;
+                       }
+               } else {
+                       if (smb1cli_conn_activate_signing(
+                                   state->cli->conn, state->ntlmssp_state->session_key,
+                                   data_blob_null)
+                           && !smb1cli_conn_check_signing(state->cli->conn, inbuf, 1)) {
+                               tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
+                               return;
+                       }
                }
-               TALLOC_FREE(subreq);
                TALLOC_FREE(state->ntlmssp_state);
                tevent_req_done(req);
                return;
@@ -1714,14 +1785,12 @@ static void cli_session_setup_ntlmssp_done(struct tevent_req *subreq)
 
        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;
        }
@@ -1756,7 +1825,7 @@ static NTSTATUS cli_session_setup_ntlmssp(struct cli_state *cli,
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                return NT_STATUS_INVALID_PARAMETER;
        }
        ev = tevent_context_init(talloc_tos());
@@ -1792,15 +1861,21 @@ static ADS_STATUS cli_session_setup_spnego(struct cli_state *cli,
        char *principal = NULL;
        char *OIDs[ASN1_MAX_OIDS];
        int i;
-       DATA_BLOB blob;
+       const DATA_BLOB *server_blob;
+       DATA_BLOB blob = data_blob_null;
        const char *p = NULL;
        char *account = NULL;
        NTSTATUS status;
 
-       DEBUG(3,("Doing spnego session setup (blob length=%lu)\n", (unsigned long)cli->secblob.length));
+       server_blob = smbXcli_conn_server_gss_blob(cli->conn);
+       if (server_blob) {
+               blob = data_blob(server_blob->data, server_blob->length);
+       }
+
+       DEBUG(3,("Doing spnego session setup (blob length=%lu)\n", (unsigned long)blob.length));
 
        /* the server might not even do spnego */
-       if (cli->secblob.length <= 16) {
+       if (blob.length == 0) {
                DEBUG(3,("server didn't supply a full spnego negprot\n"));
                goto ntlmssp;
        }
@@ -1809,9 +1884,6 @@ static ADS_STATUS cli_session_setup_spnego(struct cli_state *cli,
        file_save("negprot.dat", cli->secblob.data, cli->secblob.length);
 #endif
 
-       /* there is 16 bytes of GUID before the real spnego packet starts */
-       blob = data_blob(cli->secblob.data+16, cli->secblob.length-16);
-
        /* The server sent us the first part of the SPNEGO exchange in the
         * negprot reply. It is WRONG to depend on the principal sent in the
         * negprot reply, but right now we do it. If we don't receive one,
@@ -1848,9 +1920,9 @@ static ADS_STATUS cli_session_setup_spnego(struct cli_state *cli,
        /* If password is set we reauthenticate to kerberos server
         * and do not store results */
 
-       if (cli->got_kerberos_mechanism && cli->use_kerberos) {
+       if (user && *user && cli->got_kerberos_mechanism && cli->use_kerberos) {
                ADS_STATUS rc;
-               const char *remote_name = cli_state_remote_name(cli);
+               const char *remote_name = smbXcli_conn_remote_name(cli->conn);
 
                if (pass && *pass) {
                        int ret;
@@ -1877,56 +1949,31 @@ static ADS_STATUS cli_session_setup_spnego(struct cli_state *cli,
                        !is_ipaddress(remote_name) &&
                        !strequal(STAR_SMBSERVER,
                                  remote_name)) {
-                       char *realm = NULL;
-                       char *host = NULL;
                        DEBUG(3,("cli_session_setup_spnego: using target "
                                 "hostname not SPNEGO principal\n"));
 
-                       host = strchr_m(remote_name, '.');
                        if (dest_realm) {
-                               realm = SMB_STRDUP(dest_realm);
-                               if (!realm) {
-                                       return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
+                               char *realm = strupper_talloc(talloc_tos(), dest_realm);
+                               if (realm) {
+                                       principal = talloc_asprintf(talloc_tos(),
+                                                                   "cifs/%s@%s",
+                                                                   remote_name,
+                                                                   realm);
+                                       TALLOC_FREE(realm);
                                }
-                               strupper_m(realm);
                        } else {
-                               if (host) {
-                                       /* DNS name. */
-                                       realm = kerberos_get_realm_from_hostname(remote_name);
-                               } else {
-                                       /* NetBIOS name - use our realm. */
-                                       realm = kerberos_get_default_realm_from_ccache();
-                               }
-                       }
-
-                       if (realm == NULL || *realm == '\0') {
-                               realm = SMB_STRDUP(lp_realm());
-                               if (!realm) {
-                                       return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
-                               }
-                               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>",
-                                       remote_name,
-                                       realm));
+                               principal = kerberos_get_principal_from_service_hostname(talloc_tos(),
+                                                                                        "cifs",
+                                                                                        remote_name,
+                                                                                        lp_realm());
                        }
 
-                       principal = talloc_asprintf(talloc_tos(),
-                                                   "cifs/%s@%s",
-                                                   remote_name,
-                                                   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);
                }
 
                if (principal) {
@@ -1972,7 +2019,7 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
 {
        char *p;
        char *user2;
-       uint16_t sec_mode = cli_state_security_mode(cli);
+       uint16_t sec_mode = smb1cli_conn_server_security_mode(cli->conn);
 
        if (user) {
                user2 = talloc_strdup(talloc_tos(), user);
@@ -1996,20 +2043,7 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
                workgroup = user2;
        }
 
-       if (cli_state_protocol(cli) < PROTOCOL_LANMAN1) {
-               /*
-                * Ensure cli->server_domain,
-                * cli->server_os and cli->server_type
-                * are valid pointers.
-                */
-               cli->server_domain = talloc_strdup(cli, "");
-               cli->server_os = talloc_strdup(cli, "");
-               cli->server_type = talloc_strdup(cli, "");
-               if (cli->server_domain == NULL ||
-                               cli->server_os == NULL ||
-                               cli->server_type == NULL) {
-                       return NT_STATUS_NO_MEMORY;
-               }
+       if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_LANMAN1) {
                return NT_STATUS_OK;
        }
 
@@ -2019,7 +2053,7 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
 
        /* if its an older server then we have to use the older request format */
 
-       if (cli_state_protocol(cli) < PROTOCOL_NT1) {
+       if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_NT1) {
                if (!lp_client_lanman_auth() && passlen != 24 && (*pass)) {
                        DEBUG(1, ("Server requested LM password but 'client lanman auth = no'"
                                  " or 'client ntlmv2 auth = yes'\n"));
@@ -2028,7 +2062,7 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
 
                if ((sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0 &&
                    !lp_client_plaintext_auth() && (*pass)) {
-                       DEBUG(1, ("Server requested LM password but 'client plaintext auth = no'"
+                       DEBUG(1, ("Server requested PLAINTEXT password but 'client plaintext auth = no'"
                                  " or 'client ntlmv2 auth = yes'\n"));
                        return NT_STATUS_ACCESS_DENIED;
                }
@@ -2037,6 +2071,18 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
                                                 workgroup);
        }
 
+       if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+               const char *remote_realm = cli_state_remote_realm(cli);
+               ADS_STATUS status = cli_session_setup_spnego(cli, user, pass,
+                                                            workgroup,
+                                                            remote_realm);
+               if (!ADS_ERR_OK(status)) {
+                       DEBUG(3, ("SMB2-SPNEGO login failed: %s\n", ads_errstr(status)));
+                       return ads_ntstatus(status);
+               }
+               return NT_STATUS_OK;
+       }
+
        /* if no user is supplied then we have to do an anonymous connection.
           passwords are ignored */
 
@@ -2055,7 +2101,7 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
 
        if ((sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) == 0) {
                if (!lp_client_plaintext_auth() && (*pass)) {
-                       DEBUG(1, ("Server requested LM password but 'client plaintext auth = no'"
+                       DEBUG(1, ("Server requested PLAINTEXT password but 'client plaintext auth = no'"
                                  " or 'client ntlmv2 auth = yes'\n"));
                        return NT_STATUS_ACCESS_DENIED;
                }
@@ -2064,7 +2110,7 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
 
        /* if the server supports extended security then use SPNEGO */
 
-       if (cli_state_capabilities(cli) & CAP_EXTENDED_SECURITY) {
+       if (smb1cli_conn_capabilities(cli->conn) & CAP_EXTENDED_SECURITY) {
                const char *remote_realm = cli_state_remote_realm(cli);
                ADS_STATUS status = cli_session_setup_spnego(cli, user, pass,
                                                             workgroup,
@@ -2086,10 +2132,6 @@ NTSTATUS cli_session_setup(struct cli_state *cli,
                }
        }
 
-       if (strstr(cli->server_type, "Samba")) {
-               cli->is_samba = True;
-       }
-
        return NT_STATUS_OK;
 }
 
@@ -2158,7 +2200,7 @@ NTSTATUS cli_ulogoff(struct cli_state *cli)
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                return NT_STATUS_INVALID_PARAMETER;
        }
        ev = tevent_context_init(talloc_tos());
@@ -2203,7 +2245,7 @@ struct tevent_req *cli_tcon_andx_create(TALLOC_CTX *mem_ctx,
        uint16_t *vwv;
        char *tmp = NULL;
        uint8_t *bytes;
-       uint16_t sec_mode = cli_state_security_mode(cli);
+       uint16_t sec_mode = smb1cli_conn_server_security_mode(cli->conn);
 
        *psmbreq = NULL;
 
@@ -2242,7 +2284,7 @@ struct tevent_req *cli_tcon_andx_create(TALLOC_CTX *mem_ctx,
                 * Non-encrypted passwords - convert to DOS codepage before
                 * encryption.
                 */
-               SMBencrypt(pass, cli->secblob.data, p24);
+               SMBencrypt(pass, smb1cli_conn_server_challenge(cli->conn), p24);
                passlen = 24;
                pass = (const char *)p24;
        } else {
@@ -2252,9 +2294,9 @@ struct tevent_req *cli_tcon_andx_create(TALLOC_CTX *mem_ctx,
                        uint8_t *tmp_pass;
 
                        if (!lp_client_plaintext_auth() && (*pass)) {
-                               DEBUG(1, ("Server requested plaintext "
+                               DEBUG(1, ("Server requested PLAINTEXT "
                                          "password but "
-                                         "'client lanman auth = no' or 'client ntlmv2 auth = yes'\n"));
+                                         "'client plaintext auth = no' or 'client ntlmv2 auth = yes'\n"));
                                goto access_denied;
                        }
 
@@ -2295,12 +2337,12 @@ struct tevent_req *cli_tcon_andx_create(TALLOC_CTX *mem_ctx,
         * Add the sharename
         */
        tmp = talloc_asprintf_strupper_m(talloc_tos(), "\\\\%s\\%s",
-                                        cli_state_remote_name(cli), share);
+                                        smbXcli_conn_remote_name(cli->conn), share);
        if (tmp == NULL) {
                TALLOC_FREE(req);
                return NULL;
        }
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli), tmp, strlen(tmp)+1,
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn), tmp, strlen(tmp)+1,
                                   NULL);
        TALLOC_FREE(tmp);
 
@@ -2355,7 +2397,7 @@ struct tevent_req *cli_tcon_andx_send(TALLOC_CTX *mem_ctx,
        if (subreq == NULL) {
                return req;
        }
-       status = cli_smb_req_send(subreq);
+       status = smb1cli_req_chain_submit(&subreq, 1);
        if (!NT_STATUS_IS_OK(status)) {
                tevent_req_nterror(req, status);
                return tevent_req_post(req, ev);
@@ -2371,7 +2413,7 @@ static void cli_tcon_andx_done(struct tevent_req *subreq)
                req, struct cli_tcon_andx_state);
        struct cli_state *cli = state->cli;
        uint8_t *in;
-       char *inbuf;
+       uint8_t *inhdr;
        uint8_t wct;
        uint16_t *vwv;
        uint32_t num_bytes;
@@ -2386,12 +2428,12 @@ static void cli_tcon_andx_done(struct tevent_req *subreq)
                return;
        }
 
-       inbuf = (char *)in;
+       inhdr = in + NBT_HDR_SIZE;
 
        if (num_bytes) {
                if (clistr_pull_talloc(cli,
-                               inbuf,
-                               SVAL(inbuf, smb_flg2),
+                               (const char *)inhdr,
+                               SVAL(inhdr, HDR_FLG2),
                                &cli->dev,
                                bytes,
                                num_bytes,
@@ -2407,7 +2449,7 @@ static void cli_tcon_andx_done(struct tevent_req *subreq)
                }
        }
 
-       if ((cli_state_protocol(cli) >= PROTOCOL_NT1) && (num_bytes == 3)) {
+       if ((smbXcli_conn_protocol(cli->conn) >= PROTOCOL_NT1) && (num_bytes == 3)) {
                /* almost certainly win95 - enable bug fixes */
                cli->win95 = True;
        }
@@ -2419,11 +2461,11 @@ static void cli_tcon_andx_done(struct tevent_req *subreq)
 
        cli->dfsroot = false;
 
-       if ((wct > 2) && (cli_state_protocol(cli) >= PROTOCOL_LANMAN2)) {
+       if ((wct > 2) && (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_LANMAN2)) {
                cli->dfsroot = ((SVAL(vwv+2, 0) & SMB_SHARE_IN_DFS) != 0);
        }
 
-       cli->smb1.tid = SVAL(inbuf,smb_tid);
+       cli->smb1.tid = SVAL(inhdr, HDR_TID);
        tevent_req_done(req);
 }
 
@@ -2440,7 +2482,7 @@ NTSTATUS cli_tcon_andx(struct cli_state *cli, const char *share,
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_OK;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                /*
                 * Can't use sync call while an async call is in flight
                 */
@@ -2471,6 +2513,35 @@ NTSTATUS cli_tcon_andx(struct cli_state *cli, const char *share,
        return status;
 }
 
+NTSTATUS cli_tree_connect(struct cli_state *cli, const char *share,
+                         const char *dev, const char *pass, int passlen)
+{
+       NTSTATUS status;
+       uint16_t max_xmit = 0;
+       uint16_t tid = 0;
+
+       cli->share = talloc_strdup(cli, share);
+       if (!cli->share) {
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+               return smb2cli_tcon(cli, share);
+       }
+
+       if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_LANMAN1) {
+               return cli_tcon_andx(cli, share, dev, pass, passlen);
+       }
+
+       status = cli_raw_tcon(cli, share, pass, dev, &max_xmit, &tid);
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
+       }
+       cli->smb1.tid = tid;
+
+       return NT_STATUS_OK;
+}
+
 /****************************************************************************
  Send a tree disconnect.
 ****************************************************************************/
@@ -2531,7 +2602,7 @@ NTSTATUS cli_tdis(struct cli_state *cli)
        struct tevent_req *req;
        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
-       if (cli_has_async_calls(cli)) {
+       if (smbXcli_conn_has_async_calls(cli->conn)) {
                return NT_STATUS_INVALID_PARAMETER;
        }
        ev = tevent_context_init(talloc_tos());
@@ -2551,265 +2622,6 @@ fail:
        return status;
 }
 
-/****************************************************************************
- Send a negprot command.
-****************************************************************************/
-
-struct cli_negprot_state {
-       struct cli_state *cli;
-};
-
-static void cli_negprot_done(struct tevent_req *subreq);
-
-struct tevent_req *cli_negprot_send(TALLOC_CTX *mem_ctx,
-                                   struct event_context *ev,
-                                   struct cli_state *cli)
-{
-       struct tevent_req *req, *subreq;
-       struct cli_negprot_state *state;
-       uint8_t *bytes = NULL;
-       int numprots;
-
-       req = tevent_req_create(mem_ctx, &state, struct cli_negprot_state);
-       if (req == NULL) {
-               return NULL;
-       }
-       state->cli = cli;
-
-       if (cli_state_protocol(cli) < PROTOCOL_NT1)
-               cli->use_spnego = False;
-
-       /* setup the protocol strings */
-       for (numprots=0; numprots < ARRAY_SIZE(prots); numprots++) {
-               uint8_t c = 2;
-               if (prots[numprots].prot > cli_state_protocol(cli)) {
-                       break;
-               }
-               bytes = (uint8_t *)talloc_append_blob(
-                       state, bytes, data_blob_const(&c, sizeof(c)));
-               if (tevent_req_nomem(bytes, req)) {
-                       return tevent_req_post(req, ev);
-               }
-               bytes = smb_bytes_push_str(bytes, false,
-                                          prots[numprots].name,
-                                          strlen(prots[numprots].name)+1,
-                                          NULL);
-               if (tevent_req_nomem(bytes, req)) {
-                       return tevent_req_post(req, ev);
-               }
-       }
-
-       subreq = cli_smb_send(state, ev, cli, SMBnegprot, 0, 0, NULL,
-                             talloc_get_size(bytes), bytes);
-
-       if (tevent_req_nomem(subreq, req)) {
-               return tevent_req_post(req, ev);
-       }
-       tevent_req_set_callback(subreq, cli_negprot_done, req);
-       return req;
-}
-
-static void cli_negprot_done(struct tevent_req *subreq)
-{
-       struct tevent_req *req = tevent_req_callback_data(
-               subreq, struct tevent_req);
-       struct cli_negprot_state *state = tevent_req_data(
-               req, struct cli_negprot_state);
-       struct cli_state *cli = state->cli;
-       uint8_t wct;
-       uint16_t *vwv;
-       uint32_t num_bytes;
-       uint8_t *bytes;
-       NTSTATUS status;
-       uint16_t protnum;
-       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;
-       }
-
-       protnum = SVAL(vwv, 0);
-
-       if ((protnum >= ARRAY_SIZE(prots))
-           || (prots[protnum].prot > cli_state_protocol(cli))) {
-               tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
-               return;
-       }
-
-       cli->protocol = prots[protnum].prot;
-
-       if ((cli_state_protocol(cli) < PROTOCOL_NT1) &&
-           client_is_signing_mandatory(cli)) {
-               DEBUG(0,("cli_negprot: SMB signing is mandatory and the selected protocol level doesn't support it.\n"));
-               tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
-               return;
-       }
-
-       if (cli_state_protocol(cli) >= PROTOCOL_NT1) {
-               struct timespec ts;
-               const char *client_signing = NULL;
-               bool server_mandatory;
-               bool server_allowed;
-               const char *server_signing = NULL;
-               bool ok;
-
-               if (wct != 0x11) {
-                       tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
-                       return;
-               }
-
-               /* NT protocol */
-               cli->sec_mode = CVAL(vwv + 1, 0);
-               cli->max_mux = SVAL(vwv + 1, 1);
-               cli->max_xmit = IVAL(vwv + 3, 1);
-               cli->sesskey = IVAL(vwv + 7, 1);
-               cli->serverzone = SVALS(vwv + 15, 1);
-               cli->serverzone *= 60;
-               /* this time arrives in real GMT */
-               ts = interpret_long_date(((char *)(vwv+11))+1);
-               cli->servertime = ts.tv_sec;
-               cli->secblob = data_blob(bytes, num_bytes);
-               cli->capabilities = IVAL(vwv + 9, 1);
-               if (cli_state_capabilities(cli) & CAP_RAW_MODE) {
-                       cli->readbraw_supported = True;
-                       cli->writebraw_supported = True;      
-               }
-               /* work out if they sent us a workgroup */
-               if (!(cli_state_capabilities(cli) & CAP_EXTENDED_SECURITY) &&
-                   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;
-                       }
-               }
-
-               client_signing = "disabled";
-               if (client_is_signing_allowed(cli)) {
-                       client_signing = "allowed";
-               }
-               if (client_is_signing_mandatory(cli)) {
-                       client_signing = "required";
-               }
-
-               server_signing = "not supported";
-               if (cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_ENABLED) {
-                       server_signing = "supported";
-                       server_allowed = true;
-               }
-               if (cli->sec_mode & NEGOTIATE_SECURITY_SIGNATURES_REQUIRED) {
-                       server_signing = "required";
-                       server_mandatory = true;
-               }
-
-               ok = cli_set_signing_negotiated(cli,
-                                               server_allowed,
-                                               server_mandatory);
-               if (!ok) {
-                       DEBUG(1,("cli_negprot: SMB signing is required, "
-                                "but client[%s] and server[%s] mismatch\n",
-                                client_signing, server_signing));
-                       tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
-                       return;
-               }
-
-       } else if (cli_state_protocol(cli) >= PROTOCOL_LANMAN1) {
-               if (wct != 0x0D) {
-                       tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
-                       return;
-               }
-
-               cli->use_spnego = False;
-               cli->sec_mode = SVAL(vwv + 1, 0);
-               cli->max_xmit = SVAL(vwv + 2, 0);
-               cli->max_mux = SVAL(vwv + 3, 0);
-               cli->sesskey = IVAL(vwv + 6, 0);
-               cli->serverzone = SVALS(vwv + 10, 0);
-               cli->serverzone *= 60;
-               /* this time is converted to GMT by make_unix_date */
-               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);
-               cli->secblob = data_blob(bytes, num_bytes);
-       } else {
-               /* the old core protocol */
-               cli->use_spnego = False;
-               cli->sec_mode = 0;
-               cli->serverzone = get_time_zone(time(NULL));
-               cli->max_xmit = 1024;
-               cli->max_mux = 1;
-       }
-
-       if (cli->max_xmit < 1024) {
-               tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
-               return;
-       }
-
-       if (cli->max_mux < 1) {
-               tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
-               return;
-       }
-
-       cli->max_xmit = MIN(cli->max_xmit, CLI_BUFFER_SIZE);
-
-       /* a way to force ascii SMB */
-       if (cli->force_ascii) {
-               cli->capabilities &= ~CAP_UNICODE;
-       }
-
-       tevent_req_done(req);
-}
-
-NTSTATUS cli_negprot_recv(struct tevent_req *req)
-{
-       return tevent_req_simple_recv_ntstatus(req);
-}
-
-NTSTATUS cli_negprot(struct cli_state *cli)
-{
-       TALLOC_CTX *frame = talloc_stackframe();
-       struct event_context *ev;
-       struct tevent_req *req;
-       NTSTATUS status = NT_STATUS_OK;
-
-       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) {
-               status = NT_STATUS_NO_MEMORY;
-               goto fail;
-       }
-
-       req = cli_negprot_send(frame, ev, cli);
-       if (req == NULL) {
-               status = NT_STATUS_NO_MEMORY;
-               goto fail;
-       }
-
-       if (!tevent_req_poll(req, ev)) {
-               status = map_nt_error_from_unix(errno);
-               goto fail;
-       }
-
-       status = cli_negprot_recv(req);
- fail:
-       TALLOC_FREE(frame);
-       return status;
-}
-
 static NTSTATUS cli_connect_sock(const char *host, int name_type,
                                 const struct sockaddr_storage *pss,
                                 const char *myname, uint16_t port,
@@ -2915,6 +2727,8 @@ NTSTATUS cli_connect_nb(const char *host, const struct sockaddr_storage *dest_ss
 
        cli = cli_state_create(NULL, fd, desthost, NULL, signing_state, flags);
        if (cli == NULL) {
+               close(fd);
+               fd = -1;
                goto fail;
        }
 
@@ -2949,7 +2763,8 @@ NTSTATUS cli_start_connection(struct cli_state **output_cli,
                return nt_status;
        }
 
-       nt_status = cli_negprot(cli);
+       nt_status = smbXcli_negprot(cli->conn, cli->timeout, PROTOCOL_CORE,
+                                   PROTOCOL_NT1);
        if (!NT_STATUS_IS_OK(nt_status)) {
                DEBUG(1, ("failed negprot: %s\n", nt_errstr(nt_status)));
                cli_shutdown(cli);
@@ -3022,8 +2837,8 @@ NTSTATUS cli_full_connection(struct cli_state **output_cli,
        }
 
        if (service) {
-               nt_status = cli_tcon_andx(cli, service, service_type, password,
-                                         pw_len);
+               nt_status = cli_tree_connect(cli, service, service_type,
+                                            password, pw_len);
                if (!NT_STATUS_IS_OK(nt_status)) {
                        DEBUG(1,("failed tcon_X with %s\n", nt_errstr(nt_status)));
                        cli_shutdown(cli);
@@ -3057,20 +2872,20 @@ NTSTATUS cli_raw_tcon(struct cli_state *cli,
        NTSTATUS status;
 
        if (!lp_client_plaintext_auth() && (*pass)) {
-               DEBUG(1, ("Server requested plaintext password but 'client "
-                         "plaintext auth' is disabled\n"));
+               DEBUG(1, ("Server requested PLAINTEXT password but 'client plaintext auth = no'"
+                         " or 'client ntlmv2 auth = yes'\n"));
                return NT_STATUS_ACCESS_DENIED;
        }
 
        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),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   service, strlen(service)+1, NULL);
        bytes = smb_bytes_push_bytes(bytes, 4, NULL, 0);
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   pass, strlen(pass)+1, NULL);
        bytes = smb_bytes_push_bytes(bytes, 4, NULL, 0);
-       bytes = smb_bytes_push_str(bytes, cli_ucs2(cli),
+       bytes = smb_bytes_push_str(bytes, smbXcli_conn_use_unicode(cli->conn),
                                   dev, strlen(dev)+1, NULL);
 
        status = cli_smb(talloc_tos(), cli, SMBtcon, 0, 0, NULL,
@@ -3105,7 +2920,7 @@ struct cli_state *get_ipc_connect(char *server,
                                        lp_workgroup(),
                                        user_info->password ? user_info->password : "",
                                        flags,
-                                       Undefined);
+                                       SMB_SIGNING_DEFAULT);
 
        if (NT_STATUS_IS_OK(nt_status)) {
                return cli;
@@ -3209,7 +3024,7 @@ struct cli_state *get_ipc_connect_master_ip_bcast(TALLOC_CTX *ctx,
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(99, ("No master browsers responded: %s\n",
                           nt_errstr(status)));
-                return False;
+                return NULL;
         }
 
        for (i = 0; i < count; i++) {