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 "popt_common.h"
26 #include "rpc_client/cli_pipe.h"
27 #include "client/client_proto.h"
28 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
29 #include "../lib/util/select.h"
30 #include "system/readline.h"
31 #include "../libcli/smbreadline/smbreadline.h"
32 #include "../libcli/security/security.h"
33 #include "system/select.h"
34 #include "libsmb/clirap.h"
40 extern int do_smb_browse(void); /* mDNS browsing */
42 extern bool override_logfile
;
47 static char *desthost
;
48 static char *calling_name
;
49 static bool grepable
= false;
50 static char *cmdstr
= NULL
;
51 const char *cmd_ptr
= NULL
;
53 static int io_bufsize
= 524288;
55 static int name_type
= 0x20;
56 static int max_protocol
= PROTOCOL_NT1
;
58 static int process_tok(char *tok
);
59 static int cmd_help(void);
61 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
63 /* 30 second timeout on most commands */
64 #define CLIENT_TIMEOUT (30*1000)
65 #define SHORT_TIMEOUT (5*1000)
67 /* value for unused fid field in trans2 secondary request */
68 #define FID_UNUSED (0xFFFF)
70 time_t newer_than
= 0;
71 static int archive_level
= 0;
73 static bool translation
= false;
76 /* clitar bits insert */
79 extern bool tar_reset
;
82 static bool prompt
= true;
84 static bool recurse
= false;
85 static bool showacls
= false;
86 bool lowercase
= false;
88 static struct sockaddr_storage dest_ss
;
89 static char dest_ss_str
[INET6_ADDRSTRLEN
];
91 #define SEPARATORS " \t\n\r"
93 static bool abort_mget
= true;
96 uint64_t get_total_size
= 0;
97 unsigned int get_total_time_ms
= 0;
98 static uint64_t put_total_size
= 0;
99 static unsigned int put_total_time_ms
= 0;
102 static double dir_total
;
104 /* encrypted state. */
105 static bool smb_encrypt
;
107 /* root cli_state connection */
109 struct cli_state
*cli
;
111 static char CLI_DIRSEP_CHAR
= '\\';
112 static char CLI_DIRSEP_STR
[] = { '\\', '\0' };
114 /* Authentication for client connections. */
115 struct user_auth_info
*auth_info
;
117 /* Accessor functions for directory paths. */
118 static char *fileselection
;
119 static const char *client_get_fileselection(void)
122 return fileselection
;
127 static const char *client_set_fileselection(const char *new_fs
)
129 SAFE_FREE(fileselection
);
131 fileselection
= SMB_STRDUP(new_fs
);
133 return client_get_fileselection();
137 static const char *client_get_cwd(void)
142 return CLI_DIRSEP_STR
;
145 static const char *client_set_cwd(const char *new_cwd
)
149 cwd
= SMB_STRDUP(new_cwd
);
151 return client_get_cwd();
154 static char *cur_dir
;
155 const char *client_get_cur_dir(void)
160 return CLI_DIRSEP_STR
;
163 const char *client_set_cur_dir(const char *newdir
)
167 cur_dir
= SMB_STRDUP(newdir
);
169 return client_get_cur_dir();
172 /****************************************************************************
173 Put up a yes/no prompt.
174 ****************************************************************************/
176 static bool yesno(const char *p
)
181 if (!fgets(ans
,sizeof(ans
)-1,stdin
))
184 if (*ans
== 'y' || *ans
== 'Y')
190 /****************************************************************************
191 Write to a local file with CR/LF->LF translation if appropriate. Return the
192 number taken from the buffer. This may not equal the number written.
193 ****************************************************************************/
195 static int writefile(int f
, char *b
, int n
)
205 if (*b
== '\r' && (i
<(n
-1)) && *(b
+1) == '\n') {
208 if (write(f
, b
, 1) != 1) {
218 /****************************************************************************
219 Read from a file with LF->CR/LF translation if appropriate. Return the
220 number read. read approx n bytes.
221 ****************************************************************************/
223 static int readfile(uint8_t *b
, int n
, XFILE
*f
)
229 return x_fread(b
,1,n
,f
);
232 while (i
< (n
- 1) && (i
< BUFFER_SIZE
)) {
233 if ((c
= x_getc(f
)) == EOF
) {
237 if (c
== '\n') { /* change all LFs to CR/LF */
252 static size_t push_source(uint8_t *buf
, size_t n
, void *priv
)
254 struct push_state
*state
= (struct push_state
*)priv
;
257 if (x_feof(state
->f
)) {
261 result
= readfile(buf
, n
, state
->f
);
262 state
->nread
+= result
;
266 /****************************************************************************
268 ****************************************************************************/
270 static void send_message(const char *username
)
276 d_printf("Type your message, ending it with a Control-D\n");
279 while (i
<sizeof(buf
)-2) {
280 int c
= fgetc(stdin
);
291 status
= cli_message(cli
, desthost
, username
, buf
);
292 if (!NT_STATUS_IS_OK(status
)) {
293 d_fprintf(stderr
, "cli_message returned %s\n",
298 /****************************************************************************
299 Check the space on a device.
300 ****************************************************************************/
302 static int do_dskattr(void)
304 int total
, bsize
, avail
;
305 struct cli_state
*targetcli
= NULL
;
306 char *targetpath
= NULL
;
307 TALLOC_CTX
*ctx
= talloc_tos();
310 if ( !cli_resolve_path(ctx
, "", auth_info
, cli
, client_get_cur_dir(), &targetcli
, &targetpath
)) {
311 d_printf("Error in dskattr: %s\n", cli_errstr(cli
));
315 status
= cli_dskattr(targetcli
, &bsize
, &total
, &avail
);
316 if (!NT_STATUS_IS_OK(status
)) {
317 d_printf("Error in dskattr: %s\n", nt_errstr(status
));
321 d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
322 total
, bsize
, avail
);
327 /****************************************************************************
329 ****************************************************************************/
331 static int cmd_pwd(void)
333 d_printf("Current directory is %s",service
);
334 d_printf("%s\n",client_get_cur_dir());
338 /****************************************************************************
339 Ensure name has correct directory separators.
340 ****************************************************************************/
342 static void normalize_name(char *newdir
)
344 if (!(cli
->requested_posix_capabilities
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)) {
345 string_replace(newdir
,'/','\\');
349 /****************************************************************************
350 Change directory - inner section.
351 ****************************************************************************/
353 static int do_cd(const char *new_dir
)
356 char *saved_dir
= NULL
;
358 char *targetpath
= NULL
;
359 struct cli_state
*targetcli
= NULL
;
360 SMB_STRUCT_STAT sbuf
;
363 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 if ( !cli_resolve_path(ctx
, "", auth_info
, cli
, new_cd
, &targetcli
, &targetpath
)) {
406 d_printf("cd %s: %s\n", new_cd
, cli_errstr(cli
));
407 client_set_cur_dir(saved_dir
);
411 if (strequal(targetpath
,CLI_DIRSEP_STR
)) {
416 /* Use a trans2_qpathinfo to test directories for modern servers.
417 Except Win9x doesn't support the qpathinfo_basic() call..... */
419 if (targetcli
->protocol
> PROTOCOL_LANMAN2
&& !targetcli
->win95
) {
422 status
= cli_qpathinfo_basic(targetcli
, targetpath
, &sbuf
,
424 if (!NT_STATUS_IS_OK(status
)) {
425 d_printf("cd %s: %s\n", new_cd
, nt_errstr(status
));
426 client_set_cur_dir(saved_dir
);
430 if (!(attributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
431 d_printf("cd %s: not a directory\n", new_cd
);
432 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
& aDIR
) {
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
& aARCH
)) {
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(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(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
);
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 sd
= cli_query_secdesc(cli_state
, fnum
, ctx
);
583 DEBUG( 0, ("display_finfo() failed to "
584 "get security descriptor: %s",
585 cli_errstr(cli_state
)));
586 status
= cli_nt_error(cli_state
);
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 safe_strcpy_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
& aDIR
) {
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 if ( !cli_resolve_path(ctx
, "", auth_info
, cli
, head
, &targetcli
, &targetpath
) ) {
858 d_printf("do_list: [%s] %s\n", head
, cli_errstr(cli
));
859 remove_do_list_queue_head();
863 status
= cli_list(targetcli
, targetpath
, attribute
,
864 do_list_helper
, targetcli
);
865 if (!NT_STATUS_IS_OK(status
)) {
866 d_printf("%s listing %s\n",
867 nt_errstr(status
), targetpath
);
870 remove_do_list_queue_head();
871 if ((! do_list_queue_empty()) && (fn
== display_finfo
)) {
872 char *next_file
= do_list_queue_head();
874 if ((strlen(next_file
) >= 2) &&
875 (next_file
[strlen(next_file
) - 1] == '*') &&
876 (next_file
[strlen(next_file
) - 2] == CLI_DIRSEP_CHAR
)) {
877 save_ch
= next_file
+
878 strlen(next_file
) - 2;
881 /* cwd is only used if showacls is on */
882 client_set_cwd(next_file
);
885 if (!showacls
) /* don't disturbe the showacls output */
886 d_printf("\n%s\n",next_file
);
888 *save_ch
= CLI_DIRSEP_CHAR
;
892 TALLOC_FREE(targetpath
);
896 if (cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetpath
)) {
898 status
= cli_list(targetcli
, targetpath
, attribute
,
899 do_list_helper
, targetcli
);
900 if (!NT_STATUS_IS_OK(status
)) {
901 d_printf("%s listing %s\n",
902 nt_errstr(status
), targetpath
);
905 TALLOC_FREE(targetpath
);
907 d_printf("do_list: [%s] %s\n", mask
, cli_errstr(cli
));
908 ret_status
= cli_nt_error(cli
);
913 reset_do_list_queue();
917 /****************************************************************************
918 Get a directory listing.
919 ****************************************************************************/
921 static int cmd_dir(void)
923 TALLOC_CTX
*ctx
= talloc_tos();
924 uint16 attribute
= aDIR
| aSYSTEM
| aHIDDEN
;
931 mask
= talloc_strdup(ctx
, client_get_cur_dir());
936 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
938 if (*buf
== CLI_DIRSEP_CHAR
) {
939 mask
= talloc_strdup(ctx
, buf
);
941 mask
= talloc_asprintf_append(mask
, "%s", buf
);
944 mask
= talloc_asprintf_append(mask
, "*");
951 /* cwd is only used if showacls is on */
952 client_set_cwd(client_get_cur_dir());
955 status
= do_list(mask
, attribute
, display_finfo
, recurse
, true);
956 if (!NT_STATUS_IS_OK(status
)) {
962 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total
));
967 /****************************************************************************
968 Get a directory listing.
969 ****************************************************************************/
971 static int cmd_du(void)
973 TALLOC_CTX
*ctx
= talloc_tos();
974 uint16 attribute
= aDIR
| aSYSTEM
| aHIDDEN
;
981 mask
= talloc_strdup(ctx
, client_get_cur_dir());
985 if ((mask
[0] != '\0') && (mask
[strlen(mask
)-1]!=CLI_DIRSEP_CHAR
)) {
986 mask
= talloc_asprintf_append(mask
, "%s", CLI_DIRSEP_STR
);
992 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
994 if (*buf
== CLI_DIRSEP_CHAR
) {
995 mask
= talloc_strdup(ctx
, buf
);
997 mask
= talloc_asprintf_append(mask
, "%s", buf
);
1000 mask
= talloc_strdup(ctx
, "*");
1003 status
= do_list(mask
, attribute
, do_du
, recurse
, true);
1004 if (!NT_STATUS_IS_OK(status
)) {
1010 d_printf("Total number of bytes: %.0f\n", dir_total
);
1015 static int cmd_echo(void)
1017 TALLOC_CTX
*ctx
= talloc_tos();
1022 if (!next_token_talloc(ctx
, &cmd_ptr
, &num
, NULL
)
1023 || !next_token_talloc(ctx
, &cmd_ptr
, &data
, NULL
)) {
1024 d_printf("echo <num> <data>\n");
1028 status
= cli_echo(cli
, atoi(num
), data_blob_const(data
, strlen(data
)));
1030 if (!NT_STATUS_IS_OK(status
)) {
1031 d_printf("echo failed: %s\n", nt_errstr(status
));
1038 /****************************************************************************
1039 Get a file from rname to lname
1040 ****************************************************************************/
1042 static NTSTATUS
writefile_sink(char *buf
, size_t n
, void *priv
)
1044 int *pfd
= (int *)priv
;
1045 if (writefile(*pfd
, buf
, n
) == -1) {
1046 return map_nt_error_from_unix(errno
);
1048 return NT_STATUS_OK
;
1051 static int do_get(const char *rname
, const char *lname_in
, bool reget
)
1053 TALLOC_CTX
*ctx
= talloc_tos();
1056 bool newhandle
= false;
1057 struct timespec tp_start
;
1061 SMB_OFF_T nread
= 0;
1063 struct cli_state
*targetcli
= NULL
;
1064 char *targetname
= NULL
;
1068 lname
= talloc_strdup(ctx
, lname_in
);
1077 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, rname
, &targetcli
, &targetname
) ) {
1078 d_printf("Failed to open %s: %s\n", rname
, cli_errstr(cli
));
1082 clock_gettime_mono(&tp_start
);
1084 status
= cli_open(targetcli
, targetname
, O_RDONLY
, DENY_NONE
, &fnum
);
1085 if (!NT_STATUS_IS_OK(status
)) {
1086 d_printf("%s opening remote file %s\n", nt_errstr(status
),
1091 if(!strcmp(lname
,"-")) {
1092 handle
= fileno(stdout
);
1095 handle
= sys_open(lname
, O_WRONLY
|O_CREAT
, 0644);
1097 start
= sys_lseek(handle
, 0, SEEK_END
);
1099 d_printf("Error seeking local file\n");
1104 handle
= sys_open(lname
, O_WRONLY
|O_CREAT
|O_TRUNC
, 0644);
1109 d_printf("Error opening local file %s\n",lname
);
1114 status
= cli_qfileinfo_basic(targetcli
, fnum
, &attr
, &size
, NULL
, NULL
,
1116 if (!NT_STATUS_IS_OK(status
)) {
1117 status
= cli_getattrE(targetcli
, fnum
, &attr
, &size
, NULL
, NULL
,
1119 if(!NT_STATUS_IS_OK(status
)) {
1120 d_printf("getattrib: %s\n", nt_errstr(status
));
1125 DEBUG(1,("getting file %s of size %.0f as %s ",
1126 rname
, (double)size
, lname
));
1128 status
= cli_pull(targetcli
, fnum
, start
, size
, io_bufsize
,
1129 writefile_sink
, (void *)&handle
, &nread
);
1130 if (!NT_STATUS_IS_OK(status
)) {
1131 d_fprintf(stderr
, "parallel_read returned %s\n",
1133 cli_close(targetcli
, fnum
);
1137 status
= cli_close(targetcli
, fnum
);
1138 if (!NT_STATUS_IS_OK(status
)) {
1139 d_printf("Error %s closing remote file\n", nt_errstr(status
));
1147 if (archive_level
>= 2 && (attr
& aARCH
)) {
1148 cli_setatr(cli
, rname
, attr
& ~(uint16
)aARCH
, 0);
1152 struct timespec tp_end
;
1155 clock_gettime_mono(&tp_end
);
1156 this_time
= nsec_time_diff(&tp_end
,&tp_start
)/1000000;
1157 get_total_time_ms
+= this_time
;
1158 get_total_size
+= nread
;
1160 DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
1161 nread
/ (1.024*this_time
+ 1.0e-4),
1162 get_total_size
/ (1.024*get_total_time_ms
)));
1165 TALLOC_FREE(targetname
);
1169 /****************************************************************************
1171 ****************************************************************************/
1173 static int cmd_get(void)
1175 TALLOC_CTX
*ctx
= talloc_tos();
1180 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1185 if (!next_token_talloc(ctx
, &cmd_ptr
,&fname
,NULL
)) {
1186 d_printf("get <filename> [localname]\n");
1189 rname
= talloc_asprintf_append(rname
, "%s", fname
);
1193 rname
= clean_name(ctx
, rname
);
1198 next_token_talloc(ctx
, &cmd_ptr
,&lname
,NULL
);
1203 return do_get(rname
, lname
, false);
1206 /****************************************************************************
1207 Do an mget operation on one file.
1208 ****************************************************************************/
1210 static NTSTATUS
do_mget(struct cli_state
*cli_state
, struct file_info
*finfo
,
1213 TALLOC_CTX
*ctx
= talloc_tos();
1214 NTSTATUS status
= NT_STATUS_OK
;
1217 char *saved_curdir
= NULL
;
1218 char *mget_mask
= NULL
;
1219 char *new_cd
= NULL
;
1222 return NT_STATUS_OK
;
1225 if (strequal(finfo
->name
,".") || strequal(finfo
->name
,".."))
1226 return NT_STATUS_OK
;
1229 d_printf("mget aborted\n");
1230 return NT_STATUS_UNSUCCESSFUL
;
1233 if (finfo
->mode
& aDIR
) {
1234 if (asprintf(&quest
,
1235 "Get directory %s? ",finfo
->name
) < 0) {
1236 return NT_STATUS_NO_MEMORY
;
1239 if (asprintf(&quest
,
1240 "Get file %s? ",finfo
->name
) < 0) {
1241 return NT_STATUS_NO_MEMORY
;
1245 if (prompt
&& !yesno(quest
)) {
1247 return NT_STATUS_OK
;
1251 if (!(finfo
->mode
& aDIR
)) {
1252 rname
= talloc_asprintf(ctx
,
1254 client_get_cur_dir(),
1257 return NT_STATUS_NO_MEMORY
;
1259 do_get(rname
, finfo
->name
, false);
1261 return NT_STATUS_OK
;
1264 /* handle directories */
1265 saved_curdir
= talloc_strdup(ctx
, client_get_cur_dir());
1266 if (!saved_curdir
) {
1267 return NT_STATUS_NO_MEMORY
;
1270 new_cd
= talloc_asprintf(ctx
,
1272 client_get_cur_dir(),
1276 return NT_STATUS_NO_MEMORY
;
1278 client_set_cur_dir(new_cd
);
1280 string_replace(finfo
->name
,'\\','/');
1282 strlower_m(finfo
->name
);
1285 if (!directory_exist(finfo
->name
) &&
1286 mkdir(finfo
->name
,0777) != 0) {
1287 d_printf("failed to create directory %s\n",finfo
->name
);
1288 client_set_cur_dir(saved_curdir
);
1289 return map_nt_error_from_unix(errno
);
1292 if (chdir(finfo
->name
) != 0) {
1293 d_printf("failed to chdir to directory %s\n",finfo
->name
);
1294 client_set_cur_dir(saved_curdir
);
1295 return map_nt_error_from_unix(errno
);
1298 mget_mask
= talloc_asprintf(ctx
,
1300 client_get_cur_dir());
1303 return NT_STATUS_NO_MEMORY
;
1306 status
= do_list(mget_mask
, aSYSTEM
| aHIDDEN
| aDIR
,do_mget
,false, true);
1307 if (!NT_STATUS_IS_OK(status
)) {
1311 if (chdir("..") == -1) {
1312 d_printf("do_mget: failed to chdir to .. (error %s)\n",
1314 return map_nt_error_from_unix(errno
);
1316 client_set_cur_dir(saved_curdir
);
1317 TALLOC_FREE(mget_mask
);
1318 TALLOC_FREE(saved_curdir
);
1319 TALLOC_FREE(new_cd
);
1320 return NT_STATUS_OK
;
1323 /****************************************************************************
1324 View the file using the pager.
1325 ****************************************************************************/
1327 static int cmd_more(void)
1329 TALLOC_CTX
*ctx
= talloc_tos();
1333 char *pager_cmd
= NULL
;
1338 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1343 lname
= talloc_asprintf(ctx
, "%s/smbmore.XXXXXX",tmpdir());
1347 fd
= mkstemp(lname
);
1349 d_printf("failed to create temporary file for more\n");
1354 if (!next_token_talloc(ctx
, &cmd_ptr
,&fname
,NULL
)) {
1355 d_printf("more <filename>\n");
1359 rname
= talloc_asprintf_append(rname
, "%s", fname
);
1363 rname
= clean_name(ctx
,rname
);
1368 rc
= do_get(rname
, lname
, false);
1370 pager
=getenv("PAGER");
1372 pager_cmd
= talloc_asprintf(ctx
,
1374 (pager
? pager
:PAGER
),
1379 if (system(pager_cmd
) == -1) {
1380 d_printf("system command '%s' returned -1\n",
1388 /****************************************************************************
1390 ****************************************************************************/
1392 static int cmd_mget(void)
1394 TALLOC_CTX
*ctx
= talloc_tos();
1395 uint16 attribute
= aSYSTEM
| aHIDDEN
;
1396 char *mget_mask
= NULL
;
1398 NTSTATUS status
= NT_STATUS_OK
;
1406 while (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1408 mget_mask
= talloc_strdup(ctx
, client_get_cur_dir());
1412 if (*buf
== CLI_DIRSEP_CHAR
) {
1413 mget_mask
= talloc_strdup(ctx
, buf
);
1415 mget_mask
= talloc_asprintf_append(mget_mask
,
1421 status
= do_list(mget_mask
, attribute
, do_mget
, false, true);
1422 if (!NT_STATUS_IS_OK(status
)) {
1427 if (mget_mask
== NULL
) {
1428 d_printf("nothing to mget\n");
1433 mget_mask
= talloc_asprintf(ctx
,
1435 client_get_cur_dir());
1439 status
= do_list(mget_mask
, attribute
, do_mget
, false, true);
1440 if (!NT_STATUS_IS_OK(status
)) {
1448 /****************************************************************************
1449 Make a directory of name "name".
1450 ****************************************************************************/
1452 static bool do_mkdir(const char *name
)
1454 TALLOC_CTX
*ctx
= talloc_tos();
1455 struct cli_state
*targetcli
;
1456 char *targetname
= NULL
;
1459 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, name
, &targetcli
, &targetname
)) {
1460 d_printf("mkdir %s: %s\n", name
, cli_errstr(cli
));
1464 status
= cli_mkdir(targetcli
, targetname
);
1465 if (!NT_STATUS_IS_OK(status
)) {
1466 d_printf("%s making remote directory %s\n",
1467 nt_errstr(status
),name
);
1474 /****************************************************************************
1475 Show 8.3 name of a file.
1476 ****************************************************************************/
1478 static bool do_altname(const char *name
)
1483 status
= cli_qpathinfo_alt_name(cli
, name
, altname
);
1484 if (!NT_STATUS_IS_OK(status
)) {
1485 d_printf("%s getting alt name for %s\n",
1486 nt_errstr(status
),name
);
1489 d_printf("%s\n", altname
);
1494 /****************************************************************************
1496 ****************************************************************************/
1498 static int cmd_quit(void)
1506 /****************************************************************************
1508 ****************************************************************************/
1510 static int cmd_mkdir(void)
1512 TALLOC_CTX
*ctx
= talloc_tos();
1516 mask
= talloc_strdup(ctx
, client_get_cur_dir());
1521 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1523 d_printf("mkdir <dirname>\n");
1527 mask
= talloc_asprintf_append(mask
, "%s", buf
);
1535 struct cli_state
*targetcli
;
1536 char *targetname
= NULL
;
1540 ddir2
= talloc_strdup(ctx
, "");
1545 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
1549 ddir
= talloc_strdup(ctx
, targetname
);
1553 trim_char(ddir
,'.','\0');
1554 p
= strtok_r(ddir
, "/\\", &saveptr
);
1556 ddir2
= talloc_asprintf_append(ddir2
, "%s", p
);
1560 if (!NT_STATUS_IS_OK(cli_chkpath(targetcli
, ddir2
))) {
1563 ddir2
= talloc_asprintf_append(ddir2
, "%s", CLI_DIRSEP_STR
);
1567 p
= strtok_r(NULL
, "/\\", &saveptr
);
1576 /****************************************************************************
1578 ****************************************************************************/
1580 static int cmd_altname(void)
1582 TALLOC_CTX
*ctx
= talloc_tos();
1586 name
= talloc_strdup(ctx
, client_get_cur_dir());
1591 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
1592 d_printf("altname <file>\n");
1595 name
= talloc_asprintf_append(name
, "%s", buf
);
1603 static char *attr_str(TALLOC_CTX
*mem_ctx
, uint16_t mode
)
1605 char *attrs
= TALLOC_ZERO_ARRAY(mem_ctx
, char, 17);
1608 if (!(mode
& FILE_ATTRIBUTE_NORMAL
)) {
1609 if (mode
& FILE_ATTRIBUTE_ENCRYPTED
) {
1612 if (mode
& FILE_ATTRIBUTE_NONINDEXED
) {
1615 if (mode
& FILE_ATTRIBUTE_OFFLINE
) {
1618 if (mode
& FILE_ATTRIBUTE_COMPRESSED
) {
1621 if (mode
& FILE_ATTRIBUTE_REPARSE_POINT
) {
1624 if (mode
& FILE_ATTRIBUTE_SPARSE
) {
1627 if (mode
& FILE_ATTRIBUTE_TEMPORARY
) {
1630 if (mode
& FILE_ATTRIBUTE_NORMAL
) {
1633 if (mode
& FILE_ATTRIBUTE_READONLY
) {
1636 if (mode
& FILE_ATTRIBUTE_HIDDEN
) {
1639 if (mode
& FILE_ATTRIBUTE_SYSTEM
) {
1642 if (mode
& FILE_ATTRIBUTE_DIRECTORY
) {
1645 if (mode
& FILE_ATTRIBUTE_ARCHIVE
) {
1652 /****************************************************************************
1653 Show all info we can get
1654 ****************************************************************************/
1656 static int do_allinfo(const char *name
)
1659 struct timespec b_time
, a_time
, m_time
, c_time
;
1665 unsigned int num_streams
;
1666 struct stream_struct
*streams
;
1672 status
= cli_qpathinfo_alt_name(cli
, name
, altname
);
1673 if (!NT_STATUS_IS_OK(status
)) {
1674 d_printf("%s getting alt name for %s\n", nt_errstr(status
),
1678 d_printf("altname: %s\n", altname
);
1680 status
= cli_qpathinfo2(cli
, name
, &b_time
, &a_time
, &m_time
, &c_time
,
1681 &size
, &mode
, &ino
);
1682 if (!NT_STATUS_IS_OK(status
)) {
1683 d_printf("%s getting pathinfo for %s\n", nt_errstr(status
),
1688 unix_timespec_to_nt_time(&tmp
, b_time
);
1689 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1691 unix_timespec_to_nt_time(&tmp
, a_time
);
1692 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1694 unix_timespec_to_nt_time(&tmp
, m_time
);
1695 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1697 unix_timespec_to_nt_time(&tmp
, c_time
);
1698 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1700 d_printf("attributes: %s (%x)\n", attr_str(talloc_tos(), mode
), mode
);
1702 status
= cli_qpathinfo_streams(cli
, name
, talloc_tos(), &num_streams
,
1704 if (!NT_STATUS_IS_OK(status
)) {
1705 d_printf("%s getting streams for %s\n", nt_errstr(status
),
1710 for (i
=0; i
<num_streams
; i
++) {
1711 d_printf("stream: [%s], %lld bytes\n", streams
[i
].name
,
1712 (unsigned long long)streams
[i
].size
);
1715 status
= cli_ntcreate(cli
, name
, 0,
1716 CREATE_ACCESS_READ
, 0,
1717 FILE_SHARE_READ
|FILE_SHARE_WRITE
1719 FILE_OPEN
, 0x0, 0x0, &fnum
);
1720 if (!NT_STATUS_IS_OK(status
)) {
1722 * Ignore failure, it does not hurt if we can't list
1727 status
= cli_shadow_copy_data(talloc_tos(), cli
, fnum
,
1728 true, &snapshots
, &num_snapshots
);
1729 if (!NT_STATUS_IS_OK(status
)) {
1730 cli_close(cli
, fnum
);
1734 for (i
=0; i
<num_snapshots
; i
++) {
1737 d_printf("%s\n", snapshots
[i
]);
1738 snap_name
= talloc_asprintf(talloc_tos(), "%s%s",
1739 snapshots
[i
], name
);
1740 status
= cli_qpathinfo2(cli
, snap_name
, &b_time
, &a_time
,
1741 &m_time
, &c_time
, &size
,
1743 if (!NT_STATUS_IS_OK(status
)) {
1744 d_fprintf(stderr
, "pathinfo(%s) failed: %s\n",
1745 snap_name
, nt_errstr(status
));
1746 TALLOC_FREE(snap_name
);
1749 unix_timespec_to_nt_time(&tmp
, b_time
);
1750 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1751 unix_timespec_to_nt_time(&tmp
, a_time
);
1752 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1753 unix_timespec_to_nt_time(&tmp
, m_time
);
1754 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1755 unix_timespec_to_nt_time(&tmp
, c_time
);
1756 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1757 d_printf("size: %d\n", (int)size
);
1760 TALLOC_FREE(snapshots
);
1765 /****************************************************************************
1766 Show all info we can get
1767 ****************************************************************************/
1769 static int cmd_allinfo(void)
1771 TALLOC_CTX
*ctx
= talloc_tos();
1775 name
= talloc_strdup(ctx
, client_get_cur_dir());
1780 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
1781 d_printf("allinfo <file>\n");
1784 name
= talloc_asprintf_append(name
, "%s", buf
);
1794 /****************************************************************************
1796 ****************************************************************************/
1798 static int do_put(const char *rname
, const char *lname
, bool reput
)
1800 TALLOC_CTX
*ctx
= talloc_tos();
1803 SMB_OFF_T start
= 0;
1805 struct timespec tp_start
;
1806 struct cli_state
*targetcli
;
1807 char *targetname
= NULL
;
1808 struct push_state state
;
1811 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, rname
, &targetcli
, &targetname
)) {
1812 d_printf("Failed to open %s: %s\n", rname
, cli_errstr(cli
));
1816 clock_gettime_mono(&tp_start
);
1819 status
= cli_open(targetcli
, targetname
, O_RDWR
|O_CREAT
, DENY_NONE
, &fnum
);
1820 if (NT_STATUS_IS_OK(status
)) {
1821 if (!NT_STATUS_IS_OK(status
= cli_qfileinfo_basic(
1822 targetcli
, fnum
, NULL
,
1824 NULL
, NULL
, NULL
)) &&
1825 !NT_STATUS_IS_OK(status
= cli_getattrE(
1826 targetcli
, fnum
, NULL
,
1829 d_printf("getattrib: %s\n", nt_errstr(status
));
1834 status
= cli_open(targetcli
, targetname
, O_RDWR
|O_CREAT
|O_TRUNC
, DENY_NONE
, &fnum
);
1837 if (!NT_STATUS_IS_OK(status
)) {
1838 d_printf("%s opening remote file %s\n", nt_errstr(status
),
1843 /* allow files to be piped into smbclient
1846 Note that in this case this function will exit(0) rather
1848 if (!strcmp(lname
, "-")) {
1850 /* size of file is not known */
1852 f
= x_fopen(lname
,O_RDONLY
, 0);
1854 if (x_tseek(f
, start
, SEEK_SET
) == -1) {
1855 d_printf("Error seeking local file\n");
1863 d_printf("Error opening local file %s\n",lname
);
1867 DEBUG(1,("putting file %s as %s ",lname
,
1870 x_setvbuf(f
, NULL
, X_IOFBF
, io_bufsize
);
1875 status
= cli_push(targetcli
, fnum
, 0, 0, io_bufsize
, push_source
,
1877 if (!NT_STATUS_IS_OK(status
)) {
1878 d_fprintf(stderr
, "cli_push returned %s\n", nt_errstr(status
));
1882 status
= cli_close(targetcli
, fnum
);
1883 if (!NT_STATUS_IS_OK(status
)) {
1884 d_printf("%s closing remote file %s\n", nt_errstr(status
),
1897 struct timespec tp_end
;
1900 clock_gettime_mono(&tp_end
);
1901 this_time
= nsec_time_diff(&tp_end
,&tp_start
)/1000000;
1902 put_total_time_ms
+= this_time
;
1903 put_total_size
+= state
.nread
;
1905 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1906 state
.nread
/ (1.024*this_time
+ 1.0e-4),
1907 put_total_size
/ (1.024*put_total_time_ms
)));
1918 /****************************************************************************
1920 ****************************************************************************/
1922 static int cmd_put(void)
1924 TALLOC_CTX
*ctx
= talloc_tos();
1929 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1934 if (!next_token_talloc(ctx
, &cmd_ptr
,&lname
,NULL
)) {
1935 d_printf("put <filename>\n");
1939 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1940 rname
= talloc_asprintf_append(rname
, "%s", buf
);
1942 rname
= talloc_asprintf_append(rname
, "%s", lname
);
1948 rname
= clean_name(ctx
, rname
);
1955 /* allow '-' to represent stdin
1956 jdblair, 24.jun.98 */
1957 if (!file_exist_stat(lname
, &st
, false) &&
1958 (strcmp(lname
,"-"))) {
1959 d_printf("%s does not exist\n",lname
);
1964 return do_put(rname
, lname
, false);
1967 /*************************************
1968 File list structure.
1969 *************************************/
1971 static struct file_list
{
1972 struct file_list
*prev
, *next
;
1977 /****************************************************************************
1978 Free a file_list structure.
1979 ****************************************************************************/
1981 static void free_file_list (struct file_list
*l_head
)
1983 struct file_list
*list
, *next
;
1985 for (list
= l_head
; list
; list
= next
) {
1987 DLIST_REMOVE(l_head
, list
);
1988 SAFE_FREE(list
->file_path
);
1993 /****************************************************************************
1994 Seek in a directory/file list until you get something that doesn't start with
1996 ****************************************************************************/
1998 static bool seek_list(struct file_list
*list
, char *name
)
2001 trim_string(list
->file_path
,"./","\n");
2002 if (strncmp(list
->file_path
, name
, strlen(name
)) != 0) {
2011 /****************************************************************************
2012 Set the file selection mask.
2013 ****************************************************************************/
2015 static int cmd_select(void)
2017 TALLOC_CTX
*ctx
= talloc_tos();
2018 char *new_fs
= NULL
;
2019 next_token_talloc(ctx
, &cmd_ptr
,&new_fs
,NULL
)
2022 client_set_fileselection(new_fs
);
2024 client_set_fileselection("");
2029 /****************************************************************************
2030 Recursive file matching function act as find
2031 match must be always set to true when calling this function
2032 ****************************************************************************/
2034 static int file_find(struct file_list
**list
, const char *directory
,
2035 const char *expression
, bool match
)
2037 SMB_STRUCT_DIR
*dir
;
2038 struct file_list
*entry
;
2039 struct stat statbuf
;
2045 dir
= sys_opendir(directory
);
2049 while ((dname
= readdirname(dir
))) {
2050 if (!strcmp("..", dname
))
2052 if (!strcmp(".", dname
))
2055 if (asprintf(&path
, "%s/%s", directory
, dname
) <= 0) {
2060 if (!match
|| !gen_fnmatch(expression
, dname
)) {
2062 ret
= stat(path
, &statbuf
);
2064 if (S_ISDIR(statbuf
.st_mode
)) {
2066 ret
= file_find(list
, path
, expression
, false);
2069 d_printf("file_find: cannot stat file %s\n", path
);
2078 entry
= SMB_MALLOC_P(struct file_list
);
2080 d_printf("Out of memory in file_find\n");
2084 entry
->file_path
= path
;
2085 entry
->isdir
= isdir
;
2086 DLIST_ADD(*list
, entry
);
2096 /****************************************************************************
2098 ****************************************************************************/
2100 static int cmd_mput(void)
2102 TALLOC_CTX
*ctx
= talloc_tos();
2105 while (next_token_talloc(ctx
, &cmd_ptr
,&p
,NULL
)) {
2107 struct file_list
*temp_list
;
2108 char *quest
, *lname
, *rname
;
2112 ret
= file_find(&file_list
, ".", p
, true);
2114 free_file_list(file_list
);
2122 for (temp_list
= file_list
; temp_list
;
2123 temp_list
= temp_list
->next
) {
2126 if (asprintf(&lname
, "%s/", temp_list
->file_path
) <= 0) {
2129 trim_string(lname
, "./", "/");
2131 /* check if it's a directory */
2132 if (temp_list
->isdir
) {
2133 /* if (!recurse) continue; */
2136 if (asprintf(&quest
, "Put directory %s? ", lname
) < 0) {
2139 if (prompt
&& !yesno(quest
)) { /* No */
2140 /* Skip the directory */
2141 lname
[strlen(lname
)-1] = '/';
2142 if (!seek_list(temp_list
, lname
))
2146 if(asprintf(&rname
, "%s%s", client_get_cur_dir(), lname
) < 0) {
2149 normalize_name(rname
);
2150 if (!NT_STATUS_IS_OK(cli_chkpath(cli
, rname
)) &&
2152 DEBUG (0, ("Unable to make dir, skipping..."));
2153 /* Skip the directory */
2154 lname
[strlen(lname
)-1] = '/';
2155 if (!seek_list(temp_list
, lname
)) {
2163 if (asprintf(&quest
,"Put file %s? ", lname
) < 0) {
2166 if (prompt
&& !yesno(quest
)) {
2173 if (asprintf(&rname
, "%s%s", client_get_cur_dir(), lname
) < 0) {
2178 normalize_name(rname
);
2180 do_put(rname
, lname
, false);
2182 free_file_list(file_list
);
2191 /****************************************************************************
2193 ****************************************************************************/
2195 static int do_cancel(int job
)
2197 if (cli_printjob_del(cli
, job
)) {
2198 d_printf("Job %d cancelled\n",job
);
2201 d_printf("Error cancelling job %d : %s\n",job
,cli_errstr(cli
));
2206 /****************************************************************************
2208 ****************************************************************************/
2210 static int cmd_cancel(void)
2212 TALLOC_CTX
*ctx
= talloc_tos();
2216 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
,NULL
)) {
2217 d_printf("cancel <jobid> ...\n");
2223 } while (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
));
2228 /****************************************************************************
2230 ****************************************************************************/
2232 static int cmd_print(void)
2234 TALLOC_CTX
*ctx
= talloc_tos();
2239 if (!next_token_talloc(ctx
, &cmd_ptr
, &lname
,NULL
)) {
2240 d_printf("print <filename>\n");
2244 rname
= talloc_strdup(ctx
, lname
);
2248 p
= strrchr_m(rname
,'/');
2250 rname
= talloc_asprintf(ctx
,
2255 if (strequal(lname
,"-")) {
2256 rname
= talloc_asprintf(ctx
,
2264 return do_put(rname
, lname
, false);
2267 /****************************************************************************
2268 Show a print queue entry.
2269 ****************************************************************************/
2271 static void queue_fn(struct print_job_info
*p
)
2273 d_printf("%-6d %-9d %s\n", (int)p
->id
, (int)p
->size
, p
->name
);
2276 /****************************************************************************
2278 ****************************************************************************/
2280 static int cmd_queue(void)
2282 cli_print_queue(cli
, queue_fn
);
2286 /****************************************************************************
2288 ****************************************************************************/
2290 static NTSTATUS
do_del(struct cli_state
*cli_state
, struct file_info
*finfo
,
2293 TALLOC_CTX
*ctx
= talloc_tos();
2297 mask
= talloc_asprintf(ctx
,
2303 return NT_STATUS_NO_MEMORY
;
2306 if (finfo
->mode
& aDIR
) {
2308 return NT_STATUS_OK
;
2311 status
= cli_unlink(cli_state
, mask
, aSYSTEM
| aHIDDEN
);
2312 if (!NT_STATUS_IS_OK(status
)) {
2313 d_printf("%s deleting remote file %s\n",
2314 nt_errstr(status
), mask
);
2320 /****************************************************************************
2322 ****************************************************************************/
2324 static int cmd_del(void)
2326 TALLOC_CTX
*ctx
= talloc_tos();
2329 NTSTATUS status
= NT_STATUS_OK
;
2330 uint16 attribute
= aSYSTEM
| aHIDDEN
;
2336 mask
= talloc_strdup(ctx
, client_get_cur_dir());
2340 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2341 d_printf("del <filename>\n");
2344 mask
= talloc_asprintf_append(mask
, "%s", buf
);
2349 status
= do_list(mask
,attribute
,do_del
,false,false);
2350 if (!NT_STATUS_IS_OK(status
)) {
2356 /****************************************************************************
2357 Wildcard delete some files.
2358 ****************************************************************************/
2360 static int cmd_wdel(void)
2362 TALLOC_CTX
*ctx
= talloc_tos();
2366 struct cli_state
*targetcli
;
2367 char *targetname
= NULL
;
2370 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2371 d_printf("wdel 0x<attrib> <wcard>\n");
2375 attribute
= (uint16
)strtol(buf
, (char **)NULL
, 16);
2377 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2378 d_printf("wdel 0x<attrib> <wcard>\n");
2382 mask
= talloc_asprintf(ctx
, "%s%s",
2383 client_get_cur_dir(),
2389 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2390 d_printf("cmd_wdel %s: %s\n", mask
, cli_errstr(cli
));
2394 status
= cli_unlink(targetcli
, targetname
, attribute
);
2395 if (!NT_STATUS_IS_OK(status
)) {
2396 d_printf("%s deleting remote files %s\n", nt_errstr(status
),
2402 /****************************************************************************
2403 ****************************************************************************/
2405 static int cmd_open(void)
2407 TALLOC_CTX
*ctx
= talloc_tos();
2410 char *targetname
= NULL
;
2411 struct cli_state
*targetcli
;
2412 uint16_t fnum
= (uint16_t)-1;
2414 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2415 d_printf("open <filename>\n");
2418 mask
= talloc_asprintf(ctx
,
2420 client_get_cur_dir(),
2426 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2427 d_printf("open %s: %s\n", mask
, cli_errstr(cli
));
2431 if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli
, targetname
, 0,
2432 FILE_READ_DATA
|FILE_WRITE_DATA
, 0,
2433 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
, 0x0, 0x0, &fnum
))) {
2434 if (NT_STATUS_IS_OK(cli_ntcreate(targetcli
, targetname
, 0,
2436 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
, 0x0, 0x0, &fnum
))) {
2437 d_printf("open file %s: for read/write fnum %d\n", targetname
, fnum
);
2439 d_printf("Failed to open file %s. %s\n", targetname
, cli_errstr(cli
));
2442 d_printf("open file %s: for read/write fnum %d\n", targetname
, fnum
);
2447 static int cmd_posix_encrypt(void)
2449 TALLOC_CTX
*ctx
= talloc_tos();
2450 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
2452 if (cli
->use_kerberos
) {
2453 status
= cli_gss_smb_encryption_start(cli
);
2455 char *domain
= NULL
;
2457 char *password
= NULL
;
2459 if (!next_token_talloc(ctx
, &cmd_ptr
,&domain
,NULL
)) {
2460 d_printf("posix_encrypt domain user password\n");
2464 if (!next_token_talloc(ctx
, &cmd_ptr
,&user
,NULL
)) {
2465 d_printf("posix_encrypt domain user password\n");
2469 if (!next_token_talloc(ctx
, &cmd_ptr
,&password
,NULL
)) {
2470 d_printf("posix_encrypt domain user password\n");
2474 status
= cli_raw_ntlm_smb_encryption_start(cli
,
2480 if (!NT_STATUS_IS_OK(status
)) {
2481 d_printf("posix_encrypt failed with error %s\n", nt_errstr(status
));
2483 d_printf("encryption on\n");
2490 /****************************************************************************
2491 ****************************************************************************/
2493 static int cmd_posix_open(void)
2495 TALLOC_CTX
*ctx
= talloc_tos();
2498 char *targetname
= NULL
;
2499 struct cli_state
*targetcli
;
2503 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2504 d_printf("posix_open <filename> 0<mode>\n");
2507 mask
= talloc_asprintf(ctx
,
2509 client_get_cur_dir(),
2515 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2516 d_printf("posix_open <filename> 0<mode>\n");
2519 mode
= (mode_t
)strtol(buf
, (char **)NULL
, 8);
2521 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2522 d_printf("posix_open %s: %s\n", mask
, cli_errstr(cli
));
2526 if (!NT_STATUS_IS_OK(cli_posix_open(targetcli
, targetname
, O_CREAT
|O_RDWR
, mode
, &fnum
))) {
2527 if (!NT_STATUS_IS_OK(cli_posix_open(targetcli
, targetname
, O_CREAT
|O_RDONLY
, mode
, &fnum
))) {
2528 d_printf("posix_open file %s: for read/write fnum %d\n", targetname
, fnum
);
2530 d_printf("Failed to open file %s. %s\n", targetname
, cli_errstr(cli
));
2533 d_printf("posix_open file %s: for read/write fnum %d\n", targetname
, fnum
);
2539 static int cmd_posix_mkdir(void)
2541 TALLOC_CTX
*ctx
= talloc_tos();
2544 char *targetname
= NULL
;
2545 struct cli_state
*targetcli
;
2548 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2549 d_printf("posix_mkdir <filename> 0<mode>\n");
2552 mask
= talloc_asprintf(ctx
,
2554 client_get_cur_dir(),
2560 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2561 d_printf("posix_mkdir <filename> 0<mode>\n");
2564 mode
= (mode_t
)strtol(buf
, (char **)NULL
, 8);
2566 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2567 d_printf("posix_mkdir %s: %s\n", mask
, cli_errstr(cli
));
2571 if (!NT_STATUS_IS_OK(cli_posix_mkdir(targetcli
, targetname
, mode
))) {
2572 d_printf("Failed to open file %s. %s\n", targetname
, cli_errstr(cli
));
2574 d_printf("posix_mkdir created directory %s\n", targetname
);
2579 static int cmd_posix_unlink(void)
2581 TALLOC_CTX
*ctx
= talloc_tos();
2584 char *targetname
= NULL
;
2585 struct cli_state
*targetcli
;
2587 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2588 d_printf("posix_unlink <filename>\n");
2591 mask
= talloc_asprintf(ctx
,
2593 client_get_cur_dir(),
2599 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2600 d_printf("posix_unlink %s: %s\n", mask
, cli_errstr(cli
));
2604 if (!NT_STATUS_IS_OK(cli_posix_unlink(targetcli
, targetname
))) {
2605 d_printf("Failed to unlink file %s. %s\n", targetname
, cli_errstr(cli
));
2607 d_printf("posix_unlink deleted file %s\n", targetname
);
2613 static int cmd_posix_rmdir(void)
2615 TALLOC_CTX
*ctx
= talloc_tos();
2618 char *targetname
= NULL
;
2619 struct cli_state
*targetcli
;
2621 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2622 d_printf("posix_rmdir <filename>\n");
2625 mask
= talloc_asprintf(ctx
,
2627 client_get_cur_dir(),
2633 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2634 d_printf("posix_rmdir %s: %s\n", mask
, cli_errstr(cli
));
2638 if (!NT_STATUS_IS_OK(cli_posix_rmdir(targetcli
, targetname
))) {
2639 d_printf("Failed to unlink directory %s. %s\n", targetname
, cli_errstr(cli
));
2641 d_printf("posix_rmdir deleted directory %s\n", targetname
);
2647 static int cmd_close(void)
2649 TALLOC_CTX
*ctx
= talloc_tos();
2653 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2654 d_printf("close <fnum>\n");
2659 /* We really should use the targetcli here.... */
2660 if (!NT_STATUS_IS_OK(cli_close(cli
, fnum
))) {
2661 d_printf("close %d: %s\n", fnum
, cli_errstr(cli
));
2667 static int cmd_posix(void)
2669 TALLOC_CTX
*ctx
= talloc_tos();
2670 uint16 major
, minor
;
2671 uint32 caplow
, caphigh
;
2675 if (!SERVER_HAS_UNIX_CIFS(cli
)) {
2676 d_printf("Server doesn't support UNIX CIFS extensions.\n");
2680 status
= cli_unix_extensions_version(cli
, &major
, &minor
, &caplow
,
2682 if (!NT_STATUS_IS_OK(status
)) {
2683 d_printf("Can't get UNIX CIFS extensions version from "
2684 "server: %s\n", nt_errstr(status
));
2688 d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major
, (unsigned int)minor
);
2690 caps
= talloc_strdup(ctx
, "");
2694 if (caplow
& CIFS_UNIX_FCNTL_LOCKS_CAP
) {
2695 caps
= talloc_asprintf_append(caps
, "locks ");
2700 if (caplow
& CIFS_UNIX_POSIX_ACLS_CAP
) {
2701 caps
= talloc_asprintf_append(caps
, "acls ");
2706 if (caplow
& CIFS_UNIX_XATTTR_CAP
) {
2707 caps
= talloc_asprintf_append(caps
, "eas ");
2712 if (caplow
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2713 caps
= talloc_asprintf_append(caps
, "pathnames ");
2718 if (caplow
& CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
) {
2719 caps
= talloc_asprintf_append(caps
, "posix_path_operations ");
2724 if (caplow
& CIFS_UNIX_LARGE_READ_CAP
) {
2725 caps
= talloc_asprintf_append(caps
, "large_read ");
2730 if (caplow
& CIFS_UNIX_LARGE_WRITE_CAP
) {
2731 caps
= talloc_asprintf_append(caps
, "large_write ");
2736 if (caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
) {
2737 caps
= talloc_asprintf_append(caps
, "posix_encrypt ");
2742 if (caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
) {
2743 caps
= talloc_asprintf_append(caps
, "mandatory_posix_encrypt ");
2749 if (*caps
&& caps
[strlen(caps
)-1] == ' ') {
2750 caps
[strlen(caps
)-1] = '\0';
2753 d_printf("Server supports CIFS capabilities %s\n", caps
);
2755 status
= cli_set_unix_extensions_capabilities(cli
, major
, minor
,
2757 if (!NT_STATUS_IS_OK(status
)) {
2758 d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n",
2763 if (caplow
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2764 CLI_DIRSEP_CHAR
= '/';
2765 *CLI_DIRSEP_STR
= '/';
2766 client_set_cur_dir(CLI_DIRSEP_STR
);
2772 static int cmd_lock(void)
2774 TALLOC_CTX
*ctx
= talloc_tos();
2776 uint64_t start
, len
;
2777 enum brl_type lock_type
;
2780 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2781 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2786 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2787 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2791 if (*buf
== 'r' || *buf
== 'R') {
2792 lock_type
= READ_LOCK
;
2793 } else if (*buf
== 'w' || *buf
== 'W') {
2794 lock_type
= WRITE_LOCK
;
2796 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2800 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2801 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2805 start
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2807 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2808 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2812 len
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2814 if (!NT_STATUS_IS_OK(cli_posix_lock(cli
, fnum
, start
, len
, true, lock_type
))) {
2815 d_printf("lock failed %d: %s\n", fnum
, cli_errstr(cli
));
2821 static int cmd_unlock(void)
2823 TALLOC_CTX
*ctx
= talloc_tos();
2825 uint64_t start
, len
;
2828 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2829 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2834 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2835 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2839 start
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2841 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2842 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2846 len
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2848 if (!NT_STATUS_IS_OK(cli_posix_unlock(cli
, fnum
, start
, len
))) {
2849 d_printf("unlock failed %d: %s\n", fnum
, cli_errstr(cli
));
2856 /****************************************************************************
2858 ****************************************************************************/
2860 static int cmd_rmdir(void)
2862 TALLOC_CTX
*ctx
= talloc_tos();
2865 char *targetname
= NULL
;
2866 struct cli_state
*targetcli
;
2868 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2869 d_printf("rmdir <dirname>\n");
2872 mask
= talloc_asprintf(ctx
,
2874 client_get_cur_dir(),
2880 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2881 d_printf("rmdir %s: %s\n", mask
, cli_errstr(cli
));
2885 if (!NT_STATUS_IS_OK(cli_rmdir(targetcli
, targetname
))) {
2886 d_printf("%s removing remote directory file %s\n",
2887 cli_errstr(targetcli
),mask
);
2893 /****************************************************************************
2895 ****************************************************************************/
2897 static int cmd_link(void)
2899 TALLOC_CTX
*ctx
= talloc_tos();
2900 char *oldname
= NULL
;
2901 char *newname
= NULL
;
2904 char *targetname
= NULL
;
2905 struct cli_state
*targetcli
;
2907 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
2908 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
2909 d_printf("link <oldname> <newname>\n");
2912 oldname
= talloc_asprintf(ctx
,
2914 client_get_cur_dir(),
2919 newname
= talloc_asprintf(ctx
,
2921 client_get_cur_dir(),
2927 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, oldname
, &targetcli
, &targetname
)) {
2928 d_printf("link %s: %s\n", oldname
, cli_errstr(cli
));
2932 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
2933 d_printf("Server doesn't support UNIX CIFS calls.\n");
2937 if (!NT_STATUS_IS_OK(cli_posix_hardlink(targetcli
, targetname
, newname
))) {
2938 d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli
), newname
, oldname
);
2944 /****************************************************************************
2946 ****************************************************************************/
2948 static int cmd_readlink(void)
2950 TALLOC_CTX
*ctx
= talloc_tos();
2953 char *targetname
= NULL
;
2954 char linkname
[PATH_MAX
+1];
2955 struct cli_state
*targetcli
;
2957 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2958 d_printf("readlink <name>\n");
2961 name
= talloc_asprintf(ctx
,
2963 client_get_cur_dir(),
2969 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, name
, &targetcli
, &targetname
)) {
2970 d_printf("readlink %s: %s\n", name
, cli_errstr(cli
));
2974 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
2975 d_printf("Server doesn't support UNIX CIFS calls.\n");
2979 if (!NT_STATUS_IS_OK(cli_posix_readlink(targetcli
, name
,
2980 linkname
, PATH_MAX
+1))) {
2981 d_printf("%s readlink on file %s\n",
2982 cli_errstr(targetcli
), name
);
2986 d_printf("%s -> %s\n", name
, linkname
);
2992 /****************************************************************************
2994 ****************************************************************************/
2996 static int cmd_symlink(void)
2998 TALLOC_CTX
*ctx
= talloc_tos();
2999 char *oldname
= NULL
;
3000 char *newname
= NULL
;
3003 struct cli_state
*newcli
;
3005 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3006 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3007 d_printf("symlink <oldname> <newname>\n");
3010 /* Oldname (link target) must be an untouched blob. */
3013 newname
= talloc_asprintf(ctx
,
3015 client_get_cur_dir(),
3021 /* New name must be present in share namespace. */
3022 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, newname
, &newcli
, &newname
)) {
3023 d_printf("link %s: %s\n", oldname
, cli_errstr(cli
));
3027 if (!SERVER_HAS_UNIX_CIFS(newcli
)) {
3028 d_printf("Server doesn't support UNIX CIFS calls.\n");
3032 if (!NT_STATUS_IS_OK(cli_posix_symlink(newcli
, oldname
, newname
))) {
3033 d_printf("%s symlinking files (%s -> %s)\n",
3034 cli_errstr(newcli
), newname
, newname
);
3041 /****************************************************************************
3043 ****************************************************************************/
3045 static int cmd_chmod(void)
3047 TALLOC_CTX
*ctx
= talloc_tos();
3051 char *targetname
= NULL
;
3052 struct cli_state
*targetcli
;
3055 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3056 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3057 d_printf("chmod mode file\n");
3060 src
= talloc_asprintf(ctx
,
3062 client_get_cur_dir(),
3068 mode
= (mode_t
)strtol(buf
, NULL
, 8);
3070 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3071 d_printf("chmod %s: %s\n", src
, cli_errstr(cli
));
3075 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3076 d_printf("Server doesn't support UNIX CIFS calls.\n");
3080 if (!NT_STATUS_IS_OK(cli_posix_chmod(targetcli
, targetname
, mode
))) {
3081 d_printf("%s chmod file %s 0%o\n",
3082 cli_errstr(targetcli
), src
, (unsigned int)mode
);
3089 static const char *filetype_to_str(mode_t mode
)
3091 if (S_ISREG(mode
)) {
3092 return "regular file";
3093 } else if (S_ISDIR(mode
)) {
3097 if (S_ISCHR(mode
)) {
3098 return "character device";
3102 if (S_ISBLK(mode
)) {
3103 return "block device";
3107 if (S_ISFIFO(mode
)) {
3112 if (S_ISLNK(mode
)) {
3113 return "symbolic link";
3117 if (S_ISSOCK(mode
)) {
3124 static char rwx_to_str(mode_t m
, mode_t bt
, char ret
)
3133 static char *unix_mode_to_str(char *s
, mode_t m
)
3136 const char *str
= filetype_to_str(m
);
3152 *p
++ = str
[1] == 'y' ? 'l' : 's';
3159 *p
++ = rwx_to_str(m
, S_IRUSR
, 'r');
3160 *p
++ = rwx_to_str(m
, S_IWUSR
, 'w');
3161 *p
++ = rwx_to_str(m
, S_IXUSR
, 'x');
3162 *p
++ = rwx_to_str(m
, S_IRGRP
, 'r');
3163 *p
++ = rwx_to_str(m
, S_IWGRP
, 'w');
3164 *p
++ = rwx_to_str(m
, S_IXGRP
, 'x');
3165 *p
++ = rwx_to_str(m
, S_IROTH
, 'r');
3166 *p
++ = rwx_to_str(m
, S_IWOTH
, 'w');
3167 *p
++ = rwx_to_str(m
, S_IXOTH
, 'x');
3172 /****************************************************************************
3173 Utility function for UNIX getfacl.
3174 ****************************************************************************/
3176 static char *perms_to_string(fstring permstr
, unsigned char perms
)
3178 fstrcpy(permstr
, "---");
3179 if (perms
& SMB_POSIX_ACL_READ
) {
3182 if (perms
& SMB_POSIX_ACL_WRITE
) {
3185 if (perms
& SMB_POSIX_ACL_EXECUTE
) {
3191 /****************************************************************************
3193 ****************************************************************************/
3195 static int cmd_getfacl(void)
3197 TALLOC_CTX
*ctx
= talloc_tos();
3200 char *targetname
= NULL
;
3201 struct cli_state
*targetcli
;
3202 uint16 major
, minor
;
3203 uint32 caplow
, caphigh
;
3204 char *retbuf
= NULL
;
3206 SMB_STRUCT_STAT sbuf
;
3207 uint16 num_file_acls
= 0;
3208 uint16 num_dir_acls
= 0;
3212 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3213 d_printf("getfacl filename\n");
3216 src
= talloc_asprintf(ctx
,
3218 client_get_cur_dir(),
3224 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3225 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3229 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3230 d_printf("Server doesn't support UNIX CIFS calls.\n");
3234 status
= cli_unix_extensions_version(targetcli
, &major
, &minor
,
3236 if (!NT_STATUS_IS_OK(status
)) {
3237 d_printf("Can't get UNIX CIFS version from server: %s.\n",
3242 if (!(caplow
& CIFS_UNIX_POSIX_ACLS_CAP
)) {
3243 d_printf("This server supports UNIX extensions "
3244 "but doesn't support POSIX ACLs.\n");
3248 if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli
, targetname
, &sbuf
))) {
3249 d_printf("%s getfacl doing a stat on file %s\n",
3250 cli_errstr(targetcli
), src
);
3254 if (!NT_STATUS_IS_OK(cli_posix_getfacl(targetcli
, targetname
, ctx
, &rb_size
, &retbuf
))) {
3255 d_printf("%s getfacl file %s\n",
3256 cli_errstr(targetcli
), src
);
3260 /* ToDo : Print out the ACL values. */
3261 if (rb_size
< 6 || SVAL(retbuf
,0) != SMB_POSIX_ACL_VERSION
) {
3262 d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
3263 src
, (unsigned int)CVAL(retbuf
,0) );
3267 num_file_acls
= SVAL(retbuf
,2);
3268 num_dir_acls
= SVAL(retbuf
,4);
3269 if (rb_size
!= SMB_POSIX_ACL_HEADER_SIZE
+ SMB_POSIX_ACL_ENTRY_SIZE
*(num_file_acls
+num_dir_acls
)) {
3270 d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
3272 (unsigned int)(SMB_POSIX_ACL_HEADER_SIZE
+ SMB_POSIX_ACL_ENTRY_SIZE
*(num_file_acls
+num_dir_acls
)),
3273 (unsigned int)rb_size
);
3277 d_printf("# file: %s\n", src
);
3278 d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf
.st_ex_uid
, (unsigned int)sbuf
.st_ex_gid
);
3280 if (num_file_acls
== 0 && num_dir_acls
== 0) {
3281 d_printf("No acls found.\n");
3284 for (i
= 0; i
< num_file_acls
; i
++) {
3287 unsigned char tagtype
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
));
3288 unsigned char perms
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+1);
3291 case SMB_POSIX_ACL_USER_OBJ
:
3294 case SMB_POSIX_ACL_USER
:
3295 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3296 d_printf("user:%u:", uorg
);
3298 case SMB_POSIX_ACL_GROUP_OBJ
:
3299 d_printf("group::");
3301 case SMB_POSIX_ACL_GROUP
:
3302 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3303 d_printf("group:%u:", uorg
);
3305 case SMB_POSIX_ACL_MASK
:
3308 case SMB_POSIX_ACL_OTHER
:
3309 d_printf("other::");
3312 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3313 src
, (unsigned int)tagtype
);
3318 d_printf("%s\n", perms_to_string(permstring
, perms
));
3321 for (i
= 0; i
< num_dir_acls
; i
++) {
3324 unsigned char tagtype
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
));
3325 unsigned char perms
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+1);
3328 case SMB_POSIX_ACL_USER_OBJ
:
3329 d_printf("default:user::");
3331 case SMB_POSIX_ACL_USER
:
3332 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3333 d_printf("default:user:%u:", uorg
);
3335 case SMB_POSIX_ACL_GROUP_OBJ
:
3336 d_printf("default:group::");
3338 case SMB_POSIX_ACL_GROUP
:
3339 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3340 d_printf("default:group:%u:", uorg
);
3342 case SMB_POSIX_ACL_MASK
:
3343 d_printf("default:mask::");
3345 case SMB_POSIX_ACL_OTHER
:
3346 d_printf("default:other::");
3349 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3350 src
, (unsigned int)tagtype
);
3355 d_printf("%s\n", perms_to_string(permstring
, perms
));
3361 static void printf_cb(const char *buf
, void *private_data
)
3366 /****************************************************************************
3367 Get the EA list of a file
3368 ****************************************************************************/
3370 static int cmd_geteas(void)
3372 TALLOC_CTX
*ctx
= talloc_tos();
3375 char *targetname
= NULL
;
3376 struct cli_state
*targetcli
;
3379 struct ea_struct
*eas
;
3381 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3382 d_printf("geteas filename\n");
3385 src
= talloc_asprintf(ctx
,
3387 client_get_cur_dir(),
3393 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
,
3395 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3399 status
= cli_get_ea_list_path(targetcli
, targetname
, talloc_tos(),
3401 if (!NT_STATUS_IS_OK(status
)) {
3402 d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status
));
3406 for (i
=0; i
<num_eas
; i
++) {
3407 d_printf("%s (%d) =\n", eas
[i
].name
, (int)eas
[i
].flags
);
3408 dump_data_cb(eas
[i
].value
.data
, eas
[i
].value
.length
, false,
3418 /****************************************************************************
3420 ****************************************************************************/
3422 static int cmd_setea(void)
3424 TALLOC_CTX
*ctx
= talloc_tos();
3427 char *eaname
= NULL
;
3428 char *eavalue
= NULL
;
3429 char *targetname
= NULL
;
3430 struct cli_state
*targetcli
;
3433 if (!next_token_talloc(ctx
, &cmd_ptr
, &name
, NULL
)
3434 || !next_token_talloc(ctx
, &cmd_ptr
, &eaname
, NULL
)) {
3435 d_printf("setea filename eaname value\n");
3438 if (!next_token_talloc(ctx
, &cmd_ptr
, &eavalue
, NULL
)) {
3439 eavalue
= talloc_strdup(ctx
, "");
3441 src
= talloc_asprintf(ctx
,
3443 client_get_cur_dir(),
3449 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
,
3451 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3455 status
= cli_set_ea_path(targetcli
, targetname
, eaname
, eavalue
,
3457 if (!NT_STATUS_IS_OK(status
)) {
3458 d_printf("set_ea %s: %s\n", src
, nt_errstr(status
));
3465 /****************************************************************************
3467 ****************************************************************************/
3469 static int cmd_stat(void)
3471 TALLOC_CTX
*ctx
= talloc_tos();
3474 char *targetname
= NULL
;
3475 struct cli_state
*targetcli
;
3477 SMB_STRUCT_STAT sbuf
;
3481 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3482 d_printf("stat file\n");
3485 src
= talloc_asprintf(ctx
,
3487 client_get_cur_dir(),
3493 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3494 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3498 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3499 d_printf("Server doesn't support UNIX CIFS calls.\n");
3503 if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli
, targetname
, &sbuf
))) {
3504 d_printf("%s stat file %s\n",
3505 cli_errstr(targetcli
), src
);
3509 /* Print out the stat values. */
3510 d_printf("File: %s\n", src
);
3511 d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
3512 (double)sbuf
.st_ex_size
,
3513 (unsigned int)sbuf
.st_ex_blocks
,
3514 filetype_to_str(sbuf
.st_ex_mode
));
3516 #if defined(S_ISCHR) && defined(S_ISBLK)
3517 if (S_ISCHR(sbuf
.st_ex_mode
) || S_ISBLK(sbuf
.st_ex_mode
)) {
3518 d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
3519 (double)sbuf
.st_ex_ino
,
3520 (unsigned int)sbuf
.st_ex_nlink
,
3521 unix_dev_major(sbuf
.st_ex_rdev
),
3522 unix_dev_minor(sbuf
.st_ex_rdev
));
3525 d_printf("Inode: %.0f\tLinks: %u\n",
3526 (double)sbuf
.st_ex_ino
,
3527 (unsigned int)sbuf
.st_ex_nlink
);
3529 d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
3530 ((int)sbuf
.st_ex_mode
& 0777),
3531 unix_mode_to_str(mode_str
, sbuf
.st_ex_mode
),
3532 (unsigned int)sbuf
.st_ex_uid
,
3533 (unsigned int)sbuf
.st_ex_gid
);
3535 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_atime
);
3536 lt
= localtime(&tmp_time
);
3538 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3540 fstrcpy(mode_str
, "unknown");
3542 d_printf("Access: %s\n", mode_str
);
3544 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_mtime
);
3545 lt
= localtime(&tmp_time
);
3547 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3549 fstrcpy(mode_str
, "unknown");
3551 d_printf("Modify: %s\n", mode_str
);
3553 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_ctime
);
3554 lt
= localtime(&tmp_time
);
3556 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3558 fstrcpy(mode_str
, "unknown");
3560 d_printf("Change: %s\n", mode_str
);
3566 /****************************************************************************
3568 ****************************************************************************/
3570 static int cmd_chown(void)
3572 TALLOC_CTX
*ctx
= talloc_tos();
3576 char *buf
, *buf2
, *buf3
;
3577 struct cli_state
*targetcli
;
3578 char *targetname
= NULL
;
3580 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3581 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
) ||
3582 !next_token_talloc(ctx
, &cmd_ptr
,&buf3
,NULL
)) {
3583 d_printf("chown uid gid file\n");
3587 uid
= (uid_t
)atoi(buf
);
3588 gid
= (gid_t
)atoi(buf2
);
3590 src
= talloc_asprintf(ctx
,
3592 client_get_cur_dir(),
3597 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
) ) {
3598 d_printf("chown %s: %s\n", src
, cli_errstr(cli
));
3602 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3603 d_printf("Server doesn't support UNIX CIFS calls.\n");
3607 if (!NT_STATUS_IS_OK(cli_posix_chown(targetcli
, targetname
, uid
, gid
))) {
3608 d_printf("%s chown file %s uid=%d, gid=%d\n",
3609 cli_errstr(targetcli
), src
, (int)uid
, (int)gid
);
3616 /****************************************************************************
3618 ****************************************************************************/
3620 static int cmd_rename(void)
3622 TALLOC_CTX
*ctx
= talloc_tos();
3625 struct cli_state
*targetcli
;
3629 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3630 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3631 d_printf("rename <src> <dest>\n");
3635 src
= talloc_asprintf(ctx
,
3637 client_get_cur_dir(),
3643 dest
= talloc_asprintf(ctx
,
3645 client_get_cur_dir(),
3651 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetsrc
)) {
3652 d_printf("rename %s: %s\n", src
, cli_errstr(cli
));
3656 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, dest
, &targetcli
, &targetdest
)) {
3657 d_printf("rename %s: %s\n", dest
, cli_errstr(cli
));
3661 if (!NT_STATUS_IS_OK(cli_rename(targetcli
, targetsrc
, targetdest
))) {
3662 d_printf("%s renaming files %s -> %s \n",
3663 cli_errstr(targetcli
),
3672 /****************************************************************************
3673 Print the volume name.
3674 ****************************************************************************/
3676 static int cmd_volume(void)
3683 status
= cli_get_fs_volume_info(cli
, volname
, &serial_num
,
3685 if (!NT_STATUS_IS_OK(status
)) {
3686 d_printf("Error %s getting volume info\n", nt_errstr(status
));
3690 d_printf("Volume: |%s| serial number 0x%x\n",
3691 volname
, (unsigned int)serial_num
);
3695 /****************************************************************************
3696 Hard link files using the NT call.
3697 ****************************************************************************/
3699 static int cmd_hardlink(void)
3701 TALLOC_CTX
*ctx
= talloc_tos();
3704 struct cli_state
*targetcli
;
3707 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3708 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3709 d_printf("hardlink <src> <dest>\n");
3713 src
= talloc_asprintf(ctx
,
3715 client_get_cur_dir(),
3721 dest
= talloc_asprintf(ctx
,
3723 client_get_cur_dir(),
3729 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3730 d_printf("hardlink %s: %s\n", src
, cli_errstr(cli
));
3734 if (!NT_STATUS_IS_OK(cli_nt_hardlink(targetcli
, targetname
, dest
))) {
3735 d_printf("%s doing an NT hard link of files\n",cli_errstr(targetcli
));
3742 /****************************************************************************
3743 Toggle the prompt flag.
3744 ****************************************************************************/
3746 static int cmd_prompt(void)
3749 DEBUG(2,("prompting is now %s\n",prompt
?"on":"off"));
3753 /****************************************************************************
3754 Set the newer than time.
3755 ****************************************************************************/
3757 static int cmd_newer(void)
3759 TALLOC_CTX
*ctx
= talloc_tos();
3762 SMB_STRUCT_STAT sbuf
;
3764 ok
= next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
);
3765 if (ok
&& (sys_stat(buf
, &sbuf
, false) == 0)) {
3766 newer_than
= convert_timespec_to_time_t(sbuf
.st_ex_mtime
);
3767 DEBUG(1,("Getting files newer than %s",
3768 time_to_asc(newer_than
)));
3773 if (ok
&& newer_than
== 0) {
3774 d_printf("Error setting newer-than time\n");
3781 /****************************************************************************
3782 Set the archive level.
3783 ****************************************************************************/
3785 static int cmd_archive(void)
3787 TALLOC_CTX
*ctx
= talloc_tos();
3790 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
3791 archive_level
= atoi(buf
);
3793 d_printf("Archive level is %d\n",archive_level
);
3799 /****************************************************************************
3800 Toggle the lowercaseflag.
3801 ****************************************************************************/
3803 static int cmd_lowercase(void)
3805 lowercase
= !lowercase
;
3806 DEBUG(2,("filename lowercasing is now %s\n",lowercase
?"on":"off"));
3810 /****************************************************************************
3811 Toggle the case sensitive flag.
3812 ****************************************************************************/
3814 static int cmd_setcase(void)
3816 bool orig_case_sensitive
= cli_set_case_sensitive(cli
, false);
3818 cli_set_case_sensitive(cli
, !orig_case_sensitive
);
3819 DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive
?
3824 /****************************************************************************
3825 Toggle the showacls flag.
3826 ****************************************************************************/
3828 static int cmd_showacls(void)
3830 showacls
= !showacls
;
3831 DEBUG(2,("showacls is now %s\n",showacls
?"on":"off"));
3836 /****************************************************************************
3837 Toggle the recurse flag.
3838 ****************************************************************************/
3840 static int cmd_recurse(void)
3843 DEBUG(2,("directory recursion is now %s\n",recurse
?"on":"off"));
3847 /****************************************************************************
3848 Toggle the translate flag.
3849 ****************************************************************************/
3851 static int cmd_translate(void)
3853 translation
= !translation
;
3854 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
3855 translation
?"on":"off"));
3859 /****************************************************************************
3861 ****************************************************************************/
3863 static int cmd_lcd(void)
3865 TALLOC_CTX
*ctx
= talloc_tos();
3869 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
3870 if (chdir(buf
) == -1) {
3871 d_printf("chdir to %s failed (%s)\n",
3872 buf
, strerror(errno
));
3875 d
= TALLOC_ARRAY(ctx
, char, PATH_MAX
+1);
3879 DEBUG(2,("the local directory is now %s\n",sys_getwd(d
)));
3883 /****************************************************************************
3884 Get a file restarting at end of local file.
3885 ****************************************************************************/
3887 static int cmd_reget(void)
3889 TALLOC_CTX
*ctx
= talloc_tos();
3890 char *local_name
= NULL
;
3891 char *remote_name
= NULL
;
3895 remote_name
= talloc_strdup(ctx
, client_get_cur_dir());
3900 if (!next_token_talloc(ctx
, &cmd_ptr
, &fname
, NULL
)) {
3901 d_printf("reget <filename>\n");
3904 remote_name
= talloc_asprintf_append(remote_name
, "%s", fname
);
3908 remote_name
= clean_name(ctx
,remote_name
);
3914 next_token_talloc(ctx
, &cmd_ptr
, &p
, NULL
);
3919 return do_get(remote_name
, local_name
, true);
3922 /****************************************************************************
3923 Put a file restarting at end of local file.
3924 ****************************************************************************/
3926 static int cmd_reput(void)
3928 TALLOC_CTX
*ctx
= talloc_tos();
3929 char *local_name
= NULL
;
3930 char *remote_name
= NULL
;
3934 remote_name
= talloc_strdup(ctx
, client_get_cur_dir());
3939 if (!next_token_talloc(ctx
, &cmd_ptr
, &local_name
, NULL
)) {
3940 d_printf("reput <filename>\n");
3944 if (!file_exist_stat(local_name
, &st
, false)) {
3945 d_printf("%s does not exist\n", local_name
);
3949 if (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
3950 remote_name
= talloc_asprintf_append(remote_name
,
3953 remote_name
= talloc_asprintf_append(remote_name
,
3960 remote_name
= clean_name(ctx
, remote_name
);
3965 return do_put(remote_name
, local_name
, true);
3968 /****************************************************************************
3970 ****************************************************************************/
3972 static void browse_fn(const char *name
, uint32 m
,
3973 const char *comment
, void *state
)
3975 const char *typestr
= "";
3978 case STYPE_DISKTREE
:
3982 typestr
= "Printer";
3991 /* FIXME: If the remote machine returns non-ascii characters
3992 in any of these fields, they can corrupt the output. We
3993 should remove them. */
3995 d_printf("\t%-15s %-10.10s%s\n",
3996 name
,typestr
,comment
);
3998 d_printf ("%s|%s|%s\n",typestr
,name
,comment
);
4002 static bool browse_host_rpc(bool sort
)
4005 struct rpc_pipe_client
*pipe_hnd
= NULL
;
4006 TALLOC_CTX
*frame
= talloc_stackframe();
4008 struct srvsvc_NetShareInfoCtr info_ctr
;
4009 struct srvsvc_NetShareCtr1 ctr1
;
4010 uint32_t resume_handle
= 0;
4011 uint32_t total_entries
= 0;
4013 struct dcerpc_binding_handle
*b
;
4015 status
= cli_rpc_pipe_open_noauth(cli
, &ndr_table_srvsvc
.syntax_id
,
4018 if (!NT_STATUS_IS_OK(status
)) {
4019 DEBUG(10, ("Could not connect to srvsvc pipe: %s\n",
4020 nt_errstr(status
)));
4025 b
= pipe_hnd
->binding_handle
;
4027 ZERO_STRUCT(info_ctr
);
4031 info_ctr
.ctr
.ctr1
= &ctr1
;
4033 status
= dcerpc_srvsvc_NetShareEnumAll(b
, frame
,
4041 if (!NT_STATUS_IS_OK(status
) || !W_ERROR_IS_OK(werr
)) {
4042 TALLOC_FREE(pipe_hnd
);
4047 for (i
=0; i
< info_ctr
.ctr
.ctr1
->count
; i
++) {
4048 struct srvsvc_NetShareInfo1 info
= info_ctr
.ctr
.ctr1
->array
[i
];
4049 browse_fn(info
.name
, info
.type
, info
.comment
, NULL
);
4052 TALLOC_FREE(pipe_hnd
);
4057 /****************************************************************************
4058 Try and browse available connections on a host.
4059 ****************************************************************************/
4061 static bool browse_host(bool sort
)
4065 d_printf("\n\tSharename Type Comment\n");
4066 d_printf("\t--------- ---- -------\n");
4069 if (browse_host_rpc(sort
)) {
4073 if((ret
= cli_RNetShareEnum(cli
, browse_fn
, NULL
)) == -1)
4074 d_printf("Error returning browse list: %s\n", cli_errstr(cli
));
4079 /****************************************************************************
4081 ****************************************************************************/
4083 static void server_fn(const char *name
, uint32 m
,
4084 const char *comment
, void *state
)
4088 d_printf("\t%-16s %s\n", name
, comment
);
4090 d_printf("%s|%s|%s\n",(char *)state
, name
, comment
);
4094 /****************************************************************************
4095 Try and browse available connections on a host.
4096 ****************************************************************************/
4098 static bool list_servers(const char *wk_grp
)
4102 if (!cli
->server_domain
)
4106 d_printf("\n\tServer Comment\n");
4107 d_printf("\t--------- -------\n");
4109 fstrcpy( state
, "Server" );
4110 cli_NetServerEnum(cli
, cli
->server_domain
, SV_TYPE_ALL
, server_fn
,
4114 d_printf("\n\tWorkgroup Master\n");
4115 d_printf("\t--------- -------\n");
4118 fstrcpy( state
, "Workgroup" );
4119 cli_NetServerEnum(cli
, cli
->server_domain
, SV_TYPE_DOMAIN_ENUM
,
4124 /****************************************************************************
4125 Print or set current VUID
4126 ****************************************************************************/
4128 static int cmd_vuid(void)
4130 TALLOC_CTX
*ctx
= talloc_tos();
4133 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4134 d_printf("Current VUID is %d\n", cli
->vuid
);
4138 cli
->vuid
= atoi(buf
);
4142 /****************************************************************************
4143 Setup a new VUID, by issuing a session setup
4144 ****************************************************************************/
4146 static int cmd_logon(void)
4148 TALLOC_CTX
*ctx
= talloc_tos();
4149 char *l_username
, *l_password
;
4152 if (!next_token_talloc(ctx
, &cmd_ptr
,&l_username
,NULL
)) {
4153 d_printf("logon <username> [<password>]\n");
4157 if (!next_token_talloc(ctx
, &cmd_ptr
,&l_password
,NULL
)) {
4158 char *pass
= getpass("Password: ");
4160 l_password
= talloc_strdup(ctx
,pass
);
4167 nt_status
= cli_session_setup(cli
, l_username
,
4168 l_password
, strlen(l_password
),
4169 l_password
, strlen(l_password
),
4171 if (!NT_STATUS_IS_OK(nt_status
)) {
4172 d_printf("session setup failed: %s\n", nt_errstr(nt_status
));
4176 d_printf("Current VUID is %d\n", cli
->vuid
);
4181 /****************************************************************************
4182 list active connections
4183 ****************************************************************************/
4185 static int cmd_list_connect(void)
4187 cli_cm_display(cli
);
4191 /****************************************************************************
4192 display the current active client connection
4193 ****************************************************************************/
4195 static int cmd_show_connect( void )
4197 TALLOC_CTX
*ctx
= talloc_tos();
4198 struct cli_state
*targetcli
;
4201 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, client_get_cur_dir(),
4202 &targetcli
, &targetpath
) ) {
4203 d_printf("showconnect %s: %s\n", cur_dir
, cli_errstr(cli
));
4207 d_printf("//%s/%s\n", targetcli
->desthost
, targetcli
->share
);
4211 /****************************************************************************
4213 ***************************************************************************/
4215 int cmd_iosize(void)
4217 TALLOC_CTX
*ctx
= talloc_tos();
4221 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4223 d_printf("iosize <n> or iosize 0x<n>. "
4224 "Minimum is 16384 (0x4000), "
4225 "max is 16776960 (0xFFFF00)\n");
4227 d_printf("iosize <n> or iosize 0x<n>. "
4228 "(Encrypted connection) ,"
4229 "Minimum is 16384 (0x4000), "
4230 "max is 130048 (0x1FC00)\n");
4235 iosize
= strtol(buf
,NULL
,0);
4236 if (smb_encrypt
&& (iosize
< 0x4000 || iosize
> 0xFC00)) {
4237 d_printf("iosize out of range for encrypted "
4238 "connection (min = 16384 (0x4000), "
4239 "max = 130048 (0x1FC00)");
4241 } else if (!smb_encrypt
&& (iosize
< 0x4000 || iosize
> 0xFFFF00)) {
4242 d_printf("iosize out of range (min = 16384 (0x4000), "
4243 "max = 16776960 (0xFFFF00)");
4247 io_bufsize
= iosize
;
4248 d_printf("iosize is now %d\n", io_bufsize
);
4252 /****************************************************************************
4254 ****************************************************************************/
4255 static int cmd_history(void)
4257 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
4261 hlist
= history_list();
4263 for (i
= 0; hlist
&& hlist
[i
]; i
++) {
4264 DEBUG(0, ("%d: %s\n", i
, hlist
[i
]->line
));
4267 DEBUG(0,("no history without readline support\n"));
4273 /* Some constants for completing filename arguments */
4275 #define COMPL_NONE 0 /* No completions */
4276 #define COMPL_REMOTE 1 /* Complete remote filename */
4277 #define COMPL_LOCAL 2 /* Complete local filename */
4279 /* This defines the commands supported by this client.
4280 * NOTE: The "!" must be the last one in the list because it's fn pointer
4281 * field is NULL, and NULL in that field is used in process_tok()
4282 * (below) to indicate the end of the list. crh
4287 const char *description
;
4288 char compl_args
[2]; /* Completion argument info */
4290 {"?",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
4291 {"allinfo",cmd_allinfo
,"<file> show all available info",
4292 {COMPL_NONE
,COMPL_NONE
}},
4293 {"altname",cmd_altname
,"<file> show alt name",{COMPL_NONE
,COMPL_NONE
}},
4294 {"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
}},
4295 {"blocksize",cmd_block
,"blocksize <number> (default 20)",{COMPL_NONE
,COMPL_NONE
}},
4296 {"cancel",cmd_cancel
,"<jobid> cancel a print queue entry",{COMPL_NONE
,COMPL_NONE
}},
4297 {"case_sensitive",cmd_setcase
,"toggle the case sensitive flag to server",{COMPL_NONE
,COMPL_NONE
}},
4298 {"cd",cmd_cd
,"[directory] change/report the remote directory",{COMPL_REMOTE
,COMPL_NONE
}},
4299 {"chmod",cmd_chmod
,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE
,COMPL_REMOTE
}},
4300 {"chown",cmd_chown
,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE
,COMPL_REMOTE
}},
4301 {"close",cmd_close
,"<fid> close a file given a fid",{COMPL_REMOTE
,COMPL_REMOTE
}},
4302 {"del",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4303 {"dir",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4304 {"du",cmd_du
,"<mask> computes the total size of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4305 {"echo",cmd_echo
,"ping the server",{COMPL_NONE
,COMPL_NONE
}},
4306 {"exit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
4307 {"get",cmd_get
,"<remote name> [local name] get a file",{COMPL_REMOTE
,COMPL_LOCAL
}},
4308 {"getfacl",cmd_getfacl
,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE
,COMPL_LOCAL
}},
4309 {"geteas", cmd_geteas
, "<file name> get the EA list of a file",
4310 {COMPL_REMOTE
, COMPL_LOCAL
}},
4311 {"hardlink",cmd_hardlink
,"<src> <dest> create a Windows hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
4312 {"help",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
4313 {"history",cmd_history
,"displays the command history",{COMPL_NONE
,COMPL_NONE
}},
4314 {"iosize",cmd_iosize
,"iosize <number> (default 64512)",{COMPL_NONE
,COMPL_NONE
}},
4315 {"lcd",cmd_lcd
,"[directory] change/report the local current working directory",{COMPL_LOCAL
,COMPL_NONE
}},
4316 {"link",cmd_link
,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
4317 {"lock",cmd_lock
,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE
,COMPL_REMOTE
}},
4318 {"lowercase",cmd_lowercase
,"toggle lowercasing of filenames for get",{COMPL_NONE
,COMPL_NONE
}},
4319 {"ls",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4320 {"l",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4321 {"mask",cmd_select
,"<mask> mask all filenames against this",{COMPL_REMOTE
,COMPL_NONE
}},
4322 {"md",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
4323 {"mget",cmd_mget
,"<mask> get all the matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4324 {"mkdir",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
4325 {"more",cmd_more
,"<remote name> view a remote file with your pager",{COMPL_REMOTE
,COMPL_NONE
}},
4326 {"mput",cmd_mput
,"<mask> put all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4327 {"newer",cmd_newer
,"<file> only mget files newer than the specified local file",{COMPL_LOCAL
,COMPL_NONE
}},
4328 {"open",cmd_open
,"<mask> open a file",{COMPL_REMOTE
,COMPL_NONE
}},
4329 {"posix", cmd_posix
, "turn on all POSIX capabilities", {COMPL_REMOTE
,COMPL_NONE
}},
4330 {"posix_encrypt",cmd_posix_encrypt
,"<domain> <user> <password> start up transport encryption",{COMPL_REMOTE
,COMPL_NONE
}},
4331 {"posix_open",cmd_posix_open
,"<name> 0<mode> open_flags mode open a file using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4332 {"posix_mkdir",cmd_posix_mkdir
,"<name> 0<mode> creates a directory using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4333 {"posix_rmdir",cmd_posix_rmdir
,"<name> removes a directory using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4334 {"posix_unlink",cmd_posix_unlink
,"<name> removes a file using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4335 {"print",cmd_print
,"<file name> print a file",{COMPL_NONE
,COMPL_NONE
}},
4336 {"prompt",cmd_prompt
,"toggle prompting for filenames for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
4337 {"put",cmd_put
,"<local name> [remote name] put a file",{COMPL_LOCAL
,COMPL_REMOTE
}},
4338 {"pwd",cmd_pwd
,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE
,COMPL_NONE
}},
4339 {"q",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
4340 {"queue",cmd_queue
,"show the print queue",{COMPL_NONE
,COMPL_NONE
}},
4341 {"quit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
4342 {"readlink",cmd_readlink
,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
4343 {"rd",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
4344 {"recurse",cmd_recurse
,"toggle directory recursion for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
4345 {"reget",cmd_reget
,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE
,COMPL_LOCAL
}},
4346 {"rename",cmd_rename
,"<src> <dest> rename some files",{COMPL_REMOTE
,COMPL_REMOTE
}},
4347 {"reput",cmd_reput
,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL
,COMPL_REMOTE
}},
4348 {"rm",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4349 {"rmdir",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
4350 {"showacls",cmd_showacls
,"toggle if ACLs are shown or not",{COMPL_NONE
,COMPL_NONE
}},
4351 {"setea", cmd_setea
, "<file name> <eaname> <eaval> Set an EA of a file",
4352 {COMPL_REMOTE
, COMPL_LOCAL
}},
4353 {"setmode",cmd_setmode
,"filename <setmode string> change modes of file",{COMPL_REMOTE
,COMPL_NONE
}},
4354 {"stat",cmd_stat
,"filename Do a UNIX extensions stat call on a file",{COMPL_REMOTE
,COMPL_REMOTE
}},
4355 {"symlink",cmd_symlink
,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
4356 {"tar",cmd_tar
,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE
,COMPL_NONE
}},
4357 {"tarmode",cmd_tarmode
,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE
,COMPL_NONE
}},
4358 {"translate",cmd_translate
,"toggle text translation for printing",{COMPL_NONE
,COMPL_NONE
}},
4359 {"unlock",cmd_unlock
,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE
,COMPL_REMOTE
}},
4360 {"volume",cmd_volume
,"print the volume name",{COMPL_NONE
,COMPL_NONE
}},
4361 {"vuid",cmd_vuid
,"change current vuid",{COMPL_NONE
,COMPL_NONE
}},
4362 {"wdel",cmd_wdel
,"<attrib> <mask> wildcard delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4363 {"logon",cmd_logon
,"establish new logon",{COMPL_NONE
,COMPL_NONE
}},
4364 {"listconnect",cmd_list_connect
,"list open connections",{COMPL_NONE
,COMPL_NONE
}},
4365 {"showconnect",cmd_show_connect
,"display the current active connection",{COMPL_NONE
,COMPL_NONE
}},
4366 {"..",cmd_cd_oneup
,"change the remote directory (up one level)",{COMPL_REMOTE
,COMPL_NONE
}},
4368 /* Yes, this must be here, see crh's comment above. */
4369 {"!",NULL
,"run a shell command on the local system",{COMPL_NONE
,COMPL_NONE
}},
4370 {NULL
,NULL
,NULL
,{COMPL_NONE
,COMPL_NONE
}}
4373 /*******************************************************************
4374 Lookup a command string in the list of commands, including
4376 ******************************************************************/
4378 static int process_tok(char *tok
)
4380 int i
= 0, matches
= 0;
4382 int tok_len
= strlen(tok
);
4384 while (commands
[i
].fn
!= NULL
) {
4385 if (strequal(commands
[i
].name
,tok
)) {
4389 } else if (strnequal(commands
[i
].name
, tok
, tok_len
)) {
4398 else if (matches
== 1)
4404 /****************************************************************************
4406 ****************************************************************************/
4408 static int cmd_help(void)
4410 TALLOC_CTX
*ctx
= talloc_tos();
4414 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4415 if ((i
= process_tok(buf
)) >= 0)
4416 d_printf("HELP %s:\n\t%s\n\n",
4417 commands
[i
].name
,commands
[i
].description
);
4419 while (commands
[i
].description
) {
4420 for (j
=0; commands
[i
].description
&& (j
<5); j
++) {
4421 d_printf("%-15s",commands
[i
].name
);
4430 /****************************************************************************
4431 Process a -c command string.
4432 ****************************************************************************/
4434 static int process_command_string(const char *cmd_in
)
4436 TALLOC_CTX
*ctx
= talloc_tos();
4437 char *cmd
= talloc_strdup(ctx
, cmd_in
);
4443 /* establish the connection if not already */
4446 cli
= cli_cm_open(talloc_tos(), NULL
,
4447 have_ip
? dest_ss_str
: desthost
,
4450 max_protocol
, port
, name_type
);
4456 while (cmd
[0] != '\0') {
4462 if ((p
= strchr_m(cmd
, ';')) == 0) {
4471 /* and get the first part of the command */
4473 if (!next_token_talloc(ctx
, &cmd_ptr
,&tok
,NULL
)) {
4477 if ((i
= process_tok(tok
)) >= 0) {
4478 rc
= commands
[i
].fn();
4479 } else if (i
== -2) {
4480 d_printf("%s: command abbreviation ambiguous\n",tok
);
4482 d_printf("%s: command not found\n",tok
);
4489 #define MAX_COMPLETIONS 100
4491 struct completion_remote
{
4499 static NTSTATUS
completion_remote_filter(const char *mnt
,
4500 struct file_info
*f
,
4504 struct completion_remote
*info
= (struct completion_remote
*)state
;
4506 if (info
->count
>= MAX_COMPLETIONS
- 1) {
4507 return NT_STATUS_OK
;
4509 if (strncmp(info
->text
, f
->name
, info
->len
) != 0) {
4510 return NT_STATUS_OK
;
4512 if (ISDOT(f
->name
) || ISDOTDOT(f
->name
)) {
4513 return NT_STATUS_OK
;
4516 if ((info
->dirmask
[0] == 0) && !(f
->mode
& aDIR
))
4517 info
->matches
[info
->count
] = SMB_STRDUP(f
->name
);
4519 TALLOC_CTX
*ctx
= talloc_stackframe();
4522 tmp
= talloc_strdup(ctx
,info
->dirmask
);
4525 return NT_STATUS_NO_MEMORY
;
4527 tmp
= talloc_asprintf_append(tmp
, "%s", f
->name
);
4530 return NT_STATUS_NO_MEMORY
;
4532 if (f
->mode
& aDIR
) {
4533 tmp
= talloc_asprintf_append(tmp
, "%s",
4538 return NT_STATUS_NO_MEMORY
;
4540 info
->matches
[info
->count
] = SMB_STRDUP(tmp
);
4543 if (info
->matches
[info
->count
] == NULL
) {
4544 return NT_STATUS_OK
;
4546 if (f
->mode
& aDIR
) {
4547 smb_readline_ca_char(0);
4549 if (info
->count
== 1) {
4550 info
->samelen
= strlen(info
->matches
[info
->count
]);
4552 while (strncmp(info
->matches
[info
->count
],
4553 info
->matches
[info
->count
-1],
4554 info
->samelen
) != 0) {
4559 return NT_STATUS_OK
;
4562 static char **remote_completion(const char *text
, int len
)
4564 TALLOC_CTX
*ctx
= talloc_stackframe();
4565 char *dirmask
= NULL
;
4566 char *targetpath
= NULL
;
4567 struct cli_state
*targetcli
= NULL
;
4569 struct completion_remote info
= { NULL
, NULL
, 1, 0, NULL
, 0 };
4572 /* can't have non-static initialisation on Sun CC, so do it
4578 info
.matches
= SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS
);
4579 if (!info
.matches
) {
4585 * We're leaving matches[0] free to fill it later with the text to
4586 * display: Either the one single match or the longest common subset
4589 info
.matches
[0] = NULL
;
4592 for (i
= len
-1; i
>= 0; i
--) {
4593 if ((text
[i
] == '/') || (text
[i
] == CLI_DIRSEP_CHAR
)) {
4598 info
.text
= text
+i
+1;
4599 info
.samelen
= info
.len
= len
-i
-1;
4602 info
.dirmask
= SMB_MALLOC_ARRAY(char, i
+2);
4603 if (!info
.dirmask
) {
4606 strncpy(info
.dirmask
, text
, i
+1);
4607 info
.dirmask
[i
+1] = 0;
4608 dirmask
= talloc_asprintf(ctx
,
4610 client_get_cur_dir(),
4614 info
.dirmask
= SMB_STRDUP("");
4615 if (!info
.dirmask
) {
4618 dirmask
= talloc_asprintf(ctx
,
4620 client_get_cur_dir());
4626 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, dirmask
, &targetcli
, &targetpath
)) {
4629 status
= cli_list(targetcli
, targetpath
, aDIR
| aSYSTEM
| aHIDDEN
,
4630 completion_remote_filter
, (void *)&info
);
4631 if (!NT_STATUS_IS_OK(status
)) {
4635 if (info
.count
== 1) {
4637 * No matches at all, NULL indicates there is nothing
4639 SAFE_FREE(info
.matches
[0]);
4640 SAFE_FREE(info
.matches
);
4645 if (info
.count
== 2) {
4647 * Exactly one match in matches[1], indicate this is the one
4650 info
.matches
[0] = info
.matches
[1];
4651 info
.matches
[1] = NULL
;
4654 return info
.matches
;
4658 * We got more than one possible match, set the result to the maximum
4662 info
.matches
[0] = SMB_STRNDUP(info
.matches
[1], info
.samelen
);
4663 info
.matches
[info
.count
] = NULL
;
4664 return info
.matches
;
4667 for (i
= 0; i
< info
.count
; i
++) {
4668 SAFE_FREE(info
.matches
[i
]);
4670 SAFE_FREE(info
.matches
);
4671 SAFE_FREE(info
.dirmask
);
4676 static char **completion_fn(const char *text
, int start
, int end
)
4678 smb_readline_ca_char(' ');
4681 const char *buf
, *sp
;
4685 buf
= smb_readline_get_line_buffer();
4689 sp
= strchr(buf
, ' ');
4693 for (i
= 0; commands
[i
].name
; i
++) {
4694 if ((strncmp(commands
[i
].name
, buf
, sp
- buf
) == 0) &&
4695 (commands
[i
].name
[sp
- buf
] == 0)) {
4699 if (commands
[i
].name
== NULL
)
4705 if (sp
== (buf
+ start
))
4706 compl_type
= commands
[i
].compl_args
[0];
4708 compl_type
= commands
[i
].compl_args
[1];
4710 if (compl_type
== COMPL_REMOTE
)
4711 return remote_completion(text
, end
- start
);
4712 else /* fall back to local filename completion */
4716 int i
, len
, samelen
= 0, count
=1;
4718 matches
= SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS
);
4725 for (i
=0;commands
[i
].fn
&& count
< MAX_COMPLETIONS
-1;i
++) {
4726 if (strncmp(text
, commands
[i
].name
, len
) == 0) {
4727 matches
[count
] = SMB_STRDUP(commands
[i
].name
);
4728 if (!matches
[count
])
4731 samelen
= strlen(matches
[count
]);
4733 while (strncmp(matches
[count
], matches
[count
-1], samelen
) != 0)
4740 case 0: /* should never happen */
4744 matches
[0] = SMB_STRDUP(matches
[1]);
4747 matches
[0] = (char *)SMB_MALLOC(samelen
+1);
4750 strncpy(matches
[0], matches
[1], samelen
);
4751 matches
[0][samelen
] = 0;
4753 matches
[count
] = NULL
;
4757 for (i
= 0; i
< count
; i
++)
4765 static bool finished
;
4767 /****************************************************************************
4768 Make sure we swallow keepalives during idle time.
4769 ****************************************************************************/
4771 static void readline_callback(void)
4773 static time_t last_t
;
4774 struct timespec now
;
4778 clock_gettime_mono(&now
);
4791 /* We deliberately use receive_smb_raw instead of
4792 client_receive_smb as we want to receive
4793 session keepalives and then drop them here.
4796 ret
= poll_intr_one_fd(cli
->fd
, POLLIN
|POLLHUP
, 0, &revents
);
4798 if ((ret
> 0) && (revents
& (POLLIN
|POLLHUP
|POLLERR
))) {
4802 set_smb_read_error(&cli
->smb_rw_error
, SMB_READ_OK
);
4804 status
= receive_smb_raw(cli
->fd
, cli
->inbuf
, cli
->bufsize
, 0, 0, &len
);
4806 if (!NT_STATUS_IS_OK(status
)) {
4807 DEBUG(0, ("Read from server failed, maybe it closed "
4808 "the connection\n"));
4811 smb_readline_done();
4812 if (NT_STATUS_EQUAL(status
, NT_STATUS_END_OF_FILE
)) {
4813 set_smb_read_error(&cli
->smb_rw_error
,
4818 if (NT_STATUS_EQUAL(status
, NT_STATUS_IO_TIMEOUT
)) {
4819 set_smb_read_error(&cli
->smb_rw_error
,
4824 set_smb_read_error(&cli
->smb_rw_error
, SMB_READ_ERROR
);
4827 if(CVAL(cli
->inbuf
,0) != SMBkeepalive
) {
4828 DEBUG(0, ("Read from server "
4829 "returned unexpected packet!\n"));
4836 /* Ping the server to keep the connection alive using SMBecho. */
4839 unsigned char garbage
[16];
4840 memset(garbage
, 0xf0, sizeof(garbage
));
4841 status
= cli_echo(cli
, 1, data_blob_const(garbage
, sizeof(garbage
)));
4843 if (!NT_STATUS_IS_OK(status
)) {
4844 DEBUG(0, ("SMBecho failed. Maybe server has closed "
4845 "the connection\n"));
4847 smb_readline_done();
4852 /****************************************************************************
4853 Process commands on stdin.
4854 ****************************************************************************/
4856 static int process_stdin(void)
4861 TALLOC_CTX
*frame
= talloc_stackframe();
4863 char *the_prompt
= NULL
;
4867 /* display a prompt */
4868 if (asprintf(&the_prompt
, "smb: %s> ", client_get_cur_dir()) < 0) {
4872 line
= smb_readline(the_prompt
, readline_callback
, completion_fn
);
4873 SAFE_FREE(the_prompt
);
4879 /* special case - first char is ! */
4881 if (system(line
+ 1) == -1) {
4882 d_printf("system() command %s failed.\n",
4890 /* and get the first part of the command */
4892 if (!next_token_talloc(frame
, &cmd_ptr
,&tok
,NULL
)) {
4898 if ((i
= process_tok(tok
)) >= 0) {
4899 rc
= commands
[i
].fn();
4900 } else if (i
== -2) {
4901 d_printf("%s: command abbreviation ambiguous\n",tok
);
4903 d_printf("%s: command not found\n",tok
);
4911 /****************************************************************************
4912 Process commands from the client.
4913 ****************************************************************************/
4915 static int process(const char *base_directory
)
4919 cli
= cli_cm_open(talloc_tos(), NULL
,
4920 have_ip
? dest_ss_str
: desthost
,
4921 service
, auth_info
, true, smb_encrypt
,
4922 max_protocol
, port
, name_type
);
4927 if (base_directory
&& *base_directory
) {
4928 rc
= do_cd(base_directory
);
4936 rc
= process_command_string(cmdstr
);
4945 /****************************************************************************
4947 ****************************************************************************/
4949 static int do_host_query(const char *query_host
)
4951 cli
= cli_cm_open(talloc_tos(), NULL
,
4952 have_ip
? dest_ss_str
: query_host
, "IPC$", auth_info
, true, smb_encrypt
,
4953 max_protocol
, port
, name_type
);
4959 /* Ensure that the host can do IPv4 */
4961 if (!interpret_addr(query_host
)) {
4962 struct sockaddr_storage ss
;
4963 if (interpret_string_addr(&ss
, query_host
, 0) &&
4964 (ss
.ss_family
!= AF_INET
)) {
4965 d_printf("%s is an IPv6 address -- no workgroup available\n",
4973 /* Workgroups simply don't make sense over anything
4974 else but port 139... */
4977 cli
= cli_cm_open(talloc_tos(), NULL
,
4978 have_ip
? dest_ss_str
: query_host
, "IPC$",
4979 auth_info
, true, smb_encrypt
,
4980 max_protocol
, 139, name_type
);
4984 d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
4988 list_servers(lp_workgroup());
4995 /****************************************************************************
4996 Handle a tar operation.
4997 ****************************************************************************/
4999 static int do_tar_op(const char *base_directory
)
5003 /* do we already have a connection? */
5005 cli
= cli_cm_open(talloc_tos(), NULL
,
5006 have_ip
? dest_ss_str
: desthost
,
5007 service
, auth_info
, true, smb_encrypt
,
5008 max_protocol
, port
, name_type
);
5015 if (base_directory
&& *base_directory
) {
5016 ret
= do_cd(base_directory
);
5030 /****************************************************************************
5031 Handle a message operation.
5032 ****************************************************************************/
5034 static int do_message_op(struct user_auth_info
*a_info
)
5036 struct sockaddr_storage ss
;
5037 struct nmb_name called
, calling
;
5038 fstring server_name
;
5039 char name_type_hex
[10];
5043 make_nmb_name(&calling
, calling_name
, 0x0);
5044 make_nmb_name(&called
, desthost
, name_type
);
5046 fstrcpy(server_name
, desthost
);
5047 snprintf(name_type_hex
, sizeof(name_type_hex
), "#%X", name_type
);
5048 fstrcat(server_name
, name_type_hex
);
5054 /* we can only do messages over port 139 (to windows clients at least) */
5056 msg_port
= port
? port
: 139;
5058 if (!(cli
=cli_initialise())) {
5059 d_printf("Connection to %s failed\n", desthost
);
5062 cli_set_port(cli
, msg_port
);
5064 status
= cli_connect(cli
, server_name
, &ss
);
5065 if (!NT_STATUS_IS_OK(status
)) {
5066 d_printf("Connection to %s failed. Error %s\n", desthost
, nt_errstr(status
));
5070 if (!cli_session_request(cli
, &calling
, &called
)) {
5071 d_printf("session request failed\n");
5076 send_message(get_cmdline_auth_info_username(a_info
));
5082 /****************************************************************************
5084 ****************************************************************************/
5086 int main(int argc
,char *argv
[])
5088 char *base_directory
= NULL
;
5090 char *query_host
= NULL
;
5091 bool message
= false;
5092 static const char *new_name_resolve_order
= NULL
;
5096 fstring new_workgroup
;
5097 bool tar_opt
= false;
5098 bool service_opt
= false;
5099 struct poptOption long_options
[] = {
5102 { "name-resolve", 'R', POPT_ARG_STRING
, &new_name_resolve_order
, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },
5103 { "message", 'M', POPT_ARG_STRING
, NULL
, 'M', "Send message", "HOST" },
5104 { "ip-address", 'I', POPT_ARG_STRING
, NULL
, 'I', "Use this IP to connect to", "IP" },
5105 { "stderr", 'E', POPT_ARG_NONE
, NULL
, 'E', "Write messages to stderr instead of stdout" },
5106 { "list", 'L', POPT_ARG_STRING
, NULL
, 'L', "Get a list of shares available on a host", "HOST" },
5107 { "max-protocol", 'm', POPT_ARG_STRING
, NULL
, 'm', "Set the max protocol level", "LEVEL" },
5108 { "tar", 'T', POPT_ARG_STRING
, NULL
, 'T', "Command line tar", "<c|x>IXFqgbNan" },
5109 { "directory", 'D', POPT_ARG_STRING
, NULL
, 'D', "Start from directory", "DIR" },
5110 { "command", 'c', POPT_ARG_STRING
, &cmdstr
, 'c', "Execute semicolon separated commands" },
5111 { "send-buffer", 'b', POPT_ARG_INT
, &io_bufsize
, 'b', "Changes the transmit/send buffer", "BYTES" },
5112 { "port", 'p', POPT_ARG_INT
, &port
, 'p', "Port to connect to", "PORT" },
5113 { "grepable", 'g', POPT_ARG_NONE
, NULL
, 'g', "Produce grepable output" },
5114 { "browse", 'B', POPT_ARG_NONE
, NULL
, 'B', "Browse SMB servers using DNS" },
5116 POPT_COMMON_CONNECTION
5117 POPT_COMMON_CREDENTIALS
5120 TALLOC_CTX
*frame
= talloc_stackframe();
5122 if (!client_set_cur_dir("\\")) {
5126 /* initialize the workgroup name so we can determine whether or
5127 not it was set by a command line option */
5129 set_global_myworkgroup( "" );
5130 set_global_myname( "" );
5132 /* set default debug level to 1 regardless of what smb.conf sets */
5133 setup_logging( "smbclient", DEBUG_DEFAULT_STDERR
);
5136 lp_set_cmdline("log level", "1");
5138 auth_info
= user_auth_info_init(frame
);
5139 if (auth_info
== NULL
) {
5142 popt_common_set_auth_info(auth_info
);
5145 pc
= poptGetContext("smbclient", argc
, (const char **) argv
, long_options
, 0);
5146 poptSetOtherOptionHelp(pc
, "service <password>");
5148 lp_set_in_client(true); /* Make sure that we tell lp_load we are */
5150 while ((opt
= poptGetNextOpt(pc
)) != -1) {
5152 /* if the tar option has been called previouslt, now we need to eat out the leftovers */
5153 /* I see no other way to keep things sane --SSS */
5154 if (tar_opt
== true) {
5155 while (poptPeekArg(pc
)) {
5161 /* if the service has not yet been specified lets see if it is available in the popt stack */
5162 if (!service_opt
&& poptPeekArg(pc
)) {
5163 service
= talloc_strdup(frame
, poptGetArg(pc
));
5170 /* if the service has already been retrieved then check if we have also a password */
5172 && (!get_cmdline_auth_info_got_pass(auth_info
))
5173 && poptPeekArg(pc
)) {
5174 set_cmdline_auth_info_password(auth_info
,
5180 /* Messages are sent to NetBIOS name type 0x3
5181 * (Messenger Service). Make sure we default
5182 * to port 139 instead of port 445. srl,crh
5185 desthost
= talloc_strdup(frame
,poptGetOptArg(pc
));
5195 if (!interpret_string_addr(&dest_ss
, poptGetOptArg(pc
), 0)) {
5199 print_sockaddr(dest_ss_str
, sizeof(dest_ss_str
), &dest_ss
);
5203 setup_logging("smbclient", DEBUG_STDERR
);
5204 display_set_stderr();
5208 query_host
= talloc_strdup(frame
, poptGetOptArg(pc
));
5214 max_protocol
= interpret_protocol(poptGetOptArg(pc
), max_protocol
);
5217 /* We must use old option processing for this. Find the
5218 * position of the -T option in the raw argv[]. */
5221 for (i
= 1; i
< argc
; i
++) {
5222 if (strncmp("-T", argv
[i
],2)==0)
5226 if (!tar_parseargs(argc
, argv
, poptGetOptArg(pc
), i
)) {
5227 poptPrintUsage(pc
, stderr
, 0);
5231 /* this must be the last option, mark we have parsed it so that we know we have */
5235 base_directory
= talloc_strdup(frame
, poptGetOptArg(pc
));
5236 if (!base_directory
) {
5247 return(do_smb_browse());
5252 /* We may still have some leftovers after the last popt option has been called */
5253 if (tar_opt
== true) {
5254 while (poptPeekArg(pc
)) {
5260 /* if the service has not yet been specified lets see if it is available in the popt stack */
5261 if (!service_opt
&& poptPeekArg(pc
)) {
5262 service
= talloc_strdup(frame
,poptGetArg(pc
));
5269 /* if the service has already been retrieved then check if we have also a password */
5271 && !get_cmdline_auth_info_got_pass(auth_info
)
5272 && poptPeekArg(pc
)) {
5273 set_cmdline_auth_info_password(auth_info
,
5277 /* save the workgroup...
5279 FIXME!! do we need to do this for other options as well
5280 (or maybe a generic way to keep lp_load() from overwriting
5283 fstrcpy( new_workgroup
, lp_workgroup() );
5284 calling_name
= talloc_strdup(frame
, global_myname() );
5285 if (!calling_name
) {
5289 if ( override_logfile
)
5290 setup_logging( lp_logfile(), DEBUG_FILE
);
5292 if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {
5293 fprintf(stderr
, "%s: Can't load %s - run testparm to debug it\n",
5294 argv
[0], get_dyn_CONFIGFILE());
5297 if (get_cmdline_auth_info_use_machine_account(auth_info
) &&
5298 !set_cmdline_auth_info_machine_account_creds(auth_info
)) {
5304 if (service_opt
&& service
) {
5307 /* Convert any '/' characters in the service name to '\' characters */
5308 string_replace(service
, '/','\\');
5309 if (count_chars(service
,'\\') < 3) {
5310 d_printf("\n%s: Not enough '\\' characters in service\n",service
);
5311 poptPrintUsage(pc
, stderr
, 0);
5314 /* Remove trailing slashes */
5315 len
= strlen(service
);
5316 while(len
> 0 && service
[len
- 1] == '\\') {
5318 service
[len
] = '\0';
5322 if ( strlen(new_workgroup
) != 0 ) {
5323 set_global_myworkgroup( new_workgroup
);
5326 if ( strlen(calling_name
) != 0 ) {
5327 set_global_myname( calling_name
);
5329 TALLOC_FREE(calling_name
);
5330 calling_name
= talloc_strdup(frame
, global_myname() );
5333 smb_encrypt
= get_cmdline_auth_info_smb_encrypt(auth_info
);
5334 if (!init_names()) {
5335 fprintf(stderr
, "init_names() failed\n");
5339 if(new_name_resolve_order
)
5340 lp_set_name_resolve_order(new_name_resolve_order
);
5342 if (!tar_type
&& !query_host
&& !service
&& !message
) {
5343 poptPrintUsage(pc
, stderr
, 0);
5347 poptFreeContext(pc
);
5349 DEBUG(3,("Client started (version %s).\n", samba_version_string()));
5351 /* Ensure we have a password (or equivalent). */
5352 set_cmdline_auth_info_getpass(auth_info
);
5356 process_command_string(cmdstr
);
5357 return do_tar_op(base_directory
);
5360 if (query_host
&& *query_host
) {
5361 char *qhost
= query_host
;
5364 while (*qhost
== '\\' || *qhost
== '/')
5367 if ((slash
= strchr_m(qhost
, '/'))
5368 || (slash
= strchr_m(qhost
, '\\'))) {
5372 if ((p
=strchr_m(qhost
, '#'))) {
5375 sscanf(p
, "%x", &name_type
);
5378 return do_host_query(qhost
);
5382 return do_message_op(auth_info
);
5385 if (process(base_directory
)) {