Merge lp:~stefanor/ubuntu/lucid/samba/ntlm-auth-623342 into lp:ubuntu/lucid-proposed/samba

[Stefano Rivera]

There's a build in https://launchpad.net/~stefanor/+archive/sru

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2010-01-16 07:52:30 +0000
+++ .pc/applied-patches	2011-03-02 20:47:51 +0000
@@ -17,3 +17,5 @@
 ubuntu-gecos-fix.patch
 security-CVE-2010-3069.patch
 spnego-auth-win7.patch
+security-CVE-2011-0719.patch
+ntlm-auth-lp623342.patch

=== added directory '.pc/security-CVE-2011-0719.patch'
=== added directory '.pc/security-CVE-2011-0719.patch/lib'
=== added directory '.pc/security-CVE-2011-0719.patch/lib/tevent'
=== added file '.pc/security-CVE-2011-0719.patch/lib/tevent/tevent_select.c'
--- .pc/security-CVE-2011-0719.patch/lib/tevent/tevent_select.c	1970-01-01 00:00:00 +0000
+++ .pc/security-CVE-2011-0719.patch/lib/tevent/tevent_select.c	2011-03-02 20:47:51 +0000
@@ -0,0 +1,247 @@
+/* 
+   Unix SMB/CIFS implementation.
+   main select loop and event handling
+   Copyright (C) Andrew Tridgell	2003-2005
+   Copyright (C) Stefan Metzmacher	2005-2009
+
+     ** NOTE! The following LGPL license applies to the tevent
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/select.h"
+#include "tevent.h"
+#include "tevent_util.h"
+#include "tevent_internal.h"
+
+struct select_event_context {
+	/* a pointer back to the generic event_context */
+	struct tevent_context *ev;
+
+	/* the maximum file descriptor number in fd_events */
+	int maxfd;
+
+	/* information for exiting from the event loop */
+	int exit_code;
+};
+
+/*
+  create a select_event_context structure.
+*/
+static int select_event_context_init(struct tevent_context *ev)
+{
+	struct select_event_context *select_ev;
+
+	select_ev = talloc_zero(ev, struct select_event_context);
+	if (!select_ev) return -1;
+	select_ev->ev = ev;
+
+	ev->additional_data = select_ev;
+	return 0;
+}
+
+/*
+  recalculate the maxfd
+*/
+static void calc_maxfd(struct select_event_context *select_ev)
+{
+	struct tevent_fd *fde;
+
+	select_ev->maxfd = 0;
+	for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
+		if (fde->fd > select_ev->maxfd) {
+			select_ev->maxfd = fde->fd;
+		}
+	}
+}
+
+
+/* to mark the ev->maxfd invalid
+ * this means we need to recalculate it
+ */
+#define EVENT_INVALID_MAXFD (-1)
+
+/*
+  destroy an fd_event
+*/
+static int select_event_fd_destructor(struct tevent_fd *fde)
+{
+	struct tevent_context *ev = fde->event_ctx;
+	struct select_event_context *select_ev = NULL;
+
+	if (ev) {
+		select_ev = talloc_get_type(ev->additional_data,
+					    struct select_event_context);
+
+		if (select_ev->maxfd == fde->fd) {
+			select_ev->maxfd = EVENT_INVALID_MAXFD;
+		}
+	}
+
+	return tevent_common_fd_destructor(fde);
+}
+
+/*
+  add a fd based event
+  return NULL on failure (memory allocation error)
+*/
+static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
+					     int fd, uint16_t flags,
+					     tevent_fd_handler_t handler,
+					     void *private_data,
+					     const char *handler_name,
+					     const char *location)
+{
+	struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
+							   struct select_event_context);
+	struct tevent_fd *fde;
+
+	fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
+				   handler, private_data,
+				   handler_name, location);
+	if (!fde) return NULL;
+
+	if (fde->fd > select_ev->maxfd) {
+		select_ev->maxfd = fde->fd;
+	}
+	talloc_set_destructor(fde, select_event_fd_destructor);
+
+	return fde;
+}
+
+/*
+  event loop handling using select()
+*/
+static int select_event_loop_select(struct select_event_context *select_ev, struct timeval *tvalp)
+{
+	fd_set r_fds, w_fds;
+	struct tevent_fd *fde;
+	int selrtn;
+
+	/* we maybe need to recalculate the maxfd */
+	if (select_ev->maxfd == EVENT_INVALID_MAXFD) {
+		calc_maxfd(select_ev);
+	}
+
+	FD_ZERO(&r_fds);
+	FD_ZERO(&w_fds);
+
+	/* setup any fd events */
+	for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
+		if (fde->flags & TEVENT_FD_READ) {
+			FD_SET(fde->fd, &r_fds);
+		}
+		if (fde->flags & TEVENT_FD_WRITE) {
+			FD_SET(fde->fd, &w_fds);
+		}
+	}
+
+	if (select_ev->ev->signal_events &&
+	    tevent_common_check_signal(select_ev->ev)) {
+		return 0;
+	}
+
+	selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
+
+	if (selrtn == -1 && errno == EINTR && 
+	    select_ev->ev->signal_events) {
+		tevent_common_check_signal(select_ev->ev);
+		return 0;
+	}
+
+	if (selrtn == -1 && errno == EBADF) {
+		/* the socket is dead! this should never
+		   happen as the socket should have first been
+		   made readable and that should have removed
+		   the event, so this must be a bug. This is a
+		   fatal error. */
+		tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
+			     "ERROR: EBADF on select_event_loop_once\n");
+		select_ev->exit_code = EBADF;
+		return -1;
+	}
+
+	if (selrtn == 0 && tvalp) {
+		/* we don't care about a possible delay here */
+		tevent_common_loop_timer_delay(select_ev->ev);
+		return 0;
+	}
+
+	if (selrtn > 0) {
+		/* at least one file descriptor is ready - check
+		   which ones and call the handler, being careful to allow
+		   the handler to remove itself when called */
+		for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
+			uint16_t flags = 0;
+
+			if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
+			if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
+			if (flags) {
+				fde->handler(select_ev->ev, fde, flags, fde->private_data);
+				break;
+			}
+		}
+	}
+
+	return 0;
+}
+
+/*
+  do a single event loop using the events defined in ev 
+*/
+static int select_event_loop_once(struct tevent_context *ev, const char *location)
+{
+	struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
+		 					   struct select_event_context);
+	struct timeval tval;
+
+	if (ev->signal_events &&
+	    tevent_common_check_signal(ev)) {
+		return 0;
+	}
+
+	if (ev->immediate_events &&
+	    tevent_common_loop_immediate(ev)) {
+		return 0;
+	}
+
+	tval = tevent_common_loop_timer_delay(ev);
+	if (tevent_timeval_is_zero(&tval)) {
+		return 0;
+	}
+
+	return select_event_loop_select(select_ev, &tval);
+}
+
+static const struct tevent_ops select_event_ops = {
+	.context_init		= select_event_context_init,
+	.add_fd			= select_event_add_fd,
+	.set_fd_close_fn	= tevent_common_fd_set_close_fn,
+	.get_fd_flags		= tevent_common_fd_get_flags,
+	.set_fd_flags		= tevent_common_fd_set_flags,
+	.add_timer		= tevent_common_add_timer,
+	.schedule_immediate	= tevent_common_schedule_immediate,
+	.add_signal		= tevent_common_add_signal,
+	.loop_once		= select_event_loop_once,
+	.loop_wait		= tevent_common_loop_wait,
+};
+
+bool tevent_select_init(void)
+{
+	return tevent_register_backend("select", &select_event_ops);
+}

=== added file '.pc/security-CVE-2011-0719.patch/lib/tevent/tevent_standard.c'
--- .pc/security-CVE-2011-0719.patch/lib/tevent/tevent_standard.c	1970-01-01 00:00:00 +0000
+++ .pc/security-CVE-2011-0719.patch/lib/tevent/tevent_standard.c	2011-03-02 20:47:51 +0000
@@ -0,0 +1,569 @@
+/* 
+   Unix SMB/CIFS implementation.
+   main select loop and event handling
+   Copyright (C) Andrew Tridgell	2003-2005
+   Copyright (C) Stefan Metzmacher	2005-2009
+
+     ** NOTE! The following LGPL license applies to the tevent
+     ** library. This does NOT imply that all of Samba is released
+     ** under the LGPL
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+  This is SAMBA's default event loop code
+
+  - we try to use epoll if configure detected support for it
+    otherwise we use select()
+  - if epoll is broken on the system or the kernel doesn't support it
+    at runtime we fallback to select()
+*/
+
+#include "replace.h"
+#include "system/filesys.h"
+#include "system/select.h"
+#include "tevent.h"
+#include "tevent_util.h"
+#include "tevent_internal.h"
+
+struct std_event_context {
+	/* a pointer back to the generic event_context */
+	struct tevent_context *ev;
+
+	/* the maximum file descriptor number in fd_events */
+	int maxfd;
+
+	/* information for exiting from the event loop */
+	int exit_code;
+
+	/* when using epoll this is the handle from epoll_create */
+	int epoll_fd;
+
+	/* our pid at the time the epoll_fd was created */
+	pid_t pid;
+};
+
+/* use epoll if it is available */
+#if HAVE_EPOLL
+/*
+  called when a epoll call fails, and we should fallback
+  to using select
+*/
+static void epoll_fallback_to_select(struct std_event_context *std_ev, const char *reason)
+{
+	tevent_debug(std_ev->ev, TEVENT_DEBUG_FATAL,
+		     "%s (%s) - falling back to select()\n",
+		     reason, strerror(errno));
+	close(std_ev->epoll_fd);
+	std_ev->epoll_fd = -1;
+	talloc_set_destructor(std_ev, NULL);
+}
+
+/*
+  map from TEVENT_FD_* to EPOLLIN/EPOLLOUT
+*/
+static uint32_t epoll_map_flags(uint16_t flags)
+{
+	uint32_t ret = 0;
+	if (flags & TEVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
+	if (flags & TEVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
+	return ret;
+}
+
+/*
+ free the epoll fd
+*/
+static int epoll_ctx_destructor(struct std_event_context *std_ev)
+{
+	if (std_ev->epoll_fd != -1) {
+		close(std_ev->epoll_fd);
+	}
+	std_ev->epoll_fd = -1;
+	return 0;
+}
+
+/*
+ init the epoll fd
+*/
+static void epoll_init_ctx(struct std_event_context *std_ev)
+{
+	std_ev->epoll_fd = epoll_create(64);
+	std_ev->pid = getpid();
+	talloc_set_destructor(std_ev, epoll_ctx_destructor);
+}
+
+static void epoll_add_event(struct std_event_context *std_ev, struct tevent_fd *fde);
+
+/*
+  reopen the epoll handle when our pid changes
+  see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an 
+  demonstration of why this is needed
+ */
+static void epoll_check_reopen(struct std_event_context *std_ev)
+{
+	struct tevent_fd *fde;
+
+	if (std_ev->pid == getpid()) {
+		return;
+	}
+
+	close(std_ev->epoll_fd);
+	std_ev->epoll_fd = epoll_create(64);
+	if (std_ev->epoll_fd == -1) {
+		tevent_debug(std_ev->ev, TEVENT_DEBUG_FATAL,
+			     "Failed to recreate epoll handle after fork\n");
+		return;
+	}
+	std_ev->pid = getpid();
+	for (fde=std_ev->ev->fd_events;fde;fde=fde->next) {
+		epoll_add_event(std_ev, fde);
+	}
+}
+
+#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT	(1<<0)
+#define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR	(1<<1)
+#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR	(1<<2)
+
+/*
+ add the epoll event to the given fd_event
+*/
+static void epoll_add_event(struct std_event_context *std_ev, struct tevent_fd *fde)
+{
+	struct epoll_event event;
+	if (std_ev->epoll_fd == -1) return;
+
+	fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+	/* if we don't want events yet, don't add an epoll_event */
+	if (fde->flags == 0) return;
+
+	ZERO_STRUCT(event);
+	event.events = epoll_map_flags(fde->flags);
+	event.data.ptr = fde;
+	if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
+		epoll_fallback_to_select(std_ev, "EPOLL_CTL_ADD failed");
+	}
+	fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+
+	/* only if we want to read we want to tell the event handler about errors */
+	if (fde->flags & TEVENT_FD_READ) {
+		fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+	}
+}
+
+/*
+ delete the epoll event for given fd_event
+*/
+static void epoll_del_event(struct std_event_context *std_ev, struct tevent_fd *fde)
+{
+	struct epoll_event event;
+	if (std_ev->epoll_fd == -1) return;
+
+	fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+	/* if there's no epoll_event, we don't need to delete it */
+	if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) return;
+
+	ZERO_STRUCT(event);
+	event.events = epoll_map_flags(fde->flags);
+	event.data.ptr = fde;
+	epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
+	fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+}
+
+/*
+ change the epoll event to the given fd_event
+*/
+static void epoll_mod_event(struct std_event_context *std_ev, struct tevent_fd *fde)
+{
+	struct epoll_event event;
+	if (std_ev->epoll_fd == -1) return;
+
+	fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+	ZERO_STRUCT(event);
+	event.events = epoll_map_flags(fde->flags);
+	event.data.ptr = fde;
+	if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
+		epoll_fallback_to_select(std_ev, "EPOLL_CTL_MOD failed");
+	}
+
+	/* only if we want to read we want to tell the event handler about errors */
+	if (fde->flags & TEVENT_FD_READ) {
+		fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+	}
+}
+
+static void epoll_change_event(struct std_event_context *std_ev, struct tevent_fd *fde)
+{
+	bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
+	bool want_read = (fde->flags & TEVENT_FD_READ);
+	bool want_write= (fde->flags & TEVENT_FD_WRITE);
+
+	if (std_ev->epoll_fd == -1) return;
+
+	fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+	/* there's already an event */
+	if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
+		if (want_read || (want_write && !got_error)) {
+			epoll_mod_event(std_ev, fde);
+			return;
+		}
+		/* 
+		 * if we want to match the select behavior, we need to remove the epoll_event
+		 * when the caller isn't interested in events.
+		 *
+		 * this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
+		 */
+		epoll_del_event(std_ev, fde);
+		return;
+	}
+
+	/* there's no epoll_event attached to the fde */
+	if (want_read || (want_write && !got_error)) {
+		epoll_add_event(std_ev, fde);
+		return;
+	}
+}
+
+/*
+  event loop handling using epoll
+*/
+static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tvalp)
+{
+	int ret, i;
+#define MAXEVENTS 1
+	struct epoll_event events[MAXEVENTS];
+	int timeout = -1;
+
+	if (std_ev->epoll_fd == -1) return -1;
+
+	if (tvalp) {
+		/* it's better to trigger timed events a bit later than to early */
+		timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
+	}
+
+	if (std_ev->ev->signal_events &&
+	    tevent_common_check_signal(std_ev->ev)) {
+		return 0;
+	}
+
+	ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
+
+	if (ret == -1 && errno == EINTR && std_ev->ev->signal_events) {
+		if (tevent_common_check_signal(std_ev->ev)) {
+			return 0;
+		}
+	}
+
+	if (ret == -1 && errno != EINTR) {
+		epoll_fallback_to_select(std_ev, "epoll_wait() failed");
+		return -1;
+	}
+
+	if (ret == 0 && tvalp) {
+		/* we don't care about a possible delay here */
+		tevent_common_loop_timer_delay(std_ev->ev);
+		return 0;
+	}
+
+	for (i=0;i<ret;i++) {
+		struct tevent_fd *fde = talloc_get_type(events[i].data.ptr, 
+						       struct tevent_fd);
+		uint16_t flags = 0;
+
+		if (fde == NULL) {
+			epoll_fallback_to_select(std_ev, "epoll_wait() gave bad data");
+			return -1;
+		}
+		if (events[i].events & (EPOLLHUP|EPOLLERR)) {
+			fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
+			/*
+			 * if we only wait for TEVENT_FD_WRITE, we should not tell the
+			 * event handler about it, and remove the epoll_event,
+			 * as we only report errors when waiting for read events,
+			 * to match the select() behavior
+			 */
+			if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
+				epoll_del_event(std_ev, fde);
+				continue;
+			}
+			flags |= TEVENT_FD_READ;
+		}
+		if (events[i].events & EPOLLIN) flags |= TEVENT_FD_READ;
+		if (events[i].events & EPOLLOUT) flags |= TEVENT_FD_WRITE;
+		if (flags) {
+			fde->handler(std_ev->ev, fde, flags, fde->private_data);
+			break;
+		}
+	}
+
+	return 0;
+}
+#else
+#define epoll_init_ctx(std_ev) 
+#define epoll_add_event(std_ev,fde)
+#define epoll_del_event(std_ev,fde)
+#define epoll_change_event(std_ev,fde)
+#define epoll_event_loop(std_ev,tvalp) (-1)
+#define epoll_check_reopen(std_ev)
+#endif
+
+/*
+  create a std_event_context structure.
+*/
+static int std_event_context_init(struct tevent_context *ev)
+{
+	struct std_event_context *std_ev;
+
+	std_ev = talloc_zero(ev, struct std_event_context);
+	if (!std_ev) return -1;
+	std_ev->ev = ev;
+	std_ev->epoll_fd = -1;
+
+	epoll_init_ctx(std_ev);
+
+	ev->additional_data = std_ev;
+	return 0;
+}
+
+/*
+  recalculate the maxfd
+*/
+static void calc_maxfd(struct std_event_context *std_ev)
+{
+	struct tevent_fd *fde;
+
+	std_ev->maxfd = 0;
+	for (fde = std_ev->ev->fd_events; fde; fde = fde->next) {
+		if (fde->fd > std_ev->maxfd) {
+			std_ev->maxfd = fde->fd;
+		}
+	}
+}
+
+
+/* to mark the ev->maxfd invalid
+ * this means we need to recalculate it
+ */
+#define EVENT_INVALID_MAXFD (-1)
+
+/*
+  destroy an fd_event
+*/
+static int std_event_fd_destructor(struct tevent_fd *fde)
+{
+	struct tevent_context *ev = fde->event_ctx;
+	struct std_event_context *std_ev = NULL;
+
+	if (ev) {
+		std_ev = talloc_get_type(ev->additional_data,
+					 struct std_event_context);
+
+		epoll_check_reopen(std_ev);
+
+		if (std_ev->maxfd == fde->fd) {
+			std_ev->maxfd = EVENT_INVALID_MAXFD;
+		}
+
+		epoll_del_event(std_ev, fde);
+	}
+
+	return tevent_common_fd_destructor(fde);
+}
+
+/*
+  add a fd based event
+  return NULL on failure (memory allocation error)
+*/
+static struct tevent_fd *std_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
+					  int fd, uint16_t flags,
+					  tevent_fd_handler_t handler,
+					  void *private_data,
+					  const char *handler_name,
+					  const char *location)
+{
+	struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
+							   struct std_event_context);
+	struct tevent_fd *fde;
+
+	epoll_check_reopen(std_ev);
+
+	fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
+				   handler, private_data,
+				   handler_name, location);
+	if (!fde) return NULL;
+
+	if ((std_ev->maxfd != EVENT_INVALID_MAXFD)
+	    && (fde->fd > std_ev->maxfd)) {
+		std_ev->maxfd = fde->fd;
+	}
+	talloc_set_destructor(fde, std_event_fd_destructor);
+
+	epoll_add_event(std_ev, fde);
+
+	return fde;
+}
+
+/*
+  set the fd event flags
+*/
+static void std_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
+{
+	struct tevent_context *ev;
+	struct std_event_context *std_ev;
+
+	if (fde->flags == flags) return;
+
+	ev = fde->event_ctx;
+	std_ev = talloc_get_type(ev->additional_data, struct std_event_context);
+
+	fde->flags = flags;
+
+	epoll_check_reopen(std_ev);
+
+	epoll_change_event(std_ev, fde);
+}
+
+/*
+  event loop handling using select()
+*/
+static int std_event_loop_select(struct std_event_context *std_ev, struct timeval *tvalp)
+{
+	fd_set r_fds, w_fds;
+	struct tevent_fd *fde;
+	int selrtn;
+
+	/* we maybe need to recalculate the maxfd */
+	if (std_ev->maxfd == EVENT_INVALID_MAXFD) {
+		calc_maxfd(std_ev);
+	}
+
+	FD_ZERO(&r_fds);
+	FD_ZERO(&w_fds);
+
+	/* setup any fd events */
+	for (fde = std_ev->ev->fd_events; fde; fde = fde->next) {
+		if (fde->flags & TEVENT_FD_READ) {
+			FD_SET(fde->fd, &r_fds);
+		}
+		if (fde->flags & TEVENT_FD_WRITE) {
+			FD_SET(fde->fd, &w_fds);
+		}
+	}
+
+	if (std_ev->ev->signal_events &&
+	    tevent_common_check_signal(std_ev->ev)) {
+		return 0;
+	}
+
+	selrtn = select(std_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
+
+	if (selrtn == -1 && errno == EINTR && 
+	    std_ev->ev->signal_events) {
+		tevent_common_check_signal(std_ev->ev);
+		return 0;
+	}
+
+	if (selrtn == -1 && errno == EBADF) {
+		/* the socket is dead! this should never
+		   happen as the socket should have first been
+		   made readable and that should have removed
+		   the event, so this must be a bug. This is a
+		   fatal error. */
+		tevent_debug(std_ev->ev, TEVENT_DEBUG_FATAL,
+			     "ERROR: EBADF on std_event_loop_once\n");
+		std_ev->exit_code = EBADF;
+		return -1;
+	}
+
+	if (selrtn == 0 && tvalp) {
+		/* we don't care about a possible delay here */
+		tevent_common_loop_timer_delay(std_ev->ev);
+		return 0;
+	}
+
+	if (selrtn > 0) {
+		/* at least one file descriptor is ready - check
+		   which ones and call the handler, being careful to allow
+		   the handler to remove itself when called */
+		for (fde = std_ev->ev->fd_events; fde; fde = fde->next) {
+			uint16_t flags = 0;
+
+			if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
+			if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
+			if (flags) {
+				fde->handler(std_ev->ev, fde, flags, fde->private_data);
+				break;
+			}
+		}
+	}
+
+	return 0;
+}		
+
+/*
+  do a single event loop using the events defined in ev 
+*/
+static int std_event_loop_once(struct tevent_context *ev, const char *location)
+{
+	struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
+		 					   struct std_event_context);
+	struct timeval tval;
+
+	if (ev->signal_events &&
+	    tevent_common_check_signal(ev)) {
+		return 0;
+	}
+
+	if (ev->immediate_events &&
+	    tevent_common_loop_immediate(ev)) {
+		return 0;
+	}
+
+	tval = tevent_common_loop_timer_delay(ev);
+	if (tevent_timeval_is_zero(&tval)) {
+		return 0;
+	}
+
+	epoll_check_reopen(std_ev);
+
+	if (epoll_event_loop(std_ev, &tval) == 0) {
+		return 0;
+	}
+
+	return std_event_loop_select(std_ev, &tval);
+}
+
+static const struct tevent_ops std_event_ops = {
+	.context_init		= std_event_context_init,
+	.add_fd			= std_event_add_fd,
+	.set_fd_close_fn	= tevent_common_fd_set_close_fn,
+	.get_fd_flags		= tevent_common_fd_get_flags,
+	.set_fd_flags		= std_event_set_fd_flags,
+	.add_timer		= tevent_common_add_timer,
+	.schedule_immediate	= tevent_common_schedule_immediate,
+	.add_signal		= tevent_common_add_signal,
+	.loop_once		= std_event_loop_once,
+	.loop_wait		= tevent_common_loop_wait,
+};
+
+
+bool tevent_standard_init(void)
+{
+	return tevent_register_backend("standard", &std_event_ops);
+}
+

=== added directory '.pc/security-CVE-2011-0719.patch/nsswitch'
=== added file '.pc/security-CVE-2011-0719.patch/nsswitch/wb_common.c'
--- .pc/security-CVE-2011-0719.patch/nsswitch/wb_common.c	1970-01-01 00:00:00 +0000
+++ .pc/security-CVE-2011-0719.patch/nsswitch/wb_common.c	2011-03-02 20:47:51 +0000
@@ -0,0 +1,690 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   winbind client common code
+
+   Copyright (C) Tim Potter 2000
+   Copyright (C) Andrew Tridgell 2000
+   Copyright (C) Andrew Bartlett 2002
+
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "winbind_client.h"
+
+/* Global variables.  These are effectively the client state information */
+
+int winbindd_fd = -1;           /* fd for winbindd socket */
+static int is_privileged = 0;
+
+/* Free a response structure */
+
+void winbindd_free_response(struct winbindd_response *response)
+{
+	/* Free any allocated extra_data */
+
+	if (response)
+		SAFE_FREE(response->extra_data.data);
+}
+
+/* Initialise a request structure */
+
+void winbindd_init_request(struct winbindd_request *request, int request_type)
+{
+	request->length = sizeof(struct winbindd_request);
+
+	request->cmd = (enum winbindd_cmd)request_type;
+	request->pid = getpid();
+
+}
+
+/* Initialise a response structure */
+
+static void init_response(struct winbindd_response *response)
+{
+	/* Initialise return value */
+
+	response->result = WINBINDD_ERROR;
+}
+
+/* Close established socket */
+
+void winbind_close_sock(void)
+{
+	if (winbindd_fd != -1) {
+		close(winbindd_fd);
+		winbindd_fd = -1;
+	}
+}
+
+#define CONNECT_TIMEOUT 30
+
+/* Make sure socket handle isn't stdin, stdout or stderr */
+#define RECURSION_LIMIT 3
+
+static int make_nonstd_fd_internals(int fd, int limit /* Recursion limiter */)
+{
+	int new_fd;
+	if (fd >= 0 && fd <= 2) {
+#ifdef F_DUPFD
+		if ((new_fd = fcntl(fd, F_DUPFD, 3)) == -1) {
+			return -1;
+		}
+		/* Paranoia */
+		if (new_fd < 3) {
+			close(new_fd);
+			return -1;
+		}
+		close(fd);
+		return new_fd;
+#else
+		if (limit <= 0)
+			return -1;
+
+		new_fd = dup(fd);
+		if (new_fd == -1)
+			return -1;
+
+		/* use the program stack to hold our list of FDs to close */
+		new_fd = make_nonstd_fd_internals(new_fd, limit - 1);
+		close(fd);
+		return new_fd;
+#endif
+	}
+	return fd;
+}
+
+/****************************************************************************
+ Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
+ else
+ if SYSV use O_NDELAY
+ if BSD use FNDELAY
+ Set close on exec also.
+****************************************************************************/
+
+static int make_safe_fd(int fd)
+{
+	int result, flags;
+	int new_fd = make_nonstd_fd_internals(fd, RECURSION_LIMIT);
+	if (new_fd == -1) {
+		close(fd);
+		return -1;
+	}
+
+	/* Socket should be nonblocking. */
+#ifdef O_NONBLOCK
+#define FLAG_TO_SET O_NONBLOCK
+#else
+#ifdef SYSV
+#define FLAG_TO_SET O_NDELAY
+#else /* BSD */
+#define FLAG_TO_SET FNDELAY
+#endif
+#endif
+
+	if ((flags = fcntl(new_fd, F_GETFL)) == -1) {
+		close(new_fd);
+		return -1;
+	}
+
+	flags |= FLAG_TO_SET;
+	if (fcntl(new_fd, F_SETFL, flags) == -1) {
+		close(new_fd);
+		return -1;
+	}
+
+#undef FLAG_TO_SET
+
+	/* Socket should be closed on exec() */
+#ifdef FD_CLOEXEC
+	result = flags = fcntl(new_fd, F_GETFD, 0);
+	if (flags >= 0) {
+		flags |= FD_CLOEXEC;
+		result = fcntl( new_fd, F_SETFD, flags );
+	}
+	if (result < 0) {
+		close(new_fd);
+		return -1;
+	}
+#endif
+	return new_fd;
+}
+
+/* Connect to winbindd socket */
+
+static int winbind_named_pipe_sock(const char *dir)
+{
+	struct sockaddr_un sunaddr;
+	struct stat st;
+	char *path = NULL;
+	int fd;
+	int wait_time;
+	int slept;
+
+	/* Check permissions on unix socket directory */
+
+	if (lstat(dir, &st) == -1) {
+		errno = ENOENT;
+		return -1;
+	}
+
+	if (!S_ISDIR(st.st_mode) ||
+	    (st.st_uid != 0 && st.st_uid != geteuid())) {
+		errno = ENOENT;
+		return -1;
+	}
+
+	/* Connect to socket */
+
+	if (asprintf(&path, "%s/%s", dir, WINBINDD_SOCKET_NAME) < 0) {
+		return -1;
+	}
+
+	ZERO_STRUCT(sunaddr);
+	sunaddr.sun_family = AF_UNIX;
+	strncpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path) - 1);
+
+	/* If socket file doesn't exist, don't bother trying to connect
+	   with retry.  This is an attempt to make the system usable when
+	   the winbindd daemon is not running. */
+
+	if (lstat(path, &st) == -1) {
+		errno = ENOENT;
+		SAFE_FREE(path);
+		return -1;
+	}
+
+	SAFE_FREE(path);
+	/* Check permissions on unix socket file */
+
+	if (!S_ISSOCK(st.st_mode) ||
+	    (st.st_uid != 0 && st.st_uid != geteuid())) {
+		errno = ENOENT;
+		return -1;
+	}
+
+	/* Connect to socket */
+
+	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+		return -1;
+	}
+
+	/* Set socket non-blocking and close on exec. */
+
+	if ((fd = make_safe_fd( fd)) == -1) {
+		return fd;
+	}
+
+	for (wait_time = 0; connect(fd, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1;
+			wait_time += slept) {
+		struct timeval tv;
+		fd_set w_fds;
+		int ret;
+		int connect_errno = 0;
+		socklen_t errnosize;
+
+		if (wait_time >= CONNECT_TIMEOUT)
+			goto error_out;
+
+		switch (errno) {
+			case EINPROGRESS:
+				FD_ZERO(&w_fds);
+				FD_SET(fd, &w_fds);
+				tv.tv_sec = CONNECT_TIMEOUT - wait_time;
+				tv.tv_usec = 0;
+
+				ret = select(fd + 1, NULL, &w_fds, NULL, &tv);
+
+				if (ret > 0) {
+					errnosize = sizeof(connect_errno);
+
+					ret = getsockopt(fd, SOL_SOCKET,
+							SO_ERROR, &connect_errno, &errnosize);
+
+					if (ret >= 0 && connect_errno == 0) {
+						/* Connect succeed */
+						goto out;
+					}
+				}
+
+				slept = CONNECT_TIMEOUT;
+				break;
+			case EAGAIN:
+				slept = rand() % 3 + 1;
+				sleep(slept);
+				break;
+			default:
+				goto error_out;
+		}
+
+	}
+
+  out:
+
+	return fd;
+
+  error_out:
+
+	close(fd);
+	return -1;
+}
+
+static const char *winbindd_socket_dir(void)
+{
+#ifdef SOCKET_WRAPPER
+	const char *env_dir;
+
+	env_dir = getenv(WINBINDD_SOCKET_DIR_ENVVAR);
+	if (env_dir) {
+		return env_dir;
+	}
+#endif
+
+	return WINBINDD_SOCKET_DIR;
+}
+
+/* Connect to winbindd socket */
+
+static int winbind_open_pipe_sock(int recursing, int need_priv)
+{
+#ifdef HAVE_UNIXSOCKET
+	static pid_t our_pid;
+	struct winbindd_request request;
+	struct winbindd_response response;
+	ZERO_STRUCT(request);
+	ZERO_STRUCT(response);
+
+	if (our_pid != getpid()) {
+		winbind_close_sock();
+		our_pid = getpid();
+	}
+
+	if ((need_priv != 0) && (is_privileged == 0)) {
+		winbind_close_sock();
+	}
+
+	if (winbindd_fd != -1) {
+		return winbindd_fd;
+	}
+
+	if (recursing) {
+		return -1;
+	}
+
+	if ((winbindd_fd = winbind_named_pipe_sock(winbindd_socket_dir())) == -1) {
+		return -1;
+	}
+
+	is_privileged = 0;
+
+	/* version-check the socket */
+
+	request.wb_flags = WBFLAG_RECURSE;
+	if ((winbindd_request_response(WINBINDD_INTERFACE_VERSION, &request, &response) != NSS_STATUS_SUCCESS) || (response.data.interface_version != WINBIND_INTERFACE_VERSION)) {
+		winbind_close_sock();
+		return -1;
+	}
+
+	/* try and get priv pipe */
+
+	request.wb_flags = WBFLAG_RECURSE;
+	if (winbindd_request_response(WINBINDD_PRIV_PIPE_DIR, &request, &response) == NSS_STATUS_SUCCESS) {
+		int fd;
+		if ((fd = winbind_named_pipe_sock((char *)response.extra_data.data)) != -1) {
+			close(winbindd_fd);
+			winbindd_fd = fd;
+			is_privileged = 1;
+		}
+	}
+
+	if ((need_priv != 0) && (is_privileged == 0)) {
+		return -1;
+	}
+
+	SAFE_FREE(response.extra_data.data);
+
+	return winbindd_fd;
+#else
+	return -1;
+#endif /* HAVE_UNIXSOCKET */
+}
+
+/* Write data to winbindd socket */
+
+int winbind_write_sock(void *buffer, int count, int recursing, int need_priv)
+{
+	int result, nwritten;
+
+	/* Open connection to winbind daemon */
+
+ restart:
+
+	if (winbind_open_pipe_sock(recursing, need_priv) == -1) {
+		errno = ENOENT;
+		return -1;
+	}
+
+	/* Write data to socket */
+
+	nwritten = 0;
+
+	while(nwritten < count) {
+		struct timeval tv;
+		fd_set r_fds;
+
+		/* Catch pipe close on other end by checking if a read()
+		   call would not block by calling select(). */
+
+		FD_ZERO(&r_fds);
+		FD_SET(winbindd_fd, &r_fds);
+		ZERO_STRUCT(tv);
+
+		if (select(winbindd_fd + 1, &r_fds, NULL, NULL, &tv) == -1) {
+			winbind_close_sock();
+			return -1;                   /* Select error */
+		}
+
+		/* Write should be OK if fd not available for reading */
+
+		if (!FD_ISSET(winbindd_fd, &r_fds)) {
+
+			/* Do the write */
+
+			result = write(winbindd_fd,
+				       (char *)buffer + nwritten,
+				       count - nwritten);
+
+			if ((result == -1) || (result == 0)) {
+
+				/* Write failed */
+
+				winbind_close_sock();
+				return -1;
+			}
+
+			nwritten += result;
+
+		} else {
+
+			/* Pipe has closed on remote end */
+
+			winbind_close_sock();
+			goto restart;
+		}
+	}
+
+	return nwritten;
+}
+
+/* Read data from winbindd socket */
+
+int winbind_read_sock(void *buffer, int count)
+{
+	int nread = 0;
+	int total_time = 0, selret;
+
+	if (winbindd_fd == -1) {
+		return -1;
+	}
+
+	/* Read data from socket */
+	while(nread < count) {
+		struct timeval tv;
+		fd_set r_fds;
+
+		/* Catch pipe close on other end by checking if a read()
+		   call would not block by calling select(). */
+
+		FD_ZERO(&r_fds);
+		FD_SET(winbindd_fd, &r_fds);
+		ZERO_STRUCT(tv);
+		/* Wait for 5 seconds for a reply. May need to parameterise this... */
+		tv.tv_sec = 5;
+
+		if ((selret = select(winbindd_fd + 1, &r_fds, NULL, NULL, &tv)) == -1) {
+			winbind_close_sock();
+			return -1;                   /* Select error */
+		}
+
+		if (selret == 0) {
+			/* Not ready for read yet... */
+			if (total_time >= 30) {
+				/* Timeout */
+				winbind_close_sock();
+				return -1;
+			}
+			total_time += 5;
+			continue;
+		}
+
+		if (FD_ISSET(winbindd_fd, &r_fds)) {
+
+			/* Do the Read */
+
+			int result = read(winbindd_fd, (char *)buffer + nread,
+			      count - nread);
+
+			if ((result == -1) || (result == 0)) {
+
+				/* Read failed.  I think the only useful thing we
+				   can do here is just return -1 and fail since the
+				   transaction has failed half way through. */
+
+				winbind_close_sock();
+				return -1;
+			}
+
+			nread += result;
+
+		}
+	}
+
+	return nread;
+}
+
+/* Read reply */
+
+int winbindd_read_reply(struct winbindd_response *response)
+{
+	int result1, result2 = 0;
+
+	if (!response) {
+		return -1;
+	}
+
+	/* Read fixed length response */
+
+	result1 = winbind_read_sock(response,
+				    sizeof(struct winbindd_response));
+	if (result1 == -1) {
+		return -1;
+	}
+
+	/* We actually send the pointer value of the extra_data field from
+	   the server.  This has no meaning in the client's address space
+	   so we clear it out. */
+
+	response->extra_data.data = NULL;
+
+	/* Read variable length response */
+
+	if (response->length > sizeof(struct winbindd_response)) {
+		int extra_data_len = response->length -
+			sizeof(struct winbindd_response);
+
+		/* Mallocate memory for extra data */
+
+		if (!(response->extra_data.data = malloc(extra_data_len))) {
+			return -1;
+		}
+
+		result2 = winbind_read_sock(response->extra_data.data,
+					    extra_data_len);
+		if (result2 == -1) {
+			winbindd_free_response(response);
+			return -1;
+		}
+	}
+
+	/* Return total amount of data read */
+
+	return result1 + result2;
+}
+
+/*
+ * send simple types of requests
+ */
+
+NSS_STATUS winbindd_send_request(int req_type, int need_priv,
+				 struct winbindd_request *request)
+{
+	struct winbindd_request lrequest;
+
+	/* Check for our tricky environment variable */
+
+	if (winbind_env_set()) {
+		return NSS_STATUS_NOTFOUND;
+	}
+
+	if (!request) {
+		ZERO_STRUCT(lrequest);
+		request = &lrequest;
+	}
+
+	/* Fill in request and send down pipe */
+
+	winbindd_init_request(request, req_type);
+
+	if (winbind_write_sock(request, sizeof(*request),
+			       request->wb_flags & WBFLAG_RECURSE,
+			       need_priv) == -1)
+	{
+		/* Set ENOENT for consistency.  Required by some apps */
+		errno = ENOENT;
+
+		return NSS_STATUS_UNAVAIL;
+	}
+
+	if ((request->extra_len != 0) &&
+	    (winbind_write_sock(request->extra_data.data,
+				request->extra_len,
+				request->wb_flags & WBFLAG_RECURSE,
+				need_priv) == -1))
+	{
+		/* Set ENOENT for consistency.  Required by some apps */
+		errno = ENOENT;
+
+		return NSS_STATUS_UNAVAIL;
+	}
+
+	return NSS_STATUS_SUCCESS;
+}
+
+/*
+ * Get results from winbindd request
+ */
+
+NSS_STATUS winbindd_get_response(struct winbindd_response *response)
+{
+	struct winbindd_response lresponse;
+
+	if (!response) {
+		ZERO_STRUCT(lresponse);
+		response = &lresponse;
+	}
+
+	init_response(response);
+
+	/* Wait for reply */
+	if (winbindd_read_reply(response) == -1) {
+		/* Set ENOENT for consistency.  Required by some apps */
+		errno = ENOENT;
+
+		return NSS_STATUS_UNAVAIL;
+	}
+
+	/* Throw away extra data if client didn't request it */
+	if (response == &lresponse) {
+		winbindd_free_response(response);
+	}
+
+	/* Copy reply data from socket */
+	if (response->result != WINBINDD_OK) {
+		return NSS_STATUS_NOTFOUND;
+	}
+
+	return NSS_STATUS_SUCCESS;
+}
+
+/* Handle simple types of requests */
+
+NSS_STATUS winbindd_request_response(int req_type,
+			    struct winbindd_request *request,
+			    struct winbindd_response *response)
+{
+	NSS_STATUS status = NSS_STATUS_UNAVAIL;
+	int count = 0;
+
+	while ((status == NSS_STATUS_UNAVAIL) && (count < 10)) {
+		status = winbindd_send_request(req_type, 0, request);
+		if (status != NSS_STATUS_SUCCESS)
+			return(status);
+		status = winbindd_get_response(response);
+		count += 1;
+	}
+
+	return status;
+}
+
+NSS_STATUS winbindd_priv_request_response(int req_type,
+					  struct winbindd_request *request,
+					  struct winbindd_response *response)
+{
+	NSS_STATUS status = NSS_STATUS_UNAVAIL;
+	int count = 0;
+
+	while ((status == NSS_STATUS_UNAVAIL) && (count < 10)) {
+		status = winbindd_send_request(req_type, 1, request);
+		if (status != NSS_STATUS_SUCCESS)
+			return(status);
+		status = winbindd_get_response(response);
+		count += 1;
+	}
+
+	return status;
+}
+
+/*************************************************************************
+ ************************************************************************/
+
+const char *nss_err_str(NSS_STATUS ret)
+{
+	switch (ret) {
+		case NSS_STATUS_TRYAGAIN:
+			return "NSS_STATUS_TRYAGAIN";
+		case NSS_STATUS_SUCCESS:
+			return "NSS_STATUS_SUCCESS";
+		case NSS_STATUS_NOTFOUND:
+			return "NSS_STATUS_NOTFOUND";
+		case NSS_STATUS_UNAVAIL:
+			return "NSS_STATUS_UNAVAIL";
+#ifdef NSS_STATUS_RETURN
+		case NSS_STATUS_RETURN:
+			return "NSS_STATUS_RETURN";
+#endif
+		default:
+			return "UNKNOWN RETURN CODE!!!!!!!";
+	}
+}

=== added directory '.pc/security-CVE-2011-0719.patch/source3'
=== added directory '.pc/security-CVE-2011-0719.patch/source3/client'
=== added file '.pc/security-CVE-2011-0719.patch/source3/client/client.c'
--- .pc/security-CVE-2011-0719.patch/source3/client/client.c	1970-01-01 00:00:00 +0000
+++ .pc/security-CVE-2011-0719.patch/source3/client/client.c	2011-03-02 20:47:51 +0000
@@ -0,0 +1,5022 @@
+/*
+   Unix SMB/CIFS implementation.
+   SMB client
+   Copyright (C) Andrew Tridgell          1994-1998
+   Copyright (C) Simo Sorce               2001-2002
+   Copyright (C) Jelmer Vernooij          2003
+   Copyright (C) Gerald (Jerry) Carter    2004
+   Copyright (C) Jeremy Allison           1994-2007
+
+   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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "client/client_proto.h"
+#include "include/rpc_client.h"
+#ifndef REGISTER
+#define REGISTER 0
+#endif
+
+extern int do_smb_browse(void); /* mDNS browsing */
+
+extern bool AllowDebugChange;
+extern bool override_logfile;
+extern char tar_type;
+
+static int port = 0;
+static char *service;
+static char *desthost;
+static char *calling_name;
+static bool grepable = false;
+static char *cmdstr = NULL;
+const char *cmd_ptr = NULL;
+
+static int io_bufsize = 524288;
+
+static int name_type = 0x20;
+static int max_protocol = PROTOCOL_NT1;
+
+static int process_tok(char *tok);
+static int cmd_help(void);
+
+#define CREATE_ACCESS_READ READ_CONTROL_ACCESS
+
+/* 30 second timeout on most commands */
+#define CLIENT_TIMEOUT (30*1000)
+#define SHORT_TIMEOUT (5*1000)
+
+/* value for unused fid field in trans2 secondary request */
+#define FID_UNUSED (0xFFFF)
+
+time_t newer_than = 0;
+static int archive_level = 0;
+
+static bool translation = false;
+static bool have_ip;
+
+/* clitar bits insert */
+extern int blocksize;
+extern bool tar_inc;
+extern bool tar_reset;
+/* clitar bits end */
+
+static bool prompt = true;
+
+static bool recurse = false;
+static bool showacls = false;
+bool lowercase = false;
+
+static struct sockaddr_storage dest_ss;
+static char dest_ss_str[INET6_ADDRSTRLEN];
+
+#define SEPARATORS " \t\n\r"
+
+static bool abort_mget = true;
+
+/* timing globals */
+uint64_t get_total_size = 0;
+unsigned int get_total_time_ms = 0;
+static uint64_t put_total_size = 0;
+static unsigned int put_total_time_ms = 0;
+
+/* totals globals */
+static double dir_total;
+
+/* encrypted state. */
+static bool smb_encrypt;
+
+/* root cli_state connection */
+
+struct cli_state *cli;
+
+static char CLI_DIRSEP_CHAR = '\\';
+static char CLI_DIRSEP_STR[] = { '\\', '\0' };
+
+/* Authentication for client connections. */
+struct user_auth_info *auth_info;
+
+/* Accessor functions for directory paths. */
+static char *fileselection;
+static const char *client_get_fileselection(void)
+{
+	if (fileselection) {
+		return fileselection;
+	}
+	return "";
+}
+
+static const char *client_set_fileselection(const char *new_fs)
+{
+	SAFE_FREE(fileselection);
+	if (new_fs) {
+		fileselection = SMB_STRDUP(new_fs);
+	}
+	return client_get_fileselection();
+}
+
+static char *cwd;
+static const char *client_get_cwd(void)
+{
+	if (cwd) {
+		return cwd;
+	}
+	return CLI_DIRSEP_STR;
+}
+
+static const char *client_set_cwd(const char *new_cwd)
+{
+	SAFE_FREE(cwd);
+	if (new_cwd) {
+		cwd = SMB_STRDUP(new_cwd);
+	}
+	return client_get_cwd();
+}
+
+static char *cur_dir;
+const char *client_get_cur_dir(void)
+{
+	if (cur_dir) {
+		return cur_dir;
+	}
+	return CLI_DIRSEP_STR;
+}
+
+const char *client_set_cur_dir(const char *newdir)
+{
+	SAFE_FREE(cur_dir);
+	if (newdir) {
+		cur_dir = SMB_STRDUP(newdir);
+	}
+	return client_get_cur_dir();
+}
+
+/****************************************************************************
+ Write to a local file with CR/LF->LF translation if appropriate. Return the
+ number taken from the buffer. This may not equal the number written.
+****************************************************************************/
+
+static int writefile(int f, char *b, int n)
+{
+	int i;
+
+	if (!translation) {
+		return write(f,b,n);
+	}
+
+	i = 0;
+	while (i < n) {
+		if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
+			b++;i++;
+		}
+		if (write(f, b, 1) != 1) {
+			break;
+		}
+		b++;
+		i++;
+	}
+
+	return(i);
+}
+
+/****************************************************************************
+ Read from a file with LF->CR/LF translation if appropriate. Return the
+ number read. read approx n bytes.
+****************************************************************************/
+
+static int readfile(uint8_t *b, int n, XFILE *f)
+{
+	int i;
+	int c;
+
+	if (!translation)
+		return x_fread(b,1,n,f);
+
+	i = 0;
+	while (i < (n - 1) && (i < BUFFER_SIZE)) {
+		if ((c = x_getc(f)) == EOF) {
+			break;
+		}
+
+		if (c == '\n') { /* change all LFs to CR/LF */
+			b[i++] = '\r';
+		}
+
+		b[i++] = c;
+	}
+
+	return(i);
+}
+
+struct push_state {
+	XFILE *f;
+	SMB_OFF_T nread;
+};
+
+static size_t push_source(uint8_t *buf, size_t n, void *priv)
+{
+	struct push_state *state = (struct push_state *)priv;
+	int result;
+
+	if (x_feof(state->f)) {
+		return 0;
+	}
+
+	result = readfile(buf, n, state->f);
+	state->nread += result;
+	return result;
+}
+
+/****************************************************************************
+ Send a message.
+****************************************************************************/
+
+static void send_message(const char *username)
+{
+	int total_len = 0;
+	int grp_id;
+
+	if (!cli_message_start(cli, desthost, username, &grp_id)) {
+		d_printf("message start: %s\n", cli_errstr(cli));
+		return;
+	}
+
+
+	d_printf("Connected. Type your message, ending it with a Control-D\n");
+
+	while (!feof(stdin) && total_len < 1600) {
+		int maxlen = MIN(1600 - total_len,127);
+		char msg[1024];
+		int l=0;
+		int c;
+
+		ZERO_ARRAY(msg);
+
+		for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
+			if (c == '\n')
+				msg[l++] = '\r';
+			msg[l] = c;
+		}
+
+		if ((total_len > 0) && (strlen(msg) == 0)) {
+			break;
+		}
+
+		if (!cli_message_text(cli, msg, l, grp_id)) {
+			d_printf("SMBsendtxt failed (%s)\n",cli_errstr(cli));
+			return;
+		}
+
+		total_len += l;
+	}
+
+	if (total_len >= 1600)
+		d_printf("the message was truncated to 1600 bytes\n");
+	else
+		d_printf("sent %d bytes\n",total_len);
+
+	if (!cli_message_end(cli, grp_id)) {
+		d_printf("SMBsendend failed (%s)\n",cli_errstr(cli));
+		return;
+	}
+}
+
+/****************************************************************************
+ Check the space on a device.
+****************************************************************************/
+
+static int do_dskattr(void)
+{
+	int total, bsize, avail;
+	struct cli_state *targetcli = NULL;
+	char *targetpath = NULL;
+	TALLOC_CTX *ctx = talloc_tos();
+
+	if ( !cli_resolve_path(ctx, "", auth_info, cli, client_get_cur_dir(), &targetcli, &targetpath)) {
+		d_printf("Error in dskattr: %s\n", cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_dskattr(targetcli, &bsize, &total, &avail)) {
+		d_printf("Error in dskattr: %s\n",cli_errstr(targetcli));
+		return 1;
+	}
+
+	d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
+		 total, bsize, avail);
+
+	return 0;
+}
+
+/****************************************************************************
+ Show cd/pwd.
+****************************************************************************/
+
+static int cmd_pwd(void)
+{
+	d_printf("Current directory is %s",service);
+	d_printf("%s\n",client_get_cur_dir());
+	return 0;
+}
+
+/****************************************************************************
+ Ensure name has correct directory separators.
+****************************************************************************/
+
+static void normalize_name(char *newdir)
+{
+	if (!(cli->posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP)) {
+		string_replace(newdir,'/','\\');
+	}
+}
+
+/****************************************************************************
+ Change directory - inner section.
+****************************************************************************/
+
+static int do_cd(const char *new_dir)
+{
+	char *newdir = NULL;
+	char *saved_dir = NULL;
+	char *new_cd = NULL;
+	char *targetpath = NULL;
+	struct cli_state *targetcli = NULL;
+	SMB_STRUCT_STAT sbuf;
+	uint32 attributes;
+	int ret = 1;
+	TALLOC_CTX *ctx = talloc_stackframe();
+
+	newdir = talloc_strdup(ctx, new_dir);
+	if (!newdir) {
+		TALLOC_FREE(ctx);
+		return 1;
+	}
+
+	normalize_name(newdir);
+
+	/* Save the current directory in case the new directory is invalid */
+
+	saved_dir = talloc_strdup(ctx, client_get_cur_dir());
+	if (!saved_dir) {
+		TALLOC_FREE(ctx);
+		return 1;
+	}
+
+	if (*newdir == CLI_DIRSEP_CHAR) {
+		client_set_cur_dir(newdir);
+		new_cd = newdir;
+	} else {
+		new_cd = talloc_asprintf(ctx, "%s%s",
+				client_get_cur_dir(),
+				newdir);
+		if (!new_cd) {
+			goto out;
+		}
+	}
+
+	/* Ensure cur_dir ends in a DIRSEP */
+	if ((new_cd[0] != '\0') && (*(new_cd+strlen(new_cd)-1) != CLI_DIRSEP_CHAR)) {
+		new_cd = talloc_asprintf_append(new_cd, "%s", CLI_DIRSEP_STR);
+		if (!new_cd) {
+			goto out;
+		}
+	}
+	client_set_cur_dir(new_cd);
+
+	new_cd = clean_name(ctx, new_cd);
+	client_set_cur_dir(new_cd);
+
+	if ( !cli_resolve_path(ctx, "", auth_info, cli, new_cd, &targetcli, &targetpath)) {
+		d_printf("cd %s: %s\n", new_cd, cli_errstr(cli));
+		client_set_cur_dir(saved_dir);
+		goto out;
+	}
+
+	if (strequal(targetpath,CLI_DIRSEP_STR )) {
+		TALLOC_FREE(ctx);
+		return 0;
+	}
+
+	/* Use a trans2_qpathinfo to test directories for modern servers.
+	   Except Win9x doesn't support the qpathinfo_basic() call..... */
+
+	if (targetcli->protocol > PROTOCOL_LANMAN2 && !targetcli->win95) {
+		if (!cli_qpathinfo_basic( targetcli, targetpath, &sbuf, &attributes ) ) {
+			d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+
+		if (!(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+			d_printf("cd %s: not a directory\n", new_cd);
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+	} else {
+		targetpath = talloc_asprintf(ctx,
+				"%s%s",
+				targetpath,
+				CLI_DIRSEP_STR );
+		if (!targetpath) {
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+		targetpath = clean_name(ctx, targetpath);
+		if (!targetpath) {
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+
+		if (!cli_chkpath(targetcli, targetpath)) {
+			d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
+			client_set_cur_dir(saved_dir);
+			goto out;
+		}
+	}
+
+	ret = 0;
+
+out:
+
+	TALLOC_FREE(ctx);
+	return ret;
+}
+
+/****************************************************************************
+ Change directory.
+****************************************************************************/
+
+static int cmd_cd(void)
+{
+	char *buf = NULL;
+	int rc = 0;
+
+	if (next_token_talloc(talloc_tos(), &cmd_ptr, &buf,NULL)) {
+		rc = do_cd(buf);
+	} else {
+		d_printf("Current directory is %s\n",client_get_cur_dir());
+	}
+
+	return rc;
+}
+
+/****************************************************************************
+ Change directory.
+****************************************************************************/
+
+static int cmd_cd_oneup(void)
+{
+	return do_cd("..");
+}
+
+/*******************************************************************
+ Decide if a file should be operated on.
+********************************************************************/
+
+static bool do_this_one(file_info *finfo)
+{
+	if (!finfo->name) {
+		return false;
+	}
+
+	if (finfo->mode & aDIR) {
+		return true;
+	}
+
+	if (*client_get_fileselection() &&
+	    !mask_match(finfo->name,client_get_fileselection(),false)) {
+		DEBUG(3,("mask_match %s failed\n", finfo->name));
+		return false;
+	}
+
+	if (newer_than && finfo->mtime_ts.tv_sec < newer_than) {
+		DEBUG(3,("newer_than %s failed\n", finfo->name));
+		return false;
+	}
+
+	if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) {
+		DEBUG(3,("archive %s failed\n", finfo->name));
+		return false;
+	}
+
+	return true;
+}
+
+/****************************************************************************
+ Display info about a file.
+****************************************************************************/
+
+static void display_finfo(file_info *finfo, const char *dir)
+{
+	time_t t;
+	TALLOC_CTX *ctx = talloc_tos();
+
+	if (!do_this_one(finfo)) {
+		return;
+	}
+
+	t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
+	if (!showacls) {
+		d_printf("  %-30s%7.7s %8.0f  %s",
+			 finfo->name,
+			 attrib_string(finfo->mode),
+		 	(double)finfo->size,
+			time_to_asc(t));
+		dir_total += finfo->size;
+	} else {
+		char *afname = NULL;
+		int fnum;
+
+		/* skip if this is . or .. */
+		if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
+			return;
+		/* create absolute filename for cli_nt_create() FIXME */
+		afname = talloc_asprintf(ctx,
+					"%s%s%s",
+					dir,
+					CLI_DIRSEP_STR,
+					finfo->name);
+		if (!afname) {
+			return;
+		}
+		/* print file meta date header */
+		d_printf( "FILENAME:%s\n", finfo->name);
+		d_printf( "MODE:%s\n", attrib_string(finfo->mode));
+		d_printf( "SIZE:%.0f\n", (double)finfo->size);
+		d_printf( "MTIME:%s", time_to_asc(t));
+		fnum = cli_nt_create(finfo->cli, afname, CREATE_ACCESS_READ);
+		if (fnum == -1) {
+			DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
+				afname,
+				cli_errstr( finfo->cli)));
+		} else {
+			SEC_DESC *sd = NULL;
+			sd = cli_query_secdesc(finfo->cli, fnum, ctx);
+			if (!sd) {
+				DEBUG( 0, ("display_finfo() failed to "
+					"get security descriptor: %s",
+					cli_errstr( finfo->cli)));
+			} else {
+				display_sec_desc(sd);
+			}
+			TALLOC_FREE(sd);
+		}
+		TALLOC_FREE(afname);
+	}
+}
+
+/****************************************************************************
+ Accumulate size of a file.
+****************************************************************************/
+
+static void do_du(file_info *finfo, const char *dir)
+{
+	if (do_this_one(finfo)) {
+		dir_total += finfo->size;
+	}
+}
+
+static bool do_list_recurse;
+static bool do_list_dirs;
+static char *do_list_queue = 0;
+static long do_list_queue_size = 0;
+static long do_list_queue_start = 0;
+static long do_list_queue_end = 0;
+static void (*do_list_fn)(file_info *, const char *dir);
+
+/****************************************************************************
+ Functions for do_list_queue.
+****************************************************************************/
+
+/*
+ * The do_list_queue is a NUL-separated list of strings stored in a
+ * char*.  Since this is a FIFO, we keep track of the beginning and
+ * ending locations of the data in the queue.  When we overflow, we
+ * double the size of the char*.  When the start of the data passes
+ * the midpoint, we move everything back.  This is logically more
+ * complex than a linked list, but easier from a memory management
+ * angle.  In any memory error condition, do_list_queue is reset.
+ * Functions check to ensure that do_list_queue is non-NULL before
+ * accessing it.
+ */
+
+static void reset_do_list_queue(void)
+{
+	SAFE_FREE(do_list_queue);
+	do_list_queue_size = 0;
+	do_list_queue_start = 0;
+	do_list_queue_end = 0;
+}
+
+static void init_do_list_queue(void)
+{
+	reset_do_list_queue();
+	do_list_queue_size = 1024;
+	do_list_queue = (char *)SMB_MALLOC(do_list_queue_size);
+	if (do_list_queue == 0) {
+		d_printf("malloc fail for size %d\n",
+			 (int)do_list_queue_size);
+		reset_do_list_queue();
+	} else {
+		memset(do_list_queue, 0, do_list_queue_size);
+	}
+}
+
+static void adjust_do_list_queue(void)
+{
+	/*
+	 * If the starting point of the queue is more than half way through,
+	 * move everything toward the beginning.
+	 */
+
+	if (do_list_queue == NULL) {
+		DEBUG(4,("do_list_queue is empty\n"));
+		do_list_queue_start = do_list_queue_end = 0;
+		return;
+	}
+
+	if (do_list_queue_start == do_list_queue_end) {
+		DEBUG(4,("do_list_queue is empty\n"));
+		do_list_queue_start = do_list_queue_end = 0;
+		*do_list_queue = '\0';
+	} else if (do_list_queue_start > (do_list_queue_size / 2)) {
+		DEBUG(4,("sliding do_list_queue backward\n"));
+		memmove(do_list_queue,
+			do_list_queue + do_list_queue_start,
+			do_list_queue_end - do_list_queue_start);
+		do_list_queue_end -= do_list_queue_start;
+		do_list_queue_start = 0;
+	}
+}
+
+static void add_to_do_list_queue(const char *entry)
+{
+	long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
+	while (new_end > do_list_queue_size) {
+		do_list_queue_size *= 2;
+		DEBUG(4,("enlarging do_list_queue to %d\n",
+			 (int)do_list_queue_size));
+		do_list_queue = (char *)SMB_REALLOC(do_list_queue, do_list_queue_size);
+		if (! do_list_queue) {
+			d_printf("failure enlarging do_list_queue to %d bytes\n",
+				 (int)do_list_queue_size);
+			reset_do_list_queue();
+		} else {
+			memset(do_list_queue + do_list_queue_size / 2,
+			       0, do_list_queue_size / 2);
+		}
+	}
+	if (do_list_queue) {
+		safe_strcpy_base(do_list_queue + do_list_queue_end,
+				 entry, do_list_queue, do_list_queue_size);
+		do_list_queue_end = new_end;
+		DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
+			 entry, (int)do_list_queue_start, (int)do_list_queue_end));
+	}
+}
+
+static char *do_list_queue_head(void)
+{
+	return do_list_queue + do_list_queue_start;
+}
+
+static void remove_do_list_queue_head(void)
+{
+	if (do_list_queue_end > do_list_queue_start) {
+		do_list_queue_start += strlen(do_list_queue_head()) + 1;
+		adjust_do_list_queue();
+		DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
+			 (int)do_list_queue_start, (int)do_list_queue_end));
+	}
+}
+
+static int do_list_queue_empty(void)
+{
+	return (! (do_list_queue && *do_list_queue));
+}
+
+/****************************************************************************
+ A helper for do_list.
+****************************************************************************/
+
+static void do_list_helper(const char *mntpoint, file_info *f, const char *mask, void *state)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *dir = NULL;
+	char *dir_end = NULL;
+
+	/* Work out the directory. */
+	dir = talloc_strdup(ctx, mask);
+	if (!dir) {
+		return;
+	}
+	if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
+		*dir_end = '\0';
+	}
+
+	if (f->mode & aDIR) {
+		if (do_list_dirs && do_this_one(f)) {
+			do_list_fn(f, dir);
+		}
+		if (do_list_recurse &&
+		    f->name &&
+		    !strequal(f->name,".") &&
+		    !strequal(f->name,"..")) {
+			char *mask2 = NULL;
+			char *p = NULL;
+
+			if (!f->name[0]) {
+				d_printf("Empty dir name returned. Possible server misconfiguration.\n");
+				TALLOC_FREE(dir);
+				return;
+			}
+
+			mask2 = talloc_asprintf(ctx,
+					"%s%s",
+					mntpoint,
+					mask);
+			if (!mask2) {
+				TALLOC_FREE(dir);
+				return;
+			}
+			p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
+			if (p) {
+				p[1] = 0;
+			} else {
+				mask2[0] = '\0';
+			}
+			mask2 = talloc_asprintf_append(mask2,
+					"%s%s*",
+					f->name,
+					CLI_DIRSEP_STR);
+			if (!mask2) {
+				TALLOC_FREE(dir);
+				return;
+			}
+			add_to_do_list_queue(mask2);
+			TALLOC_FREE(mask2);
+		}
+		TALLOC_FREE(dir);
+		return;
+	}
+
+	if (do_this_one(f)) {
+		do_list_fn(f,dir);
+	}
+	TALLOC_FREE(dir);
+}
+
+/****************************************************************************
+ A wrapper around cli_list that adds recursion.
+****************************************************************************/
+
+void do_list(const char *mask,
+			uint16 attribute,
+			void (*fn)(file_info *, const char *dir),
+			bool rec,
+			bool dirs)
+{
+	static int in_do_list = 0;
+	TALLOC_CTX *ctx = talloc_tos();
+	struct cli_state *targetcli = NULL;
+	char *targetpath = NULL;
+
+	if (in_do_list && rec) {
+		fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
+		exit(1);
+	}
+
+	in_do_list = 1;
+
+	do_list_recurse = rec;
+	do_list_dirs = dirs;
+	do_list_fn = fn;
+
+	if (rec) {
+		init_do_list_queue();
+		add_to_do_list_queue(mask);
+
+		while (!do_list_queue_empty()) {
+			/*
+			 * Need to copy head so that it doesn't become
+			 * invalid inside the call to cli_list.  This
+			 * would happen if the list were expanded
+			 * during the call.
+			 * Fix from E. Jay Berkenbilt ([e-mail])
+			 */
+			char *head = talloc_strdup(ctx, do_list_queue_head());
+
+			if (!head) {
+				return;
+			}
+
+			/* check for dfs */
+
+			if ( !cli_resolve_path(ctx, "", auth_info, cli, head, &targetcli, &targetpath ) ) {
+				d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
+				remove_do_list_queue_head();
+				continue;
+			}
+
+			cli_list(targetcli, targetpath, attribute, do_list_helper, NULL);
+			remove_do_list_queue_head();
+			if ((! do_list_queue_empty()) && (fn == display_finfo)) {
+				char *next_file = do_list_queue_head();
+				char *save_ch = 0;
+				if ((strlen(next_file) >= 2) &&
+				    (next_file[strlen(next_file) - 1] == '*') &&
+				    (next_file[strlen(next_file) - 2] == CLI_DIRSEP_CHAR)) {
+					save_ch = next_file +
+						strlen(next_file) - 2;
+					*save_ch = '\0';
+					if (showacls) {
+						/* cwd is only used if showacls is on */
+						client_set_cwd(next_file);
+					}
+				}
+				if (!showacls) /* don't disturbe the showacls output */
+					d_printf("\n%s\n",next_file);
+				if (save_ch) {
+					*save_ch = CLI_DIRSEP_CHAR;
+				}
+			}
+			TALLOC_FREE(head);
+			TALLOC_FREE(targetpath);
+		}
+	} else {
+		/* check for dfs */
+		if (cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetpath)) {
+			if (cli_list(targetcli, targetpath, attribute, do_list_helper, NULL) == -1) {
+				d_printf("%s listing %s\n",
+					cli_errstr(targetcli), targetpath);
+			}
+			TALLOC_FREE(targetpath);
+		} else {
+			d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
+		}
+	}
+
+	in_do_list = 0;
+	reset_do_list_queue();
+}
+
+/****************************************************************************
+ Get a directory listing.
+****************************************************************************/
+
+static int cmd_dir(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
+	char *mask = NULL;
+	char *buf = NULL;
+	int rc = 1;
+
+	dir_total = 0;
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+
+	if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		normalize_name(buf);
+		if (*buf == CLI_DIRSEP_CHAR) {
+			mask = talloc_strdup(ctx, buf);
+		} else {
+			mask = talloc_asprintf_append(mask, "%s", buf);
+		}
+	} else {
+		mask = talloc_asprintf_append(mask, "*");
+	}
+	if (!mask) {
+		return 1;
+	}
+
+	if (showacls) {
+		/* cwd is only used if showacls is on */
+		client_set_cwd(client_get_cur_dir());
+	}
+
+	do_list(mask, attribute, display_finfo, recurse, true);
+
+	rc = do_dskattr();
+
+	DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
+
+	return rc;
+}
+
+/****************************************************************************
+ Get a directory listing.
+****************************************************************************/
+
+static int cmd_du(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
+	char *mask = NULL;
+	char *buf = NULL;
+	int rc = 1;
+
+	dir_total = 0;
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+	if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR)) {
+		mask = talloc_asprintf_append(mask, "%s", CLI_DIRSEP_STR);
+		if (!mask) {
+			return 1;
+		}
+	}
+
+	if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		normalize_name(buf);
+		if (*buf == CLI_DIRSEP_CHAR) {
+			mask = talloc_strdup(ctx, buf);
+		} else {
+			mask = talloc_asprintf_append(mask, "%s", buf);
+		}
+	} else {
+		mask = talloc_strdup(ctx, "*");
+	}
+
+	do_list(mask, attribute, do_du, recurse, true);
+
+	rc = do_dskattr();
+
+	d_printf("Total number of bytes: %.0f\n", dir_total);
+
+	return rc;
+}
+
+static int cmd_echo(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *num;
+	char *data;
+	NTSTATUS status;
+
+	if (!next_token_talloc(ctx, &cmd_ptr, &num, NULL)
+	    || !next_token_talloc(ctx, &cmd_ptr, &data, NULL)) {
+		d_printf("echo <num> <data>\n");
+		return 1;
+	}
+
+	status = cli_echo(cli, atoi(num), data_blob_const(data, strlen(data)));
+
+	if (!NT_STATUS_IS_OK(status)) {
+		d_printf("echo failed: %s\n", nt_errstr(status));
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Get a file from rname to lname
+****************************************************************************/
+
+static NTSTATUS writefile_sink(char *buf, size_t n, void *priv)
+{
+	int *pfd = (int *)priv;
+	if (writefile(*pfd, buf, n) == -1) {
+		return map_nt_error_from_unix(errno);
+	}
+	return NT_STATUS_OK;
+}
+
+static int do_get(const char *rname, const char *lname_in, bool reget)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	int handle = 0, fnum;
+	bool newhandle = false;
+	struct timeval tp_start;
+	uint16 attr;
+	SMB_OFF_T size;
+	off_t start = 0;
+	SMB_OFF_T nread = 0;
+	int rc = 0;
+	struct cli_state *targetcli = NULL;
+	char *targetname = NULL;
+	char *lname = NULL;
+	NTSTATUS status;
+
+	lname = talloc_strdup(ctx, lname_in);
+	if (!lname) {
+		return 1;
+	}
+
+	if (lowercase) {
+		strlower_m(lname);
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli, &targetname ) ) {
+		d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
+		return 1;
+	}
+
+	GetTimeOfDay(&tp_start);
+
+	fnum = cli_open(targetcli, targetname, O_RDONLY, DENY_NONE);
+
+	if (fnum == -1) {
+		d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
+		return 1;
+	}
+
+	if(!strcmp(lname,"-")) {
+		handle = fileno(stdout);
+	} else {
+		if (reget) {
+			handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
+			if (handle >= 0) {
+				start = sys_lseek(handle, 0, SEEK_END);
+				if (start == -1) {
+					d_printf("Error seeking local file\n");
+					return 1;
+				}
+			}
+		} else {
+			handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+		}
+		newhandle = true;
+	}
+	if (handle < 0) {
+		d_printf("Error opening local file %s\n",lname);
+		return 1;
+	}
+
+
+	if (!cli_qfileinfo(targetcli, fnum,
+			   &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
+	    !cli_getattrE(targetcli, fnum,
+			  &attr, &size, NULL, NULL, NULL)) {
+		d_printf("getattrib: %s\n",cli_errstr(targetcli));
+		return 1;
+	}
+
+	DEBUG(1,("getting file %s of size %.0f as %s ",
+		 rname, (double)size, lname));
+
+	status = cli_pull(targetcli, fnum, start, size, io_bufsize,
+			  writefile_sink, (void *)&handle, &nread);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, "parallel_read returned %s\n",
+			  nt_errstr(status));
+		cli_close(targetcli, fnum);
+		return 1;
+	}
+
+	if (!cli_close(targetcli, fnum)) {
+		d_printf("Error %s closing remote file\n",cli_errstr(cli));
+		rc = 1;
+	}
+
+	if (newhandle) {
+		close(handle);
+	}
+
+	if (archive_level >= 2 && (attr & aARCH)) {
+		cli_setatr(cli, rname, attr & ~(uint16)aARCH, 0);
+	}
+
+	{
+		struct timeval tp_end;
+		int this_time;
+
+		GetTimeOfDay(&tp_end);
+		this_time =
+			(tp_end.tv_sec - tp_start.tv_sec)*1000 +
+			(tp_end.tv_usec - tp_start.tv_usec)/1000;
+		get_total_time_ms += this_time;
+		get_total_size += nread;
+
+		DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
+			 nread / (1.024*this_time + 1.0e-4),
+			 get_total_size / (1.024*get_total_time_ms)));
+	}
+
+	TALLOC_FREE(targetname);
+	return rc;
+}
+
+/****************************************************************************
+ Get a file.
+****************************************************************************/
+
+static int cmd_get(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *lname = NULL;
+	char *rname = NULL;
+	char *fname = NULL;
+
+	rname = talloc_strdup(ctx, client_get_cur_dir());
+	if (!rname) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
+		d_printf("get <filename> [localname]\n");
+		return 1;
+	}
+	rname = talloc_asprintf_append(rname, "%s", fname);
+	if (!rname) {
+		return 1;
+	}
+	rname = clean_name(ctx, rname);
+	if (!rname) {
+		return 1;
+	}
+
+	next_token_talloc(ctx, &cmd_ptr,&lname,NULL);
+	if (!lname) {
+		lname = fname;
+	}
+
+	return do_get(rname, lname, false);
+}
+
+/****************************************************************************
+ Do an mget operation on one file.
+****************************************************************************/
+
+static void do_mget(file_info *finfo, const char *dir)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *rname = NULL;
+	char *quest = NULL;
+	char *saved_curdir = NULL;
+	char *mget_mask = NULL;
+	char *new_cd = NULL;
+
+	if (!finfo->name) {
+		return;
+	}
+
+	if (strequal(finfo->name,".") || strequal(finfo->name,".."))
+		return;
+
+	if (abort_mget)	{
+		d_printf("mget aborted\n");
+		return;
+	}
+
+	if (finfo->mode & aDIR) {
+		if (asprintf(&quest,
+			 "Get directory %s? ",finfo->name) < 0) {
+			return;
+		}
+	} else {
+		if (asprintf(&quest,
+			 "Get file %s? ",finfo->name) < 0) {
+			return;
+		}
+	}
+
+	if (prompt && !yesno(quest)) {
+		SAFE_FREE(quest);
+		return;
+	}
+	SAFE_FREE(quest);
+
+	if (!(finfo->mode & aDIR)) {
+		rname = talloc_asprintf(ctx,
+				"%s%s",
+				client_get_cur_dir(),
+				finfo->name);
+		if (!rname) {
+			return;
+		}
+		do_get(rname, finfo->name, false);
+		TALLOC_FREE(rname);
+		return;
+	}
+
+	/* handle directories */
+	saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
+	if (!saved_curdir) {
+		return;
+	}
+
+	new_cd = talloc_asprintf(ctx,
+				"%s%s%s",
+				client_get_cur_dir(),
+				finfo->name,
+				CLI_DIRSEP_STR);
+	if (!new_cd) {
+		return;
+	}
+	client_set_cur_dir(new_cd);
+
+	string_replace(finfo->name,'\\','/');
+	if (lowercase) {
+		strlower_m(finfo->name);
+	}
+
+	if (!directory_exist(finfo->name) &&
+	    mkdir(finfo->name,0777) != 0) {
+		d_printf("failed to create directory %s\n",finfo->name);
+		client_set_cur_dir(saved_curdir);
+		return;
+	}
+
+	if (chdir(finfo->name) != 0) {
+		d_printf("failed to chdir to directory %s\n",finfo->name);
+		client_set_cur_dir(saved_curdir);
+		return;
+	}
+
+	mget_mask = talloc_asprintf(ctx,
+			"%s*",
+			client_get_cur_dir());
+
+	if (!mget_mask) {
+		return;
+	}
+
+	do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,false, true);
+	if (chdir("..") == -1) {
+		d_printf("do_mget: failed to chdir to .. (error %s)\n",
+			strerror(errno) );
+	}
+	client_set_cur_dir(saved_curdir);
+	TALLOC_FREE(mget_mask);
+	TALLOC_FREE(saved_curdir);
+	TALLOC_FREE(new_cd);
+}
+
+/****************************************************************************
+ View the file using the pager.
+****************************************************************************/
+
+static int cmd_more(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *rname = NULL;
+	char *fname = NULL;
+	char *lname = NULL;
+	char *pager_cmd = NULL;
+	const char *pager;
+	int fd;
+	int rc = 0;
+
+	rname = talloc_strdup(ctx, client_get_cur_dir());
+	if (!rname) {
+		return 1;
+	}
+
+	lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
+	if (!lname) {
+		return 1;
+	}
+	fd = smb_mkstemp(lname);
+	if (fd == -1) {
+		d_printf("failed to create temporary file for more\n");
+		return 1;
+	}
+	close(fd);
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
+		d_printf("more <filename>\n");
+		unlink(lname);
+		return 1;
+	}
+	rname = talloc_asprintf_append(rname, "%s", fname);
+	if (!rname) {
+		return 1;
+	}
+	rname = clean_name(ctx,rname);
+	if (!rname) {
+		return 1;
+	}
+
+	rc = do_get(rname, lname, false);
+
+	pager=getenv("PAGER");
+
+	pager_cmd = talloc_asprintf(ctx,
+				"%s %s",
+				(pager? pager:PAGER),
+				lname);
+	if (!pager_cmd) {
+		return 1;
+	}
+	if (system(pager_cmd) == -1) {
+		d_printf("system command '%s' returned -1\n",
+			pager_cmd);
+	}
+	unlink(lname);
+
+	return rc;
+}
+
+/****************************************************************************
+ Do a mget command.
+****************************************************************************/
+
+static int cmd_mget(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	uint16 attribute = aSYSTEM | aHIDDEN;
+	char *mget_mask = NULL;
+	char *buf = NULL;
+
+	if (recurse) {
+		attribute |= aDIR;
+	}
+
+	abort_mget = false;
+
+	while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		mget_mask = talloc_strdup(ctx, client_get_cur_dir());
+		if (!mget_mask) {
+			return 1;
+		}
+		if (*buf == CLI_DIRSEP_CHAR) {
+			mget_mask = talloc_strdup(ctx, buf);
+		} else {
+			mget_mask = talloc_asprintf_append(mget_mask,
+							"%s", buf);
+		}
+		if (!mget_mask) {
+			return 1;
+		}
+		do_list(mget_mask, attribute, do_mget, false, true);
+	}
+
+	if (mget_mask == NULL) {
+		d_printf("nothing to mget\n");
+		return 0;
+	}
+
+	if (!*mget_mask) {
+		mget_mask = talloc_asprintf(ctx,
+					"%s*",
+					client_get_cur_dir());
+		if (!mget_mask) {
+			return 1;
+		}
+		do_list(mget_mask, attribute, do_mget, false, true);
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Make a directory of name "name".
+****************************************************************************/
+
+static bool do_mkdir(const char *name)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	struct cli_state *targetcli;
+	char *targetname = NULL;
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli, &targetname)) {
+		d_printf("mkdir %s: %s\n", name, cli_errstr(cli));
+		return false;
+	}
+
+	if (!cli_mkdir(targetcli, targetname)) {
+		d_printf("%s making remote directory %s\n",
+			 cli_errstr(targetcli),name);
+		return false;
+	}
+
+	return true;
+}
+
+/****************************************************************************
+ Show 8.3 name of a file.
+****************************************************************************/
+
+static bool do_altname(const char *name)
+{
+	fstring altname;
+
+	if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
+		d_printf("%s getting alt name for %s\n",
+			 cli_errstr(cli),name);
+		return false;
+	}
+	d_printf("%s\n", altname);
+
+	return true;
+}
+
+/****************************************************************************
+ Exit client.
+****************************************************************************/
+
+static int cmd_quit(void)
+{
+	cli_shutdown(cli);
+	exit(0);
+	/* NOTREACHED */
+	return 0;
+}
+
+/****************************************************************************
+ Make a directory.
+****************************************************************************/
+
+static int cmd_mkdir(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		if (!recurse) {
+			d_printf("mkdir <dirname>\n");
+		}
+		return 1;
+	}
+	mask = talloc_asprintf_append(mask, "%s", buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (recurse) {
+		char *ddir = NULL;
+		char *ddir2 = NULL;
+		struct cli_state *targetcli;
+		char *targetname = NULL;
+		char *p = NULL;
+		char *saveptr;
+
+		ddir2 = talloc_strdup(ctx, "");
+		if (!ddir2) {
+			return 1;
+		}
+
+		if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+			return 1;
+		}
+
+		ddir = talloc_strdup(ctx, targetname);
+		if (!ddir) {
+			return 1;
+		}
+		trim_char(ddir,'.','\0');
+		p = strtok_r(ddir, "/\\", &saveptr);
+		while (p) {
+			ddir2 = talloc_asprintf_append(ddir2, "%s", p);
+			if (!ddir2) {
+				return 1;
+			}
+			if (!cli_chkpath(targetcli, ddir2)) {
+				do_mkdir(ddir2);
+			}
+			ddir2 = talloc_asprintf_append(ddir2, "%s", CLI_DIRSEP_STR);
+			if (!ddir2) {
+				return 1;
+			}
+			p = strtok_r(NULL, "/\\", &saveptr);
+		}
+	} else {
+		do_mkdir(mask);
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Show alt name.
+****************************************************************************/
+
+static int cmd_altname(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *name;
+	char *buf;
+
+	name = talloc_strdup(ctx, client_get_cur_dir());
+	if (!name) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+		d_printf("altname <file>\n");
+		return 1;
+	}
+	name = talloc_asprintf_append(name, "%s", buf);
+	if (!name) {
+		return 1;
+	}
+	do_altname(name);
+	return 0;
+}
+
+/****************************************************************************
+ Show all info we can get
+****************************************************************************/
+
+static int do_allinfo(const char *name)
+{
+	fstring altname;
+	struct timespec b_time, a_time, m_time, c_time;
+	SMB_OFF_T size;
+	uint16_t mode;
+	SMB_INO_T ino;
+	NTTIME tmp;
+	unsigned int num_streams;
+	struct stream_struct *streams;
+	unsigned int i;
+
+	if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
+		d_printf("%s getting alt name for %s\n",
+			 cli_errstr(cli),name);
+		return false;
+	}
+	d_printf("altname: %s\n", altname);
+
+	if (!cli_qpathinfo2(cli, name, &b_time, &a_time, &m_time, &c_time,
+			    &size, &mode, &ino)) {
+		d_printf("%s getting pathinfo for %s\n",
+			 cli_errstr(cli),name);
+		return false;
+	}
+
+	unix_timespec_to_nt_time(&tmp, b_time);
+	d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
+
+	unix_timespec_to_nt_time(&tmp, a_time);
+	d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
+
+	unix_timespec_to_nt_time(&tmp, m_time);
+	d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
+
+	unix_timespec_to_nt_time(&tmp, c_time);
+	d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
+
+	if (!cli_qpathinfo_streams(cli, name, talloc_tos(), &num_streams,
+				   &streams)) {
+		d_printf("%s getting streams for %s\n",
+			 cli_errstr(cli),name);
+		return false;
+	}
+
+	for (i=0; i<num_streams; i++) {
+		d_printf("stream: [%s], %lld bytes\n", streams[i].name,
+			 (unsigned long long)streams[i].size);
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Show all info we can get
+****************************************************************************/
+
+static int cmd_allinfo(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *name;
+	char *buf;
+
+	name = talloc_strdup(ctx, client_get_cur_dir());
+	if (!name) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
+		d_printf("allinfo <file>\n");
+		return 1;
+	}
+	name = talloc_asprintf_append(name, "%s", buf);
+	if (!name) {
+		return 1;
+	}
+
+	do_allinfo(name);
+
+	return 0;
+}
+
+/****************************************************************************
+ Put a single file.
+****************************************************************************/
+
+static int do_put(const char *rname, const char *lname, bool reput)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	int fnum;
+	XFILE *f;
+	SMB_OFF_T start = 0;
+	int rc = 0;
+	struct timeval tp_start;
+	struct cli_state *targetcli;
+	char *targetname = NULL;
+	struct push_state state;
+	NTSTATUS status;
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli, &targetname)) {
+		d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
+		return 1;
+	}
+
+	GetTimeOfDay(&tp_start);
+
+	if (reput) {
+		fnum = cli_open(targetcli, targetname, O_RDWR|O_CREAT, DENY_NONE);
+		if (fnum >= 0) {
+			if (!cli_qfileinfo(targetcli, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL) &&
+			    !cli_getattrE(targetcli, fnum, NULL, &start, NULL, NULL, NULL)) {
+				d_printf("getattrib: %s\n",cli_errstr(cli));
+				return 1;
+			}
+		}
+	} else {
+		fnum = cli_open(targetcli, targetname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
+	}
+
+	if (fnum == -1) {
+		d_printf("%s opening remote file %s\n",cli_errstr(targetcli),rname);
+		return 1;
+	}
+
+	/* allow files to be piped into smbclient
+	   jdblair 24.jun.98
+
+	   Note that in this case this function will exit(0) rather
+	   than returning. */
+	if (!strcmp(lname, "-")) {
+		f = x_stdin;
+		/* size of file is not known */
+	} else {
+		f = x_fopen(lname,O_RDONLY, 0);
+		if (f && reput) {
+			if (x_tseek(f, start, SEEK_SET) == -1) {
+				d_printf("Error seeking local file\n");
+				return 1;
+			}
+		}
+	}
+
+	if (!f) {
+		d_printf("Error opening local file %s\n",lname);
+		return 1;
+	}
+
+	DEBUG(1,("putting file %s as %s ",lname,
+		 rname));
+
+	x_setvbuf(f, NULL, X_IOFBF, io_bufsize);
+
+	state.f = f;
+	state.nread = 0;
+
+	status = cli_push(targetcli, fnum, 0, 0, io_bufsize, push_source,
+			  &state);
+	if (!NT_STATUS_IS_OK(status)) {
+		d_fprintf(stderr, "cli_push returned %s\n", nt_errstr(status));
+	}
+
+	if (!cli_close(targetcli, fnum)) {
+		d_printf("%s closing remote file %s\n",cli_errstr(cli),rname);
+		x_fclose(f);
+		return 1;
+	}
+
+	if (f != x_stdin) {
+		x_fclose(f);
+	}
+
+	{
+		struct timeval tp_end;
+		int this_time;
+
+		GetTimeOfDay(&tp_end);
+		this_time =
+			(tp_end.tv_sec - tp_start.tv_sec)*1000 +
+			(tp_end.tv_usec - tp_start.tv_usec)/1000;
+		put_total_time_ms += this_time;
+		put_total_size += state.nread;
+
+		DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
+			 state.nread / (1.024*this_time + 1.0e-4),
+			 put_total_size / (1.024*put_total_time_ms)));
+	}
+
+	if (f == x_stdin) {
+		cli_shutdown(cli);
+		exit(0);
+	}
+
+	return rc;
+}
+
+/****************************************************************************
+ Put a file.
+****************************************************************************/
+
+static int cmd_put(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *lname;
+	char *rname;
+	char *buf;
+
+	rname = talloc_strdup(ctx, client_get_cur_dir());
+	if (!rname) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&lname,NULL)) {
+		d_printf("put <filename>\n");
+		return 1;
+	}
+
+	if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		rname = talloc_asprintf_append(rname, "%s", buf);
+	} else {
+		rname = talloc_asprintf_append(rname, "%s", lname);
+	}
+	if (!rname) {
+		return 1;
+	}
+
+	rname = clean_name(ctx, rname);
+	if (!rname) {
+		return 1;
+	}
+
+	{
+		SMB_STRUCT_STAT st;
+		/* allow '-' to represent stdin
+		   jdblair, 24.jun.98 */
+		if (!file_exist_stat(lname,&st) &&
+		    (strcmp(lname,"-"))) {
+			d_printf("%s does not exist\n",lname);
+			return 1;
+		}
+	}
+
+	return do_put(rname, lname, false);
+}
+
+/*************************************
+ File list structure.
+*************************************/
+
+static struct file_list {
+	struct file_list *prev, *next;
+	char *file_path;
+	bool isdir;
+} *file_list;
+
+/****************************************************************************
+ Free a file_list structure.
+****************************************************************************/
+
+static void free_file_list (struct file_list *l_head)
+{
+	struct file_list *list, *next;
+
+	for (list = l_head; list; list = next) {
+		next = list->next;
+		DLIST_REMOVE(l_head, list);
+		SAFE_FREE(list->file_path);
+		SAFE_FREE(list);
+	}
+}
+
+/****************************************************************************
+ Seek in a directory/file list until you get something that doesn't start with
+ the specified name.
+****************************************************************************/
+
+static bool seek_list(struct file_list *list, char *name)
+{
+	while (list) {
+		trim_string(list->file_path,"./","\n");
+		if (strncmp(list->file_path, name, strlen(name)) != 0) {
+			return true;
+		}
+		list = list->next;
+	}
+
+	return false;
+}
+
+/****************************************************************************
+ Set the file selection mask.
+****************************************************************************/
+
+static int cmd_select(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *new_fs = NULL;
+	next_token_talloc(ctx, &cmd_ptr,&new_fs,NULL)
+		;
+	if (new_fs) {
+		client_set_fileselection(new_fs);
+	} else {
+		client_set_fileselection("");
+	}
+	return 0;
+}
+
+/****************************************************************************
+  Recursive file matching function act as find
+  match must be always set to true when calling this function
+****************************************************************************/
+
+static int file_find(struct file_list **list, const char *directory,
+		      const char *expression, bool match)
+{
+	SMB_STRUCT_DIR *dir;
+	struct file_list *entry;
+        struct stat statbuf;
+        int ret;
+        char *path;
+	bool isdir;
+	const char *dname;
+
+        dir = sys_opendir(directory);
+	if (!dir)
+		return -1;
+
+        while ((dname = readdirname(dir))) {
+		if (!strcmp("..", dname))
+			continue;
+		if (!strcmp(".", dname))
+			continue;
+
+		if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
+			continue;
+		}
+
+		isdir = false;
+		if (!match || !gen_fnmatch(expression, dname)) {
+			if (recurse) {
+				ret = stat(path, &statbuf);
+				if (ret == 0) {
+					if (S_ISDIR(statbuf.st_mode)) {
+						isdir = true;
+						ret = file_find(list, path, expression, false);
+					}
+				} else {
+					d_printf("file_find: cannot stat file %s\n", path);
+				}
+
+				if (ret == -1) {
+					SAFE_FREE(path);
+					sys_closedir(dir);
+					return -1;
+				}
+			}
+			entry = SMB_MALLOC_P(struct file_list);
+			if (!entry) {
+				d_printf("Out of memory in file_find\n");
+				sys_closedir(dir);
+				return -1;
+			}
+			entry->file_path = path;
+			entry->isdir = isdir;
+                        DLIST_ADD(*list, entry);
+		} else {
+			SAFE_FREE(path);
+		}
+        }
+
+	sys_closedir(dir);
+	return 0;
+}
+
+/****************************************************************************
+ mput some files.
+****************************************************************************/
+
+static int cmd_mput(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *p = NULL;
+
+	while (next_token_talloc(ctx, &cmd_ptr,&p,NULL)) {
+		int ret;
+		struct file_list *temp_list;
+		char *quest, *lname, *rname;
+
+		file_list = NULL;
+
+		ret = file_find(&file_list, ".", p, true);
+		if (ret) {
+			free_file_list(file_list);
+			continue;
+		}
+
+		quest = NULL;
+		lname = NULL;
+		rname = NULL;
+
+		for (temp_list = file_list; temp_list;
+		     temp_list = temp_list->next) {
+
+			SAFE_FREE(lname);
+			if (asprintf(&lname, "%s/", temp_list->file_path) <= 0) {
+				continue;
+			}
+			trim_string(lname, "./", "/");
+
+			/* check if it's a directory */
+			if (temp_list->isdir) {
+				/* if (!recurse) continue; */
+
+				SAFE_FREE(quest);
+				if (asprintf(&quest, "Put directory %s? ", lname) < 0) {
+					break;
+				}
+				if (prompt && !yesno(quest)) { /* No */
+					/* Skip the directory */
+					lname[strlen(lname)-1] = '/';
+					if (!seek_list(temp_list, lname))
+						break;
+				} else { /* Yes */
+	      				SAFE_FREE(rname);
+					if(asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
+						break;
+					}
+					normalize_name(rname);
+					if (!cli_chkpath(cli, rname) &&
+					    !do_mkdir(rname)) {
+						DEBUG (0, ("Unable to make dir, skipping..."));
+						/* Skip the directory */
+						lname[strlen(lname)-1] = '/';
+						if (!seek_list(temp_list, lname)) {
+							break;
+						}
+					}
+				}
+				continue;
+			} else {
+				SAFE_FREE(quest);
+				if (asprintf(&quest,"Put file %s? ", lname) < 0) {
+					break;
+				}
+				if (prompt && !yesno(quest)) {
+					/* No */
+					continue;
+				}
+
+				/* Yes */
+				SAFE_FREE(rname);
+				if (asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
+					break;
+				}
+			}
+
+			normalize_name(rname);
+
+			do_put(rname, lname, false);
+		}
+		free_file_list(file_list);
+		SAFE_FREE(quest);
+		SAFE_FREE(lname);
+		SAFE_FREE(rname);
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Cancel a print job.
+****************************************************************************/
+
+static int do_cancel(int job)
+{
+	if (cli_printjob_del(cli, job)) {
+		d_printf("Job %d cancelled\n",job);
+		return 0;
+	} else {
+		d_printf("Error cancelling job %d : %s\n",job,cli_errstr(cli));
+		return 1;
+	}
+}
+
+/****************************************************************************
+ Cancel a print job.
+****************************************************************************/
+
+static int cmd_cancel(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
+	int job;
+
+	if (!next_token_talloc(ctx, &cmd_ptr, &buf,NULL)) {
+		d_printf("cancel <jobid> ...\n");
+		return 1;
+	}
+	do {
+		job = atoi(buf);
+		do_cancel(job);
+	} while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL));
+
+	return 0;
+}
+
+/****************************************************************************
+ Print a file.
+****************************************************************************/
+
+static int cmd_print(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *lname = NULL;
+	char *rname = NULL;
+	char *p = NULL;
+
+	if (!next_token_talloc(ctx, &cmd_ptr, &lname,NULL)) {
+		d_printf("print <filename>\n");
+		return 1;
+	}
+
+	rname = talloc_strdup(ctx, lname);
+	if (!rname) {
+		return 1;
+	}
+	p = strrchr_m(rname,'/');
+	if (p) {
+		rname = talloc_asprintf(ctx,
+					"%s-%d",
+					p+1,
+					(int)sys_getpid());
+	}
+	if (strequal(lname,"-")) {
+		rname = talloc_asprintf(ctx,
+				"stdin-%d",
+				(int)sys_getpid());
+	}
+	if (!rname) {
+		return 1;
+	}
+
+	return do_put(rname, lname, false);
+}
+
+/****************************************************************************
+ Show a print queue entry.
+****************************************************************************/
+
+static void queue_fn(struct print_job_info *p)
+{
+	d_printf("%-6d   %-9d    %s\n", (int)p->id, (int)p->size, p->name);
+}
+
+/****************************************************************************
+ Show a print queue.
+****************************************************************************/
+
+static int cmd_queue(void)
+{
+	cli_print_queue(cli, queue_fn);
+	return 0;
+}
+
+/****************************************************************************
+ Delete some files.
+****************************************************************************/
+
+static void do_del(file_info *finfo, const char *dir)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+
+	mask = talloc_asprintf(ctx,
+				"%s%c%s",
+				dir,
+				CLI_DIRSEP_CHAR,
+				finfo->name);
+	if (!mask) {
+		return;
+	}
+
+	if (finfo->mode & aDIR) {
+		TALLOC_FREE(mask);
+		return;
+	}
+
+	if (!cli_unlink(finfo->cli, mask)) {
+		d_printf("%s deleting remote file %s\n",
+				cli_errstr(finfo->cli),mask);
+	}
+	TALLOC_FREE(mask);
+}
+
+/****************************************************************************
+ Delete some files.
+****************************************************************************/
+
+static int cmd_del(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	uint16 attribute = aSYSTEM | aHIDDEN;
+
+	if (recurse) {
+		attribute |= aDIR;
+	}
+
+	mask = talloc_strdup(ctx, client_get_cur_dir());
+	if (!mask) {
+		return 1;
+	}
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("del <filename>\n");
+		return 1;
+	}
+	mask = talloc_asprintf_append(mask, "%s", buf);
+	if (!mask) {
+		return 1;
+	}
+
+	do_list(mask,attribute,do_del,false,false);
+	return 0;
+}
+
+/****************************************************************************
+ Wildcard delete some files.
+****************************************************************************/
+
+static int cmd_wdel(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	uint16 attribute;
+	struct cli_state *targetcli;
+	char *targetname = NULL;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("wdel 0x<attrib> <wcard>\n");
+		return 1;
+	}
+
+	attribute = (uint16)strtol(buf, (char **)NULL, 16);
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("wdel 0x<attrib> <wcard>\n");
+		return 1;
+	}
+
+	mask = talloc_asprintf(ctx, "%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_unlink_full(targetcli, targetname, attribute)) {
+		d_printf("%s deleting remote files %s\n",cli_errstr(targetcli),targetname);
+	}
+	return 0;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static int cmd_open(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+	int fnum;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("open <filename>\n");
+		return 1;
+	}
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("open %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	fnum = cli_nt_create(targetcli, targetname, FILE_READ_DATA|FILE_WRITE_DATA);
+	if (fnum == -1) {
+		fnum = cli_nt_create(targetcli, targetname, FILE_READ_DATA);
+		if (fnum != -1) {
+			d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
+		} else {
+			d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
+		}
+	} else {
+		d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
+	}
+	return 0;
+}
+
+static int cmd_posix_encrypt(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
+
+	if (cli->use_kerberos) {
+		status = cli_gss_smb_encryption_start(cli);
+	} else {
+		char *domain = NULL;
+		char *user = NULL;
+		char *password = NULL;
+
+		if (!next_token_talloc(ctx, &cmd_ptr,&domain,NULL)) {
+			d_printf("posix_encrypt domain user password\n");
+			return 1;
+		}
+
+		if (!next_token_talloc(ctx, &cmd_ptr,&user,NULL)) {
+			d_printf("posix_encrypt domain user password\n");
+			return 1;
+		}
+
+		if (!next_token_talloc(ctx, &cmd_ptr,&password,NULL)) {
+			d_printf("posix_encrypt domain user password\n");
+			return 1;
+		}
+
+		status = cli_raw_ntlm_smb_encryption_start(cli,
+							user,
+							password,
+							domain);
+	}
+
+	if (!NT_STATUS_IS_OK(status)) {
+		d_printf("posix_encrypt failed with error %s\n", nt_errstr(status));
+	} else {
+		d_printf("encryption on\n");
+		smb_encrypt = true;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static int cmd_posix_open(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+	mode_t mode;
+	int fnum;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("posix_open <filename> 0<mode>\n");
+		return 1;
+	}
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("posix_open <filename> 0<mode>\n");
+		return 1;
+	}
+	mode = (mode_t)strtol(buf, (char **)NULL, 8);
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("posix_open %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	fnum = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode);
+	if (fnum == -1) {
+		fnum = cli_posix_open(targetcli, targetname, O_CREAT|O_RDONLY, mode);
+		if (fnum != -1) {
+			d_printf("posix_open file %s: for read/write fnum %d\n", targetname, fnum);
+		} else {
+			d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
+		}
+	} else {
+		d_printf("posix_open file %s: for read/write fnum %d\n", targetname, fnum);
+	}
+
+	return 0;
+}
+
+static int cmd_posix_mkdir(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+	mode_t mode;
+	int fnum;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("posix_mkdir <filename> 0<mode>\n");
+		return 1;
+	}
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("posix_mkdir <filename> 0<mode>\n");
+		return 1;
+	}
+	mode = (mode_t)strtol(buf, (char **)NULL, 8);
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	fnum = cli_posix_mkdir(targetcli, targetname, mode);
+	if (fnum == -1) {
+		d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
+	} else {
+		d_printf("posix_mkdir created directory %s\n", targetname);
+	}
+	return 0;
+}
+
+static int cmd_posix_unlink(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("posix_unlink <filename>\n");
+		return 1;
+	}
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_posix_unlink(targetcli, targetname)) {
+		d_printf("Failed to unlink file %s. %s\n", targetname, cli_errstr(cli));
+	} else {
+		d_printf("posix_unlink deleted file %s\n", targetname);
+	}
+
+	return 0;
+}
+
+static int cmd_posix_rmdir(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("posix_rmdir <filename>\n");
+		return 1;
+	}
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_posix_rmdir(targetcli, targetname)) {
+		d_printf("Failed to unlink directory %s. %s\n", targetname, cli_errstr(cli));
+	} else {
+		d_printf("posix_rmdir deleted directory %s\n", targetname);
+	}
+
+	return 0;
+}
+
+static int cmd_close(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
+	int fnum;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("close <fnum>\n");
+		return 1;
+	}
+
+	fnum = atoi(buf);
+	/* We really should use the targetcli here.... */
+	if (!cli_close(cli, fnum)) {
+		d_printf("close %d: %s\n", fnum, cli_errstr(cli));
+		return 1;
+	}
+	return 0;
+}
+
+static int cmd_posix(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	uint16 major, minor;
+	uint32 caplow, caphigh;
+	char *caps;
+
+	if (!SERVER_HAS_UNIX_CIFS(cli)) {
+		d_printf("Server doesn't support UNIX CIFS extensions.\n");
+		return 1;
+	}
+
+	if (!cli_unix_extensions_version(cli, &major, &minor, &caplow, &caphigh)) {
+		d_printf("Can't get UNIX CIFS extensions version from server.\n");
+		return 1;
+	}
+
+	d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major, (unsigned int)minor);
+
+	caps = talloc_strdup(ctx, "");
+	if (!caps) {
+		return 1;
+	}
+        if (caplow & CIFS_UNIX_FCNTL_LOCKS_CAP) {
+		caps = talloc_asprintf_append(caps, "locks ");
+		if (!caps) {
+			return 1;
+		}
+	}
+        if (caplow & CIFS_UNIX_POSIX_ACLS_CAP) {
+		caps = talloc_asprintf_append(caps, "acls ");
+		if (!caps) {
+			return 1;
+		}
+	}
+        if (caplow & CIFS_UNIX_XATTTR_CAP) {
+		caps = talloc_asprintf_append(caps, "eas ");
+		if (!caps) {
+			return 1;
+		}
+	}
+        if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
+		caps = talloc_asprintf_append(caps, "pathnames ");
+		if (!caps) {
+			return 1;
+		}
+	}
+        if (caplow & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP) {
+		caps = talloc_asprintf_append(caps, "posix_path_operations ");
+		if (!caps) {
+			return 1;
+		}
+	}
+        if (caplow & CIFS_UNIX_LARGE_READ_CAP) {
+		caps = talloc_asprintf_append(caps, "large_read ");
+		if (!caps) {
+			return 1;
+		}
+	}
+        if (caplow & CIFS_UNIX_LARGE_WRITE_CAP) {
+		caps = talloc_asprintf_append(caps, "large_write ");
+		if (!caps) {
+			return 1;
+		}
+	}
+	if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP) {
+		caps = talloc_asprintf_append(caps, "posix_encrypt ");
+		if (!caps) {
+			return 1;
+		}
+	}
+	if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP) {
+		caps = talloc_asprintf_append(caps, "mandatory_posix_encrypt ");
+		if (!caps) {
+			return 1;
+		}
+	}
+
+	if (*caps && caps[strlen(caps)-1] == ' ') {
+		caps[strlen(caps)-1] = '\0';
+	}
+
+	d_printf("Server supports CIFS capabilities %s\n", caps);
+
+	if (!cli_set_unix_extensions_capabilities(cli, major, minor, caplow, caphigh)) {
+		d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n", cli_errstr(cli));
+		return 1;
+	}
+
+	if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
+		CLI_DIRSEP_CHAR = '/';
+		*CLI_DIRSEP_STR = '/';
+		client_set_cur_dir(CLI_DIRSEP_STR);
+	}
+
+	return 0;
+}
+
+static int cmd_lock(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
+	uint64_t start, len;
+	enum brl_type lock_type;
+	int fnum;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
+		return 1;
+	}
+	fnum = atoi(buf);
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
+		return 1;
+	}
+
+	if (*buf == 'r' || *buf == 'R') {
+		lock_type = READ_LOCK;
+	} else if (*buf == 'w' || *buf == 'W') {
+		lock_type = WRITE_LOCK;
+	} else {
+		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
+		return 1;
+	}
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
+		return 1;
+	}
+
+	start = (uint64_t)strtol(buf, (char **)NULL, 16);
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
+		return 1;
+	}
+
+	len = (uint64_t)strtol(buf, (char **)NULL, 16);
+
+	if (!cli_posix_lock(cli, fnum, start, len, true, lock_type)) {
+		d_printf("lock failed %d: %s\n", fnum, cli_errstr(cli));
+	}
+
+	return 0;
+}
+
+static int cmd_unlock(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf = NULL;
+	uint64_t start, len;
+	int fnum;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("unlock <fnum> <hex-start> <hex-len>\n");
+		return 1;
+	}
+	fnum = atoi(buf);
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("unlock <fnum> <hex-start> <hex-len>\n");
+		return 1;
+	}
+
+	start = (uint64_t)strtol(buf, (char **)NULL, 16);
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("unlock <fnum> <hex-start> <hex-len>\n");
+		return 1;
+	}
+
+	len = (uint64_t)strtol(buf, (char **)NULL, 16);
+
+	if (!cli_posix_unlock(cli, fnum, start, len)) {
+		d_printf("unlock failed %d: %s\n", fnum, cli_errstr(cli));
+	}
+
+	return 0;
+}
+
+
+/****************************************************************************
+ Remove a directory.
+****************************************************************************/
+
+static int cmd_rmdir(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *mask = NULL;
+	char *buf = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		d_printf("rmdir <dirname>\n");
+		return 1;
+	}
+	mask = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!mask) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
+		d_printf("rmdir %s: %s\n", mask, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_rmdir(targetcli, targetname)) {
+		d_printf("%s removing remote directory file %s\n",
+			 cli_errstr(targetcli),mask);
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ UNIX hardlink.
+****************************************************************************/
+
+static int cmd_link(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *oldname = NULL;
+	char *newname = NULL;
+	char *buf = NULL;
+	char *buf2 = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+		d_printf("link <oldname> <newname>\n");
+		return 1;
+	}
+	oldname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!oldname) {
+		return 1;
+	}
+	newname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!newname) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli, &targetname)) {
+		d_printf("link %s: %s\n", oldname, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	if (!cli_unix_hardlink(targetcli, targetname, newname)) {
+		d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli), newname, oldname);
+		return 1;
+	}
+	return 0;
+}
+
+/****************************************************************************
+ UNIX symlink.
+****************************************************************************/
+
+static int cmd_symlink(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *oldname = NULL;
+	char *newname = NULL;
+	char *buf = NULL;
+	char *buf2 = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+		d_printf("symlink <oldname> <newname>\n");
+		return 1;
+	}
+	oldname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!oldname) {
+		return 1;
+	}
+	newname = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!newname) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli, &targetname)) {
+		d_printf("link %s: %s\n", oldname, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	if (!cli_unix_symlink(targetcli, targetname, newname)) {
+		d_printf("%s symlinking files (%s -> %s)\n",
+			cli_errstr(targetcli), newname, targetname);
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ UNIX chmod.
+****************************************************************************/
+
+static int cmd_chmod(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	char *buf = NULL;
+	char *buf2 = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+	mode_t mode;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+		d_printf("chmod mode file\n");
+		return 1;
+	}
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!src) {
+		return 1;
+	}
+
+	mode = (mode_t)strtol(buf, NULL, 8);
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
+		d_printf("chmod %s: %s\n", src, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	if (!cli_unix_chmod(targetcli, targetname, mode)) {
+		d_printf("%s chmod file %s 0%o\n",
+			cli_errstr(targetcli), src, (unsigned int)mode);
+		return 1;
+	}
+
+	return 0;
+}
+
+static const char *filetype_to_str(mode_t mode)
+{
+	if (S_ISREG(mode)) {
+		return "regular file";
+	} else if (S_ISDIR(mode)) {
+		return "directory";
+	} else
+#ifdef S_ISCHR
+	if (S_ISCHR(mode)) {
+		return "character device";
+	} else
+#endif
+#ifdef S_ISBLK
+	if (S_ISBLK(mode)) {
+		return "block device";
+	} else
+#endif
+#ifdef S_ISFIFO
+	if (S_ISFIFO(mode)) {
+		return "fifo";
+	} else
+#endif
+#ifdef S_ISLNK
+	if (S_ISLNK(mode)) {
+		return "symbolic link";
+	} else
+#endif
+#ifdef S_ISSOCK
+	if (S_ISSOCK(mode)) {
+		return "socket";
+	} else
+#endif
+	return "";
+}
+
+static char rwx_to_str(mode_t m, mode_t bt, char ret)
+{
+	if (m & bt) {
+		return ret;
+	} else {
+		return '-';
+	}
+}
+
+static char *unix_mode_to_str(char *s, mode_t m)
+{
+	char *p = s;
+	const char *str = filetype_to_str(m);
+
+	switch(str[0]) {
+		case 'd':
+			*p++ = 'd';
+			break;
+		case 'c':
+			*p++ = 'c';
+			break;
+		case 'b':
+			*p++ = 'b';
+			break;
+		case 'f':
+			*p++ = 'p';
+			break;
+		case 's':
+			*p++ = str[1] == 'y' ? 'l' : 's';
+			break;
+		case 'r':
+		default:
+			*p++ = '-';
+			break;
+	}
+	*p++ = rwx_to_str(m, S_IRUSR, 'r');
+	*p++ = rwx_to_str(m, S_IWUSR, 'w');
+	*p++ = rwx_to_str(m, S_IXUSR, 'x');
+	*p++ = rwx_to_str(m, S_IRGRP, 'r');
+	*p++ = rwx_to_str(m, S_IWGRP, 'w');
+	*p++ = rwx_to_str(m, S_IXGRP, 'x');
+	*p++ = rwx_to_str(m, S_IROTH, 'r');
+	*p++ = rwx_to_str(m, S_IWOTH, 'w');
+	*p++ = rwx_to_str(m, S_IXOTH, 'x');
+	*p++ = '\0';
+	return s;
+}
+
+/****************************************************************************
+ Utility function for UNIX getfacl.
+****************************************************************************/
+
+static char *perms_to_string(fstring permstr, unsigned char perms)
+{
+	fstrcpy(permstr, "---");
+	if (perms & SMB_POSIX_ACL_READ) {
+		permstr[0] = 'r';
+	}
+	if (perms & SMB_POSIX_ACL_WRITE) {
+		permstr[1] = 'w';
+	}
+	if (perms & SMB_POSIX_ACL_EXECUTE) {
+		permstr[2] = 'x';
+	}
+	return permstr;
+}
+
+/****************************************************************************
+ UNIX getfacl.
+****************************************************************************/
+
+static int cmd_getfacl(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	char *name = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+	uint16 major, minor;
+	uint32 caplow, caphigh;
+	char *retbuf = NULL;
+	size_t rb_size = 0;
+	SMB_STRUCT_STAT sbuf;
+	uint16 num_file_acls = 0;
+	uint16 num_dir_acls = 0;
+	uint16 i;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
+		d_printf("getfacl filename\n");
+		return 1;
+	}
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			name);
+	if (!src) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
+		d_printf("stat %s: %s\n", src, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	if (!cli_unix_extensions_version(targetcli, &major, &minor,
+				&caplow, &caphigh)) {
+		d_printf("Can't get UNIX CIFS version from server.\n");
+		return 1;
+	}
+
+	if (!(caplow & CIFS_UNIX_POSIX_ACLS_CAP)) {
+		d_printf("This server supports UNIX extensions "
+			"but doesn't support POSIX ACLs.\n");
+		return 1;
+	}
+
+	if (!cli_unix_stat(targetcli, targetname, &sbuf)) {
+		d_printf("%s getfacl doing a stat on file %s\n",
+			cli_errstr(targetcli), src);
+		return 1;
+	}
+
+	if (!cli_unix_getfacl(targetcli, targetname, &rb_size, &retbuf)) {
+		d_printf("%s getfacl file %s\n",
+			cli_errstr(targetcli), src);
+		return 1;
+	}
+
+	/* ToDo : Print out the ACL values. */
+	if (SVAL(retbuf,0) != SMB_POSIX_ACL_VERSION || rb_size < 6) {
+		d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
+			src, (unsigned int)CVAL(retbuf,0) );
+		SAFE_FREE(retbuf);
+		return 1;
+	}
+
+	num_file_acls = SVAL(retbuf,2);
+	num_dir_acls = SVAL(retbuf,4);
+	if (rb_size != SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)) {
+		d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
+			src,
+			(unsigned int)(SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)),
+			(unsigned int)rb_size);
+
+		SAFE_FREE(retbuf);
+		return 1;
+	}
+
+	d_printf("# file: %s\n", src);
+	d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf.st_uid, (unsigned int)sbuf.st_gid);
+
+	if (num_file_acls == 0 && num_dir_acls == 0) {
+		d_printf("No acls found.\n");
+	}
+
+	for (i = 0; i < num_file_acls; i++) {
+		uint32 uorg;
+		fstring permstring;
+		unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE));
+		unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+1);
+
+		switch(tagtype) {
+			case SMB_POSIX_ACL_USER_OBJ:
+				d_printf("user::");
+				break;
+			case SMB_POSIX_ACL_USER:
+				uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
+				d_printf("user:%u:", uorg);
+				break;
+			case SMB_POSIX_ACL_GROUP_OBJ:
+				d_printf("group::");
+				break;
+			case SMB_POSIX_ACL_GROUP:
+				uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
+				d_printf("group:%u:", uorg);
+				break;
+			case SMB_POSIX_ACL_MASK:
+				d_printf("mask::");
+				break;
+			case SMB_POSIX_ACL_OTHER:
+				d_printf("other::");
+				break;
+			default:
+				d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
+					src, (unsigned int)tagtype );
+				SAFE_FREE(retbuf);
+				return 1;
+		}
+
+		d_printf("%s\n", perms_to_string(permstring, perms));
+	}
+
+	for (i = 0; i < num_dir_acls; i++) {
+		uint32 uorg;
+		fstring permstring;
+		unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE));
+		unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+1);
+
+		switch(tagtype) {
+			case SMB_POSIX_ACL_USER_OBJ:
+				d_printf("default:user::");
+				break;
+			case SMB_POSIX_ACL_USER:
+				uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
+				d_printf("default:user:%u:", uorg);
+				break;
+			case SMB_POSIX_ACL_GROUP_OBJ:
+				d_printf("default:group::");
+				break;
+			case SMB_POSIX_ACL_GROUP:
+				uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
+				d_printf("default:group:%u:", uorg);
+				break;
+			case SMB_POSIX_ACL_MASK:
+				d_printf("default:mask::");
+				break;
+			case SMB_POSIX_ACL_OTHER:
+				d_printf("default:other::");
+				break;
+			default:
+				d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
+					src, (unsigned int)tagtype );
+				SAFE_FREE(retbuf);
+				return 1;
+		}
+
+		d_printf("%s\n", perms_to_string(permstring, perms));
+	}
+
+	SAFE_FREE(retbuf);
+	return 0;
+}
+
+/****************************************************************************
+ UNIX stat.
+****************************************************************************/
+
+static int cmd_stat(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	char *name = NULL;
+	char *targetname = NULL;
+	struct cli_state *targetcli;
+	fstring mode_str;
+	SMB_STRUCT_STAT sbuf;
+	struct tm *lt;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
+		d_printf("stat file\n");
+		return 1;
+	}
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			name);
+	if (!src) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
+		d_printf("stat %s: %s\n", src, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	if (!cli_unix_stat(targetcli, targetname, &sbuf)) {
+		d_printf("%s stat file %s\n",
+			cli_errstr(targetcli), src);
+		return 1;
+	}
+
+	/* Print out the stat values. */
+	d_printf("File: %s\n", src);
+	d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
+		(double)sbuf.st_size,
+		(unsigned int)sbuf.st_blocks,
+		filetype_to_str(sbuf.st_mode));
+
+#if defined(S_ISCHR) && defined(S_ISBLK)
+	if (S_ISCHR(sbuf.st_mode) || S_ISBLK(sbuf.st_mode)) {
+		d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
+			(double)sbuf.st_ino,
+			(unsigned int)sbuf.st_nlink,
+			unix_dev_major(sbuf.st_rdev),
+			unix_dev_minor(sbuf.st_rdev));
+	} else
+#endif
+		d_printf("Inode: %.0f\tLinks: %u\n",
+			(double)sbuf.st_ino,
+			(unsigned int)sbuf.st_nlink);
+
+	d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
+		((int)sbuf.st_mode & 0777),
+		unix_mode_to_str(mode_str, sbuf.st_mode),
+		(unsigned int)sbuf.st_uid,
+		(unsigned int)sbuf.st_gid);
+
+	lt = localtime(&sbuf.st_atime);
+	if (lt) {
+		strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
+	} else {
+		fstrcpy(mode_str, "unknown");
+	}
+	d_printf("Access: %s\n", mode_str);
+
+	lt = localtime(&sbuf.st_mtime);
+	if (lt) {
+		strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
+	} else {
+		fstrcpy(mode_str, "unknown");
+	}
+	d_printf("Modify: %s\n", mode_str);
+
+	lt = localtime(&sbuf.st_ctime);
+	if (lt) {
+		strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
+	} else {
+		fstrcpy(mode_str, "unknown");
+	}
+	d_printf("Change: %s\n", mode_str);
+
+	return 0;
+}
+
+
+/****************************************************************************
+ UNIX chown.
+****************************************************************************/
+
+static int cmd_chown(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src = NULL;
+	uid_t uid;
+	gid_t gid;
+	char *buf, *buf2, *buf3;
+	struct cli_state *targetcli;
+	char *targetname = NULL;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf3,NULL)) {
+		d_printf("chown uid gid file\n");
+		return 1;
+	}
+
+	uid = (uid_t)atoi(buf);
+	gid = (gid_t)atoi(buf2);
+
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf3);
+	if (!src) {
+		return 1;
+	}
+	if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname) ) {
+		d_printf("chown %s: %s\n", src, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
+		d_printf("Server doesn't support UNIX CIFS calls.\n");
+		return 1;
+	}
+
+	if (!cli_unix_chown(targetcli, targetname, uid, gid)) {
+		d_printf("%s chown file %s uid=%d, gid=%d\n",
+			cli_errstr(targetcli), src, (int)uid, (int)gid);
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Rename some file.
+****************************************************************************/
+
+static int cmd_rename(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src, *dest;
+	char *buf, *buf2;
+	struct cli_state *targetcli;
+	char *targetsrc;
+	char *targetdest;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+		d_printf("rename <src> <dest>\n");
+		return 1;
+	}
+
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!src) {
+		return 1;
+	}
+
+	dest = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!dest) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetsrc)) {
+		d_printf("rename %s: %s\n", src, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli, &targetdest)) {
+		d_printf("rename %s: %s\n", dest, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_rename(targetcli, targetsrc, targetdest)) {
+		d_printf("%s renaming files %s -> %s \n",
+			cli_errstr(targetcli),
+			targetsrc,
+			targetdest);
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Print the volume name.
+****************************************************************************/
+
+static int cmd_volume(void)
+{
+	fstring volname;
+	uint32 serial_num;
+	time_t create_date;
+
+	if (!cli_get_fs_volume_info(cli, volname, &serial_num, &create_date)) {
+		d_printf("Errr %s getting volume info\n",cli_errstr(cli));
+		return 1;
+	}
+
+	d_printf("Volume: |%s| serial number 0x%x\n",
+			volname, (unsigned int)serial_num);
+	return 0;
+}
+
+/****************************************************************************
+ Hard link files using the NT call.
+****************************************************************************/
+
+static int cmd_hardlink(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *src, *dest;
+	char *buf, *buf2;
+	struct cli_state *targetcli;
+	char *targetname;
+
+	if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
+	    !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
+		d_printf("hardlink <src> <dest>\n");
+		return 1;
+	}
+
+	src = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf);
+	if (!src) {
+		return 1;
+	}
+
+	dest = talloc_asprintf(ctx,
+			"%s%s",
+			client_get_cur_dir(),
+			buf2);
+	if (!dest) {
+		return 1;
+	}
+
+	if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
+		d_printf("hardlink %s: %s\n", src, cli_errstr(cli));
+		return 1;
+	}
+
+	if (!cli_nt_hardlink(targetcli, targetname, dest)) {
+		d_printf("%s doing an NT hard link of files\n",cli_errstr(targetcli));
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Toggle the prompt flag.
+****************************************************************************/
+
+static int cmd_prompt(void)
+{
+	prompt = !prompt;
+	DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
+	return 1;
+}
+
+/****************************************************************************
+ Set the newer than time.
+****************************************************************************/
+
+static int cmd_newer(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
+	bool ok;
+	SMB_STRUCT_STAT sbuf;
+
+	ok = next_token_talloc(ctx, &cmd_ptr,&buf,NULL);
+	if (ok && (sys_stat(buf,&sbuf) == 0)) {
+		newer_than = sbuf.st_mtime;
+		DEBUG(1,("Getting files newer than %s",
+			 time_to_asc(newer_than)));
+	} else {
+		newer_than = 0;
+	}
+
+	if (ok && newer_than == 0) {
+		d_printf("Error setting newer-than time\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Set the archive level.
+****************************************************************************/
+
+static int cmd_archive(void)
+{
+	TALLOC_CTX *ctx = talloc_tos();
+	char *buf;
+
+	if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
+		archive_level = atoi(buf);
+	} else {
+		d_printf("Archive level is %d\n",archive_level);
+	}
+
+	return 0;
+}
+
+/****************************************************************************
+ Toggle the lowercaseflag.
+****************************************************************************/
+
+static int cmd_lowercase(void)
+{
+	lowercase = !lowercase;
+	DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
+	return 0;
+}
+
+/****************************************************************************
+ Toggle the case sensitive flag.
+****************************************************************************/
+
+static int cmd_setcase(void)
+{
+	bool orig_case_sensitive = cli_set_case_sensitive(cli, false);
+
+	cli_set_case_sensitive(cli, !orig_case_sensitive);
+	DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive ?
+		"on":"off"));