2 Unix SMB/CIFS implementation.
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
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.
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.
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/>.
25 #include "system/filesys.h"
26 #include "popt_common.h"
27 #include "rpc_client/cli_pipe.h"
28 #include "client/client_proto.h"
29 #include "client/clitar_proto.h"
30 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
31 #include "../lib/util/select.h"
32 #include "system/readline.h"
33 #include "../libcli/smbreadline/smbreadline.h"
34 #include "../libcli/security/security.h"
35 #include "system/select.h"
36 #include "libsmb/libsmb.h"
37 #include "libsmb/clirap.h"
39 #include "libsmb/nmblib.h"
40 #include "include/ntioctl.h"
41 #include "../libcli/smb/smbXcli_base.h"
47 extern int do_smb_browse(void); /* mDNS browsing */
49 extern bool override_logfile
;
53 static char *desthost
;
54 static bool grepable
= false;
55 static char *cmdstr
= NULL
;
56 const char *cmd_ptr
= NULL
;
58 static int io_bufsize
= 0; /* we use the default size */
59 static int io_timeout
= (CLIENT_TIMEOUT
/1000); /* Per operation timeout (in seconds). */
61 static int name_type
= 0x20;
62 static int max_protocol
= -1;
64 static int process_tok(char *tok
);
65 static int cmd_help(void);
67 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
69 /* value for unused fid field in trans2 secondary request */
70 #define FID_UNUSED (0xFFFF)
72 time_t newer_than
= 0;
73 static int archive_level
= 0;
75 static bool translation
= false;
78 static bool prompt
= true;
80 static bool recurse
= false;
81 static bool showacls
= false;
82 bool lowercase
= false;
83 static bool backup_intent
= false;
85 static struct sockaddr_storage dest_ss
;
86 static char dest_ss_str
[INET6_ADDRSTRLEN
];
88 #define SEPARATORS " \t\n\r"
90 static bool abort_mget
= true;
93 uint64_t get_total_size
= 0;
94 unsigned int get_total_time_ms
= 0;
95 static uint64_t put_total_size
= 0;
96 static unsigned int put_total_time_ms
= 0;
99 static double dir_total
;
101 /* encrypted state. */
102 static bool smb_encrypt
;
104 /* root cli_state connection */
106 struct cli_state
*cli
;
108 static char CLI_DIRSEP_CHAR
= '\\';
109 static char CLI_DIRSEP_STR
[] = { '\\', '\0' };
111 /* Accessor functions for directory paths. */
112 static char *fileselection
;
113 static const char *client_get_fileselection(void)
116 return fileselection
;
121 static const char *client_set_fileselection(const char *new_fs
)
123 SAFE_FREE(fileselection
);
125 fileselection
= SMB_STRDUP(new_fs
);
127 return client_get_fileselection();
131 static const char *client_get_cwd(void)
136 return CLI_DIRSEP_STR
;
139 static const char *client_set_cwd(const char *new_cwd
)
143 cwd
= SMB_STRDUP(new_cwd
);
145 return client_get_cwd();
148 static char *cur_dir
;
149 const char *client_get_cur_dir(void)
154 return CLI_DIRSEP_STR
;
157 const char *client_set_cur_dir(const char *newdir
)
161 cur_dir
= SMB_STRDUP(newdir
);
163 return client_get_cur_dir();
166 /****************************************************************************
167 Put up a yes/no prompt.
168 ****************************************************************************/
170 static bool yesno(const char *p
)
175 if (!fgets(ans
,sizeof(ans
)-1,stdin
))
178 if (*ans
== 'y' || *ans
== 'Y')
184 /****************************************************************************
185 Write to a local file with CR/LF->LF translation if appropriate. Return the
186 number taken from the buffer. This may not equal the number written.
187 ****************************************************************************/
189 static int writefile(int f
, char *b
, int n
)
199 if (*b
== '\r' && (i
<(n
-1)) && *(b
+1) == '\n') {
202 if (write(f
, b
, 1) != 1) {
212 /****************************************************************************
213 Read from a file with LF->CR/LF translation if appropriate. Return the
214 number read. read approx n bytes.
215 ****************************************************************************/
217 static int readfile(uint8_t *b
, int n
, FILE *f
)
223 return fread(b
,1,n
,f
);
226 while (i
< (n
- 1)) {
227 if ((c
= getc(f
)) == EOF
) {
231 if (c
== '\n') { /* change all LFs to CR/LF */
246 static size_t push_source(uint8_t *buf
, size_t n
, void *priv
)
248 struct push_state
*state
= (struct push_state
*)priv
;
251 if (feof(state
->f
)) {
255 result
= readfile(buf
, n
, state
->f
);
256 state
->nread
+= result
;
260 /****************************************************************************
262 ****************************************************************************/
264 static void send_message(const char *username
)
270 d_printf("Type your message, ending it with a Control-D\n");
273 while (i
<sizeof(buf
)-2) {
274 int c
= fgetc(stdin
);
285 status
= cli_message(cli
, desthost
, username
, buf
);
286 if (!NT_STATUS_IS_OK(status
)) {
287 d_fprintf(stderr
, "cli_message returned %s\n",
292 /****************************************************************************
293 Check the space on a device.
294 ****************************************************************************/
296 static int do_dskattr(void)
298 uint64_t total
, bsize
, avail
;
299 struct cli_state
*targetcli
= NULL
;
300 char *targetpath
= NULL
;
301 TALLOC_CTX
*ctx
= talloc_tos();
304 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(), cli
,
305 client_get_cur_dir(), &targetcli
,
307 if (!NT_STATUS_IS_OK(status
)) {
308 d_printf("Error in dskattr: %s\n", nt_errstr(status
));
312 status
= cli_disk_size(targetcli
, targetpath
, &bsize
, &total
, &avail
);
313 if (!NT_STATUS_IS_OK(status
)) {
314 d_printf("Error in dskattr: %s\n", nt_errstr(status
));
318 d_printf("\n\t\t%" PRIu64
319 " blocks of size %" PRIu64
320 ". %" PRIu64
" blocks available\n",
321 total
, bsize
, avail
);
326 /****************************************************************************
328 ****************************************************************************/
330 static int cmd_pwd(void)
332 d_printf("Current directory is %s",service
);
333 d_printf("%s\n",client_get_cur_dir());
337 /****************************************************************************
338 Ensure name has correct directory separators.
339 ****************************************************************************/
341 static void normalize_name(char *newdir
)
343 if (!(cli
->requested_posix_capabilities
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)) {
344 string_replace(newdir
,'/','\\');
348 /****************************************************************************
349 Change directory - inner section.
350 ****************************************************************************/
352 static int do_cd(const char *new_dir
)
355 char *saved_dir
= NULL
;
357 char *targetpath
= NULL
;
358 struct cli_state
*targetcli
= NULL
;
359 SMB_STRUCT_STAT sbuf
;
362 TALLOC_CTX
*ctx
= talloc_stackframe();
365 newdir
= talloc_strdup(ctx
, new_dir
);
371 normalize_name(newdir
);
373 /* Save the current directory in case the new directory is invalid */
375 saved_dir
= talloc_strdup(ctx
, client_get_cur_dir());
381 if (*newdir
== CLI_DIRSEP_CHAR
) {
382 client_set_cur_dir(newdir
);
385 new_cd
= talloc_asprintf(ctx
, "%s%s",
386 client_get_cur_dir(),
393 /* Ensure cur_dir ends in a DIRSEP */
394 if ((new_cd
[0] != '\0') && (*(new_cd
+strlen(new_cd
)-1) != CLI_DIRSEP_CHAR
)) {
395 new_cd
= talloc_asprintf_append(new_cd
, "%s", CLI_DIRSEP_STR
);
400 client_set_cur_dir(new_cd
);
402 new_cd
= clean_name(ctx
, new_cd
);
403 client_set_cur_dir(new_cd
);
405 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
406 cli
, new_cd
, &targetcli
, &targetpath
);
407 if (!NT_STATUS_IS_OK(status
)) {
408 d_printf("cd %s: %s\n", new_cd
, nt_errstr(status
));
409 client_set_cur_dir(saved_dir
);
413 if (strequal(targetpath
,CLI_DIRSEP_STR
)) {
418 /* Use a trans2_qpathinfo to test directories for modern servers.
419 Except Win9x doesn't support the qpathinfo_basic() call..... */
421 if (smbXcli_conn_protocol(targetcli
->conn
) > PROTOCOL_LANMAN2
&& !targetcli
->win95
) {
423 status
= cli_qpathinfo_basic(targetcli
, targetpath
, &sbuf
,
425 if (!NT_STATUS_IS_OK(status
)) {
426 d_printf("cd %s: %s\n", new_cd
, nt_errstr(status
));
427 client_set_cur_dir(saved_dir
);
431 if (!(attributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
432 d_printf("cd %s: not a directory\n", new_cd
);
433 client_set_cur_dir(saved_dir
);
438 targetpath
= talloc_asprintf(ctx
,
443 client_set_cur_dir(saved_dir
);
446 targetpath
= clean_name(ctx
, targetpath
);
448 client_set_cur_dir(saved_dir
);
452 status
= cli_chkpath(targetcli
, targetpath
);
453 if (!NT_STATUS_IS_OK(status
)) {
454 d_printf("cd %s: %s\n", new_cd
, nt_errstr(status
));
455 client_set_cur_dir(saved_dir
);
468 /****************************************************************************
470 ****************************************************************************/
472 static int cmd_cd(void)
477 if (next_token_talloc(talloc_tos(), &cmd_ptr
, &buf
,NULL
)) {
480 d_printf("Current directory is %s\n",client_get_cur_dir());
486 /****************************************************************************
488 ****************************************************************************/
490 static int cmd_cd_oneup(void)
495 /*******************************************************************
496 Decide if a file should be operated on.
497 ********************************************************************/
499 static bool do_this_one(struct file_info
*finfo
)
505 if (finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
509 if (*client_get_fileselection() &&
510 !mask_match(finfo
->name
,client_get_fileselection(),false)) {
511 DEBUG(3,("mask_match %s failed\n", finfo
->name
));
515 if (newer_than
&& finfo
->mtime_ts
.tv_sec
< newer_than
) {
516 DEBUG(3,("newer_than %s failed\n", finfo
->name
));
520 if ((archive_level
==1 || archive_level
==2) && !(finfo
->mode
& FILE_ATTRIBUTE_ARCHIVE
)) {
521 DEBUG(3,("archive %s failed\n", finfo
->name
));
528 /****************************************************************************
529 Display info about a file.
530 ****************************************************************************/
532 static NTSTATUS
display_finfo(struct cli_state
*cli_state
, struct file_info
*finfo
,
536 TALLOC_CTX
*ctx
= talloc_tos();
537 NTSTATUS status
= NT_STATUS_OK
;
539 if (!do_this_one(finfo
)) {
543 t
= finfo
->mtime_ts
.tv_sec
; /* the time is assumed to be passed as GMT */
545 d_printf(" %-30s%7.7s %8.0f %s",
547 attrib_string(talloc_tos(), finfo
->mode
),
550 dir_total
+= finfo
->size
;
555 /* skip if this is . or .. */
556 if ( strequal(finfo
->name
,"..") || strequal(finfo
->name
,".") )
558 /* create absolute filename for cli_ntcreate() FIXME */
559 afname
= talloc_asprintf(ctx
,
565 return NT_STATUS_NO_MEMORY
;
567 /* print file meta date header */
568 d_printf( "FILENAME:%s\n", finfo
->name
);
569 d_printf( "MODE:%s\n", attrib_string(talloc_tos(), finfo
->mode
));
570 d_printf( "SIZE:%.0f\n", (double)finfo
->size
);
571 d_printf( "MTIME:%s", time_to_asc(t
));
572 status
= cli_ntcreate(cli_state
, afname
, 0,
573 CREATE_ACCESS_READ
, 0,
574 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
575 FILE_OPEN
, 0x0, 0x0, &fnum
, NULL
);
576 if (!NT_STATUS_IS_OK(status
)) {
577 DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
578 afname
, nt_errstr(status
)));
580 struct security_descriptor
*sd
= NULL
;
581 status
= cli_query_secdesc(cli_state
, fnum
,
583 if (!NT_STATUS_IS_OK(status
)) {
584 DEBUG( 0, ("display_finfo() failed to "
585 "get security descriptor: %s",
588 display_sec_desc(sd
);
597 /****************************************************************************
598 Accumulate size of a file.
599 ****************************************************************************/
601 static NTSTATUS
do_du(struct cli_state
*cli_state
, struct file_info
*finfo
,
604 if (do_this_one(finfo
)) {
605 dir_total
+= finfo
->size
;
610 static bool do_list_recurse
;
611 static bool do_list_dirs
;
612 static char *do_list_queue
= 0;
613 static long do_list_queue_size
= 0;
614 static long do_list_queue_start
= 0;
615 static long do_list_queue_end
= 0;
616 static NTSTATUS (*do_list_fn
)(struct cli_state
*cli_state
, struct file_info
*,
619 /****************************************************************************
620 Functions for do_list_queue.
621 ****************************************************************************/
624 * The do_list_queue is a NUL-separated list of strings stored in a
625 * char*. Since this is a FIFO, we keep track of the beginning and
626 * ending locations of the data in the queue. When we overflow, we
627 * double the size of the char*. When the start of the data passes
628 * the midpoint, we move everything back. This is logically more
629 * complex than a linked list, but easier from a memory management
630 * angle. In any memory error condition, do_list_queue is reset.
631 * Functions check to ensure that do_list_queue is non-NULL before
635 static void reset_do_list_queue(void)
637 SAFE_FREE(do_list_queue
);
638 do_list_queue_size
= 0;
639 do_list_queue_start
= 0;
640 do_list_queue_end
= 0;
643 static void init_do_list_queue(void)
645 reset_do_list_queue();
646 do_list_queue_size
= 1024;
647 do_list_queue
= (char *)SMB_MALLOC(do_list_queue_size
);
648 if (do_list_queue
== 0) {
649 d_printf("malloc fail for size %d\n",
650 (int)do_list_queue_size
);
651 reset_do_list_queue();
653 memset(do_list_queue
, 0, do_list_queue_size
);
657 static void adjust_do_list_queue(void)
660 * If the starting point of the queue is more than half way through,
661 * move everything toward the beginning.
664 if (do_list_queue
== NULL
) {
665 DEBUG(4,("do_list_queue is empty\n"));
666 do_list_queue_start
= do_list_queue_end
= 0;
670 if (do_list_queue_start
== do_list_queue_end
) {
671 DEBUG(4,("do_list_queue is empty\n"));
672 do_list_queue_start
= do_list_queue_end
= 0;
673 *do_list_queue
= '\0';
674 } else if (do_list_queue_start
> (do_list_queue_size
/ 2)) {
675 DEBUG(4,("sliding do_list_queue backward\n"));
676 memmove(do_list_queue
,
677 do_list_queue
+ do_list_queue_start
,
678 do_list_queue_end
- do_list_queue_start
);
679 do_list_queue_end
-= do_list_queue_start
;
680 do_list_queue_start
= 0;
684 static void add_to_do_list_queue(const char *entry
)
686 long new_end
= do_list_queue_end
+ ((long)strlen(entry
)) + 1;
687 while (new_end
> do_list_queue_size
) {
688 do_list_queue_size
*= 2;
689 DEBUG(4,("enlarging do_list_queue to %d\n",
690 (int)do_list_queue_size
));
691 do_list_queue
= (char *)SMB_REALLOC(do_list_queue
, do_list_queue_size
);
692 if (! do_list_queue
) {
693 d_printf("failure enlarging do_list_queue to %d bytes\n",
694 (int)do_list_queue_size
);
695 reset_do_list_queue();
697 memset(do_list_queue
+ do_list_queue_size
/ 2,
698 0, do_list_queue_size
/ 2);
702 strlcpy_base(do_list_queue
+ do_list_queue_end
,
703 entry
, do_list_queue
, do_list_queue_size
);
704 do_list_queue_end
= new_end
;
705 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
706 entry
, (int)do_list_queue_start
, (int)do_list_queue_end
));
710 static char *do_list_queue_head(void)
712 return do_list_queue
+ do_list_queue_start
;
715 static void remove_do_list_queue_head(void)
717 if (do_list_queue_end
> do_list_queue_start
) {
718 do_list_queue_start
+= strlen(do_list_queue_head()) + 1;
719 adjust_do_list_queue();
720 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
721 (int)do_list_queue_start
, (int)do_list_queue_end
));
725 static int do_list_queue_empty(void)
727 return (! (do_list_queue
&& *do_list_queue
));
730 /****************************************************************************
731 A helper for do_list.
732 ****************************************************************************/
734 static NTSTATUS
do_list_helper(const char *mntpoint
, struct file_info
*f
,
735 const char *mask
, void *state
)
737 struct cli_state
*cli_state
= (struct cli_state
*)state
;
738 TALLOC_CTX
*ctx
= talloc_tos();
740 char *dir_end
= NULL
;
741 NTSTATUS status
= NT_STATUS_OK
;
743 /* Work out the directory. */
744 dir
= talloc_strdup(ctx
, mask
);
746 return NT_STATUS_NO_MEMORY
;
748 if ((dir_end
= strrchr(dir
, CLI_DIRSEP_CHAR
)) != NULL
) {
752 if (f
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
753 if (do_list_dirs
&& do_this_one(f
)) {
754 status
= do_list_fn(cli_state
, f
, dir
);
755 if (!NT_STATUS_IS_OK(status
)) {
759 if (do_list_recurse
&&
761 !strequal(f
->name
,".") &&
762 !strequal(f
->name
,"..")) {
767 d_printf("Empty dir name returned. Possible server misconfiguration.\n");
769 return NT_STATUS_UNSUCCESSFUL
;
772 mask2
= talloc_asprintf(ctx
,
778 return NT_STATUS_NO_MEMORY
;
780 p
= strrchr_m(mask2
,CLI_DIRSEP_CHAR
);
786 mask2
= talloc_asprintf_append(mask2
,
792 return NT_STATUS_NO_MEMORY
;
794 add_to_do_list_queue(mask2
);
801 if (do_this_one(f
)) {
802 status
= do_list_fn(cli_state
, f
, dir
);
808 /****************************************************************************
809 A wrapper around cli_list that adds recursion.
810 ****************************************************************************/
812 NTSTATUS
do_list(const char *mask
,
814 NTSTATUS (*fn
)(struct cli_state
*cli_state
, struct file_info
*,
819 static int in_do_list
= 0;
820 TALLOC_CTX
*ctx
= talloc_tos();
821 struct cli_state
*targetcli
= NULL
;
822 char *targetpath
= NULL
;
823 NTSTATUS ret_status
= NT_STATUS_OK
;
824 NTSTATUS status
= NT_STATUS_OK
;
826 if (in_do_list
&& rec
) {
827 fprintf(stderr
, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
833 do_list_recurse
= rec
;
838 init_do_list_queue();
839 add_to_do_list_queue(mask
);
841 while (!do_list_queue_empty()) {
843 * Need to copy head so that it doesn't become
844 * invalid inside the call to cli_list. This
845 * would happen if the list were expanded
847 * Fix from E. Jay Berkenbilt (ejb@ql.org)
849 char *head
= talloc_strdup(ctx
, do_list_queue_head());
852 return NT_STATUS_NO_MEMORY
;
857 status
= cli_resolve_path(ctx
, "",
858 popt_get_cmdline_auth_info(),
859 cli
, head
, &targetcli
, &targetpath
);
860 if (!NT_STATUS_IS_OK(status
)) {
861 d_printf("do_list: [%s] %s\n", head
,
863 remove_do_list_queue_head();
867 status
= cli_list(targetcli
, targetpath
, attribute
,
868 do_list_helper
, targetcli
);
869 if (!NT_STATUS_IS_OK(status
)) {
870 d_printf("%s listing %s\n",
871 nt_errstr(status
), targetpath
);
874 remove_do_list_queue_head();
875 if ((! do_list_queue_empty()) && (fn
== display_finfo
)) {
876 char *next_file
= do_list_queue_head();
878 if ((strlen(next_file
) >= 2) &&
879 (next_file
[strlen(next_file
) - 1] == '*') &&
880 (next_file
[strlen(next_file
) - 2] == CLI_DIRSEP_CHAR
)) {
881 save_ch
= next_file
+
882 strlen(next_file
) - 2;
885 /* cwd is only used if showacls is on */
886 client_set_cwd(next_file
);
889 if (!showacls
) /* don't disturbe the showacls output */
890 d_printf("\n%s\n",next_file
);
892 *save_ch
= CLI_DIRSEP_CHAR
;
896 TALLOC_FREE(targetpath
);
900 status
= cli_resolve_path(ctx
, "",
901 popt_get_cmdline_auth_info(), cli
, mask
,
902 &targetcli
, &targetpath
);
903 if (NT_STATUS_IS_OK(status
)) {
904 status
= cli_list(targetcli
, targetpath
, attribute
,
905 do_list_helper
, targetcli
);
906 if (!NT_STATUS_IS_OK(status
)) {
907 d_printf("%s listing %s\n",
908 nt_errstr(status
), targetpath
);
911 TALLOC_FREE(targetpath
);
913 d_printf("do_list: [%s] %s\n", mask
, nt_errstr(status
));
919 reset_do_list_queue();
923 /****************************************************************************
924 Get a directory listing.
925 ****************************************************************************/
927 static int cmd_dir(void)
929 TALLOC_CTX
*ctx
= talloc_tos();
930 uint16_t attribute
= FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
937 mask
= talloc_strdup(ctx
, client_get_cur_dir());
942 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
944 if (*buf
== CLI_DIRSEP_CHAR
) {
945 mask
= talloc_strdup(ctx
, buf
);
947 mask
= talloc_asprintf_append(mask
, "%s", buf
);
950 mask
= talloc_asprintf_append(mask
, "*");
957 /* cwd is only used if showacls is on */
958 client_set_cwd(client_get_cur_dir());
961 status
= do_list(mask
, attribute
, display_finfo
, recurse
, true);
962 if (!NT_STATUS_IS_OK(status
)) {
968 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total
));
973 /****************************************************************************
974 Get a directory listing.
975 ****************************************************************************/
977 static int cmd_du(void)
979 TALLOC_CTX
*ctx
= talloc_tos();
980 uint16_t attribute
= FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
987 mask
= talloc_strdup(ctx
, client_get_cur_dir());
991 if ((mask
[0] != '\0') && (mask
[strlen(mask
)-1]!=CLI_DIRSEP_CHAR
)) {
992 mask
= talloc_asprintf_append(mask
, "%s", CLI_DIRSEP_STR
);
998 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1000 if (*buf
== CLI_DIRSEP_CHAR
) {
1001 mask
= talloc_strdup(ctx
, buf
);
1003 mask
= talloc_asprintf_append(mask
, "%s", buf
);
1006 mask
= talloc_strdup(ctx
, "*");
1009 status
= do_list(mask
, attribute
, do_du
, recurse
, true);
1010 if (!NT_STATUS_IS_OK(status
)) {
1016 d_printf("Total number of bytes: %.0f\n", dir_total
);
1021 static int cmd_echo(void)
1023 TALLOC_CTX
*ctx
= talloc_tos();
1028 if (!next_token_talloc(ctx
, &cmd_ptr
, &num
, NULL
)
1029 || !next_token_talloc(ctx
, &cmd_ptr
, &data
, NULL
)) {
1030 d_printf("echo <num> <data>\n");
1034 status
= cli_echo(cli
, atoi(num
), data_blob_const(data
, strlen(data
)));
1036 if (!NT_STATUS_IS_OK(status
)) {
1037 d_printf("echo failed: %s\n", nt_errstr(status
));
1044 /****************************************************************************
1045 Get a file from rname to lname
1046 ****************************************************************************/
1048 static NTSTATUS
writefile_sink(char *buf
, size_t n
, void *priv
)
1050 int *pfd
= (int *)priv
;
1051 if (writefile(*pfd
, buf
, n
) == -1) {
1052 return map_nt_error_from_unix(errno
);
1054 return NT_STATUS_OK
;
1057 static int do_get(const char *rname
, const char *lname_in
, bool reget
)
1059 TALLOC_CTX
*ctx
= talloc_tos();
1062 bool newhandle
= false;
1063 struct timespec tp_start
;
1069 struct cli_state
*targetcli
= NULL
;
1070 char *targetname
= NULL
;
1074 lname
= talloc_strdup(ctx
, lname_in
);
1080 if (!strlower_m(lname
)) {
1081 d_printf("strlower_m %s failed\n", lname
);
1086 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
1087 cli
, rname
, &targetcli
, &targetname
);
1088 if (!NT_STATUS_IS_OK(status
)) {
1089 d_printf("Failed to open %s: %s\n", rname
, nt_errstr(status
));
1093 clock_gettime_mono(&tp_start
);
1095 status
= cli_open(targetcli
, targetname
, O_RDONLY
, DENY_NONE
, &fnum
);
1096 if (!NT_STATUS_IS_OK(status
)) {
1097 d_printf("%s opening remote file %s\n", nt_errstr(status
),
1102 if(!strcmp(lname
,"-")) {
1103 handle
= fileno(stdout
);
1106 handle
= open(lname
, O_WRONLY
|O_CREAT
, 0644);
1108 start
= lseek(handle
, 0, SEEK_END
);
1110 d_printf("Error seeking local file\n");
1115 handle
= open(lname
, O_WRONLY
|O_CREAT
|O_TRUNC
, 0644);
1120 d_printf("Error opening local file %s\n",lname
);
1125 status
= cli_qfileinfo_basic(targetcli
, fnum
, &attr
, &size
, NULL
, NULL
,
1127 if (!NT_STATUS_IS_OK(status
)) {
1128 status
= cli_getattrE(targetcli
, fnum
, &attr
, &size
, NULL
, NULL
,
1130 if(!NT_STATUS_IS_OK(status
)) {
1131 d_printf("getattrib: %s\n", nt_errstr(status
));
1136 DEBUG(1,("getting file %s of size %.0f as %s ",
1137 rname
, (double)size
, lname
));
1139 status
= cli_pull(targetcli
, fnum
, start
, size
, io_bufsize
,
1140 writefile_sink
, (void *)&handle
, &nread
);
1141 if (!NT_STATUS_IS_OK(status
)) {
1142 d_fprintf(stderr
, "parallel_read returned %s\n",
1144 cli_close(targetcli
, fnum
);
1148 status
= cli_close(targetcli
, fnum
);
1149 if (!NT_STATUS_IS_OK(status
)) {
1150 d_printf("Error %s closing remote file\n", nt_errstr(status
));
1158 if (archive_level
>= 2 && (attr
& FILE_ATTRIBUTE_ARCHIVE
)) {
1159 cli_setatr(cli
, rname
, attr
& ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE
, 0);
1163 struct timespec tp_end
;
1166 clock_gettime_mono(&tp_end
);
1167 this_time
= nsec_time_diff(&tp_end
,&tp_start
)/1000000;
1168 get_total_time_ms
+= this_time
;
1169 get_total_size
+= nread
;
1171 DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
1172 nread
/ (1.024*this_time
+ 1.0e-4),
1173 get_total_size
/ (1.024*get_total_time_ms
)));
1176 TALLOC_FREE(targetname
);
1180 /****************************************************************************
1182 ****************************************************************************/
1184 static int cmd_get(void)
1186 TALLOC_CTX
*ctx
= talloc_tos();
1191 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1196 if (!next_token_talloc(ctx
, &cmd_ptr
,&fname
,NULL
)) {
1197 d_printf("get <filename> [localname]\n");
1200 rname
= talloc_asprintf_append(rname
, "%s", fname
);
1204 rname
= clean_name(ctx
, rname
);
1209 next_token_talloc(ctx
, &cmd_ptr
,&lname
,NULL
);
1214 return do_get(rname
, lname
, false);
1217 /****************************************************************************
1218 Do an mget operation on one file.
1219 ****************************************************************************/
1221 static NTSTATUS
do_mget(struct cli_state
*cli_state
, struct file_info
*finfo
,
1224 TALLOC_CTX
*ctx
= talloc_tos();
1225 NTSTATUS status
= NT_STATUS_OK
;
1228 char *saved_curdir
= NULL
;
1229 char *mget_mask
= NULL
;
1230 char *new_cd
= NULL
;
1233 return NT_STATUS_OK
;
1236 if (strequal(finfo
->name
,".") || strequal(finfo
->name
,".."))
1237 return NT_STATUS_OK
;
1240 d_printf("mget aborted\n");
1241 return NT_STATUS_UNSUCCESSFUL
;
1244 if (finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
1245 if (asprintf(&quest
,
1246 "Get directory %s? ",finfo
->name
) < 0) {
1247 return NT_STATUS_NO_MEMORY
;
1250 if (asprintf(&quest
,
1251 "Get file %s? ",finfo
->name
) < 0) {
1252 return NT_STATUS_NO_MEMORY
;
1256 if (prompt
&& !yesno(quest
)) {
1258 return NT_STATUS_OK
;
1262 if (!(finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
)) {
1263 rname
= talloc_asprintf(ctx
,
1265 client_get_cur_dir(),
1268 return NT_STATUS_NO_MEMORY
;
1270 do_get(rname
, finfo
->name
, false);
1272 return NT_STATUS_OK
;
1275 /* handle directories */
1276 saved_curdir
= talloc_strdup(ctx
, client_get_cur_dir());
1277 if (!saved_curdir
) {
1278 return NT_STATUS_NO_MEMORY
;
1281 new_cd
= talloc_asprintf(ctx
,
1283 client_get_cur_dir(),
1287 return NT_STATUS_NO_MEMORY
;
1289 client_set_cur_dir(new_cd
);
1291 string_replace(finfo
->name
,'\\','/');
1293 if (!strlower_m(finfo
->name
)) {
1294 return NT_STATUS_INVALID_PARAMETER
;
1298 if (!directory_exist(finfo
->name
) &&
1299 mkdir(finfo
->name
,0777) != 0) {
1300 d_printf("failed to create directory %s\n",finfo
->name
);
1301 client_set_cur_dir(saved_curdir
);
1302 return map_nt_error_from_unix(errno
);
1305 if (chdir(finfo
->name
) != 0) {
1306 d_printf("failed to chdir to directory %s\n",finfo
->name
);
1307 client_set_cur_dir(saved_curdir
);
1308 return map_nt_error_from_unix(errno
);
1311 mget_mask
= talloc_asprintf(ctx
,
1313 client_get_cur_dir());
1316 return NT_STATUS_NO_MEMORY
;
1319 status
= do_list(mget_mask
,
1320 (FILE_ATTRIBUTE_SYSTEM
1321 | FILE_ATTRIBUTE_HIDDEN
1322 | FILE_ATTRIBUTE_DIRECTORY
),
1323 do_mget
, false, true);
1324 if (!NT_STATUS_IS_OK(status
)
1325 && !NT_STATUS_EQUAL(status
, NT_STATUS_ACCESS_DENIED
)) {
1327 * Ignore access denied errors to ensure all permitted files are
1333 if (chdir("..") == -1) {
1334 d_printf("do_mget: failed to chdir to .. (error %s)\n",
1336 return map_nt_error_from_unix(errno
);
1338 client_set_cur_dir(saved_curdir
);
1339 TALLOC_FREE(mget_mask
);
1340 TALLOC_FREE(saved_curdir
);
1341 TALLOC_FREE(new_cd
);
1342 return NT_STATUS_OK
;
1345 /****************************************************************************
1346 View the file using the pager.
1347 ****************************************************************************/
1349 static int cmd_more(void)
1351 TALLOC_CTX
*ctx
= talloc_tos();
1355 char *pager_cmd
= NULL
;
1361 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1366 lname
= talloc_asprintf(ctx
, "%s/smbmore.XXXXXX",tmpdir());
1370 mask
= umask(S_IRWXO
| S_IRWXG
);
1371 fd
= mkstemp(lname
);
1374 d_printf("failed to create temporary file for more\n");
1379 if (!next_token_talloc(ctx
, &cmd_ptr
,&fname
,NULL
)) {
1380 d_printf("more <filename>\n");
1384 rname
= talloc_asprintf_append(rname
, "%s", fname
);
1388 rname
= clean_name(ctx
,rname
);
1393 rc
= do_get(rname
, lname
, false);
1395 pager
=getenv("PAGER");
1397 pager_cmd
= talloc_asprintf(ctx
,
1399 (pager
? pager
:PAGER
),
1404 if (system(pager_cmd
) == -1) {
1405 d_printf("system command '%s' returned -1\n",
1413 /****************************************************************************
1415 ****************************************************************************/
1417 static int cmd_mget(void)
1419 TALLOC_CTX
*ctx
= talloc_tos();
1420 uint16_t attribute
= FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
1421 char *mget_mask
= NULL
;
1423 NTSTATUS status
= NT_STATUS_OK
;
1426 attribute
|= FILE_ATTRIBUTE_DIRECTORY
;
1431 while (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1433 mget_mask
= talloc_strdup(ctx
, client_get_cur_dir());
1437 if (*buf
== CLI_DIRSEP_CHAR
) {
1438 mget_mask
= talloc_strdup(ctx
, buf
);
1440 mget_mask
= talloc_asprintf_append(mget_mask
,
1446 status
= do_list(mget_mask
, attribute
, do_mget
, false, true);
1447 if (!NT_STATUS_IS_OK(status
)) {
1452 if (mget_mask
== NULL
) {
1453 d_printf("nothing to mget\n");
1458 mget_mask
= talloc_asprintf(ctx
,
1460 client_get_cur_dir());
1464 status
= do_list(mget_mask
, attribute
, do_mget
, false, true);
1465 if (!NT_STATUS_IS_OK(status
)) {
1473 /****************************************************************************
1474 Make a directory of name "name".
1475 ****************************************************************************/
1477 static bool do_mkdir(const char *name
)
1479 TALLOC_CTX
*ctx
= talloc_tos();
1480 struct cli_state
*targetcli
;
1481 char *targetname
= NULL
;
1484 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
1485 cli
, name
, &targetcli
, &targetname
);
1486 if (!NT_STATUS_IS_OK(status
)) {
1487 d_printf("mkdir %s: %s\n", name
, nt_errstr(status
));
1491 status
= cli_mkdir(targetcli
, targetname
);
1492 if (!NT_STATUS_IS_OK(status
)) {
1493 d_printf("%s making remote directory %s\n",
1494 nt_errstr(status
),name
);
1501 /****************************************************************************
1502 Show 8.3 name of a file.
1503 ****************************************************************************/
1505 static bool do_altname(const char *name
)
1510 status
= cli_qpathinfo_alt_name(cli
, name
, altname
);
1511 if (!NT_STATUS_IS_OK(status
)) {
1512 d_printf("%s getting alt name for %s\n",
1513 nt_errstr(status
),name
);
1516 d_printf("%s\n", altname
);
1521 /****************************************************************************
1523 ****************************************************************************/
1525 static int cmd_quit(void)
1528 popt_free_cmdline_auth_info();
1534 /****************************************************************************
1536 ****************************************************************************/
1538 static int cmd_mkdir(void)
1540 TALLOC_CTX
*ctx
= talloc_tos();
1545 mask
= talloc_strdup(ctx
, client_get_cur_dir());
1550 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1552 d_printf("mkdir <dirname>\n");
1556 mask
= talloc_asprintf_append(mask
, "%s", buf
);
1564 struct cli_state
*targetcli
;
1565 char *targetname
= NULL
;
1569 ddir2
= talloc_strdup(ctx
, "");
1574 status
= cli_resolve_path(ctx
, "",
1575 popt_get_cmdline_auth_info(), cli
, mask
,
1576 &targetcli
, &targetname
);
1577 if (!NT_STATUS_IS_OK(status
)) {
1581 ddir
= talloc_strdup(ctx
, targetname
);
1585 trim_char(ddir
,'.','\0');
1586 p
= strtok_r(ddir
, "/\\", &saveptr
);
1588 ddir2
= talloc_asprintf_append(ddir2
, "%s", p
);
1592 if (!NT_STATUS_IS_OK(cli_chkpath(targetcli
, ddir2
))) {
1595 ddir2
= talloc_asprintf_append(ddir2
, "%s", CLI_DIRSEP_STR
);
1599 p
= strtok_r(NULL
, "/\\", &saveptr
);
1608 /****************************************************************************
1610 ****************************************************************************/
1612 static int cmd_altname(void)
1614 TALLOC_CTX
*ctx
= talloc_tos();
1618 name
= talloc_strdup(ctx
, client_get_cur_dir());
1623 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
1624 d_printf("altname <file>\n");
1627 name
= talloc_asprintf_append(name
, "%s", buf
);
1635 static char *attr_str(TALLOC_CTX
*mem_ctx
, uint16_t mode
)
1637 char *attrs
= talloc_zero_array(mem_ctx
, char, 17);
1640 if (!(mode
& FILE_ATTRIBUTE_NORMAL
)) {
1641 if (mode
& FILE_ATTRIBUTE_ENCRYPTED
) {
1644 if (mode
& FILE_ATTRIBUTE_NONINDEXED
) {
1647 if (mode
& FILE_ATTRIBUTE_OFFLINE
) {
1650 if (mode
& FILE_ATTRIBUTE_COMPRESSED
) {
1653 if (mode
& FILE_ATTRIBUTE_REPARSE_POINT
) {
1656 if (mode
& FILE_ATTRIBUTE_SPARSE
) {
1659 if (mode
& FILE_ATTRIBUTE_TEMPORARY
) {
1662 if (mode
& FILE_ATTRIBUTE_NORMAL
) {
1665 if (mode
& FILE_ATTRIBUTE_READONLY
) {
1668 if (mode
& FILE_ATTRIBUTE_HIDDEN
) {
1671 if (mode
& FILE_ATTRIBUTE_SYSTEM
) {
1674 if (mode
& FILE_ATTRIBUTE_DIRECTORY
) {
1677 if (mode
& FILE_ATTRIBUTE_ARCHIVE
) {
1684 /****************************************************************************
1685 Show all info we can get
1686 ****************************************************************************/
1688 static int do_allinfo(const char *name
)
1691 struct timespec b_time
, a_time
, m_time
, c_time
;
1696 unsigned int num_streams
;
1697 struct stream_struct
*streams
;
1699 char **snapshots
= NULL
;
1703 status
= cli_qpathinfo_alt_name(cli
, name
, altname
);
1704 if (!NT_STATUS_IS_OK(status
)) {
1705 d_printf("%s getting alt name for %s\n", nt_errstr(status
),
1708 * Ignore not supported or not implemented, it does not
1709 * hurt if we can't list alternate names.
1711 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_SUPPORTED
) ||
1712 NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)) {
1718 d_printf("altname: %s\n", altname
);
1720 status
= cli_qpathinfo3(cli
, name
, &b_time
, &a_time
, &m_time
, &c_time
,
1721 &size
, &mode
, NULL
);
1722 if (!NT_STATUS_IS_OK(status
)) {
1723 d_printf("%s getting pathinfo for %s\n", nt_errstr(status
),
1728 tmp
= unix_timespec_to_nt_time(b_time
);
1729 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1731 tmp
= unix_timespec_to_nt_time(a_time
);
1732 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1734 tmp
= unix_timespec_to_nt_time(m_time
);
1735 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1737 tmp
= unix_timespec_to_nt_time(c_time
);
1738 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1740 d_printf("attributes: %s (%x)\n", attr_str(talloc_tos(), mode
), mode
);
1742 status
= cli_qpathinfo_streams(cli
, name
, talloc_tos(), &num_streams
,
1744 if (!NT_STATUS_IS_OK(status
)) {
1745 d_printf("%s getting streams for %s\n", nt_errstr(status
),
1750 for (i
=0; i
<num_streams
; i
++) {
1751 d_printf("stream: [%s], %lld bytes\n", streams
[i
].name
,
1752 (unsigned long long)streams
[i
].size
);
1755 if (mode
& FILE_ATTRIBUTE_REPARSE_POINT
) {
1756 char *subst
, *print
;
1759 status
= cli_readlink(cli
, name
, talloc_tos(), &subst
, &print
,
1761 if (!NT_STATUS_IS_OK(status
)) {
1762 d_fprintf(stderr
, "cli_readlink returned %s\n",
1765 d_printf("symlink: subst=[%s], print=[%s], flags=%x\n",
1766 subst
, print
, flags
);
1772 status
= cli_ntcreate(cli
, name
, 0,
1773 SEC_FILE_READ_DATA
| SEC_FILE_READ_ATTRIBUTE
|
1774 SEC_STD_SYNCHRONIZE
, 0,
1775 FILE_SHARE_READ
|FILE_SHARE_WRITE
1777 FILE_OPEN
, 0x0, 0x0, &fnum
, NULL
);
1778 if (!NT_STATUS_IS_OK(status
)) {
1780 * Ignore failure, it does not hurt if we can't list
1786 * In order to get shadow copy data over SMB1 we
1787 * must call twice, once with 'get_names = false'
1788 * to get the size, then again with 'get_names = true'
1789 * to get the data or a Windows server fails to return
1790 * valid info. Samba doesn't have this bug. JRA.
1793 status
= cli_shadow_copy_data(talloc_tos(), cli
, fnum
,
1794 false, &snapshots
, &num_snapshots
);
1795 if (!NT_STATUS_IS_OK(status
)) {
1796 cli_close(cli
, fnum
);
1799 status
= cli_shadow_copy_data(talloc_tos(), cli
, fnum
,
1800 true, &snapshots
, &num_snapshots
);
1801 if (!NT_STATUS_IS_OK(status
)) {
1802 cli_close(cli
, fnum
);
1806 for (i
=0; i
<num_snapshots
; i
++) {
1809 d_printf("%s\n", snapshots
[i
]);
1810 snap_name
= talloc_asprintf(talloc_tos(), "%s%s",
1811 snapshots
[i
], name
);
1812 status
= cli_qpathinfo3(cli
, snap_name
, &b_time
, &a_time
,
1813 &m_time
, &c_time
, &size
,
1815 if (!NT_STATUS_IS_OK(status
)) {
1816 d_fprintf(stderr
, "pathinfo(%s) failed: %s\n",
1817 snap_name
, nt_errstr(status
));
1818 TALLOC_FREE(snap_name
);
1821 tmp
= unix_timespec_to_nt_time(b_time
);
1822 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1823 tmp
= unix_timespec_to_nt_time(a_time
);
1824 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1825 tmp
=unix_timespec_to_nt_time(m_time
);
1826 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1827 tmp
= unix_timespec_to_nt_time(c_time
);
1828 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1829 d_printf("size: %d\n", (int)size
);
1832 TALLOC_FREE(snapshots
);
1833 cli_close(cli
, fnum
);
1838 /****************************************************************************
1839 Show all info we can get
1840 ****************************************************************************/
1842 static int cmd_allinfo(void)
1844 TALLOC_CTX
*ctx
= talloc_tos();
1848 name
= talloc_strdup(ctx
, client_get_cur_dir());
1853 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
1854 d_printf("allinfo <file>\n");
1857 name
= talloc_asprintf_append(name
, "%s", buf
);
1867 /****************************************************************************
1869 ****************************************************************************/
1871 static int do_put(const char *rname
, const char *lname
, bool reput
)
1873 TALLOC_CTX
*ctx
= talloc_tos();
1878 struct timespec tp_start
;
1879 struct cli_state
*targetcli
;
1880 char *targetname
= NULL
;
1881 struct push_state state
;
1884 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
1885 cli
, rname
, &targetcli
, &targetname
);
1886 if (!NT_STATUS_IS_OK(status
)) {
1887 d_printf("Failed to open %s: %s\n", rname
, nt_errstr(status
));
1891 clock_gettime_mono(&tp_start
);
1894 status
= cli_open(targetcli
, targetname
, O_RDWR
|O_CREAT
, DENY_NONE
, &fnum
);
1895 if (NT_STATUS_IS_OK(status
)) {
1896 if (!NT_STATUS_IS_OK(status
= cli_qfileinfo_basic(
1897 targetcli
, fnum
, NULL
,
1899 NULL
, NULL
, NULL
)) &&
1900 !NT_STATUS_IS_OK(status
= cli_getattrE(
1901 targetcli
, fnum
, NULL
,
1904 d_printf("getattrib: %s\n", nt_errstr(status
));
1909 status
= cli_open(targetcli
, targetname
, O_RDWR
|O_CREAT
|O_TRUNC
, DENY_NONE
, &fnum
);
1912 if (!NT_STATUS_IS_OK(status
)) {
1913 d_printf("%s opening remote file %s\n", nt_errstr(status
),
1918 /* allow files to be piped into smbclient
1921 Note that in this case this function will exit(0) rather
1923 if (!strcmp(lname
, "-")) {
1925 /* size of file is not known */
1927 f
= fopen(lname
, "r");
1929 if (fseek(f
, start
, SEEK_SET
) == -1) {
1930 d_printf("Error seeking local file\n");
1938 d_printf("Error opening local file %s\n",lname
);
1942 DEBUG(1,("putting file %s as %s ",lname
,
1945 setvbuf(f
, NULL
, _IOFBF
, io_bufsize
);
1950 status
= cli_push(targetcli
, fnum
, 0, 0, io_bufsize
, push_source
,
1952 if (!NT_STATUS_IS_OK(status
)) {
1953 d_fprintf(stderr
, "cli_push returned %s\n", nt_errstr(status
));
1957 status
= cli_close(targetcli
, fnum
);
1958 if (!NT_STATUS_IS_OK(status
)) {
1959 d_printf("%s closing remote file %s\n", nt_errstr(status
),
1972 struct timespec tp_end
;
1975 clock_gettime_mono(&tp_end
);
1976 this_time
= nsec_time_diff(&tp_end
,&tp_start
)/1000000;
1977 put_total_time_ms
+= this_time
;
1978 put_total_size
+= state
.nread
;
1980 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1981 state
.nread
/ (1.024*this_time
+ 1.0e-4),
1982 put_total_size
/ (1.024*put_total_time_ms
)));
1987 popt_free_cmdline_auth_info();
1994 /****************************************************************************
1996 ****************************************************************************/
1998 static int cmd_put(void)
2000 TALLOC_CTX
*ctx
= talloc_tos();
2005 rname
= talloc_strdup(ctx
, client_get_cur_dir());
2010 if (!next_token_talloc(ctx
, &cmd_ptr
,&lname
,NULL
)) {
2011 d_printf("put <filename>\n");
2015 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2016 rname
= talloc_asprintf_append(rname
, "%s", buf
);
2018 rname
= talloc_asprintf_append(rname
, "%s", lname
);
2024 rname
= clean_name(ctx
, rname
);
2031 /* allow '-' to represent stdin
2032 jdblair, 24.jun.98 */
2033 if (!file_exist_stat(lname
, &st
, false) &&
2034 (strcmp(lname
,"-"))) {
2035 d_printf("%s does not exist\n",lname
);
2040 return do_put(rname
, lname
, false);
2043 /*************************************
2044 File list structure.
2045 *************************************/
2047 static struct file_list
{
2048 struct file_list
*prev
, *next
;
2053 /****************************************************************************
2054 Free a file_list structure.
2055 ****************************************************************************/
2057 static void free_file_list (struct file_list
*l_head
)
2059 struct file_list
*list
, *next
;
2061 for (list
= l_head
; list
; list
= next
) {
2063 DLIST_REMOVE(l_head
, list
);
2064 SAFE_FREE(list
->file_path
);
2069 /****************************************************************************
2070 Seek in a directory/file list until you get something that doesn't start with
2072 ****************************************************************************/
2074 static bool seek_list(struct file_list
*list
, char *name
)
2077 trim_string(list
->file_path
,"./","\n");
2078 if (strncmp(list
->file_path
, name
, strlen(name
)) != 0) {
2087 /****************************************************************************
2088 Set the file selection mask.
2089 ****************************************************************************/
2091 static int cmd_select(void)
2093 TALLOC_CTX
*ctx
= talloc_tos();
2094 char *new_fs
= NULL
;
2095 next_token_talloc(ctx
, &cmd_ptr
,&new_fs
,NULL
)
2098 client_set_fileselection(new_fs
);
2100 client_set_fileselection("");
2105 /****************************************************************************
2106 Recursive file matching function act as find
2107 match must be always set to true when calling this function
2108 ****************************************************************************/
2110 static int file_find(struct file_list
**list
, const char *directory
,
2111 const char *expression
, bool match
)
2114 struct file_list
*entry
;
2115 struct stat statbuf
;
2121 dir
= opendir(directory
);
2125 while ((dname
= readdirname(dir
))) {
2126 if (!strcmp("..", dname
))
2128 if (!strcmp(".", dname
))
2131 if (asprintf(&path
, "%s/%s", directory
, dname
) <= 0) {
2136 if (!match
|| !gen_fnmatch(expression
, dname
)) {
2138 ret
= stat(path
, &statbuf
);
2140 if (S_ISDIR(statbuf
.st_mode
)) {
2142 ret
= file_find(list
, path
, expression
, false);
2145 d_printf("file_find: cannot stat file %s\n", path
);
2154 entry
= SMB_MALLOC_P(struct file_list
);
2156 d_printf("Out of memory in file_find\n");
2160 entry
->file_path
= path
;
2161 entry
->isdir
= isdir
;
2162 DLIST_ADD(*list
, entry
);
2172 /****************************************************************************
2174 ****************************************************************************/
2176 static int cmd_mput(void)
2178 TALLOC_CTX
*ctx
= talloc_tos();
2181 while (next_token_talloc(ctx
, &cmd_ptr
,&p
,NULL
)) {
2183 struct file_list
*temp_list
;
2184 char *quest
, *lname
, *rname
;
2188 ret
= file_find(&file_list
, ".", p
, true);
2190 free_file_list(file_list
);
2198 for (temp_list
= file_list
; temp_list
;
2199 temp_list
= temp_list
->next
) {
2202 if (asprintf(&lname
, "%s/", temp_list
->file_path
) <= 0) {
2205 trim_string(lname
, "./", "/");
2207 /* check if it's a directory */
2208 if (temp_list
->isdir
) {
2209 /* if (!recurse) continue; */
2212 if (asprintf(&quest
, "Put directory %s? ", lname
) < 0) {
2215 if (prompt
&& !yesno(quest
)) { /* No */
2216 /* Skip the directory */
2217 lname
[strlen(lname
)-1] = '/';
2218 if (!seek_list(temp_list
, lname
))
2222 if(asprintf(&rname
, "%s%s", client_get_cur_dir(), lname
) < 0) {
2225 normalize_name(rname
);
2226 if (!NT_STATUS_IS_OK(cli_chkpath(cli
, rname
)) &&
2228 DEBUG (0, ("Unable to make dir, skipping..."));
2229 /* Skip the directory */
2230 lname
[strlen(lname
)-1] = '/';
2231 if (!seek_list(temp_list
, lname
)) {
2239 if (asprintf(&quest
,"Put file %s? ", lname
) < 0) {
2242 if (prompt
&& !yesno(quest
)) {
2249 if (asprintf(&rname
, "%s%s", client_get_cur_dir(), lname
) < 0) {
2254 normalize_name(rname
);
2256 do_put(rname
, lname
, false);
2258 free_file_list(file_list
);
2267 /****************************************************************************
2269 ****************************************************************************/
2271 static int do_cancel(int job
)
2273 if (cli_printjob_del(cli
, job
)) {
2274 d_printf("Job %d cancelled\n",job
);
2277 NTSTATUS status
= cli_nt_error(cli
);
2278 d_printf("Error cancelling job %d : %s\n",
2279 job
, nt_errstr(status
));
2284 /****************************************************************************
2286 ****************************************************************************/
2288 static int cmd_cancel(void)
2290 TALLOC_CTX
*ctx
= talloc_tos();
2294 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
,NULL
)) {
2295 d_printf("cancel <jobid> ...\n");
2301 } while (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
));
2306 /****************************************************************************
2308 ****************************************************************************/
2310 static int cmd_print(void)
2312 TALLOC_CTX
*ctx
= talloc_tos();
2317 if (!next_token_talloc(ctx
, &cmd_ptr
, &lname
,NULL
)) {
2318 d_printf("print <filename>\n");
2322 rname
= talloc_strdup(ctx
, lname
);
2326 p
= strrchr_m(rname
,'/');
2328 rname
= talloc_asprintf(ctx
,
2333 if (strequal(lname
,"-")) {
2334 rname
= talloc_asprintf(ctx
,
2342 return do_put(rname
, lname
, false);
2345 /****************************************************************************
2346 Show a print queue entry.
2347 ****************************************************************************/
2349 static void queue_fn(struct print_job_info
*p
)
2351 d_printf("%-6d %-9d %s\n", (int)p
->id
, (int)p
->size
, p
->name
);
2354 /****************************************************************************
2356 ****************************************************************************/
2358 static int cmd_queue(void)
2360 cli_print_queue(cli
, queue_fn
);
2364 /****************************************************************************
2366 ****************************************************************************/
2368 static NTSTATUS
do_del(struct cli_state
*cli_state
, struct file_info
*finfo
,
2371 TALLOC_CTX
*ctx
= talloc_tos();
2375 mask
= talloc_asprintf(ctx
,
2381 return NT_STATUS_NO_MEMORY
;
2384 if (finfo
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
2386 return NT_STATUS_OK
;
2389 status
= cli_unlink(cli_state
, mask
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2390 if (!NT_STATUS_IS_OK(status
)) {
2391 d_printf("%s deleting remote file %s\n",
2392 nt_errstr(status
), mask
);
2398 /****************************************************************************
2400 ****************************************************************************/
2402 static int cmd_del(void)
2404 TALLOC_CTX
*ctx
= talloc_tos();
2407 NTSTATUS status
= NT_STATUS_OK
;
2408 uint16_t attribute
= FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
2411 attribute
|= FILE_ATTRIBUTE_DIRECTORY
;
2414 mask
= talloc_strdup(ctx
, client_get_cur_dir());
2418 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2419 d_printf("del <filename>\n");
2422 mask
= talloc_asprintf_append(mask
, "%s", buf
);
2427 status
= do_list(mask
,attribute
,do_del
,false,false);
2428 if (!NT_STATUS_IS_OK(status
)) {
2434 /****************************************************************************
2435 Wildcard delete some files.
2436 ****************************************************************************/
2438 static int cmd_wdel(void)
2440 TALLOC_CTX
*ctx
= talloc_tos();
2444 struct cli_state
*targetcli
;
2445 char *targetname
= NULL
;
2448 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2449 d_printf("wdel 0x<attrib> <wcard>\n");
2453 attribute
= (uint16_t)strtol(buf
, (char **)NULL
, 16);
2455 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2456 d_printf("wdel 0x<attrib> <wcard>\n");
2460 mask
= talloc_asprintf(ctx
, "%s%s",
2461 client_get_cur_dir(),
2467 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
2468 cli
, mask
, &targetcli
, &targetname
);
2469 if (!NT_STATUS_IS_OK(status
)) {
2470 d_printf("cmd_wdel %s: %s\n", mask
, nt_errstr(status
));
2474 status
= cli_unlink(targetcli
, targetname
, attribute
);
2475 if (!NT_STATUS_IS_OK(status
)) {
2476 d_printf("%s deleting remote files %s\n", nt_errstr(status
),
2482 /****************************************************************************
2483 ****************************************************************************/
2485 static int cmd_open(void)
2487 TALLOC_CTX
*ctx
= talloc_tos();
2490 char *targetname
= NULL
;
2491 struct cli_state
*targetcli
;
2492 uint16_t fnum
= (uint16_t)-1;
2495 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2496 d_printf("open <filename>\n");
2499 mask
= talloc_asprintf(ctx
,
2501 client_get_cur_dir(),
2507 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
2508 cli
, mask
, &targetcli
, &targetname
);
2509 if (!NT_STATUS_IS_OK(status
)) {
2510 d_printf("open %s: %s\n", mask
, nt_errstr(status
));
2514 status
= cli_ntcreate(targetcli
, targetname
, 0,
2515 FILE_READ_DATA
|FILE_WRITE_DATA
, 0,
2516 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
,
2517 0x0, 0x0, &fnum
, NULL
);
2518 if (!NT_STATUS_IS_OK(status
)) {
2519 status
= cli_ntcreate(targetcli
, targetname
, 0,
2521 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
,
2522 0x0, 0x0, &fnum
, NULL
);
2523 if (NT_STATUS_IS_OK(status
)) {
2524 d_printf("open file %s: for read/write fnum %d\n", targetname
, fnum
);
2526 d_printf("Failed to open file %s. %s\n",
2527 targetname
, nt_errstr(status
));
2530 d_printf("open file %s: for read/write fnum %d\n", targetname
, fnum
);
2535 static int cmd_posix_encrypt(void)
2537 TALLOC_CTX
*ctx
= talloc_tos();
2538 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
2539 char *domain
= NULL
;
2541 char *password
= NULL
;
2542 struct cli_credentials
*creds
= NULL
;
2543 struct cli_credentials
*lcreds
= NULL
;
2545 if (next_token_talloc(ctx
, &cmd_ptr
, &domain
, NULL
)) {
2547 if (!next_token_talloc(ctx
, &cmd_ptr
, &user
, NULL
)) {
2548 d_printf("posix_encrypt domain user password\n");
2552 if (!next_token_talloc(ctx
, &cmd_ptr
, &password
, NULL
)) {
2553 d_printf("posix_encrypt domain user password\n");
2557 lcreds
= cli_session_creds_init(ctx
,
2562 false, /* use_kerberos */
2563 false, /* fallback_after_kerberos */
2564 false, /* use_ccache */
2565 false); /* password_is_nt_hash */
2566 if (lcreds
== NULL
) {
2567 d_printf("cli_session_creds_init() failed.\n");
2572 bool auth_requested
= false;
2574 creds
= get_cmdline_auth_info_creds(
2575 popt_get_cmdline_auth_info());
2577 auth_requested
= cli_credentials_authentication_requested(creds
);
2578 if (!auth_requested
) {
2579 d_printf("posix_encrypt domain user password\n");
2584 status
= cli_smb1_setup_encryption(cli
, creds
);
2585 /* gensec currently references the creds so we can't free them here */
2586 talloc_unlink(ctx
, lcreds
);
2587 if (!NT_STATUS_IS_OK(status
)) {
2588 d_printf("posix_encrypt failed with error %s\n", nt_errstr(status
));
2590 d_printf("encryption on\n");
2597 /****************************************************************************
2598 ****************************************************************************/
2600 static int cmd_posix_open(void)
2602 TALLOC_CTX
*ctx
= talloc_tos();
2605 char *targetname
= NULL
;
2606 struct cli_state
*targetcli
;
2611 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2612 d_printf("posix_open <filename> 0<mode>\n");
2615 mask
= talloc_asprintf(ctx
,
2617 client_get_cur_dir(),
2623 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2624 d_printf("posix_open <filename> 0<mode>\n");
2627 mode
= (mode_t
)strtol(buf
, (char **)NULL
, 8);
2629 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
2630 cli
, mask
, &targetcli
, &targetname
);
2631 if (!NT_STATUS_IS_OK(status
)) {
2632 d_printf("posix_open %s: %s\n", mask
, nt_errstr(status
));
2636 status
= cli_posix_open(targetcli
, targetname
, O_CREAT
|O_RDWR
, mode
,
2638 if (!NT_STATUS_IS_OK(status
)) {
2639 status
= cli_posix_open(targetcli
, targetname
,
2640 O_CREAT
|O_RDONLY
, mode
, &fnum
);
2641 if (!NT_STATUS_IS_OK(status
)) {
2642 d_printf("Failed to open file %s. %s\n", targetname
,
2645 d_printf("posix_open file %s: for readonly fnum %d\n",
2649 d_printf("posix_open file %s: for read/write fnum %d\n",
2656 static int cmd_posix_mkdir(void)
2658 TALLOC_CTX
*ctx
= talloc_tos();
2661 char *targetname
= NULL
;
2662 struct cli_state
*targetcli
;
2666 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2667 d_printf("posix_mkdir <filename> 0<mode>\n");
2670 mask
= talloc_asprintf(ctx
,
2672 client_get_cur_dir(),
2678 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2679 d_printf("posix_mkdir <filename> 0<mode>\n");
2682 mode
= (mode_t
)strtol(buf
, (char **)NULL
, 8);
2684 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
2685 cli
, mask
, &targetcli
, &targetname
);
2686 if (!NT_STATUS_IS_OK(status
)) {
2687 d_printf("posix_mkdir %s: %s\n", mask
, nt_errstr(status
));
2691 status
= cli_posix_mkdir(targetcli
, targetname
, mode
);
2692 if (!NT_STATUS_IS_OK(status
)) {
2693 d_printf("Failed to open file %s. %s\n",
2694 targetname
, nt_errstr(status
));
2696 d_printf("posix_mkdir created directory %s\n", targetname
);
2701 static int cmd_posix_unlink(void)
2703 TALLOC_CTX
*ctx
= talloc_tos();
2706 char *targetname
= NULL
;
2707 struct cli_state
*targetcli
;
2710 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2711 d_printf("posix_unlink <filename>\n");
2714 mask
= talloc_asprintf(ctx
,
2716 client_get_cur_dir(),
2722 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
2723 cli
, mask
, &targetcli
, &targetname
);
2724 if (!NT_STATUS_IS_OK(status
)) {
2725 d_printf("posix_unlink %s: %s\n", mask
, nt_errstr(status
));
2729 status
= cli_posix_unlink(targetcli
, targetname
);
2730 if (!NT_STATUS_IS_OK(status
)) {
2731 d_printf("Failed to unlink file %s. %s\n",
2732 targetname
, nt_errstr(status
));
2734 d_printf("posix_unlink deleted file %s\n", targetname
);
2740 static int cmd_posix_rmdir(void)
2742 TALLOC_CTX
*ctx
= talloc_tos();
2745 char *targetname
= NULL
;
2746 struct cli_state
*targetcli
;
2749 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2750 d_printf("posix_rmdir <filename>\n");
2753 mask
= talloc_asprintf(ctx
,
2755 client_get_cur_dir(),
2761 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
2762 cli
, mask
, &targetcli
, &targetname
);
2763 if (!NT_STATUS_IS_OK(status
)) {
2764 d_printf("posix_rmdir %s: %s\n", mask
, nt_errstr(status
));
2768 status
= cli_posix_rmdir(targetcli
, targetname
);
2769 if (!NT_STATUS_IS_OK(status
)) {
2770 d_printf("Failed to unlink directory %s. %s\n",
2771 targetname
, nt_errstr(status
));
2773 d_printf("posix_rmdir deleted directory %s\n", targetname
);
2779 static int cmd_close(void)
2781 TALLOC_CTX
*ctx
= talloc_tos();
2786 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2787 d_printf("close <fnum>\n");
2792 /* We really should use the targetcli here.... */
2793 status
= cli_close(cli
, fnum
);
2794 if (!NT_STATUS_IS_OK(status
)) {
2795 d_printf("close %d: %s\n", fnum
, nt_errstr(status
));
2801 static int cmd_posix(void)
2803 TALLOC_CTX
*ctx
= talloc_tos();
2804 uint16_t major
, minor
;
2805 uint32_t caplow
, caphigh
;
2809 if (!SERVER_HAS_UNIX_CIFS(cli
)) {
2810 d_printf("Server doesn't support UNIX CIFS extensions.\n");
2814 status
= cli_unix_extensions_version(cli
, &major
, &minor
, &caplow
,
2816 if (!NT_STATUS_IS_OK(status
)) {
2817 d_printf("Can't get UNIX CIFS extensions version from "
2818 "server: %s\n", nt_errstr(status
));
2822 d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major
, (unsigned int)minor
);
2824 caps
= talloc_strdup(ctx
, "");
2828 if (caplow
& CIFS_UNIX_FCNTL_LOCKS_CAP
) {
2829 caps
= talloc_asprintf_append(caps
, "locks ");
2834 if (caplow
& CIFS_UNIX_POSIX_ACLS_CAP
) {
2835 caps
= talloc_asprintf_append(caps
, "acls ");
2840 if (caplow
& CIFS_UNIX_XATTTR_CAP
) {
2841 caps
= talloc_asprintf_append(caps
, "eas ");
2846 if (caplow
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2847 caps
= talloc_asprintf_append(caps
, "pathnames ");
2852 if (caplow
& CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
) {
2853 caps
= talloc_asprintf_append(caps
, "posix_path_operations ");
2858 if (caplow
& CIFS_UNIX_LARGE_READ_CAP
) {
2859 caps
= talloc_asprintf_append(caps
, "large_read ");
2864 if (caplow
& CIFS_UNIX_LARGE_WRITE_CAP
) {
2865 caps
= talloc_asprintf_append(caps
, "large_write ");
2870 if (caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
) {
2871 caps
= talloc_asprintf_append(caps
, "posix_encrypt ");
2876 if (caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
) {
2877 caps
= talloc_asprintf_append(caps
, "mandatory_posix_encrypt ");
2883 if (*caps
&& caps
[strlen(caps
)-1] == ' ') {
2884 caps
[strlen(caps
)-1] = '\0';
2887 d_printf("Server supports CIFS capabilities %s\n", caps
);
2889 status
= cli_set_unix_extensions_capabilities(cli
, major
, minor
,
2891 if (!NT_STATUS_IS_OK(status
)) {
2892 d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n",
2897 if (caplow
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2898 CLI_DIRSEP_CHAR
= '/';
2899 *CLI_DIRSEP_STR
= '/';
2900 client_set_cur_dir(CLI_DIRSEP_STR
);
2906 static int cmd_lock(void)
2908 TALLOC_CTX
*ctx
= talloc_tos();
2910 uint64_t start
, len
;
2911 enum brl_type lock_type
;
2915 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2916 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2921 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2922 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2926 if (*buf
== 'r' || *buf
== 'R') {
2927 lock_type
= READ_LOCK
;
2928 } else if (*buf
== 'w' || *buf
== 'W') {
2929 lock_type
= WRITE_LOCK
;
2931 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2935 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2936 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2940 start
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2942 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2943 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2947 len
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2949 status
= cli_posix_lock(cli
, fnum
, start
, len
, true, lock_type
);
2950 if (!NT_STATUS_IS_OK(status
)) {
2951 d_printf("lock failed %d: %s\n", fnum
, nt_errstr(status
));
2957 static int cmd_unlock(void)
2959 TALLOC_CTX
*ctx
= talloc_tos();
2961 uint64_t start
, len
;
2965 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2966 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2971 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2972 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2976 start
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2978 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2979 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2983 len
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2985 status
= cli_posix_unlock(cli
, fnum
, start
, len
);
2986 if (!NT_STATUS_IS_OK(status
)) {
2987 d_printf("unlock failed %d: %s\n", fnum
, nt_errstr(status
));
2993 static int cmd_posix_whoami(void)
2995 TALLOC_CTX
*ctx
= talloc_tos();
2996 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
2999 uint32_t num_gids
= 0;
3000 uint32_t num_sids
= 0;
3001 uint64_t *gids
= NULL
;
3002 struct dom_sid
*sids
= NULL
;
3006 status
= cli_posix_whoami(cli
,
3016 if (!NT_STATUS_IS_OK(status
)) {
3017 d_printf("posix_whoami failed with error %s\n", nt_errstr(status
));
3021 d_printf("GUEST:%s\n", guest
? "True" : "False");
3022 d_printf("UID:%" PRIu64
"\n", uid
);
3023 d_printf("GID:%" PRIu64
"\n", gid
);
3024 d_printf("NUM_GIDS:%" PRIu32
"\n", num_gids
);
3025 for (i
= 0; i
< num_gids
; i
++) {
3026 d_printf("GIDS[%" PRIu32
"]:%" PRIu64
"\n", i
, gids
[i
]);
3028 d_printf("NUM_SIDS:%" PRIu32
"\n", num_sids
);
3029 for (i
= 0; i
< num_sids
; i
++) {
3030 char *sid_str
= dom_sid_string(ctx
, &sids
[i
]);
3031 d_printf("SIDS[%" PRIu32
"]:%s\n", i
, sid_str
);
3032 TALLOC_FREE(sid_str
);
3038 /****************************************************************************
3040 ****************************************************************************/
3042 static int cmd_rmdir(void)
3044 TALLOC_CTX
*ctx
= talloc_tos();
3047 char *targetname
= NULL
;
3048 struct cli_state
*targetcli
;
3051 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
3052 d_printf("rmdir <dirname>\n");
3055 mask
= talloc_asprintf(ctx
,
3057 client_get_cur_dir(),
3063 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3064 cli
, mask
, &targetcli
, &targetname
);
3065 if (!NT_STATUS_IS_OK(status
)) {
3066 d_printf("rmdir %s: %s\n", mask
, nt_errstr(status
));
3070 status
= cli_rmdir(targetcli
, targetname
);
3071 if (!NT_STATUS_IS_OK(status
)) {
3072 d_printf("%s removing remote directory file %s\n",
3073 nt_errstr(status
), mask
);
3079 /****************************************************************************
3081 ****************************************************************************/
3083 static int cmd_link(void)
3085 TALLOC_CTX
*ctx
= talloc_tos();
3086 char *oldname
= NULL
;
3087 char *newname
= NULL
;
3090 char *targetname
= NULL
;
3091 struct cli_state
*targetcli
;
3094 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3095 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3096 d_printf("link <oldname> <newname>\n");
3099 oldname
= talloc_asprintf(ctx
,
3101 client_get_cur_dir(),
3106 newname
= talloc_asprintf(ctx
,
3108 client_get_cur_dir(),
3114 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3115 cli
, oldname
, &targetcli
, &targetname
);
3116 if (!NT_STATUS_IS_OK(status
)) {
3117 d_printf("link %s: %s\n", oldname
, nt_errstr(status
));
3121 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3122 d_printf("Server doesn't support UNIX CIFS calls.\n");
3126 status
= cli_posix_hardlink(targetcli
, targetname
, newname
);
3127 if (!NT_STATUS_IS_OK(status
)) {
3128 d_printf("%s linking files (%s -> %s)\n",
3129 nt_errstr(status
), newname
, oldname
);
3135 /****************************************************************************
3137 ****************************************************************************/
3139 static int cmd_readlink(void)
3141 TALLOC_CTX
*ctx
= talloc_tos();
3144 char *targetname
= NULL
;
3145 char linkname
[PATH_MAX
+1];
3146 struct cli_state
*targetcli
;
3149 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
3150 d_printf("readlink <name>\n");
3153 name
= talloc_asprintf(ctx
,
3155 client_get_cur_dir(),
3161 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3162 cli
, name
, &targetcli
, &targetname
);
3163 if (!NT_STATUS_IS_OK(status
)) {
3164 d_printf("readlink %s: %s\n", name
, nt_errstr(status
));
3168 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3169 d_printf("Server doesn't support UNIX CIFS calls.\n");
3173 status
= cli_posix_readlink(targetcli
, name
, linkname
, PATH_MAX
+1);
3174 if (!NT_STATUS_IS_OK(status
)) {
3175 d_printf("%s readlink on file %s\n",
3176 nt_errstr(status
), name
);
3180 d_printf("%s -> %s\n", name
, linkname
);
3186 /****************************************************************************
3188 ****************************************************************************/
3190 static int cmd_symlink(void)
3192 TALLOC_CTX
*ctx
= talloc_tos();
3193 char *oldname
= NULL
;
3194 char *newname
= NULL
;
3197 struct cli_state
*newcli
;
3200 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3201 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3202 d_printf("symlink <oldname> <newname>\n");
3205 /* Oldname (link target) must be an untouched blob. */
3208 if (SERVER_HAS_UNIX_CIFS(cli
)) {
3209 newname
= talloc_asprintf(ctx
, "%s%s", client_get_cur_dir(),
3214 /* New name must be present in share namespace. */
3215 status
= cli_resolve_path(ctx
, "",
3216 popt_get_cmdline_auth_info(), cli
, newname
,
3218 if (!NT_STATUS_IS_OK(status
)) {
3219 d_printf("link %s: %s\n", oldname
, nt_errstr(status
));
3222 status
= cli_posix_symlink(newcli
, oldname
, newname
);
3224 status
= cli_symlink(
3226 buf2
[0] == '\\' ? 0 : SYMLINK_FLAG_RELATIVE
);
3229 if (!NT_STATUS_IS_OK(status
)) {
3230 d_printf("%s symlinking files (%s -> %s)\n",
3231 nt_errstr(status
), oldname
, newname
);
3238 /****************************************************************************
3240 ****************************************************************************/
3242 static int cmd_chmod(void)
3244 TALLOC_CTX
*ctx
= talloc_tos();
3248 char *targetname
= NULL
;
3249 struct cli_state
*targetcli
;
3253 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3254 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3255 d_printf("chmod mode file\n");
3258 src
= talloc_asprintf(ctx
,
3260 client_get_cur_dir(),
3266 mode
= (mode_t
)strtol(buf
, NULL
, 8);
3268 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3269 cli
, src
, &targetcli
, &targetname
);
3270 if (!NT_STATUS_IS_OK(status
)) {
3271 d_printf("chmod %s: %s\n", src
, nt_errstr(status
));
3275 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3276 d_printf("Server doesn't support UNIX CIFS calls.\n");
3280 status
= cli_posix_chmod(targetcli
, targetname
, mode
);
3281 if (!NT_STATUS_IS_OK(status
)) {
3282 d_printf("%s chmod file %s 0%o\n",
3283 nt_errstr(status
), src
, (unsigned int)mode
);
3290 static const char *filetype_to_str(mode_t mode
)
3292 if (S_ISREG(mode
)) {
3293 return "regular file";
3294 } else if (S_ISDIR(mode
)) {
3298 if (S_ISCHR(mode
)) {
3299 return "character device";
3303 if (S_ISBLK(mode
)) {
3304 return "block device";
3308 if (S_ISFIFO(mode
)) {
3313 if (S_ISLNK(mode
)) {
3314 return "symbolic link";
3318 if (S_ISSOCK(mode
)) {
3325 static char rwx_to_str(mode_t m
, mode_t bt
, char ret
)
3334 static char *unix_mode_to_str(char *s
, mode_t m
)
3337 const char *str
= filetype_to_str(m
);
3353 *p
++ = str
[1] == 'y' ? 'l' : 's';
3360 *p
++ = rwx_to_str(m
, S_IRUSR
, 'r');
3361 *p
++ = rwx_to_str(m
, S_IWUSR
, 'w');
3362 *p
++ = rwx_to_str(m
, S_IXUSR
, 'x');
3363 *p
++ = rwx_to_str(m
, S_IRGRP
, 'r');
3364 *p
++ = rwx_to_str(m
, S_IWGRP
, 'w');
3365 *p
++ = rwx_to_str(m
, S_IXGRP
, 'x');
3366 *p
++ = rwx_to_str(m
, S_IROTH
, 'r');
3367 *p
++ = rwx_to_str(m
, S_IWOTH
, 'w');
3368 *p
++ = rwx_to_str(m
, S_IXOTH
, 'x');
3373 /****************************************************************************
3374 Utility function for UNIX getfacl.
3375 ****************************************************************************/
3377 static char *perms_to_string(fstring permstr
, unsigned char perms
)
3379 fstrcpy(permstr
, "---");
3380 if (perms
& SMB_POSIX_ACL_READ
) {
3383 if (perms
& SMB_POSIX_ACL_WRITE
) {
3386 if (perms
& SMB_POSIX_ACL_EXECUTE
) {
3392 /****************************************************************************
3394 ****************************************************************************/
3396 static int cmd_getfacl(void)
3398 TALLOC_CTX
*ctx
= talloc_tos();
3401 char *targetname
= NULL
;
3402 struct cli_state
*targetcli
;
3403 uint16_t major
, minor
;
3404 uint32_t caplow
, caphigh
;
3405 char *retbuf
= NULL
;
3407 SMB_STRUCT_STAT sbuf
;
3408 uint16_t num_file_acls
= 0;
3409 uint16_t num_dir_acls
= 0;
3413 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3414 d_printf("getfacl filename\n");
3417 src
= talloc_asprintf(ctx
,
3419 client_get_cur_dir(),
3425 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3426 cli
, src
, &targetcli
, &targetname
);
3427 if (!NT_STATUS_IS_OK(status
)) {
3428 d_printf("stat %s: %s\n", src
, nt_errstr(status
));
3432 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3433 d_printf("Server doesn't support UNIX CIFS calls.\n");
3437 status
= cli_unix_extensions_version(targetcli
, &major
, &minor
,
3439 if (!NT_STATUS_IS_OK(status
)) {
3440 d_printf("Can't get UNIX CIFS version from server: %s.\n",
3445 if (!(caplow
& CIFS_UNIX_POSIX_ACLS_CAP
)) {
3446 d_printf("This server supports UNIX extensions "
3447 "but doesn't support POSIX ACLs.\n");
3451 status
= cli_posix_stat(targetcli
, targetname
, &sbuf
);
3452 if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli
, targetname
, &sbuf
))) {
3453 d_printf("%s getfacl doing a stat on file %s\n",
3454 nt_errstr(status
), src
);
3458 status
= cli_posix_getacl(targetcli
, targetname
, ctx
, &rb_size
, &retbuf
);
3459 if (!NT_STATUS_IS_OK(status
)) {
3460 d_printf("%s getfacl file %s\n",
3461 nt_errstr(status
), src
);
3465 /* ToDo : Print out the ACL values. */
3466 if (rb_size
< 6 || SVAL(retbuf
,0) != SMB_POSIX_ACL_VERSION
) {
3467 d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
3468 src
, (unsigned int)CVAL(retbuf
,0) );
3472 num_file_acls
= SVAL(retbuf
,2);
3473 num_dir_acls
= SVAL(retbuf
,4);
3474 if (rb_size
!= SMB_POSIX_ACL_HEADER_SIZE
+ SMB_POSIX_ACL_ENTRY_SIZE
*(num_file_acls
+num_dir_acls
)) {
3475 d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
3477 (unsigned int)(SMB_POSIX_ACL_HEADER_SIZE
+ SMB_POSIX_ACL_ENTRY_SIZE
*(num_file_acls
+num_dir_acls
)),
3478 (unsigned int)rb_size
);
3482 d_printf("# file: %s\n", src
);
3483 d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf
.st_ex_uid
, (unsigned int)sbuf
.st_ex_gid
);
3485 if (num_file_acls
== 0 && num_dir_acls
== 0) {
3486 d_printf("No acls found.\n");
3489 for (i
= 0; i
< num_file_acls
; i
++) {
3492 unsigned char tagtype
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
));
3493 unsigned char perms
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+1);
3496 case SMB_POSIX_ACL_USER_OBJ
:
3499 case SMB_POSIX_ACL_USER
:
3500 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3501 d_printf("user:%u:", uorg
);
3503 case SMB_POSIX_ACL_GROUP_OBJ
:
3504 d_printf("group::");
3506 case SMB_POSIX_ACL_GROUP
:
3507 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3508 d_printf("group:%u:", uorg
);
3510 case SMB_POSIX_ACL_MASK
:
3513 case SMB_POSIX_ACL_OTHER
:
3514 d_printf("other::");
3517 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3518 src
, (unsigned int)tagtype
);
3523 d_printf("%s\n", perms_to_string(permstring
, perms
));
3526 for (i
= 0; i
< num_dir_acls
; i
++) {
3529 unsigned char tagtype
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
));
3530 unsigned char perms
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+1);
3533 case SMB_POSIX_ACL_USER_OBJ
:
3534 d_printf("default:user::");
3536 case SMB_POSIX_ACL_USER
:
3537 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3538 d_printf("default:user:%u:", uorg
);
3540 case SMB_POSIX_ACL_GROUP_OBJ
:
3541 d_printf("default:group::");
3543 case SMB_POSIX_ACL_GROUP
:
3544 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3545 d_printf("default:group:%u:", uorg
);
3547 case SMB_POSIX_ACL_MASK
:
3548 d_printf("default:mask::");
3550 case SMB_POSIX_ACL_OTHER
:
3551 d_printf("default:other::");
3554 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3555 src
, (unsigned int)tagtype
);
3560 d_printf("%s\n", perms_to_string(permstring
, perms
));
3566 /****************************************************************************
3567 Get the EA list of a file
3568 ****************************************************************************/
3570 static int cmd_geteas(void)
3572 TALLOC_CTX
*ctx
= talloc_tos();
3575 char *targetname
= NULL
;
3576 struct cli_state
*targetcli
;
3579 struct ea_struct
*eas
;
3581 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3582 d_printf("geteas filename\n");
3585 src
= talloc_asprintf(ctx
,
3587 client_get_cur_dir(),
3593 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3594 cli
, src
, &targetcli
, &targetname
);
3595 if (!NT_STATUS_IS_OK(status
)) {
3596 d_printf("stat %s: %s\n", src
, nt_errstr(status
));
3600 status
= cli_get_ea_list_path(targetcli
, targetname
, talloc_tos(),
3602 if (!NT_STATUS_IS_OK(status
)) {
3603 d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status
));
3607 for (i
=0; i
<num_eas
; i
++) {
3608 d_printf("%s (%d) =\n", eas
[i
].name
, (int)eas
[i
].flags
);
3609 dump_data_file(eas
[i
].value
.data
, eas
[i
].value
.length
, false,
3619 /****************************************************************************
3621 ****************************************************************************/
3623 static int cmd_setea(void)
3625 TALLOC_CTX
*ctx
= talloc_tos();
3628 char *eaname
= NULL
;
3629 char *eavalue
= NULL
;
3630 char *targetname
= NULL
;
3631 struct cli_state
*targetcli
;
3634 if (!next_token_talloc(ctx
, &cmd_ptr
, &name
, NULL
)
3635 || !next_token_talloc(ctx
, &cmd_ptr
, &eaname
, NULL
)) {
3636 d_printf("setea filename eaname value\n");
3639 if (!next_token_talloc(ctx
, &cmd_ptr
, &eavalue
, NULL
)) {
3640 eavalue
= talloc_strdup(ctx
, "");
3642 src
= talloc_asprintf(ctx
,
3644 client_get_cur_dir(),
3650 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3651 cli
, src
, &targetcli
, &targetname
);
3652 if (!NT_STATUS_IS_OK(status
)) {
3653 d_printf("stat %s: %s\n", src
, nt_errstr(status
));
3657 status
= cli_set_ea_path(targetcli
, targetname
, eaname
, eavalue
,
3659 if (!NT_STATUS_IS_OK(status
)) {
3660 d_printf("set_ea %s: %s\n", src
, nt_errstr(status
));
3667 /****************************************************************************
3669 ****************************************************************************/
3671 static int cmd_stat(void)
3673 TALLOC_CTX
*ctx
= talloc_tos();
3676 char *targetname
= NULL
;
3677 struct cli_state
*targetcli
;
3679 SMB_STRUCT_STAT sbuf
;
3684 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3685 d_printf("stat file\n");
3688 src
= talloc_asprintf(ctx
,
3690 client_get_cur_dir(),
3696 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3697 cli
, src
, &targetcli
, &targetname
);
3698 if (!NT_STATUS_IS_OK(status
)) {
3699 d_printf("stat %s: %s\n", src
, nt_errstr(status
));
3703 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3704 d_printf("Server doesn't support UNIX CIFS calls.\n");
3708 status
= cli_posix_stat(targetcli
, targetname
, &sbuf
);
3709 if (!NT_STATUS_IS_OK(status
)) {
3710 d_printf("%s stat file %s\n",
3711 nt_errstr(status
), src
);
3715 /* Print out the stat values. */
3716 d_printf("File: %s\n", src
);
3717 d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
3718 (double)sbuf
.st_ex_size
,
3719 (unsigned int)sbuf
.st_ex_blocks
,
3720 filetype_to_str(sbuf
.st_ex_mode
));
3722 #if defined(S_ISCHR) && defined(S_ISBLK)
3723 if (S_ISCHR(sbuf
.st_ex_mode
) || S_ISBLK(sbuf
.st_ex_mode
)) {
3724 d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
3725 (double)sbuf
.st_ex_ino
,
3726 (unsigned int)sbuf
.st_ex_nlink
,
3727 unix_dev_major(sbuf
.st_ex_rdev
),
3728 unix_dev_minor(sbuf
.st_ex_rdev
));
3731 d_printf("Inode: %.0f\tLinks: %u\n",
3732 (double)sbuf
.st_ex_ino
,
3733 (unsigned int)sbuf
.st_ex_nlink
);
3735 d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
3736 ((int)sbuf
.st_ex_mode
& 0777),
3737 unix_mode_to_str(mode_str
, sbuf
.st_ex_mode
),
3738 (unsigned int)sbuf
.st_ex_uid
,
3739 (unsigned int)sbuf
.st_ex_gid
);
3741 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_atime
);
3742 lt
= localtime(&tmp_time
);
3744 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3746 fstrcpy(mode_str
, "unknown");
3748 d_printf("Access: %s\n", mode_str
);
3750 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_mtime
);
3751 lt
= localtime(&tmp_time
);
3753 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3755 fstrcpy(mode_str
, "unknown");
3757 d_printf("Modify: %s\n", mode_str
);
3759 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_ctime
);
3760 lt
= localtime(&tmp_time
);
3762 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3764 fstrcpy(mode_str
, "unknown");
3766 d_printf("Change: %s\n", mode_str
);
3772 /****************************************************************************
3774 ****************************************************************************/
3776 static int cmd_chown(void)
3778 TALLOC_CTX
*ctx
= talloc_tos();
3782 char *buf
, *buf2
, *buf3
;
3783 struct cli_state
*targetcli
;
3784 char *targetname
= NULL
;
3787 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3788 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
) ||
3789 !next_token_talloc(ctx
, &cmd_ptr
,&buf3
,NULL
)) {
3790 d_printf("chown uid gid file\n");
3794 uid
= (uid_t
)atoi(buf
);
3795 gid
= (gid_t
)atoi(buf2
);
3797 src
= talloc_asprintf(ctx
,
3799 client_get_cur_dir(),
3804 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3805 cli
, src
, &targetcli
, &targetname
);
3806 if (!NT_STATUS_IS_OK(status
)) {
3807 d_printf("chown %s: %s\n", src
, nt_errstr(status
));
3811 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3812 d_printf("Server doesn't support UNIX CIFS calls.\n");
3816 status
= cli_posix_chown(targetcli
, targetname
, uid
, gid
);
3817 if (!NT_STATUS_IS_OK(status
)) {
3818 d_printf("%s chown file %s uid=%d, gid=%d\n",
3819 nt_errstr(status
), src
, (int)uid
, (int)gid
);
3826 /****************************************************************************
3828 ****************************************************************************/
3830 static int cmd_rename(void)
3832 TALLOC_CTX
*ctx
= talloc_tos();
3835 struct cli_state
*targetcli
;
3839 bool replace
= false;
3841 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3842 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3843 d_printf("rename <src> <dest> [-f]\n");
3847 src
= talloc_asprintf(ctx
,
3849 client_get_cur_dir(),
3855 dest
= talloc_asprintf(ctx
,
3857 client_get_cur_dir(),
3863 if (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
) &&
3864 strcsequal(buf
, "-f")) {
3868 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3869 cli
, src
, &targetcli
, &targetsrc
);
3870 if (!NT_STATUS_IS_OK(status
)) {
3871 d_printf("rename %s: %s\n", src
, nt_errstr(status
));
3875 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3876 cli
, dest
, &targetcli
, &targetdest
);
3877 if (!NT_STATUS_IS_OK(status
)) {
3878 d_printf("rename %s: %s\n", dest
, nt_errstr(status
));
3882 status
= cli_rename(targetcli
, targetsrc
, targetdest
, replace
);
3883 if (!NT_STATUS_IS_OK(status
)) {
3884 d_printf("%s renaming files %s -> %s \n",
3894 struct scopy_timing
{
3895 struct timespec tp_start
;
3898 static int scopy_status(off_t written
, void *priv
)
3900 struct timespec tp_end
;
3901 unsigned int scopy_total_time_ms
;
3902 struct scopy_timing
*st
= priv
;
3904 clock_gettime_mono(&tp_end
);
3905 scopy_total_time_ms
= nsec_time_diff(&tp_end
,&st
->tp_start
)/1000000;
3907 DEBUG(5,("Copied %jd bytes at an average %3.1f kb/s\n",
3908 (intmax_t)written
, written
/ (1.024*scopy_total_time_ms
)));
3913 /****************************************************************************
3914 Server-Side copy some file.
3915 ****************************************************************************/
3917 static int cmd_scopy(void)
3919 TALLOC_CTX
*ctx
= talloc_tos();
3922 struct cli_state
*targetcli
;
3925 uint32_t DesiredAccess
, ShareAccess
, CreateDisposition
, CreateOptions
;
3926 struct smb_create_returns cr
;
3927 uint16_t destfnum
= (uint16_t)-1;
3928 uint16_t srcfnum
= (uint16_t)-1;
3930 struct scopy_timing st
;
3934 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3935 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3936 d_printf("scopy <src> <dest>\n");
3940 src
= talloc_asprintf(ctx
,
3942 client_get_cur_dir(),
3948 dest
= talloc_asprintf(ctx
,
3950 client_get_cur_dir(),
3956 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3957 cli
, src
, &targetcli
, &targetsrc
);
3958 if (!NT_STATUS_IS_OK(status
)) {
3959 d_printf("scopy %s: %s\n", src
, nt_errstr(status
));
3963 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
3964 cli
, dest
, &targetcli
, &targetdest
);
3965 if (!NT_STATUS_IS_OK(status
)) {
3966 d_printf("scopy %s: %s\n", dest
, nt_errstr(status
));
3971 DesiredAccess
= (FILE_READ_DATA
|FILE_READ_EA
|FILE_READ_ATTRIBUTES
|
3972 READ_CONTROL_ACCESS
|SYNCHRONIZE_ACCESS
);
3973 ShareAccess
= FILE_SHARE_READ
|FILE_SHARE_DELETE
;
3974 CreateDisposition
= FILE_OPEN
;
3975 CreateOptions
= (FILE_SEQUENTIAL_ONLY
|FILE_NON_DIRECTORY_FILE
|
3976 FILE_OPEN_REPARSE_POINT
);
3977 status
= cli_ntcreate(targetcli
, targetsrc
, 0, DesiredAccess
, 0,
3978 ShareAccess
, CreateDisposition
, CreateOptions
, 0x0,
3980 if (!NT_STATUS_IS_OK(status
)) {
3981 d_printf("Failed to open file %s. %s\n",
3982 targetsrc
, nt_errstr(status
));
3986 DesiredAccess
= (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_READ_EA
|
3987 FILE_WRITE_EA
|FILE_READ_ATTRIBUTES
|FILE_WRITE_ATTRIBUTES
|
3988 DELETE_ACCESS
|READ_CONTROL_ACCESS
|WRITE_DAC_ACCESS
|SYNCHRONIZE_ACCESS
);
3989 ShareAccess
= FILE_SHARE_NONE
;
3990 CreateDisposition
= FILE_CREATE
;
3991 CreateOptions
= FILE_SEQUENTIAL_ONLY
|FILE_NON_DIRECTORY_FILE
;
3992 status
= cli_ntcreate(targetcli
, targetdest
, 0, DesiredAccess
,
3993 FILE_ATTRIBUTE_ARCHIVE
, ShareAccess
, CreateDisposition
,
3994 CreateOptions
, 0x0, &destfnum
, NULL
);
3995 if (!NT_STATUS_IS_OK(status
)) {
3996 d_printf("Failed to create file %s. %s\n",
3997 targetdest
, nt_errstr(status
));
3998 cli_close(targetcli
, srcfnum
);
4002 clock_gettime_mono(&st
.tp_start
);
4003 status
= cli_splice(targetcli
, targetcli
, srcfnum
, destfnum
,
4004 cr
.end_of_file
, 0, 0, &written
, scopy_status
, &st
);
4005 if (!NT_STATUS_IS_OK(status
)) {
4006 d_printf("%s copying file %s -> %s \n",
4013 status
= cli_close(targetcli
, srcfnum
);
4014 if (!NT_STATUS_IS_OK(status
)) {
4015 d_printf("Error %s closing remote source file\n", nt_errstr(status
));
4018 status
= cli_close(targetcli
, destfnum
);
4019 if (!NT_STATUS_IS_OK(status
)) {
4020 d_printf("Error %s closing remote dest file\n", nt_errstr(status
));
4027 /****************************************************************************
4028 Print the volume name.
4029 ****************************************************************************/
4031 static int cmd_volume(void)
4034 uint32_t serial_num
;
4038 status
= cli_get_fs_volume_info(cli
, talloc_tos(),
4039 &volname
, &serial_num
,
4041 if (!NT_STATUS_IS_OK(status
)) {
4042 d_printf("Error %s getting volume info\n", nt_errstr(status
));
4046 d_printf("Volume: |%s| serial number 0x%x\n",
4047 volname
, (unsigned int)serial_num
);
4051 /****************************************************************************
4052 Hard link files using the NT call.
4053 ****************************************************************************/
4055 static int cmd_hardlink(void)
4057 TALLOC_CTX
*ctx
= talloc_tos();
4060 struct cli_state
*targetcli
;
4064 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
4065 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
4066 d_printf("hardlink <src> <dest>\n");
4070 src
= talloc_asprintf(ctx
,
4072 client_get_cur_dir(),
4078 dest
= talloc_asprintf(ctx
,
4080 client_get_cur_dir(),
4086 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
4087 cli
, src
, &targetcli
, &targetname
);
4088 if (!NT_STATUS_IS_OK(status
)) {
4089 d_printf("hardlink %s: %s\n", src
, nt_errstr(status
));
4093 status
= cli_nt_hardlink(targetcli
, targetname
, dest
);
4094 if (!NT_STATUS_IS_OK(status
)) {
4095 d_printf("%s doing an NT hard link of files\n",
4103 /****************************************************************************
4104 Toggle the prompt flag.
4105 ****************************************************************************/
4107 static int cmd_prompt(void)
4110 DEBUG(2,("prompting is now %s\n",prompt
?"on":"off"));
4114 /****************************************************************************
4115 Set the newer than time.
4116 ****************************************************************************/
4118 static int cmd_newer(void)
4120 TALLOC_CTX
*ctx
= talloc_tos();
4123 SMB_STRUCT_STAT sbuf
;
4125 ok
= next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
);
4126 if (ok
&& (sys_stat(buf
, &sbuf
, false) == 0)) {
4127 newer_than
= convert_timespec_to_time_t(sbuf
.st_ex_mtime
);
4128 DEBUG(1,("Getting files newer than %s",
4129 time_to_asc(newer_than
)));
4134 if (ok
&& newer_than
== 0) {
4135 d_printf("Error setting newer-than time\n");
4142 /****************************************************************************
4143 Watch directory changes
4144 ****************************************************************************/
4146 static int cmd_notify(void)
4148 TALLOC_CTX
*frame
= talloc_stackframe();
4153 name
= talloc_strdup(talloc_tos(), client_get_cur_dir());
4157 if (!next_token_talloc(talloc_tos(), &cmd_ptr
, &buf
, NULL
)) {
4160 name
= talloc_asprintf_append(name
, "%s", buf
);
4164 status
= cli_ntcreate(
4165 cli
, name
, 0, FILE_READ_DATA
, 0,
4166 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
4167 FILE_OPEN
, 0, 0, &fnum
, NULL
);
4168 if (!NT_STATUS_IS_OK(status
)) {
4169 d_printf("Could not open file: %s\n", nt_errstr(status
));
4174 uint32_t i
, num_changes
;
4175 struct notify_change
*changes
;
4177 status
= cli_notify(cli
, fnum
, 1000, FILE_NOTIFY_CHANGE_ALL
,
4179 talloc_tos(), &num_changes
, &changes
);
4180 if (!NT_STATUS_IS_OK(status
)) {
4181 d_printf("notify returned %s\n",
4185 for (i
=0; i
<num_changes
; i
++) {
4186 printf("%4.4x %s\n", changes
[i
].action
,
4189 TALLOC_FREE(changes
);
4192 d_printf("notify <dir name>\n");
4198 /****************************************************************************
4199 Set the archive level.
4200 ****************************************************************************/
4202 static int cmd_archive(void)
4204 TALLOC_CTX
*ctx
= talloc_tos();
4207 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4208 archive_level
= atoi(buf
);
4210 d_printf("Archive level is %d\n",archive_level
);
4216 /****************************************************************************
4217 Toggle the backup_intent state.
4218 ****************************************************************************/
4220 static int cmd_backup(void)
4222 backup_intent
= !backup_intent
;
4223 cli_set_backup_intent(cli
, backup_intent
);
4224 DEBUG(2,("backup intent is now %s\n",backup_intent
?"on":"off"));
4228 /****************************************************************************
4229 Toggle the lowercaseflag.
4230 ****************************************************************************/
4232 static int cmd_lowercase(void)
4234 lowercase
= !lowercase
;
4235 DEBUG(2,("filename lowercasing is now %s\n",lowercase
?"on":"off"));
4239 /****************************************************************************
4240 Toggle the case sensitive flag.
4241 ****************************************************************************/
4243 static int cmd_setcase(void)
4245 bool orig_case_sensitive
= cli_set_case_sensitive(cli
, false);
4247 cli_set_case_sensitive(cli
, !orig_case_sensitive
);
4248 DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive
?
4253 /****************************************************************************
4254 Toggle the showacls flag.
4255 ****************************************************************************/
4257 static int cmd_showacls(void)
4259 showacls
= !showacls
;
4260 DEBUG(2,("showacls is now %s\n",showacls
?"on":"off"));
4265 /****************************************************************************
4266 Toggle the recurse flag.
4267 ****************************************************************************/
4269 static int cmd_recurse(void)
4272 DEBUG(2,("directory recursion is now %s\n",recurse
?"on":"off"));
4276 /****************************************************************************
4277 Toggle the translate flag.
4278 ****************************************************************************/
4280 static int cmd_translate(void)
4282 translation
= !translation
;
4283 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
4284 translation
?"on":"off"));
4288 /****************************************************************************
4290 ****************************************************************************/
4292 static int cmd_lcd(void)
4294 TALLOC_CTX
*ctx
= talloc_tos();
4298 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4299 if (chdir(buf
) == -1) {
4300 d_printf("chdir to %s failed (%s)\n",
4301 buf
, strerror(errno
));
4308 DEBUG(2,("the local directory is now %s\n",d
));
4313 /****************************************************************************
4314 Get a file restarting at end of local file.
4315 ****************************************************************************/
4317 static int cmd_reget(void)
4319 TALLOC_CTX
*ctx
= talloc_tos();
4320 char *local_name
= NULL
;
4321 char *remote_name
= NULL
;
4325 remote_name
= talloc_strdup(ctx
, client_get_cur_dir());
4330 if (!next_token_talloc(ctx
, &cmd_ptr
, &fname
, NULL
)) {
4331 d_printf("reget <filename>\n");
4334 remote_name
= talloc_asprintf_append(remote_name
, "%s", fname
);
4338 remote_name
= clean_name(ctx
,remote_name
);
4344 next_token_talloc(ctx
, &cmd_ptr
, &p
, NULL
);
4349 return do_get(remote_name
, local_name
, true);
4352 /****************************************************************************
4353 Put a file restarting at end of local file.
4354 ****************************************************************************/
4356 static int cmd_reput(void)
4358 TALLOC_CTX
*ctx
= talloc_tos();
4359 char *local_name
= NULL
;
4360 char *remote_name
= NULL
;
4364 remote_name
= talloc_strdup(ctx
, client_get_cur_dir());
4369 if (!next_token_talloc(ctx
, &cmd_ptr
, &local_name
, NULL
)) {
4370 d_printf("reput <filename>\n");
4374 if (!file_exist_stat(local_name
, &st
, false)) {
4375 d_printf("%s does not exist\n", local_name
);
4379 if (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
4380 remote_name
= talloc_asprintf_append(remote_name
,
4383 remote_name
= talloc_asprintf_append(remote_name
,
4390 remote_name
= clean_name(ctx
, remote_name
);
4395 return do_put(remote_name
, local_name
, true);
4398 /****************************************************************************
4400 ****************************************************************************/
4402 static void browse_fn(const char *name
, uint32_t m
,
4403 const char *comment
, void *state
)
4405 const char *typestr
= "";
4408 case STYPE_DISKTREE
:
4412 typestr
= "Printer";
4421 /* FIXME: If the remote machine returns non-ascii characters
4422 in any of these fields, they can corrupt the output. We
4423 should remove them. */
4425 d_printf("\t%-15s %-10.10s%s\n",
4426 name
,typestr
,comment
);
4428 d_printf ("%s|%s|%s\n",typestr
,name
,comment
);
4432 static bool browse_host_rpc(bool sort
)
4435 struct rpc_pipe_client
*pipe_hnd
= NULL
;
4436 TALLOC_CTX
*frame
= talloc_stackframe();
4438 struct srvsvc_NetShareInfoCtr info_ctr
;
4439 struct srvsvc_NetShareCtr1 ctr1
;
4440 uint32_t resume_handle
= 0;
4441 uint32_t total_entries
= 0;
4443 struct dcerpc_binding_handle
*b
;
4445 status
= cli_rpc_pipe_open_noauth(cli
, &ndr_table_srvsvc
,
4448 if (!NT_STATUS_IS_OK(status
)) {
4449 DEBUG(10, ("Could not connect to srvsvc pipe: %s\n",
4450 nt_errstr(status
)));
4455 b
= pipe_hnd
->binding_handle
;
4457 ZERO_STRUCT(info_ctr
);
4461 info_ctr
.ctr
.ctr1
= &ctr1
;
4463 status
= dcerpc_srvsvc_NetShareEnumAll(b
, frame
,
4471 if (!NT_STATUS_IS_OK(status
) || !W_ERROR_IS_OK(werr
)) {
4472 TALLOC_FREE(pipe_hnd
);
4477 for (i
=0; i
< info_ctr
.ctr
.ctr1
->count
; i
++) {
4478 struct srvsvc_NetShareInfo1 info
= info_ctr
.ctr
.ctr1
->array
[i
];
4479 browse_fn(info
.name
, info
.type
, info
.comment
, NULL
);
4482 TALLOC_FREE(pipe_hnd
);
4487 /****************************************************************************
4488 Try and browse available connections on a host.
4489 ****************************************************************************/
4491 static bool browse_host(bool sort
)
4495 d_printf("\n\tSharename Type Comment\n");
4496 d_printf("\t--------- ---- -------\n");
4499 if (browse_host_rpc(sort
)) {
4503 if((ret
= cli_RNetShareEnum(cli
, browse_fn
, NULL
)) == -1) {
4504 NTSTATUS status
= cli_nt_error(cli
);
4505 d_printf("Error returning browse list: %s\n",
4512 /****************************************************************************
4514 ****************************************************************************/
4516 static void server_fn(const char *name
, uint32_t m
,
4517 const char *comment
, void *state
)
4521 d_printf("\t%-16s %s\n", name
, comment
);
4523 d_printf("%s|%s|%s\n",(char *)state
, name
, comment
);
4527 /****************************************************************************
4528 Try and browse available connections on a host.
4529 ****************************************************************************/
4531 static bool list_servers(const char *wk_grp
)
4535 if (!cli
->server_domain
)
4539 d_printf("\n\tServer Comment\n");
4540 d_printf("\t--------- -------\n");
4542 fstrcpy( state
, "Server" );
4543 cli_NetServerEnum(cli
, cli
->server_domain
, SV_TYPE_ALL
, server_fn
,
4547 d_printf("\n\tWorkgroup Master\n");
4548 d_printf("\t--------- -------\n");
4551 fstrcpy( state
, "Workgroup" );
4552 cli_NetServerEnum(cli
, cli
->server_domain
, SV_TYPE_DOMAIN_ENUM
,
4557 /****************************************************************************
4558 Print or set current VUID
4559 ****************************************************************************/
4561 static int cmd_vuid(void)
4563 TALLOC_CTX
*ctx
= talloc_tos();
4566 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4567 d_printf("Current VUID is %d\n",
4568 cli_state_get_uid(cli
));
4572 cli_state_set_uid(cli
, atoi(buf
));
4576 /****************************************************************************
4577 Setup a new VUID, by issuing a session setup
4578 ****************************************************************************/
4580 static int cmd_logon(void)
4582 TALLOC_CTX
*ctx
= talloc_tos();
4583 char *l_username
, *l_password
;
4584 struct cli_credentials
*creds
= NULL
;
4587 if (!next_token_talloc(ctx
, &cmd_ptr
,&l_username
,NULL
)) {
4588 d_printf("logon <username> [<password>]\n");
4592 if (!next_token_talloc(ctx
, &cmd_ptr
,&l_password
,NULL
)) {
4593 char pwd
[256] = {0};
4596 rc
= samba_getpass("Password: ", pwd
, sizeof(pwd
), false, false);
4598 l_password
= talloc_strdup(ctx
, pwd
);
4605 creds
= cli_session_creds_init(ctx
,
4610 false, /* use_kerberos */
4611 false, /* fallback_after_kerberos */
4612 false, /* use_ccache */
4613 false); /* password_is_nt_hash */
4614 if (creds
== NULL
) {
4615 d_printf("cli_session_creds_init() failed.\n");
4618 nt_status
= cli_session_setup_creds(cli
, creds
);
4620 if (!NT_STATUS_IS_OK(nt_status
)) {
4621 d_printf("session setup failed: %s\n", nt_errstr(nt_status
));
4625 d_printf("Current VUID is %d\n", cli_state_get_uid(cli
));
4633 static int cmd_logoff(void)
4637 status
= cli_ulogoff(cli
);
4638 if (!NT_STATUS_IS_OK(status
)) {
4639 d_printf("logoff failed: %s\n", nt_errstr(status
));
4643 d_printf("logoff successful\n");
4649 * tree connect (connect to a share)
4652 static int cmd_tcon(void)
4654 TALLOC_CTX
*ctx
= talloc_tos();
4658 if (!next_token_talloc(ctx
, &cmd_ptr
, &sharename
, NULL
)) {
4659 d_printf("tcon <sharename>\n");
4667 status
= cli_tree_connect(cli
, sharename
, "?????", NULL
);
4668 if (!NT_STATUS_IS_OK(status
)) {
4669 d_printf("tcon failed: %s\n", nt_errstr(status
));
4673 talloc_free(sharename
);
4675 d_printf("tcon to %s successful, tid: %u\n", sharename
,
4676 cli_state_get_tid(cli
));
4681 * tree disconnect (disconnect from a share)
4684 static int cmd_tdis(void)
4688 status
= cli_tdis(cli
);
4689 if (!NT_STATUS_IS_OK(status
)) {
4690 d_printf("tdis failed: %s\n", nt_errstr(status
));
4694 d_printf("tdis successful\n");
4703 static int cmd_tid(void)
4705 TALLOC_CTX
*ctx
= talloc_tos();
4708 if (!next_token_talloc(ctx
, &cmd_ptr
, &tid_str
, NULL
)) {
4709 if (cli_state_has_tcon(cli
)) {
4710 d_printf("current tid is %d\n", cli_state_get_tid(cli
));
4712 d_printf("no tcon currently\n");
4715 uint16_t tid
= atoi(tid_str
);
4716 cli_state_set_tid(cli
, tid
);
4723 /****************************************************************************
4724 list active connections
4725 ****************************************************************************/
4727 static int cmd_list_connect(void)
4729 cli_cm_display(cli
);
4733 /****************************************************************************
4734 display the current active client connection
4735 ****************************************************************************/
4737 static int cmd_show_connect( void )
4739 TALLOC_CTX
*ctx
= talloc_tos();
4740 struct cli_state
*targetcli
;
4744 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(), cli
,
4745 client_get_cur_dir(), &targetcli
,
4747 if (!NT_STATUS_IS_OK(status
)) {
4748 d_printf("showconnect %s: %s\n", cur_dir
, nt_errstr(status
));
4752 d_printf("//%s/%s\n", smbXcli_conn_remote_name(targetcli
->conn
), targetcli
->share
);
4757 * set_remote_attr - set DOS attributes of a remote file
4758 * @filename: path to the file name
4759 * @new_attr: attribute bit mask to use
4760 * @mode: one of ATTR_SET or ATTR_UNSET
4762 * Update the file attributes with the one provided.
4764 int set_remote_attr(const char *filename
, uint16_t new_attr
, int mode
)
4766 extern struct cli_state
*cli
;
4770 status
= cli_getatr(cli
, filename
, &old_attr
, NULL
, NULL
);
4771 if (!NT_STATUS_IS_OK(status
)) {
4772 d_printf("cli_getatr failed: %s\n", nt_errstr(status
));
4776 if (mode
== ATTR_SET
) {
4777 new_attr
|= old_attr
;
4779 new_attr
= old_attr
& ~new_attr
;
4782 status
= cli_setatr(cli
, filename
, new_attr
, 0);
4783 if (!NT_STATUS_IS_OK(status
)) {
4784 d_printf("cli_setatr failed: %s\n", nt_errstr(status
));
4792 * cmd_setmode - interactive command to set DOS attributes
4794 * Read a filename and mode from the client command line and update
4795 * the file DOS attributes.
4797 int cmd_setmode(void)
4799 const extern char *cmd_ptr
;
4802 uint16_t attr
[2] = {0};
4803 int mode
= ATTR_SET
;
4806 TALLOC_CTX
*ctx
= talloc_new(NULL
);
4811 ok
= next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
);
4813 d_printf("setmode <filename> <[+|-]rsha>\n");
4818 fname
= talloc_asprintf(ctx
,
4820 client_get_cur_dir(),
4822 if (fname
== NULL
) {
4827 while (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
4828 const char *s
= buf
;
4839 attr
[mode
] |= FILE_ATTRIBUTE_READONLY
;
4842 attr
[mode
] |= FILE_ATTRIBUTE_HIDDEN
;
4845 attr
[mode
] |= FILE_ATTRIBUTE_SYSTEM
;
4848 attr
[mode
] |= FILE_ATTRIBUTE_ARCHIVE
;
4851 d_printf("setmode <filename> <perm=[+|-]rsha>\n");
4858 if (attr
[ATTR_SET
] == 0 && attr
[ATTR_UNSET
] == 0) {
4859 d_printf("setmode <filename> <[+|-]rsha>\n");
4864 DEBUG(2, ("perm set %d %d\n", attr
[ATTR_SET
], attr
[ATTR_UNSET
]));
4866 /* ignore return value: server might not store DOS attributes */
4867 set_remote_attr(fname
, attr
[ATTR_SET
], ATTR_SET
);
4868 set_remote_attr(fname
, attr
[ATTR_UNSET
], ATTR_UNSET
);
4874 /****************************************************************************
4876 ***************************************************************************/
4878 int cmd_iosize(void)
4880 TALLOC_CTX
*ctx
= talloc_tos();
4884 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4885 if (smbXcli_conn_protocol(cli
->conn
) < PROTOCOL_SMB2_02
) {
4887 d_printf("iosize <n> or iosize 0x<n>. "
4888 "Minimum is 0 (default), "
4889 "max is 16776960 (0xFFFF00)\n");
4891 d_printf("iosize <n> or iosize 0x<n>. "
4892 "(Encrypted connection) ,"
4893 "Minimum is 0 (default), "
4894 "max is 130048 (0x1FC00)\n");
4897 d_printf("iosize <n> or iosize 0x<n>.\n");
4902 iosize
= strtol(buf
,NULL
,0);
4903 if (smbXcli_conn_protocol(cli
->conn
) < PROTOCOL_SMB2_02
) {
4904 if (smb_encrypt
&& (iosize
< 0 || iosize
> 0xFC00)) {
4905 d_printf("iosize out of range for encrypted "
4906 "connection (min = 0 (default), "
4907 "max = 130048 (0x1FC00)\n");
4909 } else if (!smb_encrypt
&& (iosize
< 0 || iosize
> 0xFFFF00)) {
4910 d_printf("iosize out of range (min = 0 (default), "
4911 "max = 16776960 (0xFFFF00)\n");
4916 io_bufsize
= iosize
;
4917 d_printf("iosize is now %d\n", io_bufsize
);
4921 /****************************************************************************
4923 ***************************************************************************/
4925 static int cmd_timeout(void)
4927 TALLOC_CTX
*ctx
= talloc_tos();
4930 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4931 unsigned int old_timeout
= cli_set_timeout(cli
, 0);
4932 cli_set_timeout(cli
, old_timeout
);
4933 d_printf("timeout <n> (per-operation timeout "
4934 "in seconds - currently %u).\n",
4939 io_timeout
= strtol(buf
,NULL
,0);
4940 cli_set_timeout(cli
, io_timeout
*1000);
4941 d_printf("io_timeout per operation is now %d\n", io_timeout
);
4946 /****************************************************************************
4948 ****************************************************************************/
4949 static int cmd_history(void)
4951 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
4955 hlist
= history_list();
4957 for (i
= 0; hlist
&& hlist
[i
]; i
++) {
4958 DEBUG(0, ("%d: %s\n", i
, hlist
[i
]->line
));
4961 DEBUG(0,("no history without readline support\n"));
4967 /* Some constants for completing filename arguments */
4969 #define COMPL_NONE 0 /* No completions */
4970 #define COMPL_REMOTE 1 /* Complete remote filename */
4971 #define COMPL_LOCAL 2 /* Complete local filename */
4973 /* This defines the commands supported by this client.
4974 * NOTE: The "!" must be the last one in the list because it's fn pointer
4975 * field is NULL, and NULL in that field is used in process_tok()
4976 * (below) to indicate the end of the list. crh
4981 const char *description
;
4982 char compl_args
[2]; /* Completion argument info */
4984 {"?",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
4985 {"allinfo",cmd_allinfo
,"<file> show all available info",
4986 {COMPL_NONE
,COMPL_NONE
}},
4987 {"altname",cmd_altname
,"<file> show alt name",{COMPL_NONE
,COMPL_NONE
}},
4988 {"archive",cmd_archive
,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit",{COMPL_NONE
,COMPL_NONE
}},
4989 {"backup",cmd_backup
,"toggle backup intent state",{COMPL_NONE
,COMPL_NONE
}},
4990 {"blocksize",cmd_block
,"blocksize <number> (default 20)",{COMPL_NONE
,COMPL_NONE
}},
4991 {"cancel",cmd_cancel
,"<jobid> cancel a print queue entry",{COMPL_NONE
,COMPL_NONE
}},
4992 {"case_sensitive",cmd_setcase
,"toggle the case sensitive flag to server",{COMPL_NONE
,COMPL_NONE
}},
4993 {"cd",cmd_cd
,"[directory] change/report the remote directory",{COMPL_REMOTE
,COMPL_NONE
}},
4994 {"chmod",cmd_chmod
,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE
,COMPL_NONE
}},
4995 {"chown",cmd_chown
,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE
,COMPL_NONE
}},
4996 {"close",cmd_close
,"<fid> close a file given a fid",{COMPL_REMOTE
,COMPL_NONE
}},
4997 {"del",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4998 {"dir",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4999 {"du",cmd_du
,"<mask> computes the total size of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
5000 {"echo",cmd_echo
,"ping the server",{COMPL_NONE
,COMPL_NONE
}},
5001 {"exit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
5002 {"get",cmd_get
,"<remote name> [local name] get a file",{COMPL_REMOTE
,COMPL_LOCAL
}},
5003 {"getfacl",cmd_getfacl
,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE
,COMPL_NONE
}},
5004 {"geteas", cmd_geteas
, "<file name> get the EA list of a file",
5005 {COMPL_REMOTE
, COMPL_NONE
}},
5006 {"hardlink",cmd_hardlink
,"<src> <dest> create a Windows hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
5007 {"help",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
5008 {"history",cmd_history
,"displays the command history",{COMPL_NONE
,COMPL_NONE
}},
5009 {"iosize",cmd_iosize
,"iosize <number> (default 64512)",{COMPL_NONE
,COMPL_NONE
}},
5010 {"lcd",cmd_lcd
,"[directory] change/report the local current working directory",{COMPL_LOCAL
,COMPL_NONE
}},
5011 {"link",cmd_link
,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
5012 {"lock",cmd_lock
,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE
,COMPL_REMOTE
}},
5013 {"lowercase",cmd_lowercase
,"toggle lowercasing of filenames for get",{COMPL_NONE
,COMPL_NONE
}},
5014 {"ls",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
5015 {"l",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
5016 {"mask",cmd_select
,"<mask> mask all filenames against this",{COMPL_REMOTE
,COMPL_NONE
}},
5017 {"md",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
5018 {"mget",cmd_mget
,"<mask> get all the matching files",{COMPL_REMOTE
,COMPL_NONE
}},
5019 {"mkdir",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
5020 {"more",cmd_more
,"<remote name> view a remote file with your pager",{COMPL_REMOTE
,COMPL_NONE
}},
5021 {"mput",cmd_mput
,"<mask> put all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
5022 {"newer",cmd_newer
,"<file> only mget files newer than the specified local file",{COMPL_LOCAL
,COMPL_NONE
}},
5023 {"notify",cmd_notify
,"<file>Get notified of dir changes",{COMPL_REMOTE
,COMPL_NONE
}},
5024 {"open",cmd_open
,"<mask> open a file",{COMPL_REMOTE
,COMPL_NONE
}},
5025 {"posix", cmd_posix
, "turn on all POSIX capabilities", {COMPL_REMOTE
,COMPL_NONE
}},
5026 {"posix_encrypt",cmd_posix_encrypt
,"<domain> <user> <password> start up transport encryption",{COMPL_REMOTE
,COMPL_NONE
}},
5027 {"posix_open",cmd_posix_open
,"<name> 0<mode> open_flags mode open a file using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
5028 {"posix_mkdir",cmd_posix_mkdir
,"<name> 0<mode> creates a directory using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
5029 {"posix_rmdir",cmd_posix_rmdir
,"<name> removes a directory using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
5030 {"posix_unlink",cmd_posix_unlink
,"<name> removes a file using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
5031 {"posix_whoami",cmd_posix_whoami
,"retun logged on user information "
5032 "using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
5033 {"print",cmd_print
,"<file name> print a file",{COMPL_NONE
,COMPL_NONE
}},
5034 {"prompt",cmd_prompt
,"toggle prompting for filenames for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
5035 {"put",cmd_put
,"<local name> [remote name] put a file",{COMPL_LOCAL
,COMPL_REMOTE
}},
5036 {"pwd",cmd_pwd
,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE
,COMPL_NONE
}},
5037 {"q",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
5038 {"queue",cmd_queue
,"show the print queue",{COMPL_NONE
,COMPL_NONE
}},
5039 {"quit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
5040 {"readlink",cmd_readlink
,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
5041 {"rd",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
5042 {"recurse",cmd_recurse
,"toggle directory recursion for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
5043 {"reget",cmd_reget
,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE
,COMPL_LOCAL
}},
5044 {"rename",cmd_rename
,"<src> <dest> rename some files",{COMPL_REMOTE
,COMPL_REMOTE
}},
5045 {"reput",cmd_reput
,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL
,COMPL_REMOTE
}},
5046 {"rm",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
5047 {"rmdir",cmd_rmdir
,"<directory> remove a directory",{COMPL_REMOTE
,COMPL_NONE
}},
5048 {"showacls",cmd_showacls
,"toggle if ACLs are shown or not",{COMPL_NONE
,COMPL_NONE
}},
5049 {"setea", cmd_setea
, "<file name> <eaname> <eaval> Set an EA of a file",
5050 {COMPL_REMOTE
, COMPL_LOCAL
}},
5051 {"setmode",cmd_setmode
,"<file name> <setmode string> change modes of file",{COMPL_REMOTE
,COMPL_NONE
}},
5052 {"scopy",cmd_scopy
,"<src> <dest> server-side copy file",{COMPL_REMOTE
,COMPL_REMOTE
}},
5053 {"stat",cmd_stat
,"<file name> Do a UNIX extensions stat call on a file",{COMPL_REMOTE
,COMPL_NONE
}},
5054 {"symlink",cmd_symlink
,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
5055 {"tar",cmd_tar
,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE
,COMPL_NONE
}},
5056 {"tarmode",cmd_tarmode
,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE
,COMPL_NONE
}},
5057 {"timeout",cmd_timeout
,"timeout <number> - set the per-operation timeout in seconds (default 20)",{COMPL_NONE
,COMPL_NONE
}},
5058 {"translate",cmd_translate
,"toggle text translation for printing",{COMPL_NONE
,COMPL_NONE
}},
5059 {"unlock",cmd_unlock
,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE
,COMPL_REMOTE
}},
5060 {"volume",cmd_volume
,"print the volume name",{COMPL_NONE
,COMPL_NONE
}},
5061 {"vuid",cmd_vuid
,"change current vuid",{COMPL_NONE
,COMPL_NONE
}},
5062 {"wdel",cmd_wdel
,"<attrib> <mask> wildcard delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
5063 {"logon",cmd_logon
,"establish new logon",{COMPL_NONE
,COMPL_NONE
}},
5064 {"listconnect",cmd_list_connect
,"list open connections",{COMPL_NONE
,COMPL_NONE
}},
5065 {"showconnect",cmd_show_connect
,"display the current active connection",{COMPL_NONE
,COMPL_NONE
}},
5066 {"tcon",cmd_tcon
,"connect to a share" ,{COMPL_NONE
,COMPL_NONE
}},
5067 {"tdis",cmd_tdis
,"disconnect from a share",{COMPL_NONE
,COMPL_NONE
}},
5068 {"tid",cmd_tid
,"show or set the current tid (tree-id)",{COMPL_NONE
,COMPL_NONE
}},
5069 {"logoff",cmd_logoff
,"log off (close the session)",{COMPL_NONE
,COMPL_NONE
}},
5070 {"..",cmd_cd_oneup
,"change the remote directory (up one level)",{COMPL_REMOTE
,COMPL_NONE
}},
5072 /* Yes, this must be here, see crh's comment above. */
5073 {"!",NULL
,"run a shell command on the local system",{COMPL_NONE
,COMPL_NONE
}},
5074 {NULL
,NULL
,NULL
,{COMPL_NONE
,COMPL_NONE
}}
5077 /*******************************************************************
5078 Lookup a command string in the list of commands, including
5080 ******************************************************************/
5082 static int process_tok(char *tok
)
5084 int i
= 0, matches
= 0;
5086 int tok_len
= strlen(tok
);
5088 while (commands
[i
].fn
!= NULL
) {
5089 if (strequal(commands
[i
].name
,tok
)) {
5093 } else if (strnequal(commands
[i
].name
, tok
, tok_len
)) {
5102 else if (matches
== 1)
5108 /****************************************************************************
5110 ****************************************************************************/
5112 static int cmd_help(void)
5114 TALLOC_CTX
*ctx
= talloc_tos();
5118 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
5119 if ((i
= process_tok(buf
)) >= 0)
5120 d_printf("HELP %s:\n\t%s\n\n",
5121 commands
[i
].name
,commands
[i
].description
);
5123 while (commands
[i
].description
) {
5124 for (j
=0; commands
[i
].description
&& (j
<5); j
++) {
5125 d_printf("%-15s",commands
[i
].name
);
5134 /****************************************************************************
5135 Process a -c command string.
5136 ****************************************************************************/
5138 static int process_command_string(const char *cmd_in
)
5140 TALLOC_CTX
*ctx
= talloc_tos();
5141 char *cmd
= talloc_strdup(ctx
, cmd_in
);
5147 /* establish the connection if not already */
5152 status
= cli_cm_open(talloc_tos(), NULL
,
5153 have_ip
? dest_ss_str
: desthost
,
5154 service
, popt_get_cmdline_auth_info(),
5156 max_protocol
, port
, name_type
,
5158 if (!NT_STATUS_IS_OK(status
)) {
5161 cli_set_timeout(cli
, io_timeout
*1000);
5164 while (cmd
[0] != '\0') {
5170 if ((p
= strchr_m(cmd
, ';')) == 0) {
5179 /* and get the first part of the command */
5181 if (!next_token_talloc(ctx
, &cmd_ptr
,&tok
,NULL
)) {
5185 if ((i
= process_tok(tok
)) >= 0) {
5186 rc
= commands
[i
].fn();
5187 } else if (i
== -2) {
5188 d_printf("%s: command abbreviation ambiguous\n",tok
);
5190 d_printf("%s: command not found\n",tok
);
5197 #define MAX_COMPLETIONS 100
5199 struct completion_remote
{
5207 static NTSTATUS
completion_remote_filter(const char *mnt
,
5208 struct file_info
*f
,
5212 struct completion_remote
*info
= (struct completion_remote
*)state
;
5214 if (info
->count
>= MAX_COMPLETIONS
- 1) {
5215 return NT_STATUS_OK
;
5217 if (strncmp(info
->text
, f
->name
, info
->len
) != 0) {
5218 return NT_STATUS_OK
;
5220 if (ISDOT(f
->name
) || ISDOTDOT(f
->name
)) {
5221 return NT_STATUS_OK
;
5224 if ((info
->dirmask
[0] == 0) && !(f
->mode
& FILE_ATTRIBUTE_DIRECTORY
))
5225 info
->matches
[info
->count
] = SMB_STRDUP(f
->name
);
5227 TALLOC_CTX
*ctx
= talloc_stackframe();
5230 tmp
= talloc_strdup(ctx
,info
->dirmask
);
5233 return NT_STATUS_NO_MEMORY
;
5235 tmp
= talloc_asprintf_append(tmp
, "%s", f
->name
);
5238 return NT_STATUS_NO_MEMORY
;
5240 if (f
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
5241 tmp
= talloc_asprintf_append(tmp
, "%s",
5246 return NT_STATUS_NO_MEMORY
;
5248 info
->matches
[info
->count
] = SMB_STRDUP(tmp
);
5251 if (info
->matches
[info
->count
] == NULL
) {
5252 return NT_STATUS_OK
;
5254 if (f
->mode
& FILE_ATTRIBUTE_DIRECTORY
) {
5255 smb_readline_ca_char(0);
5257 if (info
->count
== 1) {
5258 info
->samelen
= strlen(info
->matches
[info
->count
]);
5260 while (strncmp(info
->matches
[info
->count
],
5261 info
->matches
[info
->count
-1],
5262 info
->samelen
) != 0) {
5267 return NT_STATUS_OK
;
5270 static char **remote_completion(const char *text
, int len
)
5272 TALLOC_CTX
*ctx
= talloc_stackframe();
5273 char *dirmask
= NULL
;
5274 char *targetpath
= NULL
;
5275 struct cli_state
*targetcli
= NULL
;
5277 struct completion_remote info
= { NULL
, NULL
, 1, 0, NULL
, 0 };
5280 /* can't have non-static initialisation on Sun CC, so do it
5286 info
.matches
= SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS
);
5287 if (!info
.matches
) {
5293 * We're leaving matches[0] free to fill it later with the text to
5294 * display: Either the one single match or the longest common subset
5297 info
.matches
[0] = NULL
;
5300 for (i
= len
-1; i
>= 0; i
--) {
5301 if ((text
[i
] == '/') || (text
[i
] == CLI_DIRSEP_CHAR
)) {
5306 info
.text
= text
+i
+1;
5307 info
.samelen
= info
.len
= len
-i
-1;
5310 info
.dirmask
= SMB_MALLOC_ARRAY(char, i
+2);
5311 if (!info
.dirmask
) {
5314 strncpy(info
.dirmask
, text
, i
+1);
5315 info
.dirmask
[i
+1] = 0;
5316 dirmask
= talloc_asprintf(ctx
,
5318 client_get_cur_dir(),
5322 info
.dirmask
= SMB_STRDUP("");
5323 if (!info
.dirmask
) {
5326 dirmask
= talloc_asprintf(ctx
,
5328 client_get_cur_dir());
5334 status
= cli_resolve_path(ctx
, "", popt_get_cmdline_auth_info(),
5335 cli
, dirmask
, &targetcli
, &targetpath
);
5336 if (!NT_STATUS_IS_OK(status
)) {
5339 status
= cli_list(targetcli
, targetpath
, FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
,
5340 completion_remote_filter
, (void *)&info
);
5341 if (!NT_STATUS_IS_OK(status
)) {
5345 if (info
.count
== 1) {
5347 * No matches at all, NULL indicates there is nothing
5349 SAFE_FREE(info
.matches
[0]);
5350 SAFE_FREE(info
.matches
);
5355 if (info
.count
== 2) {
5357 * Exactly one match in matches[1], indicate this is the one
5360 info
.matches
[0] = info
.matches
[1];
5361 info
.matches
[1] = NULL
;
5364 return info
.matches
;
5368 * We got more than one possible match, set the result to the maximum
5372 info
.matches
[0] = SMB_STRNDUP(info
.matches
[1], info
.samelen
);
5373 info
.matches
[info
.count
] = NULL
;
5375 return info
.matches
;
5378 for (i
= 0; i
< info
.count
; i
++) {
5379 SAFE_FREE(info
.matches
[i
]);
5381 SAFE_FREE(info
.matches
);
5382 SAFE_FREE(info
.dirmask
);
5387 static char **completion_fn(const char *text
, int start
, int end
)
5389 smb_readline_ca_char(' ');
5392 const char *buf
, *sp
;
5396 buf
= smb_readline_get_line_buffer();
5400 sp
= strchr(buf
, ' ');
5404 for (i
= 0; commands
[i
].name
; i
++) {
5405 if ((strncmp(commands
[i
].name
, buf
, sp
- buf
) == 0) &&
5406 (commands
[i
].name
[sp
- buf
] == 0)) {
5410 if (commands
[i
].name
== NULL
)
5416 if (sp
== (buf
+ start
))
5417 compl_type
= commands
[i
].compl_args
[0];
5419 compl_type
= commands
[i
].compl_args
[1];
5421 if (compl_type
== COMPL_REMOTE
)
5422 return remote_completion(text
, end
- start
);
5423 else /* fall back to local filename completion */
5427 int i
, len
, samelen
= 0, count
=1;
5429 matches
= SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS
);
5436 for (i
=0;commands
[i
].fn
&& count
< MAX_COMPLETIONS
-1;i
++) {
5437 if (strncmp(text
, commands
[i
].name
, len
) == 0) {
5438 matches
[count
] = SMB_STRDUP(commands
[i
].name
);
5439 if (!matches
[count
])
5442 samelen
= strlen(matches
[count
]);
5444 while (strncmp(matches
[count
], matches
[count
-1], samelen
) != 0)
5451 case 0: /* should never happen */
5455 matches
[0] = SMB_STRDUP(matches
[1]);
5458 matches
[0] = (char *)SMB_MALLOC(samelen
+1);
5461 strncpy(matches
[0], matches
[1], samelen
);
5462 matches
[0][samelen
] = 0;
5464 matches
[count
] = NULL
;
5468 for (i
= 0; i
< count
; i
++)
5476 static bool finished
;
5478 /****************************************************************************
5479 Make sure we swallow keepalives during idle time.
5480 ****************************************************************************/
5482 static void readline_callback(void)
5484 static time_t last_t
;
5485 struct timespec now
;
5488 unsigned char garbage
[16];
5490 clock_gettime_mono(&now
);
5498 /* Ping the server to keep the connection alive using SMBecho. */
5499 memset(garbage
, 0xf0, sizeof(garbage
));
5500 status
= cli_echo(cli
, 1, data_blob_const(garbage
, sizeof(garbage
)));
5501 if (NT_STATUS_IS_OK(status
)) {
5505 if (!cli_state_is_connected(cli
)) {
5506 DEBUG(0,("SMBecho failed (%s). The connection is "
5507 "disconnected now\n", nt_errstr(status
)));
5509 smb_readline_done();
5513 /****************************************************************************
5514 Process commands on stdin.
5515 ****************************************************************************/
5517 static int process_stdin(void)
5522 TALLOC_CTX
*frame
= talloc_stackframe();
5524 char *the_prompt
= NULL
;
5528 /* display a prompt */
5529 if (asprintf(&the_prompt
, "smb: %s> ", client_get_cur_dir()) < 0) {
5533 line
= smb_readline(the_prompt
, readline_callback
, completion_fn
);
5534 SAFE_FREE(the_prompt
);
5540 /* special case - first char is ! */
5542 if (system(line
+ 1) == -1) {
5543 d_printf("system() command %s failed.\n",
5551 /* and get the first part of the command */
5553 if (!next_token_talloc(frame
, &cmd_ptr
,&tok
,NULL
)) {
5559 if ((i
= process_tok(tok
)) >= 0) {
5560 rc
= commands
[i
].fn();
5561 } else if (i
== -2) {
5562 d_printf("%s: command abbreviation ambiguous\n",tok
);
5564 d_printf("%s: command not found\n",tok
);
5572 /****************************************************************************
5573 Process commands from the client.
5574 ****************************************************************************/
5576 static int process(const char *base_directory
)
5581 status
= cli_cm_open(talloc_tos(), NULL
,
5582 have_ip
? dest_ss_str
: desthost
,
5583 service
, popt_get_cmdline_auth_info(),
5584 true, smb_encrypt
, max_protocol
, port
,
5586 if (!NT_STATUS_IS_OK(status
)) {
5590 cli_set_timeout(cli
, io_timeout
*1000);
5592 if (base_directory
&& *base_directory
) {
5593 rc
= do_cd(base_directory
);
5601 rc
= process_command_string(cmdstr
);
5610 /****************************************************************************
5612 ****************************************************************************/
5614 static int do_host_query(const char *query_host
)
5618 status
= cli_cm_open(talloc_tos(), NULL
,
5619 have_ip
? dest_ss_str
: query_host
,
5620 "IPC$", popt_get_cmdline_auth_info(),
5621 true, smb_encrypt
, max_protocol
, port
,
5623 if (!NT_STATUS_IS_OK(status
)) {
5627 cli_set_timeout(cli
, io_timeout
*1000);
5630 /* Ensure that the host can do IPv4 */
5632 if (!interpret_addr(query_host
)) {
5633 struct sockaddr_storage ss
;
5634 if (interpret_string_addr(&ss
, query_host
, 0) &&
5635 (ss
.ss_family
!= AF_INET
)) {
5636 d_printf("%s is an IPv6 address -- no workgroup available\n",
5642 if (lp_disable_netbios()) {
5646 if (port
!= NBT_SMB_PORT
) {
5648 /* Workgroups simply don't make sense over anything
5649 else but port 139... */
5652 status
= cli_cm_open(talloc_tos(), NULL
,
5653 have_ip
? dest_ss_str
: query_host
,
5654 "IPC$", popt_get_cmdline_auth_info(),
5655 true, smb_encrypt
, max_protocol
,
5656 NBT_SMB_PORT
, name_type
, &cli
);
5657 if (!NT_STATUS_IS_OK(status
)) {
5663 d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
5667 cli_set_timeout(cli
, io_timeout
*1000);
5668 list_servers(lp_workgroup());
5675 /****************************************************************************
5676 Handle a tar operation.
5677 ****************************************************************************/
5679 static int do_tar_op(const char *base_directory
)
5681 struct tar
*tar_ctx
= tar_get_ctx();
5684 /* do we already have a connection? */
5688 status
= cli_cm_open(talloc_tos(), NULL
,
5689 have_ip
? dest_ss_str
: desthost
,
5690 service
, popt_get_cmdline_auth_info(),
5691 true, smb_encrypt
, max_protocol
,
5692 port
, name_type
, &cli
);
5693 if (!NT_STATUS_IS_OK(status
)) {
5697 cli_set_timeout(cli
, io_timeout
*1000);
5702 if (base_directory
&& *base_directory
) {
5703 ret
= do_cd(base_directory
);
5709 ret
= tar_process(tar_ctx
);
5717 /****************************************************************************
5718 Handle a message operation.
5719 ****************************************************************************/
5721 static int do_message_op(struct user_auth_info
*a_info
)
5725 if (lp_disable_netbios()) {
5726 d_printf("NetBIOS over TCP disabled.\n");
5730 status
= cli_connect_nb(desthost
, have_ip
? &dest_ss
: NULL
,
5731 port
? port
: NBT_SMB_PORT
, name_type
,
5732 lp_netbios_name(), SMB_SIGNING_DEFAULT
, 0, &cli
);
5733 if (!NT_STATUS_IS_OK(status
)) {
5734 d_printf("Connection to %s failed. Error %s\n", desthost
, nt_errstr(status
));
5738 cli_set_timeout(cli
, io_timeout
*1000);
5739 send_message(get_cmdline_auth_info_username(a_info
));
5745 /****************************************************************************
5747 ****************************************************************************/
5749 int main(int argc
,char *argv
[])
5751 const char **const_argv
= discard_const_p(const char *, argv
);
5752 char *base_directory
= NULL
;
5754 char *query_host
= NULL
;
5755 bool message
= false;
5756 static const char *new_name_resolve_order
= NULL
;
5760 bool tar_opt
= false;
5761 bool service_opt
= false;
5762 struct tar
*tar_ctx
= tar_get_ctx();
5764 struct poptOption long_options
[] = {
5767 { "name-resolve", 'R', POPT_ARG_STRING
, &new_name_resolve_order
, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },
5768 { "message", 'M', POPT_ARG_STRING
, NULL
, 'M', "Send message", "HOST" },
5769 { "ip-address", 'I', POPT_ARG_STRING
, NULL
, 'I', "Use this IP to connect to", "IP" },
5770 { "stderr", 'E', POPT_ARG_NONE
, NULL
, 'E', "Write messages to stderr instead of stdout" },
5771 { "list", 'L', POPT_ARG_STRING
, NULL
, 'L', "Get a list of shares available on a host", "HOST" },
5772 { "max-protocol", 'm', POPT_ARG_STRING
, NULL
, 'm', "Set the max protocol level", "LEVEL" },
5773 { "tar", 'T', POPT_ARG_STRING
, NULL
, 'T', "Command line tar", "<c|x>IXFqgbNan" },
5774 { "directory", 'D', POPT_ARG_STRING
, NULL
, 'D', "Start from directory", "DIR" },
5775 { "command", 'c', POPT_ARG_STRING
, &cmdstr
, 'c', "Execute semicolon separated commands" },
5776 { "send-buffer", 'b', POPT_ARG_INT
, &io_bufsize
, 'b', "Changes the transmit/send buffer", "BYTES" },
5777 { "timeout", 't', POPT_ARG_INT
, &io_timeout
, 'b', "Changes the per-operation timeout", "SECONDS" },
5778 { "port", 'p', POPT_ARG_INT
, &port
, 'p', "Port to connect to", "PORT" },
5779 { "grepable", 'g', POPT_ARG_NONE
, NULL
, 'g', "Produce grepable output" },
5780 { "browse", 'B', POPT_ARG_NONE
, NULL
, 'B', "Browse SMB servers using DNS" },
5782 POPT_COMMON_CONNECTION
5783 POPT_COMMON_CREDENTIALS
5786 TALLOC_CTX
*frame
= talloc_stackframe();
5788 if (!client_set_cur_dir("\\")) {
5792 /* set default debug level to 1 regardless of what smb.conf sets */
5793 setup_logging( "smbclient", DEBUG_DEFAULT_STDERR
);
5796 lp_set_cmdline("log level", "1");
5798 popt_common_credentials_set_ignore_missing_conf();
5799 popt_common_credentials_set_delay_post();
5802 pc
= poptGetContext("smbclient", argc
, const_argv
, long_options
, 0);
5803 poptSetOtherOptionHelp(pc
, "service <password>");
5805 while ((opt
= poptGetNextOpt(pc
)) != -1) {
5807 /* if the tar option has been called previouslt, now we need to eat out the leftovers */
5808 /* I see no other way to keep things sane --SSS */
5809 if (tar_opt
== true) {
5810 while (poptPeekArg(pc
)) {
5816 /* if the service has not yet been specified lets see if it is available in the popt stack */
5817 if (!service_opt
&& poptPeekArg(pc
)) {
5818 service
= talloc_strdup(frame
, poptGetArg(pc
));
5825 /* if the service has already been retrieved then check if we have also a password */
5827 && (!get_cmdline_auth_info_got_pass(
5828 popt_get_cmdline_auth_info()))
5829 && poptPeekArg(pc
)) {
5830 set_cmdline_auth_info_password(
5831 popt_get_cmdline_auth_info(), poptGetArg(pc
));
5837 /* Messages are sent to NetBIOS name type 0x3
5838 * (Messenger Service). Make sure we default
5839 * to port 139 instead of port 445. srl,crh
5842 desthost
= talloc_strdup(frame
,poptGetOptArg(pc
));
5847 port
= NBT_SMB_PORT
;
5852 if (!interpret_string_addr(&dest_ss
, poptGetOptArg(pc
), 0)) {
5856 print_sockaddr(dest_ss_str
, sizeof(dest_ss_str
), &dest_ss
);
5860 setup_logging("smbclient", DEBUG_STDERR
);
5861 display_set_stderr();
5865 query_host
= talloc_strdup(frame
, poptGetOptArg(pc
));
5871 lp_set_cmdline("client max protocol", poptGetOptArg(pc
));
5874 /* We must use old option processing for this. Find the
5875 * position of the -T option in the raw argv[]. */
5879 for (i
= 1; i
< argc
; i
++) {
5880 if (strncmp("-T", argv
[i
],2)==0)
5884 if (tar_parse_args(tar_ctx
, poptGetOptArg(pc
),
5885 const_argv
+ i
, argc
- i
)) {
5886 poptPrintUsage(pc
, stderr
, 0);
5890 /* this must be the last option, mark we have parsed it so that we know we have */
5894 base_directory
= talloc_strdup(frame
, poptGetOptArg(pc
));
5895 if (!base_directory
) {
5906 return(do_smb_browse());
5911 /* We may still have some leftovers after the last popt option has been called */
5912 if (tar_opt
== true) {
5913 while (poptPeekArg(pc
)) {
5919 /* if the service has not yet been specified lets see if it is available in the popt stack */
5920 if (!service_opt
&& poptPeekArg(pc
)) {
5921 service
= talloc_strdup(frame
,poptGetArg(pc
));
5928 /* if the service has already been retrieved then check if we have also a password */
5930 && !get_cmdline_auth_info_got_pass(popt_get_cmdline_auth_info())
5931 && poptPeekArg(pc
)) {
5932 set_cmdline_auth_info_password(popt_get_cmdline_auth_info(),
5936 if (service_opt
&& service
) {
5939 /* Convert any '/' characters in the service name to '\' characters */
5940 string_replace(service
, '/','\\');
5941 if (count_chars(service
,'\\') < 3) {
5942 d_printf("\n%s: Not enough '\\' characters in service\n",service
);
5943 poptPrintUsage(pc
, stderr
, 0);
5946 /* Remove trailing slashes */
5947 len
= strlen(service
);
5948 while(len
> 0 && service
[len
- 1] == '\\') {
5950 service
[len
] = '\0';
5954 if (!init_names()) {
5955 fprintf(stderr
, "init_names() failed\n");
5959 if(new_name_resolve_order
)
5960 lp_set_cmdline("name resolve order", new_name_resolve_order
);
5962 if (!tar_to_process(tar_ctx
) && !query_host
&& !service
&& !message
) {
5963 poptPrintUsage(pc
, stderr
, 0);
5967 poptFreeContext(pc
);
5968 popt_burn_cmdline_password(argc
, argv
);
5970 DEBUG(3,("Client started (version %s).\n", samba_version_string()));
5972 /* Ensure we have a password (or equivalent). */
5973 popt_common_credentials_post();
5974 smb_encrypt
= get_cmdline_auth_info_smb_encrypt(
5975 popt_get_cmdline_auth_info());
5977 max_protocol
= lp_client_max_protocol();
5979 if (tar_to_process(tar_ctx
)) {
5981 process_command_string(cmdstr
);
5982 rc
= do_tar_op(base_directory
);
5983 } else if (query_host
&& *query_host
) {
5984 char *qhost
= query_host
;
5987 while (*qhost
== '\\' || *qhost
== '/')
5990 if ((slash
= strchr_m(qhost
, '/'))
5991 || (slash
= strchr_m(qhost
, '\\'))) {
5995 if ((p
=strchr_m(qhost
, '#'))) {
5998 sscanf(p
, "%x", &name_type
);
6001 rc
= do_host_query(qhost
);
6002 } else if (message
) {
6003 rc
= do_message_op(popt_get_cmdline_auth_info());
6004 } else if (process(base_directory
)) {
6008 popt_free_cmdline_auth_info();