Remove the static "struct client_connection" mess which is part of
[jra/samba/.git] / source3 / client / client.c
1 /*
2    Unix SMB/CIFS implementation.
3    SMB client
4    Copyright (C) Andrew Tridgell          1994-1998
5    Copyright (C) Simo Sorce               2001-2002
6    Copyright (C) Jelmer Vernooij          2003
7    Copyright (C) Gerald (Jerry) Carter    2004
8    Copyright (C) Jeremy Allison           1994-2007
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "client/client_proto.h"
26 #include "include/rpc_client.h"
27 #ifndef REGISTER
28 #define REGISTER 0
29 #endif
30
31 extern int do_smb_browse(void); /* mDNS browsing */
32
33 extern bool AllowDebugChange;
34 extern bool override_logfile;
35 extern char tar_type;
36
37 static int port = 0;
38 static char *service;
39 static char *desthost;
40 static char *calling_name;
41 static bool grepable = false;
42 static char *cmdstr = NULL;
43 const char *cmd_ptr = NULL;
44
45 static int io_bufsize = 524288;
46
47 static int name_type = 0x20;
48 static int max_protocol = PROTOCOL_NT1;
49
50 static int process_tok(char *tok);
51 static int cmd_help(void);
52
53 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
54
55 /* 30 second timeout on most commands */
56 #define CLIENT_TIMEOUT (30*1000)
57 #define SHORT_TIMEOUT (5*1000)
58
59 /* value for unused fid field in trans2 secondary request */
60 #define FID_UNUSED (0xFFFF)
61
62 time_t newer_than = 0;
63 static int archive_level = 0;
64
65 static bool translation = false;
66 static bool have_ip;
67
68 /* clitar bits insert */
69 extern int blocksize;
70 extern bool tar_inc;
71 extern bool tar_reset;
72 /* clitar bits end */
73
74 static bool prompt = true;
75
76 static bool recurse = false;
77 static bool showacls = false;
78 bool lowercase = false;
79
80 static struct sockaddr_storage dest_ss;
81 static char dest_ss_str[INET6_ADDRSTRLEN];
82
83 #define SEPARATORS " \t\n\r"
84
85 static bool abort_mget = true;
86
87 /* timing globals */
88 uint64_t get_total_size = 0;
89 unsigned int get_total_time_ms = 0;
90 static uint64_t put_total_size = 0;
91 static unsigned int put_total_time_ms = 0;
92
93 /* totals globals */
94 static double dir_total;
95
96 /* encrypted state. */
97 static bool smb_encrypt;
98
99 /* root cli_state connection */
100
101 struct cli_state *cli;
102
103 static char CLI_DIRSEP_CHAR = '\\';
104 static char CLI_DIRSEP_STR[] = { '\\', '\0' };
105
106 /* Accessor functions for directory paths. */
107 static char *fileselection;
108 static const char *client_get_fileselection(void)
109 {
110         if (fileselection) {
111                 return fileselection;
112         }
113         return "";
114 }
115
116 static const char *client_set_fileselection(const char *new_fs)
117 {
118         SAFE_FREE(fileselection);
119         if (new_fs) {
120                 fileselection = SMB_STRDUP(new_fs);
121         }
122         return client_get_fileselection();
123 }
124
125 static char *cwd;
126 static const char *client_get_cwd(void)
127 {
128         if (cwd) {
129                 return cwd;
130         }
131         return CLI_DIRSEP_STR;
132 }
133
134 static const char *client_set_cwd(const char *new_cwd)
135 {
136         SAFE_FREE(cwd);
137         if (new_cwd) {
138                 cwd = SMB_STRDUP(new_cwd);
139         }
140         return client_get_cwd();
141 }
142
143 static char *cur_dir;
144 const char *client_get_cur_dir(void)
145 {
146         if (cur_dir) {
147                 return cur_dir;
148         }
149         return CLI_DIRSEP_STR;
150 }
151
152 const char *client_set_cur_dir(const char *newdir)
153 {
154         SAFE_FREE(cur_dir);
155         if (newdir) {
156                 cur_dir = SMB_STRDUP(newdir);
157         }
158         return client_get_cur_dir();
159 }
160
161 /****************************************************************************
162  Write to a local file with CR/LF->LF translation if appropriate. Return the
163  number taken from the buffer. This may not equal the number written.
164 ****************************************************************************/
165
166 static int writefile(int f, char *b, int n)
167 {
168         int i;
169
170         if (!translation) {
171                 return write(f,b,n);
172         }
173
174         i = 0;
175         while (i < n) {
176                 if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
177                         b++;i++;
178                 }
179                 if (write(f, b, 1) != 1) {
180                         break;
181                 }
182                 b++;
183                 i++;
184         }
185
186         return(i);
187 }
188
189 /****************************************************************************
190  Read from a file with LF->CR/LF translation if appropriate. Return the
191  number read. read approx n bytes.
192 ****************************************************************************/
193
194 static int readfile(uint8_t *b, int n, XFILE *f)
195 {
196         int i;
197         int c;
198
199         if (!translation)
200                 return x_fread(b,1,n,f);
201
202         i = 0;
203         while (i < (n - 1) && (i < BUFFER_SIZE)) {
204                 if ((c = x_getc(f)) == EOF) {
205                         break;
206                 }
207
208                 if (c == '\n') { /* change all LFs to CR/LF */
209                         b[i++] = '\r';
210                 }
211
212                 b[i++] = c;
213         }
214
215         return(i);
216 }
217
218 struct push_state {
219         XFILE *f;
220         SMB_OFF_T nread;
221 };
222
223 static size_t push_source(uint8_t *buf, size_t n, void *priv)
224 {
225         struct push_state *state = (struct push_state *)priv;
226         int result;
227
228         if (x_feof(state->f)) {
229                 return 0;
230         }
231
232         result = readfile(buf, n, state->f);
233         state->nread += result;
234         return result;
235 }
236
237 /****************************************************************************
238  Send a message.
239 ****************************************************************************/
240
241 static void send_message(const char *username)
242 {
243         int total_len = 0;
244         int grp_id;
245
246         if (!cli_message_start(cli, desthost, username, &grp_id)) {
247                 d_printf("message start: %s\n", cli_errstr(cli));
248                 return;
249         }
250
251
252         d_printf("Connected. Type your message, ending it with a Control-D\n");
253
254         while (!feof(stdin) && total_len < 1600) {
255                 int maxlen = MIN(1600 - total_len,127);
256                 char msg[1024];
257                 int l=0;
258                 int c;
259
260                 ZERO_ARRAY(msg);
261
262                 for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
263                         if (c == '\n')
264                                 msg[l++] = '\r';
265                         msg[l] = c;
266                 }
267
268                 if ((total_len > 0) && (strlen(msg) == 0)) {
269                         break;
270                 }
271
272                 if (!cli_message_text(cli, msg, l, grp_id)) {
273                         d_printf("SMBsendtxt failed (%s)\n",cli_errstr(cli));
274                         return;
275                 }
276
277                 total_len += l;
278         }
279
280         if (total_len >= 1600)
281                 d_printf("the message was truncated to 1600 bytes\n");
282         else
283                 d_printf("sent %d bytes\n",total_len);
284
285         if (!cli_message_end(cli, grp_id)) {
286                 d_printf("SMBsendend failed (%s)\n",cli_errstr(cli));
287                 return;
288         }
289 }
290
291 /****************************************************************************
292  Check the space on a device.
293 ****************************************************************************/
294
295 static int do_dskattr(void)
296 {
297         int total, bsize, avail;
298         struct cli_state *targetcli = NULL;
299         char *targetpath = NULL;
300         TALLOC_CTX *ctx = talloc_tos();
301
302         if ( !cli_resolve_path(ctx, "", cli, client_get_cur_dir(), &targetcli, &targetpath)) {
303                 d_printf("Error in dskattr: %s\n", cli_errstr(cli));
304                 return 1;
305         }
306
307         if (!cli_dskattr(targetcli, &bsize, &total, &avail)) {
308                 d_printf("Error in dskattr: %s\n",cli_errstr(targetcli));
309                 return 1;
310         }
311
312         d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
313                  total, bsize, avail);
314
315         return 0;
316 }
317
318 /****************************************************************************
319  Show cd/pwd.
320 ****************************************************************************/
321
322 static int cmd_pwd(void)
323 {
324         d_printf("Current directory is %s",service);
325         d_printf("%s\n",client_get_cur_dir());
326         return 0;
327 }
328
329 /****************************************************************************
330  Ensure name has correct directory separators.
331 ****************************************************************************/
332
333 static void normalize_name(char *newdir)
334 {
335         if (!(cli->posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP)) {
336                 string_replace(newdir,'/','\\');
337         }
338 }
339
340 /****************************************************************************
341  Change directory - inner section.
342 ****************************************************************************/
343
344 static int do_cd(const char *new_dir)
345 {
346         char *newdir = NULL;
347         char *saved_dir = NULL;
348         char *new_cd = NULL;
349         char *targetpath = NULL;
350         struct cli_state *targetcli = NULL;
351         SMB_STRUCT_STAT sbuf;
352         uint32 attributes;
353         int ret = 1;
354         TALLOC_CTX *ctx = talloc_stackframe();
355
356         newdir = talloc_strdup(ctx, new_dir);
357         if (!newdir) {
358                 TALLOC_FREE(ctx);
359                 return 1;
360         }
361
362         normalize_name(newdir);
363
364         /* Save the current directory in case the new directory is invalid */
365
366         saved_dir = talloc_strdup(ctx, client_get_cur_dir());
367         if (!saved_dir) {
368                 TALLOC_FREE(ctx);
369                 return 1;
370         }
371
372         if (*newdir == CLI_DIRSEP_CHAR) {
373                 client_set_cur_dir(newdir);
374                 new_cd = newdir;
375         } else {
376                 new_cd = talloc_asprintf(ctx, "%s%s",
377                                 client_get_cur_dir(),
378                                 newdir);
379                 if (!new_cd) {
380                         goto out;
381                 }
382         }
383
384         /* Ensure cur_dir ends in a DIRSEP */
385         if ((new_cd[0] != '\0') && (*(new_cd+strlen(new_cd)-1) != CLI_DIRSEP_CHAR)) {
386                 new_cd = talloc_asprintf_append(new_cd, "%s", CLI_DIRSEP_STR);
387                 if (!new_cd) {
388                         goto out;
389                 }
390         }
391         client_set_cur_dir(new_cd);
392
393         new_cd = clean_name(ctx, new_cd);
394         client_set_cur_dir(new_cd);
395
396         if ( !cli_resolve_path(ctx, "", cli, new_cd, &targetcli, &targetpath)) {
397                 d_printf("cd %s: %s\n", new_cd, cli_errstr(cli));
398                 client_set_cur_dir(saved_dir);
399                 goto out;
400         }
401
402         if (strequal(targetpath,CLI_DIRSEP_STR )) {
403                 TALLOC_FREE(ctx);
404                 return 0;
405         }
406
407         /* Use a trans2_qpathinfo to test directories for modern servers.
408            Except Win9x doesn't support the qpathinfo_basic() call..... */
409
410         if (targetcli->protocol > PROTOCOL_LANMAN2 && !targetcli->win95) {
411                 if (!cli_qpathinfo_basic( targetcli, targetpath, &sbuf, &attributes ) ) {
412                         d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
413                         client_set_cur_dir(saved_dir);
414                         goto out;
415                 }
416
417                 if (!(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
418                         d_printf("cd %s: not a directory\n", new_cd);
419                         client_set_cur_dir(saved_dir);
420                         goto out;
421                 }
422         } else {
423                 targetpath = talloc_asprintf(ctx,
424                                 "%s%s",
425                                 targetpath,
426                                 CLI_DIRSEP_STR );
427                 if (!targetpath) {
428                         client_set_cur_dir(saved_dir);
429                         goto out;
430                 }
431                 targetpath = clean_name(ctx, targetpath);
432                 if (!targetpath) {
433                         client_set_cur_dir(saved_dir);
434                         goto out;
435                 }
436
437                 if (!cli_chkpath(targetcli, targetpath)) {
438                         d_printf("cd %s: %s\n", new_cd, cli_errstr(targetcli));
439                         client_set_cur_dir(saved_dir);
440                         goto out;
441                 }
442         }
443
444         ret = 0;
445
446 out:
447
448         TALLOC_FREE(ctx);
449         return ret;
450 }
451
452 /****************************************************************************
453  Change directory.
454 ****************************************************************************/
455
456 static int cmd_cd(void)
457 {
458         char *buf = NULL;
459         int rc = 0;
460
461         if (next_token_talloc(talloc_tos(), &cmd_ptr, &buf,NULL)) {
462                 rc = do_cd(buf);
463         } else {
464                 d_printf("Current directory is %s\n",client_get_cur_dir());
465         }
466
467         return rc;
468 }
469
470 /****************************************************************************
471  Change directory.
472 ****************************************************************************/
473
474 static int cmd_cd_oneup(void)
475 {
476         return do_cd("..");
477 }
478
479 /*******************************************************************
480  Decide if a file should be operated on.
481 ********************************************************************/
482
483 static bool do_this_one(file_info *finfo)
484 {
485         if (!finfo->name) {
486                 return false;
487         }
488
489         if (finfo->mode & aDIR) {
490                 return true;
491         }
492
493         if (*client_get_fileselection() &&
494             !mask_match(finfo->name,client_get_fileselection(),false)) {
495                 DEBUG(3,("mask_match %s failed\n", finfo->name));
496                 return false;
497         }
498
499         if (newer_than && finfo->mtime_ts.tv_sec < newer_than) {
500                 DEBUG(3,("newer_than %s failed\n", finfo->name));
501                 return false;
502         }
503
504         if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) {
505                 DEBUG(3,("archive %s failed\n", finfo->name));
506                 return false;
507         }
508
509         return true;
510 }
511
512 /****************************************************************************
513  Display info about a file.
514 ****************************************************************************/
515
516 static void display_finfo(file_info *finfo, const char *dir)
517 {
518         time_t t;
519         TALLOC_CTX *ctx = talloc_tos();
520
521         if (!do_this_one(finfo)) {
522                 return;
523         }
524
525         t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
526         if (!showacls) {
527                 d_printf("  %-30s%7.7s %8.0f  %s",
528                          finfo->name,
529                          attrib_string(finfo->mode),
530                         (double)finfo->size,
531                         time_to_asc(t));
532                 dir_total += finfo->size;
533         } else {
534                 char *afname = NULL;
535                 int fnum;
536
537                 /* skip if this is . or .. */
538                 if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
539                         return;
540                 /* create absolute filename for cli_nt_create() FIXME */
541                 afname = talloc_asprintf(ctx,
542                                         "%s%s%s",
543                                         dir,
544                                         CLI_DIRSEP_STR,
545                                         finfo->name);
546                 if (!afname) {
547                         return;
548                 }
549                 /* print file meta date header */
550                 d_printf( "FILENAME:%s\n", finfo->name);
551                 d_printf( "MODE:%s\n", attrib_string(finfo->mode));
552                 d_printf( "SIZE:%.0f\n", (double)finfo->size);
553                 d_printf( "MTIME:%s", time_to_asc(t));
554                 fnum = cli_nt_create(finfo->cli, afname, CREATE_ACCESS_READ);
555                 if (fnum == -1) {
556                         DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
557                                 afname,
558                                 cli_errstr( finfo->cli)));
559                 } else {
560                         SEC_DESC *sd = NULL;
561                         sd = cli_query_secdesc(finfo->cli, fnum, ctx);
562                         if (!sd) {
563                                 DEBUG( 0, ("display_finfo() failed to "
564                                         "get security descriptor: %s",
565                                         cli_errstr( finfo->cli)));
566                         } else {
567                                 display_sec_desc(sd);
568                         }
569                         TALLOC_FREE(sd);
570                 }
571                 TALLOC_FREE(afname);
572         }
573 }
574
575 /****************************************************************************
576  Accumulate size of a file.
577 ****************************************************************************/
578
579 static void do_du(file_info *finfo, const char *dir)
580 {
581         if (do_this_one(finfo)) {
582                 dir_total += finfo->size;
583         }
584 }
585
586 static bool do_list_recurse;
587 static bool do_list_dirs;
588 static char *do_list_queue = 0;
589 static long do_list_queue_size = 0;
590 static long do_list_queue_start = 0;
591 static long do_list_queue_end = 0;
592 static void (*do_list_fn)(file_info *, const char *dir);
593
594 /****************************************************************************
595  Functions for do_list_queue.
596 ****************************************************************************/
597
598 /*
599  * The do_list_queue is a NUL-separated list of strings stored in a
600  * char*.  Since this is a FIFO, we keep track of the beginning and
601  * ending locations of the data in the queue.  When we overflow, we
602  * double the size of the char*.  When the start of the data passes
603  * the midpoint, we move everything back.  This is logically more
604  * complex than a linked list, but easier from a memory management
605  * angle.  In any memory error condition, do_list_queue is reset.
606  * Functions check to ensure that do_list_queue is non-NULL before
607  * accessing it.
608  */
609
610 static void reset_do_list_queue(void)
611 {
612         SAFE_FREE(do_list_queue);
613         do_list_queue_size = 0;
614         do_list_queue_start = 0;
615         do_list_queue_end = 0;
616 }
617
618 static void init_do_list_queue(void)
619 {
620         reset_do_list_queue();
621         do_list_queue_size = 1024;
622         do_list_queue = (char *)SMB_MALLOC(do_list_queue_size);
623         if (do_list_queue == 0) {
624                 d_printf("malloc fail for size %d\n",
625                          (int)do_list_queue_size);
626                 reset_do_list_queue();
627         } else {
628                 memset(do_list_queue, 0, do_list_queue_size);
629         }
630 }
631
632 static void adjust_do_list_queue(void)
633 {
634         /*
635          * If the starting point of the queue is more than half way through,
636          * move everything toward the beginning.
637          */
638
639         if (do_list_queue == NULL) {
640                 DEBUG(4,("do_list_queue is empty\n"));
641                 do_list_queue_start = do_list_queue_end = 0;
642                 return;
643         }
644
645         if (do_list_queue_start == do_list_queue_end) {
646                 DEBUG(4,("do_list_queue is empty\n"));
647                 do_list_queue_start = do_list_queue_end = 0;
648                 *do_list_queue = '\0';
649         } else if (do_list_queue_start > (do_list_queue_size / 2)) {
650                 DEBUG(4,("sliding do_list_queue backward\n"));
651                 memmove(do_list_queue,
652                         do_list_queue + do_list_queue_start,
653                         do_list_queue_end - do_list_queue_start);
654                 do_list_queue_end -= do_list_queue_start;
655                 do_list_queue_start = 0;
656         }
657 }
658
659 static void add_to_do_list_queue(const char *entry)
660 {
661         long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
662         while (new_end > do_list_queue_size) {
663                 do_list_queue_size *= 2;
664                 DEBUG(4,("enlarging do_list_queue to %d\n",
665                          (int)do_list_queue_size));
666                 do_list_queue = (char *)SMB_REALLOC(do_list_queue, do_list_queue_size);
667                 if (! do_list_queue) {
668                         d_printf("failure enlarging do_list_queue to %d bytes\n",
669                                  (int)do_list_queue_size);
670                         reset_do_list_queue();
671                 } else {
672                         memset(do_list_queue + do_list_queue_size / 2,
673                                0, do_list_queue_size / 2);
674                 }
675         }
676         if (do_list_queue) {
677                 safe_strcpy_base(do_list_queue + do_list_queue_end,
678                                  entry, do_list_queue, do_list_queue_size);
679                 do_list_queue_end = new_end;
680                 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
681                          entry, (int)do_list_queue_start, (int)do_list_queue_end));
682         }
683 }
684
685 static char *do_list_queue_head(void)
686 {
687         return do_list_queue + do_list_queue_start;
688 }
689
690 static void remove_do_list_queue_head(void)
691 {
692         if (do_list_queue_end > do_list_queue_start) {
693                 do_list_queue_start += strlen(do_list_queue_head()) + 1;
694                 adjust_do_list_queue();
695                 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
696                          (int)do_list_queue_start, (int)do_list_queue_end));
697         }
698 }
699
700 static int do_list_queue_empty(void)
701 {
702         return (! (do_list_queue && *do_list_queue));
703 }
704
705 /****************************************************************************
706  A helper for do_list.
707 ****************************************************************************/
708
709 static void do_list_helper(const char *mntpoint, file_info *f, const char *mask, void *state)
710 {
711         TALLOC_CTX *ctx = talloc_tos();
712         char *dir = NULL;
713         char *dir_end = NULL;
714
715         /* Work out the directory. */
716         dir = talloc_strdup(ctx, mask);
717         if (!dir) {
718                 return;
719         }
720         if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
721                 *dir_end = '\0';
722         }
723
724         if (f->mode & aDIR) {
725                 if (do_list_dirs && do_this_one(f)) {
726                         do_list_fn(f, dir);
727                 }
728                 if (do_list_recurse &&
729                     f->name &&
730                     !strequal(f->name,".") &&
731                     !strequal(f->name,"..")) {
732                         char *mask2 = NULL;
733                         char *p = NULL;
734
735                         if (!f->name[0]) {
736                                 d_printf("Empty dir name returned. Possible server misconfiguration.\n");
737                                 TALLOC_FREE(dir);
738                                 return;
739                         }
740
741                         mask2 = talloc_asprintf(ctx,
742                                         "%s%s",
743                                         mntpoint,
744                                         mask);
745                         if (!mask2) {
746                                 TALLOC_FREE(dir);
747                                 return;
748                         }
749                         p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
750                         if (p) {
751                                 p[1] = 0;
752                         } else {
753                                 mask2[0] = '\0';
754                         }
755                         mask2 = talloc_asprintf_append(mask2,
756                                         "%s%s*",
757                                         f->name,
758                                         CLI_DIRSEP_STR);
759                         if (!mask2) {
760                                 TALLOC_FREE(dir);
761                                 return;
762                         }
763                         add_to_do_list_queue(mask2);
764                         TALLOC_FREE(mask2);
765                 }
766                 TALLOC_FREE(dir);
767                 return;
768         }
769
770         if (do_this_one(f)) {
771                 do_list_fn(f,dir);
772         }
773         TALLOC_FREE(dir);
774 }
775
776 /****************************************************************************
777  A wrapper around cli_list that adds recursion.
778 ****************************************************************************/
779
780 void do_list(const char *mask,
781                         uint16 attribute,
782                         void (*fn)(file_info *, const char *dir),
783                         bool rec,
784                         bool dirs)
785 {
786         static int in_do_list = 0;
787         TALLOC_CTX *ctx = talloc_tos();
788         struct cli_state *targetcli = NULL;
789         char *targetpath = NULL;
790
791         if (in_do_list && rec) {
792                 fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
793                 exit(1);
794         }
795
796         in_do_list = 1;
797
798         do_list_recurse = rec;
799         do_list_dirs = dirs;
800         do_list_fn = fn;
801
802         if (rec) {
803                 init_do_list_queue();
804                 add_to_do_list_queue(mask);
805
806                 while (!do_list_queue_empty()) {
807                         /*
808                          * Need to copy head so that it doesn't become
809                          * invalid inside the call to cli_list.  This
810                          * would happen if the list were expanded
811                          * during the call.
812                          * Fix from E. Jay Berkenbilt (ejb@ql.org)
813                          */
814                         char *head = talloc_strdup(ctx, do_list_queue_head());
815
816                         if (!head) {
817                                 return;
818                         }
819
820                         /* check for dfs */
821
822                         if ( !cli_resolve_path(ctx, "", cli, head, &targetcli, &targetpath ) ) {
823                                 d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
824                                 remove_do_list_queue_head();
825                                 continue;
826                         }
827
828                         cli_list(targetcli, targetpath, attribute, do_list_helper, NULL);
829                         remove_do_list_queue_head();
830                         if ((! do_list_queue_empty()) && (fn == display_finfo)) {
831                                 char *next_file = do_list_queue_head();
832                                 char *save_ch = 0;
833                                 if ((strlen(next_file) >= 2) &&
834                                     (next_file[strlen(next_file) - 1] == '*') &&
835                                     (next_file[strlen(next_file) - 2] == CLI_DIRSEP_CHAR)) {
836                                         save_ch = next_file +
837                                                 strlen(next_file) - 2;
838                                         *save_ch = '\0';
839                                         if (showacls) {
840                                                 /* cwd is only used if showacls is on */
841                                                 client_set_cwd(next_file);
842                                         }
843                                 }
844                                 if (!showacls) /* don't disturbe the showacls output */
845                                         d_printf("\n%s\n",next_file);
846                                 if (save_ch) {
847                                         *save_ch = CLI_DIRSEP_CHAR;
848                                 }
849                         }
850                         TALLOC_FREE(head);
851                         TALLOC_FREE(targetpath);
852                 }
853         } else {
854                 /* check for dfs */
855                 if (cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetpath)) {
856                         if (cli_list(targetcli, targetpath, attribute, do_list_helper, NULL) == -1) {
857                                 d_printf("%s listing %s\n",
858                                         cli_errstr(targetcli), targetpath);
859                         }
860                         TALLOC_FREE(targetpath);
861                 } else {
862                         d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
863                 }
864         }
865
866         in_do_list = 0;
867         reset_do_list_queue();
868 }
869
870 /****************************************************************************
871  Get a directory listing.
872 ****************************************************************************/
873
874 static int cmd_dir(void)
875 {
876         TALLOC_CTX *ctx = talloc_tos();
877         uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
878         char *mask = NULL;
879         char *buf = NULL;
880         int rc = 1;
881
882         dir_total = 0;
883         mask = talloc_strdup(ctx, client_get_cur_dir());
884         if (!mask) {
885                 return 1;
886         }
887
888         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
889                 normalize_name(buf);
890                 if (*buf == CLI_DIRSEP_CHAR) {
891                         mask = talloc_strdup(ctx, buf);
892                 } else {
893                         mask = talloc_asprintf_append(mask, "%s", buf);
894                 }
895         } else {
896                 mask = talloc_asprintf_append(mask, "*");
897         }
898         if (!mask) {
899                 return 1;
900         }
901
902         if (showacls) {
903                 /* cwd is only used if showacls is on */
904                 client_set_cwd(client_get_cur_dir());
905         }
906
907         do_list(mask, attribute, display_finfo, recurse, true);
908
909         rc = do_dskattr();
910
911         DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
912
913         return rc;
914 }
915
916 /****************************************************************************
917  Get a directory listing.
918 ****************************************************************************/
919
920 static int cmd_du(void)
921 {
922         TALLOC_CTX *ctx = talloc_tos();
923         uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
924         char *mask = NULL;
925         char *buf = NULL;
926         int rc = 1;
927
928         dir_total = 0;
929         mask = talloc_strdup(ctx, client_get_cur_dir());
930         if (!mask) {
931                 return 1;
932         }
933         if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR)) {
934                 mask = talloc_asprintf_append(mask, "%s", CLI_DIRSEP_STR);
935                 if (!mask) {
936                         return 1;
937                 }
938         }
939
940         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
941                 normalize_name(buf);
942                 if (*buf == CLI_DIRSEP_CHAR) {
943                         mask = talloc_strdup(ctx, buf);
944                 } else {
945                         mask = talloc_asprintf_append(mask, "%s", buf);
946                 }
947         } else {
948                 mask = talloc_strdup(ctx, "*");
949         }
950
951         do_list(mask, attribute, do_du, recurse, true);
952
953         rc = do_dskattr();
954
955         d_printf("Total number of bytes: %.0f\n", dir_total);
956
957         return rc;
958 }
959
960 static int cmd_echo(void)
961 {
962         TALLOC_CTX *ctx = talloc_tos();
963         char *num;
964         char *data;
965         NTSTATUS status;
966
967         if (!next_token_talloc(ctx, &cmd_ptr, &num, NULL)
968             || !next_token_talloc(ctx, &cmd_ptr, &data, NULL)) {
969                 d_printf("echo <num> <data>\n");
970                 return 1;
971         }
972
973         status = cli_echo(cli, atoi(num), data_blob_const(data, strlen(data)));
974
975         if (!NT_STATUS_IS_OK(status)) {
976                 d_printf("echo failed: %s\n", nt_errstr(status));
977                 return 1;
978         }
979
980         return 0;
981 }
982
983 /****************************************************************************
984  Get a file from rname to lname
985 ****************************************************************************/
986
987 static NTSTATUS writefile_sink(char *buf, size_t n, void *priv)
988 {
989         int *pfd = (int *)priv;
990         if (writefile(*pfd, buf, n) == -1) {
991                 return map_nt_error_from_unix(errno);
992         }
993         return NT_STATUS_OK;
994 }
995
996 static int do_get(const char *rname, const char *lname_in, bool reget)
997 {
998         TALLOC_CTX *ctx = talloc_tos();
999         int handle = 0, fnum;
1000         bool newhandle = false;
1001         struct timeval tp_start;
1002         uint16 attr;
1003         SMB_OFF_T size;
1004         off_t start = 0;
1005         SMB_OFF_T nread = 0;
1006         int rc = 0;
1007         struct cli_state *targetcli = NULL;
1008         char *targetname = NULL;
1009         char *lname = NULL;
1010         NTSTATUS status;
1011
1012         lname = talloc_strdup(ctx, lname_in);
1013         if (!lname) {
1014                 return 1;
1015         }
1016
1017         if (lowercase) {
1018                 strlower_m(lname);
1019         }
1020
1021         if (!cli_resolve_path(ctx, "", cli, rname, &targetcli, &targetname ) ) {
1022                 d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
1023                 return 1;
1024         }
1025
1026         GetTimeOfDay(&tp_start);
1027
1028         fnum = cli_open(targetcli, targetname, O_RDONLY, DENY_NONE);
1029
1030         if (fnum == -1) {
1031                 d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
1032                 return 1;
1033         }
1034
1035         if(!strcmp(lname,"-")) {
1036                 handle = fileno(stdout);
1037         } else {
1038                 if (reget) {
1039                         handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
1040                         if (handle >= 0) {
1041                                 start = sys_lseek(handle, 0, SEEK_END);
1042                                 if (start == -1) {
1043                                         d_printf("Error seeking local file\n");
1044                                         return 1;
1045                                 }
1046                         }
1047                 } else {
1048                         handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1049                 }
1050                 newhandle = true;
1051         }
1052         if (handle < 0) {
1053                 d_printf("Error opening local file %s\n",lname);
1054                 return 1;
1055         }
1056
1057
1058         if (!cli_qfileinfo(targetcli, fnum,
1059                            &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
1060             !cli_getattrE(targetcli, fnum,
1061                           &attr, &size, NULL, NULL, NULL)) {
1062                 d_printf("getattrib: %s\n",cli_errstr(targetcli));
1063                 return 1;
1064         }
1065
1066         DEBUG(1,("getting file %s of size %.0f as %s ",
1067                  rname, (double)size, lname));
1068
1069         status = cli_pull(targetcli, fnum, start, size, io_bufsize,
1070                           writefile_sink, (void *)&handle, &nread);
1071         if (!NT_STATUS_IS_OK(status)) {
1072                 d_fprintf(stderr, "parallel_read returned %s\n",
1073                           nt_errstr(status));
1074                 cli_close(targetcli, fnum);
1075                 return 1;
1076         }
1077
1078         if (!cli_close(targetcli, fnum)) {
1079                 d_printf("Error %s closing remote file\n",cli_errstr(cli));
1080                 rc = 1;
1081         }
1082
1083         if (newhandle) {
1084                 close(handle);
1085         }
1086
1087         if (archive_level >= 2 && (attr & aARCH)) {
1088                 cli_setatr(cli, rname, attr & ~(uint16)aARCH, 0);
1089         }
1090
1091         {
1092                 struct timeval tp_end;
1093                 int this_time;
1094
1095                 GetTimeOfDay(&tp_end);
1096                 this_time =
1097                         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1098                         (tp_end.tv_usec - tp_start.tv_usec)/1000;
1099                 get_total_time_ms += this_time;
1100                 get_total_size += nread;
1101
1102                 DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
1103                          nread / (1.024*this_time + 1.0e-4),
1104                          get_total_size / (1.024*get_total_time_ms)));
1105         }
1106
1107         TALLOC_FREE(targetname);
1108         return rc;
1109 }
1110
1111 /****************************************************************************
1112  Get a file.
1113 ****************************************************************************/
1114
1115 static int cmd_get(void)
1116 {
1117         TALLOC_CTX *ctx = talloc_tos();
1118         char *lname = NULL;
1119         char *rname = NULL;
1120         char *fname = NULL;
1121
1122         rname = talloc_strdup(ctx, client_get_cur_dir());
1123         if (!rname) {
1124                 return 1;
1125         }
1126
1127         if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
1128                 d_printf("get <filename> [localname]\n");
1129                 return 1;
1130         }
1131         rname = talloc_asprintf_append(rname, "%s", fname);
1132         if (!rname) {
1133                 return 1;
1134         }
1135         rname = clean_name(ctx, rname);
1136         if (!rname) {
1137                 return 1;
1138         }
1139
1140         next_token_talloc(ctx, &cmd_ptr,&lname,NULL);
1141         if (!lname) {
1142                 lname = fname;
1143         }
1144
1145         return do_get(rname, lname, false);
1146 }
1147
1148 /****************************************************************************
1149  Do an mget operation on one file.
1150 ****************************************************************************/
1151
1152 static void do_mget(file_info *finfo, const char *dir)
1153 {
1154         TALLOC_CTX *ctx = talloc_tos();
1155         char *rname = NULL;
1156         char *quest = NULL;
1157         char *saved_curdir = NULL;
1158         char *mget_mask = NULL;
1159         char *new_cd = NULL;
1160
1161         if (!finfo->name) {
1162                 return;
1163         }
1164
1165         if (strequal(finfo->name,".") || strequal(finfo->name,".."))
1166                 return;
1167
1168         if (abort_mget) {
1169                 d_printf("mget aborted\n");
1170                 return;
1171         }
1172
1173         if (finfo->mode & aDIR) {
1174                 if (asprintf(&quest,
1175                          "Get directory %s? ",finfo->name) < 0) {
1176                         return;
1177                 }
1178         } else {
1179                 if (asprintf(&quest,
1180                          "Get file %s? ",finfo->name) < 0) {
1181                         return;
1182                 }
1183         }
1184
1185         if (prompt && !yesno(quest)) {
1186                 SAFE_FREE(quest);
1187                 return;
1188         }
1189         SAFE_FREE(quest);
1190
1191         if (!(finfo->mode & aDIR)) {
1192                 rname = talloc_asprintf(ctx,
1193                                 "%s%s",
1194                                 client_get_cur_dir(),
1195                                 finfo->name);
1196                 if (!rname) {
1197                         return;
1198                 }
1199                 do_get(rname, finfo->name, false);
1200                 TALLOC_FREE(rname);
1201                 return;
1202         }
1203
1204         /* handle directories */
1205         saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
1206         if (!saved_curdir) {
1207                 return;
1208         }
1209
1210         new_cd = talloc_asprintf(ctx,
1211                                 "%s%s%s",
1212                                 client_get_cur_dir(),
1213                                 finfo->name,
1214                                 CLI_DIRSEP_STR);
1215         if (!new_cd) {
1216                 return;
1217         }
1218         client_set_cur_dir(new_cd);
1219
1220         string_replace(finfo->name,'\\','/');
1221         if (lowercase) {
1222                 strlower_m(finfo->name);
1223         }
1224
1225         if (!directory_exist(finfo->name) &&
1226             mkdir(finfo->name,0777) != 0) {
1227                 d_printf("failed to create directory %s\n",finfo->name);
1228                 client_set_cur_dir(saved_curdir);
1229                 return;
1230         }
1231
1232         if (chdir(finfo->name) != 0) {
1233                 d_printf("failed to chdir to directory %s\n",finfo->name);
1234                 client_set_cur_dir(saved_curdir);
1235                 return;
1236         }
1237
1238         mget_mask = talloc_asprintf(ctx,
1239                         "%s*",
1240                         client_get_cur_dir());
1241
1242         if (!mget_mask) {
1243                 return;
1244         }
1245
1246         do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,false, true);
1247         if (chdir("..") == -1) {
1248                 d_printf("do_mget: failed to chdir to .. (error %s)\n",
1249                         strerror(errno) );
1250         }
1251         client_set_cur_dir(saved_curdir);
1252         TALLOC_FREE(mget_mask);
1253         TALLOC_FREE(saved_curdir);
1254         TALLOC_FREE(new_cd);
1255 }
1256
1257 /****************************************************************************
1258  View the file using the pager.
1259 ****************************************************************************/
1260
1261 static int cmd_more(void)
1262 {
1263         TALLOC_CTX *ctx = talloc_tos();
1264         char *rname = NULL;
1265         char *fname = NULL;
1266         char *lname = NULL;
1267         char *pager_cmd = NULL;
1268         const char *pager;
1269         int fd;
1270         int rc = 0;
1271
1272         rname = talloc_strdup(ctx, client_get_cur_dir());
1273         if (!rname) {
1274                 return 1;
1275         }
1276
1277         lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
1278         if (!lname) {
1279                 return 1;
1280         }
1281         fd = smb_mkstemp(lname);
1282         if (fd == -1) {
1283                 d_printf("failed to create temporary file for more\n");
1284                 return 1;
1285         }
1286         close(fd);
1287
1288         if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
1289                 d_printf("more <filename>\n");
1290                 unlink(lname);
1291                 return 1;
1292         }
1293         rname = talloc_asprintf_append(rname, "%s", fname);
1294         if (!rname) {
1295                 return 1;
1296         }
1297         rname = clean_name(ctx,rname);
1298         if (!rname) {
1299                 return 1;
1300         }
1301
1302         rc = do_get(rname, lname, false);
1303
1304         pager=getenv("PAGER");
1305
1306         pager_cmd = talloc_asprintf(ctx,
1307                                 "%s %s",
1308                                 (pager? pager:PAGER),
1309                                 lname);
1310         if (!pager_cmd) {
1311                 return 1;
1312         }
1313         if (system(pager_cmd) == -1) {
1314                 d_printf("system command '%s' returned -1\n",
1315                         pager_cmd);
1316         }
1317         unlink(lname);
1318
1319         return rc;
1320 }
1321
1322 /****************************************************************************
1323  Do a mget command.
1324 ****************************************************************************/
1325
1326 static int cmd_mget(void)
1327 {
1328         TALLOC_CTX *ctx = talloc_tos();
1329         uint16 attribute = aSYSTEM | aHIDDEN;
1330         char *mget_mask = NULL;
1331         char *buf = NULL;
1332
1333         if (recurse) {
1334                 attribute |= aDIR;
1335         }
1336
1337         abort_mget = false;
1338
1339         while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1340                 mget_mask = talloc_strdup(ctx, client_get_cur_dir());
1341                 if (!mget_mask) {
1342                         return 1;
1343                 }
1344                 if (*buf == CLI_DIRSEP_CHAR) {
1345                         mget_mask = talloc_strdup(ctx, buf);
1346                 } else {
1347                         mget_mask = talloc_asprintf_append(mget_mask,
1348                                                         "%s", buf);
1349                 }
1350                 if (!mget_mask) {
1351                         return 1;
1352                 }
1353                 do_list(mget_mask, attribute, do_mget, false, true);
1354         }
1355
1356         if (mget_mask == NULL) {
1357                 d_printf("nothing to mget\n");
1358                 return 0;
1359         }
1360
1361         if (!*mget_mask) {
1362                 mget_mask = talloc_asprintf(ctx,
1363                                         "%s*",
1364                                         client_get_cur_dir());
1365                 if (!mget_mask) {
1366                         return 1;
1367                 }
1368                 do_list(mget_mask, attribute, do_mget, false, true);
1369         }
1370
1371         return 0;
1372 }
1373
1374 /****************************************************************************
1375  Make a directory of name "name".
1376 ****************************************************************************/
1377
1378 static bool do_mkdir(const char *name)
1379 {
1380         TALLOC_CTX *ctx = talloc_tos();
1381         struct cli_state *targetcli;
1382         char *targetname = NULL;
1383
1384         if (!cli_resolve_path(ctx, "", cli, name, &targetcli, &targetname)) {
1385                 d_printf("mkdir %s: %s\n", name, cli_errstr(cli));
1386                 return false;
1387         }
1388
1389         if (!cli_mkdir(targetcli, targetname)) {
1390                 d_printf("%s making remote directory %s\n",
1391                          cli_errstr(targetcli),name);
1392                 return false;
1393         }
1394
1395         return true;
1396 }
1397
1398 /****************************************************************************
1399  Show 8.3 name of a file.
1400 ****************************************************************************/
1401
1402 static bool do_altname(const char *name)
1403 {
1404         fstring altname;
1405
1406         if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
1407                 d_printf("%s getting alt name for %s\n",
1408                          cli_errstr(cli),name);
1409                 return false;
1410         }
1411         d_printf("%s\n", altname);
1412
1413         return true;
1414 }
1415
1416 /****************************************************************************
1417  Exit client.
1418 ****************************************************************************/
1419
1420 static int cmd_quit(void)
1421 {
1422         cli_shutdown(cli);
1423         exit(0);
1424         /* NOTREACHED */
1425         return 0;
1426 }
1427
1428 /****************************************************************************
1429  Make a directory.
1430 ****************************************************************************/
1431
1432 static int cmd_mkdir(void)
1433 {
1434         TALLOC_CTX *ctx = talloc_tos();
1435         char *mask = NULL;
1436         char *buf = NULL;
1437
1438         mask = talloc_strdup(ctx, client_get_cur_dir());
1439         if (!mask) {
1440                 return 1;
1441         }
1442
1443         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1444                 if (!recurse) {
1445                         d_printf("mkdir <dirname>\n");
1446                 }
1447                 return 1;
1448         }
1449         mask = talloc_asprintf_append(mask, "%s", buf);
1450         if (!mask) {
1451                 return 1;
1452         }
1453
1454         if (recurse) {
1455                 char *ddir = NULL;
1456                 char *ddir2 = NULL;
1457                 struct cli_state *targetcli;
1458                 char *targetname = NULL;
1459                 char *p = NULL;
1460                 char *saveptr;
1461
1462                 ddir2 = talloc_strdup(ctx, "");
1463                 if (!ddir2) {
1464                         return 1;
1465                 }
1466
1467                 if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
1468                         return 1;
1469                 }
1470
1471                 ddir = talloc_strdup(ctx, targetname);
1472                 if (!ddir) {
1473                         return 1;
1474                 }
1475                 trim_char(ddir,'.','\0');
1476                 p = strtok_r(ddir, "/\\", &saveptr);
1477                 while (p) {
1478                         ddir2 = talloc_asprintf_append(ddir2, "%s", p);
1479                         if (!ddir2) {
1480                                 return 1;
1481                         }
1482                         if (!cli_chkpath(targetcli, ddir2)) {
1483                                 do_mkdir(ddir2);
1484                         }
1485                         ddir2 = talloc_asprintf_append(ddir2, "%s", CLI_DIRSEP_STR);
1486                         if (!ddir2) {
1487                                 return 1;
1488                         }
1489                         p = strtok_r(NULL, "/\\", &saveptr);
1490                 }
1491         } else {
1492                 do_mkdir(mask);
1493         }
1494
1495         return 0;
1496 }
1497
1498 /****************************************************************************
1499  Show alt name.
1500 ****************************************************************************/
1501
1502 static int cmd_altname(void)
1503 {
1504         TALLOC_CTX *ctx = talloc_tos();
1505         char *name;
1506         char *buf;
1507
1508         name = talloc_strdup(ctx, client_get_cur_dir());
1509         if (!name) {
1510                 return 1;
1511         }
1512
1513         if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
1514                 d_printf("altname <file>\n");
1515                 return 1;
1516         }
1517         name = talloc_asprintf_append(name, "%s", buf);
1518         if (!name) {
1519                 return 1;
1520         }
1521         do_altname(name);
1522         return 0;
1523 }
1524
1525 /****************************************************************************
1526  Show all info we can get
1527 ****************************************************************************/
1528
1529 static int do_allinfo(const char *name)
1530 {
1531         fstring altname;
1532         struct timespec b_time, a_time, m_time, c_time;
1533         SMB_OFF_T size;
1534         uint16_t mode;
1535         SMB_INO_T ino;
1536         NTTIME tmp;
1537         unsigned int num_streams;
1538         struct stream_struct *streams;
1539         unsigned int i;
1540
1541         if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
1542                 d_printf("%s getting alt name for %s\n",
1543                          cli_errstr(cli),name);
1544                 return false;
1545         }
1546         d_printf("altname: %s\n", altname);
1547
1548         if (!cli_qpathinfo2(cli, name, &b_time, &a_time, &m_time, &c_time,
1549                             &size, &mode, &ino)) {
1550                 d_printf("%s getting pathinfo for %s\n",
1551                          cli_errstr(cli),name);
1552                 return false;
1553         }
1554
1555         unix_timespec_to_nt_time(&tmp, b_time);
1556         d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1557
1558         unix_timespec_to_nt_time(&tmp, a_time);
1559         d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1560
1561         unix_timespec_to_nt_time(&tmp, m_time);
1562         d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
1563
1564         unix_timespec_to_nt_time(&tmp, c_time);
1565         d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
1566
1567         if (!cli_qpathinfo_streams(cli, name, talloc_tos(), &num_streams,
1568                                    &streams)) {
1569                 d_printf("%s getting streams for %s\n",
1570                          cli_errstr(cli),name);
1571                 return false;
1572         }
1573
1574         for (i=0; i<num_streams; i++) {
1575                 d_printf("stream: [%s], %lld bytes\n", streams[i].name,
1576                          (unsigned long long)streams[i].size);
1577         }
1578
1579         return 0;
1580 }
1581
1582 /****************************************************************************
1583  Show all info we can get
1584 ****************************************************************************/
1585
1586 static int cmd_allinfo(void)
1587 {
1588         TALLOC_CTX *ctx = talloc_tos();
1589         char *name;
1590         char *buf;
1591
1592         name = talloc_strdup(ctx, client_get_cur_dir());
1593         if (!name) {
1594                 return 1;
1595         }
1596
1597         if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
1598                 d_printf("allinfo <file>\n");
1599                 return 1;
1600         }
1601         name = talloc_asprintf_append(name, "%s", buf);
1602         if (!name) {
1603                 return 1;
1604         }
1605
1606         do_allinfo(name);
1607
1608         return 0;
1609 }
1610
1611 /****************************************************************************
1612  Put a single file.
1613 ****************************************************************************/
1614
1615 static int do_put(const char *rname, const char *lname, bool reput)
1616 {
1617         TALLOC_CTX *ctx = talloc_tos();
1618         int fnum;
1619         XFILE *f;
1620         SMB_OFF_T start = 0;
1621         int rc = 0;
1622         struct timeval tp_start;
1623         struct cli_state *targetcli;
1624         char *targetname = NULL;
1625         struct push_state state;
1626         NTSTATUS status;
1627
1628         if (!cli_resolve_path(ctx, "", cli, rname, &targetcli, &targetname)) {
1629                 d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
1630                 return 1;
1631         }
1632
1633         GetTimeOfDay(&tp_start);
1634
1635         if (reput) {
1636                 fnum = cli_open(targetcli, targetname, O_RDWR|O_CREAT, DENY_NONE);
1637                 if (fnum >= 0) {
1638                         if (!cli_qfileinfo(targetcli, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL) &&
1639                             !cli_getattrE(targetcli, fnum, NULL, &start, NULL, NULL, NULL)) {
1640                                 d_printf("getattrib: %s\n",cli_errstr(cli));
1641                                 return 1;
1642                         }
1643                 }
1644         } else {
1645                 fnum = cli_open(targetcli, targetname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
1646         }
1647
1648         if (fnum == -1) {
1649                 d_printf("%s opening remote file %s\n",cli_errstr(targetcli),rname);
1650                 return 1;
1651         }
1652
1653         /* allow files to be piped into smbclient
1654            jdblair 24.jun.98
1655
1656            Note that in this case this function will exit(0) rather
1657            than returning. */
1658         if (!strcmp(lname, "-")) {
1659                 f = x_stdin;
1660                 /* size of file is not known */
1661         } else {
1662                 f = x_fopen(lname,O_RDONLY, 0);
1663                 if (f && reput) {
1664                         if (x_tseek(f, start, SEEK_SET) == -1) {
1665                                 d_printf("Error seeking local file\n");
1666                                 return 1;
1667                         }
1668                 }
1669         }
1670
1671         if (!f) {
1672                 d_printf("Error opening local file %s\n",lname);
1673                 return 1;
1674         }
1675
1676         DEBUG(1,("putting file %s as %s ",lname,
1677                  rname));
1678
1679         x_setvbuf(f, NULL, X_IOFBF, io_bufsize);
1680
1681         state.f = f;
1682         state.nread = 0;
1683
1684         status = cli_push(targetcli, fnum, 0, 0, io_bufsize, push_source,
1685                           &state);
1686         if (!NT_STATUS_IS_OK(status)) {
1687                 d_fprintf(stderr, "cli_push returned %s\n", nt_errstr(status));
1688         }
1689
1690         if (!cli_close(targetcli, fnum)) {
1691                 d_printf("%s closing remote file %s\n",cli_errstr(cli),rname);
1692                 x_fclose(f);
1693                 return 1;
1694         }
1695
1696         if (f != x_stdin) {
1697                 x_fclose(f);
1698         }
1699
1700         {
1701                 struct timeval tp_end;
1702                 int this_time;
1703
1704                 GetTimeOfDay(&tp_end);
1705                 this_time =
1706                         (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1707                         (tp_end.tv_usec - tp_start.tv_usec)/1000;
1708                 put_total_time_ms += this_time;
1709                 put_total_size += state.nread;
1710
1711                 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1712                          state.nread / (1.024*this_time + 1.0e-4),
1713                          put_total_size / (1.024*put_total_time_ms)));
1714         }
1715
1716         if (f == x_stdin) {
1717                 cli_shutdown(cli);
1718                 exit(0);
1719         }
1720
1721         return rc;
1722 }
1723
1724 /****************************************************************************
1725  Put a file.
1726 ****************************************************************************/
1727
1728 static int cmd_put(void)
1729 {
1730         TALLOC_CTX *ctx = talloc_tos();
1731         char *lname;
1732         char *rname;
1733         char *buf;
1734
1735         rname = talloc_strdup(ctx, client_get_cur_dir());
1736         if (!rname) {
1737                 return 1;
1738         }
1739
1740         if (!next_token_talloc(ctx, &cmd_ptr,&lname,NULL)) {
1741                 d_printf("put <filename>\n");
1742                 return 1;
1743         }
1744
1745         if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1746                 rname = talloc_asprintf_append(rname, "%s", buf);
1747         } else {
1748                 rname = talloc_asprintf_append(rname, "%s", lname);
1749         }
1750         if (!rname) {
1751                 return 1;
1752         }
1753
1754         rname = clean_name(ctx, rname);
1755         if (!rname) {
1756                 return 1;
1757         }
1758
1759         {
1760                 SMB_STRUCT_STAT st;
1761                 /* allow '-' to represent stdin
1762                    jdblair, 24.jun.98 */
1763                 if (!file_exist_stat(lname,&st) &&
1764                     (strcmp(lname,"-"))) {
1765                         d_printf("%s does not exist\n",lname);
1766                         return 1;
1767                 }
1768         }
1769
1770         return do_put(rname, lname, false);
1771 }
1772
1773 /*************************************
1774  File list structure.
1775 *************************************/
1776
1777 static struct file_list {
1778         struct file_list *prev, *next;
1779         char *file_path;
1780         bool isdir;
1781 } *file_list;
1782
1783 /****************************************************************************
1784  Free a file_list structure.
1785 ****************************************************************************/
1786
1787 static void free_file_list (struct file_list *l_head)
1788 {
1789         struct file_list *list, *next;
1790
1791         for (list = l_head; list; list = next) {
1792                 next = list->next;
1793                 DLIST_REMOVE(l_head, list);
1794                 SAFE_FREE(list->file_path);
1795                 SAFE_FREE(list);
1796         }
1797 }
1798
1799 /****************************************************************************
1800  Seek in a directory/file list until you get something that doesn't start with
1801  the specified name.
1802 ****************************************************************************/
1803
1804 static bool seek_list(struct file_list *list, char *name)
1805 {
1806         while (list) {
1807                 trim_string(list->file_path,"./","\n");
1808                 if (strncmp(list->file_path, name, strlen(name)) != 0) {
1809                         return true;
1810                 }
1811                 list = list->next;
1812         }
1813
1814         return false;
1815 }
1816
1817 /****************************************************************************
1818  Set the file selection mask.
1819 ****************************************************************************/
1820
1821 static int cmd_select(void)
1822 {
1823         TALLOC_CTX *ctx = talloc_tos();
1824         char *new_fs = NULL;
1825         next_token_talloc(ctx, &cmd_ptr,&new_fs,NULL)
1826                 ;
1827         if (new_fs) {
1828                 client_set_fileselection(new_fs);
1829         } else {
1830                 client_set_fileselection("");
1831         }
1832         return 0;
1833 }
1834
1835 /****************************************************************************
1836   Recursive file matching function act as find
1837   match must be always set to true when calling this function
1838 ****************************************************************************/
1839
1840 static int file_find(struct file_list **list, const char *directory,
1841                       const char *expression, bool match)
1842 {
1843         SMB_STRUCT_DIR *dir;
1844         struct file_list *entry;
1845         struct stat statbuf;
1846         int ret;
1847         char *path;
1848         bool isdir;
1849         const char *dname;
1850
1851         dir = sys_opendir(directory);
1852         if (!dir)
1853                 return -1;
1854
1855         while ((dname = readdirname(dir))) {
1856                 if (!strcmp("..", dname))
1857                         continue;
1858                 if (!strcmp(".", dname))
1859                         continue;
1860
1861                 if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
1862                         continue;
1863                 }
1864
1865                 isdir = false;
1866                 if (!match || !gen_fnmatch(expression, dname)) {
1867                         if (recurse) {
1868                                 ret = stat(path, &statbuf);
1869                                 if (ret == 0) {
1870                                         if (S_ISDIR(statbuf.st_mode)) {
1871                                                 isdir = true;
1872                                                 ret = file_find(list, path, expression, false);
1873                                         }
1874                                 } else {
1875                                         d_printf("file_find: cannot stat file %s\n", path);
1876                                 }
1877
1878                                 if (ret == -1) {
1879                                         SAFE_FREE(path);
1880                                         sys_closedir(dir);
1881                                         return -1;
1882                                 }
1883                         }
1884                         entry = SMB_MALLOC_P(struct file_list);
1885                         if (!entry) {
1886                                 d_printf("Out of memory in file_find\n");
1887                                 sys_closedir(dir);
1888                                 return -1;
1889                         }
1890                         entry->file_path = path;
1891                         entry->isdir = isdir;
1892                         DLIST_ADD(*list, entry);
1893                 } else {
1894                         SAFE_FREE(path);
1895                 }
1896         }
1897
1898         sys_closedir(dir);
1899         return 0;
1900 }
1901
1902 /****************************************************************************
1903  mput some files.
1904 ****************************************************************************/
1905
1906 static int cmd_mput(void)
1907 {
1908         TALLOC_CTX *ctx = talloc_tos();
1909         char *p = NULL;
1910
1911         while (next_token_talloc(ctx, &cmd_ptr,&p,NULL)) {
1912                 int ret;
1913                 struct file_list *temp_list;
1914                 char *quest, *lname, *rname;
1915
1916                 file_list = NULL;
1917
1918                 ret = file_find(&file_list, ".", p, true);
1919                 if (ret) {
1920                         free_file_list(file_list);
1921                         continue;
1922                 }
1923
1924                 quest = NULL;
1925                 lname = NULL;
1926                 rname = NULL;
1927
1928                 for (temp_list = file_list; temp_list;
1929                      temp_list = temp_list->next) {
1930
1931                         SAFE_FREE(lname);
1932                         if (asprintf(&lname, "%s/", temp_list->file_path) <= 0) {
1933                                 continue;
1934                         }
1935                         trim_string(lname, "./", "/");
1936
1937                         /* check if it's a directory */
1938                         if (temp_list->isdir) {
1939                                 /* if (!recurse) continue; */
1940
1941                                 SAFE_FREE(quest);
1942                                 if (asprintf(&quest, "Put directory %s? ", lname) < 0) {
1943                                         break;
1944                                 }
1945                                 if (prompt && !yesno(quest)) { /* No */
1946                                         /* Skip the directory */
1947                                         lname[strlen(lname)-1] = '/';
1948                                         if (!seek_list(temp_list, lname))
1949                                                 break;
1950                                 } else { /* Yes */
1951                                         SAFE_FREE(rname);
1952                                         if(asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
1953                                                 break;
1954                                         }
1955                                         normalize_name(rname);
1956                                         if (!cli_chkpath(cli, rname) &&
1957                                             !do_mkdir(rname)) {
1958                                                 DEBUG (0, ("Unable to make dir, skipping..."));
1959                                                 /* Skip the directory */
1960                                                 lname[strlen(lname)-1] = '/';
1961                                                 if (!seek_list(temp_list, lname)) {
1962                                                         break;
1963                                                 }
1964                                         }
1965                                 }
1966                                 continue;
1967                         } else {
1968                                 SAFE_FREE(quest);
1969                                 if (asprintf(&quest,"Put file %s? ", lname) < 0) {
1970                                         break;
1971                                 }
1972                                 if (prompt && !yesno(quest)) {
1973                                         /* No */
1974                                         continue;
1975                                 }
1976
1977                                 /* Yes */
1978                                 SAFE_FREE(rname);
1979                                 if (asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
1980                                         break;
1981                                 }
1982                         }
1983
1984                         normalize_name(rname);
1985
1986                         do_put(rname, lname, false);
1987                 }
1988                 free_file_list(file_list);
1989                 SAFE_FREE(quest);
1990                 SAFE_FREE(lname);
1991                 SAFE_FREE(rname);
1992         }
1993
1994         return 0;
1995 }
1996
1997 /****************************************************************************
1998  Cancel a print job.
1999 ****************************************************************************/
2000
2001 static int do_cancel(int job)
2002 {
2003         if (cli_printjob_del(cli, job)) {
2004                 d_printf("Job %d cancelled\n",job);
2005                 return 0;
2006         } else {
2007                 d_printf("Error cancelling job %d : %s\n",job,cli_errstr(cli));
2008                 return 1;
2009         }
2010 }
2011
2012 /****************************************************************************
2013  Cancel a print job.
2014 ****************************************************************************/
2015
2016 static int cmd_cancel(void)
2017 {
2018         TALLOC_CTX *ctx = talloc_tos();
2019         char *buf = NULL;
2020         int job;
2021
2022         if (!next_token_talloc(ctx, &cmd_ptr, &buf,NULL)) {
2023                 d_printf("cancel <jobid> ...\n");
2024                 return 1;
2025         }
2026         do {
2027                 job = atoi(buf);
2028                 do_cancel(job);
2029         } while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL));
2030
2031         return 0;
2032 }
2033
2034 /****************************************************************************
2035  Print a file.
2036 ****************************************************************************/
2037
2038 static int cmd_print(void)
2039 {
2040         TALLOC_CTX *ctx = talloc_tos();
2041         char *lname = NULL;
2042         char *rname = NULL;
2043         char *p = NULL;
2044
2045         if (!next_token_talloc(ctx, &cmd_ptr, &lname,NULL)) {
2046                 d_printf("print <filename>\n");
2047                 return 1;
2048         }
2049
2050         rname = talloc_strdup(ctx, lname);
2051         if (!rname) {
2052                 return 1;
2053         }
2054         p = strrchr_m(rname,'/');
2055         if (p) {
2056                 rname = talloc_asprintf(ctx,
2057                                         "%s-%d",
2058                                         p+1,
2059                                         (int)sys_getpid());
2060         }
2061         if (strequal(lname,"-")) {
2062                 rname = talloc_asprintf(ctx,
2063                                 "stdin-%d",
2064                                 (int)sys_getpid());
2065         }
2066         if (!rname) {
2067                 return 1;
2068         }
2069
2070         return do_put(rname, lname, false);
2071 }
2072
2073 /****************************************************************************
2074  Show a print queue entry.
2075 ****************************************************************************/
2076
2077 static void queue_fn(struct print_job_info *p)
2078 {
2079         d_printf("%-6d   %-9d    %s\n", (int)p->id, (int)p->size, p->name);
2080 }
2081
2082 /****************************************************************************
2083  Show a print queue.
2084 ****************************************************************************/
2085
2086 static int cmd_queue(void)
2087 {
2088         cli_print_queue(cli, queue_fn);
2089         return 0;
2090 }
2091
2092 /****************************************************************************
2093  Delete some files.
2094 ****************************************************************************/
2095
2096 static void do_del(file_info *finfo, const char *dir)
2097 {
2098         TALLOC_CTX *ctx = talloc_tos();
2099         char *mask = NULL;
2100
2101         mask = talloc_asprintf(ctx,
2102                                 "%s%c%s",
2103                                 dir,
2104                                 CLI_DIRSEP_CHAR,
2105                                 finfo->name);
2106         if (!mask) {
2107                 return;
2108         }
2109
2110         if (finfo->mode & aDIR) {
2111                 TALLOC_FREE(mask);
2112                 return;
2113         }
2114
2115         if (!cli_unlink(finfo->cli, mask)) {
2116                 d_printf("%s deleting remote file %s\n",
2117                                 cli_errstr(finfo->cli),mask);
2118         }
2119         TALLOC_FREE(mask);
2120 }
2121
2122 /****************************************************************************
2123  Delete some files.
2124 ****************************************************************************/
2125
2126 static int cmd_del(void)
2127 {
2128         TALLOC_CTX *ctx = talloc_tos();
2129         char *mask = NULL;
2130         char *buf = NULL;
2131         uint16 attribute = aSYSTEM | aHIDDEN;
2132
2133         if (recurse) {
2134                 attribute |= aDIR;
2135         }
2136
2137         mask = talloc_strdup(ctx, client_get_cur_dir());
2138         if (!mask) {
2139                 return 1;
2140         }
2141         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2142                 d_printf("del <filename>\n");
2143                 return 1;
2144         }
2145         mask = talloc_asprintf_append(mask, "%s", buf);
2146         if (!mask) {
2147                 return 1;
2148         }
2149
2150         do_list(mask,attribute,do_del,false,false);
2151         return 0;
2152 }
2153
2154 /****************************************************************************
2155  Wildcard delete some files.
2156 ****************************************************************************/
2157
2158 static int cmd_wdel(void)
2159 {
2160         TALLOC_CTX *ctx = talloc_tos();
2161         char *mask = NULL;
2162         char *buf = NULL;
2163         uint16 attribute;
2164         struct cli_state *targetcli;
2165         char *targetname = NULL;
2166
2167         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2168                 d_printf("wdel 0x<attrib> <wcard>\n");
2169                 return 1;
2170         }
2171
2172         attribute = (uint16)strtol(buf, (char **)NULL, 16);
2173
2174         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2175                 d_printf("wdel 0x<attrib> <wcard>\n");
2176                 return 1;
2177         }
2178
2179         mask = talloc_asprintf(ctx, "%s%s",
2180                         client_get_cur_dir(),
2181                         buf);
2182         if (!mask) {
2183                 return 1;
2184         }
2185
2186         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2187                 d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli));
2188                 return 1;
2189         }
2190
2191         if (!cli_unlink_full(targetcli, targetname, attribute)) {
2192                 d_printf("%s deleting remote files %s\n",cli_errstr(targetcli),targetname);
2193         }
2194         return 0;
2195 }
2196
2197 /****************************************************************************
2198 ****************************************************************************/
2199
2200 static int cmd_open(void)
2201 {
2202         TALLOC_CTX *ctx = talloc_tos();
2203         char *mask = NULL;
2204         char *buf = NULL;
2205         char *targetname = NULL;
2206         struct cli_state *targetcli;
2207         int fnum;
2208
2209         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2210                 d_printf("open <filename>\n");
2211                 return 1;
2212         }
2213         mask = talloc_asprintf(ctx,
2214                         "%s%s",
2215                         client_get_cur_dir(),
2216                         buf);
2217         if (!mask) {
2218                 return 1;
2219         }
2220
2221         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2222                 d_printf("open %s: %s\n", mask, cli_errstr(cli));
2223                 return 1;
2224         }
2225
2226         fnum = cli_nt_create(targetcli, targetname, FILE_READ_DATA|FILE_WRITE_DATA);
2227         if (fnum == -1) {
2228                 fnum = cli_nt_create(targetcli, targetname, FILE_READ_DATA);
2229                 if (fnum != -1) {
2230                         d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
2231                 } else {
2232                         d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
2233                 }
2234         } else {
2235                 d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
2236         }
2237         return 0;
2238 }
2239
2240 static int cmd_posix_encrypt(void)
2241 {
2242         TALLOC_CTX *ctx = talloc_tos();
2243         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2244
2245         if (cli->use_kerberos) {
2246                 status = cli_gss_smb_encryption_start(cli);
2247         } else {
2248                 char *domain = NULL;
2249                 char *user = NULL;
2250                 char *password = NULL;
2251
2252                 if (!next_token_talloc(ctx, &cmd_ptr,&domain,NULL)) {
2253                         d_printf("posix_encrypt domain user password\n");
2254                         return 1;
2255                 }
2256
2257                 if (!next_token_talloc(ctx, &cmd_ptr,&user,NULL)) {
2258                         d_printf("posix_encrypt domain user password\n");
2259                         return 1;
2260                 }
2261
2262                 if (!next_token_talloc(ctx, &cmd_ptr,&password,NULL)) {
2263                         d_printf("posix_encrypt domain user password\n");
2264                         return 1;
2265                 }
2266
2267                 status = cli_raw_ntlm_smb_encryption_start(cli,
2268                                                         user,
2269                                                         password,
2270                                                         domain);
2271         }
2272
2273         if (!NT_STATUS_IS_OK(status)) {
2274                 d_printf("posix_encrypt failed with error %s\n", nt_errstr(status));
2275         } else {
2276                 d_printf("encryption on\n");
2277                 smb_encrypt = true;
2278         }
2279
2280         return 0;
2281 }
2282
2283 /****************************************************************************
2284 ****************************************************************************/
2285
2286 static int cmd_posix_open(void)
2287 {
2288         TALLOC_CTX *ctx = talloc_tos();
2289         char *mask = NULL;
2290         char *buf = NULL;
2291         char *targetname = NULL;
2292         struct cli_state *targetcli;
2293         mode_t mode;
2294         int fnum;
2295
2296         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2297                 d_printf("posix_open <filename> 0<mode>\n");
2298                 return 1;
2299         }
2300         mask = talloc_asprintf(ctx,
2301                         "%s%s",
2302                         client_get_cur_dir(),
2303                         buf);
2304         if (!mask) {
2305                 return 1;
2306         }
2307
2308         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2309                 d_printf("posix_open <filename> 0<mode>\n");
2310                 return 1;
2311         }
2312         mode = (mode_t)strtol(buf, (char **)NULL, 8);
2313
2314         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2315                 d_printf("posix_open %s: %s\n", mask, cli_errstr(cli));
2316                 return 1;
2317         }
2318
2319         fnum = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode);
2320         if (fnum == -1) {
2321                 fnum = cli_posix_open(targetcli, targetname, O_CREAT|O_RDONLY, mode);
2322                 if (fnum != -1) {
2323                         d_printf("posix_open file %s: for read/write fnum %d\n", targetname, fnum);
2324                 } else {
2325                         d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
2326                 }
2327         } else {
2328                 d_printf("posix_open file %s: for read/write fnum %d\n", targetname, fnum);
2329         }
2330
2331         return 0;
2332 }
2333
2334 static int cmd_posix_mkdir(void)
2335 {
2336         TALLOC_CTX *ctx = talloc_tos();
2337         char *mask = NULL;
2338         char *buf = NULL;
2339         char *targetname = NULL;
2340         struct cli_state *targetcli;
2341         mode_t mode;
2342         int fnum;
2343
2344         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2345                 d_printf("posix_mkdir <filename> 0<mode>\n");
2346                 return 1;
2347         }
2348         mask = talloc_asprintf(ctx,
2349                         "%s%s",
2350                         client_get_cur_dir(),
2351                         buf);
2352         if (!mask) {
2353                 return 1;
2354         }
2355
2356         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2357                 d_printf("posix_mkdir <filename> 0<mode>\n");
2358                 return 1;
2359         }
2360         mode = (mode_t)strtol(buf, (char **)NULL, 8);
2361
2362         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2363                 d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli));
2364                 return 1;
2365         }
2366
2367         fnum = cli_posix_mkdir(targetcli, targetname, mode);
2368         if (fnum == -1) {
2369                 d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
2370         } else {
2371                 d_printf("posix_mkdir created directory %s\n", targetname);
2372         }
2373         return 0;
2374 }
2375
2376 static int cmd_posix_unlink(void)
2377 {
2378         TALLOC_CTX *ctx = talloc_tos();
2379         char *mask = NULL;
2380         char *buf = NULL;
2381         char *targetname = NULL;
2382         struct cli_state *targetcli;
2383
2384         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2385                 d_printf("posix_unlink <filename>\n");
2386                 return 1;
2387         }
2388         mask = talloc_asprintf(ctx,
2389                         "%s%s",
2390                         client_get_cur_dir(),
2391                         buf);
2392         if (!mask) {
2393                 return 1;
2394         }
2395
2396         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2397                 d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli));
2398                 return 1;
2399         }
2400
2401         if (!cli_posix_unlink(targetcli, targetname)) {
2402                 d_printf("Failed to unlink file %s. %s\n", targetname, cli_errstr(cli));
2403         } else {
2404                 d_printf("posix_unlink deleted file %s\n", targetname);
2405         }
2406
2407         return 0;
2408 }
2409
2410 static int cmd_posix_rmdir(void)
2411 {
2412         TALLOC_CTX *ctx = talloc_tos();
2413         char *mask = NULL;
2414         char *buf = NULL;
2415         char *targetname = NULL;
2416         struct cli_state *targetcli;
2417
2418         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2419                 d_printf("posix_rmdir <filename>\n");
2420                 return 1;
2421         }
2422         mask = talloc_asprintf(ctx,
2423                         "%s%s",
2424                         client_get_cur_dir(),
2425                         buf);
2426         if (!mask) {
2427                 return 1;
2428         }
2429
2430         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2431                 d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli));
2432                 return 1;
2433         }
2434
2435         if (!cli_posix_rmdir(targetcli, targetname)) {
2436                 d_printf("Failed to unlink directory %s. %s\n", targetname, cli_errstr(cli));
2437         } else {
2438                 d_printf("posix_rmdir deleted directory %s\n", targetname);
2439         }
2440
2441         return 0;
2442 }
2443
2444 static int cmd_close(void)
2445 {
2446         TALLOC_CTX *ctx = talloc_tos();
2447         char *buf = NULL;
2448         int fnum;
2449
2450         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2451                 d_printf("close <fnum>\n");
2452                 return 1;
2453         }
2454
2455         fnum = atoi(buf);
2456         /* We really should use the targetcli here.... */
2457         if (!cli_close(cli, fnum)) {
2458                 d_printf("close %d: %s\n", fnum, cli_errstr(cli));
2459                 return 1;
2460         }
2461         return 0;
2462 }
2463
2464 static int cmd_posix(void)
2465 {
2466         TALLOC_CTX *ctx = talloc_tos();
2467         uint16 major, minor;
2468         uint32 caplow, caphigh;
2469         char *caps;
2470
2471         if (!SERVER_HAS_UNIX_CIFS(cli)) {
2472                 d_printf("Server doesn't support UNIX CIFS extensions.\n");
2473                 return 1;
2474         }
2475
2476         if (!cli_unix_extensions_version(cli, &major, &minor, &caplow, &caphigh)) {
2477                 d_printf("Can't get UNIX CIFS extensions version from server.\n");
2478                 return 1;
2479         }
2480
2481         d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major, (unsigned int)minor);
2482
2483         caps = talloc_strdup(ctx, "");
2484         if (!caps) {
2485                 return 1;
2486         }
2487         if (caplow & CIFS_UNIX_FCNTL_LOCKS_CAP) {
2488                 caps = talloc_asprintf_append(caps, "locks ");
2489                 if (!caps) {
2490                         return 1;
2491                 }
2492         }
2493         if (caplow & CIFS_UNIX_POSIX_ACLS_CAP) {
2494                 caps = talloc_asprintf_append(caps, "acls ");
2495                 if (!caps) {
2496                         return 1;
2497                 }
2498         }
2499         if (caplow & CIFS_UNIX_XATTTR_CAP) {
2500                 caps = talloc_asprintf_append(caps, "eas ");
2501                 if (!caps) {
2502                         return 1;
2503                 }
2504         }
2505         if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2506                 caps = talloc_asprintf_append(caps, "pathnames ");
2507                 if (!caps) {
2508                         return 1;
2509                 }
2510         }
2511         if (caplow & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP) {
2512                 caps = talloc_asprintf_append(caps, "posix_path_operations ");
2513                 if (!caps) {
2514                         return 1;
2515                 }
2516         }
2517         if (caplow & CIFS_UNIX_LARGE_READ_CAP) {
2518                 caps = talloc_asprintf_append(caps, "large_read ");
2519                 if (!caps) {
2520                         return 1;
2521                 }
2522         }
2523         if (caplow & CIFS_UNIX_LARGE_WRITE_CAP) {
2524                 caps = talloc_asprintf_append(caps, "large_write ");
2525                 if (!caps) {
2526                         return 1;
2527                 }
2528         }
2529         if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP) {
2530                 caps = talloc_asprintf_append(caps, "posix_encrypt ");
2531                 if (!caps) {
2532                         return 1;
2533                 }
2534         }
2535         if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP) {
2536                 caps = talloc_asprintf_append(caps, "mandatory_posix_encrypt ");
2537                 if (!caps) {
2538                         return 1;
2539                 }
2540         }
2541
2542         if (*caps && caps[strlen(caps)-1] == ' ') {
2543                 caps[strlen(caps)-1] = '\0';
2544         }
2545
2546         d_printf("Server supports CIFS capabilities %s\n", caps);
2547
2548         if (!cli_set_unix_extensions_capabilities(cli, major, minor, caplow, caphigh)) {
2549                 d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n", cli_errstr(cli));
2550                 return 1;
2551         }
2552
2553         if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2554                 CLI_DIRSEP_CHAR = '/';
2555                 *CLI_DIRSEP_STR = '/';
2556                 client_set_cur_dir(CLI_DIRSEP_STR);
2557         }
2558
2559         return 0;
2560 }
2561
2562 static int cmd_lock(void)
2563 {
2564         TALLOC_CTX *ctx = talloc_tos();
2565         char *buf = NULL;
2566         uint64_t start, len;
2567         enum brl_type lock_type;
2568         int fnum;
2569
2570         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2571                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2572                 return 1;
2573         }
2574         fnum = atoi(buf);
2575
2576         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2577                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2578                 return 1;
2579         }
2580
2581         if (*buf == 'r' || *buf == 'R') {
2582                 lock_type = READ_LOCK;
2583         } else if (*buf == 'w' || *buf == 'W') {
2584                 lock_type = WRITE_LOCK;
2585         } else {
2586                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2587                 return 1;
2588         }
2589
2590         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2591                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2592                 return 1;
2593         }
2594
2595         start = (uint64_t)strtol(buf, (char **)NULL, 16);
2596
2597         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2598                 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2599                 return 1;
2600         }
2601
2602         len = (uint64_t)strtol(buf, (char **)NULL, 16);
2603
2604         if (!cli_posix_lock(cli, fnum, start, len, true, lock_type)) {
2605                 d_printf("lock failed %d: %s\n", fnum, cli_errstr(cli));
2606         }
2607
2608         return 0;
2609 }
2610
2611 static int cmd_unlock(void)
2612 {
2613         TALLOC_CTX *ctx = talloc_tos();
2614         char *buf = NULL;
2615         uint64_t start, len;
2616         int fnum;
2617
2618         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2619                 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2620                 return 1;
2621         }
2622         fnum = atoi(buf);
2623
2624         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2625                 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2626                 return 1;
2627         }
2628
2629         start = (uint64_t)strtol(buf, (char **)NULL, 16);
2630
2631         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2632                 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2633                 return 1;
2634         }
2635
2636         len = (uint64_t)strtol(buf, (char **)NULL, 16);
2637
2638         if (!cli_posix_unlock(cli, fnum, start, len)) {
2639                 d_printf("unlock failed %d: %s\n", fnum, cli_errstr(cli));
2640         }
2641
2642         return 0;
2643 }
2644
2645
2646 /****************************************************************************
2647  Remove a directory.
2648 ****************************************************************************/
2649
2650 static int cmd_rmdir(void)
2651 {
2652         TALLOC_CTX *ctx = talloc_tos();
2653         char *mask = NULL;
2654         char *buf = NULL;
2655         char *targetname = NULL;
2656         struct cli_state *targetcli;
2657
2658         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2659                 d_printf("rmdir <dirname>\n");
2660                 return 1;
2661         }
2662         mask = talloc_asprintf(ctx,
2663                         "%s%s",
2664                         client_get_cur_dir(),
2665                         buf);
2666         if (!mask) {
2667                 return 1;
2668         }
2669
2670         if (!cli_resolve_path(ctx, "", cli, mask, &targetcli, &targetname)) {
2671                 d_printf("rmdir %s: %s\n", mask, cli_errstr(cli));
2672                 return 1;
2673         }
2674
2675         if (!cli_rmdir(targetcli, targetname)) {
2676                 d_printf("%s removing remote directory file %s\n",
2677                          cli_errstr(targetcli),mask);
2678         }
2679
2680         return 0;
2681 }
2682
2683 /****************************************************************************
2684  UNIX hardlink.
2685 ****************************************************************************/
2686
2687 static int cmd_link(void)
2688 {
2689         TALLOC_CTX *ctx = talloc_tos();
2690         char *oldname = NULL;
2691         char *newname = NULL;
2692         char *buf = NULL;
2693         char *buf2 = NULL;
2694         char *targetname = NULL;
2695         struct cli_state *targetcli;
2696
2697         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
2698             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
2699                 d_printf("link <oldname> <newname>\n");
2700                 return 1;
2701         }
2702         oldname = talloc_asprintf(ctx,
2703                         "%s%s",
2704                         client_get_cur_dir(),
2705                         buf);
2706         if (!oldname) {
2707                 return 1;
2708         }
2709         newname = talloc_asprintf(ctx,
2710                         "%s%s",
2711                         client_get_cur_dir(),
2712                         buf2);
2713         if (!newname) {
2714                 return 1;
2715         }
2716
2717         if (!cli_resolve_path(ctx, "", cli, oldname, &targetcli, &targetname)) {
2718                 d_printf("link %s: %s\n", oldname, cli_errstr(cli));
2719                 return 1;
2720         }
2721
2722         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
2723                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2724                 return 1;
2725         }
2726
2727         if (!cli_unix_hardlink(targetcli, targetname, newname)) {
2728                 d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli), newname, oldname);
2729                 return 1;
2730         }
2731         return 0;
2732 }
2733
2734 /****************************************************************************
2735  UNIX symlink.
2736 ****************************************************************************/
2737
2738 static int cmd_symlink(void)
2739 {
2740         TALLOC_CTX *ctx = talloc_tos();
2741         char *oldname = NULL;
2742         char *newname = NULL;
2743         char *buf = NULL;
2744         char *buf2 = NULL;
2745         char *targetname = NULL;
2746         struct cli_state *targetcli;
2747
2748         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
2749             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
2750                 d_printf("symlink <oldname> <newname>\n");
2751                 return 1;
2752         }
2753         oldname = talloc_asprintf(ctx,
2754                         "%s%s",
2755                         client_get_cur_dir(),
2756                         buf);
2757         if (!oldname) {
2758                 return 1;
2759         }
2760         newname = talloc_asprintf(ctx,
2761                         "%s%s",
2762                         client_get_cur_dir(),
2763                         buf2);
2764         if (!newname) {
2765                 return 1;
2766         }
2767
2768         if (!cli_resolve_path(ctx, "", cli, oldname, &targetcli, &targetname)) {
2769                 d_printf("link %s: %s\n", oldname, cli_errstr(cli));
2770                 return 1;
2771         }
2772
2773         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
2774                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2775                 return 1;
2776         }
2777
2778         if (!cli_unix_symlink(targetcli, targetname, newname)) {
2779                 d_printf("%s symlinking files (%s -> %s)\n",
2780                         cli_errstr(targetcli), newname, targetname);
2781                 return 1;
2782         }
2783
2784         return 0;
2785 }
2786
2787 /****************************************************************************
2788  UNIX chmod.
2789 ****************************************************************************/
2790
2791 static int cmd_chmod(void)
2792 {
2793         TALLOC_CTX *ctx = talloc_tos();
2794         char *src = NULL;
2795         char *buf = NULL;
2796         char *buf2 = NULL;
2797         char *targetname = NULL;
2798         struct cli_state *targetcli;
2799         mode_t mode;
2800
2801         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
2802             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
2803                 d_printf("chmod mode file\n");
2804                 return 1;
2805         }
2806         src = talloc_asprintf(ctx,
2807                         "%s%s",
2808                         client_get_cur_dir(),
2809                         buf2);
2810         if (!src) {
2811                 return 1;
2812         }
2813
2814         mode = (mode_t)strtol(buf, NULL, 8);
2815
2816         if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
2817                 d_printf("chmod %s: %s\n", src, cli_errstr(cli));
2818                 return 1;
2819         }
2820
2821         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
2822                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2823                 return 1;
2824         }
2825
2826         if (!cli_unix_chmod(targetcli, targetname, mode)) {
2827                 d_printf("%s chmod file %s 0%o\n",
2828                         cli_errstr(targetcli), src, (unsigned int)mode);
2829                 return 1;
2830         }
2831
2832         return 0;
2833 }
2834
2835 static const char *filetype_to_str(mode_t mode)
2836 {
2837         if (S_ISREG(mode)) {
2838                 return "regular file";
2839         } else if (S_ISDIR(mode)) {
2840                 return "directory";
2841         } else
2842 #ifdef S_ISCHR
2843         if (S_ISCHR(mode)) {
2844                 return "character device";
2845         } else
2846 #endif
2847 #ifdef S_ISBLK
2848         if (S_ISBLK(mode)) {
2849                 return "block device";
2850         } else
2851 #endif
2852 #ifdef S_ISFIFO
2853         if (S_ISFIFO(mode)) {
2854                 return "fifo";
2855         } else
2856 #endif
2857 #ifdef S_ISLNK
2858         if (S_ISLNK(mode)) {
2859                 return "symbolic link";
2860         } else
2861 #endif
2862 #ifdef S_ISSOCK
2863         if (S_ISSOCK(mode)) {
2864                 return "socket";
2865         } else
2866 #endif
2867         return "";
2868 }
2869
2870 static char rwx_to_str(mode_t m, mode_t bt, char ret)
2871 {
2872         if (m & bt) {
2873                 return ret;
2874         } else {
2875                 return '-';
2876         }
2877 }
2878
2879 static char *unix_mode_to_str(char *s, mode_t m)
2880 {
2881         char *p = s;
2882         const char *str = filetype_to_str(m);
2883
2884         switch(str[0]) {
2885                 case 'd':
2886                         *p++ = 'd';
2887                         break;
2888                 case 'c':
2889                         *p++ = 'c';
2890                         break;
2891                 case 'b':
2892                         *p++ = 'b';
2893                         break;
2894                 case 'f':
2895                         *p++ = 'p';
2896                         break;
2897                 case 's':
2898                         *p++ = str[1] == 'y' ? 'l' : 's';
2899                         break;
2900                 case 'r':
2901                 default:
2902                         *p++ = '-';
2903                         break;
2904         }
2905         *p++ = rwx_to_str(m, S_IRUSR, 'r');
2906         *p++ = rwx_to_str(m, S_IWUSR, 'w');
2907         *p++ = rwx_to_str(m, S_IXUSR, 'x');
2908         *p++ = rwx_to_str(m, S_IRGRP, 'r');
2909         *p++ = rwx_to_str(m, S_IWGRP, 'w');
2910         *p++ = rwx_to_str(m, S_IXGRP, 'x');
2911         *p++ = rwx_to_str(m, S_IROTH, 'r');
2912         *p++ = rwx_to_str(m, S_IWOTH, 'w');
2913         *p++ = rwx_to_str(m, S_IXOTH, 'x');
2914         *p++ = '\0';
2915         return s;
2916 }
2917
2918 /****************************************************************************
2919  Utility function for UNIX getfacl.
2920 ****************************************************************************/
2921
2922 static char *perms_to_string(fstring permstr, unsigned char perms)
2923 {
2924         fstrcpy(permstr, "---");
2925         if (perms & SMB_POSIX_ACL_READ) {
2926                 permstr[0] = 'r';
2927         }
2928         if (perms & SMB_POSIX_ACL_WRITE) {
2929                 permstr[1] = 'w';
2930         }
2931         if (perms & SMB_POSIX_ACL_EXECUTE) {
2932                 permstr[2] = 'x';
2933         }
2934         return permstr;
2935 }
2936
2937 /****************************************************************************
2938  UNIX getfacl.
2939 ****************************************************************************/
2940
2941 static int cmd_getfacl(void)
2942 {
2943         TALLOC_CTX *ctx = talloc_tos();
2944         char *src = NULL;
2945         char *name = NULL;
2946         char *targetname = NULL;
2947         struct cli_state *targetcli;
2948         uint16 major, minor;
2949         uint32 caplow, caphigh;
2950         char *retbuf = NULL;
2951         size_t rb_size = 0;
2952         SMB_STRUCT_STAT sbuf;
2953         uint16 num_file_acls = 0;
2954         uint16 num_dir_acls = 0;
2955         uint16 i;
2956
2957         if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
2958                 d_printf("getfacl filename\n");
2959                 return 1;
2960         }
2961         src = talloc_asprintf(ctx,
2962                         "%s%s",
2963                         client_get_cur_dir(),
2964                         name);
2965         if (!src) {
2966                 return 1;
2967         }
2968
2969         if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
2970                 d_printf("stat %s: %s\n", src, cli_errstr(cli));
2971                 return 1;
2972         }
2973
2974         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
2975                 d_printf("Server doesn't support UNIX CIFS calls.\n");
2976                 return 1;
2977         }
2978
2979         if (!cli_unix_extensions_version(targetcli, &major, &minor,
2980                                 &caplow, &caphigh)) {
2981                 d_printf("Can't get UNIX CIFS version from server.\n");
2982                 return 1;
2983         }
2984
2985         if (!(caplow & CIFS_UNIX_POSIX_ACLS_CAP)) {
2986                 d_printf("This server supports UNIX extensions "
2987                         "but doesn't support POSIX ACLs.\n");
2988                 return 1;
2989         }
2990
2991         if (!cli_unix_stat(targetcli, targetname, &sbuf)) {
2992                 d_printf("%s getfacl doing a stat on file %s\n",
2993                         cli_errstr(targetcli), src);
2994                 return 1;
2995         }
2996
2997         if (!cli_unix_getfacl(targetcli, targetname, &rb_size, &retbuf)) {
2998                 d_printf("%s getfacl file %s\n",
2999                         cli_errstr(targetcli), src);
3000                 return 1;
3001         }
3002
3003         /* ToDo : Print out the ACL values. */
3004         if (SVAL(retbuf,0) != SMB_POSIX_ACL_VERSION || rb_size < 6) {
3005                 d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
3006                         src, (unsigned int)CVAL(retbuf,0) );
3007                 SAFE_FREE(retbuf);
3008                 return 1;
3009         }
3010
3011         num_file_acls = SVAL(retbuf,2);
3012         num_dir_acls = SVAL(retbuf,4);
3013         if (rb_size != SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)) {
3014                 d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
3015                         src,
3016                         (unsigned int)(SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)),
3017                         (unsigned int)rb_size);
3018
3019                 SAFE_FREE(retbuf);
3020                 return 1;
3021         }
3022
3023         d_printf("# file: %s\n", src);
3024         d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf.st_uid, (unsigned int)sbuf.st_gid);
3025
3026         if (num_file_acls == 0 && num_dir_acls == 0) {
3027                 d_printf("No acls found.\n");
3028         }
3029
3030         for (i = 0; i < num_file_acls; i++) {
3031                 uint32 uorg;
3032                 fstring permstring;
3033                 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE));
3034                 unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+1);
3035
3036                 switch(tagtype) {
3037                         case SMB_POSIX_ACL_USER_OBJ:
3038                                 d_printf("user::");
3039                                 break;
3040                         case SMB_POSIX_ACL_USER:
3041                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3042                                 d_printf("user:%u:", uorg);
3043                                 break;
3044                         case SMB_POSIX_ACL_GROUP_OBJ:
3045                                 d_printf("group::");
3046                                 break;
3047                         case SMB_POSIX_ACL_GROUP:
3048                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3049                                 d_printf("group:%u:", uorg);
3050                                 break;
3051                         case SMB_POSIX_ACL_MASK:
3052                                 d_printf("mask::");
3053                                 break;
3054                         case SMB_POSIX_ACL_OTHER:
3055                                 d_printf("other::");
3056                                 break;
3057                         default:
3058                                 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3059                                         src, (unsigned int)tagtype );
3060                                 SAFE_FREE(retbuf);
3061                                 return 1;
3062                 }
3063
3064                 d_printf("%s\n", perms_to_string(permstring, perms));
3065         }
3066
3067         for (i = 0; i < num_dir_acls; i++) {
3068                 uint32 uorg;
3069                 fstring permstring;
3070                 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE));
3071                 unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+1);
3072
3073                 switch(tagtype) {
3074                         case SMB_POSIX_ACL_USER_OBJ:
3075                                 d_printf("default:user::");
3076                                 break;
3077                         case SMB_POSIX_ACL_USER:
3078                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3079                                 d_printf("default:user:%u:", uorg);
3080                                 break;
3081                         case SMB_POSIX_ACL_GROUP_OBJ:
3082                                 d_printf("default:group::");
3083                                 break;
3084                         case SMB_POSIX_ACL_GROUP:
3085                                 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3086                                 d_printf("default:group:%u:", uorg);
3087                                 break;
3088                         case SMB_POSIX_ACL_MASK:
3089                                 d_printf("default:mask::");
3090                                 break;
3091                         case SMB_POSIX_ACL_OTHER:
3092                                 d_printf("default:other::");
3093                                 break;
3094                         default:
3095                                 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3096                                         src, (unsigned int)tagtype );
3097                                 SAFE_FREE(retbuf);
3098                                 return 1;
3099                 }
3100
3101                 d_printf("%s\n", perms_to_string(permstring, perms));
3102         }
3103
3104         SAFE_FREE(retbuf);
3105         return 0;
3106 }
3107
3108 /****************************************************************************
3109  UNIX stat.
3110 ****************************************************************************/
3111
3112 static int cmd_stat(void)
3113 {
3114         TALLOC_CTX *ctx = talloc_tos();
3115         char *src = NULL;
3116         char *name = NULL;
3117         char *targetname = NULL;
3118         struct cli_state *targetcli;
3119         fstring mode_str;
3120         SMB_STRUCT_STAT sbuf;
3121         struct tm *lt;
3122
3123         if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
3124                 d_printf("stat file\n");
3125                 return 1;
3126         }
3127         src = talloc_asprintf(ctx,
3128                         "%s%s",
3129                         client_get_cur_dir(),
3130                         name);
3131         if (!src) {
3132                 return 1;
3133         }
3134
3135         if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname)) {
3136                 d_printf("stat %s: %s\n", src, cli_errstr(cli));
3137                 return 1;
3138         }
3139
3140         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3141                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3142                 return 1;
3143         }
3144
3145         if (!cli_unix_stat(targetcli, targetname, &sbuf)) {
3146                 d_printf("%s stat file %s\n",
3147                         cli_errstr(targetcli), src);
3148                 return 1;
3149         }
3150
3151         /* Print out the stat values. */
3152         d_printf("File: %s\n", src);
3153         d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
3154                 (double)sbuf.st_size,
3155                 (unsigned int)sbuf.st_blocks,
3156                 filetype_to_str(sbuf.st_mode));
3157
3158 #if defined(S_ISCHR) && defined(S_ISBLK)
3159         if (S_ISCHR(sbuf.st_mode) || S_ISBLK(sbuf.st_mode)) {
3160                 d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
3161                         (double)sbuf.st_ino,
3162                         (unsigned int)sbuf.st_nlink,
3163                         unix_dev_major(sbuf.st_rdev),
3164                         unix_dev_minor(sbuf.st_rdev));
3165         } else
3166 #endif
3167                 d_printf("Inode: %.0f\tLinks: %u\n",
3168                         (double)sbuf.st_ino,
3169                         (unsigned int)sbuf.st_nlink);
3170
3171         d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
3172                 ((int)sbuf.st_mode & 0777),
3173                 unix_mode_to_str(mode_str, sbuf.st_mode),
3174                 (unsigned int)sbuf.st_uid,
3175                 (unsigned int)sbuf.st_gid);
3176
3177         lt = localtime(&sbuf.st_atime);
3178         if (lt) {
3179                 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
3180         } else {
3181                 fstrcpy(mode_str, "unknown");
3182         }
3183         d_printf("Access: %s\n", mode_str);
3184
3185         lt = localtime(&sbuf.st_mtime);
3186         if (lt) {
3187                 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
3188         } else {
3189                 fstrcpy(mode_str, "unknown");
3190         }
3191         d_printf("Modify: %s\n", mode_str);
3192
3193         lt = localtime(&sbuf.st_ctime);
3194         if (lt) {
3195                 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
3196         } else {
3197                 fstrcpy(mode_str, "unknown");
3198         }
3199         d_printf("Change: %s\n", mode_str);
3200
3201         return 0;
3202 }
3203
3204
3205 /****************************************************************************
3206  UNIX chown.
3207 ****************************************************************************/
3208
3209 static int cmd_chown(void)
3210 {
3211         TALLOC_CTX *ctx = talloc_tos();
3212         char *src = NULL;
3213         uid_t uid;
3214         gid_t gid;
3215         char *buf, *buf2, *buf3;
3216         struct cli_state *targetcli;
3217         char *targetname = NULL;
3218
3219         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3220             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL) ||
3221             !next_token_talloc(ctx, &cmd_ptr,&buf3,NULL)) {
3222                 d_printf("chown uid gid file\n");
3223                 return 1;
3224         }
3225
3226         uid = (uid_t)atoi(buf);
3227         gid = (gid_t)atoi(buf2);
3228
3229         src = talloc_asprintf(ctx,
3230                         "%s%s",
3231                         client_get_cur_dir(),
3232                         buf3);
3233         if (!src) {
3234                 return 1;
3235         }
3236         if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetname) ) {
3237                 d_printf("chown %s: %s\n", src, cli_errstr(cli));
3238                 return 1;
3239         }
3240
3241         if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3242                 d_printf("Server doesn't support UNIX CIFS calls.\n");
3243                 return 1;
3244         }
3245
3246         if (!cli_unix_chown(targetcli, targetname, uid, gid)) {
3247                 d_printf("%s chown file %s uid=%d, gid=%d\n",
3248                         cli_errstr(targetcli), src, (int)uid, (int)gid);
3249                 return 1;
3250         }
3251
3252         return 0;
3253 }
3254
3255 /****************************************************************************
3256  Rename some file.
3257 ****************************************************************************/
3258
3259 static int cmd_rename(void)
3260 {
3261         TALLOC_CTX *ctx = talloc_tos();
3262         char *src, *dest;
3263         char *buf, *buf2;
3264         struct cli_state *targetcli;
3265         char *targetsrc;
3266         char *targetdest;
3267
3268         if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3269             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3270                 d_printf("rename <src> <dest>\n");
3271                 return 1;
3272         }
3273
3274         src = talloc_asprintf(ctx,
3275                         "%s%s",
3276                         client_get_cur_dir(),
3277                         buf);
3278         if (!src) {
3279                 return 1;
3280         }
3281
3282         dest = talloc_asprintf(ctx,
3283                         "%s%s",
3284                         client_get_cur_dir(),
3285                         buf2);
3286         if (!dest) {
3287                 return 1;
3288         }
3289
3290         if (!cli_resolve_path(ctx, "", cli, src, &targetcli, &targetsrc)) {
3291                 d_printf("rename %s: %s\n", src, cli_errstr(cli));
3292                 return 1;
3293         }
3294
3295         if (!cli_resolve_path(ctx, "", cli, dest, &targetcli, &targetdest)) {
3296                 d_printf("rename %s: %s\n", dest, cli_errstr(cli));
3297                 return 1;
3298         }
3299
3300         if (!cli_rename(targetcli, targetsrc, targetdest)) {
3301                 d_printf("%s renaming files %s -> %s \n",
3302                         cli_errstr(targetcli),
3303                         targetsrc,
3304                         targetdest);
3305                 return 1;
3306         }
3307
3308         return 0;
3309 }