1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
samba-mirror/source3/rpc_client/cli_connect.c
Gerald Carter a08d444896 More work on AddPrinterDriver() and AddPrinterEx() client RPC's
Also fixed init_unistr() to deal with a NULL source character string.



-jerry
(This used to be commit 8ecd5dd52a)
2000-08-09 20:14:29 +00:00

397 lines
12 KiB
C

/*
Unix SMB/Netbios implementation.
Version 1.9.
SMB client generic functions
Copyright (C) Andrew Tridgell 1994-2000
Copyright (C) Luke Kenneth Casson Leighton 1996-2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define NO_SYSLOG
#include "includes.h"
#include "rpc_parse.h"
#include "rpc_client.h"
static struct cli_connection **con_list = NULL;
static uint32 num_cons = 0;
struct user_creds *usr_creds = NULL;
vuser_key *user_key = NULL;
extern int DEBUGLEVEL;
extern pstring global_myname;
/*
* needed for the struct cli_connection
* none of these functions are implemented in HEAD currently
* rpc_client/cli_connect.c for details
*
* the 'typedef struct _cli_auth_fns cli_auth_fns;' is in
* rpc_misc.h
*/
struct _cli_auth_fns {
/* these three will do for now. they *should* match with server-side */
BOOL (*create_bind_req) (struct cli_connection *, prs_struct *,
uint32, RPC_IFACE *, RPC_IFACE *);
BOOL (*decode_bind_resp) (struct cli_connection *, prs_struct *);
BOOL (*create_bind_cont) (struct cli_connection *, prs_struct *, uint32);
/* creates an authenticated PDU */
BOOL (*cli_create_pdu) (struct cli_connection *, uint8, prs_struct *,
int, int *, prs_struct *, uint8 *);
/* decodes an authenticated PDU */
BOOL (*cli_decode_pdu) (struct cli_connection *, prs_struct *, int, int);
};
cli_auth_fns cli_noauth_fns =
{
NULL,
NULL,
NULL,
NULL,
NULL
};
void init_connections(void)
{
con_list = NULL;
num_cons = 0;
init_cli_use();
}
static void free_con_array(uint32 num_entries,
struct cli_connection **entries)
{
void (*fn) (void *) = (void (*)(void *))&cli_connection_free;
free_void_array(num_entries, (void **)entries, *fn);
}
static struct cli_connection *add_con_to_array(uint32 * len,
struct cli_connection ***array,
struct cli_connection *con)
{
return (struct cli_connection *)add_item_to_array(len,
(void ***)array,
(void *)con);
}
void free_connections(void)
{
DEBUG(3, ("free_connections: closing all MSRPC connections\n"));
free_con_array(num_cons, con_list);
free_cli_use();
init_connections();
}
static struct cli_connection *cli_con_get(const char *srv_name,
char *pipe_name,
cli_auth_fns * auth,
void *auth_creds, BOOL reuse)
{
struct cli_connection *con = NULL;
BOOL is_new_connection = False;
CREDS_NT usr;
struct ntuser_creds *ntc = NULL;
struct ncacn_np *pNcacn;
/*
* initialization stuff
*/
con = (struct cli_connection *)malloc(sizeof(*con));
if (con == NULL)
{
return NULL;
}
memset(con, 0, sizeof(*con));
copy_user_creds(&con->usr_creds, NULL);
con->usr_creds.reuse = reuse;
if (srv_name != NULL)
{
con->srv_name = strdup(srv_name);
}
if (pipe_name != NULL)
{
con->pipe_name = strdup(pipe_name);
}
if (usr_creds != NULL)
{
ntc = &usr_creds->ntc;
}
/* fix me XXXX **WHAT** a hack. The cli_state* is malloc'd
deep within the call stack, so we can grab that pointer.
ncacn_np* is stored in an array which is currently handled
by underlying systems. --jerry */
pNcacn = ncacn_np_use_add(pipe_name, user_key, srv_name,
ntc, reuse,
&is_new_connection);
if (pNcacn == NULL)
return NULL;
con->pCli_state = pNcacn->smb;
if (con->pCli_state == NULL)
return NULL;
con->pCli_state->key.pid = 0;
con->pCli_state->key.vuid = UID_FIELD_INVALID;
create_ntc_from_cli_state ( &usr, con->pCli_state );
copy_nt_creds(&con->usr_creds.ntc, &usr);
if (is_new_connection)
{
con->auth_info = NULL;
con->auth_creds = auth_creds;
if (auth != NULL)
{
con->auth = auth;
}
else
{
con->auth = &cli_noauth_fns;
}
if (!rpc_pipe_bind(con->pCli_state, pipe_name, global_myname))
{
DEBUG(0, ("rpc_pipe_bind failed\n"));
cli_connection_free(con);
return NULL;
}
}
else
{
con->auth_info = cli_conn_get_auth_creds(con);
con->auth = cli_conn_get_authfns(con);
if (con->auth_info != NULL)
{
DEBUG(1,("cli_con_get: TODO: auth reuse\n"));
cli_connection_free(con);
return NULL;
}
else
{
con->auth = &cli_noauth_fns;
}
}
add_con_to_array(&num_cons, &con_list, con);
return con;
}
/****************************************************************************
terminate client connection
****************************************************************************/
void cli_connection_free(struct cli_connection *con)
{
BOOL closed = False;
struct cli_state *oldcli = NULL;
int i;
DEBUG(10, ("cli_connection_free: %d\n", __LINE__));
if (con->pCli_state != NULL)
{
DEBUG(10, ("msrpc smb connection\n"));
ncacn_np_use_del(con->srv_name, con->pipe_name,
&con->pCli_state->key, False, &closed);
oldcli = con->pCli_state;
con->pCli_state = NULL;
}
DEBUG(10, ("cli_connection_free: closed: %s\n", BOOLSTR(closed)));
if (closed)
{
for (i = 0; i < num_cons; i++)
{
struct cli_connection *c = con_list[i];
if (c != NULL && con != c && c->pCli_state == oldcli)
{
/* WHOOPS! fnum already open: too bad!!!
get rid of all other connections that
were using that connection
*/
c->pCli_state = NULL;
}
}
}
/* don't free the cli_state since it is being handled
by the *clis list in rpc_client/cli_use.c.
This code needs to be fixed badly. It is **way**
to complicated. --jerry */
/* if (oldcli != NULL)
{
free(oldcli);
} */
if (con->srv_name != NULL)
{
free(con->srv_name);
con->srv_name = NULL;
}
if (con->pipe_name != NULL)
{
free(con->pipe_name);
con->pipe_name = NULL;
}
if (con->auth_info != NULL)
{
free(con->auth_info);
con->auth_info = NULL;
}
memset(&con->usr_creds, 0, sizeof(con->usr_creds));
for (i = 0; i < num_cons; i++)
{
if (con == con_list[i])
{
con_list[i] = NULL;
}
}
free(con);
}
void cli_connection_unlink(struct cli_connection *con)
{
if (con != NULL)
{
cli_connection_free(con);
}
return;
}
/****************************************************************************
init client state
****************************************************************************/
BOOL cli_connection_init(const char *srv_name, char *pipe_name,
struct cli_connection **con)
{
return cli_connection_init_auth(srv_name, pipe_name, con, NULL, NULL);
}
/****************************************************************************
init client state
****************************************************************************/
BOOL cli_connection_init_auth(const char *srv_name, char *pipe_name,
struct cli_connection **con,
cli_auth_fns * auth, void *auth_creds)
{
BOOL reuse = True;
/*
* allocate
*/
DEBUG(10, ("cli_connection_init_auth: %s %s\n",
srv_name != NULL ? srv_name : "<null>", pipe_name));
*con = cli_con_get(srv_name, pipe_name, auth, auth_creds, reuse);
return (*con) != NULL;
}
/****************************************************************************
get auth functions associated with an msrpc session.
****************************************************************************/
struct _cli_auth_fns *cli_conn_get_authfns(struct cli_connection *con)
{
return con != NULL ? con->auth : NULL;
}
/****************************************************************************
get auth info associated with an msrpc session.
****************************************************************************/
void *cli_conn_get_auth_creds(struct cli_connection *con)
{
return con != NULL ? con->auth_creds : NULL;
}
/****************************************************************************
send a request on an rpc pipe.
****************************************************************************/
BOOL rpc_hnd_pipe_req(const POLICY_HND * hnd, uint8 op_num,
prs_struct * data, prs_struct * rdata)
{
struct cli_connection *con = NULL;
/* we need this to locate the cli_connection associated
with the POLICY_HND */
if ((con=RpcHndList_get_connection(hnd)) == NULL)
return False;
if (!rpc_con_ok(con)) return False;
return rpc_con_pipe_req(con, op_num, data, rdata);
}
/****************************************************************************
send a request on an rpc pipe.
****************************************************************************/
BOOL rpc_con_pipe_req(struct cli_connection *con, uint8 op_num,
prs_struct * data, prs_struct * rdata)
{
BOOL ret;
DEBUG(10, ("rpc_con_pipe_req: op_num %d offset %d used: %d\n",
op_num, data->data_offset, data->buffer_size));
prs_dump("in_rpcclient", (int)op_num, data);
/* Why does this use prs->data_offset? --jerry */
/* prs_realloc_data(data, data->data_offset); */
ret = rpc_api_pipe_req(con->pCli_state, op_num, data, rdata);
prs_dump("out_rpcclient", (int)op_num, rdata);
return ret;
}
/****************************************************************************
this allows us to detect dead servers. The cli->fd is set to -1 when
we get an error
*****************************************************************************/
BOOL rpc_con_ok(struct cli_connection *con)
{
if (!con)
return False;
if (!con->pCli_state)
return False;
if (con->pCli_state->fd == -1)
return False;
return True;
}