source3/client/client.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB client
   4    Copyright (C) Andrew Tridgell          1994-1998
   5    Copyright (C) Simo Sorce               2001-2002
   6    Copyright (C) Jelmer Vernooij          2003
   7    Copyright (C) Gerald (Jerry) Carter    2004
   8    Copyright (C) Jeremy Allison           1994-2007
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "system/filesys.h"
  26 #include "popt_common.h"
  27 #include "rpc_client/cli_pipe.h"
  28 #include "client/client_proto.h"
  29 #include "client/clitar_proto.h"
  30 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
  31 #include "../lib/util/select.h"
  32 #include "system/readline.h"
  33 #include "../libcli/smbreadline/smbreadline.h"
  34 #include "../libcli/security/security.h"
  35 #include "system/select.h"
  36 #include "libsmb/libsmb.h"
  37 #include "libsmb/clirap.h"
  38 #include "trans2.h"
  39 #include "libsmb/nmblib.h"
  40 #include "include/ntioctl.h"
  41 #include "../libcli/smb/smbXcli_base.h"
  42
  43 #ifndef REGISTER
  44 #define REGISTER 0
  45 #endif
  46
  47 extern int do_smb_browse(void); /* mDNS browsing */
  48
  49 extern bool override_logfile;
  50 extern char tar_type;
  51
  52 static int port = 0;
  53 static char *service;
  54 static char *desthost;
  55 static bool grepable = false;
  56 static char *cmdstr = NULL;
  57 const char *cmd_ptr = NULL;
  58
  59 static int io_bufsize = 0; /* we use the default size */
  60 static int io_timeout = (CLIENT_TIMEOUT/1000); /* Per operation timeout (in seconds). */
  61
  62 static int name_type = 0x20;
  63 static int max_protocol = -1;
  64
  65 static int process_tok(char *tok);
  66 static int cmd_help(void);
  67
  68 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
  69
  70 /* value for unused fid field in trans2 secondary request */
  71 #define FID_UNUSED (0xFFFF)
  72
  73 time_t newer_than = 0;
  74 static int archive_level = 0;
  75
  76 static bool translation = false;
  77 static bool have_ip;
  78
  79 /* clitar bits insert */
  80 extern int blocksize;
  81 extern bool tar_inc;
  82 extern bool tar_reset;
  83 /* clitar bits end */
  84
  85 static bool prompt = true;
  86
  87 static bool recurse = false;
  88 static bool showacls = false;
  89 bool lowercase = false;
  90 static bool backup_intent = false;
  91
  92 static struct sockaddr_storage dest_ss;
  93 static char dest_ss_str[INET6_ADDRSTRLEN];
  94
  95 #define SEPARATORS " \t\n\r"
  96
  97 static bool abort_mget = true;
  98
  99 /* timing globals */
 100 uint64_t get_total_size = 0;
 101 unsigned int get_total_time_ms = 0;
 102 static uint64_t put_total_size = 0;
 103 static unsigned int put_total_time_ms = 0;
 104
 105 /* totals globals */
 106 static double dir_total;
 107
 108 /* encrypted state. */
 109 static bool smb_encrypt;
 110
 111 /* root cli_state connection */
 112
 113 struct cli_state *cli;
 114
 115 static char CLI_DIRSEP_CHAR = '\\';
 116 static char CLI_DIRSEP_STR[] = { '\\', '\0' };
 117
 118 /* Authentication for client connections. */
 119 struct user_auth_info *auth_info;
 120
 121 /* Accessor functions for directory paths. */
 122 static char *fileselection;
 123 static const char *client_get_fileselection(void)
 124 {
 125         if (fileselection) {
 126                 return fileselection;
 127         }
 128         return "";
 129 }
 130
 131 static const char *client_set_fileselection(const char *new_fs)
 132 {
 133         SAFE_FREE(fileselection);
 134         if (new_fs) {
 135                 fileselection = SMB_STRDUP(new_fs);
 136         }
 137         return client_get_fileselection();
 138 }
 139
 140 static char *cwd;
 141 static const char *client_get_cwd(void)
 142 {
 143         if (cwd) {
 144                 return cwd;
 145         }
 146         return CLI_DIRSEP_STR;
 147 }
 148
 149 static const char *client_set_cwd(const char *new_cwd)
 150 {
 151         SAFE_FREE(cwd);
 152         if (new_cwd) {
 153                 cwd = SMB_STRDUP(new_cwd);
 154         }
 155         return client_get_cwd();
 156 }
 157
 158 static char *cur_dir;
 159 const char *client_get_cur_dir(void)
 160 {
 161         if (cur_dir) {
 162                 return cur_dir;
 163         }
 164         return CLI_DIRSEP_STR;
 165 }
 166
 167 const char *client_set_cur_dir(const char *newdir)
 168 {
 169         SAFE_FREE(cur_dir);
 170         if (newdir) {
 171                 cur_dir = SMB_STRDUP(newdir);
 172         }
 173         return client_get_cur_dir();
 174 }
 175
 176 /****************************************************************************
 177  Put up a yes/no prompt.
 178 ****************************************************************************/
 179
 180 static bool yesno(const char *p)
 181 {
 182         char ans[20];
 183         printf("%s",p);
 184
 185         if (!fgets(ans,sizeof(ans)-1,stdin))
 186                 return(False);
 187
 188         if (*ans == 'y' || *ans == 'Y')
 189                 return(True);
 190
 191         return(False);
 192 }
 193
 194 /****************************************************************************
 195  Write to a local file with CR/LF->LF translation if appropriate. Return the
 196  number taken from the buffer. This may not equal the number written.
 197 ****************************************************************************/
 198
 199 static int writefile(int f, char *b, int n)
 200 {
 201         int i;
 202
 203         if (!translation) {
 204                 return write(f,b,n);
 205         }
 206
 207         i = 0;
 208         while (i < n) {
 209                 if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
 210                         b++;i++;
 211                 }
 212                 if (write(f, b, 1) != 1) {
 213                         break;
 214                 }
 215                 b++;
 216                 i++;
 217         }
 218
 219         return(i);
 220 }
 221
 222 /****************************************************************************
 223  Read from a file with LF->CR/LF translation if appropriate. Return the
 224  number read. read approx n bytes.
 225 ****************************************************************************/
 226
 227 static int readfile(uint8_t *b, int n, XFILE *f)
 228 {
 229         int i;
 230         int c;
 231
 232         if (!translation)
 233                 return x_fread(b,1,n,f);
 234
 235         i = 0;
 236         while (i < (n - 1) && (i < BUFFER_SIZE)) {
 237                 if ((c = x_getc(f)) == EOF) {
 238                         break;
 239                 }
 240
 241                 if (c == '\n') { /* change all LFs to CR/LF */
 242                         b[i++] = '\r';
 243                 }
 244
 245                 b[i++] = c;
 246         }
 247
 248         return(i);
 249 }
 250
 251 struct push_state {
 252         XFILE *f;
 253         off_t nread;
 254 };
 255
 256 static size_t push_source(uint8_t *buf, size_t n, void *priv)
 257 {
 258         struct push_state *state = (struct push_state *)priv;
 259         int result;
 260
 261         if (x_feof(state->f)) {
 262                 return 0;
 263         }
 264
 265         result = readfile(buf, n, state->f);
 266         state->nread += result;
 267         return result;
 268 }
 269
 270 /****************************************************************************
 271  Send a message.
 272 ****************************************************************************/
 273
 274 static void send_message(const char *username)
 275 {
 276         char buf[1600];
 277         NTSTATUS status;
 278         int i;
 279
 280         d_printf("Type your message, ending it with a Control-D\n");
 281
 282         i = 0;
 283         while (i<sizeof(buf)-2) {
 284                 int c = fgetc(stdin);
 285                 if (c == EOF) {
 286                         break;
 287                 }
 288                 if (c == '\n') {
 289                         buf[i++] = '\r';
 290                 }
 291                 buf[i++] = c;
 292         }
 293         buf[i] = '\0';
 294
 295         status = cli_message(cli, desthost, username, buf);
 296         if (!NT_STATUS_IS_OK(status)) {
 297                 d_fprintf(stderr, "cli_message returned %s\n",
 298                           nt_errstr(status));
 299         }
 300 }
 301
 302 /****************************************************************************
 303  Check the space on a device.
 304 ****************************************************************************/
 305
 306 static int do_dskattr(void)
 307 {
 308         int total, bsize, avail;
 309         struct cli_state *targetcli = NULL;
 310         char *targetpath = NULL;
 311         TALLOC_CTX *ctx = talloc_tos();
 312         NTSTATUS status;
 313
 314         status = cli_resolve_path(ctx, "", auth_info, cli,
 315                                   client_get_cur_dir(), &targetcli,
 316                                   &targetpath);
 317         if (!NT_STATUS_IS_OK(status)) {
 318                 d_printf("Error in dskattr: %s\n", nt_errstr(status));
 319                 return 1;
 320         }
 321
 322         status = cli_dskattr(targetcli, &bsize, &total, &avail);
 323         if (!NT_STATUS_IS_OK(status)) {
 324                 d_printf("Error in dskattr: %s\n", nt_errstr(status));
 325                 return 1;
 326         }
 327
 328         d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
 329                  total, bsize, avail);
 330
 331         return 0;
 332 }
 333
 334 /****************************************************************************
 335  Show cd/pwd.
 336 ****************************************************************************/
 337
 338 static int cmd_pwd(void)
 339 {
 340         d_printf("Current directory is %s",service);
 341         d_printf("%s\n",client_get_cur_dir());
 342         return 0;
 343 }
 344
 345 /****************************************************************************
 346  Ensure name has correct directory separators.
 347 ****************************************************************************/
 348
 349 static void normalize_name(char *newdir)
 350 {
 351         if (!(cli->requested_posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP)) {
 352                 string_replace(newdir,'/','\\');
 353         }
 354 }
 355
 356 /****************************************************************************
 357  Change directory - inner section.
 358 ****************************************************************************/
 359
 360 static int do_cd(const char *new_dir)
 361 {
 362         char *newdir = NULL;
 363         char *saved_dir = NULL;
 364         char *new_cd = NULL;
 365         char *targetpath = NULL;
 366         struct cli_state *targetcli = NULL;
 367         SMB_STRUCT_STAT sbuf;
 368         uint32 attributes;
 369         int ret = 1;
 370         TALLOC_CTX *ctx = talloc_stackframe();
 371         NTSTATUS status;
 372
 373         newdir = talloc_strdup(ctx, new_dir);
 374         if (!newdir) {
 375                 TALLOC_FREE(ctx);
 376                 return 1;
 377         }
 378
 379         normalize_name(newdir);
 380
 381         /* Save the current directory in case the new directory is invalid */
 382
 383         saved_dir = talloc_strdup(ctx, client_get_cur_dir());
 384         if (!saved_dir) {
 385                 TALLOC_FREE(ctx);
 386                 return 1;
 387         }
 388
 389         if (*newdir == CLI_DIRSEP_CHAR) {
 390                 client_set_cur_dir(newdir);
 391                 new_cd = newdir;
 392         } else {
 393                 new_cd = talloc_asprintf(ctx, "%s%s",
 394                                 client_get_cur_dir(),
 395                                 newdir);
 396                 if (!new_cd) {
 397                         goto out;
 398                 }
 399         }
 400
 401         /* Ensure cur_dir ends in a DIRSEP */
 402         if ((new_cd[0] != '\0') && (*(new_cd+strlen(new_cd)-1) != CLI_DIRSEP_CHAR)) {
 403                 new_cd = talloc_asprintf_append(new_cd, "%s", CLI_DIRSEP_STR);
 404                 if (!new_cd) {
 405                         goto out;
 406                 }
 407         }
 408         client_set_cur_dir(new_cd);
 409
 410         new_cd = clean_name(ctx, new_cd);
 411         client_set_cur_dir(new_cd);
 412
 413         status = cli_resolve_path(ctx, "", auth_info, cli, new_cd,
 414                                   &targetcli, &targetpath);
 415         if (!NT_STATUS_IS_OK(status)) {
 416                 d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
 417                 client_set_cur_dir(saved_dir);
 418                 goto out;
 419         }
 420
 421         if (strequal(targetpath,CLI_DIRSEP_STR )) {
 422                 TALLOC_FREE(ctx);
 423                 return 0;
 424         }
 425
 426         /* Use a trans2_qpathinfo to test directories for modern servers.
 427            Except Win9x doesn't support the qpathinfo_basic() call..... */
 428
 429         if (smbXcli_conn_protocol(targetcli->conn) > PROTOCOL_LANMAN2 && !targetcli->win95) {
 430
 431                 status = cli_qpathinfo_basic(targetcli, targetpath, &sbuf,
 432                                              &attributes);
 433                 if (!NT_STATUS_IS_OK(status)) {
 434                         d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
 435                         client_set_cur_dir(saved_dir);
 436                         goto out;
 437                 }
 438
 439                 if (!(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
 440                         d_printf("cd %s: not a directory\n", new_cd);
 441                         client_set_cur_dir(saved_dir);
 442                         goto out;
 443                 }
 444         } else {
 445
 446                 targetpath = talloc_asprintf(ctx,
 447                                 "%s%s",
 448                                 targetpath,
 449                                 CLI_DIRSEP_STR );
 450                 if (!targetpath) {
 451                         client_set_cur_dir(saved_dir);
 452                         goto out;
 453                 }
 454                 targetpath = clean_name(ctx, targetpath);
 455                 if (!targetpath) {
 456                         client_set_cur_dir(saved_dir);
 457                         goto out;
 458                 }
 459
 460                 status = cli_chkpath(targetcli, targetpath);
 461                 if (!NT_STATUS_IS_OK(status)) {
 462                         d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
 463                         client_set_cur_dir(saved_dir);
 464                         goto out;
 465                 }
 466         }
 467
 468         ret = 0;
 469
 470 out:
 471
 472         TALLOC_FREE(ctx);
 473         return ret;
 474 }
 475
 476 /****************************************************************************
 477  Change directory.
 478 ****************************************************************************/
 479
 480 static int cmd_cd(void)
 481 {
 482         char *buf = NULL;
 483         int rc = 0;
 484
 485         if (next_token_talloc(talloc_tos(), &cmd_ptr, &buf,NULL)) {
 486                 rc = do_cd(buf);
 487         } else {
 488                 d_printf("Current directory is %s\n",client_get_cur_dir());
 489         }
 490
 491         return rc;
 492 }
 493
 494 /****************************************************************************
 495  Change directory.
 496 ****************************************************************************/
 497
 498 static int cmd_cd_oneup(void)
 499 {
 500         return do_cd("..");
 501 }
 502
 503 /*******************************************************************
 504  Decide if a file should be operated on.
 505 ********************************************************************/
 506
 507 static bool do_this_one(struct file_info *finfo)
 508 {
 509         if (!finfo->name) {
 510                 return false;
 511         }
 512
 513         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
 514                 return true;
 515         }
 516
 517         if (*client_get_fileselection() &&
 518             !mask_match(finfo->name,client_get_fileselection(),false)) {
 519                 DEBUG(3,("mask_match %s failed\n", finfo->name));
 520                 return false;
 521         }
 522
 523         if (newer_than && finfo->mtime_ts.tv_sec < newer_than) {
 524                 DEBUG(3,("newer_than %s failed\n", finfo->name));
 525                 return false;
 526         }
 527
 528         if ((archive_level==1 || archive_level==2) && !(finfo->mode & FILE_ATTRIBUTE_ARCHIVE)) {
 529                 DEBUG(3,("archive %s failed\n", finfo->name));
 530                 return false;
 531         }
 532
 533         return true;
 534 }
 535
 536 /****************************************************************************
 537  Display info about a file.
 538 ****************************************************************************/
 539
 540 static NTSTATUS display_finfo(struct cli_state *cli_state, struct file_info *finfo,
 541                           const char *dir)
 542 {
 543         time_t t;
 544         TALLOC_CTX *ctx = talloc_tos();
 545         NTSTATUS status = NT_STATUS_OK;
 546
 547         if (!do_this_one(finfo)) {
 548                 return NT_STATUS_OK;
 549         }
 550
 551         t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
 552         if (!showacls) {
 553                 d_printf("  %-30s%7.7s %8.0f  %s",
 554                          finfo->name,
 555                          attrib_string(talloc_tos(), finfo->mode),
 556                         (double)finfo->size,
 557                         time_to_asc(t));
 558                 dir_total += finfo->size;
 559         } else {
 560                 char *afname = NULL;
 561                 uint16_t fnum;
 562
 563                 /* skip if this is . or .. */
 564                 if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
 565                         return NT_STATUS_OK;
 566                 /* create absolute filename for cli_ntcreate() FIXME */
 567                 afname = talloc_asprintf(ctx,
 568                                         "%s%s%s",
 569                                         dir,
 570                                         CLI_DIRSEP_STR,
 571                                         finfo->name);
 572                 if (!afname) {
 573                         return NT_STATUS_NO_MEMORY;
 574                 }
 575                 /* print file meta date header */
 576                 d_printf( "FILENAME:%s\n", finfo->name);
 577                 d_printf( "MODE:%s\n", attrib_string(talloc_tos(), finfo->mode));
 578                 d_printf( "SIZE:%.0f\n", (double)finfo->size);
 579                 d_printf( "MTIME:%s", time_to_asc(t));
 580                 status = cli_ntcreate(cli_state, afname, 0,
 581                                       CREATE_ACCESS_READ, 0,
 582                                       FILE_SHARE_READ|FILE_SHARE_WRITE,
 583                                       FILE_OPEN, 0x0, 0x0, &fnum);
 584                 if (!NT_STATUS_IS_OK(status)) {
 585                         DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
 586                                    afname, nt_errstr(status)));
 587                 } else {
 588                         struct security_descriptor *sd = NULL;
 589                         status = cli_query_secdesc(cli_state, fnum,
 590                                                    ctx, &sd);
 591                         if (!NT_STATUS_IS_OK(status)) {
 592                                 DEBUG( 0, ("display_finfo() failed to "
 593                                            "get security descriptor: %s",
 594                                            nt_errstr(status)));
 595                         } else {
 596                                 display_sec_desc(sd);
 597                         }
 598                         TALLOC_FREE(sd);
 599                 }
 600                 TALLOC_FREE(afname);
 601         }
 602         return status;
 603 }
 604
 605 /****************************************************************************
 606  Accumulate size of a file.
 607 ****************************************************************************/
 608
 609 static NTSTATUS do_du(struct cli_state *cli_state, struct file_info *finfo,
 610                   const char *dir)
 611 {
 612         if (do_this_one(finfo)) {
 613                 dir_total += finfo->size;
 614         }
 615         return NT_STATUS_OK;
 616 }
 617
 618 static bool do_list_recurse;
 619 static bool do_list_dirs;
 620 static char *do_list_queue = 0;
 621 static long do_list_queue_size = 0;
 622 static long do_list_queue_start = 0;
 623 static long do_list_queue_end = 0;
 624 static NTSTATUS (*do_list_fn)(struct cli_state *cli_state, struct file_info *,
 625                           const char *dir);
 626
 627 /****************************************************************************
 628  Functions for do_list_queue.
 629 ****************************************************************************/
 630
 631 /*
 632  * The do_list_queue is a NUL-separated list of strings stored in a
 633  * char*.  Since this is a FIFO, we keep track of the beginning and
 634  * ending locations of the data in the queue.  When we overflow, we
 635  * double the size of the char*.  When the start of the data passes
 636  * the midpoint, we move everything back.  This is logically more
 637  * complex than a linked list, but easier from a memory management
 638  * angle.  In any memory error condition, do_list_queue is reset.
 639  * Functions check to ensure that do_list_queue is non-NULL before
 640  * accessing it.
 641  */
 642
 643 static void reset_do_list_queue(void)
 644 {
 645         SAFE_FREE(do_list_queue);
 646         do_list_queue_size = 0;
 647         do_list_queue_start = 0;
 648         do_list_queue_end = 0;
 649 }
 650
 651 static void init_do_list_queue(void)
 652 {
 653         reset_do_list_queue();
 654         do_list_queue_size = 1024;
 655         do_list_queue = (char *)SMB_MALLOC(do_list_queue_size);
 656         if (do_list_queue == 0) {
 657                 d_printf("malloc fail for size %d\n",
 658                          (int)do_list_queue_size);
 659                 reset_do_list_queue();
 660         } else {
 661                 memset(do_list_queue, 0, do_list_queue_size);
 662         }
 663 }
 664
 665 static void adjust_do_list_queue(void)
 666 {
 667         /*
 668          * If the starting point of the queue is more than half way through,
 669          * move everything toward the beginning.
 670          */
 671
 672         if (do_list_queue == NULL) {
 673                 DEBUG(4,("do_list_queue is empty\n"));
 674                 do_list_queue_start = do_list_queue_end = 0;
 675                 return;
 676         }
 677
 678         if (do_list_queue_start == do_list_queue_end) {
 679                 DEBUG(4,("do_list_queue is empty\n"));
 680                 do_list_queue_start = do_list_queue_end = 0;
 681                 *do_list_queue = '\0';
 682         } else if (do_list_queue_start > (do_list_queue_size / 2)) {
 683                 DEBUG(4,("sliding do_list_queue backward\n"));
 684                 memmove(do_list_queue,
 685                         do_list_queue + do_list_queue_start,
 686                         do_list_queue_end - do_list_queue_start);
 687                 do_list_queue_end -= do_list_queue_start;
 688                 do_list_queue_start = 0;
 689         }
 690 }
 691
 692 static void add_to_do_list_queue(const char *entry)
 693 {
 694         long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
 695         while (new_end > do_list_queue_size) {
 696                 do_list_queue_size *= 2;
 697                 DEBUG(4,("enlarging do_list_queue to %d\n",
 698                          (int)do_list_queue_size));
 699                 do_list_queue = (char *)SMB_REALLOC(do_list_queue, do_list_queue_size);
 700                 if (! do_list_queue) {
 701                         d_printf("failure enlarging do_list_queue to %d bytes\n",
 702                                  (int)do_list_queue_size);
 703                         reset_do_list_queue();
 704                 } else {
 705                         memset(do_list_queue + do_list_queue_size / 2,
 706                                0, do_list_queue_size / 2);
 707                 }
 708         }
 709         if (do_list_queue) {
 710                 strlcpy_base(do_list_queue + do_list_queue_end,
 711                                  entry, do_list_queue, do_list_queue_size);
 712                 do_list_queue_end = new_end;
 713                 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
 714                          entry, (int)do_list_queue_start, (int)do_list_queue_end));
 715         }
 716 }
 717
 718 static char *do_list_queue_head(void)
 719 {
 720         return do_list_queue + do_list_queue_start;
 721 }
 722
 723 static void remove_do_list_queue_head(void)
 724 {
 725         if (do_list_queue_end > do_list_queue_start) {
 726                 do_list_queue_start += strlen(do_list_queue_head()) + 1;
 727                 adjust_do_list_queue();
 728                 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
 729                          (int)do_list_queue_start, (int)do_list_queue_end));
 730         }
 731 }
 732
 733 static int do_list_queue_empty(void)
 734 {
 735         return (! (do_list_queue && *do_list_queue));
 736 }
 737
 738 /****************************************************************************
 739  A helper for do_list.
 740 ****************************************************************************/
 741
 742 static NTSTATUS do_list_helper(const char *mntpoint, struct file_info *f,
 743                            const char *mask, void *state)
 744 {
 745         struct cli_state *cli_state = (struct cli_state *)state;
 746         TALLOC_CTX *ctx = talloc_tos();
 747         char *dir = NULL;
 748         char *dir_end = NULL;
 749         NTSTATUS status = NT_STATUS_OK;
 750
 751         /* Work out the directory. */
 752         dir = talloc_strdup(ctx, mask);
 753         if (!dir) {
 754                 return NT_STATUS_NO_MEMORY;
 755         }
 756         if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
 757                 *dir_end = '\0';
 758         }
 759
 760         if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
 761                 if (do_list_dirs && do_this_one(f)) {
 762                         status = do_list_fn(cli_state, f, dir);
 763                         if (!NT_STATUS_IS_OK(status)) {
 764                                 return status;
 765                         }
 766                 }
 767                 if (do_list_recurse &&
 768                     f->name &&
 769                     !strequal(f->name,".") &&
 770                     !strequal(f->name,"..")) {
 771                         char *mask2 = NULL;
 772                         char *p = NULL;
 773
 774                         if (!f->name[0]) {
 775                                 d_printf("Empty dir name returned. Possible server misconfiguration.\n");
 776                                 TALLOC_FREE(dir);
 777                                 return NT_STATUS_UNSUCCESSFUL;
 778                         }
 779
 780                         mask2 = talloc_asprintf(ctx,
 781                                         "%s%s",
 782                                         mntpoint,
 783                                         mask);
 784                         if (!mask2) {
 785                                 TALLOC_FREE(dir);
 786                                 return NT_STATUS_NO_MEMORY;
 787                         }
 788                         p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
 789                         if (p) {
 790                                 p[1] = 0;
 791                         } else {
 792                                 mask2[0] = '\0';
 793                         }
 794                         mask2 = talloc_asprintf_append(mask2,
 795                                         "%s%s*",
 796                                         f->name,
 797                                         CLI_DIRSEP_STR);
 798                         if (!mask2) {
 799                                 TALLOC_FREE(dir);
 800                                 return NT_STATUS_NO_MEMORY;
 801                         }
 802                         add_to_do_list_queue(mask2);
 803                         TALLOC_FREE(mask2);
 804                 }
 805                 TALLOC_FREE(dir);
 806                 return NT_STATUS_OK;
 807         }
 808
 809         if (do_this_one(f)) {
 810                 status = do_list_fn(cli_state, f, dir);
 811         }
 812         TALLOC_FREE(dir);
 813         return status;
 814 }
 815
 816 /****************************************************************************
 817  A wrapper around cli_list that adds recursion.
 818 ****************************************************************************/
 819
 820 NTSTATUS do_list(const char *mask,
 821                         uint16 attribute,
 822                         NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
 823                                    const char *dir),
 824                         bool rec,
 825                         bool dirs)
 826 {
 827         static int in_do_list = 0;
 828         TALLOC_CTX *ctx = talloc_tos();
 829         struct cli_state *targetcli = NULL;
 830         char *targetpath = NULL;
 831         NTSTATUS ret_status = NT_STATUS_OK;
 832         NTSTATUS status = NT_STATUS_OK;
 833
 834         if (in_do_list && rec) {
 835                 fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
 836                 exit(1);
 837         }
 838
 839         in_do_list = 1;
 840
 841         do_list_recurse = rec;
 842         do_list_dirs = dirs;
 843         do_list_fn = fn;
 844
 845         if (rec) {
 846                 init_do_list_queue();
 847                 add_to_do_list_queue(mask);
 848
 849                 while (!do_list_queue_empty()) {
 850                         /*
 851                          * Need to copy head so that it doesn't become
 852                          * invalid inside the call to cli_list.  This
 853                          * would happen if the list were expanded
 854                          * during the call.
 855                          * Fix from E. Jay Berkenbilt (ejb@ql.org)
 856                          */
 857                         char *head = talloc_strdup(ctx, do_list_queue_head());
 858
 859                         if (!head) {
 860                                 return NT_STATUS_NO_MEMORY;
 861                         }
 862
 863                         /* check for dfs */
 864
 865                         status = cli_resolve_path(ctx, "", auth_info, cli,
 866                                                   head, &targetcli,
 867                                                   &targetpath);
 868                         if (!NT_STATUS_IS_OK(status)) {
 869                                 d_printf("do_list: [%s] %s\n", head,
 870                                          nt_errstr(status));
 871                                 remove_do_list_queue_head();
 872                                 continue;
 873                         }
 874
 875                         status = cli_list(targetcli, targetpath, attribute,
 876                                  do_list_helper, targetcli);
 877                         if (!NT_STATUS_IS_OK(status)) {
 878                                 d_printf("%s listing %s\n",
 879                                          nt_errstr(status), targetpath);
 880                                 ret_status = status;
 881                         }
 882                         remove_do_list_queue_head();
 883                         if ((! do_list_queue_empty()) && (fn == display_finfo)) {
 884                                 char *next_file = do_list_queue_head();
 885                                 char *save_ch = 0;
 886                                 if ((strlen(next_file) >= 2) &&
 887                                     (next_file[strlen(next_file) - 1] == '*') &&
 888                                     (next_file[strlen(next_file) - 2] == CLI_DIRSEP_CHAR)) {
 889                                         save_ch = next_file +
 890                                                 strlen(next_file) - 2;
 891                                         *save_ch = '\0';
 892                                         if (showacls) {
 893                                                 /* cwd is only used if showacls is on */
 894                                                 client_set_cwd(next_file);
 895                                         }
 896                                 }
 897                                 if (!showacls) /* don't disturbe the showacls output */
 898                                         d_printf("\n%s\n",next_file);
 899                                 if (save_ch) {
 900                                         *save_ch = CLI_DIRSEP_CHAR;
 901                                 }
 902                         }
 903                         TALLOC_FREE(head);
 904                         TALLOC_FREE(targetpath);
 905                 }
 906         } else {
 907                 /* check for dfs */
 908                 status = cli_resolve_path(ctx, "", auth_info, cli, mask,
 909                                           &targetcli, &targetpath);
 910                 if (NT_STATUS_IS_OK(status)) {
 911                         status = cli_list(targetcli, targetpath, attribute,
 912                                           do_list_helper, targetcli);
 913                         if (!NT_STATUS_IS_OK(status)) {
 914                                 d_printf("%s listing %s\n",
 915                                          nt_errstr(status), targetpath);
 916                                 ret_status = status;
 917                         }
 918                         TALLOC_FREE(targetpath);
 919                 } else {
 920                         d_printf("do_list: [%s] %s\n", mask, nt_errstr(status));
 921                         ret_status = status;
 922                 }
 923         }
 924
 925         in_do_list = 0;
 926         reset_do_list_queue();
 927         return ret_status;
 928 }
 929
 930 /****************************************************************************
 931  Get a directory listing.
 932 ****************************************************************************/
 933
 934 static int cmd_dir(void)
 935 {
 936         TALLOC_CTX *ctx = talloc_tos();
 937         uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 938         char *mask = NULL;
 939         char *buf = NULL;
 940         int rc = 1;
 941         NTSTATUS status;
 942
 943         dir_total = 0;
 944         mask = talloc_strdup(ctx, client_get_cur_dir());
 945         if (!mask) {
 946                 return 1;
 947         }
 948
 949         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
 950                 normalize_name(buf);
 951                 if (*buf == CLI_DIRSEP_CHAR) {
 952                         mask = talloc_strdup(ctx, buf);
 953                 } else {
 954                         mask = talloc_asprintf_append(mask, "%s", buf);
 955                 }
 956         } else {
 957                 mask = talloc_asprintf_append(mask, "*");
 958         }
 959         if (!mask) {
 960                 return 1;
 961         }
 962
 963         if (showacls) {
 964                 /* cwd is only used if showacls is on */
 965                 client_set_cwd(client_get_cur_dir());
 966         }
 967
 968         status = do_list(mask, attribute, display_finfo, recurse, true);
 969         if (!NT_STATUS_IS_OK(status)) {
 970                 return 1;
 971         }
 972
 973         rc = do_dskattr();
 974
 975         DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
 976
 977         return rc;
 978 }
 979
 980 /****************************************************************************
 981  Get a directory listing.
 982 ****************************************************************************/
 983
 984 static int cmd_du(void)
 985 {
 986         TALLOC_CTX *ctx = talloc_tos();
 987         uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 988         char *mask = NULL;
 989         char *buf = NULL;
 990         NTSTATUS status;
 991         int rc = 1;
 992
 993         dir_total = 0;
 994         mask = talloc_strdup(ctx, client_get_cur_dir());
 995         if (!mask) {
 996                 return 1;
 997         }
 998         if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR)) {
 999                 mask = talloc_asprintf_append(mask, "%s", CLI_DIRSEP_STR);
1000                 if (!mask) {
1001                         return 1;
1002                 }
1003         }
1004
1005         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1006                 normalize_name(buf);
1007                 if (*buf == CLI_DIRSEP_CHAR) {
1008                         mask = talloc_strdup(ctx, buf);
1009                 } else {
1010                         mask = talloc_asprintf_append(mask, "%s", buf);
1011                 }
1012         } else {
1013                 mask = talloc_strdup(ctx, "*");
1014         }
1015
1016         status = do_list(mask, attribute, do_du, recurse, true);
1017         if (!NT_STATUS_IS_OK(status)) {
1018                 return 1;
1019         }
1020
1021         rc = do_dskattr();
1022
1023         d_printf("Total number of bytes: %.0f\n", dir_total);
1024
1025         return rc;
1026 }
1027
1028 static int cmd_echo(void)
1029 {
1030         TALLOC_CTX *ctx = talloc_tos();
1031         char *num;
1032         char *data;
1033         NTSTATUS status;
1034
1035         if (!next_token_talloc(ctx, &cmd_ptr, &num, NULL)
1036             || !next_token_talloc(ctx, &cmd_ptr, &data, NULL)) {
1037                 d_printf("echo <num> <data>\n");
1038                 return 1;
1039         }
1040
1041         status = cli_echo(cli, atoi(num), data_blob_const(data, strlen(data)));
1042
1043         if (!NT_STATUS_IS_OK(status)) {
1044                 d_printf("echo failed: %s\n", nt_errstr(status));
1045                 return 1;
1046         }
1047
1048         return 0;
1049 }
1050
1051 /****************************************************************************
1052  Get a file from rname to lname
1053 ****************************************************************************/
1054
1055 static NTSTATUS writefile_sink(char *buf, size_t n, void *priv)
1056 {
1057         int *pfd = (int *)priv;
1058         if (writefile(*pfd, buf, n) == -1) {
1059                 return map_nt_error_from_unix(errno);
1060         }
1061         return NT_STATUS_OK;
1062 }
1063
1064 static int do_get(const char *rname, const char *lname_in, bool reget)
1065 {
1066         TALLOC_CTX *ctx = talloc_tos();
1067         int handle = 0;
1068         uint16_t fnum;
1069         bool newhandle = false;
1070         struct timespec tp_start;
1071         uint16 attr;
1072         off_t size;
1073         off_t start = 0;
1074         off_t nread = 0;
1075         int rc = 0;
1076         struct cli_state *targetcli = NULL;
1077         char *targetname = NULL;
1078         char *lname = NULL;
1079         NTSTATUS status;
1080
1081         lname = talloc_strdup(ctx, lname_in);
1082         if (!lname) {
1083                 return 1;
1084         }
1085
1086         if (lowercase) {
1087                 if (!strlower_m(lname)) {
1088                         d_printf("strlower_m %s failed\n", lname);
1089                         return 1;
1090                 }
1091         }
1092
1093         status = cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli,
1094                                   &targetname);
1095         if (!NT_STATUS_IS_OK(status)) {
1096                 d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
1097                 return 1;
1098         }
1099
1100         clock_gettime_mono(&tp_start);
1101
1102         status = cli_open(targetcli, targetname, O_RDONLY, DENY_NONE, &fnum);
1103         if (!NT_STATUS_IS_OK(status)) {
1104                 d_printf("%s opening remote file %s\n", nt_errstr(status),
1105                          rname);
1106                 return 1;
1107         }
1108
1109         if(!strcmp(lname,"-")) {
1110                 handle = fileno(stdout);
1111         } else {
1112                 if (reget) {
1113                         handle = open(lname, O_WRONLY|O_CREAT, 0644);
1114                         if (handle >= 0) {
1115                                 start = lseek(handle, 0, SEEK_END);
1116                                 if (start == -1) {
1117                                         d_printf("Error seeking local file\n");
1118                                         return 1;
1119                                 }
1120                         }
1121                 } else {
1122                         handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1123                 }
1124                 newhandle = true;
1125         }
1126         if (handle < 0) {
1127                 d_printf("Error opening local file %s\n",lname);
1128                 return 1;
1129         }
1130
1131
1132         status = cli_qfileinfo_basic(targetcli, fnum, &attr, &size, NULL, NULL,
1133                                      NULL, NULL, NULL);
1134         if (!NT_STATUS_IS_OK(status)) {
1135                 status = cli_getattrE(targetcli, fnum, &attr, &size, NULL, NULL,
1136                                       NULL);
1137                 if(!NT_STATUS_IS_OK(status)) {
1138                         d_printf("getattrib: %s\n", nt_errstr(status));
1139                         return 1;
1140                 }
1141         }
1142
1143         DEBUG(1,("getting file %s of size %.0f as %s ",
1144                  rname, (double)size, lname));
1145
1146         status = cli_pull(targetcli, fnum, start, size, io_bufsize,
1147                           writefile_sink, (void *)&handle, &nread);
1148         if (!NT_STATUS_IS_OK(status)) {
1149                 d_fprintf(stderr, "parallel_read returned %s\n",
1150                           nt_errstr(status));
1151                 cli_close(targetcli, fnum);
1152                 return 1;
1153         }
1154
1155         status = cli_close(targetcli, fnum);
1156         if (!NT_STATUS_IS_OK(status)) {
1157                 d_printf("Error %s closing remote file\n", nt_errstr(status));
1158                 rc = 1;
1159         }
1160
1161         if (newhandle) {
1162                 close(handle);
1163         }
1164
1165         if (archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
1166                 cli_setatr(cli, rname, attr & ~(uint16)FILE_ATTRIBUTE_ARCHIVE, 0);
1167         }
1168
1169         {
1170                 struct timespec tp_end;
1171                 int this_time;
1172
1173                 clock_gettime_mono(&tp_end);
1174                 this_time = nsec_time_diff(&tp_end,&tp_start)/1000000;
1175                 get_total_time_ms += this_time;
1176                 get_total_size += nread;
1177
1178                 DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
1179                          nread / (1.024*this_time + 1.0e-4),
1180                          get_total_size / (1.024*get_total_time_ms)));
1181         }
1182
1183         TALLOC_FREE(targetname);
1184         return rc;
1185 }
1186
1187 /****************************************************************************
1188  Get a file.
1189 ****************************************************************************/
1190
1191 static int cmd_get(void)
1192 {
1193         TALLOC_CTX *ctx = talloc_tos();
1194         char *lname = NULL;
1195         char *rname = NULL;
1196         char *fname = NULL;
1197
1198         rname = talloc_strdup(ctx, client_get_cur_dir());
1199         if (!rname) {
1200                 return 1;
1201         }
1202
1203         if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
1204                 d_printf("get <filename> [localname]\n");
1205                 return 1;
1206         }
1207         rname = talloc_asprintf_append(rname, "%s", fname);
1208         if (!rname) {
1209                 return 1;
1210         }
1211         rname = clean_name(ctx, rname);
1212         if (!rname) {
1213                 return 1;
1214         }
1215
1216         next_token_talloc(ctx, &cmd_ptr,&lname,NULL);
1217         if (!lname) {
1218                 lname = fname;
1219         }
1220
1221         return do_get(rname, lname, false);
1222 }
1223
1224 /****************************************************************************
1225  Do an mget operation on one file.
1226 ****************************************************************************/
1227
1228 static NTSTATUS do_mget(struct cli_state *cli_state, struct file_info *finfo,
1229                     const char *dir)
1230 {
1231         TALLOC_CTX *ctx = talloc_tos();
1232         NTSTATUS status = NT_STATUS_OK;
1233         char *rname = NULL;
1234         char *quest = NULL;
1235         char *saved_curdir = NULL;
1236         char *mget_mask = NULL;
1237         char *new_cd = NULL;
1238
1239         if (!finfo->name) {
1240                 return NT_STATUS_OK;
1241         }
1242
1243         if (strequal(finfo->name,".") || strequal(finfo->name,".."))
1244                 return NT_STATUS_OK;
1245
1246         if (abort_mget) {
1247                 d_printf("mget aborted\n");
1248                 return NT_STATUS_UNSUCCESSFUL;
1249         }
1250
1251         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
1252                 if (asprintf(&quest,
1253                          "Get directory %s? ",finfo->name) < 0) {
1254                         return NT_STATUS_NO_MEMORY;
1255                 }
1256         } else {
1257                 if (asprintf(&quest,
1258                          "Get file %s? ",finfo->name) < 0) {
1259                         return NT_STATUS_NO_MEMORY;
1260                 }
1261         }
1262
1263         if (prompt && !yesno(quest)) {
1264                 SAFE_FREE(quest);
1265                 return NT_STATUS_OK;
1266         }
1267         SAFE_FREE(quest);
1268
1269         if (!(finfo->mode & FILE_ATTRIBUTE_DIRECTORY)) {
1270                 rname = talloc_asprintf(ctx,
1271                                 "%s%s",
1272                                 client_get_cur_dir(),
1273                                 finfo->name);
1274                 if (!rname) {
1275                         return NT_STATUS_NO_MEMORY;
1276                 }
1277                 do_get(rname, finfo->name, false);
1278                 TALLOC_FREE(rname);
1279                 return NT_STATUS_OK;
1280         }
1281
1282         /* handle directories */
1283         saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
1284         if (!saved_curdir) {
1285                 return NT_STATUS_NO_MEMORY;
1286         }
1287
1288         new_cd = talloc_asprintf(ctx,
1289                                 "%s%s%s",
1290                                 client_get_cur_dir(),
1291                                 finfo->name,
1292                                 CLI_DIRSEP_STR);
1293         if (!new_cd) {
1294                 return NT_STATUS_NO_MEMORY;
1295         }
1296         client_set_cur_dir(new_cd);
1297
1298         string_replace(finfo->name,'\\','/');
1299         if (lowercase) {
1300                 if (!strlower_m(finfo->name)) {
1301                         return NT_STATUS_INVALID_PARAMETER;
1302                 }
1303         }
1304
1305         if (!directory_exist(finfo->name) &&
1306             mkdir(finfo->name,0777) != 0) {
1307                 d_printf("failed to create directory %s\n",finfo->name);
1308                 client_set_cur_dir(saved_curdir);
1309                 return map_nt_error_from_unix(errno);
1310         }
1311
1312         if (chdir(finfo->name) != 0) {
1313                 d_printf("failed to chdir to directory %s\n",finfo->name);
1314                 client_set_cur_dir(saved_curdir);
1315                 return map_nt_error_from_unix(errno);
1316         }
1317
1318         mget_mask = talloc_asprintf(ctx,
1319                         "%s*",
1320                         client_get_cur_dir());
1321
1322         if (!mget_mask) {
1323                 return NT_STATUS_NO_MEMORY;
1324         }
1325
1326         status = do_list(mget_mask,
1327                          (FILE_ATTRIBUTE_SYSTEM
1328                           | FILE_ATTRIBUTE_HIDDEN
1329                           | FILE_ATTRIBUTE_DIRECTORY),
1330                          do_mget, false, true);
1331         if (!NT_STATUS_IS_OK(status)
1332          && !NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1333                 /*
1334                  * Ignore access denied errors to ensure all permitted files are
1335                  * pulled down.
1336                  */
1337                 return status;
1338         }
1339
1340         if (chdir("..") == -1) {
1341                 d_printf("do_mget: failed to chdir to .. (error %s)\n",
1342                         strerror(errno) );
1343                 return map_nt_error_from_unix(errno);
1344         }
1345         client_set_cur_dir(saved_curdir);
1346         TALLOC_FREE(mget_mask);
1347         TALLOC_FREE(saved_curdir);
1348         TALLOC_FREE(new_cd);
1349         return NT_STATUS_OK;
1350 }
1351
1352 /****************************************************************************
1353  View the file using the pager.
1354 ****************************************************************************/
1355
1356 static int cmd_more(void)
1357 {
1358         TALLOC_CTX *ctx = talloc_tos();
1359         char *rname = NULL;
1360         char *fname = NULL;
1361         char *lname = NULL;
1362         char *pager_cmd = NULL;
1363         const char *pager;
1364         int fd;
1365         int rc = 0;
1366         mode_t mask;
1367
1368         rname = talloc_strdup(ctx, client_get_cur_dir());
1369         if (!rname) {
1370                 return 1;
1371         }
1372
1373         lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
1374         if (!lname) {
1375                 return 1;
1376         }
1377         mask = umask(S_IRWXO | S_IRWXG);
1378         fd = mkstemp(lname);
1379         umask(mask);
1380         if (fd == -1) {
1381                 d_printf("failed to create temporary file for more\n");
1382                 return 1;
1383         }
1384         close(fd);
1385
1386         if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
1387                 d_printf("more <filename>\n");
1388                 unlink(lname);
1389                 return 1;
1390         }
1391         rname = talloc_asprintf_append(rname, "%s", fname);
1392         if (!rname) {
1393                 return 1;
1394         }
1395         rname = clean_name(ctx,rname);
1396         if (!rname) {
1397                 return 1;
1398         }
1399
1400         rc = do_get(rname, lname, false);
1401
1402         pager=getenv("PAGER");
1403
1404         pager_cmd = talloc_asprintf(ctx,
1405                                 "%s %s",
1406                                 (pager? pager:PAGER),
1407                                 lname);
1408         if (!pager_cmd) {
1409                 return 1;
1410         }
1411         if (system(pager_cmd) == -1) {
1412                 d_printf("system command '%s' returned -1\n",
1413                         pager_cmd);
1414         }
1415         unlink(lname);
1416
1417         return rc;
1418 }
1419
1420 /****************************************************************************
1421  Do a mget command.
1422 ****************************************************************************/
1423
1424 static int cmd_mget(void)
1425 {
1426         TALLOC_CTX *ctx = talloc_tos();
1427         uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
1428         char *mget_mask = NULL;
1429         char *buf = NULL;
1430         NTSTATUS status = NT_STATUS_OK;
1431
1432         if (recurse) {
1433                 attribute |= FILE_ATTRIBUTE_DIRECTORY;
1434         }
1435
1436         abort_mget = false;
1437
1438         while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1439
1440                 mget_mask = talloc_strdup(ctx, client_get_cur_dir());
1441                 if (!mget_mask) {
1442                         return 1;
1443                 }
1444                 if (*buf == CLI_DIRSEP_CHAR) {
1445                         mget_mask = talloc_strdup(ctx, buf);
1446                 } else {
1447                         mget_mask = talloc_asprintf_append(mget_mask,
1448                                                         "%s", buf);
1449                 }
1450                 if (!mget_mask) {
1451                         return 1;
1452                 }
1453                 status = do_list(mget_mask, attribute, do_mget, false, true);
1454                 if (!NT_STATUS_IS_OK(status)) {
1455                         return 1;
1456                 }
1457         }
1458
1459         if (mget_mask == NULL) {
1460                 d_printf("nothing to mget\n");
1461                 return 0;
1462         }
1463
1464         if (!*mget_mask) {
1465                 mget_mask = talloc_asprintf(ctx,
1466                                         "%s*",
1467                                         client_get_cur_dir());
1468                 if (!mget_mask) {
1469                         return 1;
1470                 }
1471                 status = do_list(mget_mask, attribute, do_mget, false, true);
1472                 if (!NT_STATUS_IS_OK(status)) {
1473                         return 1;
1474                 }
1475         }
1476
1477         return 0;
1478 }
1479
1480 /****************************************************************************
1481  Make a directory of name "name".
1482 ****************************************************************************/
1483
1484 static bool do_mkdir(const char *name)
1485 {
1486         TALLOC_CTX *ctx = talloc_tos();
1487         struct cli_state *targetcli;
1488         char *targetname = NULL;
1489         NTSTATUS status;
1490
1491         status = cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli,
1492                                   &targetname);
1493         if (!NT_STATUS_IS_OK(status)) {
1494                 d_printf("mkdir %s: %s\n", name, nt_errstr(status));
1495                 return false;
1496         }
1497
1498         status = cli_mkdir(targetcli, targetname);
1499         if (!NT_STATUS_IS_OK(status)) {
1500                 d_printf("%s making remote directory %s\n",
1501                          nt_errstr(status),name);
1502                 return false;
1503         }
1504
1505         return true;
1506 }
1507
1508 /****************************************************************************
1509  Show 8.3 name of a file.
1510 ****************************************************************************/
1511
1512 static bool do_altname(const char *name)
1513 {
1514         fstring altname;
1515         NTSTATUS status;
1516
1517         status = cli_qpathinfo_alt_name(cli, name, altname);
1518         if (!NT_STATUS_IS_OK(status)) {
1519                 d_printf("%s getting alt name for %s\n",
1520                          nt_errstr(status),name);
1521                 return false;
1522         }
1523         d_printf("%s\n", altname);
1524
1525         return true;
1526 }
1527
1528 /****************************************************************************
1529  Exit client.
1530 ****************************************************************************/
1531
1532 static int cmd_quit(void)
1533 {
1534         cli_shutdown(cli);
1535         exit(0);
1536         /* NOTREACHED */
1537         return 0;
1538 }
1539
1540 /****************************************************************************
1541  Make a directory.
1542 ****************************************************************************/
1543
1544 static int cmd_mkdir(void)
1545 {
1546         TALLOC_CTX *ctx = talloc_tos();
1547         char *mask = NULL;
1548         char *buf = NULL;
1549         NTSTATUS status;
1550
1551         mask = talloc_strdup(ctx, client_get_cur_dir());
1552         if (!mask) {
1553                 return 1;
1554         }
1555
1556         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1557                 if (!recurse) {
1558                         d_printf("mkdir <dirname>\n");
1559                 }
1560                 return 1;
1561         }
1562         mask = talloc_asprintf_append(mask, "%s", buf);
1563         if (!mask) {
1564                 return 1;
1565         }
1566
1567         if (recurse) {
1568                 char *ddir = NULL;
1569                 char *ddir2 = NULL;
1570                 struct cli_state *targetcli;
1571                 char *targetname = NULL;
1572                 char *p = NULL;
1573                 char *saveptr;
1574
1575                 ddir2 = talloc_strdup(ctx, "");
1576                 if (!ddir2) {
1577                         return 1;
1578                 }
1579
1580                 status = cli_resolve_path(ctx, "", auth_info, cli, mask,
1581                                           &targetcli, &targetname);
1582                 if (!NT_STATUS_IS_OK(status)) {
1583                         return 1;
1584                 }
1585
1586                 ddir = talloc_strdup(ctx, targetname);
1587                 if (!ddir) {
1588                         return 1;
1589                 }
1590                 trim_char(ddir,'.','\0');
1591                 p = strtok_r(ddir, "/\\", &saveptr);
1592                 while (p) {
1593                         ddir2 = talloc_asprintf_append(ddir2, "%s", p);
1594                         if (!ddir2) {
1595                                 return 1;
1596                         }
1597                         if (!NT_STATUS_IS_OK(cli_chkpath(targetcli, ddir2))) {
1598                                 do_mkdir(ddir2);
1599                         }
1600                         ddir2 = talloc_asprintf_append(ddir2, "%s", CLI_DIRSEP_STR);
1601                         if (!ddir2) {
1602                                 return 1;
1603                         }
1604                         p = strtok_r(NULL, "/\\", &saveptr);
1605                 }
1606         } else {
1607                 do_mkdir(mask);
1608         }
1609
1610         return 0;
1611 }
1612
1613 /****************************************************************************
1614  Show alt name.
1615 ****************************************************************************/
1616
1617 static int cmd_altname(void)
1618 {
1619         TALLOC_CTX *ctx = talloc_tos();
1620         char *name;
1621         char *buf;
1622
1623         name = talloc_strdup(ctx, client_get_cur_dir());
1624         if (!name) {
1625                 return 1;
1626         }
1627
1628         if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
1629                 d_printf("altname <file>\n");
1630                 return 1;
1631         }
1632         name = talloc_asprintf_append(name, "%s", buf);
1633         if (!name) {
1634                 return 1;
1635         }
1636         do_altname(name);
1637         return 0;
1638 }
1639
1640 static char *attr_str(TALLOC_CTX *mem_ctx, uint16_t mode)
1641 {
1642         char *attrs = talloc_zero_array(mem_ctx, char, 17);
1643         int i = 0;
1644
1645         if (!(mode & FILE_ATTRIBUTE_NORMAL)) {
1646                 if (mode & FILE_ATTRIBUTE_ENCRYPTED) {
1647                         attrs[i++] = 'E';
1648                 }
1649                 if (mode & FILE_ATTRIBUTE_NONINDEXED) {
1650                         attrs[i++] = 'N';
1651                 }
1652                 if (mode & FILE_ATTRIBUTE_OFFLINE) {
1653                         attrs[i++] = 'O';
1654                 }
1655                 if (mode & FILE_ATTRIBUTE_COMPRESSED) {
1656                         attrs[i++] = 'C';
1657                 }
1658                 if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
1659                         attrs[i++] = 'r';
1660                 }
1661                 if (mode & FILE_ATTRIBUTE_SPARSE) {
1662                         attrs[i++] = 's';
1663                 }
1664                 if (mode & FILE_ATTRIBUTE_TEMPORARY) {
1665                         attrs[i++] = 'T';
1666                 }
1667                 if (mode & FILE_ATTRIBUTE_NORMAL) {
1668                         attrs[i++] = 'N';
1669                 }
1670                 if (mode & FILE_ATTRIBUTE_READONLY) {
1671                         attrs[i++] = 'R';
1672                 }
1673                 if (mode & FILE_ATTRIBUTE_HIDDEN) {
1674                         attrs[i++] = 'H';
1675                 }
1676                 if (mode & FILE_ATTRIBUTE_SYSTEM) {
1677                         attrs[i++] = 'S';
1678                 }
1679                 if (mode & FILE_ATTRIBUTE_DIRECTORY) {
1680                         attrs[i++] = 'D';
1681                 }
1682                 if (mode & FILE_ATTRIBUTE_ARCHIVE) {
1683                         attrs[i++] = 'A';
1684                 }
1685         }
1686         return attrs;
1687 }
1688
1689 /****************************************************************************
1690  Show all info we can get
1691 ****************************************************************************/
1692
1693 static int do_allinfo(const char *name)
1694 {
1695         fstring altname;
1696         struct timespec b_time, a_time, m_time, c_time;
1697         off_t size;
1698         uint16_t mode;
1699         NTTIME tmp;
1700         uint16_t fnum;
1701         unsigned int num_streams;
1702         struct stream_struct *streams;
1703         int num_snapshots;
1704         char **snapshots;
1705         unsigned int i;
1706         NTSTATUS status;
1707
1708         status = cli_qpathinfo_alt_name(cli, name, altname);
1709         if (!NT_STATUS_IS_OK(status)) {
1710                 d_printf("%s getting alt name for %s\n", nt_errstr(status),
1711                          name);
1712                 /*
1713                  * Ignore not supported or not implemented, it does not
1714                  * hurt if we can't list alternate names.
1715                  */
1716                 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED) ||
1717                     NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
1718                         altname[0] = '\0';
1719                 } else {
1720                         return false;
1721                 }
1722         }
1723         d_printf("altname: %s\n", altname);
1724
1725         status = cli_qpathinfo3(cli, name, &b_time, &a_time, &m_time, &c_time,
1726                                 &size, &mode, NULL);
1727         if (!NT_STATUS_IS_OK(status)) {
1728                 d_printf("%s getting pathinfo for %s\n", nt_errstr(status),
1729                          name);
1730                 return false;
1731         }
1732
1733         unix_timespec_to_nt_time(&tmp, b_time);
1734         d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1735
1736         unix_timespec_to_nt_time(&tmp, a_time);
1737         d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1738
1739         unix_timespec_to_nt_time(&tmp, m_time);
1740         d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
1741
1742         unix_timespec_to_nt_time(&tmp, c_time);
1743         d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1744
1745         d_printf("attributes: %s (%x)\n", attr_str(talloc_tos(), mode), mode);
1746
1747         status = cli_qpathinfo_streams(cli, name, talloc_tos(), &num_streams,
1748                                        &streams);
1749         if (!NT_STATUS_IS_OK(status)) {
1750                 d_printf("%s getting streams for %s\n", nt_errstr(status),
1751                          name);
1752                 return false;
1753         }
1754
1755         for (i=0; i<num_streams; i++) {
1756                 d_printf("stream: [%s], %lld bytes\n", streams[i].name,
1757                          (unsigned long long)streams[i].size);
1758         }
1759
1760         if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
1761                 char *subst, *print;
1762                 uint32_t flags;
1763
1764                 status = cli_readlink(cli, name, talloc_tos(), &subst, &print,
1765                                       &flags);
1766                 if (!NT_STATUS_IS_OK(status)) {
1767                         d_fprintf(stderr, "cli_readlink returned %s\n",
1768                                   nt_errstr(status));
1769                 } else {
1770                         d_printf("symlink: subst=[%s], print=[%s], flags=%x\n",
1771                                  subst, print, flags);
1772                         TALLOC_FREE(subst);
1773                         TALLOC_FREE(print);
1774                 }
1775         }
1776
1777         status = cli_ntcreate(cli, name, 0,
1778                               SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE |
1779                               SEC_STD_SYNCHRONIZE, 0,
1780                               FILE_SHARE_READ|FILE_SHARE_WRITE
1781                               |FILE_SHARE_DELETE,
1782                               FILE_OPEN, 0x0, 0x0, &fnum);
1783         if (!NT_STATUS_IS_OK(status)) {
1784                 /*
1785                  * Ignore failure, it does not hurt if we can't list
1786                  * snapshots
1787                  */
1788                 return 0;
1789         }
1790         status = cli_shadow_copy_data(talloc_tos(), cli, fnum,
1791                                       true, &snapshots, &num_snapshots);
1792         if (!NT_STATUS_IS_OK(status)) {
1793                 cli_close(cli, fnum);
1794                 return 0;
1795         }
1796
1797         for (i=0; i<num_snapshots; i++) {
1798                 char *snap_name;
1799
1800                 d_printf("%s\n", snapshots[i]);
1801                 snap_name = talloc_asprintf(talloc_tos(), "%s%s",
1802                                             snapshots[i], name);
1803                 status = cli_qpathinfo3(cli, snap_name, &b_time, &a_time,
1804                                         &m_time, &c_time, &size,
1805                                         NULL, NULL);
1806                 if (!NT_STATUS_IS_OK(status)) {
1807                         d_fprintf(stderr, "pathinfo(%s) failed: %s\n",
1808                                   snap_name, nt_errstr(status));
1809                         TALLOC_FREE(snap_name);
1810                         continue;
1811                 }
1812                 unix_timespec_to_nt_time(&tmp, b_time);
1813                 d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1814                 unix_timespec_to_nt_time(&tmp, a_time);
1815                 d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1816                 unix_timespec_to_nt_time(&tmp, m_time);
1817                 d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
1818                 unix_timespec_to_nt_time(&tmp, c_time);
1819                 d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1820                 d_printf("size: %d\n", (int)size);
1821         }
1822
1823         TALLOC_FREE(snapshots);
1824
1825         return 0;
1826 }
1827
1828 /****************************************************************************
1829  Show all info we can get
1830 ****************************************************************************/
1831
1832 static int cmd_allinfo(void)
1833 {
1834         TALLOC_CTX *ctx = talloc_tos();
1835         char *name;
1836         char *buf;
1837
1838         name = talloc_strdup(ctx, client_get_cur_dir());
1839         if (!name) {
1840                 return 1;
1841         }
1842
1843         if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
1844                 d_printf("allinfo <file>\n");
1845                 return 1;
1846         }
1847         name = talloc_asprintf_append(name, "%s", buf);
1848         if (!name) {
1849                 return 1;
1850         }
1851
1852         do_allinfo(name);
1853
1854         return 0;
1855 }
1856
1857 /****************************************************************************
1858  Put a single file.
1859 ****************************************************************************/
1860
1861 static int do_put(const char *rname, const char *lname, bool reput)
1862 {
1863         TALLOC_CTX *ctx = talloc_tos();
1864         uint16_t fnum;
1865         XFILE *f;
1866         off_t start = 0;
1867         int rc = 0;
1868         struct timespec tp_start;
1869         struct cli_state *targetcli;
1870         char *targetname = NULL;
1871         struct push_state state;
1872         NTSTATUS status;
1873
1874         status = cli_resolve_path(ctx, "", auth_info, cli, rname,
1875                                   &targetcli, &targetname);
1876         if (!NT_STATUS_IS_OK(status)) {
1877                 d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
1878                 return 1;
1879         }
1880
1881         clock_gettime_mono(&tp_start);
1882
1883         if (reput) {
1884                 status = cli_open(targetcli, targetname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
1885                 if (NT_STATUS_IS_OK(status)) {
1886                         if (!NT_STATUS_IS_OK(status = cli_qfileinfo_basic(
1887                                                      targetcli, fnum, NULL,
1888                                                      &start, NULL, NULL,
1889                                                      NULL, NULL, NULL)) &&
1890                             !NT_STATUS_IS_OK(status = cli_getattrE(
1891                                                      targetcli, fnum, NULL,
1892                                                      &start, NULL, NULL,
1893                                                      NULL))) {
1894                                 d_printf("getattrib: %s\n", nt_errstr(status));
1895                                 return 1;
1896                         }
1897                 }
1898         } else {
1899                 status = cli_open(targetcli, targetname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnum);
1900         }
1901
1902         if (!NT_STATUS_IS_OK(status)) {
1903                 d_printf("%s opening remote file %s\n", nt_errstr(status),
1904                          rname);
1905                 return 1;
1906         }
1907
1908         /* allow files to be piped into smbclient
1909            jdblair 24.jun.98
1910
1911            Note that in this case this function will exit(0) rather
1912            than returning. */
1913         if (!strcmp(lname, "-")) {
1914                 f = x_stdin;
1915                 /* size of file is not known */
1916         } else {
1917                 f = x_fopen(lname,O_RDONLY, 0);
1918                 if (f && reput) {
1919                         if (x_tseek(f, start, SEEK_SET) == -1) {
1920                                 d_printf("Error seeking local file\n");
1921                                 x_fclose(f);
1922                                 return 1;
1923                         }
1924                 }
1925         }
1926
1927         if (!f) {
1928                 d_printf("Error opening local file %s\n",lname);
1929                 return 1;
1930         }
1931
1932         DEBUG(1,("putting file %s as %s ",lname,
1933                  rname));
1934
1935         x_setvbuf(f, NULL, X_IOFBF, io_bufsize);
1936
1937         state.f = f;
1938         state.nread = 0;
1939
1940         status = cli_push(targetcli, fnum, 0, 0, io_bufsize, push_source,
1941                           &state);
1942         if (!NT_STATUS_IS_OK(status)) {
1943                 d_fprintf(stderr, "cli_push returned %s\n", nt_errstr(status));
1944                 rc = 1;
1945         }
1946
1947         status = cli_close(targetcli, fnum);
1948         if (!NT_STATUS_IS_OK(status)) {
1949                 d_printf("%s closing remote file %s\n", nt_errstr(status),
1950                          rname);
1951                 if (f != x_stdin) {
1952                         x_fclose(f);
1953                 }
1954                 return 1;
1955         }
1956
1957         if (f != x_stdin) {
1958                 x_fclose(f);
1959         }
1960
1961         {
1962                 struct timespec tp_end;
1963                 int this_time;
1964
1965                 clock_gettime_mono(&tp_end);
1966                 this_time = nsec_time_diff(&tp_end,&tp_start)/1000000;
1967                 put_total_time_ms += this_time;
1968                 put_total_size += state.nread;
1969
1970                 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1971                          state.nread / (1.024*this_time + 1.0e-4),
1972                          put_total_size / (1.024*put_total_time_ms)));
1973         }
1974
1975         if (f == x_stdin) {
1976                 cli_shutdown(cli);
1977                 exit(rc);
1978         }
1979
1980         return rc;
1981 }
1982
1983 /****************************************************************************
1984  Put a file.
1985 ****************************************************************************/
1986
1987 static int cmd_put(void)
1988 {
1989         TALLOC_CTX *ctx = talloc_tos();
1990         char *lname;
1991         char *rname;
1992         char *buf;
1993
1994         rname = talloc_strdup(ctx, client_get_cur_dir());
1995         if (!rname) {
1996                 return 1;
1997         }
1998
1999         if (!next_token_talloc(ctx, &cmd_ptr,&lname,NULL)) {
2000                 d_printf("put <filename>\n");
2001                 return 1;
2002         }
2003
2004         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2005                 rname = talloc_asprintf_append(rname, "%s", buf);
2006         } else {
2007                 rname = talloc_asprintf_append(rname, "%s", lname);
2008         }
2009         if (!rname) {
2010                 return 1;
2011         }
2012
2013         rname = clean_name(ctx, rname);
2014         if (!rname) {
2015                 return 1;
2016         }
2017
2018         {
2019                 SMB_STRUCT_STAT st;
2020                 /* allow '-' to represent stdin
2021                    jdblair, 24.jun.98 */
2022                 if (!file_exist_stat(lname, &st, false) &&
2023                     (strcmp(lname,"-"))) {
2024                         d_printf("%s does not exist\n",lname);
2025                         return 1;
2026                 }
2027         }
2028
2029         return do_put(rname, lname, false);
2030 }
2031
2032 /*************************************
2033  File list structure.
2034 *************************************/
2035
2036 static struct file_list {
2037         struct file_list *prev, *next;
2038         char *file_path;
2039         bool isdir;
2040 } *file_list;
2041
2042 /****************************************************************************
2043  Free a file_list structure.
2044 ****************************************************************************/
2045
2046 static void free_file_list (struct file_list *l_head)
2047 {
2048         struct file_list *list, *next;
2049
2050         for (list = l_head; list; list = next) {
2051                 next = list->next;
2052                 DLIST_REMOVE(l_head, list);
2053                 SAFE_FREE(list->file_path);
2054                 SAFE_FREE(list);
2055         }
2056 }
2057
2058 /****************************************************************************
2059  Seek in a directory/file list until you get something that doesn't start with
2060  the specified name.
2061 ****************************************************************************/
2062
2063 static bool seek_list(struct file_list *list, char *name)
2064 {
2065         while (list) {
2066                 trim_string(list->file_path,"./","\n");
2067                 if (strncmp(list->file_path, name, strlen(name)) != 0) {
2068                         return true;
2069                 }
2070                 list = list->next;
2071         }
2072
2073         return false;
2074 }
2075
2076 /****************************************************************************
2077  Set the file selection mask.
2078 ****************************************************************************/
2079
2080 static int cmd_select(void)
2081 {
2082         TALLOC_CTX *ctx = talloc_tos();
2083         char *new_fs = NULL;
2084         next_token_talloc(ctx, &cmd_ptr,&new_fs,NULL)
2085                 ;
2086         if (new_fs) {
2087                 client_set_fileselection(new_fs);
2088         } else {
2089                 client_set_fileselection("");
2090         }
2091         return 0;
2092 }
2093
2094 /****************************************************************************
2095   Recursive file matching function act as find
2096   match must be always set to true when calling this function
2097 ****************************************************************************/
2098
2099 static int file_find(struct file_list **list, const char *directory,
2100                       const char *expression, bool match)
2101 {
2102         DIR *dir;
2103         struct file_list *entry;
2104         struct stat statbuf;
2105         int ret;
2106         char *path;
2107         bool isdir;
2108         const char *dname;
2109
2110         dir = opendir(directory);
2111         if (!dir)
2112                 return -1;
2113
2114         while ((dname = readdirname(dir))) {
2115                 if (!strcmp("..", dname))
2116                         continue;
2117                 if (!strcmp(".", dname))
2118                         continue;
2119
2120                 if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
2121                         continue;
2122                 }
2123
2124                 isdir = false;
2125                 if (!match || !gen_fnmatch(expression, dname)) {
2126                         if (recurse) {
2127                                 ret = stat(path, &statbuf);
2128                                 if (ret == 0) {
2129                                         if (S_ISDIR(statbuf.st_mode)) {
2130                                                 isdir = true;
2131                                                 ret = file_find(list, path, expression, false);
2132                                         }
2133                                 } else {
2134                                         d_printf("file_find: cannot stat file %s\n", path);
2135                                 }
2136
2137                                 if (ret == -1) {
2138                                         SAFE_FREE(path);
2139                                         closedir(dir);
2140                                         return -1;
2141                                 }
2142                         }
2143                         entry = SMB_MALLOC_P(struct file_list);
2144                         if (!entry) {
2145                                 d_printf("Out of memory in file_find\n");
2146                                 closedir(dir);
2147                                 return -1;
2148                         }
2149                         entry->file_path = path;
2150                         entry->isdir = isdir;
2151                         DLIST_ADD(*list, entry);
2152                 } else {
2153                         SAFE_FREE(path);
2154                 }
2155         }
2156
2157         closedir(dir);
2158         return 0;
2159 }
2160
2161 /****************************************************************************
2162  mput some files.
2163 ****************************************************************************/
2164
2165 static int cmd_mput(void)
2166 {
2167         TALLOC_CTX *ctx = talloc_tos();
2168         char *p = NULL;
2169
2170         while (next_token_talloc(ctx, &cmd_ptr,&p,NULL)) {
2171                 int ret;
2172                 struct file_list *temp_list;
2173                 char *quest, *lname, *rname;
2174
2175                 file_list = NULL;
2176
2177                 ret = file_find(&file_list, ".", p, true);
2178                 if (ret) {
2179                         free_file_list(file_list);
2180                         continue;
2181                 }
2182
2183                 quest = NULL;
2184                 lname = NULL;
2185                 rname = NULL;
2186
2187                 for (temp_list = file_list; temp_list;
2188                      temp_list = temp_list->next) {
2189
2190                         SAFE_FREE(lname);
2191                         if (asprintf(&lname, "%s/", temp_list->file_path) <= 0) {
2192                                 continue;
2193                         }
2194                         trim_string(lname, "./", "/");
2195
2196                         /* check if it's a directory */
2197                         if (temp_list->isdir) {
2198                                 /* if (!recurse) continue; */
2199
2200                                 SAFE_FREE(quest);
2201                                 if (asprintf(&quest, "Put directory %s? ", lname) < 0) {
2202                                         break;
2203                                 }
2204                                 if (prompt && !yesno(quest)) { /* No */
2205                                         /* Skip the directory */
2206                                         lname[strlen(lname)-1] = '/';
2207                                         if (!seek_list(temp_list, lname))
2208                                                 break;
2209                                 } else { /* Yes */
2210                                         SAFE_FREE(rname);
2211                                         if(asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
2212                                                 break;
2213                                         }
2214                                         normalize_name(rname);
2215                                         if (!NT_STATUS_IS_OK(cli_chkpath(cli, rname)) &&
2216                                             !do_mkdir(rname)) {
2217                                                 DEBUG (0, ("Unable to make dir, skipping..."));
2218                                                 /* Skip the directory */
2219                                                 lname[strlen(lname)-1] = '/';
2220                                                 if (!seek_list(temp_list, lname)) {
2221                                                         break;
2222                                                 }
2223                                         }
2224                                 }
2225                                 continue;
2226                         } else {
2227                                 SAFE_FREE(quest);
2228                                 if (asprintf(&quest,"Put file %s? ", lname) < 0) {
2229                                         break;
2230                                 }
2231                                 if (prompt && !yesno(quest)) {
2232                                         /* No */
2233                                         continue;
2234                                 }
2235
2236                                 /* Yes */
2237                                 SAFE_FREE(rname);
2238                                 if (asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
2239                                         break;
2240                                 }
2241                         }
2242
2243                         normalize_name(rname);
2244
2245                         do_put(rname, lname, false);
2246                 }
2247                 free_file_list(file_list);
2248                 SAFE_FREE(quest);
2249                 SAFE_FREE(lname);
2250                 SAFE_FREE(rname);
2251         }
2252
2253         return 0;
2254 }
2255
2256 /****************************************************************************
2257  Cancel a print job.
2258 ****************************************************************************/
2259
2260 static int do_cancel(int job)
2261 {
2262         if (cli_printjob_del(cli, job)) {
2263                 d_printf("Job %d cancelled\n",job);
2264                 return 0;
2265         } else {
2266                 NTSTATUS status = cli_nt_error(cli);
2267                 d_printf("Error cancelling job %d : %s\n",
2268                          job, nt_errstr(status));
2269                 return 1;
2270         }
2271 }
2272
2273 /****************************************************************************
2274  Cancel a print job.
2275 ****************************************************************************/
2276
2277 static int cmd_cancel(void)
2278 {
2279         TALLOC_CTX *ctx = talloc_tos();
2280         char *buf = NULL;
2281         int job;
2282
2283         if (!next_token_talloc(ctx, &cmd_ptr, &buf,NULL)) {
2284                 d_printf("cancel <jobid> ...\n");
2285                 return 1;
2286         }
2287         do {
2288                 job = atoi(buf);
2289                 do_cancel(job);
2290         } while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL));
2291
2292         return 0;
2293 }
2294
2295 /****************************************************************************
2296  Print a file.
2297 ****************************************************************************/
2298
2299 static int cmd_print(void)
2300 {
2301         TALLOC_CTX *ctx = talloc_tos();
2302         char *lname = NULL;
2303         char *rname = NULL;
2304         char *p = NULL;
2305
2306         if (!next_token_talloc(ctx, &cmd_ptr, &lname,NULL)) {
2307                 d_printf("print <filename>\n");
2308                 return 1;
2309         }
2310
2311         rname = talloc_strdup(ctx, lname);
2312         if (!rname) {
2313                 return 1;
2314         }
2315         p = strrchr_m(rname,'/');
2316         if (p) {
2317                 rname = talloc_asprintf(ctx,
2318                                         "%s-%d",
2319                                         p+1,
2320                                         (int)getpid());
2321         }
2322         if (strequal(lname,"-")) {
2323                 rname = talloc_asprintf(ctx,
2324                                 "stdin-%d",
2325                                 (int)getpid());
2326         }
2327         if (!rname) {
2328                 return 1;
2329         }
2330
2331         return do_put(rname, lname, false);
2332 }
2333
2334 /****************************************************************************
2335  Show a print queue entry.
2336 ****************************************************************************/
2337
2338 static void queue_fn(struct print_job_info *p)
2339 {
2340         d_printf("%-6d   %-9d    %s\n", (int)p->id, (int)p->size, p->name);
2341 }
2342
2343 /****************************************************************************
2344  Show a print queue.
2345 ****************************************************************************/
2346
2347 static int cmd_queue(void)
2348 {
2349         cli_print_queue(cli, queue_fn);
2350         return 0;
2351 }
2352
2353 /****************************************************************************
2354  Delete some files.
2355 ****************************************************************************/
2356
2357 static NTSTATUS do_del(struct cli_state *cli_state, struct file_info *finfo,
2358                    const char *dir)
2359 {
2360         TALLOC_CTX *ctx = talloc_tos();
2361         char *mask = NULL;
2362         NTSTATUS status;
2363
2364         mask = talloc_asprintf(ctx,
2365                                 "%s%c%s",
2366                                 dir,
2367                                 CLI_DIRSEP_CHAR,
2368                                 finfo->name);
2369         if (!mask) {
2370                 return NT_STATUS_NO_MEMORY;
2371         }
2372
2373         if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
2374                 TALLOC_FREE(mask);
2375                 return NT_STATUS_OK;
2376         }
2377
2378         status = cli_unlink(cli_state, mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2379         if (!NT_STATUS_IS_OK(status)) {
2380                 d_printf("%s deleting remote file %s\n",
2381                          nt_errstr(status), mask);
2382         }
2383         TALLOC_FREE(mask);
2384         return status;
2385 }
2386
2387 /****************************************************************************
2388  Delete some files.
2389 ****************************************************************************/
2390
2391 static int cmd_del(void)
2392 {
2393         TALLOC_CTX *ctx = talloc_tos();
2394         char *mask = NULL;
2395         char *buf = NULL;
2396         NTSTATUS status = NT_STATUS_OK;
2397         uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
2398
2399         if (recurse) {
2400                 attribute |= FILE_ATTRIBUTE_DIRECTORY;
2401         }
2402
2403         mask = talloc_strdup(ctx, client_get_cur_dir());
2404         if (!mask) {
2405                 return 1;
2406         }
2407         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2408                 d_printf("del <filename>\n");
2409                 return 1;
2410         }
2411         mask = talloc_asprintf_append(mask, "%s", buf);
2412         if (!mask) {
2413                 return 1;
2414         }
2415
2416         status = do_list(mask,attribute,do_del,false,false);
2417         if (!NT_STATUS_IS_OK(status)) {
2418                 return 1;
2419         }
2420         return 0;
2421 }
2422
2423 /****************************************************************************
2424  Wildcard delete some files.
2425 ****************************************************************************/
2426
2427 static int cmd_wdel(void)
2428 {
2429         TALLOC_CTX *ctx = talloc_tos();
2430         char *mask = NULL;
2431         char *buf = NULL;
2432         uint16 attribute;
2433         struct cli_state *targetcli;
2434         char *targetname = NULL;
2435         NTSTATUS status;
2436
2437         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2438                 d_printf("wdel 0x<attrib> <wcard>\n");
2439                 return 1;
2440         }
2441
2442         attribute = (uint16)strtol(buf, (char **)NULL, 16);
2443
2444         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2445                 d_printf("wdel 0x<attrib> <wcard>\n");
2446                 return 1;
2447         }
2448
2449         mask = talloc_asprintf(ctx, "%s%s",
2450                         client_get_cur_dir(),
2451                         buf);
2452         if (!mask) {
2453                 return 1;
2454         }
2455
2456         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2457                                   &targetname);
2458         if (!NT_STATUS_IS_OK(status)) {
2459                 d_printf("cmd_wdel %s: %s\n", mask, nt_errstr(status));
2460                 return 1;
2461         }
2462
2463         status = cli_unlink(targetcli, targetname, attribute);
2464         if (!NT_STATUS_IS_OK(status)) {
2465                 d_printf("%s deleting remote files %s\n", nt_errstr(status),
2466                          targetname);
2467         }
2468         return 0;
2469 }
2470
2471 /****************************************************************************
2472 ****************************************************************************/
2473
2474 static int cmd_open(void)
2475 {
2476         TALLOC_CTX *ctx = talloc_tos();
2477         char *mask = NULL;
2478         char *buf = NULL;
2479         char *targetname = NULL;
2480         struct cli_state *targetcli;
2481         uint16_t fnum = (uint16_t)-1;
2482         NTSTATUS status;
2483
2484         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2485                 d_printf("open <filename>\n");
2486                 return 1;
2487         }
2488         mask = talloc_asprintf(ctx,
2489                         "%s%s",
2490                         client_get_cur_dir(),
2491                         buf);
2492         if (!mask) {
2493                 return 1;
2494         }
2495
2496         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2497                                   &targetname);
2498         if (!NT_STATUS_IS_OK(status)) {
2499                 d_printf("open %s: %s\n", mask, nt_errstr(status));
2500                 return 1;
2501         }
2502
2503         status = cli_ntcreate(targetcli, targetname, 0,
2504                         FILE_READ_DATA|FILE_WRITE_DATA, 0,
2505                         FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
2506                         0x0, 0x0, &fnum);
2507         if (!NT_STATUS_IS_OK(status)) {
2508                 status = cli_ntcreate(targetcli, targetname, 0,
2509                                 FILE_READ_DATA, 0,
2510                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
2511                                 0x0, 0x0, &fnum);
2512                 if (NT_STATUS_IS_OK(status)) {
2513                         d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
2514                 } else {
2515                         d_printf("Failed to open file %s. %s\n",
2516                                  targetname, nt_errstr(status));
2517                 }
2518         } else {
2519                 d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
2520         }
2521         return 0;
2522 }
2523
2524 static int cmd_posix_encrypt(void)
2525 {
2526         TALLOC_CTX *ctx = talloc_tos();
2527         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2528
2529         if (cli->use_kerberos) {
2530                 status = cli_gss_smb_encryption_start(cli);
2531         } else {
2532                 char *domain = NULL;
2533                 char *user = NULL;
2534                 char *password = NULL;
2535
2536                 if (!next_token_talloc(ctx, &cmd_ptr,&domain,NULL)) {
2537                         d_printf("posix_encrypt domain user password\n");
2538                         return 1;
2539                 }
2540
2541                 if (!next_token_talloc(ctx, &cmd_ptr,&user,NULL)) {
2542                         d_printf("posix_encrypt domain user password\n");
2543                         return 1;
2544                 }
2545
2546                 if (!next_token_talloc(ctx, &cmd_ptr,&password,NULL)) {
2547                         d_printf("posix_encrypt domain user password\n");
2548                         return 1;
2549                 }
2550
2551                 status = cli_raw_ntlm_smb_encryption_start(cli,
2552                                                         user,
2553                                                         password,
2554                                                         domain);
2555         }
2556
2557         if (!NT_STATUS_IS_OK(status)) {
2558                 d_printf("posix_encrypt failed with error %s\n", nt_errstr(status));
2559         } else {
2560                 d_printf("encryption on\n");
2561                 smb_encrypt = true;
2562         }
2563
2564         return 0;
2565 }
2566
2567 /****************************************************************************
2568 ****************************************************************************/
2569
2570 static int cmd_posix_open(void)
2571 {
2572         TALLOC_CTX *ctx = talloc_tos();
2573         char *mask = NULL;
2574         char *buf = NULL;
2575         char *targetname = NULL;
2576         struct cli_state *targetcli;
2577         mode_t mode;
2578         uint16_t fnum;
2579         NTSTATUS status;
2580
2581         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2582                 d_printf("posix_open <filename> 0<mode>\n");
2583                 return 1;
2584         }
2585         mask = talloc_asprintf(ctx,
2586                         "%s%s",
2587                         client_get_cur_dir(),
2588                         buf);
2589         if (!mask) {
2590                 return 1;
2591         }
2592
2593         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2594                 d_printf("posix_open <filename> 0<mode>\n");
2595                 return 1;
2596         }
2597         mode = (mode_t)strtol(buf, (char **)NULL, 8);
2598
2599         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2600                                   &targetname);
2601         if (!NT_STATUS_IS_OK(status)) {
2602                 d_printf("posix_open %s: %s\n", mask, nt_errstr(status));
2603                 return 1;
2604         }
2605
2606         status = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode,
2607                                 &fnum);
2608         if (!NT_STATUS_IS_OK(status)) {
2609                 status = cli_posix_open(targetcli, targetname,
2610                                         O_CREAT|O_RDONLY, mode, &fnum);
2611                 if (!NT_STATUS_IS_OK(status)) {
2612                         d_printf("Failed to open file %s. %s\n", targetname,
2613                                  nt_errstr(status));
2614                 } else {
2615                         d_printf("posix_open file %s: for readonly fnum %d\n",
2616                                  targetname, fnum);
2617                 }
2618         } else {
2619                 d_printf("posix_open file %s: for read/write fnum %d\n",
2620                          targetname, fnum);
2621         }
2622
2623         return 0;
2624 }
2625
2626 static int cmd_posix_mkdir(void)
2627 {
2628         TALLOC_CTX *ctx = talloc_tos();
2629         char *mask = NULL;
2630         char *buf = NULL;
2631         char *targetname = NULL;
2632         struct cli_state *targetcli;
2633         mode_t mode;
2634         NTSTATUS status;
2635
2636         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2637                 d_printf("posix_mkdir <filename> 0<mode>\n");
2638                 return 1;
2639         }
2640         mask = talloc_asprintf(ctx,
2641                         "%s%s",
2642                         client_get_cur_dir(),
2643                         buf);
2644         if (!mask) {
2645                 return 1;
2646         }
2647
2648         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2649                 d_printf("posix_mkdir <filename> 0<mode>\n");
2650                 return 1;
2651         }
2652         mode = (mode_t)strtol(buf, (char **)NULL, 8);
2653
2654         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2655                                   &targetname);
2656         if (!NT_STATUS_IS_OK(status)) {
2657                 d_printf("posix_mkdir %s: %s\n", mask, nt_errstr(status));
2658                 return 1;
2659         }
2660
2661         status = cli_posix_mkdir(targetcli, targetname, mode);
2662         if (!NT_STATUS_IS_OK(status)) {
2663                 d_printf("Failed to open file %s. %s\n",
2664                          targetname, nt_errstr(status));
2665         } else {
2666                 d_printf("posix_mkdir created directory %s\n", targetname);
2667         }
2668         return 0;
2669 }
2670
2671 static int cmd_posix_unlink(void)
2672 {
2673         TALLOC_CTX *ctx = talloc_tos();
2674         char *mask = NULL;
2675         char *buf = NULL;
2676         char *targetname = NULL;
2677         struct cli_state *targetcli;
2678         NTSTATUS status;
2679
2680         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2681                 d_printf("posix_unlink <filename>\n");
2682                 return 1;
2683         }
2684         mask = talloc_asprintf(ctx,
2685                         "%s%s",
2686                         client_get_cur_dir(),
2687                         buf);
2688         if (!mask) {
2689                 return 1;
2690         }
2691
2692         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2693                                   &targetname);
2694         if (!NT_STATUS_IS_OK(status)) {
2695                 d_printf("posix_unlink %s: %s\n", mask, nt_errstr(status));
2696                 return 1;
2697         }
2698
2699         status = cli_posix_unlink(targetcli, targetname);
2700         if (!NT_STATUS_IS_OK(status)) {
2701                 d_printf("Failed to unlink file %s. %s\n",
2702                          targetname, nt_errstr(status));
2703         } else {
2704                 d_printf("posix_unlink deleted file %s\n", targetname);
2705         }
2706
2707         return 0;
2708 }
2709
2710 static int cmd_posix_rmdir(void)
2711 {
2712         TALLOC_CTX *ctx = talloc_tos();
2713         char *mask = NULL;
2714         char *buf = NULL;
2715         char *targetname = NULL;
2716         struct cli_state *targetcli;
2717         NTSTATUS status;
2718
2719         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2720                 d_printf("posix_rmdir <filename>\n");
2721                 return 1;
2722         }
2723         mask = talloc_asprintf(ctx,
2724                         "%s%s",
2725                         client_get_cur_dir(),
2726                         buf);
2727         if (!mask) {
2728                 return 1;
2729         }
2730
2731         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2732                                   &targetname);
2733         if (!NT_STATUS_IS_OK(status)) {
2734                 d_printf("posix_rmdir %s: %s\n", mask, nt_errstr(status));
2735                 return 1;
2736         }
2737
2738         status = cli_posix_rmdir(targetcli, targetname);
2739         if (!NT_STATUS_IS_OK(status)) {
2740                 d_printf("Failed to unlink directory %s. %s\n",
2741                          targetname, nt_errstr(status));
2742         } else {
2743                 d_printf("posix_rmdir deleted directory %s\n", targetname);
2744         }
2745
2746         return 0;
2747 }
2748
2749 static int cmd_close(void)
2750 {
2751         TALLOC_CTX *ctx = talloc_tos();
2752         char *buf = NULL;
2753         int fnum;
2754         NTSTATUS status;
2755
2756         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2757                 d_printf("close <fnum>\n");
2758                 return 1;
2759         }
2760
2761         fnum = atoi(buf);
2762         /* We really should use the targetcli here.... */
2763         status = cli_close(cli, fnum);
2764         if (!NT_STATUS_IS_OK(status)) {
2765                 d_printf("close %d: %s\n", fnum, nt_errstr(status));
2766                 return 1;
2767         }
2768         return 0;
2769 }
2770
2771 static int cmd_posix(void)
2772 {
2773         TALLOC_CTX *ctx = talloc_tos();
2774         uint16 major, minor;
2775         uint32 caplow, caphigh;
2776         char *caps;
2777         NTSTATUS status;
2778
2779         if (!SERVER_HAS_UNIX_CIFS(cli)) {
2780                 d_printf("Server doesn't support UNIX CIFS extensions.\n");
2781                 return 1;
2782         }
2783
2784         status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
2785                                              &caphigh);
2786         if (!NT_STATUS_IS_OK(status)) {
2787                 d_printf("Can't get UNIX CIFS extensions version from "
2788                          "server: %s\n", nt_errstr(status));
2789                 return 1;
2790         }
2791
2792         d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major, (unsigned int)minor);
2793
2794         caps = talloc_strdup(ctx, "");
2795         if (!caps) {
2796                 return 1;
2797         }
2798         if (caplow & CIFS_UNIX_FCNTL_LOCKS_CAP) {
2799                 caps = talloc_asprintf_append(caps, "locks ");
2800                 if (!caps) {
2801                         return 1;
2802                 }
2803         }
2804         if (caplow & CIFS_UNIX_POSIX_ACLS_CAP) {
2805                 caps = talloc_asprintf_append(caps, "acls ");
2806                 if (!caps) {
2807                         return 1;
2808                 }
2809         }
2810         if (caplow & CIFS_UNIX_XATTTR_CAP) {
2811                 caps = talloc_asprintf_append(caps, "eas ");
2812                 if (!caps) {
2813                         return 1;
2814                 }
2815         }
2816         if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2817                 caps = talloc_asprintf_append(caps, "pathnames ");
2818                 if (!caps) {
2819                         return 1;
2820                 }
2821         }
2822         if (caplow & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP) {
2823                 caps = talloc_asprintf_append(caps, "posix_path_operations ");
2824                 if (!caps) {
2825                         return 1;
2826                 }
2827         }
2828         if (caplow & CIFS_UNIX_LARGE_READ_CAP) {
2829                 caps = talloc_asprintf_append(caps, "large_read ");
2830                 if (!caps) {
2831                         return 1;
2832                 }
2833         }
2834         if (caplow & CIFS_UNIX_LARGE_WRITE_CAP) {
2835                 caps = talloc_asprintf_append(caps, "large_write ");
2836                 if (!caps) {
2837                         return 1;
2838                 }
2839         }
2840         if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP) {
2841                 caps = talloc_asprintf_append(caps, "posix_encrypt ");
2842                 if (!caps) {
2843                         return 1;
2844                 }
2845         }
2846         if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP) {
2847                 caps = talloc_asprintf_append(caps, "mandatory_posix_encrypt ");
2848                 if (!caps) {
2849                         return 1;
2850                 }
2851         }
2852
2853         if (*caps && caps[strlen(caps)-1] == ' ') {
2854                 caps[strlen(caps)-1] = '\0';
2855         }
2856
2857         d_printf("Server supports CIFS capabilities %s\n", caps);
2858
2859         status = cli_set_unix_extensions_capabilities(cli, major, minor,
2860                                                       caplow, caphigh);
2861         if (!NT_STATUS_IS_OK(status)) {
2862                 d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n",
2863                          nt_errstr(status));
2864                 return 1;
2865         }
2866
2867         if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2868                 CLI_DIRSEP_CHAR = '/';
2869                 *CLI_DIRSEP_STR = '/';
2870                 client_set_cur_dir(CLI_DIRSEP_STR);
2871         }
2872
2873         return 0;
2874 }
2875
2876 static int cmd_lock(void)
2877 {
2878         TALLOC_CTX *ctx = talloc_tos();
2879         char *buf = NULL;
2880         uint64_t start, len;
2881         enum brl_type lock_type;
2882         int fnum;
2883         NTSTATUS status;
2884
2885         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2886                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2887                 return 1;
2888         }
2889         fnum = atoi(buf);
2890
2891         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2892                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2893                 return 1;
2894         }
2895
2896         if (*buf == 'r' || *buf == 'R') {
2897                 lock_type = READ_LOCK;
2898         } else if (*buf == 'w' || *buf == 'W') {
2899                 lock_type = WRITE_LOCK;
2900         } else {
2901                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2902                 return 1;
2903         }
2904
2905         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2906                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2907                 return 1;
2908         }
2909
2910         start = (uint64_t)strtol(buf, (char **)NULL, 16);
2911
2912         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2913                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2914                 return 1;
2915         }
2916
2917         len = (uint64_t)strtol(buf, (char **)NULL, 16);
2918
2919         status = cli_posix_lock(cli, fnum, start, len, true, lock_type);
2920         if (!NT_STATUS_IS_OK(status)) {
2921                 d_printf("lock failed %d: %s\n", fnum, nt_errstr(status));
2922         }
2923
2924         return 0;
2925 }
2926
2927 static int cmd_unlock(void)
2928 {
2929         TALLOC_CTX *ctx = talloc_tos();
2930         char *buf = NULL;
2931         uint64_t start, len;
2932         int fnum;
2933         NTSTATUS status;
2934
2935         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2936                 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2937                 return 1;
2938         }
2939         fnum = atoi(buf);
2940
2941         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2942                 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2943                 return 1;
2944         }
2945
2946         start = (uint64_t)strtol(buf, (char **)NULL, 16);
2947
2948         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2949                 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2950                 return 1;
2951         }
2952
2953         len = (uint64_t)strtol(buf, (char **)NULL, 16);
2954
2955         status = cli_posix_unlock(cli, fnum, start, len);
2956         if (!NT_STATUS_IS_OK(status)) {
2957                 d_printf("unlock failed %d: %s\n", fnum, nt_errstr(status));
2958         }
2959
2960         return 0;
2961 }
2962
2963
2964 /****************************************************************************
2965  Remove a directory.
2966 ****************************************************************************/
2967
2968 static int cmd_rmdir(void)
2969 {
2970         TALLOC_CTX *ctx = talloc_tos();
2971         char *mask = NULL;
2972         char *buf = NULL;
2973         char *targetname = NULL;
2974         struct cli_state *targetcli;
2975         NTSTATUS status;
2976
2977         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2978                 d_printf("rmdir <dirname>\n");
2979                 return 1;
2980         }
2981         mask = talloc_asprintf(ctx,
2982                         "%s%s",
2983                         client_get_cur_dir(),
2984                         buf);
2985         if (!mask) {
2986                 return 1;
2987         }
2988
2989         status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
2990                                   &targetname);
2991         if (!NT_STATUS_IS_OK(status)) {
2992                 d_printf("rmdir %s: %s\n", mask, nt_errstr(status));
2993                 return 1;
2994         }
2995
2996         status = cli_rmdir(targetcli, targetname);
2997         if (!NT_STATUS_IS_OK(status)) {
2998                 d_printf("%s removing remote directory file %s\n",
2999                          nt_errstr(status), mask);
3000         }
3001
3002         return 0;
3003 }
3004
3005 /****************************************************************************
3006  UNIX hardlink.
3007 ****************************************************************************/
3008
3009 static int cmd_link(void)
3010 {
3011         TALLOC_CTX *ctx = talloc_tos();
3012         char *oldname = NULL;
3013         char *newname = NULL;
3014         char *buf = NULL;
3015         char *buf2 = NULL;
3016         char *targetname = NULL;
3017         struct cli_state *targetcli;
3018         NTSTATUS status;
3019
3020         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3021             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3022                 d_printf("link <oldname> <newname>\n");
3023                 return 1;
3024         }
3025         oldname = talloc_asprintf(ctx,
3026                         "%s%s",
3027                         client_get_cur_dir(),
3028                         buf);
3029         if (!oldname) {
3030                 return 1;
3031         }
3032         newname = talloc_asprintf(ctx,
3033                         "%s%s",
3034                         client_get_cur_dir(),
3035                         buf2);
3036         if (!newname) {
3037                 return 1;
3038         }
3039
3040         status = cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli,
3041                                   &targetname);
3042         if (!NT_STATUS_IS_OK(status)) {
3043                 d_printf("link %s: %s\n", oldname, nt_errstr(status));
3044                 return 1;
3045         }
3046
3047         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3048                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3049                 return 1;
3050         }
3051
3052         status = cli_posix_hardlink(targetcli, targetname, newname);
3053         if (!NT_STATUS_IS_OK(status)) {
3054                 d_printf("%s linking files (%s -> %s)\n",
3055                          nt_errstr(status), newname, oldname);
3056                 return 1;
3057         }
3058         return 0;
3059 }
3060
3061 /****************************************************************************
3062  UNIX readlink.
3063 ****************************************************************************/
3064
3065 static int cmd_readlink(void)
3066 {
3067         TALLOC_CTX *ctx = talloc_tos();
3068         char *name= NULL;
3069         char *buf = NULL;
3070         char *targetname = NULL;
3071         char linkname[PATH_MAX+1];
3072         struct cli_state *targetcli;
3073         NTSTATUS status;
3074
3075         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3076                 d_printf("readlink <name>\n");
3077                 return 1;
3078         }
3079         name = talloc_asprintf(ctx,
3080                         "%s%s",
3081                         client_get_cur_dir(),
3082                         buf);
3083         if (!name) {
3084                 return 1;
3085         }
3086
3087         status = cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli,
3088                                   &targetname);
3089         if (!NT_STATUS_IS_OK(status)) {
3090                 d_printf("readlink %s: %s\n", name, nt_errstr(status));
3091                 return 1;
3092         }
3093
3094         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3095                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3096                 return 1;
3097         }
3098
3099         status = cli_posix_readlink(targetcli, name, linkname, PATH_MAX+1);
3100         if (!NT_STATUS_IS_OK(status)) {
3101                 d_printf("%s readlink on file %s\n",
3102                          nt_errstr(status), name);
3103                 return 1;
3104         }
3105
3106         d_printf("%s -> %s\n", name, linkname);
3107
3108         return 0;
3109 }
3110
3111
3112 /****************************************************************************
3113  UNIX symlink.
3114 ****************************************************************************/
3115
3116 static int cmd_symlink(void)
3117 {
3118         TALLOC_CTX *ctx = talloc_tos();
3119         char *oldname = NULL;
3120         char *newname = NULL;
3121         char *buf = NULL;
3122         char *buf2 = NULL;
3123         struct cli_state *newcli;
3124         NTSTATUS status;
3125
3126         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3127             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3128                 d_printf("symlink <oldname> <newname>\n");
3129                 return 1;
3130         }
3131         /* Oldname (link target) must be an untouched blob. */
3132         oldname = buf;
3133
3134         if (SERVER_HAS_UNIX_CIFS(cli)) {
3135                 newname = talloc_asprintf(ctx, "%s%s", client_get_cur_dir(),
3136                                           buf2);
3137                 if (!newname) {
3138                         return 1;
3139                 }
3140                 /* New name must be present in share namespace. */
3141                 status = cli_resolve_path(ctx, "", auth_info, cli, newname,
3142                                           &newcli, &newname);
3143                 if (!NT_STATUS_IS_OK(status)) {
3144                         d_printf("link %s: %s\n", oldname, nt_errstr(status));
3145                         return 1;
3146                 }
3147                 status = cli_posix_symlink(newcli, oldname, newname);
3148         } else {
3149                 status = cli_symlink(
3150                         cli, oldname, buf2,
3151                         buf2[0] == '\\' ? 0 : SYMLINK_FLAG_RELATIVE);
3152         }
3153
3154         if (!NT_STATUS_IS_OK(status)) {
3155                 d_printf("%s symlinking files (%s -> %s)\n",
3156                          nt_errstr(status), oldname, newname);
3157                 return 1;
3158         }
3159
3160         return 0;
3161 }
3162
3163 /****************************************************************************
3164  UNIX chmod.
3165 ****************************************************************************/
3166
3167 static int cmd_chmod(void)
3168 {
3169         TALLOC_CTX *ctx = talloc_tos();
3170         char *src = NULL;
3171         char *buf = NULL;
3172         char *buf2 = NULL;
3173         char *targetname = NULL;
3174         struct cli_state *targetcli;
3175         mode_t mode;
3176         NTSTATUS status;
3177
3178         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3179             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3180                 d_printf("chmod mode file\n");
3181                 return 1;
3182         }
3183         src = talloc_asprintf(ctx,
3184                         "%s%s",
3185                         client_get_cur_dir(),
3186                         buf2);
3187         if (!src) {
3188                 return 1;
3189         }
3190
3191         mode = (mode_t)strtol(buf, NULL, 8);
3192
3193         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3194                                   &targetname);
3195         if (!NT_STATUS_IS_OK(status)) {
3196                 d_printf("chmod %s: %s\n", src, nt_errstr(status));
3197                 return 1;
3198         }
3199
3200         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3201                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3202                 return 1;
3203         }
3204
3205         status = cli_posix_chmod(targetcli, targetname, mode);
3206         if (!NT_STATUS_IS_OK(status)) {
3207                 d_printf("%s chmod file %s 0%o\n",
3208                          nt_errstr(status), src, (unsigned int)mode);
3209                 return 1;
3210         }
3211
3212         return 0;
3213 }
3214
3215 static const char *filetype_to_str(mode_t mode)
3216 {
3217         if (S_ISREG(mode)) {
3218                 return "regular file";
3219         } else if (S_ISDIR(mode)) {
3220                 return "directory";
3221         } else
3222 #ifdef S_ISCHR
3223         if (S_ISCHR(mode)) {
3224                 return "character device";
3225         } else
3226 #endif
3227 #ifdef S_ISBLK
3228         if (S_ISBLK(mode)) {
3229                 return "block device";
3230         } else
3231 #endif
3232 #ifdef S_ISFIFO
3233         if (S_ISFIFO(mode)) {
3234                 return "fifo";
3235         } else
3236 #endif
3237 #ifdef S_ISLNK
3238         if (S_ISLNK(mode)) {
3239                 return "symbolic link";
3240         } else
3241 #endif
3242 #ifdef S_ISSOCK
3243         if (S_ISSOCK(mode)) {
3244                 return "socket";
3245         } else
3246 #endif
3247         return "";
3248 }
3249
3250 static char rwx_to_str(mode_t m, mode_t bt, char ret)
3251 {
3252         if (m & bt) {
3253                 return ret;
3254         } else {
3255                 return '-';
3256         }
3257 }
3258
3259 static char *unix_mode_to_str(char *s, mode_t m)
3260 {
3261         char *p = s;
3262         const char *str = filetype_to_str(m);
3263
3264         switch(str[0]) {
3265                 case 'd':
3266                         *p++ = 'd';
3267                         break;
3268                 case 'c':
3269                         *p++ = 'c';
3270                         break;
3271                 case 'b':
3272                         *p++ = 'b';
3273                         break;
3274                 case 'f':
3275                         *p++ = 'p';
3276                         break;
3277                 case 's':
3278                         *p++ = str[1] == 'y' ? 'l' : 's';
3279                         break;
3280                 case 'r':
3281                 default:
3282                         *p++ = '-';
3283                         break;
3284         }
3285         *p++ = rwx_to_str(m, S_IRUSR, 'r');
3286         *p++ = rwx_to_str(m, S_IWUSR, 'w');
3287         *p++ = rwx_to_str(m, S_IXUSR, 'x');
3288         *p++ = rwx_to_str(m, S_IRGRP, 'r');
3289         *p++ = rwx_to_str(m, S_IWGRP, 'w');
3290         *p++ = rwx_to_str(m, S_IXGRP, 'x');
3291         *p++ = rwx_to_str(m, S_IROTH, 'r');
3292         *p++ = rwx_to_str(m, S_IWOTH, 'w');
3293         *p++ = rwx_to_str(m, S_IXOTH, 'x');
3294         *p++ = '\0';
3295         return s;
3296 }
3297
3298 /****************************************************************************
3299  Utility function for UNIX getfacl.
3300 ****************************************************************************/
3301
3302 static char *perms_to_string(fstring permstr, unsigned char perms)
3303 {
3304         fstrcpy(permstr, "---");
3305         if (perms & SMB_POSIX_ACL_READ) {
3306                 permstr[0] = 'r';
3307         }
3308         if (perms & SMB_POSIX_ACL_WRITE) {
3309                 permstr[1] = 'w';
3310         }
3311         if (perms & SMB_POSIX_ACL_EXECUTE) {
3312                 permstr[2] = 'x';
3313         }
3314         return permstr;
3315 }
3316
3317 /****************************************************************************
3318  UNIX getfacl.
3319 ****************************************************************************/
3320
3321 static int cmd_getfacl(void)
3322 {
3323         TALLOC_CTX *ctx = talloc_tos();
3324         char *src = NULL;
3325         char *name = NULL;
3326         char *targetname = NULL;
3327         struct cli_state *targetcli;
3328         uint16 major, minor;
3329         uint32 caplow, caphigh;
3330         char *retbuf = NULL;
3331         size_t rb_size = 0;
3332         SMB_STRUCT_STAT sbuf;
3333         uint16 num_file_acls = 0;
3334         uint16 num_dir_acls = 0;
3335         uint16 i;
3336         NTSTATUS status;
3337
3338         if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
3339                 d_printf("getfacl filename\n");
3340                 return 1;
3341         }
3342         src = talloc_asprintf(ctx,
3343                         "%s%s",
3344                         client_get_cur_dir(),
3345                         name);
3346         if (!src) {
3347                 return 1;
3348         }
3349
3350         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3351                                   &targetname);
3352         if (!NT_STATUS_IS_OK(status)) {
3353                 d_printf("stat %s: %s\n", src, nt_errstr(status));
3354                 return 1;
3355         }
3356
3357         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3358                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3359                 return 1;
3360         }
3361
3362         status = cli_unix_extensions_version(targetcli, &major, &minor,
3363                                              &caplow, &caphigh);
3364         if (!NT_STATUS_IS_OK(status)) {
3365                 d_printf("Can't get UNIX CIFS version from server: %s.\n",
3366                          nt_errstr(status));
3367                 return 1;
3368         }
3369
3370         if (!(caplow & CIFS_UNIX_POSIX_ACLS_CAP)) {
3371                 d_printf("This server supports UNIX extensions "
3372                         "but doesn't support POSIX ACLs.\n");
3373                 return 1;
3374         }
3375
3376         status = cli_posix_stat(targetcli, targetname, &sbuf);
3377         if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli, targetname, &sbuf))) {
3378                 d_printf("%s getfacl doing a stat on file %s\n",
3379                          nt_errstr(status), src);
3380                 return 1;
3381         }
3382
3383         status = cli_posix_getfacl(targetcli, targetname, ctx, &rb_size, &retbuf);
3384         if (!NT_STATUS_IS_OK(status)) {
3385                 d_printf("%s getfacl file %s\n",
3386                          nt_errstr(status), src);
3387                 return 1;
3388         }
3389
3390         /* ToDo : Print out the ACL values. */
3391         if (rb_size < 6 || SVAL(retbuf,0) != SMB_POSIX_ACL_VERSION) {
3392                 d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
3393                         src, (unsigned int)CVAL(retbuf,0) );
3394                 return 1;
3395         }
3396
3397         num_file_acls = SVAL(retbuf,2);
3398         num_dir_acls = SVAL(retbuf,4);
3399         if (rb_size != SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)) {
3400                 d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
3401                         src,
3402                         (unsigned int)(SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)),
3403                         (unsigned int)rb_size);
3404                 return 1;
3405         }
3406
3407         d_printf("# file: %s\n", src);
3408         d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf.st_ex_uid, (unsigned int)sbuf.st_ex_gid);
3409
3410         if (num_file_acls == 0 && num_dir_acls == 0) {
3411                 d_printf("No acls found.\n");
3412         }
3413
3414         for (i = 0; i < num_file_acls; i++) {
3415                 uint32 uorg;
3416                 fstring permstring;
3417                 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE));
3418                 unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+1);
3419
3420                 switch(tagtype) {
3421                         case SMB_POSIX_ACL_USER_OBJ:
3422                                 d_printf("user::");
3423                                 break;
3424                         case SMB_POSIX_ACL_USER:
3425                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3426                                 d_printf("user:%u:", uorg);
3427                                 break;
3428                         case SMB_POSIX_ACL_GROUP_OBJ:
3429                                 d_printf("group::");
3430                                 break;
3431                         case SMB_POSIX_ACL_GROUP:
3432                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3433                                 d_printf("group:%u:", uorg);
3434                                 break;
3435                         case SMB_POSIX_ACL_MASK:
3436                                 d_printf("mask::");
3437                                 break;
3438                         case SMB_POSIX_ACL_OTHER:
3439                                 d_printf("other::");
3440                                 break;
3441                         default:
3442                                 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3443                                         src, (unsigned int)tagtype );
3444                                 SAFE_FREE(retbuf);
3445                                 return 1;
3446                 }
3447
3448                 d_printf("%s\n", perms_to_string(permstring, perms));
3449         }
3450
3451         for (i = 0; i < num_dir_acls; i++) {
3452                 uint32 uorg;
3453                 fstring permstring;
3454                 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE));
3455                 unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+1);
3456
3457                 switch(tagtype) {
3458                         case SMB_POSIX_ACL_USER_OBJ:
3459                                 d_printf("default:user::");
3460                                 break;
3461                         case SMB_POSIX_ACL_USER:
3462                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3463                                 d_printf("default:user:%u:", uorg);
3464                                 break;
3465                         case SMB_POSIX_ACL_GROUP_OBJ:
3466                                 d_printf("default:group::");
3467                                 break;
3468                         case SMB_POSIX_ACL_GROUP:
3469                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3470                                 d_printf("default:group:%u:", uorg);
3471                                 break;
3472                         case SMB_POSIX_ACL_MASK:
3473                                 d_printf("default:mask::");
3474                                 break;
3475                         case SMB_POSIX_ACL_OTHER:
3476                                 d_printf("default:other::");
3477                                 break;
3478                         default:
3479                                 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3480                                         src, (unsigned int)tagtype );
3481                                 SAFE_FREE(retbuf);
3482                                 return 1;
3483                 }
3484
3485                 d_printf("%s\n", perms_to_string(permstring, perms));
3486         }
3487
3488         return 0;
3489 }
3490
3491 /****************************************************************************
3492  Get the EA list of a file
3493 ****************************************************************************/
3494
3495 static int cmd_geteas(void)
3496 {
3497         TALLOC_CTX *ctx = talloc_tos();
3498         char *src = NULL;
3499         char *name = NULL;
3500         char *targetname = NULL;
3501         struct cli_state *targetcli;
3502         NTSTATUS status;
3503         size_t i, num_eas;
3504         struct ea_struct *eas;
3505
3506         if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
3507                 d_printf("geteas filename\n");
3508                 return 1;
3509         }
3510         src = talloc_asprintf(ctx,
3511                         "%s%s",
3512                         client_get_cur_dir(),
3513                         name);
3514         if (!src) {
3515                 return 1;
3516         }
3517
3518         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3519                                   &targetname);
3520         if (!NT_STATUS_IS_OK(status)) {
3521                 d_printf("stat %s: %s\n", src, nt_errstr(status));
3522                 return 1;
3523         }
3524
3525         status = cli_get_ea_list_path(targetcli, targetname, talloc_tos(),
3526                                       &num_eas, &eas);
3527         if (!NT_STATUS_IS_OK(status)) {
3528                 d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status));
3529                 return 1;
3530         }
3531
3532         for (i=0; i<num_eas; i++) {
3533                 d_printf("%s (%d) =\n", eas[i].name, (int)eas[i].flags);
3534                 dump_data_file(eas[i].value.data, eas[i].value.length, false,
3535                                stdout);
3536                 d_printf("\n");
3537         }
3538
3539         TALLOC_FREE(eas);
3540
3541         return 0;
3542 }
3543
3544 /****************************************************************************
3545  Set an EA of a file
3546 ****************************************************************************/
3547
3548 static int cmd_setea(void)
3549 {
3550         TALLOC_CTX *ctx = talloc_tos();
3551         char *src = NULL;
3552         char *name = NULL;
3553         char *eaname = NULL;
3554         char *eavalue = NULL;
3555         char *targetname = NULL;
3556         struct cli_state *targetcli;
3557         NTSTATUS status;
3558
3559         if (!next_token_talloc(ctx, &cmd_ptr, &name, NULL)
3560             || !next_token_talloc(ctx, &cmd_ptr, &eaname, NULL)) {
3561                 d_printf("setea filename eaname value\n");
3562                 return 1;
3563         }
3564         if (!next_token_talloc(ctx, &cmd_ptr, &eavalue, NULL)) {
3565                 eavalue = talloc_strdup(ctx, "");
3566         }
3567         src = talloc_asprintf(ctx,
3568                         "%s%s",
3569                         client_get_cur_dir(),
3570                         name);
3571         if (!src) {
3572                 return 1;
3573         }
3574
3575         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3576                                   &targetname);
3577         if (!NT_STATUS_IS_OK(status)) {
3578                 d_printf("stat %s: %s\n", src, nt_errstr(status));
3579                 return 1;
3580         }
3581
3582         status =  cli_set_ea_path(targetcli, targetname, eaname, eavalue,
3583                                   strlen(eavalue));
3584         if (!NT_STATUS_IS_OK(status)) {
3585                 d_printf("set_ea %s: %s\n", src, nt_errstr(status));
3586                 return 1;
3587         }
3588
3589         return 0;
3590 }
3591
3592 /****************************************************************************
3593  UNIX stat.
3594 ****************************************************************************/
3595
3596 static int cmd_stat(void)
3597 {
3598         TALLOC_CTX *ctx = talloc_tos();
3599         char *src = NULL;
3600         char *name = NULL;
3601         char *targetname = NULL;
3602         struct cli_state *targetcli;
3603         fstring mode_str;
3604         SMB_STRUCT_STAT sbuf;
3605         struct tm *lt;
3606         time_t tmp_time;
3607         NTSTATUS status;
3608
3609         if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
3610                 d_printf("stat file\n");
3611                 return 1;
3612         }
3613         src = talloc_asprintf(ctx,
3614                         "%s%s",
3615                         client_get_cur_dir(),
3616                         name);
3617         if (!src) {
3618                 return 1;
3619         }
3620
3621         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3622                                   &targetname);
3623         if (!NT_STATUS_IS_OK(status)) {
3624                 d_printf("stat %s: %s\n", src, nt_errstr(status));
3625                 return 1;
3626         }
3627
3628         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3629                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3630                 return 1;
3631         }
3632
3633         status = cli_posix_stat(targetcli, targetname, &sbuf);
3634         if (!NT_STATUS_IS_OK(status)) {
3635                 d_printf("%s stat file %s\n",
3636                          nt_errstr(status), src);
3637                 return 1;
3638         }
3639
3640         /* Print out the stat values. */
3641         d_printf("File: %s\n", src);
3642         d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
3643                 (double)sbuf.st_ex_size,
3644                 (unsigned int)sbuf.st_ex_blocks,
3645                 filetype_to_str(sbuf.st_ex_mode));
3646
3647 #if defined(S_ISCHR) && defined(S_ISBLK)
3648         if (S_ISCHR(sbuf.st_ex_mode) || S_ISBLK(sbuf.st_ex_mode)) {
3649                 d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
3650                         (double)sbuf.st_ex_ino,
3651                         (unsigned int)sbuf.st_ex_nlink,
3652                         unix_dev_major(sbuf.st_ex_rdev),
3653                         unix_dev_minor(sbuf.st_ex_rdev));
3654         } else
3655 #endif
3656                 d_printf("Inode: %.0f\tLinks: %u\n",
3657                         (double)sbuf.st_ex_ino,
3658                         (unsigned int)sbuf.st_ex_nlink);
3659
3660         d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
3661                 ((int)sbuf.st_ex_mode & 0777),
3662                 unix_mode_to_str(mode_str, sbuf.st_ex_mode),
3663                 (unsigned int)sbuf.st_ex_uid,
3664                 (unsigned int)sbuf.st_ex_gid);
3665
3666         tmp_time = convert_timespec_to_time_t(sbuf.st_ex_atime);
3667         lt = localtime(&tmp_time);
3668         if (lt) {
3669                 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
3670         } else {
3671                 fstrcpy(mode_str, "unknown");
3672         }
3673         d_printf("Access: %s\n", mode_str);
3674
3675         tmp_time = convert_timespec_to_time_t(sbuf.st_ex_mtime);
3676         lt = localtime(&tmp_time);
3677         if (lt) {
3678                 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
3679         } else {
3680                 fstrcpy(mode_str, "unknown");
3681         }
3682         d_printf("Modify: %s\n", mode_str);
3683
3684         tmp_time = convert_timespec_to_time_t(sbuf.st_ex_ctime);
3685         lt = localtime(&tmp_time);
3686         if (lt) {
3687                 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
3688         } else {
3689                 fstrcpy(mode_str, "unknown");
3690         }
3691         d_printf("Change: %s\n", mode_str);
3692
3693         return 0;
3694 }
3695
3696
3697 /****************************************************************************
3698  UNIX chown.
3699 ****************************************************************************/
3700
3701 static int cmd_chown(void)
3702 {
3703         TALLOC_CTX *ctx = talloc_tos();
3704         char *src = NULL;
3705         uid_t uid;
3706         gid_t gid;
3707         char *buf, *buf2, *buf3;
3708         struct cli_state *targetcli;
3709         char *targetname = NULL;
3710         NTSTATUS status;
3711
3712         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3713             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL) ||
3714             !next_token_talloc(ctx, &cmd_ptr,&buf3,NULL)) {
3715                 d_printf("chown uid gid file\n");
3716                 return 1;
3717         }
3718
3719         uid = (uid_t)atoi(buf);
3720         gid = (gid_t)atoi(buf2);
3721
3722         src = talloc_asprintf(ctx,
3723                         "%s%s",
3724                         client_get_cur_dir(),
3725                         buf3);
3726         if (!src) {
3727                 return 1;
3728         }
3729         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3730                                   &targetname);
3731         if (!NT_STATUS_IS_OK(status)) {
3732                 d_printf("chown %s: %s\n", src, nt_errstr(status));
3733                 return 1;
3734         }
3735
3736         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3737                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3738                 return 1;
3739         }
3740
3741         status = cli_posix_chown(targetcli, targetname, uid, gid);
3742         if (!NT_STATUS_IS_OK(status)) {
3743                 d_printf("%s chown file %s uid=%d, gid=%d\n",
3744                          nt_errstr(status), src, (int)uid, (int)gid);
3745                 return 1;
3746         }
3747
3748         return 0;
3749 }
3750
3751 /****************************************************************************
3752  Rename some file.
3753 ****************************************************************************/
3754
3755 static int cmd_rename(void)
3756 {
3757         TALLOC_CTX *ctx = talloc_tos();
3758         char *src, *dest;
3759         char *buf, *buf2;
3760         struct cli_state *targetcli;
3761         char *targetsrc;
3762         char *targetdest;
3763         NTSTATUS status;
3764
3765         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3766             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3767                 d_printf("rename <src> <dest>\n");
3768                 return 1;
3769         }
3770
3771         src = talloc_asprintf(ctx,
3772                         "%s%s",
3773                         client_get_cur_dir(),
3774                         buf);
3775         if (!src) {
3776                 return 1;
3777         }
3778
3779         dest = talloc_asprintf(ctx,
3780                         "%s%s",
3781                         client_get_cur_dir(),
3782                         buf2);
3783         if (!dest) {
3784                 return 1;
3785         }
3786
3787         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3788                                   &targetsrc);
3789         if (!NT_STATUS_IS_OK(status)) {
3790                 d_printf("rename %s: %s\n", src, nt_errstr(status));
3791                 return 1;
3792         }
3793
3794         status = cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli,
3795                                   &targetdest);
3796         if (!NT_STATUS_IS_OK(status)) {
3797                 d_printf("rename %s: %s\n", dest, nt_errstr(status));
3798                 return 1;
3799         }
3800
3801         status = cli_rename(targetcli, targetsrc, targetdest);
3802         if (!NT_STATUS_IS_OK(status)) {
3803                 d_printf("%s renaming files %s -> %s \n",
3804                         nt_errstr(status),
3805                         targetsrc,
3806                         targetdest);
3807                 return 1;
3808         }
3809
3810         return 0;
3811 }
3812
3813 /****************************************************************************
3814  Print the volume name.
3815 ****************************************************************************/
3816
3817 static int cmd_volume(void)
3818 {
3819         char *volname;
3820         uint32_t serial_num;
3821         time_t create_date;
3822         NTSTATUS status;
3823
3824         status = cli_get_fs_volume_info(cli, talloc_tos(),
3825                                         &volname, &serial_num,
3826                                         &create_date);
3827         if (!NT_STATUS_IS_OK(status)) {
3828                 d_printf("Error %s getting volume info\n", nt_errstr(status));
3829                 return 1;
3830         }
3831
3832         d_printf("Volume: |%s| serial number 0x%x\n",
3833                         volname, (unsigned int)serial_num);
3834         return 0;
3835 }
3836
3837 /****************************************************************************
3838  Hard link files using the NT call.
3839 ****************************************************************************/
3840
3841 static int cmd_hardlink(void)
3842 {
3843         TALLOC_CTX *ctx = talloc_tos();
3844         char *src, *dest;
3845         char *buf, *buf2;
3846         struct cli_state *targetcli;
3847         char *targetname;
3848         NTSTATUS status;
3849
3850         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3851             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3852                 d_printf("hardlink <src> <dest>\n");
3853                 return 1;
3854         }
3855
3856         src = talloc_asprintf(ctx,
3857                         "%s%s",
3858                         client_get_cur_dir(),
3859                         buf);
3860         if (!src) {
3861                 return 1;
3862         }
3863
3864         dest = talloc_asprintf(ctx,
3865                         "%s%s",
3866                         client_get_cur_dir(),
3867                         buf2);
3868         if (!dest) {
3869                 return 1;
3870         }
3871
3872         status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
3873                                   &targetname);
3874         if (!NT_STATUS_IS_OK(status)) {
3875                 d_printf("hardlink %s: %s\n", src, nt_errstr(status));
3876                 return 1;
3877         }
3878
3879         status = cli_nt_hardlink(targetcli, targetname, dest);
3880         if (!NT_STATUS_IS_OK(status)) {
3881                 d_printf("%s doing an NT hard link of files\n",
3882                          nt_errstr(status));
3883                 return 1;
3884         }
3885
3886         return 0;
3887 }
3888
3889 /****************************************************************************
3890  Toggle the prompt flag.
3891 ****************************************************************************/
3892
3893 static int cmd_prompt(void)
3894 {
3895         prompt = !prompt;
3896         DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
3897         return 1;
3898 }
3899
3900 /****************************************************************************
3901  Set the newer than time.
3902 ****************************************************************************/
3903
3904 static int cmd_newer(void)
3905 {
3906         TALLOC_CTX *ctx = talloc_tos();
3907         char *buf;
3908         bool ok;
3909         SMB_STRUCT_STAT sbuf;
3910
3911         ok = next_token_talloc(ctx, &cmd_ptr,&buf,NULL);
3912         if (ok && (sys_stat(buf, &sbuf, false) == 0)) {
3913                 newer_than = convert_timespec_to_time_t(sbuf.st_ex_mtime);
3914                 DEBUG(1,("Getting files newer than %s",
3915                          time_to_asc(newer_than)));
3916         } else {
3917                 newer_than = 0;
3918         }
3919
3920         if (ok && newer_than == 0) {
3921                 d_printf("Error setting newer-than time\n");
3922                 return 1;
3923         }
3924
3925         return 0;
3926 }
3927
3928 /****************************************************************************
3929  Watch directory changes
3930 ****************************************************************************/
3931
3932 static int cmd_notify(void)
3933 {
3934         TALLOC_CTX *frame = talloc_stackframe();
3935         char *name, *buf;
3936         NTSTATUS status;
3937         uint16_t fnum;
3938
3939         name = talloc_strdup(talloc_tos(), client_get_cur_dir());
3940         if (name == NULL) {
3941                 goto fail;
3942         }
3943         if (!next_token_talloc(talloc_tos(), &cmd_ptr, &buf, NULL)) {
3944                 goto usage;
3945         }
3946         name = talloc_asprintf_append(name, "%s", buf);
3947         if (name == NULL) {
3948                 goto fail;
3949         }
3950         status = cli_ntcreate(
3951                 cli, name, 0, FILE_READ_DATA, 0,
3952                 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3953                 FILE_OPEN, 0, 0, &fnum);
3954         if (!NT_STATUS_IS_OK(status)) {
3955                 d_printf("Could not open file: %s\n", nt_errstr(status));
3956                 goto fail;
3957         }
3958
3959         while (1) {
3960                 uint32_t i, num_changes;
3961                 struct notify_change *changes;
3962
3963                 status = cli_notify(cli, fnum, 1000, FILE_NOTIFY_CHANGE_ALL,
3964                                     true,
3965                                     talloc_tos(), &num_changes, &changes);
3966                 if (!NT_STATUS_IS_OK(status)) {
3967                         d_printf("notify returned %s\n",
3968                                  nt_errstr(status));
3969                         goto fail;
3970                 }
3971                 for (i=0; i<num_changes; i++) {
3972                         printf("%4.4x %s\n", changes[i].action,
3973                                changes[i].name);
3974                 }
3975                 TALLOC_FREE(changes);
3976         }
3977 usage:
3978         d_printf("notify <file>\n");
3979 fail:
3980         TALLOC_FREE(frame);
3981         return 1;
3982 }
3983
3984 /****************************************************************************
3985  Set the archive level.
3986 ****************************************************************************/
3987
3988 static int cmd_archive(void)
3989 {
3990         TALLOC_CTX *ctx = talloc_tos();
3991         char *buf;
3992
3993         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3994                 archive_level = atoi(buf);
3995         } else {
3996                 d_printf("Archive level is %d\n",archive_level);
3997         }
3998
3999         return 0;
4000 }
4001
4002 /****************************************************************************
4003  Toggle the backup_intent state.
4004 ****************************************************************************/
4005
4006 static int cmd_backup(void)
4007 {
4008         backup_intent = !backup_intent;
4009         cli_set_backup_intent(cli, backup_intent);
4010         DEBUG(2,("backup intent is now %s\n",backup_intent?"on":"off"));
4011         return 1;
4012 }
4013
4014 /****************************************************************************
4015  Toggle the lowercaseflag.
4016 ****************************************************************************/
4017
4018 static int cmd_lowercase(void)
4019 {
4020         lowercase = !lowercase;
4021         DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
4022         return 0;
4023 }
4024
4025 /****************************************************************************
4026  Toggle the case sensitive flag.
4027 ****************************************************************************/
4028
4029 static int cmd_setcase(void)
4030 {
4031         bool orig_case_sensitive = cli_set_case_sensitive(cli, false);
4032
4033         cli_set_case_sensitive(cli, !orig_case_sensitive);
4034         DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive ?
4035                 "on":"off"));
4036         return 0;
4037 }
4038
4039 /****************************************************************************
4040  Toggle the showacls flag.
4041 ****************************************************************************/
4042
4043 static int cmd_showacls(void)
4044 {
4045         showacls = !showacls;
4046         DEBUG(2,("showacls is now %s\n",showacls?"on":"off"));
4047         return 0;
4048 }
4049
4050
4051 /****************************************************************************
4052  Toggle the recurse flag.
4053 ****************************************************************************/
4054
4055 static int cmd_recurse(void)
4056 {
4057         recurse = !recurse;
4058         DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
4059         return 0;
4060 }
4061
4062 /****************************************************************************
4063  Toggle the translate flag.
4064 ****************************************************************************/
4065
4066 static int cmd_translate(void)
4067 {
4068         translation = !translation;
4069         DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
4070                  translation?"on":"off"));
4071         return 0;
4072 }
4073
4074 /****************************************************************************
4075  Do the lcd command.
4076  ****************************************************************************/
4077
4078 static int cmd_lcd(void)
4079 {
4080         TALLOC_CTX *ctx = talloc_tos();
4081         char *buf;
4082         char *d;
4083
4084         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4085                 if (chdir(buf) == -1) {
4086                         d_printf("chdir to %s failed (%s)\n",
4087                                 buf, strerror(errno));
4088                 }
4089         }
4090         d = sys_getwd();
4091         if (!d) {
4092                 return 1;
4093         }
4094         DEBUG(2,("the local directory is now %s\n",d));
4095         SAFE_FREE(d);
4096         return 0;
4097 }
4098
4099 /****************************************************************************
4100  Get a file restarting at end of local file.
4101  ****************************************************************************/
4102
4103 static int cmd_reget(void)
4104 {
4105         TALLOC_CTX *ctx = talloc_tos();
4106         char *local_name = NULL;
4107         char *remote_name = NULL;
4108         char *fname = NULL;
4109         char *p = NULL;
4110
4111         remote_name = talloc_strdup(ctx, client_get_cur_dir());
4112         if (!remote_name) {
4113                 return 1;
4114         }
4115
4116         if (!next_token_talloc(ctx, &cmd_ptr, &fname, NULL)) {
4117                 d_printf("reget <filename>\n");
4118                 return 1;
4119         }
4120         remote_name = talloc_asprintf_append(remote_name, "%s", fname);
4121         if (!remote_name) {
4122                 return 1;
4123         }
4124         remote_name = clean_name(ctx,remote_name);
4125         if (!remote_name) {
4126                 return 1;
4127         }
4128
4129         local_name = fname;
4130         next_token_talloc(ctx, &cmd_ptr, &p, NULL);
4131         if (p) {
4132                 local_name = p;
4133         }
4134
4135         return do_get(remote_name, local_name, true);
4136 }
4137
4138 /****************************************************************************
4139  Put a file restarting at end of local file.
4140  ****************************************************************************/
4141
4142 static int cmd_reput(void)
4143 {
4144         TALLOC_CTX *ctx = talloc_tos();
4145         char *local_name = NULL;
4146         char *remote_name = NULL;
4147         char *buf;
4148         SMB_STRUCT_STAT st;
4149
4150         remote_name = talloc_strdup(ctx, client_get_cur_dir());
4151         if (!remote_name) {
4152                 return 1;
4153         }
4154
4155         if (!next_token_talloc(ctx, &cmd_ptr, &local_name, NULL)) {
4156                 d_printf("reput <filename>\n");
4157                 return 1;
4158         }
4159
4160         if (!file_exist_stat(local_name, &st, false)) {
4161                 d_printf("%s does not exist\n", local_name);
4162                 return 1;
4163         }
4164
4165         if (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
4166                 remote_name = talloc_asprintf_append(remote_name,
4167                                                 "%s", buf);
4168         } else {
4169                 remote_name = talloc_asprintf_append(remote_name,
4170                                                 "%s", local_name);
4171         }
4172         if (!remote_name) {
4173                 return 1;
4174         }
4175
4176         remote_name = clean_name(ctx, remote_name);
4177         if (!remote_name) {
4178                 return 1;
4179         }
4180
4181         return do_put(remote_name, local_name, true);
4182 }
4183
4184 /****************************************************************************
4185  List a share name.
4186  ****************************************************************************/
4187
4188 static void browse_fn(const char *name, uint32 m,
4189                       const char *comment, void *state)
4190 {
4191         const char *typestr = "";
4192
4193         switch (m & 7) {
4194         case STYPE_DISKTREE:
4195                 typestr = "Disk";
4196                 break;
4197         case STYPE_PRINTQ:
4198                 typestr = "Printer";
4199                 break;
4200         case STYPE_DEVICE:
4201                 typestr = "Device";
4202                 break;
4203         case STYPE_IPC:
4204                 typestr = "IPC";
4205                 break;
4206         }
4207         /* FIXME: If the remote machine returns non-ascii characters
4208            in any of these fields, they can corrupt the output.  We
4209            should remove them. */
4210         if (!grepable) {
4211                 d_printf("\t%-15s %-10.10s%s\n",
4212                         name,typestr,comment);
4213         } else {
4214                 d_printf ("%s|%s|%s\n",typestr,name,comment);
4215         }
4216 }
4217
4218 static bool browse_host_rpc(bool sort)
4219 {
4220         NTSTATUS status;
4221         struct rpc_pipe_client *pipe_hnd = NULL;
4222         TALLOC_CTX *frame = talloc_stackframe();
4223         WERROR werr;
4224         struct srvsvc_NetShareInfoCtr info_ctr;
4225         struct srvsvc_NetShareCtr1 ctr1;
4226         uint32_t resume_handle = 0;
4227         uint32_t total_entries = 0;
4228         int i;
4229         struct dcerpc_binding_handle *b;
4230
4231         status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc,
4232                                           &pipe_hnd);
4233
4234         if (!NT_STATUS_IS_OK(status)) {
4235                 DEBUG(10, ("Could not connect to srvsvc pipe: %s\n",
4236                            nt_errstr(status)));
4237                 TALLOC_FREE(frame);
4238                 return false;
4239         }
4240
4241         b = pipe_hnd->binding_handle;
4242
4243         ZERO_STRUCT(info_ctr);
4244         ZERO_STRUCT(ctr1);
4245
4246         info_ctr.level = 1;
4247         info_ctr.ctr.ctr1 = &ctr1;
4248
4249         status = dcerpc_srvsvc_NetShareEnumAll(b, frame,
4250                                               pipe_hnd->desthost,
4251                                               &info_ctr,
4252                                               0xffffffff,
4253                                               &total_entries,
4254                                               &resume_handle,
4255                                               &werr);
4256
4257         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
4258                 TALLOC_FREE(pipe_hnd);
4259                 TALLOC_FREE(frame);
4260                 return false;
4261         }
4262
4263         for (i=0; i < info_ctr.ctr.ctr1->count; i++) {
4264                 struct srvsvc_NetShareInfo1 info = info_ctr.ctr.ctr1->array[i];
4265                 browse_fn(info.name, info.type, info.comment, NULL);
4266         }
4267
4268         TALLOC_FREE(pipe_hnd);
4269         TALLOC_FREE(frame);
4270         return true;
4271 }
4272
4273 /****************************************************************************
4274  Try and browse available connections on a host.
4275 ****************************************************************************/
4276
4277 static bool browse_host(bool sort)
4278 {
4279         int ret;
4280         if (!grepable) {
4281                 d_printf("\n\tSharename       Type      Comment\n");
4282                 d_printf("\t---------       ----      -------\n");
4283         }
4284
4285         if (browse_host_rpc(sort)) {
4286                 return true;
4287         }
4288
4289         if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1) {
4290                 NTSTATUS status = cli_nt_error(cli);
4291                 d_printf("Error returning browse list: %s\n",
4292                          nt_errstr(status));
4293         }
4294
4295         return (ret != -1);
4296 }
4297
4298 /****************************************************************************
4299  List a server name.
4300 ****************************************************************************/
4301
4302 static void server_fn(const char *name, uint32 m,
4303                       const char *comment, void *state)
4304 {
4305
4306         if (!grepable){
4307                 d_printf("\t%-16s     %s\n", name, comment);
4308         } else {
4309                 d_printf("%s|%s|%s\n",(char *)state, name, comment);
4310         }
4311 }
4312
4313 /****************************************************************************
4314  Try and browse available connections on a host.
4315 ****************************************************************************/
4316
4317 static bool list_servers(const char *wk_grp)
4318 {
4319         fstring state;
4320
4321         if (!cli->server_domain)
4322                 return false;
4323
4324         if (!grepable) {
4325                 d_printf("\n\tServer               Comment\n");
4326                 d_printf("\t---------            -------\n");
4327         };
4328         fstrcpy( state, "Server" );
4329         cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL, server_fn,
4330                           state);
4331
4332         if (!grepable) {
4333                 d_printf("\n\tWorkgroup            Master\n");
4334                 d_printf("\t---------            -------\n");
4335         };
4336
4337         fstrcpy( state, "Workgroup" );
4338         cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM,
4339                           server_fn, state);
4340         return true;
4341 }
4342
4343 /****************************************************************************
4344  Print or set current VUID
4345 ****************************************************************************/
4346
4347 static int cmd_vuid(void)
4348 {
4349         TALLOC_CTX *ctx = talloc_tos();
4350         char *buf;
4351
4352         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4353                 d_printf("Current VUID is %d\n",
4354                          cli_state_get_uid(cli));
4355                 return 0;
4356         }
4357
4358         cli_state_set_uid(cli, atoi(buf));
4359         return 0;
4360 }
4361
4362 /****************************************************************************
4363  Setup a new VUID, by issuing a session setup
4364 ****************************************************************************/
4365
4366 static int cmd_logon(void)
4367 {
4368         TALLOC_CTX *ctx = talloc_tos();
4369         char *l_username, *l_password;
4370         NTSTATUS nt_status;
4371
4372         if (!next_token_talloc(ctx, &cmd_ptr,&l_username,NULL)) {
4373                 d_printf("logon <username> [<password>]\n");
4374                 return 0;
4375         }
4376
4377         if (!next_token_talloc(ctx, &cmd_ptr,&l_password,NULL)) {
4378                 char pwd[256] = {0};
4379                 int rc;
4380
4381                 rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
4382                 if (rc == 0) {
4383                         l_password = talloc_strdup(ctx, pwd);
4384                 }
4385         }
4386         if (!l_password) {
4387                 return 1;
4388         }
4389
4390         nt_status = cli_session_setup(cli, l_username,
4391                                       l_password, strlen(l_password),
4392                                       l_password, strlen(l_password),
4393                                       lp_workgroup());
4394         if (!NT_STATUS_IS_OK(nt_status)) {
4395                 d_printf("session setup failed: %s\n", nt_errstr(nt_status));
4396                 return -1;
4397         }
4398
4399         d_printf("Current VUID is %d\n", cli_state_get_uid(cli));
4400         return 0;
4401 }
4402
4403 /**
4404  * close the session
4405  */
4406
4407 static int cmd_logoff(void)
4408 {
4409         NTSTATUS status;
4410
4411         status = cli_ulogoff(cli);
4412         if (!NT_STATUS_IS_OK(status)) {
4413                 d_printf("logoff failed: %s\n", nt_errstr(status));
4414                 return -1;
4415         }
4416
4417         d_printf("logoff successful\n");
4418         return 0;
4419 }
4420
4421
4422 /**
4423  * tree connect (connect to a share)
4424  */
4425
4426 static int cmd_tcon(void)
4427 {
4428         TALLOC_CTX *ctx = talloc_tos();
4429         char *sharename;
4430         NTSTATUS status;
4431
4432         if (!next_token_talloc(ctx, &cmd_ptr, &sharename, NULL)) {
4433                 d_printf("tcon <sharename>\n");
4434                 return 0;
4435         }
4436
4437         if (!sharename) {
4438                 return 1;
4439         }
4440
4441         status = cli_tree_connect(cli, sharename, "?????", "", 0);
4442         if (!NT_STATUS_IS_OK(status)) {
4443                 d_printf("tcon failed: %s\n", nt_errstr(status));
4444                 return -1;
4445         }
4446
4447         talloc_free(sharename);
4448
4449         d_printf("tcon to %s successful, tid: %u\n", sharename,
4450                  cli_state_get_tid(cli));
4451         return 0;
4452 }
4453
4454 /**
4455  * tree disconnect (disconnect from a share)
4456  */
4457
4458 static int cmd_tdis(void)
4459 {
4460         NTSTATUS status;
4461
4462         status = cli_tdis(cli);
4463         if (!NT_STATUS_IS_OK(status)) {
4464                 d_printf("tdis failed: %s\n", nt_errstr(status));
4465                 return -1;
4466         }
4467
4468         d_printf("tdis successful\n");
4469         return 0;
4470 }
4471
4472
4473 /**
4474  * get or set tid
4475  */
4476
4477 static int cmd_tid(void)
4478 {
4479         TALLOC_CTX *ctx = talloc_tos();
4480         char *tid_str;
4481
4482         if (!next_token_talloc(ctx, &cmd_ptr, &tid_str, NULL)) {
4483                 if (cli_state_has_tcon(cli)) {
4484                         d_printf("current tid is %d\n", cli_state_get_tid(cli));
4485                 } else {
4486                         d_printf("no tcon currently\n");
4487                 }
4488         } else {
4489                 uint16_t tid = atoi(tid_str);
4490                 cli_state_set_tid(cli, tid);
4491         }
4492
4493         return 0;
4494 }
4495
4496
4497 /****************************************************************************
4498  list active connections
4499 ****************************************************************************/
4500
4501 static int cmd_list_connect(void)
4502 {
4503         cli_cm_display(cli);
4504         return 0;
4505 }
4506
4507 /****************************************************************************
4508  display the current active client connection
4509 ****************************************************************************/
4510
4511 static int cmd_show_connect( void )
4512 {
4513         TALLOC_CTX *ctx = talloc_tos();
4514         struct cli_state *targetcli;
4515         char *targetpath;
4516         NTSTATUS status;
4517
4518         status = cli_resolve_path(ctx, "", auth_info, cli,
4519                                   client_get_cur_dir(), &targetcli,
4520                                   &targetpath);
4521         if (!NT_STATUS_IS_OK(status)) {
4522                 d_printf("showconnect %s: %s\n", cur_dir, nt_errstr(status));
4523                 return 1;
4524         }
4525
4526         d_printf("//%s/%s\n", smbXcli_conn_remote_name(targetcli->conn), targetcli->share);
4527         return 0;
4528 }
4529
4530 /****************************************************************************
4531  iosize command
4532 ***************************************************************************/
4533
4534 int cmd_iosize(void)
4535 {
4536         TALLOC_CTX *ctx = talloc_tos();
4537         char *buf;
4538         int iosize;
4539
4540         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4541                 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
4542                         if (!smb_encrypt) {
4543                                 d_printf("iosize <n> or iosize 0x<n>. "
4544                                         "Minimum is 0 (default), "
4545                                         "max is 16776960 (0xFFFF00)\n");
4546                         } else {
4547                                 d_printf("iosize <n> or iosize 0x<n>. "
4548                                         "(Encrypted connection) ,"
4549                                         "Minimum is 0 (default), "
4550                                         "max is 130048 (0x1FC00)\n");
4551                         }
4552                 } else {
4553                         d_printf("iosize <n> or iosize 0x<n>.\n");
4554                 }
4555                 return 1;
4556         }
4557
4558         iosize = strtol(buf,NULL,0);
4559         if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
4560                 if (smb_encrypt && (iosize < 0 || iosize > 0xFC00)) {
4561                         d_printf("iosize out of range for encrypted "
4562                                 "connection (min = 0 (default), "
4563                                 "max = 130048 (0x1FC00)\n");
4564                         return 1;
4565                 } else if (!smb_encrypt && (iosize < 0 || iosize > 0xFFFF00)) {
4566                         d_printf("iosize out of range (min = 0 (default), "
4567                                 "max = 16776960 (0xFFFF00)\n");
4568                         return 1;
4569                 }
4570         }
4571
4572         io_bufsize = iosize;
4573         d_printf("iosize is now %d\n", io_bufsize);
4574         return 0;
4575 }
4576
4577 /****************************************************************************
4578  timeout command
4579 ***************************************************************************/
4580
4581 static int cmd_timeout(void)
4582 {
4583         TALLOC_CTX *ctx = talloc_tos();
4584         char *buf;
4585
4586         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4587                 unsigned int old_timeout = cli_set_timeout(cli, 0);
4588                 cli_set_timeout(cli, old_timeout);
4589                 d_printf("timeout <n> (per-operation timeout "
4590                         "in seconds - currently %u).\n",
4591                         old_timeout/1000);
4592                 return 1;
4593         }
4594
4595         io_timeout = strtol(buf,NULL,0);
4596         cli_set_timeout(cli, io_timeout*1000);
4597         d_printf("io_timeout per operation is now %d\n", io_timeout);
4598         return 0;
4599 }
4600
4601
4602 /****************************************************************************
4603 history
4604 ****************************************************************************/
4605 static int cmd_history(void)
4606 {
4607 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
4608         HIST_ENTRY **hlist;
4609         int i;
4610
4611         hlist = history_list();
4612
4613         for (i = 0; hlist && hlist[i]; i++) {
4614                 DEBUG(0, ("%d: %s\n", i, hlist[i]->line));
4615         }
4616 #else
4617         DEBUG(0,("no history without readline support\n"));
4618 #endif
4619
4620         return 0;
4621 }
4622
4623 /* Some constants for completing filename arguments */
4624
4625 #define COMPL_NONE        0          /* No completions */
4626 #define COMPL_REMOTE      1          /* Complete remote filename */
4627 #define COMPL_LOCAL       2          /* Complete local filename */
4628
4629 /* This defines the commands supported by this client.
4630  * NOTE: The "!" must be the last one in the list because it's fn pointer
4631  *       field is NULL, and NULL in that field is used in process_tok()
4632  *       (below) to indicate the end of the list.  crh
4633  */
4634 static struct {
4635         const char *name;
4636         int (*fn)(void);
4637         const char *description;
4638         char compl_args[2];      /* Completion argument info */
4639 } commands[] = {
4640   {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
4641   {"allinfo",cmd_allinfo,"<file> show all available info",
4642    {COMPL_NONE,COMPL_NONE}},
4643   {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
4644   {"archive",cmd_archive,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit",{COMPL_NONE,COMPL_NONE}},
4645   {"backup",cmd_backup,"toggle backup intent state",{COMPL_NONE,COMPL_NONE}},
4646   {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},
4647   {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
4648   {"case_sensitive",cmd_setcase,"toggle the case sensitive flag to server",{COMPL_NONE,COMPL_NONE}},
4649   {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
4650   {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_NONE}},
4651   {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_NONE}},
4652   {"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_NONE}},
4653   {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
4654   {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
4655   {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},
4656   {"echo",cmd_echo,"ping the server",{COMPL_NONE,COMPL_NONE}},
4657   {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
4658   {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
4659   {"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_NONE}},
4660   {"geteas", cmd_geteas, "<file name> get the EA list of a file",
4661    {COMPL_REMOTE, COMPL_NONE}},
4662   {"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},
4663   {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
4664   {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
4665   {"iosize",cmd_iosize,"iosize <number> (default 64512)",{COMPL_NONE,COMPL_NONE}},
4666   {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
4667   {"link",cmd_link,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
4668   {"lock",cmd_lock,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
4669   {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
4670   {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
4671   {"l",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
4672   {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},
4673   {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
4674   {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
4675   {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
4676   {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
4677   {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
4678   {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
4679   {"notify",cmd_notify,"<file>Get notified of dir changes",{COMPL_REMOTE,COMPL_NONE}},
4680   {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
4681   {"posix", cmd_posix, "turn on all POSIX capabilities", {COMPL_REMOTE,COMPL_NONE}},
4682   {"posix_encrypt",cmd_posix_encrypt,"<domain> <user> <password> start up transport encryption",{COMPL_REMOTE,COMPL_NONE}},
4683   {"posix_open",cmd_posix_open,"<name> 0<mode> open_flags mode open a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
4684   {"posix_mkdir",cmd_posix_mkdir,"<name> 0<mode> creates a directory using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
4685   {"posix_rmdir",cmd_posix_rmdir,"<name> removes a directory using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
4686   {"posix_unlink",cmd_posix_unlink,"<name> removes a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
4687   {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
4688   {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
4689   {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
4690   {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
4691   {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
4692   {"queue",cmd_queue,"show the print queue",{COMPL_NONE,COMPL_NONE}},
4693   {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
4694   {"readlink",cmd_readlink,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE,COMPL_REMOTE}},
4695   {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
4696   {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
4697   {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
4698   {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
4699   {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
4700   {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
4701   {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_REMOTE,COMPL_NONE}},
4702   {"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}},
4703   {"setea", cmd_setea, "<file name> <eaname> <eaval> Set an EA of a file",
4704    {COMPL_REMOTE, COMPL_LOCAL}},
4705   {"setmode",cmd_setmode,"<file name> <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
4706   {"stat",cmd_stat,"<file name> Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_NONE}},
4707   {"symlink",cmd_symlink,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
4708   {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},
4709   {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},
4710   {"timeout",cmd_timeout,"timeout <number> - set the per-operation timeout in seconds (default 20)",{COMPL_NONE,COMPL_NONE}},
4711   {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
4712   {"unlock",cmd_unlock,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
4713   {"volume",cmd_volume,"print the volume name",{COMPL_NONE,COMPL_NONE}},
4714   {"vuid",cmd_vuid,"change current vuid",{COMPL_NONE,COMPL_NONE}},
4715   {"wdel",cmd_wdel,"<attrib> <mask> wildcard delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
4716   {"logon",cmd_logon,"establish new logon",{COMPL_NONE,COMPL_NONE}},
4717   {"listconnect",cmd_list_connect,"list open connections",{COMPL_NONE,COMPL_NONE}},
4718   {"showconnect",cmd_show_connect,"display the current active connection",{COMPL_NONE,COMPL_NONE}},
4719   {"tcon",cmd_tcon,"connect to a share" ,{COMPL_NONE,COMPL_NONE}},
4720   {"tdis",cmd_tdis,"disconnect from a share",{COMPL_NONE,COMPL_NONE}},
4721   {"tid",cmd_tid,"show or set the current tid (tree-id)",{COMPL_NONE,COMPL_NONE}},
4722   {"logoff",cmd_logoff,"log off (close the session)",{COMPL_NONE,COMPL_NONE}},
4723   {"..",cmd_cd_oneup,"change the remote directory (up one level)",{COMPL_REMOTE,COMPL_NONE}},
4724
4725   /* Yes, this must be here, see crh's comment above. */
4726   {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
4727   {NULL,NULL,NULL,{COMPL_NONE,COMPL_NONE}}
4728 };
4729
4730 /*******************************************************************
4731  Lookup a command string in the list of commands, including
4732  abbreviations.
4733 ******************************************************************/
4734
4735 static int process_tok(char *tok)
4736 {
4737         int i = 0, matches = 0;
4738         int cmd=0;
4739         int tok_len = strlen(tok);
4740
4741         while (commands[i].fn != NULL) {
4742                 if (strequal(commands[i].name,tok)) {
4743                         matches = 1;
4744                         cmd = i;
4745                         break;
4746                 } else if (strnequal(commands[i].name, tok, tok_len)) {
4747                         matches++;
4748                         cmd = i;
4749                 }
4750                 i++;
4751         }
4752
4753         if (matches == 0)
4754                 return(-1);
4755         else if (matches == 1)
4756                 return(cmd);
4757         else
4758                 return(-2);
4759 }
4760
4761 /****************************************************************************
4762  Help.
4763 ****************************************************************************/
4764
4765 static int cmd_help(void)
4766 {
4767         TALLOC_CTX *ctx = talloc_tos();
4768         int i=0,j;
4769         char *buf;
4770
4771         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4772                 if ((i = process_tok(buf)) >= 0)
4773                         d_printf("HELP %s:\n\t%s\n\n",
4774                                 commands[i].name,commands[i].description);
4775         } else {
4776                 while (commands[i].description) {
4777                         for (j=0; commands[i].description && (j<5); j++) {
4778                                 d_printf("%-15s",commands[i].name);
4779                                 i++;
4780                         }
4781                         d_printf("\n");
4782                 }
4783         }
4784         return 0;
4785 }
4786
4787 /****************************************************************************
4788  Process a -c command string.
4789 ****************************************************************************/
4790
4791 static int process_command_string(const char *cmd_in)
4792 {
4793         TALLOC_CTX *ctx = talloc_tos();
4794         char *cmd = talloc_strdup(ctx, cmd_in);
4795         int rc = 0;
4796
4797         if (!cmd) {
4798                 return 1;
4799         }
4800         /* establish the connection if not already */
4801
4802         if (!cli) {
4803                 NTSTATUS status;
4804
4805                 status = cli_cm_open(talloc_tos(), NULL,
4806                                      have_ip ? dest_ss_str : desthost,
4807                                      service, auth_info,
4808                                      true, smb_encrypt,
4809                                      max_protocol, port, name_type,
4810                                      &cli);
4811                 if (!NT_STATUS_IS_OK(status)) {
4812                         return 1;
4813                 }
4814                 cli_set_timeout(cli, io_timeout*1000);
4815         }
4816
4817         while (cmd[0] != '\0')    {
4818                 char *line;
4819                 char *p;
4820                 char *tok;
4821                 int i;
4822
4823                 if ((p = strchr_m(cmd, ';')) == 0) {
4824                         line = cmd;
4825                         cmd += strlen(cmd);
4826                 } else {
4827                         *p = '\0';
4828                         line = cmd;
4829                         cmd = p + 1;
4830                 }
4831
4832                 /* and get the first part of the command */
4833                 cmd_ptr = line;
4834                 if (!next_token_talloc(ctx, &cmd_ptr,&tok,NULL)) {
4835                         continue;
4836                 }
4837
4838                 if ((i = process_tok(tok)) >= 0) {
4839                         rc = commands[i].fn();
4840                 } else if (i == -2) {
4841                         d_printf("%s: command abbreviation ambiguous\n",tok);
4842                 } else {
4843                         d_printf("%s: command not found\n",tok);
4844                 }
4845         }
4846
4847         return rc;
4848 }
4849
4850 #define MAX_COMPLETIONS 100
4851
4852 struct completion_remote {
4853         char *dirmask;
4854         char **matches;
4855         int count, samelen;
4856         const char *text;
4857         int len;
4858 };
4859
4860 static NTSTATUS completion_remote_filter(const char *mnt,
4861                                 struct file_info *f,
4862                                 const char *mask,
4863                                 void *state)
4864 {
4865         struct completion_remote *info = (struct completion_remote *)state;
4866
4867         if (info->count >= MAX_COMPLETIONS - 1) {
4868                 return NT_STATUS_OK;
4869         }
4870         if (strncmp(info->text, f->name, info->len) != 0) {
4871                 return NT_STATUS_OK;
4872         }
4873         if (ISDOT(f->name) || ISDOTDOT(f->name)) {
4874                 return NT_STATUS_OK;
4875         }
4876
4877         if ((info->dirmask[0] == 0) && !(f->mode & FILE_ATTRIBUTE_DIRECTORY))
4878                 info->matches[info->count] = SMB_STRDUP(f->name);
4879         else {
4880                 TALLOC_CTX *ctx = talloc_stackframe();
4881                 char *tmp;
4882
4883                 tmp = talloc_strdup(ctx,info->dirmask);
4884                 if (!tmp) {
4885                         TALLOC_FREE(ctx);
4886                         return NT_STATUS_NO_MEMORY;
4887                 }
4888                 tmp = talloc_asprintf_append(tmp, "%s", f->name);
4889                 if (!tmp) {
4890                         TALLOC_FREE(ctx);
4891                         return NT_STATUS_NO_MEMORY;
4892                 }
4893                 if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
4894                         tmp = talloc_asprintf_append(tmp, "%s",
4895                                                      CLI_DIRSEP_STR);
4896                 }
4897                 if (!tmp) {
4898                         TALLOC_FREE(ctx);
4899                         return NT_STATUS_NO_MEMORY;
4900                 }
4901                 info->matches[info->count] = SMB_STRDUP(tmp);
4902                 TALLOC_FREE(ctx);
4903         }
4904         if (info->matches[info->count] == NULL) {
4905                 return NT_STATUS_OK;
4906         }
4907         if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
4908                 smb_readline_ca_char(0);
4909         }
4910         if (info->count == 1) {
4911                 info->samelen = strlen(info->matches[info->count]);
4912         } else {
4913                 while (strncmp(info->matches[info->count],
4914                                info->matches[info->count-1],
4915                                info->samelen) != 0) {
4916                         info->samelen--;
4917                 }
4918         }
4919         info->count++;
4920         return NT_STATUS_OK;
4921 }
4922
4923 static char **remote_completion(const char *text, int len)
4924 {
4925         TALLOC_CTX *ctx = talloc_stackframe();
4926         char *dirmask = NULL;
4927         char *targetpath = NULL;
4928         struct cli_state *targetcli = NULL;
4929         int i;
4930         struct completion_remote info = { NULL, NULL, 1, 0, NULL, 0 };
4931         NTSTATUS status;
4932
4933         /* can't have non-static initialisation on Sun CC, so do it
4934            at run time here */
4935         info.samelen = len;
4936         info.text = text;
4937         info.len = len;
4938
4939         info.matches = SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS);
4940         if (!info.matches) {
4941                 TALLOC_FREE(ctx);
4942                 return NULL;
4943         }
4944
4945         /*
4946          * We're leaving matches[0] free to fill it later with the text to
4947          * display: Either the one single match or the longest common subset
4948          * of the matches.
4949          */
4950         info.matches[0] = NULL;
4951         info.count = 1;
4952
4953         for (i = len-1; i >= 0; i--) {
4954                 if ((text[i] == '/') || (text[i] == CLI_DIRSEP_CHAR)) {
4955                         break;
4956                 }
4957         }
4958
4959         info.text = text+i+1;
4960         info.samelen = info.len = len-i-1;
4961
4962         if (i > 0) {
4963                 info.dirmask = SMB_MALLOC_ARRAY(char, i+2);
4964                 if (!info.dirmask) {
4965                         goto cleanup;
4966                 }
4967                 strncpy(info.dirmask, text, i+1);
4968                 info.dirmask[i+1] = 0;
4969                 dirmask = talloc_asprintf(ctx,
4970                                         "%s%*s*",
4971                                         client_get_cur_dir(),
4972                                         i-1,
4973                                         text);
4974         } else {
4975                 info.dirmask = SMB_STRDUP("");
4976                 if (!info.dirmask) {
4977                         goto cleanup;
4978                 }
4979                 dirmask = talloc_asprintf(ctx,
4980                                         "%s*",
4981                                         client_get_cur_dir());
4982         }
4983         if (!dirmask) {
4984                 goto cleanup;
4985         }
4986
4987         status = cli_resolve_path(ctx, "", auth_info, cli, dirmask, &targetcli,
4988                                   &targetpath);
4989         if (!NT_STATUS_IS_OK(status)) {
4990                 goto cleanup;
4991         }
4992         status = cli_list(targetcli, targetpath, FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
4993                           completion_remote_filter, (void *)&info);
4994         if (!NT_STATUS_IS_OK(status)) {
4995                 goto cleanup;
4996         }
4997
4998         if (info.count == 1) {
4999                 /*
5000                  * No matches at all, NULL indicates there is nothing
5001                  */
5002                 SAFE_FREE(info.matches[0]);
5003                 SAFE_FREE(info.matches);
5004                 TALLOC_FREE(ctx);
5005                 return NULL;
5006         }
5007
5008         if (info.count == 2) {
5009                 /*
5010                  * Exactly one match in matches[1], indicate this is the one
5011                  * in matches[0].
5012                  */
5013                 info.matches[0] = info.matches[1];
5014                 info.matches[1] = NULL;
5015                 info.count -= 1;
5016                 TALLOC_FREE(ctx);
5017                 return info.matches;
5018         }
5019
5020         /*
5021          * We got more than one possible match, set the result to the maximum
5022          * common subset
5023          */
5024
5025         info.matches[0] = SMB_STRNDUP(info.matches[1], info.samelen);
5026         info.matches[info.count] = NULL;
5027         TALLOC_FREE(ctx);
5028         return info.matches;
5029
5030 cleanup:
5031         for (i = 0; i < info.count; i++) {
5032                 SAFE_FREE(info.matches[i]);
5033         }
5034         SAFE_FREE(info.matches);
5035         SAFE_FREE(info.dirmask);
5036         TALLOC_FREE(ctx);
5037         return NULL;
5038 }
5039
5040 static char **completion_fn(const char *text, int start, int end)
5041 {
5042         smb_readline_ca_char(' ');
5043
5044         if (start) {
5045                 const char *buf, *sp;
5046                 int i;
5047                 char compl_type;
5048
5049                 buf = smb_readline_get_line_buffer();
5050                 if (buf == NULL)
5051                         return NULL;
5052
5053                 sp = strchr(buf, ' ');
5054                 if (sp == NULL)
5055                         return NULL;
5056
5057                 for (i = 0; commands[i].name; i++) {
5058                         if ((strncmp(commands[i].name, buf, sp - buf) == 0) &&
5059                             (commands[i].name[sp - buf] == 0)) {
5060                                 break;
5061                         }
5062                 }
5063                 if (commands[i].name == NULL)
5064                         return NULL;
5065
5066                 while (*sp == ' ')
5067                         sp++;
5068
5069                 if (sp == (buf + start))
5070                         compl_type = commands[i].compl_args[0];
5071                 else
5072                         compl_type = commands[i].compl_args[1];
5073
5074                 if (compl_type == COMPL_REMOTE)
5075                         return remote_completion(text, end - start);
5076                 else /* fall back to local filename completion */
5077                         return NULL;
5078         } else {
5079                 char **matches;
5080                 int i, len, samelen = 0, count=1;
5081
5082                 matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
5083                 if (!matches) {
5084                         return NULL;
5085                 }
5086                 matches[0] = NULL;
5087
5088                 len = strlen(text);
5089                 for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
5090                         if (strncmp(text, commands[i].name, len) == 0) {
5091                                 matches[count] = SMB_STRDUP(commands[i].name);
5092                                 if (!matches[count])
5093                                         goto cleanup;
5094                                 if (count == 1)
5095                                         samelen = strlen(matches[count]);
5096                                 else
5097                                         while (strncmp(matches[count], matches[count-1], samelen) != 0)
5098                                                 samelen--;
5099                                 count++;
5100                         }
5101                 }
5102
5103                 switch (count) {
5104                 case 0: /* should never happen */
5105                 case 1:
5106                         goto cleanup;
5107                 case 2:
5108                         matches[0] = SMB_STRDUP(matches[1]);
5109                         break;
5110                 default:
5111                         matches[0] = (char *)SMB_MALLOC(samelen+1);
5112                         if (!matches[0])
5113                                 goto cleanup;
5114                         strncpy(matches[0], matches[1], samelen);
5115                         matches[0][samelen] = 0;
5116                 }
5117                 matches[count] = NULL;
5118                 return matches;
5119
5120 cleanup:
5121                 for (i = 0; i < count; i++)
5122                         free(matches[i]);
5123
5124                 free(matches);
5125                 return NULL;
5126         }
5127 }
5128
5129 static bool finished;
5130
5131 /****************************************************************************
5132  Make sure we swallow keepalives during idle time.
5133 ****************************************************************************/
5134
5135 static void readline_callback(void)
5136 {
5137         static time_t last_t;
5138         struct timespec now;
5139         time_t t;
5140         NTSTATUS status;
5141         unsigned char garbage[16];
5142
5143         clock_gettime_mono(&now);
5144         t = now.tv_sec;
5145
5146         if (t - last_t < 5)
5147                 return;
5148
5149         last_t = t;
5150
5151         /* Ping the server to keep the connection alive using SMBecho. */
5152         memset(garbage, 0xf0, sizeof(garbage));
5153         status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
5154         if (NT_STATUS_IS_OK(status)) {
5155                 return;
5156         }
5157
5158         if (!cli_state_is_connected(cli)) {
5159                 DEBUG(0,("SMBecho failed (%s). The connection is "
5160                          "disconnected now\n", nt_errstr(status)));
5161                 finished = true;
5162                 smb_readline_done();
5163         }
5164 }
5165
5166 /****************************************************************************
5167  Process commands on stdin.
5168 ****************************************************************************/
5169
5170 static int process_stdin(void)
5171 {
5172         int rc = 0;
5173
5174         while (!finished) {
5175                 TALLOC_CTX *frame = talloc_stackframe();
5176                 char *tok = NULL;
5177                 char *the_prompt = NULL;
5178                 char *line = NULL;
5179                 int i;
5180
5181                 /* display a prompt */
5182                 if (asprintf(&the_prompt, "smb: %s> ", client_get_cur_dir()) < 0) {
5183                         TALLOC_FREE(frame);
5184                         break;
5185                 }
5186                 line = smb_readline(the_prompt, readline_callback, completion_fn);
5187                 SAFE_FREE(the_prompt);
5188                 if (!line) {
5189                         TALLOC_FREE(frame);
5190                         break;
5191                 }
5192
5193                 /* special case - first char is ! */
5194                 if (*line == '!') {
5195                         if (system(line + 1) == -1) {
5196                                 d_printf("system() command %s failed.\n",
5197                                         line+1);
5198                         }
5199                         SAFE_FREE(line);
5200                         TALLOC_FREE(frame);
5201                         continue;
5202                 }
5203
5204                 /* and get the first part of the command */
5205                 cmd_ptr = line;
5206                 if (!next_token_talloc(frame, &cmd_ptr,&tok,NULL)) {
5207                         TALLOC_FREE(frame);
5208                         SAFE_FREE(line);
5209                         continue;
5210                 }
5211
5212                 if ((i = process_tok(tok)) >= 0) {
5213                         rc = commands[i].fn();
5214                 } else if (i == -2) {
5215                         d_printf("%s: command abbreviation ambiguous\n",tok);
5216                 } else {
5217                         d_printf("%s: command not found\n",tok);
5218                 }
5219                 SAFE_FREE(line);
5220                 TALLOC_FREE(frame);
5221         }
5222         return rc;
5223 }
5224
5225 /****************************************************************************
5226  Process commands from the client.
5227 ****************************************************************************/
5228
5229 static int process(const char *base_directory)
5230 {
5231         int rc = 0;
5232         NTSTATUS status;
5233
5234         status = cli_cm_open(talloc_tos(), NULL,
5235                              have_ip ? dest_ss_str : desthost,
5236                              service, auth_info, true, smb_encrypt,
5237                              max_protocol, port, name_type, &cli);
5238         if (!NT_STATUS_IS_OK(status)) {
5239                 return 1;
5240         }
5241
5242         cli_set_timeout(cli, io_timeout*1000);
5243
5244         if (base_directory && *base_directory) {
5245                 rc = do_cd(base_directory);
5246                 if (rc) {
5247                         cli_shutdown(cli);
5248                         return rc;
5249                 }
5250         }
5251
5252         if (cmdstr) {
5253                 rc = process_command_string(cmdstr);
5254         } else {
5255                 process_stdin();
5256         }
5257
5258         cli_shutdown(cli);
5259         return rc;
5260 }
5261
5262 /****************************************************************************
5263  Handle a -L query.
5264 ****************************************************************************/
5265
5266 static int do_host_query(const char *query_host)
5267 {
5268         NTSTATUS status;
5269
5270         status = cli_cm_open(talloc_tos(), NULL,
5271                              have_ip ? dest_ss_str : query_host,
5272                              "IPC$", auth_info, true, smb_encrypt,
5273                              max_protocol, port, name_type, &cli);
5274         if (!NT_STATUS_IS_OK(status)) {
5275                 return 1;
5276         }
5277
5278         cli_set_timeout(cli, io_timeout*1000);
5279         browse_host(true);
5280
5281         /* Ensure that the host can do IPv4 */
5282
5283         if (!interpret_addr(query_host)) {
5284                 struct sockaddr_storage ss;
5285                 if (interpret_string_addr(&ss, query_host, 0) &&
5286                                 (ss.ss_family != AF_INET)) {
5287                         d_printf("%s is an IPv6 address -- no workgroup available\n",
5288                                 query_host);
5289                         return 1;
5290                 }
5291         }
5292
5293         if (port != NBT_SMB_PORT) {
5294
5295                 /* Workgroups simply don't make sense over anything
5296                    else but port 139... */
5297
5298                 cli_shutdown(cli);
5299                 status = cli_cm_open(talloc_tos(), NULL,
5300                                      have_ip ? dest_ss_str : query_host,
5301                                      "IPC$", auth_info, true, smb_encrypt,
5302                                      max_protocol, NBT_SMB_PORT, name_type,
5303                                      &cli);
5304                 if (!NT_STATUS_IS_OK(status)) {
5305                         cli = NULL;
5306                 }
5307         }
5308
5309         if (cli == NULL) {
5310                 d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
5311                 return 1;
5312         }
5313
5314         cli_set_timeout(cli, io_timeout*1000);
5315         list_servers(lp_workgroup());
5316
5317         cli_shutdown(cli);
5318
5319         return(0);
5320 }
5321
5322 /****************************************************************************
5323  Handle a tar operation.
5324 ****************************************************************************/
5325
5326 static int do_tar_op(const char *base_directory)
5327 {
5328         int ret;
5329
5330         /* do we already have a connection? */
5331         if (!cli) {
5332                 NTSTATUS status;
5333
5334                 status = cli_cm_open(talloc_tos(), NULL,
5335                                      have_ip ? dest_ss_str : desthost,
5336                                      service, auth_info, true, smb_encrypt,
5337                                      max_protocol, port, name_type, &cli);
5338                 if (!NT_STATUS_IS_OK(status)) {
5339                         return 1;
5340                 }
5341                 cli_set_timeout(cli, io_timeout*1000);
5342         }
5343
5344         recurse=true;
5345
5346         if (base_directory && *base_directory)  {
5347                 ret = do_cd(base_directory);
5348                 if (ret) {
5349                         cli_shutdown(cli);
5350                         return ret;
5351                 }
5352         }
5353
5354         ret=process_tar();
5355
5356         cli_shutdown(cli);
5357
5358         return(ret);
5359 }
5360
5361 /****************************************************************************
5362  Handle a message operation.
5363 ****************************************************************************/
5364
5365 static int do_message_op(struct user_auth_info *a_info)
5366 {
5367         NTSTATUS status;
5368
5369         status = cli_connect_nb(desthost, have_ip ? &dest_ss : NULL,
5370                                 port ? port : NBT_SMB_PORT, name_type,
5371                                 lp_netbios_name(), SMB_SIGNING_DEFAULT, 0, &cli);
5372         if (!NT_STATUS_IS_OK(status)) {
5373                 d_printf("Connection to %s failed. Error %s\n", desthost, nt_errstr(status));
5374                 return 1;
5375         }
5376
5377         cli_set_timeout(cli, io_timeout*1000);
5378         send_message(get_cmdline_auth_info_username(a_info));
5379         cli_shutdown(cli);
5380
5381         return 0;
5382 }
5383
5384 /****************************************************************************
5385   main program
5386 ****************************************************************************/
5387
5388  int main(int argc,char *argv[])
5389 {
5390         const char **const_argv = discard_const_p(const char *, argv);
5391         char *base_directory = NULL;
5392         int opt;
5393         char *query_host = NULL;
5394         bool message = false;
5395         static const char *new_name_resolve_order = NULL;
5396         poptContext pc;
5397         char *p;
5398         int rc = 0;
5399         bool tar_opt = false;
5400         bool service_opt = false;
5401         struct poptOption long_options[] = {
5402                 POPT_AUTOHELP
5403
5404                 { "name-resolve", 'R', POPT_ARG_STRING, &new_name_resolve_order, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },
5405                 { "message", 'M', POPT_ARG_STRING, NULL, 'M', "Send message", "HOST" },
5406                 { "ip-address", 'I', POPT_ARG_STRING, NULL, 'I', "Use this IP to connect to", "IP" },
5407                 { "stderr", 'E', POPT_ARG_NONE, NULL, 'E', "Write messages to stderr instead of stdout" },
5408                 { "list", 'L', POPT_ARG_STRING, NULL, 'L', "Get a list of shares available on a host", "HOST" },
5409                 { "max-protocol", 'm', POPT_ARG_STRING, NULL, 'm', "Set the max protocol level", "LEVEL" },
5410                 { "tar", 'T', POPT_ARG_STRING, NULL, 'T', "Command line tar", "<c|x>IXFqgbNan" },
5411                 { "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
5412                 { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },
5413                 { "send-buffer", 'b', POPT_ARG_INT, &io_bufsize, 'b', "Changes the transmit/send buffer", "BYTES" },
5414                 { "timeout", 't', POPT_ARG_INT, &io_timeout, 'b', "Changes the per-operation timeout", "SECONDS" },
5415                 { "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
5416                 { "grepable", 'g', POPT_ARG_NONE, NULL, 'g', "Produce grepable output" },
5417                 { "browse", 'B', POPT_ARG_NONE, NULL, 'B', "Browse SMB servers using DNS" },
5418                 POPT_COMMON_SAMBA
5419                 POPT_COMMON_CONNECTION
5420                 POPT_COMMON_CREDENTIALS
5421                 POPT_TABLEEND
5422         };
5423         TALLOC_CTX *frame = talloc_stackframe();
5424
5425         if (!client_set_cur_dir("\\")) {
5426                 exit(ENOMEM);
5427         }
5428
5429         /* set default debug level to 1 regardless of what smb.conf sets */
5430         setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
5431         load_case_tables();
5432
5433         lp_set_cmdline("log level", "1");
5434
5435         auth_info = user_auth_info_init(frame);
5436         if (auth_info == NULL) {
5437                 exit(1);
5438         }
5439         popt_common_set_auth_info(auth_info);
5440
5441         /* skip argv(0) */
5442         pc = poptGetContext("smbclient", argc, const_argv, long_options, 0);
5443         poptSetOtherOptionHelp(pc, "service <password>");
5444
5445         while ((opt = poptGetNextOpt(pc)) != -1) {
5446
5447                 /* if the tar option has been called previouslt, now we need to eat out the leftovers */
5448                 /* I see no other way to keep things sane --SSS */
5449                 if (tar_opt == true) {
5450                         while (poptPeekArg(pc)) {
5451                                 poptGetArg(pc);
5452                         }
5453                         tar_opt = false;
5454                 }
5455
5456                 /* if the service has not yet been specified lets see if it is available in the popt stack */
5457                 if (!service_opt && poptPeekArg(pc)) {
5458                         service = talloc_strdup(frame, poptGetArg(pc));
5459                         if (!service) {
5460                                 exit(ENOMEM);
5461                         }
5462                         service_opt = true;
5463                 }
5464
5465                 /* if the service has already been retrieved then check if we have also a password */
5466                 if (service_opt
5467                     && (!get_cmdline_auth_info_got_pass(auth_info))
5468                     && poptPeekArg(pc)) {
5469                         set_cmdline_auth_info_password(auth_info,
5470                                                        poptGetArg(pc));
5471                 }
5472
5473
5474                 switch (opt) {
5475                 case 'M':
5476                         /* Messages are sent to NetBIOS name type 0x3
5477                          * (Messenger Service).  Make sure we default
5478                          * to port 139 instead of port 445. srl,crh
5479                          */
5480                         name_type = 0x03;
5481                         desthost = talloc_strdup(frame,poptGetOptArg(pc));
5482                         if (!desthost) {
5483                                 exit(ENOMEM);
5484                         }
5485                         if( !port )
5486                                 port = NBT_SMB_PORT;
5487                         message = true;
5488                         break;
5489                 case 'I':
5490                         {
5491                                 if (!interpret_string_addr(&dest_ss, poptGetOptArg(pc), 0)) {
5492                                         exit(1);
5493                                 }
5494                                 have_ip = true;
5495                                 print_sockaddr(dest_ss_str, sizeof(dest_ss_str), &dest_ss);
5496                         }
5497                         break;
5498                 case 'E':
5499                         setup_logging("smbclient", DEBUG_STDERR );
5500                         display_set_stderr();
5501                         break;
5502
5503                 case 'L':
5504                         query_host = talloc_strdup(frame, poptGetOptArg(pc));
5505                         if (!query_host) {
5506                                 exit(ENOMEM);
5507                         }
5508                         break;
5509                 case 'm':
5510                         lp_set_cmdline("client max protocol", poptGetOptArg(pc));
5511                         break;
5512                 case 'T':
5513                         /* We must use old option processing for this. Find the
5514                          * position of the -T option in the raw argv[]. */
5515                         {
5516                                 int i;
5517                                 extern struct tar tar_ctx;
5518
5519                                 for (i = 1; i < argc; i++) {
5520                                         if (strncmp("-T", argv[i],2)==0)
5521                                                 break;
5522                                 }
5523                                 i++;
5524                                 if (!tar_parse_args(&tar_ctx, poptGetOptArg(pc), argv + i, argc - i)) {
5525                                         poptPrintUsage(pc, stderr, 0);
5526                                         exit(1);
5527                                 }
5528                         }
5529                         /* this must be the last option, mark we have parsed it so that we know we have */
5530                         tar_opt = true;
5531                         break;
5532                 case 'D':
5533                         base_directory = talloc_strdup(frame, poptGetOptArg(pc));
5534                         if (!base_directory) {
5535                                 exit(ENOMEM);
5536                         }
5537                         break;
5538                 case 'g':
5539                         grepable=true;
5540                         break;
5541                 case 'e':
5542                         smb_encrypt=true;
5543                         break;
5544                 case 'B':
5545                         return(do_smb_browse());
5546
5547                 }
5548         }
5549
5550         /* We may still have some leftovers after the last popt option has been called */
5551         if (tar_opt == true) {
5552                 while (poptPeekArg(pc)) {
5553                         poptGetArg(pc);
5554                 }
5555                 tar_opt = false;
5556         }
5557
5558         /* if the service has not yet been specified lets see if it is available in the popt stack */
5559         if (!service_opt && poptPeekArg(pc)) {
5560                 service = talloc_strdup(frame,poptGetArg(pc));
5561                 if (!service) {
5562                         exit(ENOMEM);
5563                 }
5564                 service_opt = true;
5565         }
5566
5567         /* if the service has already been retrieved then check if we have also a password */
5568         if (service_opt
5569             && !get_cmdline_auth_info_got_pass(auth_info)
5570             && poptPeekArg(pc)) {
5571                 set_cmdline_auth_info_password(auth_info,
5572                                                poptGetArg(pc));
5573         }
5574
5575         if ( override_logfile )
5576                 setup_logging( lp_logfile(talloc_tos()), DEBUG_FILE );
5577
5578         if (!lp_load_client(get_dyn_CONFIGFILE())) {
5579                 fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",
5580                         argv[0], get_dyn_CONFIGFILE());
5581         }
5582
5583         if (get_cmdline_auth_info_use_machine_account(auth_info) &&
5584             !set_cmdline_auth_info_machine_account_creds(auth_info)) {
5585                 exit(-1);
5586         }
5587
5588         load_interfaces();
5589
5590         if (service_opt && service) {
5591                 size_t len;
5592
5593                 /* Convert any '/' characters in the service name to '\' characters */
5594                 string_replace(service, '/','\\');
5595                 if (count_chars(service,'\\') < 3) {
5596                         d_printf("\n%s: Not enough '\\' characters in service\n",service);
5597                         poptPrintUsage(pc, stderr, 0);
5598                         exit(1);
5599                 }
5600                 /* Remove trailing slashes */
5601                 len = strlen(service);
5602                 while(len > 0 && service[len - 1] == '\\') {
5603                         --len;
5604                         service[len] = '\0';
5605                 }
5606         }
5607
5608         smb_encrypt = get_cmdline_auth_info_smb_encrypt(auth_info);
5609         if (!init_names()) {
5610                 fprintf(stderr, "init_names() failed\n");
5611                 exit(1);
5612         }
5613
5614         if(new_name_resolve_order)
5615                 lp_set_cmdline("name resolve order", new_name_resolve_order);
5616
5617         if (!tar_type && !query_host && !service && !message) {
5618                 poptPrintUsage(pc, stderr, 0);
5619                 exit(1);
5620         }
5621
5622         poptFreeContext(pc);
5623         popt_burn_cmdline_password(argc, argv);
5624
5625         DEBUG(3,("Client started (version %s).\n", samba_version_string()));
5626
5627         /* Ensure we have a password (or equivalent). */
5628         set_cmdline_auth_info_getpass(auth_info);
5629
5630         max_protocol = lp_client_max_protocol();
5631
5632         if (tar_type) {
5633                 if (cmdstr)
5634                         process_command_string(cmdstr);
5635                 rc = do_tar_op(base_directory);
5636         } else if (query_host && *query_host) {
5637                 char *qhost = query_host;
5638                 char *slash;
5639
5640                 while (*qhost == '\\' || *qhost == '/')
5641                         qhost++;
5642
5643                 if ((slash = strchr_m(qhost, '/'))
5644                     || (slash = strchr_m(qhost, '\\'))) {
5645                         *slash = 0;
5646                 }
5647
5648                 if ((p=strchr_m(qhost, '#'))) {
5649                         *p = 0;
5650                         p++;
5651                         sscanf(p, "%x", &name_type);
5652                 }
5653
5654                 rc = do_host_query(qhost);
5655         } else if (message) {
5656                 rc = do_message_op(auth_info);
5657         } else if (process(base_directory)) {
5658                 rc = 1;
5659         }
5660
5661         TALLOC_FREE(frame);
5662         return rc;
5663 }