#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.
}
/****************************************************************************
- convenience routine to find if we negotiated ucs2
+ Set the 'backup_intent' flag.
****************************************************************************/
-bool cli_ucs2(struct cli_state *cli)
+bool cli_set_backup_intent(struct cli_state *cli, bool flag)
{
- return ((cli_state_capabilities(cli) & CAP_UNICODE) != 0);
-}
-
-/****************************************************************************
- 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->smb1.pid);
- memset(buf+smb_pidhigh, 0, 12);
- SSVAL(buf,smb_uid, cli_state_get_uid(cli));
- SSVAL(buf,smb_mid, 0);
-
- if (cli_state_protocol(cli) <= 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_state_capabilities(cli) & CAP_UNICODE)
- flags2 |= FLAGS2_UNICODE_STRINGS;
- if ((cli_state_capabilities(cli) & CAP_DFS) && cli->dfsroot)
- flags2 |= FLAGS2_DFS_PATHNAMES;
- if (cli_state_capabilities(cli) & CAP_STATUS32)
- flags2 |= FLAGS2_32_BIT_ERROR_CODES;
- if (cli_state_capabilities(cli) & CAP_EXTENDED_SECURITY)
- flags2 |= FLAGS2_EXTENDED_SECURITY;
- SSVAL(buf,smb_flg2, flags2);
-}
-
-/****************************************************************************
- Initialize Domain, user or password.
-****************************************************************************/
-
-NTSTATUS cli_set_domain(struct cli_state *cli, const char *domain)
-{
- TALLOC_FREE(cli->domain);
- cli->domain = talloc_strdup(cli, domain ? domain : "");
- if (cli->domain == NULL) {
- return NT_STATUS_NO_MEMORY;
- }
- return NT_STATUS_OK;
-}
-
-NTSTATUS cli_set_username(struct cli_state *cli, const char *username)
-{
- TALLOC_FREE(cli->user_name);
- cli->user_name = talloc_strdup(cli, username ? username : "");
- if (cli->user_name == NULL) {
- return NT_STATUS_NO_MEMORY;
- }
- return NT_STATUS_OK;
-}
-
-NTSTATUS cli_set_password(struct cli_state *cli, const char *password)
-{
- TALLOC_FREE(cli->password);
-
- /* Password can be NULL. */
- if (password) {
- cli->password = talloc_strdup(cli, password);
- if (cli->password == NULL) {
- return NT_STATUS_NO_MEMORY;
- }
- } else {
- /* Use zero NTLMSSP hashes and session key. */
- cli->password = NULL;
- }
-
- return NT_STATUS_OK;
-}
-
-/****************************************************************************
- Initialise credentials of a client structure.
-****************************************************************************/
-
-NTSTATUS cli_init_creds(struct cli_state *cli, const char *username, const char *domain, const char *password)
-{
- NTSTATUS status = cli_set_username(cli, username);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
- status = cli_set_domain(cli, domain);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
- }
- DEBUG(10,("cli_init_creds: user %s domain %s\n", cli->user_name, cli->domain));
-
- return cli_set_password(cli, password);
+ bool old_state = cli->backup_intent;
+ cli->backup_intent = flag;
+ return old_state;
}
/****************************************************************************
Set the signing state (used from the command line).
****************************************************************************/
+struct GUID cli_state_client_guid;
+
struct cli_state *cli_state_create(TALLOC_CTX *mem_ctx,
int fd,
const char *remote_name,
int signing_state, int flags)
{
struct cli_state *cli = NULL;
- bool allow_smb_signing;
- bool desire_smb_signing;
- bool mandatory_signing;
- socklen_t ss_length;
- int ret;
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;
+
+ if (!GUID_all_zero(&cli_state_client_guid)) {
+ client_guid = cli_state_client_guid;
+ } else {
+ client_guid = GUID_random();
+ }
/* Check the effective uid - make sure we are not setuid */
if (is_setuid_root()) {
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->raw_status = NT_STATUS_INTERNAL_ERROR;
- cli->timeout = 20000; /* Timeout is in milliseconds. */
- cli->case_sensitive = false;
+ cli->map_dos_errors = true; /* remove this */
+ cli->timeout = CLIENT_TIMEOUT;
/* Set the CLI_FORCE_DOSERR environment variable to test
client routines using DOS errors instead of STATUS32
if (getenv("CLI_FORCE_ASCII")) {
force_ascii = true;
}
+ if (!lp_unicode()) {
+ force_ascii = true;
+ }
if (flags & CLI_FULL_CONNECTION_FORCE_ASCII) {
force_ascii = true;
}
cli->use_ccache = true;
}
+ if (flags & CLI_FULL_CONNECTION_USE_NT_HASH) {
+ cli->pw_nt_hash = true;
+ }
+
if (flags & CLI_FULL_CONNECTION_OPLOCKS) {
cli->use_oplocks = true;
}
signing_state = lp_client_signing();
}
- switch (signing_state) {
- case SMB_SIGNING_OFF:
- /* never */
- allow_smb_signing = false;
- desire_smb_signing = false;
- mandatory_signing = false;
- break;
- default:
- case SMB_SIGNING_DEFAULT:
- case SMB_SIGNING_IF_REQUIRED:
- allow_smb_signing = true;
- desire_smb_signing = false;
- mandatory_signing = false;
- break;
- case SMB_SIGNING_REQUIRED:
- /* always */
- allow_smb_signing = true;
- desire_smb_signing = true;
- mandatory_signing = true;
- break;
- }
-
- /* initialise signing */
- cli->signing_state = smb_signing_init(cli,
- allow_smb_signing,
- desire_smb_signing,
- mandatory_signing);
- if (!cli->signing_state) {
- goto error;
- }
-
- cli->conn.smb1.client.capabilities = 0;
- cli->conn.smb1.client.capabilities |= CAP_LARGE_FILES;
- cli->conn.smb1.client.capabilities |= CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
- cli->conn.smb1.client.capabilities |= CAP_LOCK_AND_READ | CAP_NT_FIND;
- cli->conn.smb1.client.capabilities |= CAP_DFS | CAP_W2K_SMBS;
- cli->conn.smb1.client.capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX;
- cli->conn.smb1.client.capabilities |= CAP_LWIO;
+ smb1_capabilities = 0;
+ smb1_capabilities |= CAP_LARGE_FILES;
+ smb1_capabilities |= CAP_NT_SMBS | CAP_RPC_REMOTE_APIS;
+ smb1_capabilities |= CAP_LOCK_AND_READ | CAP_NT_FIND;
+ smb1_capabilities |= CAP_DFS | CAP_W2K_SMBS;
+ smb1_capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX;
+ smb1_capabilities |= CAP_LWIO;
if (!force_dos_errors) {
- cli->conn.smb1.client.capabilities |= CAP_STATUS32;
+ smb1_capabilities |= CAP_STATUS32;
}
if (!force_ascii) {
- cli->conn.smb1.client.capabilities |= CAP_UNICODE;
+ smb1_capabilities |= CAP_UNICODE;
}
if (use_spnego) {
- cli->conn.smb1.client.capabilities |= CAP_EXTENDED_SECURITY;
+ smb1_capabilities |= CAP_EXTENDED_SECURITY;
}
if (use_level_II_oplocks) {
- cli->conn.smb1.client.capabilities |= CAP_LEVEL_II_OPLOCKS;
+ smb1_capabilities |= CAP_LEVEL_II_OPLOCKS;
}
- cli->conn.smb1.client.max_xmit = CLI_BUFFER_SIZE;
-
- cli->conn.smb1.capabilities = cli->conn.smb1.client.capabilities;
- cli->conn.smb1.max_xmit = 1024;
-
- cli->conn.smb1.mid = 1;
-
- cli->conn.outgoing = tevent_queue_create(cli, "cli_outgoing");
- if (cli->conn.outgoing == NULL) {
- goto error;
- }
- cli->conn.pending = NULL;
-
- cli->conn.remote_name = talloc_strdup(cli, remote_name);
- if (cli->conn.remote_name == NULL) {
- goto error;
- }
+ smb2_capabilities = SMB2_CAP_ALL;
if (remote_realm) {
- cli->conn.remote_realm = talloc_strdup(cli, remote_realm);
- if (cli->conn.remote_realm == NULL) {
+ cli->remote_realm = talloc_strdup(cli, remote_realm);
+ if (cli->remote_realm == NULL) {
goto error;
}
}
- cli->conn.fd = fd;
+ cli->conn = smbXcli_conn_create(cli, fd, remote_name,
+ signing_state,
+ smb1_capabilities,
+ &client_guid,
+ smb2_capabilities);
+ if (cli->conn == NULL) {
+ goto error;
+ }
- ss_length = sizeof(cli->conn.local_ss);
- ret = getsockname(fd,
- (struct sockaddr *)(void *)&cli->conn.local_ss,
- &ss_length);
- if (ret == -1) {
+ 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;
}
- ss_length = sizeof(cli->conn.remote_ss);
- ret = getpeername(fd,
- (struct sockaddr *)(void *)&cli->conn.remote_ss,
- &ss_length);
- if (ret == -1) {
+ 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->smb1.pid = (uint16_t)sys_getpid();
- cli->smb1.vc_num = cli->smb1.pid;
- cli->smb1.tid = UINT16_MAX;
- cli->smb1.uid = UID_FIELD_INVALID;
-
cli->initialised = 1;
return cli;
return NULL;
}
-bool cli_state_encryption_on(struct cli_state *cli)
-{
- return common_encryption_on(cli->trans_enc_state);
-}
-
-
/****************************************************************************
Close all pipes open on this session.
****************************************************************************/
if (cli_state_has_tcon(cli)) {
cli_tdis(cli);
}
-
- data_blob_free(&cli->user_session_key);
- cli_state_disconnect(cli);
+ smbXcli_conn_disconnect(cli->conn, NT_STATUS_OK);
- /*
- * Need to free pending first, they remove themselves
- */
- while (cli->conn.pending) {
- talloc_free(cli->conn.pending[0]);
- }
TALLOC_FREE(cli);
}
_cli_shutdown(cli);
}
-/****************************************************************************
- Set socket options on a open connection.
-****************************************************************************/
-
-void cli_sockopt(struct cli_state *cli, const char *options)
-{
- set_socket_options(cli->conn.fd, options);
-}
-
-const struct sockaddr_storage *cli_state_local_sockaddr(struct cli_state *cli)
-{
- return &cli->conn.local_ss;
-}
-
-const struct sockaddr_storage *cli_state_remote_sockaddr(struct cli_state *cli)
-{
- return &cli->conn.remote_ss;
-}
-
-const char *cli_state_remote_name(struct cli_state *cli)
-{
- return cli->conn.remote_name;
-}
-
const char *cli_state_remote_realm(struct cli_state *cli)
{
- return cli->conn.remote_realm;
+ return cli->remote_realm;
}
uint16_t cli_state_get_vc_num(struct cli_state *cli)
return cli->smb1.vc_num;
}
-uint32_t cli_state_server_session_key(struct cli_state *cli)
-{
- return cli->conn.smb1.server.session_key;
-}
-
/****************************************************************************
Set the PID to use for smb messages. Return the old pid.
****************************************************************************/
-uint16 cli_setpid(struct cli_state *cli, uint16 pid)
+uint16_t cli_setpid(struct cli_state *cli, uint16 pid)
{
uint16_t ret = cli->smb1.pid;
cli->smb1.pid = pid;
bool cli_state_has_tcon(struct cli_state *cli)
{
- if (cli->smb1.tid == UINT16_MAX) {
+ uint16_t tid = cli_state_get_tid(cli);
+
+ if (tid == UINT16_MAX) {
return false;
}
uint16_t cli_state_get_tid(struct cli_state *cli)
{
- return cli->smb1.tid;
+ return smb1cli_tcon_current_id(cli->smb1.tcon);
}
uint16_t cli_state_set_tid(struct cli_state *cli, uint16_t tid)
{
- uint16_t ret = cli->smb1.tid;
- cli->smb1.tid = 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 cli->smb1.uid;
+ return smb1cli_session_current_id(cli->smb1.session);
}
uint16_t cli_state_set_uid(struct cli_state *cli, uint16_t uid)
{
- uint16_t ret = cli->smb1.uid;
- cli->smb1.uid = 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;
- cli->case_sensitive = case_sensitive;
- return ret;
-}
+ bool ret;
+ uint32_t fs_attrs;
+ struct smbXcli_tcon *tcon;
-enum protocol_types cli_state_protocol(struct cli_state *cli)
-{
- return cli->conn.protocol;
-}
+ if (smbXcli_conn_protocol(cli->conn) >= PROTOCOL_SMB2_02) {
+ tcon = cli->smb2.tcon;
+ } else {
+ tcon = cli->smb1.tcon;
+ }
-uint32_t cli_state_capabilities(struct cli_state *cli)
-{
- return cli->conn.smb1.capabilities;
+ fs_attrs = smbXcli_tcon_get_fs_attributes(tcon);
+ if (fs_attrs & FILE_CASE_SENSITIVE_SEARCH) {
+ ret = true;
+ } else {
+ ret = false;
+ }
+ if (case_sensitive) {
+ fs_attrs |= FILE_CASE_SENSITIVE_SEARCH;
+ } else {
+ fs_attrs &= ~FILE_CASE_SENSITIVE_SEARCH;
+ }
+ smbXcli_tcon_set_fs_attributes(tcon, fs_attrs);
+
+ return ret;
}
uint32_t cli_state_available_size(struct cli_state *cli, uint32_t ofs)
{
- uint32_t ret = cli->conn.smb1.max_xmit;
+ uint32_t ret = smb1cli_conn_max_xmit(cli->conn);
if (ofs >= ret) {
return 0;
return ret;
}
-uint16_t cli_state_max_requests(struct cli_state *cli)
-{
- return cli->conn.smb1.server.max_mux;
-}
-
-const uint8_t *cli_state_server_challenge(struct cli_state *cli)
-{
- return cli->conn.smb1.server.challenge;
-}
-
-const DATA_BLOB *cli_state_server_gss_blob(struct cli_state *cli)
-{
- return &cli->conn.smb1.server.gss_blob;
-}
-
-uint16_t cli_state_security_mode(struct cli_state *cli)
+time_t cli_state_server_time(struct cli_state *cli)
{
- return cli->conn.smb1.server.security_mode;
-}
+ NTTIME nt;
+ time_t t;
-int cli_state_server_time_zone(struct cli_state *cli)
-{
- return cli->conn.smb1.server.time_zone;
-}
+ nt = smbXcli_conn_server_system_time(cli->conn);
+ t = nt_time_to_unix(nt);
-time_t cli_state_server_time(struct cli_state *cli)
-{
- return cli->conn.smb1.server.system_time;
+ 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;
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 / bbaumbach / samba-autobuild / .git / blobdiff