/*
Unix SMB/CIFS implementation.
+
client connect/disconnect routines
- Copyright (C) Andrew Tridgell 2003
+
+ Copyright (C) Andrew Tridgell 2003-2005
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
#include "includes.h"
+#include "libcli/libcli.h"
+#include "libcli/raw/libcliraw.h"
+#include "libcli/smb_composite/smb_composite.h"
/*
- wrapper around cli_sock_connect()
+ wrapper around smbcli_sock_connect()
*/
-BOOL cli_socket_connect(struct cli_state *cli, const char *server, struct in_addr *ip)
+BOOL smbcli_socket_connect(struct smbcli_state *cli, const char *server)
{
- struct cli_socket *sock;
+ struct smbcli_socket *sock;
- sock = cli_sock_init();
- if (!sock) return False;
+ sock = smbcli_sock_connect_byname(server, 0, NULL, NULL);
- if (!cli_sock_connect_byname(sock, server, 0)) {
- cli_sock_close(sock);
- return False;
- }
+ if (sock == NULL) return False;
- cli->transport = cli_transport_init(sock);
+ cli->transport = smbcli_transport_init(sock, cli, True);
if (!cli->transport) {
- cli_sock_close(sock);
return False;
}
return True;
}
-/* wrapper around cli_transport_connect() */
-BOOL cli_transport_establish(struct cli_state *cli,
- struct nmb_name *calling,
- struct nmb_name *called)
+/* wrapper around smbcli_transport_connect() */
+BOOL smbcli_transport_establish(struct smbcli_state *cli,
+ struct nbt_name *calling,
+ struct nbt_name *called)
{
- return cli_transport_connect(cli->transport, calling, called);
+ return smbcli_transport_connect(cli->transport, calling, called);
}
/* wrapper around smb_raw_negotiate() */
-NTSTATUS cli_negprot(struct cli_state *cli)
+NTSTATUS smbcli_negprot(struct smbcli_state *cli)
{
- return smb_raw_negotiate(cli->transport);
+ return smb_raw_negotiate(cli->transport, lp_maxprotocol());
}
-/* wrapper around smb_raw_session_setup() */
-NTSTATUS cli_session_setup(struct cli_state *cli,
- const char *user,
- const char *password,
- const char *domain)
+/* wrapper around smb_raw_sesssetup() */
+NTSTATUS smbcli_session_setup(struct smbcli_state *cli,
+ struct cli_credentials *credentials)
{
- union smb_sesssetup setup;
+ struct smb_composite_sesssetup setup;
NTSTATUS status;
- TALLOC_CTX *mem_ctx;
- cli->session = cli_session_init(cli->transport);
+ cli->session = smbcli_session_init(cli->transport, cli, True);
if (!cli->session) return NT_STATUS_UNSUCCESSFUL;
- mem_ctx = talloc_init("cli_session_setup");
- if (!mem_ctx) return NT_STATUS_NO_MEMORY;
-
- setup.generic.level = RAW_SESSSETUP_GENERIC;
- setup.generic.in.sesskey = cli->transport->negotiate.sesskey;
- setup.generic.in.capabilities = cli->transport->negotiate.capabilities;
- if (!user || !user[0]) {
- setup.generic.in.password = NULL;
- setup.generic.in.user = "";
- setup.generic.in.domain = "";
- setup.generic.in.capabilities &= ~CAP_EXTENDED_SECURITY;
- } else {
- setup.generic.in.password = password;
- setup.generic.in.user = user;
- setup.generic.in.domain = domain;
- }
-
- status = smb_raw_session_setup(cli->session, mem_ctx, &setup);
+ setup.in.sesskey = cli->transport->negotiate.sesskey;
+ setup.in.capabilities = cli->transport->negotiate.capabilities;
+ setup.in.credentials = credentials;
+ setup.in.workgroup = lp_workgroup();
- cli->session->vuid = setup.generic.out.vuid;
+ status = smb_composite_sesssetup(cli->session, &setup);
- talloc_destroy(mem_ctx);
+ cli->session->vuid = setup.out.vuid;
return status;
}
-/* wrapper around smb_tree_connect() */
-NTSTATUS cli_send_tconX(struct cli_state *cli, const char *sharename,
- const char *devtype, const char *password)
+/* wrapper around smb_raw_tcon() */
+NTSTATUS smbcli_tconX(struct smbcli_state *cli, const char *sharename,
+ const char *devtype, const char *password)
{
union smb_tcon tcon;
TALLOC_CTX *mem_ctx;
NTSTATUS status;
- cli->tree = cli_tree_init(cli->session);
+ cli->tree = smbcli_tree_init(cli->session, cli, True);
if (!cli->tree) return NT_STATUS_UNSUCCESSFUL;
- cli->tree->reference_count++;
+ mem_ctx = talloc_init("tcon");
+ if (!mem_ctx) {
+ return NT_STATUS_NO_MEMORY;
+ }
/* setup a tree connect */
tcon.generic.level = RAW_TCON_TCONX;
tcon.tconx.in.flags = 0;
- tcon.tconx.in.password = data_blob(password, strlen(password)+1);
+ if (cli->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_USER_LEVEL) {
+ tcon.tconx.in.password = data_blob(NULL, 0);
+ } else if (cli->transport->negotiate.sec_mode & NEGOTIATE_SECURITY_CHALLENGE_RESPONSE) {
+ tcon.tconx.in.password = data_blob_talloc(mem_ctx, NULL, 24);
+ if (cli->transport->negotiate.secblob.length < 8) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+ SMBencrypt(password, cli->transport->negotiate.secblob.data, tcon.tconx.in.password.data);
+ } else {
+ tcon.tconx.in.password = data_blob_talloc(mem_ctx, password, strlen(password)+1);
+ }
tcon.tconx.in.path = sharename;
tcon.tconx.in.device = devtype;
- mem_ctx = talloc_init("tcon");
- if (!mem_ctx)
- return NT_STATUS_NO_MEMORY;
+ status = smb_raw_tcon(cli->tree, mem_ctx, &tcon);
- status = smb_tree_connect(cli->tree, mem_ctx, &tcon);
+ cli->tree->tid = tcon.tconx.out.tid;
- cli->tree->tid = tcon.tconx.out.cnum;
-
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
/*
- easy way to get to a fully connected cli_state in one call
+ easy way to get to a fully connected smbcli_state in one call
*/
-NTSTATUS cli_full_connection(struct cli_state **ret_cli,
- const char *myname,
- const char *host,
- struct in_addr *ip,
- const char *sharename,
- const char *devtype,
- const char *username,
- const char *domain,
- const char *password,
- uint_t flags,
- BOOL *retry)
+NTSTATUS smbcli_full_connection(TALLOC_CTX *parent_ctx,
+ struct smbcli_state **ret_cli,
+ const char *host,
+ const char *sharename,
+ const char *devtype,
+ struct cli_credentials *credentials,
+ struct event_context *ev)
{
- struct cli_tree *tree;
+ struct smbcli_tree *tree;
NTSTATUS status;
- char *p;
- TALLOC_CTX *mem_ctx;
-
- mem_ctx = talloc_init("cli_full_connection");
*ret_cli = NULL;
- /* if the username is of the form DOMAIN\username then split out the domain */
- p = strpbrk(username, "\\/");
- if (p) {
- domain = talloc_strndup(mem_ctx, username, PTR_DIFF(p, username));
- username = talloc_strdup(mem_ctx, p+1);
- }
-
- status = cli_tree_full_connection(&tree, myname, host, 0, sharename, devtype,
- username, domain, password);
+ status = smbcli_tree_full_connection(parent_ctx,
+ &tree, host, 0, sharename, devtype,
+ credentials, ev);
if (!NT_STATUS_IS_OK(status)) {
goto done;
}
- (*ret_cli) = cli_state_init();
+ (*ret_cli) = smbcli_state_init(parent_ctx);
(*ret_cli)->tree = tree;
(*ret_cli)->session = tree->session;
(*ret_cli)->transport = tree->session->transport;
- tree->reference_count++;
+ talloc_steal(*ret_cli, tree);
+
done:
- talloc_destroy(mem_ctx);
return status;
}
/*
disconnect the tree
*/
-NTSTATUS cli_tdis(struct cli_state *cli)
+NTSTATUS smbcli_tdis(struct smbcli_state *cli)
{
return smb_tree_disconnect(cli->tree);
}
/****************************************************************************
Initialise a client state structure.
****************************************************************************/
-struct cli_state *cli_state_init(void)
+struct smbcli_state *smbcli_state_init(TALLOC_CTX *mem_ctx)
{
- struct cli_state *cli;
- TALLOC_CTX *mem_ctx;
-
- mem_ctx = talloc_init("cli_state");
- if (!mem_ctx) return NULL;
-
- cli = talloc_zero(mem_ctx, sizeof(*cli));
- cli->mem_ctx = mem_ctx;
-
- return cli;
+ return talloc_zero(mem_ctx, struct smbcli_state);
}
-/****************************************************************************
- Shutdown a client structure.
-****************************************************************************/
-void cli_shutdown(struct cli_state *cli)
+/*
+ parse a //server/share type UNC name
+*/
+BOOL smbcli_parse_unc(const char *unc_name, TALLOC_CTX *mem_ctx,
+ const char **hostname, const char **sharename)
{
- if (!cli) return;
- if (cli->tree) {
- cli->tree->reference_count++;
- cli_tree_close(cli->tree);
+ char *p;
+
+ if (strncmp(unc_name, "\\\\", 2) &&
+ strncmp(unc_name, "//", 2)) {
+ return False;
}
- if (cli->mem_ctx) {
- talloc_destroy(cli->mem_ctx);
+
+ *hostname = talloc_strdup(mem_ctx, &unc_name[2]);
+ p = strchr_m(&(*hostname)[2],'/');
+ if (!p) {
+ p = strchr_m(&(*hostname)[2],'\\');
+ if (!p) return False;
}
+ *p = 0;
+ *sharename = talloc_strdup(mem_ctx, p+1);
+
+ return True;
}
+
+
+
git.samba.org / jra / samba / .git / blobdiff