first pass at merging rpcclient from TNG to HEAD. You can get a

semi-connection and a rpcclient prompt, but no functionality there yet.
Will be a few more days on that.

--jerry

source/lib/msrpc-client.c

@@ -129,6 +129,38 @@ BOOL msrpc_receive(int fd, prs_struct *ps)
 	return True;
 }
 
+/****************************************************************************
+close the socket descriptor
+****************************************************************************/
+static void ncalrpc_l_close_socket(struct msrpc_local *msrpc)
+{
+        if (msrpc->fd != -1)
+        {
+                close(msrpc->fd);
+        }
+        msrpc->fd = -1;
+}
+
+
+/****************************************************************************
+shutdown a msrpcent structure
+****************************************************************************/
+void ncalrpc_l_shutdown(struct msrpc_local *msrpc)
+{
+        DEBUG(10, ("msrpc_shutdown\n"));
+        if (msrpc->outbuf)
+        {
+                free(msrpc->outbuf);
+        }
+        if (msrpc->inbuf)
+        {
+                free(msrpc->inbuf);
+        }
+        ncalrpc_l_close_socket(msrpc);
+        memset(msrpc, 0, sizeof(*msrpc));
+}
+
+
 /****************************************************************************
 open the msrpcent sockets
 ****************************************************************************/

source/rpc_client/cli_connect.c

@@ -0,0 +1,190 @@
+/* 
+   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"
+
+enum
+{ MSRPC_NONE, MSRPC_LOCAL, MSRPC_SMB };
+
+struct cli_connection
+{
+	uint32 num_connections;
+	char *srv_name;
+	char *pipe_name;
+	struct user_creds usr_creds;
+
+	int type;
+
+	union
+	{
+		struct ncacn_np *smb;
+		struct msrpc_local *local;
+		void *cli;
+	} msrpc;
+
+	cli_auth_fns *auth;
+	void *auth_info;
+	void *auth_creds;
+};
+
+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;
+
+
+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);
+}
+
+
+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();
+}
+
+/****************************************************************************
+terminate client connection
+****************************************************************************/
+void cli_connection_free(struct cli_connection *con)
+{
+        BOOL closed = False;
+        void *oldcli = NULL;
+        int i;
+
+        DEBUG(10, ("cli_connection_free: %d\n", __LINE__));
+
+        if (con->msrpc.cli != NULL)
+        {
+                switch (con->type)
+                {
+                        case MSRPC_LOCAL:
+                        {
+                                DEBUG(10, ("msrpc local connection\n"));
+                                ncalrpc_l_use_del(con->pipe_name,
+                                                  &con->msrpc.local->nt.key,
+                                                  False, &closed);
+                                oldcli = con->msrpc.local;
+                                con->msrpc.local = NULL;
+                                break;
+                        }
+                        case MSRPC_SMB:
+                        {
+                                DEBUG(10, ("msrpc smb connection\n"));
+                                ncacn_np_use_del(con->srv_name,
+                                                 con->pipe_name,
+                                                 &con->msrpc.smb->smb->key,
+                                                 False, &closed);
+                                oldcli = con->msrpc.local;
+                                con->msrpc.smb = NULL;
+                                break;
+                        }
+                }
+        }
+
+        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->msrpc.cli == oldcli)
+                        {
+                                /* WHOOPS! fnum already open: too bad!!!
+                                   get rid of all other connections that
+                                   were using that connection
+                                 */
+                                switch (c->type)
+                                {
+                                        case MSRPC_LOCAL:
+                                        {
+                                                c->msrpc.local = NULL;
+                                                break;
+                                        }
+                                        case MSRPC_SMB:
+                                        {
+                                                c->msrpc.smb = NULL;
+                                                break;
+                                        }
+                                }
+                        }
+                }
+        }
+
+        if (con->msrpc.cli != NULL)
+        {
+                free(con->msrpc.cli);
+        }
+        con->msrpc.cli = NULL;
+
+        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);
+}

source/rpc_client/cli_use.c

@@ -0,0 +1,448 @@
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   SMB client generic functions
+   Copyright (C) Andrew Tridgell 1994-1999
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1999
+   
+   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 "trans2.h"
+#include "rpc_client.h"
+
+extern int DEBUGLEVEL;
+extern pstring scope;
+extern pstring global_myname;
+
+struct cli_use
+{
+	struct cli_state *cli;
+	uint32 num_users;
+};
+
+static struct cli_use **clis = NULL;
+static uint32 num_clis = 0;
+
+/****************************************************************************
+terminate client connection
+****************************************************************************/
+static void cli_use_free(struct cli_use *cli)
+{
+	if (cli->cli != NULL)
+	{
+		if (cli->cli->initialised)
+		{
+			cli_ulogoff(cli->cli);
+			cli_shutdown(cli->cli);
+		}
+		free(cli->cli);
+	}
+
+	free(cli);
+}
+
+/****************************************************************************
+free a client array
+****************************************************************************/
+static void free_cli_array(uint32 num_entries, struct cli_use **entries)
+{
+	void (*fn) (void *) = (void (*)(void *))&cli_use_free;
+	free_void_array(num_entries, (void **)entries, *fn);
+}
+
+/****************************************************************************
+add a client state to the array
+****************************************************************************/
+static struct cli_use *add_cli_to_array(uint32 *len,
+					struct cli_use ***array,
+					struct cli_use *cli)
+{
+	int i;
+	for (i = 0; i < num_clis; i++)
+	{
+		if (clis[i] == NULL)
+		{
+			clis[i] = cli;
+			return cli;
+		}
+	}
+
+	return (struct cli_use *)add_item_to_array(len,
+						   (void ***)array,
+						   (void *)cli);
+
+}
+
+/****************************************************************************
+initiate client array
+****************************************************************************/
+void init_cli_use(void)
+{
+	clis = NULL;
+	num_clis = 0;
+}
+
+/****************************************************************************
+terminate client array
+****************************************************************************/
+void free_cli_use(void)
+{
+	free_cli_array(num_clis, clis);
+	init_cli_use();
+}
+
+/****************************************************************************
+find client state.  server name, user name, domain name and password must all
+match.
+****************************************************************************/
+static struct cli_use *cli_find(const char *srv_name,
+				const struct ntuser_creds *usr_creds,
+				BOOL reuse)
+{
+	int i;
+	const char *sv_name = srv_name;
+	struct ntuser_creds null_usr;
+
+	if (usr_creds == NULL)
+	{
+		copy_nt_creds(&null_usr, usr_creds);
+		usr_creds = &null_usr;
+	}
+
+	if (strnequal("\\\\", sv_name, 2))
+	{
+		sv_name = &sv_name[2];
+	}
+
+	DEBUG(10, ("cli_find: %s %s %s reuse: %s\n",
+		   srv_name, usr_creds->user_name, usr_creds->domain,
+		   BOOLSTR(reuse)));
+
+
+	for (i = 0; i < num_clis; i++)
+	{
+		char *cli_name = NULL;
+		struct cli_use *c = clis[i];
+
+		if (c == NULL || !c->cli->initialised || c->cli->fd == -1)
+		{
+			continue;
+		}
+
+		cli_name = c->cli->desthost;
+
+		DEBUG(10, ("cli_find[%d]: %s %s %s\n",
+			   i, cli_name,
+			   c->cli->user_name, c->cli->domain));
+
+		if (strnequal("\\\\", cli_name, 2))
+		{
+			cli_name = &cli_name[2];
+		}
+
+		if (!strequal(cli_name, sv_name))
+		{
+			continue;
+		}
+		if (strequal(usr_creds->user_name, "") &&
+		    strequal(usr_creds->domain, "") &&
+		    pwd_is_nullpwd(&usr_creds->pwd))
+		{
+			return c;
+		}
+		if (!strequal(usr_creds->user_name, c->cli->user_name))
+		{
+			continue;
+		}
+		if (!reuse && !pwd_compare(&usr_creds->pwd, &c->cli->pwd))
+		{
+			DEBUG(100, ("password doesn't match\n"));
+			continue;
+		}
+		if (usr_creds->domain[0] == 0)
+		{
+			return c;
+		}
+		if (strequal(usr_creds->domain, c->cli->domain))
+		{
+			return c;
+		}
+	}
+
+	return NULL;
+}
+
+/****************************************************************************
+create a new client state from user credentials
+****************************************************************************/
+static struct cli_use *cli_use_get(const char *srv_name,
+				   const struct ntuser_creds *usr_creds)
+{
+	struct cli_use *cli = (struct cli_use *)malloc(sizeof(*cli));
+
+	if (cli == NULL)
+	{
+		return NULL;
+	}
+
+	memset(cli, 0, sizeof(*cli));
+
+	cli->cli = cli_initialise(NULL);
+
+	if (cli->cli == NULL)
+	{
+		return NULL;
+	}
+
+	cli_init_creds(cli->cli, usr_creds);
+
+	return cli;
+}
+
+/****************************************************************************
+init client state
+****************************************************************************/
+struct cli_state *cli_net_use_add(const char *srv_name,
+				  const struct ntuser_creds *usr_creds,
+				  BOOL reuse, BOOL *is_new)
+{
+	struct nmb_name calling;
+	struct nmb_name called;
+	struct in_addr *dest_ip = NULL;
+	fstring dest_host;
+	struct in_addr ip;
+	struct cli_use *cli;
+
+	DEBUG(10, ("cli_net_use_add\n"));
+
+	cli = cli_find(srv_name, usr_creds, reuse);
+
+	if (cli != NULL)
+	{
+		cli->num_users++;
+		DEBUG(10,
+		      ("cli_net_use_add: num_users: %d\n", cli->num_users));
+		(*is_new) = False;
+		return cli->cli;
+	}
+
+	/* reuse an existing connection requested, and one was not found */
+	if (usr_creds != NULL && reuse)
+	{
+		return False;
+	}
+
+	/*
+	 * allocate
+	 */
+
+	cli = cli_use_get(srv_name, usr_creds);
+
+	if (resolve_srv_name(srv_name, dest_host, &ip))
+	{
+		dest_ip = &ip;
+	}
+	else
+	{
+		cli_use_free(cli);
+		return NULL;
+	}
+
+	make_nmb_name(&called, dns_to_netbios_name(dest_host), 0x20);
+	make_nmb_name(&calling, dns_to_netbios_name(global_myname), 0);
+
+	/*
+	 * connect
+	 */
+
+	if (!cli_establish_connection(cli->cli,
+				      dest_host, dest_ip,
+				      &calling, &called,
+				      "IPC$", "IPC", False, True))
+	{
+		DEBUG(0, ("cli_net_use_add: connection failed\n"));
+		cli_use_free(cli);
+		return NULL;
+	}
+
+	add_cli_to_array(&num_clis, &clis, cli);
+	cli->num_users++;
+
+	DEBUG(10, ("cli_net_use_add: num_users: %d\n", cli->num_users));
+
+	(*is_new) = True;
+
+	return cli->cli;
+}
+
+/****************************************************************************
+delete a client state
+****************************************************************************/
+BOOL cli_net_use_del(const char *srv_name,
+		     const struct ntuser_creds *usr_creds,
+		     BOOL force_close, BOOL *connection_closed)
+{
+	int i;
+	const char *sv_name = srv_name;
+
+	DEBUG(10, ("cli_net_use_del: %s. %s. %s. force close: %s\n",
+		   srv_name,
+		   usr_creds ? usr_creds->user_name : "",
+		   usr_creds ? usr_creds->domain : "", BOOLSTR(force_close)));
+
+	if (strnequal("\\\\", sv_name, 2))
+	{
+		sv_name = &sv_name[2];
+	}
+
+	if (connection_closed != NULL)
+	{
+		*connection_closed = False;
+	}
+
+	for (i = 0; i < num_clis; i++)
+	{
+		char *cli_name = NULL;
+
+		if (clis[i] == NULL)
+			continue;
+		if (clis[i]->cli == NULL)
+			continue;
+
+		cli_name = clis[i]->cli->desthost;
+
+		DEBUG(10, ("connection: %s %s %s\n", cli_name,
+			   clis[i]->cli->user_name,
+			   clis[i]->cli->domain));
+
+		if (strnequal("\\\\", cli_name, 2))
+		{
+			cli_name = &cli_name[2];
+		}
+
+		if (!strequal(cli_name, sv_name))
+			continue;
+
+		if (strequal(usr_creds ? usr_creds->user_name : "",
+			     clis[i]->cli->user_name) &&
+		    strequal(usr_creds ? usr_creds->domain : "",
+			     clis[i]->cli->domain))
+		{
+			/* decrement number of users */
+			clis[i]->num_users--;
+
+			DEBUG(10, ("idx: %i num_users now: %d\n",
+				   i, clis[i]->num_users));
+
+			if (force_close || clis[i]->num_users == 0)
+			{
+				cli_use_free(clis[i]);
+				clis[i] = NULL;
+				if (connection_closed != NULL)
+				{
+					*connection_closed = True;
+				}
+			}
+			return True;
+		}
+	}
+
+	return False;
+}
+
+/****************************************************************************
+enumerate client states
+****************************************************************************/
+void cli_net_use_enum(uint32 *num_cons, struct use_info ***use)
+{
+	int i;
+
+	*num_cons = 0;
+	*use = NULL;
+
+	for (i = 0; i < num_clis; i++)
+	{
+		struct use_info item;
+
+		ZERO_STRUCT(item);
+
+		if (clis[i] == NULL)
+			continue;
+
+		item.connected = clis[i]->cli != NULL ? True : False;
+
+		if (item.connected)
+		{
+			item.srv_name = clis[i]->cli->desthost;
+			item.user_name = clis[i]->cli->user_name;
+			item.key = clis[i]->cli->key;
+			item.domain = clis[i]->cli->domain;
+		}
+
+		add_use_info_to_array(num_cons, use, &item);
+	}
+}
+
+
+/****************************************************************************
+wait for keyboard activity, swallowing network packets on all client states.
+****************************************************************************/
+void cli_use_wait_keyboard(void)
+{
+	fd_set fds;
+	struct timeval timeout;
+
+	while (1)
+	{
+		int i;
+		int maxfd = fileno(stdin);
+		FD_ZERO(&fds);
+		FD_SET(fileno(stdin), &fds);
+		for (i = 0; i < num_clis; i++)
+		{
+			if (clis[i] != NULL && clis[i]->cli != NULL)
+			{
+				int fd = clis[i]->cli->fd;
+				FD_SET(fd, &fds);
+				maxfd = MAX(fd, maxfd);
+			}
+		}
+
+		timeout.tv_sec = 20;
+		timeout.tv_usec = 0;
+		sys_select(maxfd + 1, &fds, &timeout);
+
+		if (FD_ISSET(fileno(stdin), &fds))
+			return;
+
+		/* We deliberately use receive_smb instead of
+		   client_receive_smb as we want to receive
+		   session keepalives and then drop them here.
+		 */
+		for (i = 0; i < num_clis; i++)
+		{
+			int fd;
+			if (clis[i] == NULL || clis[i]->cli == NULL)
+				continue;
+			fd = clis[i]->cli->fd;
+			if (FD_ISSET(fd, &fds))
+				receive_smb(fd, clis[i]->cli->inbuf, 0);
+		}
+	}
+}

source/rpc_client/ncacn_np_use.c

@@ -0,0 +1,173 @@
+/*
+   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"
+#include "trans2.h"
+
+extern int DEBUGLEVEL;
+extern pstring global_myname;
+
+struct ncacn_np_use
+{
+        struct ncacn_np *cli;
+        uint32 num_users;
+};
+
+static struct ncacn_np_use **msrpcs = NULL;
+static uint32 num_msrpcs = 0;
+
+/****************************************************************************
+terminate client connection
+****************************************************************************/
+static void ncacn_np_shutdown(struct ncacn_np *cli)
+{
+        if (cli != NULL)
+        {
+                if (cli->smb != NULL)
+                {
+                        if (cli->smb->initialised)
+                        {
+                                /* cli_nt_session_close(cli->smb, cli->fnum); JERRY */
+                                cli_nt_session_close(cli->smb);
+                        }
+#if 0  /* commented out by JERRY */
+                        cli_net_use_del(cli->smb->desthost,
+                                        &cli->smb->usr, False, False);
+#endif
+                }
+        }
+}
+
+
+/****************************************************************************
+terminate client connection
+****************************************************************************/
+static void ncacn_np_use_free(struct ncacn_np_use *cli)
+{
+        if (cli->cli != NULL)
+        {
+                if (cli->cli->initialised)
+                {
+                        ncacn_np_shutdown(cli->cli);
+                }
+                ZERO_STRUCTP(cli->cli);
+                free(cli->cli);
+        }
+        ZERO_STRUCTP(cli);
+        free(cli);
+}
+
+
+/****************************************************************************
+delete a client state
+****************************************************************************/
+BOOL ncacn_np_use_del(const char *srv_name, const char *pipe_name,
+                      const vuser_key * key,
+                      BOOL force_close, BOOL *connection_closed)
+{
+        int i;
+        DEBUG(10, ("ncacn_np_net_use_del: %s. force close: %s ",
+                   pipe_name, BOOLSTR(force_close)));
+        if (key != NULL)
+        {
+                DEBUG(10, ("[%d,%x]", key->pid, key->vuid));
+        }
+        DEBUG(10, ("\n"));
+
+        if (connection_closed != NULL)
+        {
+                *connection_closed = False;
+        }
+
+        if (strnequal("\\PIPE\\", pipe_name, 6))
+        {
+                pipe_name = &pipe_name[6];
+        }
+
+        if (strnequal("\\\\", srv_name, 2))
+        {
+                srv_name = &srv_name[6];
+        }
+
+        for (i = 0; i < num_msrpcs; i++)
+        {
+                char *ncacn_np_name = NULL;
+                char *ncacn_np_srv_name = NULL;
+                struct ncacn_np_use *c = msrpcs[i];
+                vuser_key k;
+
+                if (c == NULL || c->cli == NULL || c->cli->smb == NULL)
+                        continue;
+
+                ncacn_np_name = c->cli->pipe_name;
+                ncacn_np_srv_name = c->cli->smb->desthost;
+
+                k = c->cli->smb->key;
+
+                DEBUG(10, ("use_del[%d]: %s %s %s %s [%d,%x]\n",
+                           i, ncacn_np_name, ncacn_np_srv_name,
+                           c->cli->smb->user_name,
+                           c->cli->smb->domain, k.pid, k.vuid));
+
+                if (strnequal("\\PIPE\\", ncacn_np_name, 6))
+                {
+                        ncacn_np_name = &ncacn_np_name[6];
+                }
+                if (!strequal(ncacn_np_srv_name, srv_name))
+                {
+                        continue;
+                }
+                if (strnequal("\\\\", ncacn_np_srv_name, 2))
+                {
+                        ncacn_np_srv_name = &ncacn_np_srv_name[6];
+                }
+                if (!strequal(ncacn_np_name, pipe_name))
+                {
+                        continue;
+                }
+                if (key->pid != k.pid || key->vuid != k.vuid)
+                {
+                        continue;
+                }
+                /* decrement number of users */
+                c->num_users--;
+                DEBUG(10, ("idx: %i num_users now: %d\n",
+                           i, c->num_users));
+                if (force_close || c->num_users == 0)
+                {
+                        ncacn_np_use_free(c);
+                        msrpcs[i] = NULL;
+                        if (connection_closed != NULL)
+                        {
+                                *connection_closed = True;
+                        }
+                }
+                return True;
+        }
+
+        return False;
+}
+

source/rpc_client/ncalrpc_l_use.c

@@ -0,0 +1,127 @@
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   SMB client generic functions
+   Copyright (C) Andrew Tridgell 1994-1999
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1999
+   
+   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"
+
+extern int DEBUGLEVEL;
+
+struct ncalrpc_use
+{
+        struct msrpc_local *cli;
+        uint32 num_users;
+};
+
+static struct ncalrpc_use **clis = NULL;
+static uint32 num_clis = 0;
+
+/****************************************************************************
+terminate client connection
+****************************************************************************/
+static void ncalrpc_use_free(struct ncalrpc_use *cli)
+{
+        if (cli->cli != NULL)
+        {
+                if (cli->cli->initialised)
+                {
+                        ncalrpc_l_shutdown(cli->cli);
+                }
+                free(cli->cli);
+        }
+
+        free(cli);
+}
+
+/****************************************************************************
+delete a client state
+****************************************************************************/
+BOOL ncalrpc_l_use_del(const char *pipe_name,
+                       const vuser_key * key,
+                       BOOL force_close, BOOL *connection_closed)
+{
+        int i;
+
+        if (strnequal("\\PIPE\\", pipe_name, 6))
+        {
+                pipe_name = &pipe_name[6];
+        }
+
+        DEBUG(10, ("ncalrpc_l_use_del: %s. [%d,%x] force close: %s\n",
+                   pipe_name, key->pid, key->vuid, BOOLSTR(force_close)));
+
+        if (connection_closed != NULL)
+        {
+                *connection_closed = False;
+        }
+
+        for (i = 0; i < num_clis; i++)
+        {
+                char *ncalrpc_name = NULL;
+
+                if (clis[i] == NULL)
+                        continue;
+                if (clis[i]->cli == NULL)
+                        continue;
+
+                ncalrpc_name = clis[i]->cli->pipe_name;
+
+                if (strnequal("\\PIPE\\", pipe_name, 6))
+                {
+                        ncalrpc_name = &ncalrpc_name[6];
+                }
+
+                DEBUG(10, ("connection: %s [%d,%x]", ncalrpc_name,
+                           clis[i]->cli->nt.key.pid,
+                           clis[i]->cli->nt.key.vuid));
+
+                if (!strequal(ncalrpc_name, pipe_name))
+                        continue;
+
+                if (key->pid != clis[i]->cli->nt.key.pid ||
+                    key->vuid != clis[i]->cli->nt.key.vuid)
+                {
+                        continue;
+                }
+                /* decrement number of users */
+                clis[i]->num_users--;
+
+                DEBUG(10, ("idx: %i num_users now: %d\n",
+                           i, clis[i]->num_users));
+
+                if (force_close || clis[i]->num_users == 0)
+                {
+                        ncalrpc_use_free(clis[i]);
+                        clis[i] = NULL;
+                        if (connection_closed != NULL)
+                        {
+                                *connection_closed = True;
+                        }
+                }
+                return True;
+        }
+
+        return False;
+}
+
+

source/rpcclient/rpcclient.c

@@ -2,7 +2,8 @@
    Unix SMB/Netbios implementation.
    Version 1.9.
    SMB client
-   Copyright (C) Andrew Tridgell 1994-1998
+   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
@@ -19,754 +20,24 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#ifdef SYSLOG
-#undef SYSLOG
-#endif
-
 #include "includes.h"
+#include "ntdomain.h"
+#include "rpcclient.h"
 
-#ifndef REGISTER
+ int main(int argc, char *argv[])
-#define REGISTER 0
-#endif
-
-extern pstring debugf;
-extern pstring global_myname;
-
-extern pstring user_socket_options;
-
-
-extern int DEBUGLEVEL;
-
-
-extern file_info def_finfo;
-
-#define CNV_LANG(s) dos2unix_format(s,False)
-#define CNV_INPUT(s) unix2dos_format(s,True)
-
-static int process_tok(fstring tok);
-static void cmd_help(struct client_info *info);
-static void cmd_quit(struct client_info *info);
-
-static struct cli_state smbcli;
-struct cli_state *smb_cli = &smbcli;
-
-FILE *out_hnd;
-
-/****************************************************************************
-initialise smb client structure
-****************************************************************************/
-void rpcclient_init(void)
 {
-	memset((char *)smb_cli, '\0', sizeof(smb_cli));
-	cli_initialise(smb_cli);
-	smb_cli->capabilities |= CAP_NT_SMBS | CAP_STATUS32;
-}
-
-/****************************************************************************
-make smb client connection
-****************************************************************************/
-static BOOL rpcclient_connect(struct client_info *info)
-{
-	struct nmb_name calling;
-	struct nmb_name called;
-
-	make_nmb_name(&called , dns_to_netbios_name(info->dest_host ), info->name_type);
-	make_nmb_name(&calling, dns_to_netbios_name(info->myhostname), 0x0            );
-
-	if (!cli_establish_connection(smb_cli, 
-	                          info->dest_host, &info->dest_ip, 
-	                          &calling, &called,
-	                          info->share, info->svc_type,
-	                          False, True))
-	{
-		DEBUG(0,("rpcclient_connect: connection failed\n"));
-		cli_shutdown(smb_cli);
-		return False;
-	}
-
-	return True;
-}
-
-/****************************************************************************
-stop the smb connection(s?)
-****************************************************************************/
-static void rpcclient_stop(void)
-{
-	cli_shutdown(smb_cli);
-}
-/****************************************************************************
- This defines the commands supported by this client
- ****************************************************************************/
-struct
-{
-  char *name;
-  void (*fn)(struct client_info*);
-  char *description;
-} commands[] = 
-{
-  {"regenum",    cmd_reg_enum,         "<keyname> Registry Enumeration (keys, values)"},
-  {"regdeletekey",cmd_reg_delete_key,  "<keyname> Registry Key Delete"},
-  {"regcreatekey",cmd_reg_create_key,  "<keyname> [keyclass] Registry Key Create"},
-  {"regquerykey",cmd_reg_query_key,    "<keyname> Registry Key Query"},
-  {"regdeleteval",cmd_reg_delete_val,  "<valname> Registry Value Delete"},
-  {"regcreateval",cmd_reg_create_val,  "<valname> <valtype> <value> Registry Key Create"},
-  {"reggetsec",  cmd_reg_get_key_sec,  "<keyname> Registry Key Security"},
-  {"regtestsec", cmd_reg_test_key_sec, "<keyname> Test Registry Key Security"},
-  {"ntlogin",    cmd_netlogon_login_test, "[username] [password] NT Domain login test"},
-  {"wksinfo",    cmd_wks_query_info,   "Workstation Query Info"},
-  {"srvinfo",    cmd_srv_query_info,   "Server Query Info"},
-  {"srvsessions",cmd_srv_enum_sess,    "List sessions on a server"},
-  {"srvshares",  cmd_srv_enum_shares,  "List shares on a server"},
-  {"srvconnections",cmd_srv_enum_conn, "List connections on a server"},
-  {"srvfiles",   cmd_srv_enum_files,   "List files on a server"},
-  {"lsaquery",   cmd_lsa_query_info,   "Query Info Policy (domain member or server)"},
-  {"lookupsids", cmd_lsa_lookup_sids,  "Resolve names from SIDs"},
-  {"enumusers",  cmd_sam_enum_users,   "SAM User Database Query (experimental!)"},
-  {"ntpass",     cmd_sam_ntchange_pwd, "NT SAM Password Change"},
-  {"samuser",    cmd_sam_query_user,   "<username> SAM User Query (experimental!)"},
-  {"samtest",    cmd_sam_test      ,   "SAM User Encrypted RPC test (experimental!)"},
-  {"enumaliases",cmd_sam_enum_aliases, "SAM Aliases Database Query (experimental!)"},
 #if 0
-  {"enumgroups", cmd_sam_enum_groups,  "SAM Group Database Query (experimental!)"},
+	add_lsa_commands();
-#endif
+	add_net_commands();
-  {"samgroups",  cmd_sam_query_groups, "SAM Group Database Query (experimental!)"},
+	add_evt_commands();
-  {"quit",       cmd_quit,        "logoff the server"},
+	add_sam_commands();
-  {"q",          cmd_quit,        "logoff the server"},
+	add_svc_commands();
-  {"exit",       cmd_quit,        "logoff the server"},
+	add_reg_commands();
-  {"bye",        cmd_quit,        "logoff the server"},
+	add_ntl_commands();
-  {"help",       cmd_help,        "[command] give help on a command"},
+	add_at_commands();
-  {"?",          cmd_help,        "[command] give help on a command"},
+	add_spl_commands();
-  {"!",          NULL,            "run a shell command on the local system"},
+	add_dfs_commands();
-  {"",           NULL,            NULL}
-};
-
-
-/****************************************************************************
-do a (presumably graceful) quit...
-****************************************************************************/
-static void cmd_quit(struct client_info *info)
-{
-	rpcclient_stop();
-	exit(0);
-}
-
-/****************************************************************************
-help
-****************************************************************************/
-static void cmd_help(struct client_info *info)
-{
-  int i=0,j;
-  fstring buf;
-
-  if (next_token(NULL,buf,NULL, sizeof(buf)))
-    {
-      if ((i = process_tok(buf)) >= 0)
-	fprintf(out_hnd, "HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description);		    
-    }
-  else
-    while (commands[i].description)
-      {
-	for (j=0; commands[i].description && (j<5); j++) {
-	  fprintf(out_hnd, "%-15s",commands[i].name);
-	  i++;
-	}
-	fprintf(out_hnd, "\n");
-      }
-}
-
-/*******************************************************************
-  lookup a command string in the list of commands, including 
-  abbreviations
-  ******************************************************************/
-static int process_tok(fstring tok)
-{
-  int i = 0, matches = 0;
-  int cmd=0;
-  int tok_len = strlen(tok);
-  
-  while (commands[i].fn != NULL)
-    {
-      if (strequal(commands[i].name,tok))
-	{
-	  matches = 1;
-	  cmd = i;
-	  break;
-	}
-      else if (strnequal(commands[i].name, tok, tok_len))
-	{
-	  matches++;
-	  cmd = i;
-	}
-      i++;
-    }
-  
-  if (matches == 0)
-    return(-1);
-  else if (matches == 1)
-    return(cmd);
-  else
-    return(-2);
-}
-
-/****************************************************************************
-wait for keyboard activity, swallowing network packets
-****************************************************************************/
-static void wait_keyboard(struct cli_state *cli)
-{
-  fd_set fds;
-  struct timeval timeout;
-  
-  while (1) 
-    {
-      FD_ZERO(&fds);
-      FD_SET(cli->fd,&fds);
-      FD_SET(fileno(stdin),&fds);
-
-      timeout.tv_sec = 20;
-      timeout.tv_usec = 0;
-      sys_select_intr(MAX(cli->fd,fileno(stdin))+1,&fds,&timeout);
-      
-      if (FD_ISSET(fileno(stdin),&fds))
-  	return;
-
-      /* We deliberately use receive_smb instead of
-         client_receive_smb as we want to receive
-         session keepalives and then drop them here.
-       */
-      if (FD_ISSET(cli->fd,&fds))
-  	receive_smb(cli->fd,cli->inbuf,0);
-    }  
-}
-
-/****************************************************************************
-  process commands from the client
-****************************************************************************/
-static void do_command(struct client_info *info, char *tok, char *line)
-{
-	int i;
-
-	if ((i = process_tok(tok)) >= 0)
-	{
-		commands[i].fn(info);
-	}
-	else if (i == -2)
-	{
-		fprintf(out_hnd, "%s: command abbreviation ambiguous\n", CNV_LANG(tok));
-	}
-	else
-	{
-		fprintf(out_hnd, "%s: command not found\n", CNV_LANG(tok));
-	}
-}
-
-/****************************************************************************
-  process commands from the client
-****************************************************************************/
-static BOOL process( struct client_info *info, char *cmd_str)
-{
-	pstring line;
-	char *cmd = cmd_str;
-
-	if (cmd[0] != '\0') while (cmd[0] != '\0')
-	{
-		char *p;
-		fstring tok;
-
-		if ((p = strchr(cmd, ';')) == 0)
-		{
-			strncpy(line, cmd, 999);
-			line[1000] = '\0';
-			cmd += strlen(cmd);
-		}
-		else
-		{
-			if (p - cmd > 999) p = cmd + 999;
-			strncpy(line, cmd, p - cmd);
-			line[p - cmd] = '\0';
-			cmd = p + 1;
-		}
-
-		/* input language code to internal one */
-		CNV_INPUT (line);
-
-		/* get the first part of the command */
-		{
-			char *ptr = line;
-			if (!next_token(&ptr,tok,NULL, sizeof(tok))) continue;
-		}
-
-		do_command(info, tok, line);
-	}
-	else while (!feof(stdin))
-	{
-		fstring tok;
-
-		/* display a prompt */
-		fprintf(out_hnd, "smb: %s> ", CNV_LANG(info->cur_dir));
-		fflush(out_hnd);
-
-#ifdef CLIX
-		line[0] = wait_keyboard(smb_cli);
-		/* this might not be such a good idea... */
-		if ( line[0] == EOF)
-		{
-			break;
-		}
-#else
-		wait_keyboard(smb_cli);
 #endif
 
-		/* and get a response */
+	return command_main(argc, argv);
-#ifdef CLIX
-		fgets( &line[1],999, stdin);
-#else
-		if (!fgets(line,1000,stdin))
-		{
-			break;
-		}
-#endif
-
-		/* input language code to internal one */
-		CNV_INPUT (line);
-
-		/* special case - first char is ! */
-		if (*line == '!')
-		{
-			system(line + 1);
-			continue;
-		}
-
-		fprintf(out_hnd, "%s\n", line);
-
-		/* get the first part of the command */
-		{
-			char *ptr = line;
-			if (!next_token(&ptr,tok,NULL, sizeof(tok))) continue;
-		}
-
-		do_command(info, tok, line);
-	}
-
-	return(True);
-}
-
-/****************************************************************************
-usage on the program
-****************************************************************************/
-static void usage(char *pname)
-{
-  fprintf(out_hnd, "Usage: %s service <password> [-d debuglevel] [-l log] ",
-	   pname);
-
-  fprintf(out_hnd, "\nVersion %s\n",VERSION);
-  fprintf(out_hnd, "\t-d debuglevel         set the debuglevel\n");
-  fprintf(out_hnd, "\t-l log basename.      Basename for log/debug files\n");
-  fprintf(out_hnd, "\t-n netbios name.      Use this name as my netbios name\n");
-  fprintf(out_hnd, "\t-N                    don't ask for a password\n");
-  fprintf(out_hnd, "\t-m max protocol       set the max protocol level\n");
-  fprintf(out_hnd, "\t-I dest IP            use this IP to connect to\n");
-  fprintf(out_hnd, "\t-E                    write messages to stderr instead of stdout\n");
-  fprintf(out_hnd, "\t-U username           set the network username\n");
-  fprintf(out_hnd, "\t-W workgroup          set the workgroup name\n");
-  fprintf(out_hnd, "\t-c command string     execute semicolon separated commands\n");
-  fprintf(out_hnd, "\t-t terminal code      terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n");
-  fprintf(out_hnd, "\n");
-}
-
-enum client_action
-{
-	CLIENT_NONE,
-	CLIENT_IPC,
-	CLIENT_SVC
-};
-
-/****************************************************************************
-  main program
-****************************************************************************/
- int main(int argc,char *argv[])
-{
-	BOOL interactive = True;
-	int opt;
-	extern FILE *dbf;
-	extern char *optarg;
-	extern int optind;
-	static pstring servicesf = CONFIGFILE;
-	pstring term_code;
-	char *p;
-	BOOL got_pass = False;
-	char *cmd_str="";
-	mode_t myumask = 0755;
-	enum client_action cli_action = CLIENT_NONE;
-
-	struct client_info cli_info;
-
-	pstring password; /* local copy only, if one is entered */
-
-	printf("Please use rpcclient from the SAMBA_TNG cvs tag.\n");
-	printf("Please refer to http://samba.org/cvs.html for details.\n");
-/*
-#ifndef DEBUG_PASSWORD
-	exit(-1);
-#endif
-*/
-
-	out_hnd = stdout;
-	fstrcpy(debugf, argv[0]);
-
-	rpcclient_init();
-
-#ifdef KANJI
-	pstrcpy(term_code, KANJI);
-#else /* KANJI */
-	*term_code = 0;
-#endif /* KANJI */
-
-	DEBUGLEVEL = 2;
-
-	cli_info.put_total_size = 0;
-	cli_info.put_total_time_ms = 0;
-	cli_info.get_total_size = 0;
-	cli_info.get_total_time_ms = 0;
-
-	cli_info.dir_total = 0;
-	cli_info.newer_than = 0;
-	cli_info.archive_level = 0;
-	cli_info.print_mode = 1;
-
-	cli_info.translation = False;
-	cli_info.recurse_dir = False;
-	cli_info.lowercase = False;
-	cli_info.prompt = True;
-	cli_info.abort_mget = True;
-
-	cli_info.dest_ip.s_addr = 0;
-	cli_info.name_type = 0x20;
-
-	pstrcpy(cli_info.cur_dir , "\\");
-	pstrcpy(cli_info.file_sel, "");
-	pstrcpy(cli_info.base_dir, "");
-	pstrcpy(smb_cli->domain, "");
-	pstrcpy(smb_cli->user_name, "");
-	pstrcpy(cli_info.myhostname, "");
-	pstrcpy(cli_info.dest_host, "");
-
-	pstrcpy(cli_info.svc_type, "A:");
-	pstrcpy(cli_info.share, "");
-	pstrcpy(cli_info.service, "");
-
-	ZERO_STRUCT(cli_info.dom.level3_sid);
-	ZERO_STRUCT(cli_info.dom.level5_sid);
-	fstrcpy(cli_info.dom.level3_dom, "");
-	fstrcpy(cli_info.dom.level5_dom, "");
-
-	smb_cli->nt_pipe_fnum   = 0xffff;
-
-	TimeInit();
-	charset_initialise();
-
-	myumask = umask(0);
-	umask(myumask);
-
-	if (!get_myname(global_myname))
-	{
-		fprintf(stderr, "Failed to get my hostname.\n");
-	}
-
-	if (getenv("USER"))
-	{
-		pstrcpy(smb_cli->user_name,getenv("USER"));
-
-		/* modification to support userid%passwd syntax in the USER var
-		25.Aug.97, jdblair@uab.edu */
-
-		if ((p=strchr(smb_cli->user_name,'%')))
-		{
-			*p = 0;
-			pstrcpy(password,p+1);
-			got_pass = True;
-			memset(strchr(getenv("USER"),'%')+1,'X',strlen(password));
-		}
-		strupper(smb_cli->user_name);
-	}
-
-	password[0] = 0;
-
-	/* modification to support PASSWD environmental var
-	   25.Aug.97, jdblair@uab.edu */
-	if (getenv("PASSWD"))
-	{
-		pstrcpy(password,getenv("PASSWD"));
-	}
-
-	if (*smb_cli->user_name == 0 && getenv("LOGNAME"))
-	{
-		pstrcpy(smb_cli->user_name,getenv("LOGNAME"));
-		strupper(smb_cli->user_name);
-	}
-
-	if (argc < 2)
-	{
-		usage(argv[0]);
-		exit(1);
-	}
-
-	if (*argv[1] != '-')
-	{
-
-		pstrcpy(cli_info.service, argv[1]);  
-		/* Convert any '/' characters in the service name to '\' characters */
-		string_replace( cli_info.service, '/','\\');
-		argc--;
-		argv++;
-
-		fprintf(out_hnd, "service: %s\n", cli_info.service);
-
-		if (count_chars(cli_info.service,'\\') < 3)
-		{
-			usage(argv[0]);
-			printf("\n%s: Not enough '\\' characters in service\n", cli_info.service);
-			exit(1);
-		}
-
-		/*
-		if (count_chars(cli_info.service,'\\') > 3)
-		{
-			usage(pname);
-			printf("\n%s: Too many '\\' characters in service\n", cli_info.service);
-			exit(1);
-		}
-		*/
-
-		if (argc > 1 && (*argv[1] != '-'))
-		{
-			got_pass = True;
-			pstrcpy(password,argv[1]);  
-			memset(argv[1],'X',strlen(argv[1]));
-			argc--;
-			argv++;
-		}
-
-		cli_action = CLIENT_SVC;
-	}
-
-	while ((opt = getopt(argc, argv,"s:O:M:S:i:N:n:d:l:hI:EB:U:L:t:m:W:T:D:c:")) != EOF)
-	{
-		switch (opt)
-		{
-			case 'm':
-			{
-				/* FIXME ... max_protocol seems to be funny here */
-
-				int max_protocol = 0;
-				max_protocol = interpret_protocol(optarg,max_protocol);
-				fprintf(stderr, "max protocol not currently supported\n");
-				break;
-			}
-
-			case 'O':
-			{
-				pstrcpy(user_socket_options,optarg);
-				break;	
-			}
-
-			case 'S':
-			{
-				pstrcpy(cli_info.dest_host,optarg);
-				strupper(cli_info.dest_host);
-				cli_action = CLIENT_IPC;
-				break;
-			}
-
-			case 'i':
-			{
-				extern pstring global_scope;
-				pstrcpy(global_scope, optarg);
-				strupper(global_scope);
-				break;
-			}
-
-			case 'U':
-			{
-				char *lp;
-				pstrcpy(smb_cli->user_name,optarg);
-				if ((lp=strchr(smb_cli->user_name,'%')))
-				{
-					*lp = 0;
-					pstrcpy(password,lp+1);
-					got_pass = True;
-					memset(strchr(optarg,'%')+1,'X',strlen(password));
-				}
-				break;
-			}
-
-			case 'W':
-			{
-				pstrcpy(smb_cli->domain,optarg);
-				break;
-			}
-
-			case 'E':
-			{
-				dbf = stderr;
-				break;
-			}
-
-			case 'I':
-			{
-				cli_info.dest_ip = *interpret_addr2(optarg);
-				if (zero_ip(cli_info.dest_ip))
-				{
-					exit(1);
-				}
-				break;
-			}
-
-			case 'n':
-			{
-				fstrcpy(global_myname, optarg);
-				break;
-			}
-
-			case 'N':
-			{
-				got_pass = True;
-				break;
-			}
-
-			case 'd':
-			{
-				if (*optarg == 'A')
-					DEBUGLEVEL = 10000;
-				else
-					DEBUGLEVEL = atoi(optarg);
-				break;
-			}
-
-			case 'l':
-			{
-				slprintf(debugf, sizeof(debugf)-1,
-				         "%s.client", optarg);
-				interactive = False;
-				break;
-			}
-
-			case 'c':
-			{
-				cmd_str = optarg;
-				got_pass = True;
-				break;
-			}
-
-			case 'h':
-			{
-				usage(argv[0]);
-				exit(0);
-				break;
-			}
-
-			case 's':
-			{
-				pstrcpy(servicesf, optarg);
-				break;
-			}
-
-			case 't':
-			{
-				pstrcpy(term_code, optarg);
-				break;
-			}
-
-			default:
-			{
-				usage(argv[0]);
-				exit(1);
-				break;
-			}
-		}
-	}
-
-	setup_logging(debugf, interactive);
-
-	if (cli_action == CLIENT_NONE)
-	{
-		usage(argv[0]);
-		exit(1);
-	}
-
-	strupper(global_myname);
-	fstrcpy(cli_info.myhostname, global_myname);
-
-	DEBUG(3,("%s client started (version %s)\n",timestring(False),VERSION));
-
-	if (!lp_load(servicesf,True, False, False))
-	{
-		fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf);
-	}
-
-	codepage_initialise(lp_client_code_page());
-
-	if (*smb_cli->domain == 0) pstrcpy(smb_cli->domain,lp_workgroup());
-
-	load_interfaces();
-
-	if (cli_action == CLIENT_IPC)
-	{
-		pstrcpy(cli_info.share, "IPC$");
-		pstrcpy(cli_info.svc_type, "IPC");
-	}
-
-	fstrcpy(cli_info.mach_acct, cli_info.myhostname);
-	strupper(cli_info.mach_acct);
-	fstrcat(cli_info.mach_acct, "$");
-
-	/* set the password cache info */
-	if (got_pass)
-	{
-		if (password[0] == 0)
-		{
-			pwd_set_nullpwd(&(smb_cli->pwd));
-		}
-		else
-		{
-			pwd_make_lm_nt_16(&(smb_cli->pwd), password); /* generate 16 byte hashes */
-		}
-	}
-	else 
-	{
-		pwd_read(&(smb_cli->pwd), "Enter Password:", True);
-	}
-
-	/* paranoia: destroy the local copy of the password */
-	memset((char *)password, '\0', sizeof(password)); 
-
-	/* establish connections.  nothing to stop these being re-established. */
-	rpcclient_connect(&cli_info);
-
-	DEBUG(5,("rpcclient_connect: smb_cli->fd:%d\n", smb_cli->fd));
-	if (smb_cli->fd <= 0)
-	{
-		fprintf(stderr, "warning: connection could not be established to %s<%02x>\n",
-		                 cli_info.dest_host, cli_info.name_type);
-		fprintf(stderr, "this version of smbclient may crash if you proceed\n");
-		exit(-1);
-	}
-
-	switch (cli_action)
-	{
-		case CLIENT_IPC:
-		{
-			process(&cli_info, cmd_str);
-			break;
-		}
-
-		default:
-		{
-			fprintf(stderr, "unknown client action requested\n");
-			break;
-		}
-	}
-
-	rpcclient_stop();
-
-	return(0);
 }

source/script/mkproto.awk

@@ -2,8 +2,12 @@ BEGIN {
   inheader=0;
 #  use_ldap_define = 0;
   current_file="";
-  print "#ifndef _PROTO_H_"
+  if (headername=="") {
-  print "#define _PROTO_H_"
+    headername="_PROTO_H_";
+  }
+
+  print "#ifndef",headername
+  print "#define",headername
   print "/* This file is automatically generated with \"make proto\". DO NOT EDIT */"
   print ""
 }

source/script/mkproto.sh

@@ -0,0 +1,41 @@
+#! /bin/sh
+
+LANG=C; export LANG
+LC_ALL=C; export LC_ALL
+LC_COLLATE=C; export LC_COLLATE
+
+if [ $# -lt 3 ]
+then
+  echo "Usage: $0 awk [-h headerdefine] outputheader proto_obj"
+  exit 1
+fi
+
+awk="$1"
+shift
+
+if [ x"$1" = x-h ]
+then
+  headeropt="-v headername=$2"
+  shift; shift;
+else
+  headeropt=""
+fi
+
+header="$1"
+shift
+headertmp="$header.$$.tmp~"
+
+proto_src="`echo $@ | tr ' ' '\n' | sed -e 's/\.o/\.c/g' | sort | uniq | egrep -v 'ubiqx/|wrapped'`"
+
+echo creating $header
+
+${awk} $headeropt \
+  -f script/mkproto.awk $proto_src > $headertmp
+
+if cmp -s $header $headertmp 2>/dev/null
+then
+  echo "$header unchanged"
+  rm $headertmp
+else
+  mv $headertmp $header
+fi