source4/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-2004
   7    Copyright (C) James J Myers   2003 <myersjj@samba.org>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "version.h"
  26 #include "libcli/libcli.h"
  27 #include "lib/cmdline/popt_common.h"
  28 #include "librpc/gen_ndr/ndr_srvsvc.h"
  29 #include "librpc/gen_ndr/ndr_lsa.h"
  30 #include "libcli/raw/libcliraw.h"
  31 #include "system/dir.h"
  32 #include "system/filesys.h"
  33 #include "dlinklist.h"
  34 #include "system/readline.h"
  35 #include "auth/gensec/gensec.h"
  36 #include "system/time.h" /* needed by some systems for asctime() */
  37
  38 static int io_bufsize = 64512;
  39
  40 struct smbclient_context {
  41         char *remote_cur_dir;
  42         struct smbcli_state *cli;
  43         char *fileselection;
  44         time_t newer_than;
  45         BOOL prompt;
  46         BOOL recurse;
  47         int archive_level;
  48         BOOL lowercase;
  49         int printmode;
  50         BOOL translation;
  51 };
  52
  53 /* timing globals */
  54 static uint64_t get_total_size = 0;
  55 static uint_t get_total_time_ms = 0;
  56 static uint64_t put_total_size = 0;
  57 static uint_t put_total_time_ms = 0;
  58
  59 /* Unfortunately, there is no way to pass the a context to the completion function as an argument */
  60 static struct smbclient_context *rl_ctx;
  61
  62 /* totals globals */
  63 static double dir_total;
  64
  65 /*******************************************************************
  66  Reduce a file name, removing .. elements.
  67 ********************************************************************/
  68 void dos_clean_name(char *s)
  69 {
  70         char *p=NULL,*r;
  71
  72         DEBUG(3,("dos_clean_name [%s]\n",s));
  73
  74         /* remove any double slashes */
  75         all_string_sub(s, "\\\\", "\\", 0);
  76
  77         while ((p = strstr(s,"\\..\\")) != NULL) {
  78                 *p = '\0';
  79                 if ((r = strrchr(s,'\\')) != NULL)
  80                         memmove(r,p+3,strlen(p+3)+1);
  81         }
  82
  83         trim_string(s,NULL,"\\..");
  84
  85         all_string_sub(s, "\\.\\", "\\", 0);
  86 }
  87
  88 /****************************************************************************
  89 write to a local file with CR/LF->LF translation if appropriate. return the
  90 number taken from the buffer. This may not equal the number written.
  91 ****************************************************************************/
  92 static int writefile(int f, const void *_b, int n, BOOL translation)
  93 {
  94         const uint8_t *b = _b;
  95         int i;
  96
  97         if (!translation) {
  98                 return write(f,b,n);
  99         }
 100
 101         i = 0;
 102         while (i < n) {
 103                 if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
 104                         b++;i++;
 105                 }
 106                 if (write(f, b, 1) != 1) {
 107                         break;
 108                 }
 109                 b++;
 110                 i++;
 111         }
 112
 113         return(i);
 114 }
 115
 116 /****************************************************************************
 117   read from a file with LF->CR/LF translation if appropriate. return the
 118   number read. read approx n bytes.
 119 ****************************************************************************/
 120 static int readfile(void *_b, int n, XFILE *f, BOOL translation)
 121 {
 122         uint8_t *b = _b;
 123         int i;
 124         int c;
 125
 126         if (!translation)
 127                 return x_fread(b,1,n,f);
 128
 129         i = 0;
 130         while (i < (n - 1)) {
 131                 if ((c = x_getc(f)) == EOF) {
 132                         break;
 133                 }
 134
 135                 if (c == '\n') { /* change all LFs to CR/LF */
 136                         b[i++] = '\r';
 137                 }
 138
 139                 b[i++] = c;
 140         }
 141
 142         return(i);
 143 }
 144
 145
 146 /****************************************************************************
 147 send a message
 148 ****************************************************************************/
 149 static void send_message(struct smbcli_state *cli, const char *desthost)
 150 {
 151         char msg[1600];
 152         int total_len = 0;
 153         int grp_id;
 154
 155         if (!smbcli_message_start(cli->tree, desthost, cli_credentials_get_username(cmdline_credentials), &grp_id)) {
 156                 d_printf("message start: %s\n", smbcli_errstr(cli->tree));
 157                 return;
 158         }
 159
 160
 161         d_printf("Connected. Type your message, ending it with a Control-D\n");
 162
 163         while (!feof(stdin) && total_len < 1600) {
 164                 int maxlen = MIN(1600 - total_len,127);
 165                 int l=0;
 166                 int c;
 167
 168                 for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
 169                         if (c == '\n')
 170                                 msg[l++] = '\r';
 171                         msg[l] = c;
 172                 }
 173
 174                 if (!smbcli_message_text(cli->tree, msg, l, grp_id)) {
 175                         d_printf("SMBsendtxt failed (%s)\n",smbcli_errstr(cli->tree));
 176                         return;
 177                 }
 178
 179                 total_len += l;
 180         }
 181
 182         if (total_len >= 1600)
 183                 d_printf("the message was truncated to 1600 bytes\n");
 184         else
 185                 d_printf("sent %d bytes\n",total_len);
 186
 187         if (!smbcli_message_end(cli->tree, grp_id)) {
 188                 d_printf("SMBsendend failed (%s)\n",smbcli_errstr(cli->tree));
 189                 return;
 190         }
 191 }
 192
 193
 194
 195 /****************************************************************************
 196 check the space on a device
 197 ****************************************************************************/
 198 static int do_dskattr(struct smbclient_context *ctx)
 199 {
 200         int total, bsize, avail;
 201
 202         if (NT_STATUS_IS_ERR(smbcli_dskattr(ctx->cli->tree, &bsize, &total, &avail))) {
 203                 d_printf("Error in dskattr: %s\n",smbcli_errstr(ctx->cli->tree));
 204                 return 1;
 205         }
 206
 207         d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
 208                  total, bsize, avail);
 209
 210         return 0;
 211 }
 212
 213 /****************************************************************************
 214 show cd/pwd
 215 ****************************************************************************/
 216 static int cmd_pwd(struct smbclient_context *ctx, const char **args)
 217 {
 218         d_printf("Current directory is %s\n", ctx->remote_cur_dir);
 219         return 0;
 220 }
 221
 222 /*
 223   convert a string to dos format
 224 */
 225 static void dos_format(char *s)
 226 {
 227         string_replace(s, '/', '\\');
 228 }
 229
 230 /****************************************************************************
 231 change directory - inner section
 232 ****************************************************************************/
 233 static int do_cd(struct smbclient_context *ctx, const char *newdir)
 234 {
 235         char *dname;
 236
 237         /* Save the current directory in case the
 238            new directory is invalid */
 239         if (newdir[0] == '\\')
 240                 dname = talloc_strdup(NULL, newdir);
 241         else
 242                 dname = talloc_asprintf(NULL, "%s\\%s", ctx->remote_cur_dir, newdir);
 243
 244         dos_format(dname);
 245
 246         if (*(dname+strlen(dname)-1) != '\\') {
 247                 dname = talloc_append_string(NULL, dname, "\\");
 248         }
 249         dos_clean_name(dname);
 250
 251         if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx->cli->tree, dname))) {
 252                 d_printf("cd %s: %s\n", dname, smbcli_errstr(ctx->cli->tree));
 253                 talloc_free(dname);
 254         } else {
 255                 ctx->remote_cur_dir = dname;
 256         }
 257
 258         return 0;
 259 }
 260
 261 /****************************************************************************
 262 change directory
 263 ****************************************************************************/
 264 static int cmd_cd(struct smbclient_context *ctx, const char **args)
 265 {
 266         int rc = 0;
 267
 268         if (args[1])
 269                 rc = do_cd(ctx, args[1]);
 270         else
 271                 d_printf("Current directory is %s\n",ctx->remote_cur_dir);
 272
 273         return rc;
 274 }
 275
 276
 277 BOOL mask_match(struct smbcli_state *c, const char *string, const char *pattern,
 278                 BOOL is_case_sensitive)
 279 {
 280         char *p2, *s2;
 281         BOOL ret;
 282
 283         if (strcmp(string,"..") == 0)
 284                 string = ".";
 285         if (strcmp(pattern,".") == 0)
 286                 return False;
 287
 288         if (is_case_sensitive)
 289                 return ms_fnmatch(pattern, string,
 290                                   c->transport->negotiate.protocol) == 0;
 291
 292         p2 = strlower_talloc(NULL, pattern);
 293         s2 = strlower_talloc(NULL, string);
 294         ret = ms_fnmatch(p2, s2, c->transport->negotiate.protocol) == 0;
 295         talloc_free(p2);
 296         talloc_free(s2);
 297
 298         return ret;
 299 }
 300
 301
 302
 303 /*******************************************************************
 304   decide if a file should be operated on
 305   ********************************************************************/
 306 static BOOL do_this_one(struct smbclient_context *ctx, struct clilist_file_info *finfo)
 307 {
 308         if (finfo->attrib & FILE_ATTRIBUTE_DIRECTORY) return(True);
 309
 310         if (ctx->fileselection &&
 311             !mask_match(ctx->cli, finfo->name,ctx->fileselection,False)) {
 312                 DEBUG(3,("mask_match %s failed\n", finfo->name));
 313                 return False;
 314         }
 315
 316         if (ctx->newer_than && finfo->mtime < ctx->newer_than) {
 317                 DEBUG(3,("newer_than %s failed\n", finfo->name));
 318                 return(False);
 319         }
 320
 321         if ((ctx->archive_level==1 || ctx->archive_level==2) && !(finfo->attrib & FILE_ATTRIBUTE_ARCHIVE)) {
 322                 DEBUG(3,("archive %s failed\n", finfo->name));
 323                 return(False);
 324         }
 325
 326         return(True);
 327 }
 328
 329 /****************************************************************************
 330   display info about a file
 331   ****************************************************************************/
 332 static void display_finfo(struct smbclient_context *ctx, struct clilist_file_info *finfo)
 333 {
 334         if (do_this_one(ctx, finfo)) {
 335                 time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */
 336                 char *astr = attrib_string(NULL, finfo->attrib);
 337                 d_printf("  %-30s%7.7s %8.0f  %s",
 338                          finfo->name,
 339                          astr,
 340                          (double)finfo->size,
 341                          asctime(localtime(&t)));
 342                 dir_total += finfo->size;
 343                 talloc_free(astr);
 344         }
 345 }
 346
 347
 348 /****************************************************************************
 349    accumulate size of a file
 350   ****************************************************************************/
 351 static void do_du(struct smbclient_context *ctx, struct clilist_file_info *finfo)
 352 {
 353         if (do_this_one(ctx, finfo)) {
 354                 dir_total += finfo->size;
 355         }
 356 }
 357
 358 static BOOL do_list_recurse;
 359 static BOOL do_list_dirs;
 360 static char *do_list_queue = 0;
 361 static long do_list_queue_size = 0;
 362 static long do_list_queue_start = 0;
 363 static long do_list_queue_end = 0;
 364 static void (*do_list_fn)(struct smbclient_context *, struct clilist_file_info *);
 365
 366 /****************************************************************************
 367 functions for do_list_queue
 368   ****************************************************************************/
 369
 370 /*
 371  * The do_list_queue is a NUL-separated list of strings stored in a
 372  * char*.  Since this is a FIFO, we keep track of the beginning and
 373  * ending locations of the data in the queue.  When we overflow, we
 374  * double the size of the char*.  When the start of the data passes
 375  * the midpoint, we move everything back.  This is logically more
 376  * complex than a linked list, but easier from a memory management
 377  * angle.  In any memory error condition, do_list_queue is reset.
 378  * Functions check to ensure that do_list_queue is non-NULL before
 379  * accessing it.
 380  */
 381 static void reset_do_list_queue(void)
 382 {
 383         SAFE_FREE(do_list_queue);
 384         do_list_queue_size = 0;
 385         do_list_queue_start = 0;
 386         do_list_queue_end = 0;
 387 }
 388
 389 static void init_do_list_queue(void)
 390 {
 391         reset_do_list_queue();
 392         do_list_queue_size = 1024;
 393         do_list_queue = malloc(do_list_queue_size);
 394         if (do_list_queue == 0) {
 395                 d_printf("malloc fail for size %d\n",
 396                          (int)do_list_queue_size);
 397                 reset_do_list_queue();
 398         } else {
 399                 memset(do_list_queue, 0, do_list_queue_size);
 400         }
 401 }
 402
 403 static void adjust_do_list_queue(void)
 404 {
 405         /*
 406          * If the starting point of the queue is more than half way through,
 407          * move everything toward the beginning.
 408          */
 409         if (do_list_queue && (do_list_queue_start == do_list_queue_end))
 410         {
 411                 DEBUG(4,("do_list_queue is empty\n"));
 412                 do_list_queue_start = do_list_queue_end = 0;
 413                 *do_list_queue = '\0';
 414         }
 415         else if (do_list_queue_start > (do_list_queue_size / 2))
 416         {
 417                 DEBUG(4,("sliding do_list_queue backward\n"));
 418                 memmove(do_list_queue,
 419                         do_list_queue + do_list_queue_start,
 420                         do_list_queue_end - do_list_queue_start);
 421                 do_list_queue_end -= do_list_queue_start;
 422                 do_list_queue_start = 0;
 423         }
 424
 425 }
 426
 427 static void add_to_do_list_queue(const char* entry)
 428 {
 429         char *dlq;
 430         long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
 431         while (new_end > do_list_queue_size)
 432         {
 433                 do_list_queue_size *= 2;
 434                 DEBUG(4,("enlarging do_list_queue to %d\n",
 435                          (int)do_list_queue_size));
 436                 dlq = realloc_p(do_list_queue, char, do_list_queue_size);
 437                 if (! dlq) {
 438                         d_printf("failure enlarging do_list_queue to %d bytes\n",
 439                                  (int)do_list_queue_size);
 440                         reset_do_list_queue();
 441                 }
 442                 else
 443                 {
 444                         do_list_queue = dlq;
 445                         memset(do_list_queue + do_list_queue_size / 2,
 446                                0, do_list_queue_size / 2);
 447                 }
 448         }
 449         if (do_list_queue)
 450         {
 451                 safe_strcpy(do_list_queue + do_list_queue_end, entry,
 452                             do_list_queue_size - do_list_queue_end - 1);
 453                 do_list_queue_end = new_end;
 454                 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
 455                          entry, (int)do_list_queue_start, (int)do_list_queue_end));
 456         }
 457 }
 458
 459 static char *do_list_queue_head(void)
 460 {
 461         return do_list_queue + do_list_queue_start;
 462 }
 463
 464 static void remove_do_list_queue_head(void)
 465 {
 466         if (do_list_queue_end > do_list_queue_start)
 467         {
 468                 do_list_queue_start += strlen(do_list_queue_head()) + 1;
 469                 adjust_do_list_queue();
 470                 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
 471                          (int)do_list_queue_start, (int)do_list_queue_end));
 472         }
 473 }
 474
 475 static int do_list_queue_empty(void)
 476 {
 477         return (! (do_list_queue && *do_list_queue));
 478 }
 479
 480 /****************************************************************************
 481 a helper for do_list
 482   ****************************************************************************/
 483 static void do_list_helper(struct clilist_file_info *f, const char *mask, void *state)
 484 {
 485         struct smbclient_context *ctx = state;
 486
 487         if (f->attrib & FILE_ATTRIBUTE_DIRECTORY) {
 488                 if (do_list_dirs && do_this_one(ctx, f)) {
 489                         do_list_fn(ctx, f);
 490                 }
 491                 if (do_list_recurse &&
 492                     !strequal(f->name,".") &&
 493                     !strequal(f->name,"..")) {
 494                         char *mask2;
 495                         char *p;
 496
 497                         mask2 = talloc_strdup(NULL, mask);
 498                         p = strrchr_m(mask2,'\\');
 499                         if (!p) return;
 500                         p[1] = 0;
 501                         mask2 = talloc_asprintf_append(mask2, "%s\\*", f->name);
 502                         add_to_do_list_queue(mask2);
 503                 }
 504                 return;
 505         }
 506
 507         if (do_this_one(ctx, f)) {
 508                 do_list_fn(ctx, f);
 509         }
 510 }
 511
 512
 513 /****************************************************************************
 514 a wrapper around smbcli_list that adds recursion
 515   ****************************************************************************/
 516 static void do_list(struct smbclient_context *ctx, const char *mask,uint16_t attribute,
 517              void (*fn)(struct smbclient_context *, struct clilist_file_info *),BOOL rec, BOOL dirs)
 518 {
 519         static int in_do_list = 0;
 520
 521         if (in_do_list && rec)
 522         {
 523                 fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
 524                 exit(1);
 525         }
 526
 527         in_do_list = 1;
 528
 529         do_list_recurse = rec;
 530         do_list_dirs = dirs;
 531         do_list_fn = fn;
 532
 533         if (rec)
 534         {
 535                 init_do_list_queue();
 536                 add_to_do_list_queue(mask);
 537
 538                 while (! do_list_queue_empty())
 539                 {
 540                         /*
 541                          * Need to copy head so that it doesn't become
 542                          * invalid inside the call to smbcli_list.  This
 543                          * would happen if the list were expanded
 544                          * during the call.
 545                          * Fix from E. Jay Berkenbilt (ejb@ql.org)
 546                          */
 547                         char *head;
 548                         head = do_list_queue_head();
 549                         smbcli_list(ctx->cli->tree, head, attribute, do_list_helper, ctx);
 550                         remove_do_list_queue_head();
 551                         if ((! do_list_queue_empty()) && (fn == display_finfo))
 552                         {
 553                                 char* next_file = do_list_queue_head();
 554                                 char* save_ch = 0;
 555                                 if ((strlen(next_file) >= 2) &&
 556                                     (next_file[strlen(next_file) - 1] == '*') &&
 557                                     (next_file[strlen(next_file) - 2] == '\\'))
 558                                 {
 559                                         save_ch = next_file +
 560                                                 strlen(next_file) - 2;
 561                                         *save_ch = '\0';
 562                                 }
 563                                 d_printf("\n%s\n",next_file);
 564                                 if (save_ch)
 565                                 {
 566                                         *save_ch = '\\';
 567                                 }
 568                         }
 569                 }
 570         }
 571         else
 572         {
 573                 if (smbcli_list(ctx->cli->tree, mask, attribute, do_list_helper, ctx) == -1)
 574                 {
 575                         d_printf("%s listing %s\n", smbcli_errstr(ctx->cli->tree), mask);
 576                 }
 577         }
 578
 579         in_do_list = 0;
 580         reset_do_list_queue();
 581 }
 582
 583 /****************************************************************************
 584   get a directory listing
 585   ****************************************************************************/
 586 static int cmd_dir(struct smbclient_context *ctx, const char **args)
 587 {
 588         uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 589         char *mask;
 590         int rc;
 591
 592         dir_total = 0;
 593
 594         mask = talloc_strdup(ctx, ctx->remote_cur_dir);
 595         if(mask[strlen(mask)-1]!='\\')
 596                 mask = talloc_append_string(ctx, mask,"\\");
 597
 598         if (args[1]) {
 599                 mask = talloc_strdup(ctx, args[1]);
 600                 if (mask[0] != '\\')
 601                         mask = talloc_append_string(ctx, mask, "\\");
 602                 dos_format(mask);
 603         }
 604         else {
 605                 if (ctx->cli->tree->session->transport->negotiate.protocol <=
 606                     PROTOCOL_LANMAN1) {
 607                         mask = talloc_append_string(ctx, mask, "*.*");
 608                 } else {
 609                         mask = talloc_append_string(ctx, mask, "*");
 610                 }
 611         }
 612
 613         do_list(ctx, mask, attribute, display_finfo, ctx->recurse, True);
 614
 615         rc = do_dskattr(ctx);
 616
 617         DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
 618
 619         return rc;
 620 }
 621
 622
 623 /****************************************************************************
 624   get a directory listing
 625   ****************************************************************************/
 626 static int cmd_du(struct smbclient_context *ctx, const char **args)
 627 {
 628         uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 629         int rc;
 630         char *mask;
 631
 632         dir_total = 0;
 633
 634         if (args[1]) {
 635                 if (args[1][0] == '\\')
 636                         mask = talloc_strdup(ctx, args[1]);
 637                 else
 638                         mask = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
 639                 dos_format(mask);
 640         } else {
 641                 mask = talloc_asprintf(ctx, "%s\\*", ctx->remote_cur_dir);
 642         }
 643
 644         do_list(ctx, mask, attribute, do_du, ctx->recurse, True);
 645
 646         talloc_free(mask);
 647
 648         rc = do_dskattr(ctx);
 649
 650         d_printf("Total number of bytes: %.0f\n", dir_total);
 651
 652         return rc;
 653 }
 654
 655
 656 /****************************************************************************
 657   get a file from rname to lname
 658   ****************************************************************************/
 659 static int do_get(struct smbclient_context *ctx, char *rname, const char *lname, BOOL reget)
 660 {
 661         int handle = 0, fnum;
 662         BOOL newhandle = False;
 663         uint8_t *data;
 664         struct timeval tp_start;
 665         int read_size = io_bufsize;
 666         uint16_t attr;
 667         size_t size;
 668         off_t start = 0;
 669         off_t nread = 0;
 670         int rc = 0;
 671
 672         GetTimeOfDay(&tp_start);
 673
 674         if (ctx->lowercase) {
 675                 strlower(discard_const_p(char, lname));
 676         }
 677
 678         fnum = smbcli_open(ctx->cli->tree, rname, O_RDONLY, DENY_NONE);
 679
 680         if (fnum == -1) {
 681                 d_printf("%s opening remote file %s\n",smbcli_errstr(ctx->cli->tree),rname);
 682                 return 1;
 683         }
 684
 685         if(!strcmp(lname,"-")) {
 686                 handle = fileno(stdout);
 687         } else {
 688                 if (reget) {
 689                         handle = open(lname, O_WRONLY|O_CREAT, 0644);
 690                         if (handle >= 0) {
 691                                 start = lseek(handle, 0, SEEK_END);
 692                                 if (start == -1) {
 693                                         d_printf("Error seeking local file\n");
 694                                         return 1;
 695                                 }
 696                         }
 697                 } else {
 698                         handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
 699                 }
 700                 newhandle = True;
 701         }
 702         if (handle < 0) {
 703                 d_printf("Error opening local file %s\n",lname);
 704                 return 1;
 705         }
 706
 707
 708         if (NT_STATUS_IS_ERR(smbcli_qfileinfo(ctx->cli->tree, fnum,
 709                            &attr, &size, NULL, NULL, NULL, NULL, NULL)) &&
 710             NT_STATUS_IS_ERR(smbcli_getattrE(ctx->cli->tree, fnum,
 711                           &attr, &size, NULL, NULL, NULL))) {
 712                 d_printf("getattrib: %s\n",smbcli_errstr(ctx->cli->tree));
 713                 return 1;
 714         }
 715
 716         DEBUG(2,("getting file %s of size %.0f as %s ",
 717                  rname, (double)size, lname));
 718
 719         if(!(data = (uint8_t *)malloc(read_size))) {
 720                 d_printf("malloc fail for size %d\n", read_size);
 721                 smbcli_close(ctx->cli->tree, fnum);
 722                 return 1;
 723         }
 724
 725         while (1) {
 726                 int n = smbcli_read(ctx->cli->tree, fnum, data, nread + start, read_size);
 727
 728                 if (n <= 0) break;
 729
 730                 if (writefile(handle,data, n, ctx->translation) != n) {
 731                         d_printf("Error writing local file\n");
 732                         rc = 1;
 733                         break;
 734                 }
 735
 736                 nread += n;
 737         }
 738
 739         if (nread + start < size) {
 740                 DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n",
 741                             rname, (long)nread));
 742
 743                 rc = 1;
 744         }
 745
 746         SAFE_FREE(data);
 747
 748         if (NT_STATUS_IS_ERR(smbcli_close(ctx->cli->tree, fnum))) {
 749                 d_printf("Error %s closing remote file\n",smbcli_errstr(ctx->cli->tree));
 750                 rc = 1;
 751         }
 752
 753         if (newhandle) {
 754                 close(handle);
 755         }
 756
 757         if (ctx->archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
 758                 smbcli_setatr(ctx->cli->tree, rname, attr & ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE, 0);
 759         }
 760
 761         {
 762                 struct timeval tp_end;
 763                 int this_time;
 764
 765                 GetTimeOfDay(&tp_end);
 766                 this_time =
 767                         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
 768                         (tp_end.tv_usec - tp_start.tv_usec)/1000;
 769                 get_total_time_ms += this_time;
 770                 get_total_size += nread;
 771
 772                 DEBUG(2,("(%3.1f kb/s) (average %3.1f kb/s)\n",
 773                          nread / (1.024*this_time + 1.0e-4),
 774                          get_total_size / (1.024*get_total_time_ms)));
 775         }
 776
 777         return rc;
 778 }
 779
 780
 781 /****************************************************************************
 782   get a file
 783   ****************************************************************************/
 784 static int cmd_get(struct smbclient_context *ctx, const char **args)
 785 {
 786         const char *lname;
 787         char *rname;
 788
 789         if (!args[1]) {
 790                 d_printf("get <filename>\n");
 791                 return 1;
 792         }
 793
 794         rname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
 795
 796         if (args[2])
 797                 lname = args[2];
 798         else
 799                 lname = args[1];
 800
 801         dos_clean_name(rname);
 802
 803         return do_get(ctx, rname, lname, False);
 804 }
 805
 806 /****************************************************************************
 807  Put up a yes/no prompt.
 808 ****************************************************************************/
 809 static BOOL yesno(char *p)
 810 {
 811         char ans[4];
 812         printf("%s",p);
 813
 814         if (!fgets(ans,sizeof(ans)-1,stdin))
 815                 return(False);
 816
 817         if (*ans == 'y' || *ans == 'Y')
 818                 return(True);
 819
 820         return(False);
 821 }
 822
 823 /****************************************************************************
 824   do a mget operation on one file
 825   ****************************************************************************/
 826 static void do_mget(struct smbclient_context *ctx, struct clilist_file_info *finfo)
 827 {
 828         char *rname;
 829         char *quest;
 830         char *mget_mask;
 831         char *saved_curdir;
 832
 833         if (strequal(finfo->name,".") || strequal(finfo->name,".."))
 834                 return;
 835
 836         if (finfo->attrib & FILE_ATTRIBUTE_DIRECTORY)
 837                 asprintf(&quest, "Get directory %s? ",finfo->name);
 838         else
 839                 asprintf(&quest, "Get file %s? ",finfo->name);
 840
 841         if (ctx->prompt && !yesno(quest)) return;
 842
 843         SAFE_FREE(quest);
 844
 845         if (!(finfo->attrib & FILE_ATTRIBUTE_DIRECTORY)) {
 846                 asprintf(&rname, "%s%s",ctx->remote_cur_dir,finfo->name);
 847                 do_get(ctx, rname, finfo->name, False);
 848                 SAFE_FREE(rname);
 849                 return;
 850         }
 851
 852         /* handle directories */
 853         saved_curdir = talloc_strdup(NULL, ctx->remote_cur_dir);
 854
 855         ctx->remote_cur_dir = talloc_asprintf_append(NULL, "%s\\", finfo->name);
 856
 857         string_replace(discard_const_p(char, finfo->name), '\\', '/');
 858         if (ctx->lowercase) {
 859                 strlower(discard_const_p(char, finfo->name));
 860         }
 861
 862         if (!directory_exist(finfo->name) &&
 863             mkdir(finfo->name,0777) != 0) {
 864                 d_printf("failed to create directory %s\n",finfo->name);
 865                 return;
 866         }
 867
 868         if (chdir(finfo->name) != 0) {
 869                 d_printf("failed to chdir to directory %s\n",finfo->name);
 870                 return;
 871         }
 872
 873         mget_mask = talloc_asprintf(NULL, "%s*", ctx->remote_cur_dir);
 874
 875         do_list(ctx, mget_mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,do_mget,False, True);
 876         chdir("..");
 877         talloc_free(ctx->remote_cur_dir);
 878
 879         ctx->remote_cur_dir = saved_curdir;
 880 }
 881
 882
 883 /****************************************************************************
 884 view the file using the pager
 885 ****************************************************************************/
 886 static int cmd_more(struct smbclient_context *ctx, const char **args)
 887 {
 888         char *rname;
 889         char *pager_cmd;
 890         char *lname;
 891         char *pager;
 892         int fd;
 893         int rc = 0;
 894
 895         lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
 896         fd = mkstemp(lname);
 897         if (fd == -1) {
 898                 d_printf("failed to create temporary file for more\n");
 899                 return 1;
 900         }
 901         close(fd);
 902
 903         if (!args[1]) {
 904                 d_printf("more <filename>\n");
 905                 unlink(lname);
 906                 return 1;
 907         }
 908         rname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
 909         dos_clean_name(rname);
 910
 911         rc = do_get(ctx, rname, lname, False);
 912
 913         pager=getenv("PAGER");
 914
 915         pager_cmd = talloc_asprintf(ctx, "%s %s",(pager? pager:PAGER), lname);
 916         system(pager_cmd);
 917         unlink(lname);
 918
 919         return rc;
 920 }
 921
 922
 923
 924 /****************************************************************************
 925 do a mget command
 926 ****************************************************************************/
 927 static int cmd_mget(struct smbclient_context *ctx, const char **args)
 928 {
 929         uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
 930         char *mget_mask;
 931         int i;
 932
 933         if (ctx->recurse)
 934                 attribute |= FILE_ATTRIBUTE_DIRECTORY;
 935
 936         for (i = 1; args[i]; i++) {
 937                 mget_mask = talloc_strdup(ctx,ctx->remote_cur_dir);
 938                 if(mget_mask[strlen(mget_mask)-1]!='\\')
 939                         mget_mask = talloc_append_string(ctx, mget_mask, "\\");
 940
 941                 mget_mask = talloc_strdup(ctx, args[i]);
 942                 if (mget_mask[0] != '\\')
 943                         mget_mask = talloc_append_string(ctx, mget_mask, "\\");
 944                 do_list(ctx, mget_mask, attribute,do_mget,False,True);
 945         }
 946
 947         if (!*mget_mask) {
 948                 mget_mask = talloc_asprintf(ctx, "%s\\*", ctx->remote_cur_dir);
 949                 do_list(ctx, mget_mask, attribute,do_mget,False,True);
 950         }
 951
 952         talloc_free(mget_mask);
 953
 954         return 0;
 955 }
 956
 957
 958 /****************************************************************************
 959 make a directory of name "name"
 960 ****************************************************************************/
 961 static NTSTATUS do_mkdir(struct smbclient_context *ctx, char *name)
 962 {
 963         NTSTATUS status;
 964
 965         if (NT_STATUS_IS_ERR(status = smbcli_mkdir(ctx->cli->tree, name))) {
 966                 d_printf("%s making remote directory %s\n",
 967                          smbcli_errstr(ctx->cli->tree),name);
 968                 return status;
 969         }
 970
 971         return status;
 972 }
 973
 974
 975 /****************************************************************************
 976  Exit client.
 977 ****************************************************************************/
 978 static int cmd_quit(struct smbclient_context *ctx, const char **args)
 979 {
 980         talloc_free(ctx);
 981         exit(0);
 982         /* NOTREACHED */
 983         return 0;
 984 }
 985
 986
 987 /****************************************************************************
 988   make a directory
 989   ****************************************************************************/
 990 static int cmd_mkdir(struct smbclient_context *ctx, const char **args)
 991 {
 992         char *mask, *p;
 993
 994         if (!args[1]) {
 995                 if (!ctx->recurse)
 996                         d_printf("mkdir <dirname>\n");
 997                 return 1;
 998         }
 999
1000         mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir,args[1]);
1001
1002         if (ctx->recurse) {
1003                 dos_clean_name(mask);
1004
1005                 trim_string(mask,".",NULL);
1006                 for (p = strtok(mask,"/\\"); p; p = strtok(p, "/\\")) {
1007                         char *parent = talloc_strndup(ctx, mask, PTR_DIFF(p, mask));
1008
1009                         if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx->cli->tree, parent))) {
1010                                 do_mkdir(ctx, parent);
1011                         }
1012
1013                         talloc_free(parent);
1014                 }
1015         } else {
1016                 do_mkdir(ctx, mask);
1017         }
1018
1019         return 0;
1020 }
1021
1022 /****************************************************************************
1023 show 8.3 name of a file
1024 ****************************************************************************/
1025 static int cmd_altname(struct smbclient_context *ctx, const char **args)
1026 {
1027         const char *altname;
1028         char *name;
1029
1030         if (!args[1]) {
1031                 d_printf("altname <file>\n");
1032                 return 1;
1033         }
1034
1035         name = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1036
1037         if (!NT_STATUS_IS_OK(smbcli_qpathinfo_alt_name(ctx->cli->tree, name, &altname))) {
1038                 d_printf("%s getting alt name for %s\n",
1039                          smbcli_errstr(ctx->cli->tree),name);
1040                 return(False);
1041         }
1042         d_printf("%s\n", altname);
1043
1044         return 0;
1045 }
1046
1047
1048 /****************************************************************************
1049   put a single file
1050   ****************************************************************************/
1051 static int do_put(struct smbclient_context *ctx, char *rname, char *lname, BOOL reput)
1052 {
1053         int fnum;
1054         XFILE *f;
1055         size_t start = 0;
1056         off_t nread = 0;
1057         uint8_t *buf = NULL;
1058         int maxwrite = io_bufsize;
1059         int rc = 0;
1060
1061         struct timeval tp_start;
1062         GetTimeOfDay(&tp_start);
1063
1064         if (reput) {
1065                 fnum = smbcli_open(ctx->cli->tree, rname, O_RDWR|O_CREAT, DENY_NONE);
1066                 if (fnum >= 0) {
1067                         if (NT_STATUS_IS_ERR(smbcli_qfileinfo(ctx->cli->tree, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL)) &&
1068                             NT_STATUS_IS_ERR(smbcli_getattrE(ctx->cli->tree, fnum, NULL, &start, NULL, NULL, NULL))) {
1069                                 d_printf("getattrib: %s\n",smbcli_errstr(ctx->cli->tree));
1070                                 return 1;
1071                         }
1072                 }
1073         } else {
1074                 fnum = smbcli_open(ctx->cli->tree, rname, O_RDWR|O_CREAT|O_TRUNC,
1075                                 DENY_NONE);
1076         }
1077
1078         if (fnum == -1) {
1079                 d_printf("%s opening remote file %s\n",smbcli_errstr(ctx->cli->tree),rname);
1080                 return 1;
1081         }
1082
1083         /* allow files to be piped into smbclient
1084            jdblair 24.jun.98
1085
1086            Note that in this case this function will exit(0) rather
1087            than returning. */
1088         if (!strcmp(lname, "-")) {
1089                 f = x_stdin;
1090                 /* size of file is not known */
1091         } else {
1092                 f = x_fopen(lname,O_RDONLY, 0);
1093                 if (f && reput) {
1094                         if (x_tseek(f, start, SEEK_SET) == -1) {
1095                                 d_printf("Error seeking local file\n");
1096                                 return 1;
1097                         }
1098                 }
1099         }
1100
1101         if (!f) {
1102                 d_printf("Error opening local file %s\n",lname);
1103                 return 1;
1104         }
1105
1106
1107         DEBUG(1,("putting file %s as %s ",lname,
1108                  rname));
1109
1110         buf = (uint8_t *)malloc(maxwrite);
1111         if (!buf) {
1112                 d_printf("ERROR: Not enough memory!\n");
1113                 return 1;
1114         }
1115         while (!x_feof(f)) {
1116                 int n = maxwrite;
1117                 int ret;
1118
1119                 if ((n = readfile(buf,n,f,ctx->translation)) < 1) {
1120                         if((n == 0) && x_feof(f))
1121                                 break; /* Empty local file. */
1122
1123                         d_printf("Error reading local file: %s\n", strerror(errno));
1124                         rc = 1;
1125                         break;
1126                 }
1127
1128                 ret = smbcli_write(ctx->cli->tree, fnum, 0, buf, nread + start, n);
1129
1130                 if (n != ret) {
1131                         d_printf("Error writing file: %s\n", smbcli_errstr(ctx->cli->tree));
1132                         rc = 1;
1133                         break;
1134                 }
1135
1136                 nread += n;
1137         }
1138
1139         if (NT_STATUS_IS_ERR(smbcli_close(ctx->cli->tree, fnum))) {
1140                 d_printf("%s closing remote file %s\n",smbcli_errstr(ctx->cli->tree),rname);
1141                 x_fclose(f);
1142                 SAFE_FREE(buf);
1143                 return 1;
1144         }
1145
1146
1147         if (f != x_stdin) {
1148                 x_fclose(f);
1149         }
1150
1151         SAFE_FREE(buf);
1152
1153         {
1154                 struct timeval tp_end;
1155                 int this_time;
1156
1157                 GetTimeOfDay(&tp_end);
1158                 this_time =
1159                         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1160                         (tp_end.tv_usec - tp_start.tv_usec)/1000;
1161                 put_total_time_ms += this_time;
1162                 put_total_size += nread;
1163
1164                 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1165                          nread / (1.024*this_time + 1.0e-4),
1166                          put_total_size / (1.024*put_total_time_ms)));
1167         }
1168
1169         if (f == x_stdin) {
1170                 talloc_free(ctx);
1171                 exit(0);
1172         }
1173
1174         return rc;
1175 }
1176
1177
1178
1179 /****************************************************************************
1180   put a file
1181   ****************************************************************************/
1182 static int cmd_put(struct smbclient_context *ctx, const char **args)
1183 {
1184         char *lname;
1185         char *rname;
1186
1187         if (!args[1]) {
1188                 d_printf("put <filename>\n");
1189                 return 1;
1190         }
1191
1192         lname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
1193
1194         if (args[2])
1195                 rname = talloc_strdup(ctx, args[2]);
1196         else
1197                 rname = talloc_strdup(ctx, lname);
1198
1199         dos_clean_name(rname);
1200
1201         /* allow '-' to represent stdin
1202            jdblair, 24.jun.98 */
1203         if (!file_exist(lname) && (strcmp(lname,"-"))) {
1204                 d_printf("%s does not exist\n",lname);
1205                 return 1;
1206         }
1207
1208         return do_put(ctx, rname, lname, False);
1209 }
1210
1211 /*************************************
1212   File list structure
1213 *************************************/
1214
1215 static struct file_list {
1216         struct file_list *prev, *next;
1217         char *file_path;
1218         BOOL isdir;
1219 } *file_list;
1220
1221 /****************************************************************************
1222   Free a file_list structure
1223 ****************************************************************************/
1224
1225 static void free_file_list (struct file_list * list)
1226 {
1227         struct file_list *tmp;
1228
1229         while (list)
1230         {
1231                 tmp = list;
1232                 DLIST_REMOVE(list, list);
1233                 SAFE_FREE(tmp->file_path);
1234                 SAFE_FREE(tmp);
1235         }
1236 }
1237
1238 /****************************************************************************
1239   seek in a directory/file list until you get something that doesn't start with
1240   the specified name
1241   ****************************************************************************/
1242 static BOOL seek_list(struct file_list *list, char *name)
1243 {
1244         while (list) {
1245                 trim_string(list->file_path,"./","\n");
1246                 if (strncmp(list->file_path, name, strlen(name)) != 0) {
1247                         return(True);
1248                 }
1249                 list = list->next;
1250         }
1251
1252         return(False);
1253 }
1254
1255 /****************************************************************************
1256   set the file selection mask
1257   ****************************************************************************/
1258 static int cmd_select(struct smbclient_context *ctx, const char **args)
1259 {
1260         talloc_free(ctx->fileselection);
1261         ctx->fileselection = talloc_strdup(NULL, args[1]);
1262
1263         return 0;
1264 }
1265
1266 /*******************************************************************
1267   A readdir wrapper which just returns the file name.
1268  ********************************************************************/
1269 static const char *readdirname(DIR *p)
1270 {
1271         struct dirent *ptr;
1272         char *dname;
1273
1274         if (!p)
1275                 return(NULL);
1276
1277         ptr = (struct dirent *)readdir(p);
1278         if (!ptr)
1279                 return(NULL);
1280
1281         dname = ptr->d_name;
1282
1283 #ifdef NEXT2
1284         if (telldir(p) < 0)
1285                 return(NULL);
1286 #endif
1287
1288 #ifdef HAVE_BROKEN_READDIR
1289         /* using /usr/ucb/cc is BAD */
1290         dname = dname - 2;
1291 #endif
1292
1293         {
1294                 static char *buf;
1295                 int len = NAMLEN(ptr);
1296                 buf = talloc_strndup(NULL, dname, len);
1297                 dname = buf;
1298         }
1299
1300         return(dname);
1301 }
1302
1303 /****************************************************************************
1304   Recursive file matching function act as find
1305   match must be always set to True when calling this function
1306 ****************************************************************************/
1307 static int file_find(struct smbclient_context *ctx, struct file_list **list, const char *directory,
1308                       const char *expression, BOOL match)
1309 {
1310         DIR *dir;
1311         struct file_list *entry;
1312         struct stat statbuf;
1313         int ret;
1314         char *path;
1315         BOOL isdir;
1316         const char *dname;
1317
1318         dir = opendir(directory);
1319         if (!dir) return -1;
1320
1321         while ((dname = readdirname(dir))) {
1322                 if (!strcmp("..", dname)) continue;
1323                 if (!strcmp(".", dname)) continue;
1324
1325                 if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
1326                         continue;
1327                 }
1328
1329                 isdir = False;
1330                 if (!match || !gen_fnmatch(expression, dname)) {
1331                         if (ctx->recurse) {
1332                                 ret = stat(path, &statbuf);
1333                                 if (ret == 0) {
1334                                         if (S_ISDIR(statbuf.st_mode)) {
1335                                                 isdir = True;
1336                                                 ret = file_find(ctx, list, path, expression, False);
1337                                         }
1338                                 } else {
1339                                         d_printf("file_find: cannot stat file %s\n", path);
1340                                 }
1341
1342                                 if (ret == -1) {
1343                                         SAFE_FREE(path);
1344                                         closedir(dir);
1345                                         return -1;
1346                                 }
1347                         }
1348                         entry = malloc_p(struct file_list);
1349                         if (!entry) {
1350                                 d_printf("Out of memory in file_find\n");
1351                                 closedir(dir);
1352                                 return -1;
1353                         }
1354                         entry->file_path = path;
1355                         entry->isdir = isdir;
1356                         DLIST_ADD(*list, entry);
1357                 } else {
1358                         SAFE_FREE(path);
1359                 }
1360         }
1361
1362         closedir(dir);
1363         return 0;
1364 }
1365
1366 /****************************************************************************
1367   mput some files
1368   ****************************************************************************/
1369 static int cmd_mput(struct smbclient_context *ctx, const char **args)
1370 {
1371         int i;
1372
1373         for (i = 1; args[i]; i++) {
1374                 int ret;
1375                 struct file_list *temp_list;
1376                 char *quest, *lname, *rname;
1377
1378                 printf("%s\n", args[i]);
1379
1380                 file_list = NULL;
1381
1382                 ret = file_find(ctx, &file_list, ".", args[i], True);
1383                 if (ret) {
1384                         free_file_list(file_list);
1385                         continue;
1386                 }
1387
1388                 quest = NULL;
1389                 lname = NULL;
1390                 rname = NULL;
1391
1392                 for (temp_list = file_list; temp_list;
1393                      temp_list = temp_list->next) {
1394
1395                         SAFE_FREE(lname);
1396                         if (asprintf(&lname, "%s/", temp_list->file_path) <= 0)
1397                                 continue;
1398                         trim_string(lname, "./", "/");
1399
1400                         /* check if it's a directory */
1401                         if (temp_list->isdir) {
1402                                 /* if (!recurse) continue; */
1403
1404                                 SAFE_FREE(quest);
1405                                 if (asprintf(&quest, "Put directory %s? ", lname) < 0) break;
1406                                 if (ctx->prompt && !yesno(quest)) { /* No */
1407                                         /* Skip the directory */
1408                                         lname[strlen(lname)-1] = '/';
1409                                         if (!seek_list(temp_list, lname))
1410                                                 break;
1411                                 } else { /* Yes */
1412                                         SAFE_FREE(rname);
1413                                         if(asprintf(&rname, "%s%s", ctx->remote_cur_dir, lname) < 0) break;
1414                                         dos_format(rname);
1415                                         if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx->cli->tree, rname)) &&
1416                                             NT_STATUS_IS_ERR(do_mkdir(ctx, rname))) {
1417                                                 DEBUG (0, ("Unable to make dir, skipping..."));
1418                                                 /* Skip the directory */
1419                                                 lname[strlen(lname)-1] = '/';
1420                                                 if (!seek_list(temp_list, lname))
1421                                                         break;
1422                                         }
1423                                 }
1424                                 continue;
1425                         } else {
1426                                 SAFE_FREE(quest);
1427                                 if (asprintf(&quest,"Put file %s? ", lname) < 0) break;
1428                                 if (ctx->prompt && !yesno(quest)) /* No */
1429                                         continue;
1430
1431                                 /* Yes */
1432                                 SAFE_FREE(rname);
1433                                 if (asprintf(&rname, "%s%s", ctx->remote_cur_dir, lname) < 0) break;
1434                         }
1435
1436                         dos_format(rname);
1437
1438                         do_put(ctx, rname, lname, False);
1439                 }
1440                 free_file_list(file_list);
1441                 SAFE_FREE(quest);
1442                 SAFE_FREE(lname);
1443                 SAFE_FREE(rname);
1444         }
1445
1446         return 0;
1447 }
1448
1449
1450 /****************************************************************************
1451   print a file
1452   ****************************************************************************/
1453 static int cmd_print(struct smbclient_context *ctx, const char **args)
1454 {
1455         char *lname, *rname;
1456         char *p;
1457
1458         if (!args[1]) {
1459                 d_printf("print <filename>\n");
1460                 return 1;
1461         }
1462
1463         lname = talloc_strdup(ctx, args[1]);
1464
1465         rname = talloc_strdup(ctx, lname);
1466         p = strrchr_m(rname,'/');
1467         if (p) {
1468                 slprintf(rname, sizeof(rname)-1, "%s-%d", p+1, (int)getpid());
1469         }
1470
1471         if (strequal(lname,"-")) {
1472                 slprintf(rname, sizeof(rname)-1, "stdin-%d", (int)getpid());
1473         }
1474
1475         return do_put(ctx, rname, lname, False);
1476 }
1477
1478
1479 static int cmd_rewrite(struct smbclient_context *ctx, const char **args)
1480 {
1481         d_printf("REWRITE: command not implemented (FIXME!)\n");
1482
1483         return 0;
1484 }
1485
1486 /****************************************************************************
1487 delete some files
1488 ****************************************************************************/
1489 static int cmd_del(struct smbclient_context *ctx, const char **args)
1490 {
1491         char *mask;
1492         uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
1493
1494         if (ctx->recurse)
1495                 attribute |= FILE_ATTRIBUTE_DIRECTORY;
1496
1497         if (!args[1]) {
1498                 d_printf("del <filename>\n");
1499                 return 1;
1500         }
1501         mask = talloc_asprintf(ctx,"%s%s", ctx->remote_cur_dir, args[1]);
1502
1503         if (NT_STATUS_IS_ERR(smbcli_unlink(ctx->cli->tree, mask))) {
1504                 d_printf("%s deleting remote file %s\n",smbcli_errstr(ctx->cli->tree),mask);
1505         }
1506
1507         return 0;
1508 }
1509
1510
1511 /****************************************************************************
1512 delete a whole directory tree
1513 ****************************************************************************/
1514 static int cmd_deltree(struct smbclient_context *ctx, const char **args)
1515 {
1516         char *dname;
1517         int ret;
1518
1519         if (!args[1]) {
1520                 d_printf("deltree <dirname>\n");
1521                 return 1;
1522         }
1523
1524         dname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1525
1526         ret = smbcli_deltree(ctx->cli->tree, dname);
1527
1528         if (ret == -1) {
1529                 printf("Failed to delete tree %s - %s\n", dname, smbcli_errstr(ctx->cli->tree));
1530                 return -1;
1531         }
1532
1533         printf("Deleted %d files in %s\n", ret, dname);
1534
1535         return 0;
1536 }
1537
1538 typedef struct {
1539         const char  *level_name;
1540         enum smb_fsinfo_level level;
1541 } fsinfo_level_t;
1542
1543 fsinfo_level_t fsinfo_levels[] = {
1544         {"dskattr", RAW_QFS_DSKATTR},
1545         {"allocation", RAW_QFS_ALLOCATION},
1546         {"volume", RAW_QFS_VOLUME},
1547         {"volumeinfo", RAW_QFS_VOLUME_INFO},
1548         {"sizeinfo", RAW_QFS_SIZE_INFO},
1549         {"deviceinfo", RAW_QFS_DEVICE_INFO},
1550         {"attributeinfo", RAW_QFS_ATTRIBUTE_INFO},
1551         {"unixinfo", RAW_QFS_UNIX_INFO},
1552         {"volume-information", RAW_QFS_VOLUME_INFORMATION},
1553         {"size-information", RAW_QFS_SIZE_INFORMATION},
1554         {"device-information", RAW_QFS_DEVICE_INFORMATION},
1555         {"attribute-information", RAW_QFS_ATTRIBUTE_INFORMATION},
1556         {"quota-information", RAW_QFS_QUOTA_INFORMATION},
1557         {"fullsize-information", RAW_QFS_FULL_SIZE_INFORMATION},
1558         {"objectid", RAW_QFS_OBJECTID_INFORMATION},
1559         {NULL, RAW_QFS_GENERIC}
1560 };
1561
1562
1563 static int cmd_fsinfo(struct smbclient_context *ctx, const char **args)
1564 {
1565         union smb_fsinfo fsinfo;
1566         NTSTATUS status;
1567         fsinfo_level_t *fsinfo_level;
1568
1569         if (!args[1]) {
1570                 d_printf("fsinfo <level>, where level is one of following:\n");
1571                 fsinfo_level = fsinfo_levels;
1572                 while(fsinfo_level->level_name) {
1573                         d_printf("%s\n", fsinfo_level->level_name);
1574                         fsinfo_level++;
1575                 }
1576                 return 1;
1577         }
1578
1579         fsinfo_level = fsinfo_levels;
1580         while(fsinfo_level->level_name && !strequal(args[1],fsinfo_level->level_name)) {
1581                 fsinfo_level++;
1582         }
1583
1584         if (!fsinfo_level->level_name) {
1585                 d_printf("wrong level name!\n");
1586                 return 1;
1587         }
1588
1589         fsinfo.generic.level = fsinfo_level->level;
1590         status = smb_raw_fsinfo(ctx->cli->tree, ctx, &fsinfo);
1591         if (!NT_STATUS_IS_OK(status)) {
1592                 d_printf("fsinfo-level-%s - %s\n", fsinfo_level->level_name, nt_errstr(status));
1593                 return 1;
1594         }
1595
1596         d_printf("fsinfo-level-%s:\n", fsinfo_level->level_name);
1597         switch(fsinfo.generic.level) {
1598         case RAW_QFS_DSKATTR:
1599                 d_printf("\tunits_total:                %hu\n",
1600                          (unsigned short) fsinfo.dskattr.out.units_total);
1601                 d_printf("\tblocks_per_unit:            %hu\n",
1602                          (unsigned short) fsinfo.dskattr.out.blocks_per_unit);
1603                 d_printf("\tblocks_size:                %hu\n",
1604                          (unsigned short) fsinfo.dskattr.out.block_size);
1605                 d_printf("\tunits_free:                 %hu\n",
1606                          (unsigned short) fsinfo.dskattr.out.units_free);
1607                 break;
1608         case RAW_QFS_ALLOCATION:
1609                 d_printf("\tfs_id:                      %lu\n",
1610                          (unsigned long) fsinfo.allocation.out.fs_id);
1611                 d_printf("\tsectors_per_unit:           %lu\n",
1612                          (unsigned long) fsinfo.allocation.out.sectors_per_unit);
1613                 d_printf("\ttotal_alloc_units:          %lu\n",
1614                          (unsigned long) fsinfo.allocation.out.total_alloc_units);
1615                 d_printf("\tavail_alloc_units:          %lu\n",
1616                          (unsigned long) fsinfo.allocation.out.avail_alloc_units);
1617                 d_printf("\tbytes_per_sector:           %hu\n",
1618                          (unsigned short) fsinfo.allocation.out.bytes_per_sector);
1619                 break;
1620         case RAW_QFS_VOLUME:
1621                 d_printf("\tserial_number:              %lu\n",
1622                          (unsigned long) fsinfo.volume.out.serial_number);
1623                 d_printf("\tvolume_name:                %s\n", fsinfo.volume.out.volume_name.s);
1624                 break;
1625         case RAW_QFS_VOLUME_INFO:
1626         case RAW_QFS_VOLUME_INFORMATION:
1627                 d_printf("\tcreate_time:                %s\n",
1628                          nt_time_string(ctx,fsinfo.volume_info.out.create_time));
1629                 d_printf("\tserial_number:              %lu\n",
1630                          (unsigned long) fsinfo.volume_info.out.serial_number);
1631                 d_printf("\tvolume_name:                %s\n", fsinfo.volume_info.out.volume_name.s);
1632                 break;
1633         case RAW_QFS_SIZE_INFO:
1634         case RAW_QFS_SIZE_INFORMATION:
1635                 d_printf("\ttotal_alloc_units:          %llu\n",
1636                          (unsigned long long) fsinfo.size_info.out.total_alloc_units);
1637                 d_printf("\tavail_alloc_units:          %llu\n",
1638                          (unsigned long long) fsinfo.size_info.out.avail_alloc_units);
1639                 d_printf("\tsectors_per_unit:           %lu\n",
1640                          (unsigned long) fsinfo.size_info.out.sectors_per_unit);
1641                 d_printf("\tbytes_per_sector:           %lu\n",
1642                          (unsigned long) fsinfo.size_info.out.bytes_per_sector);
1643                 break;
1644         case RAW_QFS_DEVICE_INFO:
1645         case RAW_QFS_DEVICE_INFORMATION:
1646                 d_printf("\tdevice_type:                %lu\n",
1647                          (unsigned long) fsinfo.device_info.out.device_type);
1648                 d_printf("\tcharacteristics:            0x%lx\n",
1649                          (unsigned long) fsinfo.device_info.out.characteristics);
1650                 break;
1651         case RAW_QFS_ATTRIBUTE_INFORMATION:
1652         case RAW_QFS_ATTRIBUTE_INFO:
1653                 d_printf("\tfs_attr:                    0x%lx\n",
1654                          (unsigned long) fsinfo.attribute_info.out.fs_attr);
1655                 d_printf("\tmax_file_component_length:  %lu\n",
1656                          (unsigned long) fsinfo.attribute_info.out.max_file_component_length);
1657                 d_printf("\tfs_type:                    %s\n", fsinfo.attribute_info.out.fs_type.s);
1658                 break;
1659         case RAW_QFS_UNIX_INFO:
1660                 d_printf("\tmajor_version:              %hu\n",
1661                          (unsigned short) fsinfo.unix_info.out.major_version);
1662                 d_printf("\tminor_version:              %hu\n",
1663                          (unsigned short) fsinfo.unix_info.out.minor_version);
1664                 d_printf("\tcapability:                 0x%llx\n",
1665                          (unsigned long long) fsinfo.unix_info.out.capability);
1666                 break;
1667         case RAW_QFS_QUOTA_INFORMATION:
1668                 d_printf("\tunknown[3]:                 [%llu,%llu,%llu]\n",
1669                          (unsigned long long) fsinfo.quota_information.out.unknown[0],
1670                          (unsigned long long) fsinfo.quota_information.out.unknown[1],
1671                          (unsigned long long) fsinfo.quota_information.out.unknown[2]);
1672                 d_printf("\tquota_soft:                 %llu\n",
1673                          (unsigned long long) fsinfo.quota_information.out.quota_soft);
1674                 d_printf("\tquota_hard:                 %llu\n",
1675                          (unsigned long long) fsinfo.quota_information.out.quota_hard);
1676                 d_printf("\tquota_flags:                0x%llx\n",
1677                          (unsigned long long) fsinfo.quota_information.out.quota_flags);
1678                 break;
1679         case RAW_QFS_FULL_SIZE_INFORMATION:
1680                 d_printf("\ttotal_alloc_units:          %llu\n",
1681                          (unsigned long long) fsinfo.full_size_information.out.total_alloc_units);
1682                 d_printf("\tcall_avail_alloc_units:     %llu\n",
1683                          (unsigned long long) fsinfo.full_size_information.out.call_avail_alloc_units);
1684                 d_printf("\tactual_avail_alloc_units:   %llu\n",
1685                          (unsigned long long) fsinfo.full_size_information.out.actual_avail_alloc_units);
1686                 d_printf("\tsectors_per_unit:           %lu\n",
1687                          (unsigned long) fsinfo.full_size_information.out.sectors_per_unit);
1688                 d_printf("\tbytes_per_sector:           %lu\n",
1689                          (unsigned long) fsinfo.full_size_information.out.bytes_per_sector);
1690                 break;
1691         case RAW_QFS_OBJECTID_INFORMATION:
1692                 d_printf("\tGUID:                       %s\n",
1693                          GUID_string(ctx,&fsinfo.objectid_information.out.guid));
1694                 d_printf("\tunknown[6]:                 [%llu,%llu,%llu,%llu,%llu,%llu]\n",
1695                          (unsigned long long) fsinfo.objectid_information.out.unknown[0],
1696                          (unsigned long long) fsinfo.objectid_information.out.unknown[2],
1697                          (unsigned long long) fsinfo.objectid_information.out.unknown[3],
1698                          (unsigned long long) fsinfo.objectid_information.out.unknown[4],
1699                          (unsigned long long) fsinfo.objectid_information.out.unknown[5],
1700                          (unsigned long long) fsinfo.objectid_information.out.unknown[6] );
1701                 break;
1702         case RAW_QFS_GENERIC:
1703                 d_printf("\twrong level returned\n");
1704                 break;
1705         }
1706
1707         return 0;
1708 }
1709
1710 /****************************************************************************
1711 show as much information as possible about a file
1712 ****************************************************************************/
1713 static int cmd_allinfo(struct smbclient_context *ctx, const char **args)
1714 {
1715         char *fname;
1716         union smb_fileinfo finfo;
1717         NTSTATUS status;
1718
1719         if (!args[1]) {
1720                 d_printf("allinfo <filename>\n");
1721                 return 1;
1722         }
1723         fname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1724
1725         /* first a ALL_INFO QPATHINFO */
1726         finfo.generic.level = RAW_FILEINFO_ALL_INFO;
1727         finfo.generic.in.fname = fname;
1728         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1729         if (!NT_STATUS_IS_OK(status)) {
1730                 d_printf("%s - %s\n", fname, nt_errstr(status));
1731                 return 1;
1732         }
1733
1734         d_printf("\tcreate_time:    %s\n", nt_time_string(ctx, finfo.all_info.out.create_time));
1735         d_printf("\taccess_time:    %s\n", nt_time_string(ctx, finfo.all_info.out.access_time));
1736         d_printf("\twrite_time:     %s\n", nt_time_string(ctx, finfo.all_info.out.write_time));
1737         d_printf("\tchange_time:    %s\n", nt_time_string(ctx, finfo.all_info.out.change_time));
1738         d_printf("\tattrib:         0x%x\n", finfo.all_info.out.attrib);
1739         d_printf("\talloc_size:     %lu\n", (unsigned long)finfo.all_info.out.alloc_size);
1740         d_printf("\tsize:           %lu\n", (unsigned long)finfo.all_info.out.size);
1741         d_printf("\tnlink:          %u\n", finfo.all_info.out.nlink);
1742         d_printf("\tdelete_pending: %u\n", finfo.all_info.out.delete_pending);
1743         d_printf("\tdirectory:      %u\n", finfo.all_info.out.directory);
1744         d_printf("\tea_size:        %u\n", finfo.all_info.out.ea_size);
1745         d_printf("\tfname:          '%s'\n", finfo.all_info.out.fname.s);
1746
1747         /* 8.3 name if any */
1748         finfo.generic.level = RAW_FILEINFO_ALT_NAME_INFO;
1749         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1750         if (NT_STATUS_IS_OK(status)) {
1751                 d_printf("\talt_name:       %s\n", finfo.alt_name_info.out.fname.s);
1752         }
1753
1754         /* file_id if available */
1755         finfo.generic.level = RAW_FILEINFO_INTERNAL_INFORMATION;
1756         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1757         if (NT_STATUS_IS_OK(status)) {
1758                 d_printf("\tfile_id         %.0f\n",
1759                          (double)finfo.internal_information.out.file_id);
1760         }
1761
1762         /* the EAs, if any */
1763         finfo.generic.level = RAW_FILEINFO_ALL_EAS;
1764         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1765         if (NT_STATUS_IS_OK(status)) {
1766                 int i;
1767                 for (i=0;i<finfo.all_eas.out.num_eas;i++) {
1768                         d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i,
1769                                  finfo.all_eas.out.eas[i].flags,
1770                                  (int)finfo.all_eas.out.eas[i].value.length,
1771                                  finfo.all_eas.out.eas[i].name.s);
1772                 }
1773         }
1774
1775         /* streams, if available */
1776         finfo.generic.level = RAW_FILEINFO_STREAM_INFO;
1777         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1778         if (NT_STATUS_IS_OK(status)) {
1779                 int i;
1780                 for (i=0;i<finfo.stream_info.out.num_streams;i++) {
1781                         d_printf("\tstream %d:\n", i);
1782                         d_printf("\t\tsize       %ld\n",
1783                                  (long)finfo.stream_info.out.streams[i].size);
1784                         d_printf("\t\talloc size %ld\n",
1785                                  (long)finfo.stream_info.out.streams[i].alloc_size);
1786                         d_printf("\t\tname       %s\n", finfo.stream_info.out.streams[i].stream_name.s);
1787                 }
1788         }
1789
1790         /* dev/inode if available */
1791         finfo.generic.level = RAW_FILEINFO_COMPRESSION_INFORMATION;
1792         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1793         if (NT_STATUS_IS_OK(status)) {
1794                 d_printf("\tcompressed size %ld\n", (long)finfo.compression_info.out.compressed_size);
1795                 d_printf("\tformat          %ld\n", (long)finfo.compression_info.out.format);
1796                 d_printf("\tunit_shift      %ld\n", (long)finfo.compression_info.out.unit_shift);
1797                 d_printf("\tchunk_shift     %ld\n", (long)finfo.compression_info.out.chunk_shift);
1798                 d_printf("\tcluster_shift   %ld\n", (long)finfo.compression_info.out.cluster_shift);
1799         }
1800
1801         return 0;
1802 }
1803
1804
1805 /****************************************************************************
1806 shows EA contents
1807 ****************************************************************************/
1808 static int cmd_eainfo(struct smbclient_context *ctx, const char **args)
1809 {
1810         char *fname;
1811         union smb_fileinfo finfo;
1812         NTSTATUS status;
1813         int i;
1814
1815         if (!args[1]) {
1816                 d_printf("eainfo <filename>\n");
1817                 return 1;
1818         }
1819         fname = talloc_strdup(ctx, args[1]);
1820
1821         finfo.generic.in.fname = fname;
1822         finfo.generic.level = RAW_FILEINFO_ALL_EAS;
1823         status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1824
1825         if (!NT_STATUS_IS_OK(status)) {
1826                 d_printf("RAW_FILEINFO_ALL_EAS - %s\n", nt_errstr(status));
1827                 return 1;
1828         }
1829
1830         d_printf("%s has %d EAs\n", fname, finfo.all_eas.out.num_eas);
1831
1832         for (i=0;i<finfo.all_eas.out.num_eas;i++) {
1833                 d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i,
1834                          finfo.all_eas.out.eas[i].flags,
1835                          (int)finfo.all_eas.out.eas[i].value.length,
1836                          finfo.all_eas.out.eas[i].name.s);
1837                 fflush(stdout);
1838                 dump_data(0,
1839                           finfo.all_eas.out.eas[i].value.data,
1840                           finfo.all_eas.out.eas[i].value.length);
1841         }
1842
1843         return 0;
1844 }
1845
1846
1847 /****************************************************************************
1848 show any ACL on a file
1849 ****************************************************************************/
1850 static int cmd_acl(struct smbclient_context *ctx, const char **args)
1851 {
1852         char *fname;
1853         union smb_fileinfo query;
1854         NTSTATUS status;
1855         int fnum;
1856
1857         if (!args[1]) {
1858                 d_printf("acl <filename>\n");
1859                 return 1;
1860         }
1861         fname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1862
1863         fnum = smbcli_nt_create_full(ctx->cli->tree, fname, 0,
1864                                      SEC_STD_READ_CONTROL,
1865                                      0,
1866                                      NTCREATEX_SHARE_ACCESS_DELETE|
1867                                      NTCREATEX_SHARE_ACCESS_READ|
1868                                      NTCREATEX_SHARE_ACCESS_WRITE,
1869                                      NTCREATEX_DISP_OPEN,
1870                                      0, 0);
1871         if (fnum == -1) {
1872                 d_printf("%s - %s\n", fname, smbcli_errstr(ctx->cli->tree));
1873                 return -1;
1874         }
1875
1876         query.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1877         query.query_secdesc.in.fnum = fnum;
1878         query.query_secdesc.secinfo_flags = 0x7;
1879
1880         status = smb_raw_fileinfo(ctx->cli->tree, ctx, &query);
1881         if (!NT_STATUS_IS_OK(status)) {
1882                 d_printf("%s - %s\n", fname, nt_errstr(status));
1883                 return 1;
1884         }
1885
1886         NDR_PRINT_DEBUG(security_descriptor, query.query_secdesc.out.sd);
1887
1888         return 0;
1889 }
1890
1891 /****************************************************************************
1892 lookup a name or sid
1893 ****************************************************************************/
1894 static int cmd_lookup(struct smbclient_context *ctx, const char **args)
1895 {
1896         NTSTATUS status;
1897         struct dom_sid *sid;
1898
1899         if (!args[1]) {
1900                 d_printf("lookup <sid|name>\n");
1901                 return 1;
1902         }
1903
1904         sid = dom_sid_parse_talloc(ctx, args[1]);
1905         if (sid == NULL) {
1906                 const char *sidstr;
1907                 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sidstr);
1908                 if (!NT_STATUS_IS_OK(status)) {
1909                         d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
1910                         return 1;
1911                 }
1912
1913                 d_printf("%s\n", sidstr);
1914         } else {
1915                 const char *name;
1916                 status = smblsa_lookup_sid(ctx->cli, args[1], ctx, &name);
1917                 if (!NT_STATUS_IS_OK(status)) {
1918                         d_printf("lsa_LookupSids - %s\n", nt_errstr(status));
1919                         return 1;
1920                 }
1921
1922                 d_printf("%s\n", name);
1923         }
1924
1925         return 0;
1926 }
1927
1928 /****************************************************************************
1929 show privileges for a user
1930 ****************************************************************************/
1931 static int cmd_privileges(struct smbclient_context *ctx, const char **args)
1932 {
1933         NTSTATUS status;
1934         struct dom_sid *sid;
1935         struct lsa_RightSet rights;
1936         unsigned i;
1937
1938         if (!args[1]) {
1939                 d_printf("privileges <sid|name>\n");
1940                 return 1;
1941         }
1942
1943         sid = dom_sid_parse_talloc(ctx, args[1]);
1944         if (sid == NULL) {
1945                 const char *sid_str;
1946                 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sid_str);
1947                 if (!NT_STATUS_IS_OK(status)) {
1948                         d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
1949                         return 1;
1950                 }
1951                 sid = dom_sid_parse_talloc(ctx, sid_str);
1952         }
1953
1954         status = smblsa_sid_privileges(ctx->cli, sid, ctx, &rights);
1955         if (!NT_STATUS_IS_OK(status)) {
1956                 d_printf("lsa_EnumAccountRights - %s\n", nt_errstr(status));
1957                 return 1;
1958         }
1959
1960         for (i=0;i<rights.count;i++) {
1961                 d_printf("\t%s\n", rights.names[i].string);
1962         }
1963
1964         return 0;
1965 }
1966
1967
1968 /****************************************************************************
1969 add privileges for a user
1970 ****************************************************************************/
1971 static int cmd_addprivileges(struct smbclient_context *ctx, const char **args)
1972 {
1973         NTSTATUS status;
1974         struct dom_sid *sid;
1975         struct lsa_RightSet rights;
1976         int i;
1977
1978         if (!args[1]) {
1979                 d_printf("addprivileges <sid|name> <privilege...>\n");
1980                 return 1;
1981         }
1982
1983         sid = dom_sid_parse_talloc(ctx, args[1]);
1984         if (sid == NULL) {
1985                 const char *sid_str;
1986                 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sid_str);
1987                 if (!NT_STATUS_IS_OK(status)) {
1988                         d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
1989                         return 1;
1990                 }
1991                 sid = dom_sid_parse_talloc(ctx, sid_str);
1992         }
1993
1994         ZERO_STRUCT(rights);
1995         for (i = 2; args[i]; i++) {
1996                 rights.names = talloc_realloc(ctx, rights.names,
1997                                               struct lsa_StringLarge, rights.count+1);
1998                 rights.names[rights.count].string = talloc_strdup(ctx, args[i]);
1999                 rights.count++;
2000         }
2001
2002
2003         status = smblsa_sid_add_privileges(ctx->cli, sid, ctx, &rights);
2004         if (!NT_STATUS_IS_OK(status)) {
2005                 d_printf("lsa_AddAccountRights - %s\n", nt_errstr(status));
2006                 return 1;
2007         }
2008
2009         return 0;
2010 }
2011
2012 /****************************************************************************
2013 delete privileges for a user
2014 ****************************************************************************/
2015 static int cmd_delprivileges(struct smbclient_context *ctx, const char **args)
2016 {
2017         NTSTATUS status;
2018         struct dom_sid *sid;
2019         struct lsa_RightSet rights;
2020         int i;
2021
2022         if (!args[1]) {
2023                 d_printf("delprivileges <sid|name> <privilege...>\n");
2024                 return 1;
2025         }
2026
2027         sid = dom_sid_parse_talloc(ctx, args[1]);
2028         if (sid == NULL) {
2029                 const char *sid_str;
2030                 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sid_str);
2031                 if (!NT_STATUS_IS_OK(status)) {
2032                         d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
2033                         return 1;
2034                 }
2035                 sid = dom_sid_parse_talloc(ctx, sid_str);
2036         }
2037
2038         ZERO_STRUCT(rights);
2039         for (i = 2; args[i]; i++) {
2040                 rights.names = talloc_realloc(ctx, rights.names,
2041                                               struct lsa_StringLarge, rights.count+1);
2042                 rights.names[rights.count].string = talloc_strdup(ctx, args[i]);
2043                 rights.count++;
2044         }
2045
2046
2047         status = smblsa_sid_del_privileges(ctx->cli, sid, ctx, &rights);
2048         if (!NT_STATUS_IS_OK(status)) {
2049                 d_printf("lsa_RemoveAccountRights - %s\n", nt_errstr(status));
2050                 return 1;
2051         }
2052
2053         return 0;
2054 }
2055
2056
2057 /****************************************************************************
2058 ****************************************************************************/
2059 static int cmd_open(struct smbclient_context *ctx, const char **args)
2060 {
2061         char *mask;
2062
2063         if (!args[1]) {
2064                 d_printf("open <filename>\n");
2065                 return 1;
2066         }
2067         mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2068
2069         smbcli_open(ctx->cli->tree, mask, O_RDWR, DENY_ALL);
2070
2071         return 0;
2072 }
2073
2074
2075 /****************************************************************************
2076 remove a directory
2077 ****************************************************************************/
2078 static int cmd_rmdir(struct smbclient_context *ctx, const char **args)
2079 {
2080         char *mask;
2081
2082         if (!args[1]) {
2083                 d_printf("rmdir <dirname>\n");
2084                 return 1;
2085         }
2086         mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2087
2088         if (NT_STATUS_IS_ERR(smbcli_rmdir(ctx->cli->tree, mask))) {
2089                 d_printf("%s removing remote directory file %s\n",
2090                          smbcli_errstr(ctx->cli->tree),mask);
2091         }
2092
2093         return 0;
2094 }
2095
2096 /****************************************************************************
2097  UNIX hardlink.
2098 ****************************************************************************/
2099 static int cmd_link(struct smbclient_context *ctx, const char **args)
2100 {
2101         char *src,*dest;
2102
2103         if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2104                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2105                 return 1;
2106         }
2107
2108
2109         if (!args[1] || !args[2]) {
2110                 d_printf("link <src> <dest>\n");
2111                 return 1;
2112         }
2113
2114         src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2115         dest = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2116
2117         if (NT_STATUS_IS_ERR(smbcli_unix_hardlink(ctx->cli->tree, src, dest))) {
2118                 d_printf("%s linking files (%s -> %s)\n", smbcli_errstr(ctx->cli->tree), src, dest);
2119                 return 1;
2120         }
2121
2122         return 0;
2123 }
2124
2125 /****************************************************************************
2126  UNIX symlink.
2127 ****************************************************************************/
2128
2129 static int cmd_symlink(struct smbclient_context *ctx, const char **args)
2130 {
2131         char *src,*dest;
2132
2133         if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2134                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2135                 return 1;
2136         }
2137
2138         if (!args[1] || !args[2]) {
2139                 d_printf("symlink <src> <dest>\n");
2140                 return 1;
2141         }
2142
2143         src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2144         dest = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2145
2146         if (NT_STATUS_IS_ERR(smbcli_unix_symlink(ctx->cli->tree, src, dest))) {
2147                 d_printf("%s symlinking files (%s -> %s)\n",
2148                         smbcli_errstr(ctx->cli->tree), src, dest);
2149                 return 1;
2150         }
2151
2152         return 0;
2153 }
2154
2155 /****************************************************************************
2156  UNIX chmod.
2157 ****************************************************************************/
2158
2159 static int cmd_chmod(struct smbclient_context *ctx, const char **args)
2160 {
2161         char *src;
2162         mode_t mode;
2163
2164         if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2165                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2166                 return 1;
2167         }
2168
2169         if (!args[1] || !args[2]) {
2170                 d_printf("chmod mode file\n");
2171                 return 1;
2172         }
2173
2174         src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2175
2176         mode = (mode_t)strtol(args[1], NULL, 8);
2177
2178         if (NT_STATUS_IS_ERR(smbcli_unix_chmod(ctx->cli->tree, src, mode))) {
2179                 d_printf("%s chmod file %s 0%o\n",
2180                         smbcli_errstr(ctx->cli->tree), src, (uint_t)mode);
2181                 return 1;
2182         }
2183
2184         return 0;
2185 }
2186
2187 /****************************************************************************
2188  UNIX chown.
2189 ****************************************************************************/
2190
2191 static int cmd_chown(struct smbclient_context *ctx, const char **args)
2192 {
2193         char *src;
2194         uid_t uid;
2195         gid_t gid;
2196
2197         if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2198                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2199                 return 1;
2200         }
2201
2202         if (!args[1] || !args[2] || !args[3]) {
2203                 d_printf("chown uid gid file\n");
2204                 return 1;
2205         }
2206
2207         uid = (uid_t)atoi(args[1]);
2208         gid = (gid_t)atoi(args[2]);
2209         src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[3]);
2210
2211         if (NT_STATUS_IS_ERR(smbcli_unix_chown(ctx->cli->tree, src, uid, gid))) {
2212                 d_printf("%s chown file %s uid=%d, gid=%d\n",
2213                         smbcli_errstr(ctx->cli->tree), src, (int)uid, (int)gid);
2214                 return 1;
2215         }
2216
2217         return 0;
2218 }
2219
2220 /****************************************************************************
2221 rename some files
2222 ****************************************************************************/
2223 static int cmd_rename(struct smbclient_context *ctx, const char **args)
2224 {
2225         char *src,*dest;
2226
2227         if (!args[1] || !args[2]) {
2228                 d_printf("rename <src> <dest>\n");
2229                 return 1;
2230         }
2231
2232         src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2233         dest = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2234
2235         if (NT_STATUS_IS_ERR(smbcli_rename(ctx->cli->tree, src, dest))) {
2236                 d_printf("%s renaming files\n",smbcli_errstr(ctx->cli->tree));
2237                 return 1;
2238         }
2239
2240         return 0;
2241 }
2242
2243
2244 /****************************************************************************
2245 toggle the prompt flag
2246 ****************************************************************************/
2247 static int cmd_prompt(struct smbclient_context *ctx, const char **args)
2248 {
2249         ctx->prompt = !ctx->prompt;
2250         DEBUG(2,("prompting is now %s\n",ctx->prompt?"on":"off"));
2251
2252         return 1;
2253 }
2254
2255
2256 /****************************************************************************
2257 set the newer than time
2258 ****************************************************************************/
2259 static int cmd_newer(struct smbclient_context *ctx, const char **args)
2260 {
2261         struct stat sbuf;
2262
2263         if (args[1] && (stat(args[1],&sbuf) == 0)) {
2264                 ctx->newer_than = sbuf.st_mtime;
2265                 DEBUG(1,("Getting files newer than %s",
2266                          asctime(localtime(&ctx->newer_than))));
2267         } else {
2268                 ctx->newer_than = 0;
2269         }
2270
2271         if (args[1] && ctx->newer_than == 0) {
2272                 d_printf("Error setting newer-than time\n");
2273                 return 1;
2274         }
2275
2276         return 0;
2277 }
2278
2279 /****************************************************************************
2280 set the archive level
2281 ****************************************************************************/
2282 static int cmd_archive(struct smbclient_context *ctx, const char **args)
2283 {
2284         if (args[1]) {
2285                 ctx->archive_level = atoi(args[1]);
2286         } else
2287                 d_printf("Archive level is %d\n",ctx->archive_level);
2288
2289         return 0;
2290 }
2291
2292 /****************************************************************************
2293 toggle the lowercaseflag
2294 ****************************************************************************/
2295 static int cmd_lowercase(struct smbclient_context *ctx, const char **args)
2296 {
2297         ctx->lowercase = !ctx->lowercase;
2298         DEBUG(2,("filename lowercasing is now %s\n",ctx->lowercase?"on":"off"));
2299
2300         return 0;
2301 }
2302
2303
2304
2305
2306 /****************************************************************************
2307 toggle the recurse flag
2308 ****************************************************************************/
2309 static int cmd_recurse(struct smbclient_context *ctx, const char **args)
2310 {
2311         ctx->recurse = !ctx->recurse;
2312         DEBUG(2,("directory recursion is now %s\n",ctx->recurse?"on":"off"));
2313
2314         return 0;
2315 }
2316
2317 /****************************************************************************
2318 toggle the translate flag
2319 ****************************************************************************/
2320 static int cmd_translate(struct smbclient_context *ctx, const char **args)
2321 {
2322         ctx->translation = !ctx->translation;
2323         DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
2324                  ctx->translation?"on":"off"));
2325
2326         return 0;
2327 }
2328
2329
2330 /****************************************************************************
2331 do a printmode command
2332 ****************************************************************************/
2333 static int cmd_printmode(struct smbclient_context *ctx, const char **args)
2334 {
2335         if (args[1]) {
2336                 if (strequal(args[1],"text")) {
2337                         ctx->printmode = 0;
2338                 } else {
2339                         if (strequal(args[1],"graphics"))
2340                                 ctx->printmode = 1;
2341                         else
2342                                 ctx->printmode = atoi(args[1]);
2343                 }
2344         }
2345
2346         switch(ctx->printmode)
2347         {
2348                 case 0:
2349                         DEBUG(2,("the printmode is now text\n"));
2350                         break;
2351                 case 1:
2352                         DEBUG(2,("the printmode is now graphics\n"));
2353                         break;
2354                 default:
2355                         DEBUG(2,("the printmode is now %d\n", ctx->printmode));
2356                         break;
2357         }
2358
2359         return 0;
2360 }
2361
2362 /****************************************************************************
2363  do the lcd command
2364  ****************************************************************************/
2365 static int cmd_lcd(struct smbclient_context *ctx, const char **args)
2366 {
2367         char d[PATH_MAX];
2368
2369         if (args[1])
2370                 chdir(args[1]);
2371         DEBUG(2,("the local directory is now %s\n",getcwd(d, PATH_MAX)));
2372
2373         return 0;
2374 }
2375
2376 /****************************************************************************
2377 history
2378 ****************************************************************************/
2379 static int cmd_history(struct smbclient_context *ctx, const char **args)
2380 {
2381 #if defined(HAVE_LIBREADLINE)
2382         HIST_ENTRY **hlist;
2383         int i;
2384
2385         hlist = history_list();
2386
2387         for (i = 0; hlist && hlist[i]; i++) {
2388                 DEBUG(0, ("%d: %s\n", i, hlist[i]->line));
2389         }
2390 #else
2391         DEBUG(0,("no history without readline support\n"));
2392 #endif
2393
2394         return 0;
2395 }
2396
2397 /****************************************************************************
2398  get a file restarting at end of local file
2399  ****************************************************************************/
2400 static int cmd_reget(struct smbclient_context *ctx, const char **args)
2401 {
2402         char *local_name;
2403         char *remote_name;
2404
2405         if (!args[1]) {
2406                 d_printf("reget <filename>\n");
2407                 return 1;
2408         }
2409         remote_name = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
2410         dos_clean_name(remote_name);
2411
2412         if (args[2])
2413                 local_name = talloc_strdup(ctx, args[2]);
2414         else
2415                 local_name = talloc_strdup(ctx, args[1]);
2416
2417         return do_get(ctx, remote_name, local_name, True);
2418 }
2419
2420 /****************************************************************************
2421  put a file restarting at end of local file
2422  ****************************************************************************/
2423 static int cmd_reput(struct smbclient_context *ctx, const char **args)
2424 {
2425         char *local_name;
2426         char *remote_name;
2427
2428         if (!args[1]) {
2429                 d_printf("reput <filename>\n");
2430                 return 1;
2431         }
2432         local_name = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
2433
2434         if (!file_exist(local_name)) {
2435                 d_printf("%s does not exist\n", local_name);
2436                 return 1;
2437         }
2438
2439         if (args[2])
2440                 remote_name = talloc_strdup(ctx, args[2]);
2441         else
2442                 remote_name = talloc_strdup(ctx, args[1]);
2443
2444         dos_clean_name(remote_name);
2445
2446         return do_put(ctx, remote_name, local_name, True);
2447 }
2448
2449
2450 /*
2451   return a string representing a share type
2452 */
2453 static const char *share_type_str(uint32_t type)
2454 {
2455         switch (type & 0xF) {
2456         case STYPE_DISKTREE:
2457                 return "Disk";
2458         case STYPE_PRINTQ:
2459                 return "Printer";
2460         case STYPE_DEVICE:
2461                 return "Device";
2462         case STYPE_IPC:
2463                 return "IPC";
2464         default:
2465                 return "Unknown";
2466         }
2467 }
2468
2469
2470 /*
2471   display a list of shares from a level 1 share enum
2472 */
2473 static void display_share_result(struct srvsvc_NetShareCtr1 *ctr1)
2474 {
2475         int i;
2476
2477         for (i=0;i<ctr1->count;i++) {
2478                 struct srvsvc_NetShareInfo1 *info = ctr1->array+i;
2479
2480                 printf("\t%-15s %-10.10s %s\n",
2481                        info->name,
2482                        share_type_str(info->type),
2483                        info->comment);
2484         }
2485 }
2486
2487
2488
2489 /****************************************************************************
2490 try and browse available shares on a host
2491 ****************************************************************************/
2492 static BOOL browse_host(const char *query_host)
2493 {
2494         struct dcerpc_pipe *p;
2495         char *binding;
2496         NTSTATUS status;
2497         struct srvsvc_NetShareEnumAll r;
2498         uint32_t resume_handle = 0;
2499         TALLOC_CTX *mem_ctx = talloc_init("browse_host");
2500         struct srvsvc_NetShareCtr1 ctr1;
2501
2502         binding = talloc_asprintf(mem_ctx, "ncacn_np:%s", query_host);
2503
2504         status = dcerpc_pipe_connect(mem_ctx, &p, binding,
2505                                          &dcerpc_table_srvsvc,
2506                                      cmdline_credentials, NULL);
2507         if (!NT_STATUS_IS_OK(status)) {
2508                 d_printf("Failed to connect to %s - %s\n",
2509                          binding, nt_errstr(status));
2510                 talloc_free(mem_ctx);
2511                 return False;
2512         }
2513
2514         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
2515         r.in.level = 1;
2516         r.in.ctr.ctr1 = &ctr1;
2517         r.in.max_buffer = ~0;
2518         r.in.resume_handle = &resume_handle;
2519
2520         d_printf("\n\tSharename       Type       Comment\n");
2521         d_printf("\t---------       ----       -------\n");
2522
2523         do {
2524                 ZERO_STRUCT(ctr1);
2525                 status = dcerpc_srvsvc_NetShareEnumAll(p, mem_ctx, &r);
2526
2527                 if (NT_STATUS_IS_OK(status) &&
2528                     (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA) ||
2529                      W_ERROR_IS_OK(r.out.result)) &&
2530                     r.out.ctr.ctr1) {
2531                         display_share_result(r.out.ctr.ctr1);
2532                         resume_handle += r.out.ctr.ctr1->count;
2533                 }
2534         } while (NT_STATUS_IS_OK(status) && W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA));
2535
2536         talloc_free(mem_ctx);
2537
2538         if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
2539                 d_printf("Failed NetShareEnumAll %s - %s/%s\n",
2540                          binding, nt_errstr(status), win_errstr(r.out.result));
2541                 return False;
2542         }
2543
2544         return False;
2545 }
2546
2547 /****************************************************************************
2548 try and browse available connections on a host
2549 ****************************************************************************/
2550 static BOOL list_servers(const char *wk_grp)
2551 {
2552         d_printf("REWRITE: list servers not implemented\n");
2553         return False;
2554 }
2555
2556 /* Some constants for completing filename arguments */
2557
2558 #define COMPL_NONE        0          /* No completions */
2559 #define COMPL_REMOTE      1          /* Complete remote filename */
2560 #define COMPL_LOCAL       2          /* Complete local filename */
2561
2562 static int cmd_help(struct smbclient_context *ctx, const char **args);
2563
2564 /* This defines the commands supported by this client.
2565  * NOTE: The "!" must be the last one in the list because it's fn pointer
2566  *       field is NULL, and NULL in that field is used in process_tok()
2567  *       (below) to indicate the end of the list.  crh
2568  */
2569 static struct
2570 {
2571   const char *name;
2572   int (*fn)(struct smbclient_context *ctx, const char **args);
2573   const char *description;
2574   char compl_args[2];      /* Completion argument info */
2575 } commands[] =
2576 {
2577   {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
2578   {"addprivileges",cmd_addprivileges,"<sid|name> <privilege...> add privileges for a user",{COMPL_NONE,COMPL_NONE}},
2579   {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
2580   {"acl",cmd_acl,"<file> show file ACL",{COMPL_NONE,COMPL_NONE}},
2581   {"allinfo",cmd_allinfo,"<file> show all possible info about a file",{COMPL_NONE,COMPL_NONE}},
2582   {"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}},
2583   {"cancel",cmd_rewrite,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
2584   {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
2585   {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},
2586   {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},
2587   {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
2588   {"delprivileges",cmd_delprivileges,"<sid|name> <privilege...> remove privileges for a user",{COMPL_NONE,COMPL_NONE}},
2589   {"deltree",cmd_deltree,"<dir> delete a whole directory tree",{COMPL_REMOTE,COMPL_NONE}},
2590   {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2591   {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2592   {"eainfo",cmd_eainfo,"<file> show EA contents for a file",{COMPL_NONE,COMPL_NONE}},
2593   {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2594   {"fsinfo",cmd_fsinfo,"query file system info",{COMPL_NONE,COMPL_NONE}},
2595   {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
2596   {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
2597   {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
2598   {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
2599   {"link",cmd_link,"<src> <dest> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
2600   {"lookup",cmd_lookup,"<sid|name> show SID for name or name for SID",{COMPL_NONE,COMPL_NONE}},
2601   {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
2602   {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2603   {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},
2604   {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
2605   {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
2606   {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
2607   {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
2608   {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
2609   {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
2610   {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
2611   {"privileges",cmd_privileges,"<user> show privileges for a user",{COMPL_NONE,COMPL_NONE}},
2612   {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
2613   {"printmode",cmd_printmode,"<graphics or text> set the print mode",{COMPL_NONE,COMPL_NONE}},
2614   {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
2615   {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
2616   {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
2617   {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2618   {"queue",cmd_rewrite,"show the print queue",{COMPL_NONE,COMPL_NONE}},
2619   {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2620   {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
2621   {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
2622   {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
2623   {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
2624   {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
2625   {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
2626   {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
2627   {"symlink",cmd_symlink,"<src> <dest> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
2628   {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
2629
2630   /* Yes, this must be here, see crh's comment above. */
2631   {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
2632   {NULL,NULL,NULL,{COMPL_NONE,COMPL_NONE}}
2633 };
2634
2635
2636 /*******************************************************************
2637   lookup a command string in the list of commands, including
2638   abbreviations
2639   ******************************************************************/
2640 static int process_tok(const char *tok)
2641 {
2642         int i = 0, matches = 0;
2643         int cmd=0;
2644         int tok_len = strlen(tok);
2645
2646         while (commands[i].fn != NULL) {
2647                 if (strequal(commands[i].name,tok)) {
2648                         matches = 1;
2649                         cmd = i;
2650                         break;
2651                 } else if (strncasecmp(commands[i].name, tok, tok_len) == 0) {
2652                         matches++;
2653                         cmd = i;
2654                 }
2655                 i++;
2656         }
2657
2658         if (matches == 0)
2659                 return(-1);
2660         else if (matches == 1)
2661                 return(cmd);
2662         else
2663                 return(-2);
2664 }
2665
2666 /****************************************************************************
2667 help
2668 ****************************************************************************/
2669 static int cmd_help(struct smbclient_context *ctx, const char **args)
2670 {
2671         int i=0,j;
2672
2673         if (args[1]) {
2674                 if ((i = process_tok(args[1])) >= 0)
2675                         d_printf("HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description);
2676         } else {
2677                 while (commands[i].description) {
2678                         for (j=0; commands[i].description && (j<5); j++) {
2679                                 d_printf("%-15s",commands[i].name);
2680                                 i++;
2681                         }
2682                         d_printf("\n");
2683                 }
2684         }
2685         return 0;
2686 }
2687
2688 static int process_line(struct smbclient_context *ctx, const char *cline);
2689 /****************************************************************************
2690 process a -c command string
2691 ****************************************************************************/
2692 static int process_command_string(struct smbclient_context *ctx, const char *cmd)
2693 {
2694         const char **lines;
2695         int i, rc = 0;
2696
2697         lines = str_list_make(NULL, cmd, ";");
2698         for (i = 0; lines[i]; i++) {
2699                 rc |= process_line(ctx, lines[i]);
2700         }
2701         talloc_free(lines);
2702
2703         return rc;
2704 }
2705
2706 #define MAX_COMPLETIONS 100
2707
2708 typedef struct {
2709         char *dirmask;
2710         char **matches;
2711         int count, samelen;
2712         const char *text;
2713         int len;
2714 } completion_remote_t;
2715
2716 static void completion_remote_filter(struct clilist_file_info *f, const char *mask, void *state)
2717 {
2718         completion_remote_t *info = (completion_remote_t *)state;
2719
2720         if ((info->count < MAX_COMPLETIONS - 1) && (strncmp(info->text, f->name, info->len) == 0) && (strcmp(f->name, ".") != 0) && (strcmp(f->name, "..") != 0)) {
2721                 if ((info->dirmask[0] == 0) && !(f->attrib & FILE_ATTRIBUTE_DIRECTORY))
2722                         info->matches[info->count] = strdup(f->name);
2723                 else {
2724                         char *tmp;
2725
2726                         if (info->dirmask[0] != 0)
2727                                 tmp = talloc_asprintf(NULL, "%s/%s", info->dirmask, f->name);
2728                         else
2729                                 tmp = talloc_strdup(NULL, f->name);
2730
2731                         if (f->attrib & FILE_ATTRIBUTE_DIRECTORY)
2732                                 tmp = talloc_append_string(NULL, tmp, "/");
2733                         info->matches[info->count] = tmp;
2734                 }
2735                 if (info->matches[info->count] == NULL)
2736                         return;
2737                 if (f->attrib & FILE_ATTRIBUTE_DIRECTORY)
2738                         smb_readline_ca_char(0);
2739
2740                 if (info->count == 1)
2741                         info->samelen = strlen(info->matches[info->count]);
2742                 else
2743                         while (strncmp(info->matches[info->count], info->matches[info->count-1], info->samelen) != 0)
2744                                 info->samelen--;
2745                 info->count++;
2746         }
2747 }
2748
2749 static char **remote_completion(const char *text, int len)
2750 {
2751         char *dirmask;
2752         int i;
2753         completion_remote_t info;
2754
2755         info.samelen = len;
2756         info.text = text;
2757         info.len = len;
2758
2759         if (len >= PATH_MAX)
2760                 return(NULL);
2761
2762         info.matches = malloc_array_p(char *, MAX_COMPLETIONS);
2763         if (!info.matches) return NULL;
2764         info.matches[0] = NULL;
2765
2766         for (i = len-1; i >= 0; i--)
2767                 if ((text[i] == '/') || (text[i] == '\\'))
2768                         break;
2769         info.text = text+i+1;
2770         info.samelen = info.len = len-i-1;
2771
2772         if (i > 0) {
2773                 info.dirmask = talloc_strndup(NULL, text, i+1);
2774                 info.dirmask[i+1] = 0;
2775                 asprintf(&dirmask, "%s%*s*", rl_ctx->remote_cur_dir, i-1, text);
2776         } else
2777                 asprintf(&dirmask, "%s*", rl_ctx->remote_cur_dir);
2778
2779         if (smbcli_list(rl_ctx->cli->tree, dirmask,
2780                      FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
2781                      completion_remote_filter, &info) < 0)
2782                 goto cleanup;
2783
2784         if (info.count == 2)
2785                 info.matches[0] = strdup(info.matches[1]);
2786         else {
2787                 info.matches[0] = malloc(info.samelen+1);
2788                 if (!info.matches[0])
2789                         goto cleanup;
2790                 strncpy(info.matches[0], info.matches[1], info.samelen);
2791                 info.matches[0][info.samelen] = 0;
2792         }
2793         info.matches[info.count] = NULL;
2794         return info.matches;
2795
2796 cleanup:
2797         for (i = 0; i < info.count; i++)
2798                 free(info.matches[i]);
2799         free(info.matches);
2800         return NULL;
2801 }
2802
2803 static char **completion_fn(const char *text, int start, int end)
2804 {
2805         smb_readline_ca_char(' ');
2806
2807         if (start) {
2808                 const char *buf, *sp;
2809                 int i;
2810                 char compl_type;
2811
2812                 buf = smb_readline_get_line_buffer();
2813                 if (buf == NULL)
2814                         return NULL;
2815
2816                 sp = strchr(buf, ' ');
2817                 if (sp == NULL)
2818                         return NULL;
2819
2820                 for (i = 0; commands[i].name; i++)
2821                         if ((strncmp(commands[i].name, text, sp - buf) == 0) && (commands[i].name[sp - buf] == 0))
2822                                 break;
2823                 if (commands[i].name == NULL)
2824                         return NULL;
2825
2826                 while (*sp == ' ')
2827                         sp++;
2828
2829                 if (sp == (buf + start))
2830                         compl_type = commands[i].compl_args[0];
2831                 else
2832                         compl_type = commands[i].compl_args[1];
2833
2834                 if (compl_type == COMPL_REMOTE)
2835                         return remote_completion(text, end - start);
2836                 else /* fall back to local filename completion */
2837                         return NULL;
2838         } else {
2839                 char **matches;
2840                 int i, len, samelen = 0, count=1;
2841
2842                 matches = malloc_array_p(char *, MAX_COMPLETIONS);
2843                 if (!matches) return NULL;
2844                 matches[0] = NULL;
2845
2846                 len = strlen(text);
2847                 for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
2848                         if (strncmp(text, commands[i].name, len) == 0) {
2849                                 matches[count] = strdup(commands[i].name);
2850                                 if (!matches[count])
2851                                         goto cleanup;
2852                                 if (count == 1)
2853                                         samelen = strlen(matches[count]);
2854                                 else
2855                                         while (strncmp(matches[count], matches[count-1], samelen) != 0)
2856                                                 samelen--;
2857                                 count++;
2858                         }
2859                 }
2860
2861                 switch (count) {
2862                 case 0: /* should never happen */
2863                 case 1:
2864                         goto cleanup;
2865                 case 2:
2866                         matches[0] = strdup(matches[1]);
2867                         break;
2868                 default:
2869                         matches[0] = malloc(samelen+1);
2870                         if (!matches[0])
2871                                 goto cleanup;
2872                         strncpy(matches[0], matches[1], samelen);
2873                         matches[0][samelen] = 0;
2874                 }
2875                 matches[count] = NULL;
2876                 return matches;
2877
2878 cleanup:
2879                 while (i >= 0) {
2880                         free(matches[i]);
2881                         i--;
2882                 }
2883                 free(matches);
2884                 return NULL;
2885         }
2886 }
2887
2888 /****************************************************************************
2889 make sure we swallow keepalives during idle time
2890 ****************************************************************************/
2891 static void readline_callback(void)
2892 {
2893         static time_t last_t;
2894         time_t t;
2895
2896         t = time(NULL);
2897
2898         if (t - last_t < 5) return;
2899
2900         last_t = t;
2901
2902         smbcli_transport_process(rl_ctx->cli->transport);
2903
2904         if (rl_ctx->cli->tree) {
2905                 smbcli_chkpath(rl_ctx->cli->tree, "\\");
2906         }
2907 }
2908
2909 static int process_line(struct smbclient_context *ctx, const char *cline)
2910 {
2911         const char **args;
2912         int i;
2913
2914         /* and get the first part of the command */
2915         args = str_list_make_shell(ctx, cline, NULL);
2916         if (!args || !args[0])
2917                 return 0;
2918
2919         if ((i = process_tok(args[0])) >= 0) {
2920                 i = commands[i].fn(ctx, args);
2921         } else if (i == -2) {
2922                 d_printf("%s: command abbreviation ambiguous\n",args[0]);
2923         } else {
2924                 d_printf("%s: command not found\n",args[0]);
2925         }
2926
2927         talloc_free(args);
2928
2929         return i;
2930 }
2931
2932 /****************************************************************************
2933 process commands on stdin
2934 ****************************************************************************/
2935 static int process_stdin(struct smbclient_context *ctx)
2936 {
2937         int rc = 0;
2938         while (1) {
2939                 /* display a prompt */
2940                 char *the_prompt = talloc_asprintf(ctx, "smb: %s> ", ctx->remote_cur_dir);
2941                 char *cline = smb_readline(the_prompt, readline_callback, completion_fn);
2942                 talloc_free(the_prompt);
2943
2944                 if (!cline) break;
2945
2946                 /* special case - first char is ! */
2947                 if (*cline == '!') {
2948                         system(cline + 1);
2949                         continue;
2950                 }
2951
2952                 rc |= process_command_string(ctx, cline);
2953         }
2954
2955         return rc;
2956 }
2957
2958
2959 /*****************************************************
2960 return a connection to a server
2961 *******************************************************/
2962 static struct smbclient_context *do_connect(TALLOC_CTX *mem_ctx,
2963                                        const char *server, const char *share, struct cli_credentials *cred)
2964 {
2965         NTSTATUS status;
2966         struct smbclient_context *ctx = talloc_zero(mem_ctx, struct smbclient_context);
2967         if (!ctx) {
2968                 return NULL;
2969         }
2970
2971         rl_ctx = ctx; /* Ugly hack */
2972
2973         if (strncmp(share, "\\\\", 2) == 0 ||
2974             strncmp(share, "//", 2) == 0) {
2975                 smbcli_parse_unc(share, ctx, &server, &share);
2976         }
2977
2978         ctx->remote_cur_dir = talloc_strdup(ctx, "\\");
2979
2980         status = smbcli_full_connection(ctx, &ctx->cli, server,
2981                                         share, NULL, cred, NULL);
2982         if (!NT_STATUS_IS_OK(status)) {
2983                 d_printf("Connection to \\\\%s\\%s failed - %s\n",
2984                          server, share, nt_errstr(status));
2985                 talloc_free(ctx);
2986                 return NULL;
2987         }
2988
2989         return ctx;
2990 }
2991
2992 /****************************************************************************
2993 handle a -L query
2994 ****************************************************************************/
2995 static int do_host_query(const char *query_host)
2996 {
2997         browse_host(query_host);
2998         list_servers(lp_workgroup());
2999         return(0);
3000 }
3001
3002
3003 /****************************************************************************
3004 handle a message operation
3005 ****************************************************************************/
3006 static int do_message_op(const char *desthost, const char *destip, int name_type)
3007 {
3008         struct nbt_name called, calling;
3009         const char *server_name;
3010         struct smbcli_state *cli;
3011
3012         make_nbt_name_client(&calling, lp_netbios_name());
3013
3014         nbt_choose_called_name(NULL, &called, desthost, name_type);
3015
3016         server_name = destip ? destip : desthost;
3017
3018         if (!(cli=smbcli_state_init(NULL)) || !smbcli_socket_connect(cli, server_name)) {
3019                 d_printf("Connection to %s failed\n", server_name);
3020                 return 1;
3021         }
3022
3023         if (!smbcli_transport_establish(cli, &calling, &called)) {
3024                 d_printf("session request failed\n");
3025                 talloc_free(cli);
3026                 return 1;
3027         }
3028
3029         send_message(cli, desthost);
3030         talloc_free(cli);
3031
3032         return 0;
3033 }
3034
3035
3036 /****************************************************************************
3037   main program
3038 ****************************************************************************/
3039  int main(int argc,char *argv[])
3040 {
3041         const char *base_directory = NULL;
3042         const char *dest_ip;
3043         int opt;
3044         const char *query_host = NULL;
3045         BOOL message = False;
3046         const char *desthost;
3047 #ifdef KANJI
3048         const char *term_code = KANJI;
3049 #else
3050         const char *term_code = "";
3051 #endif /* KANJI */
3052         poptContext pc;
3053         const char *service = NULL;
3054         int port = 0;
3055         char *p;
3056         int rc = 0;
3057         int name_type = 0x20;
3058         TALLOC_CTX *mem_ctx;
3059         struct smbclient_context *ctx;
3060         const char *cmdstr = NULL;
3061
3062         struct poptOption long_options[] = {
3063                 POPT_AUTOHELP
3064
3065                 { "message", 'M', POPT_ARG_STRING, NULL, 'M', "Send message", "HOST" },
3066                 { "ip-address", 'I', POPT_ARG_STRING, NULL, 'I', "Use this IP to connect to", "IP" },
3067                 { "stderr", 'E', POPT_ARG_NONE, NULL, 'E', "Write messages to stderr instead of stdout" },
3068                 { "list", 'L', POPT_ARG_STRING, NULL, 'L', "Get a list of shares available on a host", "HOST" },
3069                 { "terminal", 't', POPT_ARG_STRING, NULL, 't', "Terminal I/O code {sjis|euc|jis7|jis8|junet|hex}", "CODE" },
3070                 { "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
3071                 { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },
3072                 { "send-buffer", 'b', POPT_ARG_INT, NULL, 'b', "Changes the transmit/send buffer", "BYTES" },
3073                 { "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
3074                 POPT_COMMON_SAMBA
3075                 POPT_COMMON_CONNECTION
3076                 POPT_COMMON_CREDENTIALS
3077                 POPT_COMMON_VERSION
3078                 POPT_TABLEEND
3079         };
3080
3081         mem_ctx = talloc_init("client.c/main");
3082         if (!mem_ctx) {
3083                 d_printf("\nclient.c: Not enough memory\n");
3084                 exit(1);
3085         }
3086
3087         pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 0);
3088         poptSetOtherOptionHelp(pc, "[OPTIONS] service <password>");
3089
3090         while ((opt = poptGetNextOpt(pc)) != -1) {
3091                 switch (opt) {
3092                 case 'M':
3093                         /* Messages are sent to NetBIOS name type 0x3
3094                          * (Messenger Service).  Make sure we default
3095                          * to port 139 instead of port 445. srl,crh
3096                          */
3097                         name_type = 0x03;
3098                         desthost = strdup(poptGetOptArg(pc));
3099                         if( 0 == port ) port = 139;
3100                         message = True;
3101                         break;
3102                 case 'I':
3103                         dest_ip = poptGetOptArg(pc);
3104                         break;
3105                 case 'L':
3106                         query_host = strdup(poptGetOptArg(pc));
3107                         break;
3108                 case 't':
3109                         term_code = strdup(poptGetOptArg(pc));
3110                         break;
3111                 case 'D':
3112                         base_directory = strdup(poptGetOptArg(pc));
3113                         break;
3114                 case 'b':
3115                         io_bufsize = MAX(1, atoi(poptGetOptArg(pc)));
3116                         break;
3117                 }
3118         }
3119
3120         gensec_init();
3121
3122         if(poptPeekArg(pc)) {
3123                 char *s = strdup(poptGetArg(pc));
3124
3125                 /* Convert any '/' characters in the service name to '\' characters */
3126                 string_replace(s, '/','\\');
3127
3128                 service = s;
3129
3130                 if (count_chars(s,'\\') < 3) {
3131                         d_printf("\n%s: Not enough '\\' characters in service\n",s);
3132                         poptPrintUsage(pc, stderr, 0);
3133                         exit(1);
3134                 }
3135         }
3136
3137         if (poptPeekArg(pc)) {
3138                 cli_credentials_set_password(cmdline_credentials, poptGetArg(pc), CRED_SPECIFIED);
3139         }
3140
3141         /*init_names(); */
3142
3143         if (!query_host && !service && !message) {
3144                 poptPrintUsage(pc, stderr, 0);
3145                 exit(1);
3146         }
3147
3148         poptFreeContext(pc);
3149
3150         DEBUG( 3, ( "Client started (version %s).\n", SAMBA_VERSION_STRING ) );
3151
3152         if (query_host && (p=strchr_m(query_host,'#'))) {
3153                 *p = 0;
3154                 p++;
3155                 sscanf(p, "%x", &name_type);
3156         }
3157
3158         if (query_host) {
3159                 return do_host_query(query_host);
3160         }
3161
3162         if (message) {
3163                 return do_message_op(desthost, dest_ip, name_type);
3164         }
3165
3166
3167         ctx = do_connect(mem_ctx, desthost, service, cmdline_credentials);
3168         if (!ctx)
3169                 return 1;
3170
3171         if (base_directory)
3172                 do_cd(ctx, base_directory);
3173
3174         if (cmdstr) {
3175                 rc = process_command_string(ctx, cmdstr);
3176         } else {
3177                 rc = process_stdin(ctx);
3178         }
3179
3180         talloc_free(mem_ctx);
3181
3182         return rc;
3183 }