#include "includes.h"
#include "libsmb/libsmb.h"
#include "../lib/util/tevent_ntstatus.h"
-#include "smb_signing.h"
+#include "../libcli/smb/smb_signing.h"
+#include "../libcli/smb/smb_seal.h"
#include "async_smb.h"
+#include "../libcli/smb/smbXcli_base.h"
+#include "../librpc/ndr/libndr.h"
+#include "../include/client.h"
/*******************************************************************
Setup the word count and byte count for a client smb message.
}
/****************************************************************************
- Change the port number used to call on.
+ Set the 'backup_intent' flag.
****************************************************************************/
-void cli_set_port(struct cli_state *cli, int port)
+bool cli_set_backup_intent(struct cli_state *cli, bool flag)
{
- cli->port = port;
-}
-
-/****************************************************************************
- convenience routine to find if we negotiated ucs2
-****************************************************************************/
-
-bool cli_ucs2(struct cli_state *cli)
-{
- return ((cli->capabilities & CAP_UNICODE) != 0);
-}
-
-bool cli_state_seqnum_persistent(struct cli_state *cli,
- uint16_t mid)
-{
- struct cli_state_seqnum *c;
-
- for (c = cli->seqnum; c; c = c->next) {
- if (c->mid == mid) {
- c->persistent = true;
- return true;
- }
- }
-
- return false;
-}
-
-bool cli_state_seqnum_remove(struct cli_state *cli,
- uint16_t mid)
-{
- struct cli_state_seqnum *c;
-
- for (c = cli->seqnum; c; c = c->next) {
- if (c->mid == mid) {
- DLIST_REMOVE(cli->seqnum, c);
- TALLOC_FREE(c);
- return true;
- }
- }
-
- return false;
-}
-
-/****************************************************************************
- Setup basics in a outgoing packet.
-****************************************************************************/
-
-void cli_setup_packet_buf(struct cli_state *cli, char *buf)
-{
- uint16 flags2;
- cli->rap_error = 0;
- SIVAL(buf,smb_rcls,0);
- SSVAL(buf,smb_pid,cli->pid);
- memset(buf+smb_pidhigh, 0, 12);
- SSVAL(buf,smb_uid,cli->vuid);
- SSVAL(buf,smb_mid,cli->mid);
-
- if (cli->protocol <= PROTOCOL_CORE) {
- return;
- }
-
- if (cli->case_sensitive) {
- SCVAL(buf,smb_flg,0x0);
- } else {
- /* Default setting, case insensitive. */
- SCVAL(buf,smb_flg,0x8);
- }
- flags2 = FLAGS2_LONG_PATH_COMPONENTS;
- if (cli->capabilities & CAP_UNICODE)
- flags2 |= FLAGS2_UNICODE_STRINGS;
- if ((cli->capabilities & CAP_DFS) && cli->dfsroot)
- flags2 |= FLAGS2_DFS_PATHNAMES;
- if (cli->capabilities & CAP_STATUS32)
- flags2 |= FLAGS2_32_BIT_ERROR_CODES;
- if (cli->use_spnego)
- flags2 |= FLAGS2_EXTENDED_SECURITY;
- SSVAL(buf,smb_flg2, flags2);
+ bool old_state = cli->backup_intent;
+ cli->backup_intent = flag;
+ return old_state;
}
/****************************************************************************
Set the signing state (used from the command line).
****************************************************************************/
-struct cli_state *cli_initialise_ex(int signing_state)
+struct cli_state *cli_state_create(TALLOC_CTX *mem_ctx,
+ int fd,
+ const char *remote_name,
+ const char *remote_realm,
+ int signing_state, int flags)
{
struct cli_state *cli = NULL;
- bool allow_smb_signing = false;
- bool mandatory_signing = false;
+ bool use_spnego = lp_client_use_spnego();
+ bool force_dos_errors = false;
+ bool force_ascii = false;
+ bool use_level_II_oplocks = false;
+ uint32_t smb1_capabilities = 0;
+ uint32_t smb2_capabilities = 0;
+ struct GUID client_guid = GUID_random();
/* Check the effective uid - make sure we are not setuid */
if (is_setuid_root()) {
return NULL;
}
- cli = talloc_zero(NULL, struct cli_state);
+ cli = talloc_zero(mem_ctx, struct cli_state);
if (!cli) {
return NULL;
}
+ cli->server_domain = talloc_strdup(cli, "");
+ if (!cli->server_domain) {
+ goto error;
+ }
+ cli->server_os = talloc_strdup(cli, "");
+ if (!cli->server_os) {
+ goto error;
+ }
+ cli->server_type = talloc_strdup(cli, "");
+ if (!cli->server_type) {
+ goto error;
+ }
+
cli->dfs_mountpoint = talloc_strdup(cli, "");
if (!cli->dfs_mountpoint) {
goto error;
}
- cli->port = 0;
- cli->fd = -1;
- cli->cnum = -1;
- cli->pid = (uint16)sys_getpid();
- cli->mid = 1;
- cli->vuid = UID_FIELD_INVALID;
- cli->protocol = PROTOCOL_NT1;
- cli->timeout = 20000; /* Timeout is in milliseconds. */
- cli->bufsize = CLI_BUFFER_SIZE+4;
- cli->max_xmit = cli->bufsize;
- cli->outbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
- cli->seqnum = 0;
- cli->inbuf = (char *)SMB_MALLOC(cli->bufsize+SAFETY_MARGIN);
- cli->oplock_handler = cli_oplock_ack;
+ cli->raw_status = NT_STATUS_INTERNAL_ERROR;
+ cli->map_dos_errors = true; /* remove this */
+ cli->timeout = CLIENT_TIMEOUT;
cli->case_sensitive = false;
- cli->smb_rw_error = SMB_READ_OK;
-
- cli->use_spnego = lp_client_use_spnego();
-
- cli->capabilities = CAP_UNICODE | CAP_STATUS32 | CAP_DFS;
/* Set the CLI_FORCE_DOSERR environment variable to test
client routines using DOS errors instead of STATUS32
ones. This intended only as a temporary hack. */
- if (getenv("CLI_FORCE_DOSERR"))
- cli->force_dos_errors = true;
+ if (getenv("CLI_FORCE_DOSERR")) {
+ force_dos_errors = true;
+ }
+ if (flags & CLI_FULL_CONNECTION_FORCE_DOS_ERRORS) {
+ force_dos_errors = true;
+ }
- if (lp_client_signing()) {
- allow_smb_signing = true;
+ if (getenv("CLI_FORCE_ASCII")) {
+ force_ascii = true;
+ }
+ if (!lp_unicode()) {
+ force_ascii = true;
+ }
+ if (flags & CLI_FULL_CONNECTION_FORCE_ASCII) {
+ force_ascii = true;
+ }
+
+ if (flags & CLI_FULL_CONNECTION_DONT_SPNEGO) {
+ use_spnego = false;
+ } else if (flags & CLI_FULL_CONNECTION_USE_KERBEROS) {
+ cli->use_kerberos = true;
+ }
+ if ((flags & CLI_FULL_CONNECTION_FALLBACK_AFTER_KERBEROS) &&
+ cli->use_kerberos) {
+ cli->fallback_after_kerberos = true;
}
- if (lp_client_signing() == Required) {
- mandatory_signing = true;
+ if (flags & CLI_FULL_CONNECTION_USE_CCACHE) {
+ cli->use_ccache = true;
}
- if (signing_state != Undefined) {
- allow_smb_signing = true;
+ if (flags & CLI_FULL_CONNECTION_USE_NT_HASH) {
+ cli->pw_nt_hash = true;
}
- if (signing_state == false) {
- allow_smb_signing = false;
- mandatory_signing = false;
+ if (flags & CLI_FULL_CONNECTION_OPLOCKS) {
+ cli->use_oplocks = true;
+ }
+ if (flags & CLI_FULL_CONNECTION_LEVEL_II_OPLOCKS) {
+ use_level_II_oplocks = true;
}
- if (signing_state == Required) {
- mandatory_signing = true;
+ if (signing_state == SMB_SIGNING_DEFAULT) {
+ signing_state = lp_client_signing();
}
- if (!cli->outbuf || !cli->inbuf)
- goto error;
+ smb1_capabilities = 0;
+ smb1_capabilities |= CAP_LARGE_FILES;
+ smb1_capabilities |= CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
+ smb1_capabilities |= CAP_LOCK_AND_READ | CAP_NT_FIND;
+ smb1_capabilities |= CAP_DFS | CAP_W2K_SMBS;
+ smb1_capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX;
+ smb1_capabilities |= CAP_LWIO;
- memset(cli->outbuf, 0, cli->bufsize);
- memset(cli->inbuf, 0, cli->bufsize);
+ if (!force_dos_errors) {
+ smb1_capabilities |= CAP_STATUS32;
+ }
- /* initialise signing */
- cli->signing_state = smb_signing_init(cli,
- allow_smb_signing,
- mandatory_signing);
- if (!cli->signing_state) {
+ if (!force_ascii) {
+ smb1_capabilities |= CAP_UNICODE;
+ }
+
+ if (use_spnego) {
+ smb1_capabilities |= CAP_EXTENDED_SECURITY;
+ }
+
+ if (use_level_II_oplocks) {
+ smb1_capabilities |= CAP_LEVEL_II_OPLOCKS;
+ }
+
+ smb2_capabilities = SMB2_CAP_ALL;
+
+ if (remote_realm) {
+ cli->remote_realm = talloc_strdup(cli, remote_realm);
+ if (cli->remote_realm == NULL) {
+ goto error;
+ }
+ }
+
+ cli->conn = smbXcli_conn_create(cli, fd, remote_name,
+ signing_state,
+ smb1_capabilities,
+ &client_guid,
+ smb2_capabilities);
+ if (cli->conn == NULL) {
goto error;
}
- cli->outgoing = tevent_queue_create(cli, "cli_outgoing");
- if (cli->outgoing == NULL) {
+ cli->smb1.pid = (uint16_t)getpid();
+ cli->smb1.vc_num = cli->smb1.pid;
+ cli->smb1.tcon = smbXcli_tcon_create(cli);
+ if (cli->smb1.tcon == NULL) {
+ goto error;
+ }
+ smb1cli_tcon_set_id(cli->smb1.tcon, UINT16_MAX);
+ cli->smb1.session = smbXcli_session_create(cli, cli->conn);
+ if (cli->smb1.session == NULL) {
goto error;
}
- cli->pending = NULL;
cli->initialised = 1;
-
return cli;
/* Clean up after malloc() error */
error:
- SAFE_FREE(cli->inbuf);
- SAFE_FREE(cli->outbuf);
TALLOC_FREE(cli);
return NULL;
}
-struct cli_state *cli_initialise(void)
-{
- return cli_initialise_ex(Undefined);
-}
-
/****************************************************************************
Close all pipes open on this session.
****************************************************************************/
* can remain active on the peer end, until some (long) timeout period
* later. This tree disconnect forces the peer to clean up, since the
* connection will be going away.
- *
- * Also, do not do tree disconnect when cli->smb_rw_error is SMB_DO_NOT_DO_TDIS
- * the only user for this so far is smbmount which passes opened connection
- * down to kernel's smbfs module.
*/
- if ( (cli->cnum != (uint16)-1) && (cli->smb_rw_error != SMB_DO_NOT_DO_TDIS ) ) {
+ if (cli_state_has_tcon(cli)) {
cli_tdis(cli);
}
-
- SAFE_FREE(cli->outbuf);
- SAFE_FREE(cli->inbuf);
-
- data_blob_free(&cli->secblob);
- data_blob_free(&cli->user_session_key);
- if (cli->fd != -1) {
- close(cli->fd);
- }
- cli->fd = -1;
- cli->smb_rw_error = SMB_READ_OK;
+ smbXcli_conn_disconnect(cli->conn, NT_STATUS_OK);
- /*
- * Need to free pending first, they remove themselves
- */
- while (cli->pending) {
- talloc_free(cli->pending[0]);
- }
TALLOC_FREE(cli);
}
_cli_shutdown(cli);
}
-/****************************************************************************
- Set socket options on a open connection.
-****************************************************************************/
+const char *cli_state_remote_realm(struct cli_state *cli)
+{
+ return cli->remote_realm;
+}
-void cli_sockopt(struct cli_state *cli, const char *options)
+uint16_t cli_state_get_vc_num(struct cli_state *cli)
{
- set_socket_options(cli->fd, options);
+ return cli->smb1.vc_num;
}
/****************************************************************************
uint16 cli_setpid(struct cli_state *cli, uint16 pid)
{
- uint16 ret = cli->pid;
- cli->pid = pid;
+ uint16_t ret = cli->smb1.pid;
+ cli->smb1.pid = pid;
+ return ret;
+}
+
+uint16_t cli_getpid(struct cli_state *cli)
+{
+ return cli->smb1.pid;
+}
+
+bool cli_state_has_tcon(struct cli_state *cli)
+{
+ uint16_t tid = cli_state_get_tid(cli);
+
+ if (tid == UINT16_MAX) {
+ return false;
+ }
+
+ return true;
+}
+
+uint16_t cli_state_get_tid(struct cli_state *cli)
+{
+ return smb1cli_tcon_current_id(cli->smb1.tcon);
+}
+
+uint16_t cli_state_set_tid(struct cli_state *cli, uint16_t tid)
+{
+ uint16_t ret = smb1cli_tcon_current_id(cli->smb1.tcon);
+ smb1cli_tcon_set_id(cli->smb1.tcon, tid);
+ return ret;
+}
+
+uint16_t cli_state_get_uid(struct cli_state *cli)
+{
+ return smb1cli_session_current_id(cli->smb1.session);
+}
+
+uint16_t cli_state_set_uid(struct cli_state *cli, uint16_t uid)
+{
+ uint16_t ret = smb1cli_session_current_id(cli->smb1.session);
+ smb1cli_session_set_id(cli->smb1.session, uid);
return ret;
}
bool cli_set_case_sensitive(struct cli_state *cli, bool case_sensitive)
{
bool ret = cli->case_sensitive;
+ uint32_t fs_attrs;
+ struct smbXcli_tcon *tcon;
+
+ if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+ tcon = cli->smb2.tcon;
+ } else {
+ tcon = cli->smb1.tcon;
+ }
+
+ fs_attrs = smbXcli_tcon_get_fs_attributes(tcon);
+ if (case_sensitive) {
+ fs_attrs |= FILE_CASE_SENSITIVE_SEARCH;
+ } else {
+ fs_attrs &= ~FILE_CASE_SENSITIVE_SEARCH;
+ }
+ smbXcli_tcon_set_fs_attributes(tcon, fs_attrs);
+
cli->case_sensitive = case_sensitive;
return ret;
}
+uint32_t cli_state_available_size(struct cli_state *cli, uint32_t ofs)
+{
+ uint32_t ret = smb1cli_conn_max_xmit(cli->conn);
+
+ if (ofs >= ret) {
+ return 0;
+ }
+
+ ret -= ofs;
+
+ return ret;
+}
+
+time_t cli_state_server_time(struct cli_state *cli)
+{
+ NTTIME nt;
+ time_t t;
+
+ nt = smbXcli_conn_server_system_time(cli->conn);
+ t = nt_time_to_unix(nt);
+
+ return t;
+}
+
struct cli_echo_state {
- uint16_t vwv[1];
- DATA_BLOB data;
- int num_echos;
+ bool is_smb2;
};
static void cli_echo_done(struct tevent_req *subreq);
-struct tevent_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
+struct tevent_req *cli_echo_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct cli_state *cli, uint16_t num_echos,
DATA_BLOB data)
{
if (req == NULL) {
return NULL;
}
- SSVAL(state->vwv, 0, num_echos);
- state->data = data;
- state->num_echos = num_echos;
- subreq = cli_smb_send(state, ev, cli, SMBecho, 0, 1, state->vwv,
- data.length, data.data);
- if (subreq == NULL) {
- goto fail;
+ if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+ state->is_smb2 = true;
+ subreq = smb2cli_echo_send(state, ev,
+ cli->conn,
+ cli->timeout);
+ } else {
+ subreq = smb1cli_echo_send(state, ev,
+ cli->conn,
+ cli->timeout,
+ num_echos,
+ data);
+ }
+ if (tevent_req_nomem(subreq, req)) {
+ return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, cli_echo_done, req);
+
return req;
- fail:
- TALLOC_FREE(req);
- return NULL;
}
static void cli_echo_done(struct tevent_req *subreq)
struct cli_echo_state *state = tevent_req_data(
req, struct cli_echo_state);
NTSTATUS status;
- uint32_t num_bytes;
- uint8_t *bytes;
- uint8_t *inbuf;
- status = cli_smb_recv(subreq, state, &inbuf, 0, NULL, NULL,
- &num_bytes, &bytes);
+ if (state->is_smb2) {
+ status = smb2cli_echo_recv(subreq);
+ } else {
+ status = smb1cli_echo_recv(subreq);
+ }
+ TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
tevent_req_nterror(req, status);
return;
}
- if ((num_bytes != state->data.length)
- || (memcmp(bytes, state->data.data, num_bytes) != 0)) {
- tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
- return;
- }
-
- state->num_echos -=1;
- if (state->num_echos == 0) {
- tevent_req_done(req);
- return;
- }
- if (!cli_smb_req_set_pending(subreq)) {
- tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
- return;
- }
+ tevent_req_done(req);
}
/**
NTSTATUS cli_echo(struct cli_state *cli, uint16_t num_echos, DATA_BLOB data)
{
TALLOC_CTX *frame = talloc_stackframe();
- struct event_context *ev;
+ struct tevent_context *ev;
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
*/
goto fail;
}
- ev = event_context_init(frame);
+ ev = samba_tevent_context_init(frame);
if (ev == NULL) {
status = NT_STATUS_NO_MEMORY;
goto fail;
status = cli_echo_recv(req);
fail:
TALLOC_FREE(frame);
- if (!NT_STATUS_IS_OK(status)) {
- cli_set_error(cli, status);
- }
return status;
}
struct tevent_req *req = NULL;
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(mem_ctx);
+ ev = samba_tevent_context_init(mem_ctx);
if (ev == NULL) {
goto fail;
}
git.samba.org / mat / samba.git / blobdiff