2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Simo Sorce 2001-2002
6 Copyright (C) Jelmer Vernooij 2003
7 Copyright (C) Gerald (Jerry) Carter 2004
8 Copyright (C) Jeremy Allison 1994-2007
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "system/filesys.h"
26 #include "popt_common.h"
27 #include "rpc_client/cli_pipe.h"
28 #include "client/client_proto.h"
29 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
30 #include "../lib/util/select.h"
31 #include "system/readline.h"
32 #include "../libcli/smbreadline/smbreadline.h"
33 #include "../libcli/security/security.h"
34 #include "system/select.h"
35 #include "libsmb/clirap.h"
37 #include "libsmb/nmblib.h"
43 extern int do_smb_browse(void); /* mDNS browsing */
45 extern bool override_logfile
;
50 static char *desthost
;
51 static char *calling_name
;
52 static bool grepable
= false;
53 static char *cmdstr
= NULL
;
54 const char *cmd_ptr
= NULL
;
56 static int io_bufsize
= 524288;
58 static int name_type
= 0x20;
59 static int max_protocol
= PROTOCOL_NT1
;
61 static int process_tok(char *tok
);
62 static int cmd_help(void);
64 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
66 /* 30 second timeout on most commands */
67 #define CLIENT_TIMEOUT (30*1000)
68 #define SHORT_TIMEOUT (5*1000)
70 /* value for unused fid field in trans2 secondary request */
71 #define FID_UNUSED (0xFFFF)
73 time_t newer_than
= 0;
74 static int archive_level
= 0;
76 static bool translation
= false;
79 /* clitar bits insert */
82 extern bool tar_reset
;
85 static bool prompt
= true;
87 static bool recurse
= false;
88 static bool showacls
= false;
89 bool lowercase
= false;
91 static struct sockaddr_storage dest_ss
;
92 static char dest_ss_str
[INET6_ADDRSTRLEN
];
94 #define SEPARATORS " \t\n\r"
96 static bool abort_mget
= true;
99 uint64_t get_total_size
= 0;
100 unsigned int get_total_time_ms
= 0;
101 static uint64_t put_total_size
= 0;
102 static unsigned int put_total_time_ms
= 0;
105 static double dir_total
;
107 /* encrypted state. */
108 static bool smb_encrypt
;
110 /* root cli_state connection */
112 struct cli_state
*cli
;
114 static char CLI_DIRSEP_CHAR
= '\\';
115 static char CLI_DIRSEP_STR
[] = { '\\', '\0' };
117 /* Authentication for client connections. */
118 struct user_auth_info
*auth_info
;
120 /* Accessor functions for directory paths. */
121 static char *fileselection
;
122 static const char *client_get_fileselection(void)
125 return fileselection
;
130 static const char *client_set_fileselection(const char *new_fs
)
132 SAFE_FREE(fileselection
);
134 fileselection
= SMB_STRDUP(new_fs
);
136 return client_get_fileselection();
140 static const char *client_get_cwd(void)
145 return CLI_DIRSEP_STR
;
148 static const char *client_set_cwd(const char *new_cwd
)
152 cwd
= SMB_STRDUP(new_cwd
);
154 return client_get_cwd();
157 static char *cur_dir
;
158 const char *client_get_cur_dir(void)
163 return CLI_DIRSEP_STR
;
166 const char *client_set_cur_dir(const char *newdir
)
170 cur_dir
= SMB_STRDUP(newdir
);
172 return client_get_cur_dir();
175 /****************************************************************************
176 Put up a yes/no prompt.
177 ****************************************************************************/
179 static bool yesno(const char *p
)
184 if (!fgets(ans
,sizeof(ans
)-1,stdin
))
187 if (*ans
== 'y' || *ans
== 'Y')
193 /****************************************************************************
194 Write to a local file with CR/LF->LF translation if appropriate. Return the
195 number taken from the buffer. This may not equal the number written.
196 ****************************************************************************/
198 static int writefile(int f
, char *b
, int n
)
208 if (*b
== '\r' && (i
<(n
-1)) && *(b
+1) == '\n') {
211 if (write(f
, b
, 1) != 1) {
221 /****************************************************************************
222 Read from a file with LF->CR/LF translation if appropriate. Return the
223 number read. read approx n bytes.
224 ****************************************************************************/
226 static int readfile(uint8_t *b
, int n
, XFILE
*f
)
232 return x_fread(b
,1,n
,f
);
235 while (i
< (n
- 1) && (i
< BUFFER_SIZE
)) {
236 if ((c
= x_getc(f
)) == EOF
) {
240 if (c
== '\n') { /* change all LFs to CR/LF */
255 static size_t push_source(uint8_t *buf
, size_t n
, void *priv
)
257 struct push_state
*state
= (struct push_state
*)priv
;
260 if (x_feof(state
->f
)) {
264 result
= readfile(buf
, n
, state
->f
);
265 state
->nread
+= result
;
269 /****************************************************************************
271 ****************************************************************************/
273 static void send_message(const char *username
)
279 d_printf("Type your message, ending it with a Control-D\n");
282 while (i
<sizeof(buf
)-2) {
283 int c
= fgetc(stdin
);
294 status
= cli_message(cli
, desthost
, username
, buf
);
295 if (!NT_STATUS_IS_OK(status
)) {
296 d_fprintf(stderr
, "cli_message returned %s\n",
301 /****************************************************************************
302 Check the space on a device.
303 ****************************************************************************/
305 static int do_dskattr(void)
307 int total
, bsize
, avail
;
308 struct cli_state
*targetcli
= NULL
;
309 char *targetpath
= NULL
;
310 TALLOC_CTX
*ctx
= talloc_tos();
313 if ( !cli_resolve_path(ctx
, "", auth_info
, cli
, client_get_cur_dir(), &targetcli
, &targetpath
)) {
314 d_printf("Error in dskattr: %s\n", cli_errstr(cli
));
318 status
= cli_dskattr(targetcli
, &bsize
, &total
, &avail
);
319 if (!NT_STATUS_IS_OK(status
)) {
320 d_printf("Error in dskattr: %s\n", nt_errstr(status
));
324 d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
325 total
, bsize
, avail
);
330 /****************************************************************************
332 ****************************************************************************/
334 static int cmd_pwd(void)
336 d_printf("Current directory is %s",service
);
337 d_printf("%s\n",client_get_cur_dir());
341 /****************************************************************************
342 Ensure name has correct directory separators.
343 ****************************************************************************/
345 static void normalize_name(char *newdir
)
347 if (!(cli
->requested_posix_capabilities
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)) {
348 string_replace(newdir
,'/','\\');
352 /****************************************************************************
353 Change directory - inner section.
354 ****************************************************************************/
356 static int do_cd(const char *new_dir
)
359 char *saved_dir
= NULL
;
361 char *targetpath
= NULL
;
362 struct cli_state
*targetcli
= NULL
;
363 SMB_STRUCT_STAT sbuf
;
366 TALLOC_CTX
*ctx
= talloc_stackframe();
368 newdir
= talloc_strdup(ctx
, new_dir
);
374 normalize_name(newdir
);
376 /* Save the current directory in case the new directory is invalid */
378 saved_dir
= talloc_strdup(ctx
, client_get_cur_dir());
384 if (*newdir
== CLI_DIRSEP_CHAR
) {
385 client_set_cur_dir(newdir
);
388 new_cd
= talloc_asprintf(ctx
, "%s%s",
389 client_get_cur_dir(),
396 /* Ensure cur_dir ends in a DIRSEP */
397 if ((new_cd
[0] != '\0') && (*(new_cd
+strlen(new_cd
)-1) != CLI_DIRSEP_CHAR
)) {
398 new_cd
= talloc_asprintf_append(new_cd
, "%s", CLI_DIRSEP_STR
);
403 client_set_cur_dir(new_cd
);
405 new_cd
= clean_name(ctx
, new_cd
);
406 client_set_cur_dir(new_cd
);
408 if ( !cli_resolve_path(ctx
, "", auth_info
, cli
, new_cd
, &targetcli
, &targetpath
)) {
409 d_printf("cd %s: %s\n", new_cd
, cli_errstr(cli
));
410 client_set_cur_dir(saved_dir
);
414 if (strequal(targetpath
,CLI_DIRSEP_STR
)) {
419 /* Use a trans2_qpathinfo to test directories for modern servers.
420 Except Win9x doesn't support the qpathinfo_basic() call..... */
422 if (targetcli
->protocol
> PROTOCOL_LANMAN2
&& !targetcli
->win95
) {
425 status
= cli_qpathinfo_basic(targetcli
, targetpath
, &sbuf
,
427 if (!NT_STATUS_IS_OK(status
)) {
428 d_printf("cd %s: %s\n", new_cd
, nt_errstr(status
));
429 client_set_cur_dir(saved_dir
);
433 if (!(attributes
& FILE_ATTRIBUTE_DIRECTORY
)) {
434 d_printf("cd %s: not a directory\n", new_cd
);
435 client_set_cur_dir(saved_dir
);
441 targetpath
= talloc_asprintf(ctx
,
446 client_set_cur_dir(saved_dir
);
449 targetpath
= clean_name(ctx
, targetpath
);
451 client_set_cur_dir(saved_dir
);
455 status
= cli_chkpath(targetcli
, targetpath
);
456 if (!NT_STATUS_IS_OK(status
)) {
457 d_printf("cd %s: %s\n", new_cd
, nt_errstr(status
));
458 client_set_cur_dir(saved_dir
);
471 /****************************************************************************
473 ****************************************************************************/
475 static int cmd_cd(void)
480 if (next_token_talloc(talloc_tos(), &cmd_ptr
, &buf
,NULL
)) {
483 d_printf("Current directory is %s\n",client_get_cur_dir());
489 /****************************************************************************
491 ****************************************************************************/
493 static int cmd_cd_oneup(void)
498 /*******************************************************************
499 Decide if a file should be operated on.
500 ********************************************************************/
502 static bool do_this_one(struct file_info
*finfo
)
508 if (finfo
->mode
& aDIR
) {
512 if (*client_get_fileselection() &&
513 !mask_match(finfo
->name
,client_get_fileselection(),false)) {
514 DEBUG(3,("mask_match %s failed\n", finfo
->name
));
518 if (newer_than
&& finfo
->mtime_ts
.tv_sec
< newer_than
) {
519 DEBUG(3,("newer_than %s failed\n", finfo
->name
));
523 if ((archive_level
==1 || archive_level
==2) && !(finfo
->mode
& aARCH
)) {
524 DEBUG(3,("archive %s failed\n", finfo
->name
));
531 /****************************************************************************
532 Display info about a file.
533 ****************************************************************************/
535 static NTSTATUS
display_finfo(struct cli_state
*cli_state
, struct file_info
*finfo
,
539 TALLOC_CTX
*ctx
= talloc_tos();
540 NTSTATUS status
= NT_STATUS_OK
;
542 if (!do_this_one(finfo
)) {
546 t
= finfo
->mtime_ts
.tv_sec
; /* the time is assumed to be passed as GMT */
548 d_printf(" %-30s%7.7s %8.0f %s",
550 attrib_string(finfo
->mode
),
553 dir_total
+= finfo
->size
;
558 /* skip if this is . or .. */
559 if ( strequal(finfo
->name
,"..") || strequal(finfo
->name
,".") )
561 /* create absolute filename for cli_ntcreate() FIXME */
562 afname
= talloc_asprintf(ctx
,
568 return NT_STATUS_NO_MEMORY
;
570 /* print file meta date header */
571 d_printf( "FILENAME:%s\n", finfo
->name
);
572 d_printf( "MODE:%s\n", attrib_string(finfo
->mode
));
573 d_printf( "SIZE:%.0f\n", (double)finfo
->size
);
574 d_printf( "MTIME:%s", time_to_asc(t
));
575 status
= cli_ntcreate(cli_state
, afname
, 0,
576 CREATE_ACCESS_READ
, 0,
577 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
578 FILE_OPEN
, 0x0, 0x0, &fnum
);
579 if (!NT_STATUS_IS_OK(status
)) {
580 DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
581 afname
, nt_errstr(status
)));
583 struct security_descriptor
*sd
= NULL
;
584 sd
= cli_query_secdesc(cli_state
, fnum
, ctx
);
586 DEBUG( 0, ("display_finfo() failed to "
587 "get security descriptor: %s",
588 cli_errstr(cli_state
)));
589 status
= cli_nt_error(cli_state
);
591 display_sec_desc(sd
);
600 /****************************************************************************
601 Accumulate size of a file.
602 ****************************************************************************/
604 static NTSTATUS
do_du(struct cli_state
*cli_state
, struct file_info
*finfo
,
607 if (do_this_one(finfo
)) {
608 dir_total
+= finfo
->size
;
613 static bool do_list_recurse
;
614 static bool do_list_dirs
;
615 static char *do_list_queue
= 0;
616 static long do_list_queue_size
= 0;
617 static long do_list_queue_start
= 0;
618 static long do_list_queue_end
= 0;
619 static NTSTATUS (*do_list_fn
)(struct cli_state
*cli_state
, struct file_info
*,
622 /****************************************************************************
623 Functions for do_list_queue.
624 ****************************************************************************/
627 * The do_list_queue is a NUL-separated list of strings stored in a
628 * char*. Since this is a FIFO, we keep track of the beginning and
629 * ending locations of the data in the queue. When we overflow, we
630 * double the size of the char*. When the start of the data passes
631 * the midpoint, we move everything back. This is logically more
632 * complex than a linked list, but easier from a memory management
633 * angle. In any memory error condition, do_list_queue is reset.
634 * Functions check to ensure that do_list_queue is non-NULL before
638 static void reset_do_list_queue(void)
640 SAFE_FREE(do_list_queue
);
641 do_list_queue_size
= 0;
642 do_list_queue_start
= 0;
643 do_list_queue_end
= 0;
646 static void init_do_list_queue(void)
648 reset_do_list_queue();
649 do_list_queue_size
= 1024;
650 do_list_queue
= (char *)SMB_MALLOC(do_list_queue_size
);
651 if (do_list_queue
== 0) {
652 d_printf("malloc fail for size %d\n",
653 (int)do_list_queue_size
);
654 reset_do_list_queue();
656 memset(do_list_queue
, 0, do_list_queue_size
);
660 static void adjust_do_list_queue(void)
663 * If the starting point of the queue is more than half way through,
664 * move everything toward the beginning.
667 if (do_list_queue
== NULL
) {
668 DEBUG(4,("do_list_queue is empty\n"));
669 do_list_queue_start
= do_list_queue_end
= 0;
673 if (do_list_queue_start
== do_list_queue_end
) {
674 DEBUG(4,("do_list_queue is empty\n"));
675 do_list_queue_start
= do_list_queue_end
= 0;
676 *do_list_queue
= '\0';
677 } else if (do_list_queue_start
> (do_list_queue_size
/ 2)) {
678 DEBUG(4,("sliding do_list_queue backward\n"));
679 memmove(do_list_queue
,
680 do_list_queue
+ do_list_queue_start
,
681 do_list_queue_end
- do_list_queue_start
);
682 do_list_queue_end
-= do_list_queue_start
;
683 do_list_queue_start
= 0;
687 static void add_to_do_list_queue(const char *entry
)
689 long new_end
= do_list_queue_end
+ ((long)strlen(entry
)) + 1;
690 while (new_end
> do_list_queue_size
) {
691 do_list_queue_size
*= 2;
692 DEBUG(4,("enlarging do_list_queue to %d\n",
693 (int)do_list_queue_size
));
694 do_list_queue
= (char *)SMB_REALLOC(do_list_queue
, do_list_queue_size
);
695 if (! do_list_queue
) {
696 d_printf("failure enlarging do_list_queue to %d bytes\n",
697 (int)do_list_queue_size
);
698 reset_do_list_queue();
700 memset(do_list_queue
+ do_list_queue_size
/ 2,
701 0, do_list_queue_size
/ 2);
705 safe_strcpy_base(do_list_queue
+ do_list_queue_end
,
706 entry
, do_list_queue
, do_list_queue_size
);
707 do_list_queue_end
= new_end
;
708 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
709 entry
, (int)do_list_queue_start
, (int)do_list_queue_end
));
713 static char *do_list_queue_head(void)
715 return do_list_queue
+ do_list_queue_start
;
718 static void remove_do_list_queue_head(void)
720 if (do_list_queue_end
> do_list_queue_start
) {
721 do_list_queue_start
+= strlen(do_list_queue_head()) + 1;
722 adjust_do_list_queue();
723 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
724 (int)do_list_queue_start
, (int)do_list_queue_end
));
728 static int do_list_queue_empty(void)
730 return (! (do_list_queue
&& *do_list_queue
));
733 /****************************************************************************
734 A helper for do_list.
735 ****************************************************************************/
737 static NTSTATUS
do_list_helper(const char *mntpoint
, struct file_info
*f
,
738 const char *mask
, void *state
)
740 struct cli_state
*cli_state
= (struct cli_state
*)state
;
741 TALLOC_CTX
*ctx
= talloc_tos();
743 char *dir_end
= NULL
;
744 NTSTATUS status
= NT_STATUS_OK
;
746 /* Work out the directory. */
747 dir
= talloc_strdup(ctx
, mask
);
749 return NT_STATUS_NO_MEMORY
;
751 if ((dir_end
= strrchr(dir
, CLI_DIRSEP_CHAR
)) != NULL
) {
755 if (f
->mode
& aDIR
) {
756 if (do_list_dirs
&& do_this_one(f
)) {
757 status
= do_list_fn(cli_state
, f
, dir
);
758 if (!NT_STATUS_IS_OK(status
)) {
762 if (do_list_recurse
&&
764 !strequal(f
->name
,".") &&
765 !strequal(f
->name
,"..")) {
770 d_printf("Empty dir name returned. Possible server misconfiguration.\n");
772 return NT_STATUS_UNSUCCESSFUL
;
775 mask2
= talloc_asprintf(ctx
,
781 return NT_STATUS_NO_MEMORY
;
783 p
= strrchr_m(mask2
,CLI_DIRSEP_CHAR
);
789 mask2
= talloc_asprintf_append(mask2
,
795 return NT_STATUS_NO_MEMORY
;
797 add_to_do_list_queue(mask2
);
804 if (do_this_one(f
)) {
805 status
= do_list_fn(cli_state
, f
, dir
);
811 /****************************************************************************
812 A wrapper around cli_list that adds recursion.
813 ****************************************************************************/
815 NTSTATUS
do_list(const char *mask
,
817 NTSTATUS (*fn
)(struct cli_state
*cli_state
, struct file_info
*,
822 static int in_do_list
= 0;
823 TALLOC_CTX
*ctx
= talloc_tos();
824 struct cli_state
*targetcli
= NULL
;
825 char *targetpath
= NULL
;
826 NTSTATUS ret_status
= NT_STATUS_OK
;
827 NTSTATUS status
= NT_STATUS_OK
;
829 if (in_do_list
&& rec
) {
830 fprintf(stderr
, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
836 do_list_recurse
= rec
;
841 init_do_list_queue();
842 add_to_do_list_queue(mask
);
844 while (!do_list_queue_empty()) {
846 * Need to copy head so that it doesn't become
847 * invalid inside the call to cli_list. This
848 * would happen if the list were expanded
850 * Fix from E. Jay Berkenbilt (ejb@ql.org)
852 char *head
= talloc_strdup(ctx
, do_list_queue_head());
855 return NT_STATUS_NO_MEMORY
;
860 if ( !cli_resolve_path(ctx
, "", auth_info
, cli
, head
, &targetcli
, &targetpath
) ) {
861 d_printf("do_list: [%s] %s\n", head
, cli_errstr(cli
));
862 remove_do_list_queue_head();
866 status
= cli_list(targetcli
, targetpath
, attribute
,
867 do_list_helper
, targetcli
);
868 if (!NT_STATUS_IS_OK(status
)) {
869 d_printf("%s listing %s\n",
870 nt_errstr(status
), targetpath
);
873 remove_do_list_queue_head();
874 if ((! do_list_queue_empty()) && (fn
== display_finfo
)) {
875 char *next_file
= do_list_queue_head();
877 if ((strlen(next_file
) >= 2) &&
878 (next_file
[strlen(next_file
) - 1] == '*') &&
879 (next_file
[strlen(next_file
) - 2] == CLI_DIRSEP_CHAR
)) {
880 save_ch
= next_file
+
881 strlen(next_file
) - 2;
884 /* cwd is only used if showacls is on */
885 client_set_cwd(next_file
);
888 if (!showacls
) /* don't disturbe the showacls output */
889 d_printf("\n%s\n",next_file
);
891 *save_ch
= CLI_DIRSEP_CHAR
;
895 TALLOC_FREE(targetpath
);
899 if (cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetpath
)) {
901 status
= cli_list(targetcli
, targetpath
, attribute
,
902 do_list_helper
, targetcli
);
903 if (!NT_STATUS_IS_OK(status
)) {
904 d_printf("%s listing %s\n",
905 nt_errstr(status
), targetpath
);
908 TALLOC_FREE(targetpath
);
910 d_printf("do_list: [%s] %s\n", mask
, cli_errstr(cli
));
911 ret_status
= cli_nt_error(cli
);
916 reset_do_list_queue();
920 /****************************************************************************
921 Get a directory listing.
922 ****************************************************************************/
924 static int cmd_dir(void)
926 TALLOC_CTX
*ctx
= talloc_tos();
927 uint16 attribute
= aDIR
| aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
934 mask
= talloc_strdup(ctx
, client_get_cur_dir());
939 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
941 if (*buf
== CLI_DIRSEP_CHAR
) {
942 mask
= talloc_strdup(ctx
, buf
);
944 mask
= talloc_asprintf_append(mask
, "%s", buf
);
947 mask
= talloc_asprintf_append(mask
, "*");
954 /* cwd is only used if showacls is on */
955 client_set_cwd(client_get_cur_dir());
958 status
= do_list(mask
, attribute
, display_finfo
, recurse
, true);
959 if (!NT_STATUS_IS_OK(status
)) {
965 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total
));
970 /****************************************************************************
971 Get a directory listing.
972 ****************************************************************************/
974 static int cmd_du(void)
976 TALLOC_CTX
*ctx
= talloc_tos();
977 uint16 attribute
= aDIR
| aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
984 mask
= talloc_strdup(ctx
, client_get_cur_dir());
988 if ((mask
[0] != '\0') && (mask
[strlen(mask
)-1]!=CLI_DIRSEP_CHAR
)) {
989 mask
= talloc_asprintf_append(mask
, "%s", CLI_DIRSEP_STR
);
995 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
997 if (*buf
== CLI_DIRSEP_CHAR
) {
998 mask
= talloc_strdup(ctx
, buf
);
1000 mask
= talloc_asprintf_append(mask
, "%s", buf
);
1003 mask
= talloc_strdup(ctx
, "*");
1006 status
= do_list(mask
, attribute
, do_du
, recurse
, true);
1007 if (!NT_STATUS_IS_OK(status
)) {
1013 d_printf("Total number of bytes: %.0f\n", dir_total
);
1018 static int cmd_echo(void)
1020 TALLOC_CTX
*ctx
= talloc_tos();
1025 if (!next_token_talloc(ctx
, &cmd_ptr
, &num
, NULL
)
1026 || !next_token_talloc(ctx
, &cmd_ptr
, &data
, NULL
)) {
1027 d_printf("echo <num> <data>\n");
1031 status
= cli_echo(cli
, atoi(num
), data_blob_const(data
, strlen(data
)));
1033 if (!NT_STATUS_IS_OK(status
)) {
1034 d_printf("echo failed: %s\n", nt_errstr(status
));
1041 /****************************************************************************
1042 Get a file from rname to lname
1043 ****************************************************************************/
1045 static NTSTATUS
writefile_sink(char *buf
, size_t n
, void *priv
)
1047 int *pfd
= (int *)priv
;
1048 if (writefile(*pfd
, buf
, n
) == -1) {
1049 return map_nt_error_from_unix(errno
);
1051 return NT_STATUS_OK
;
1054 static int do_get(const char *rname
, const char *lname_in
, bool reget
)
1056 TALLOC_CTX
*ctx
= talloc_tos();
1059 bool newhandle
= false;
1060 struct timespec tp_start
;
1064 SMB_OFF_T nread
= 0;
1066 struct cli_state
*targetcli
= NULL
;
1067 char *targetname
= NULL
;
1071 lname
= talloc_strdup(ctx
, lname_in
);
1080 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, rname
, &targetcli
, &targetname
) ) {
1081 d_printf("Failed to open %s: %s\n", rname
, cli_errstr(cli
));
1085 clock_gettime_mono(&tp_start
);
1087 status
= cli_open(targetcli
, targetname
, O_RDONLY
, DENY_NONE
, &fnum
);
1088 if (!NT_STATUS_IS_OK(status
)) {
1089 d_printf("%s opening remote file %s\n", nt_errstr(status
),
1094 if(!strcmp(lname
,"-")) {
1095 handle
= fileno(stdout
);
1098 handle
= sys_open(lname
, O_WRONLY
|O_CREAT
, 0644);
1100 start
= sys_lseek(handle
, 0, SEEK_END
);
1102 d_printf("Error seeking local file\n");
1107 handle
= sys_open(lname
, O_WRONLY
|O_CREAT
|O_TRUNC
, 0644);
1112 d_printf("Error opening local file %s\n",lname
);
1117 status
= cli_qfileinfo_basic(targetcli
, fnum
, &attr
, &size
, NULL
, NULL
,
1119 if (!NT_STATUS_IS_OK(status
)) {
1120 status
= cli_getattrE(targetcli
, fnum
, &attr
, &size
, NULL
, NULL
,
1122 if(!NT_STATUS_IS_OK(status
)) {
1123 d_printf("getattrib: %s\n", nt_errstr(status
));
1128 DEBUG(1,("getting file %s of size %.0f as %s ",
1129 rname
, (double)size
, lname
));
1131 status
= cli_pull(targetcli
, fnum
, start
, size
, io_bufsize
,
1132 writefile_sink
, (void *)&handle
, &nread
);
1133 if (!NT_STATUS_IS_OK(status
)) {
1134 d_fprintf(stderr
, "parallel_read returned %s\n",
1136 cli_close(targetcli
, fnum
);
1140 status
= cli_close(targetcli
, fnum
);
1141 if (!NT_STATUS_IS_OK(status
)) {
1142 d_printf("Error %s closing remote file\n", nt_errstr(status
));
1150 if (archive_level
>= 2 && (attr
& aARCH
)) {
1151 cli_setatr(cli
, rname
, attr
& ~(uint16
)aARCH
, 0);
1155 struct timespec tp_end
;
1158 clock_gettime_mono(&tp_end
);
1159 this_time
= nsec_time_diff(&tp_end
,&tp_start
)/1000000;
1160 get_total_time_ms
+= this_time
;
1161 get_total_size
+= nread
;
1163 DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
1164 nread
/ (1.024*this_time
+ 1.0e-4),
1165 get_total_size
/ (1.024*get_total_time_ms
)));
1168 TALLOC_FREE(targetname
);
1172 /****************************************************************************
1174 ****************************************************************************/
1176 static int cmd_get(void)
1178 TALLOC_CTX
*ctx
= talloc_tos();
1183 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1188 if (!next_token_talloc(ctx
, &cmd_ptr
,&fname
,NULL
)) {
1189 d_printf("get <filename> [localname]\n");
1192 rname
= talloc_asprintf_append(rname
, "%s", fname
);
1196 rname
= clean_name(ctx
, rname
);
1201 next_token_talloc(ctx
, &cmd_ptr
,&lname
,NULL
);
1206 return do_get(rname
, lname
, false);
1209 /****************************************************************************
1210 Do an mget operation on one file.
1211 ****************************************************************************/
1213 static NTSTATUS
do_mget(struct cli_state
*cli_state
, struct file_info
*finfo
,
1216 TALLOC_CTX
*ctx
= talloc_tos();
1217 NTSTATUS status
= NT_STATUS_OK
;
1220 char *saved_curdir
= NULL
;
1221 char *mget_mask
= NULL
;
1222 char *new_cd
= NULL
;
1225 return NT_STATUS_OK
;
1228 if (strequal(finfo
->name
,".") || strequal(finfo
->name
,".."))
1229 return NT_STATUS_OK
;
1232 d_printf("mget aborted\n");
1233 return NT_STATUS_UNSUCCESSFUL
;
1236 if (finfo
->mode
& aDIR
) {
1237 if (asprintf(&quest
,
1238 "Get directory %s? ",finfo
->name
) < 0) {
1239 return NT_STATUS_NO_MEMORY
;
1242 if (asprintf(&quest
,
1243 "Get file %s? ",finfo
->name
) < 0) {
1244 return NT_STATUS_NO_MEMORY
;
1248 if (prompt
&& !yesno(quest
)) {
1250 return NT_STATUS_OK
;
1254 if (!(finfo
->mode
& aDIR
)) {
1255 rname
= talloc_asprintf(ctx
,
1257 client_get_cur_dir(),
1260 return NT_STATUS_NO_MEMORY
;
1262 do_get(rname
, finfo
->name
, false);
1264 return NT_STATUS_OK
;
1267 /* handle directories */
1268 saved_curdir
= talloc_strdup(ctx
, client_get_cur_dir());
1269 if (!saved_curdir
) {
1270 return NT_STATUS_NO_MEMORY
;
1273 new_cd
= talloc_asprintf(ctx
,
1275 client_get_cur_dir(),
1279 return NT_STATUS_NO_MEMORY
;
1281 client_set_cur_dir(new_cd
);
1283 string_replace(finfo
->name
,'\\','/');
1285 strlower_m(finfo
->name
);
1288 if (!directory_exist(finfo
->name
) &&
1289 mkdir(finfo
->name
,0777) != 0) {
1290 d_printf("failed to create directory %s\n",finfo
->name
);
1291 client_set_cur_dir(saved_curdir
);
1292 return map_nt_error_from_unix(errno
);
1295 if (chdir(finfo
->name
) != 0) {
1296 d_printf("failed to chdir to directory %s\n",finfo
->name
);
1297 client_set_cur_dir(saved_curdir
);
1298 return map_nt_error_from_unix(errno
);
1301 mget_mask
= talloc_asprintf(ctx
,
1303 client_get_cur_dir());
1306 return NT_STATUS_NO_MEMORY
;
1309 status
= do_list(mget_mask
, aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
| aDIR
,do_mget
,false, true);
1310 if (!NT_STATUS_IS_OK(status
)) {
1314 if (chdir("..") == -1) {
1315 d_printf("do_mget: failed to chdir to .. (error %s)\n",
1317 return map_nt_error_from_unix(errno
);
1319 client_set_cur_dir(saved_curdir
);
1320 TALLOC_FREE(mget_mask
);
1321 TALLOC_FREE(saved_curdir
);
1322 TALLOC_FREE(new_cd
);
1323 return NT_STATUS_OK
;
1326 /****************************************************************************
1327 View the file using the pager.
1328 ****************************************************************************/
1330 static int cmd_more(void)
1332 TALLOC_CTX
*ctx
= talloc_tos();
1336 char *pager_cmd
= NULL
;
1341 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1346 lname
= talloc_asprintf(ctx
, "%s/smbmore.XXXXXX",tmpdir());
1350 fd
= mkstemp(lname
);
1352 d_printf("failed to create temporary file for more\n");
1357 if (!next_token_talloc(ctx
, &cmd_ptr
,&fname
,NULL
)) {
1358 d_printf("more <filename>\n");
1362 rname
= talloc_asprintf_append(rname
, "%s", fname
);
1366 rname
= clean_name(ctx
,rname
);
1371 rc
= do_get(rname
, lname
, false);
1373 pager
=getenv("PAGER");
1375 pager_cmd
= talloc_asprintf(ctx
,
1377 (pager
? pager
:PAGER
),
1382 if (system(pager_cmd
) == -1) {
1383 d_printf("system command '%s' returned -1\n",
1391 /****************************************************************************
1393 ****************************************************************************/
1395 static int cmd_mget(void)
1397 TALLOC_CTX
*ctx
= talloc_tos();
1398 uint16 attribute
= aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
1399 char *mget_mask
= NULL
;
1401 NTSTATUS status
= NT_STATUS_OK
;
1409 while (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1411 mget_mask
= talloc_strdup(ctx
, client_get_cur_dir());
1415 if (*buf
== CLI_DIRSEP_CHAR
) {
1416 mget_mask
= talloc_strdup(ctx
, buf
);
1418 mget_mask
= talloc_asprintf_append(mget_mask
,
1424 status
= do_list(mget_mask
, attribute
, do_mget
, false, true);
1425 if (!NT_STATUS_IS_OK(status
)) {
1430 if (mget_mask
== NULL
) {
1431 d_printf("nothing to mget\n");
1436 mget_mask
= talloc_asprintf(ctx
,
1438 client_get_cur_dir());
1442 status
= do_list(mget_mask
, attribute
, do_mget
, false, true);
1443 if (!NT_STATUS_IS_OK(status
)) {
1451 /****************************************************************************
1452 Make a directory of name "name".
1453 ****************************************************************************/
1455 static bool do_mkdir(const char *name
)
1457 TALLOC_CTX
*ctx
= talloc_tos();
1458 struct cli_state
*targetcli
;
1459 char *targetname
= NULL
;
1462 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, name
, &targetcli
, &targetname
)) {
1463 d_printf("mkdir %s: %s\n", name
, cli_errstr(cli
));
1467 status
= cli_mkdir(targetcli
, targetname
);
1468 if (!NT_STATUS_IS_OK(status
)) {
1469 d_printf("%s making remote directory %s\n",
1470 nt_errstr(status
),name
);
1477 /****************************************************************************
1478 Show 8.3 name of a file.
1479 ****************************************************************************/
1481 static bool do_altname(const char *name
)
1486 status
= cli_qpathinfo_alt_name(cli
, name
, altname
);
1487 if (!NT_STATUS_IS_OK(status
)) {
1488 d_printf("%s getting alt name for %s\n",
1489 nt_errstr(status
),name
);
1492 d_printf("%s\n", altname
);
1497 /****************************************************************************
1499 ****************************************************************************/
1501 static int cmd_quit(void)
1509 /****************************************************************************
1511 ****************************************************************************/
1513 static int cmd_mkdir(void)
1515 TALLOC_CTX
*ctx
= talloc_tos();
1519 mask
= talloc_strdup(ctx
, client_get_cur_dir());
1524 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1526 d_printf("mkdir <dirname>\n");
1530 mask
= talloc_asprintf_append(mask
, "%s", buf
);
1538 struct cli_state
*targetcli
;
1539 char *targetname
= NULL
;
1543 ddir2
= talloc_strdup(ctx
, "");
1548 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
1552 ddir
= talloc_strdup(ctx
, targetname
);
1556 trim_char(ddir
,'.','\0');
1557 p
= strtok_r(ddir
, "/\\", &saveptr
);
1559 ddir2
= talloc_asprintf_append(ddir2
, "%s", p
);
1563 if (!NT_STATUS_IS_OK(cli_chkpath(targetcli
, ddir2
))) {
1566 ddir2
= talloc_asprintf_append(ddir2
, "%s", CLI_DIRSEP_STR
);
1570 p
= strtok_r(NULL
, "/\\", &saveptr
);
1579 /****************************************************************************
1581 ****************************************************************************/
1583 static int cmd_altname(void)
1585 TALLOC_CTX
*ctx
= talloc_tos();
1589 name
= talloc_strdup(ctx
, client_get_cur_dir());
1594 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
1595 d_printf("altname <file>\n");
1598 name
= talloc_asprintf_append(name
, "%s", buf
);
1606 static char *attr_str(TALLOC_CTX
*mem_ctx
, uint16_t mode
)
1608 char *attrs
= TALLOC_ZERO_ARRAY(mem_ctx
, char, 17);
1611 if (!(mode
& FILE_ATTRIBUTE_NORMAL
)) {
1612 if (mode
& FILE_ATTRIBUTE_ENCRYPTED
) {
1615 if (mode
& FILE_ATTRIBUTE_NONINDEXED
) {
1618 if (mode
& FILE_ATTRIBUTE_OFFLINE
) {
1621 if (mode
& FILE_ATTRIBUTE_COMPRESSED
) {
1624 if (mode
& FILE_ATTRIBUTE_REPARSE_POINT
) {
1627 if (mode
& FILE_ATTRIBUTE_SPARSE
) {
1630 if (mode
& FILE_ATTRIBUTE_TEMPORARY
) {
1633 if (mode
& FILE_ATTRIBUTE_NORMAL
) {
1636 if (mode
& FILE_ATTRIBUTE_READONLY
) {
1639 if (mode
& FILE_ATTRIBUTE_HIDDEN
) {
1642 if (mode
& FILE_ATTRIBUTE_SYSTEM
) {
1645 if (mode
& FILE_ATTRIBUTE_DIRECTORY
) {
1648 if (mode
& FILE_ATTRIBUTE_ARCHIVE
) {
1655 /****************************************************************************
1656 Show all info we can get
1657 ****************************************************************************/
1659 static int do_allinfo(const char *name
)
1662 struct timespec b_time
, a_time
, m_time
, c_time
;
1668 unsigned int num_streams
;
1669 struct stream_struct
*streams
;
1675 status
= cli_qpathinfo_alt_name(cli
, name
, altname
);
1676 if (!NT_STATUS_IS_OK(status
)) {
1677 d_printf("%s getting alt name for %s\n", nt_errstr(status
),
1681 d_printf("altname: %s\n", altname
);
1683 status
= cli_qpathinfo2(cli
, name
, &b_time
, &a_time
, &m_time
, &c_time
,
1684 &size
, &mode
, &ino
);
1685 if (!NT_STATUS_IS_OK(status
)) {
1686 d_printf("%s getting pathinfo for %s\n", nt_errstr(status
),
1691 unix_timespec_to_nt_time(&tmp
, b_time
);
1692 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1694 unix_timespec_to_nt_time(&tmp
, a_time
);
1695 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1697 unix_timespec_to_nt_time(&tmp
, m_time
);
1698 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1700 unix_timespec_to_nt_time(&tmp
, c_time
);
1701 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1703 d_printf("attributes: %s (%x)\n", attr_str(talloc_tos(), mode
), mode
);
1705 status
= cli_qpathinfo_streams(cli
, name
, talloc_tos(), &num_streams
,
1707 if (!NT_STATUS_IS_OK(status
)) {
1708 d_printf("%s getting streams for %s\n", nt_errstr(status
),
1713 for (i
=0; i
<num_streams
; i
++) {
1714 d_printf("stream: [%s], %lld bytes\n", streams
[i
].name
,
1715 (unsigned long long)streams
[i
].size
);
1718 status
= cli_ntcreate(cli
, name
, 0,
1719 CREATE_ACCESS_READ
, 0,
1720 FILE_SHARE_READ
|FILE_SHARE_WRITE
1722 FILE_OPEN
, 0x0, 0x0, &fnum
);
1723 if (!NT_STATUS_IS_OK(status
)) {
1725 * Ignore failure, it does not hurt if we can't list
1730 status
= cli_shadow_copy_data(talloc_tos(), cli
, fnum
,
1731 true, &snapshots
, &num_snapshots
);
1732 if (!NT_STATUS_IS_OK(status
)) {
1733 cli_close(cli
, fnum
);
1737 for (i
=0; i
<num_snapshots
; i
++) {
1740 d_printf("%s\n", snapshots
[i
]);
1741 snap_name
= talloc_asprintf(talloc_tos(), "%s%s",
1742 snapshots
[i
], name
);
1743 status
= cli_qpathinfo2(cli
, snap_name
, &b_time
, &a_time
,
1744 &m_time
, &c_time
, &size
,
1746 if (!NT_STATUS_IS_OK(status
)) {
1747 d_fprintf(stderr
, "pathinfo(%s) failed: %s\n",
1748 snap_name
, nt_errstr(status
));
1749 TALLOC_FREE(snap_name
);
1752 unix_timespec_to_nt_time(&tmp
, b_time
);
1753 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1754 unix_timespec_to_nt_time(&tmp
, a_time
);
1755 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1756 unix_timespec_to_nt_time(&tmp
, m_time
);
1757 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1758 unix_timespec_to_nt_time(&tmp
, c_time
);
1759 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp
));
1760 d_printf("size: %d\n", (int)size
);
1763 TALLOC_FREE(snapshots
);
1768 /****************************************************************************
1769 Show all info we can get
1770 ****************************************************************************/
1772 static int cmd_allinfo(void)
1774 TALLOC_CTX
*ctx
= talloc_tos();
1778 name
= talloc_strdup(ctx
, client_get_cur_dir());
1783 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
1784 d_printf("allinfo <file>\n");
1787 name
= talloc_asprintf_append(name
, "%s", buf
);
1797 /****************************************************************************
1799 ****************************************************************************/
1801 static int do_put(const char *rname
, const char *lname
, bool reput
)
1803 TALLOC_CTX
*ctx
= talloc_tos();
1806 SMB_OFF_T start
= 0;
1808 struct timespec tp_start
;
1809 struct cli_state
*targetcli
;
1810 char *targetname
= NULL
;
1811 struct push_state state
;
1814 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, rname
, &targetcli
, &targetname
)) {
1815 d_printf("Failed to open %s: %s\n", rname
, cli_errstr(cli
));
1819 clock_gettime_mono(&tp_start
);
1822 status
= cli_open(targetcli
, targetname
, O_RDWR
|O_CREAT
, DENY_NONE
, &fnum
);
1823 if (NT_STATUS_IS_OK(status
)) {
1824 if (!NT_STATUS_IS_OK(status
= cli_qfileinfo_basic(
1825 targetcli
, fnum
, NULL
,
1827 NULL
, NULL
, NULL
)) &&
1828 !NT_STATUS_IS_OK(status
= cli_getattrE(
1829 targetcli
, fnum
, NULL
,
1832 d_printf("getattrib: %s\n", nt_errstr(status
));
1837 status
= cli_open(targetcli
, targetname
, O_RDWR
|O_CREAT
|O_TRUNC
, DENY_NONE
, &fnum
);
1840 if (!NT_STATUS_IS_OK(status
)) {
1841 d_printf("%s opening remote file %s\n", nt_errstr(status
),
1846 /* allow files to be piped into smbclient
1849 Note that in this case this function will exit(0) rather
1851 if (!strcmp(lname
, "-")) {
1853 /* size of file is not known */
1855 f
= x_fopen(lname
,O_RDONLY
, 0);
1857 if (x_tseek(f
, start
, SEEK_SET
) == -1) {
1858 d_printf("Error seeking local file\n");
1866 d_printf("Error opening local file %s\n",lname
);
1870 DEBUG(1,("putting file %s as %s ",lname
,
1873 x_setvbuf(f
, NULL
, X_IOFBF
, io_bufsize
);
1878 status
= cli_push(targetcli
, fnum
, 0, 0, io_bufsize
, push_source
,
1880 if (!NT_STATUS_IS_OK(status
)) {
1881 d_fprintf(stderr
, "cli_push returned %s\n", nt_errstr(status
));
1885 status
= cli_close(targetcli
, fnum
);
1886 if (!NT_STATUS_IS_OK(status
)) {
1887 d_printf("%s closing remote file %s\n", nt_errstr(status
),
1900 struct timespec tp_end
;
1903 clock_gettime_mono(&tp_end
);
1904 this_time
= nsec_time_diff(&tp_end
,&tp_start
)/1000000;
1905 put_total_time_ms
+= this_time
;
1906 put_total_size
+= state
.nread
;
1908 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1909 state
.nread
/ (1.024*this_time
+ 1.0e-4),
1910 put_total_size
/ (1.024*put_total_time_ms
)));
1921 /****************************************************************************
1923 ****************************************************************************/
1925 static int cmd_put(void)
1927 TALLOC_CTX
*ctx
= talloc_tos();
1932 rname
= talloc_strdup(ctx
, client_get_cur_dir());
1937 if (!next_token_talloc(ctx
, &cmd_ptr
,&lname
,NULL
)) {
1938 d_printf("put <filename>\n");
1942 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
1943 rname
= talloc_asprintf_append(rname
, "%s", buf
);
1945 rname
= talloc_asprintf_append(rname
, "%s", lname
);
1951 rname
= clean_name(ctx
, rname
);
1958 /* allow '-' to represent stdin
1959 jdblair, 24.jun.98 */
1960 if (!file_exist_stat(lname
, &st
, false) &&
1961 (strcmp(lname
,"-"))) {
1962 d_printf("%s does not exist\n",lname
);
1967 return do_put(rname
, lname
, false);
1970 /*************************************
1971 File list structure.
1972 *************************************/
1974 static struct file_list
{
1975 struct file_list
*prev
, *next
;
1980 /****************************************************************************
1981 Free a file_list structure.
1982 ****************************************************************************/
1984 static void free_file_list (struct file_list
*l_head
)
1986 struct file_list
*list
, *next
;
1988 for (list
= l_head
; list
; list
= next
) {
1990 DLIST_REMOVE(l_head
, list
);
1991 SAFE_FREE(list
->file_path
);
1996 /****************************************************************************
1997 Seek in a directory/file list until you get something that doesn't start with
1999 ****************************************************************************/
2001 static bool seek_list(struct file_list
*list
, char *name
)
2004 trim_string(list
->file_path
,"./","\n");
2005 if (strncmp(list
->file_path
, name
, strlen(name
)) != 0) {
2014 /****************************************************************************
2015 Set the file selection mask.
2016 ****************************************************************************/
2018 static int cmd_select(void)
2020 TALLOC_CTX
*ctx
= talloc_tos();
2021 char *new_fs
= NULL
;
2022 next_token_talloc(ctx
, &cmd_ptr
,&new_fs
,NULL
)
2025 client_set_fileselection(new_fs
);
2027 client_set_fileselection("");
2032 /****************************************************************************
2033 Recursive file matching function act as find
2034 match must be always set to true when calling this function
2035 ****************************************************************************/
2037 static int file_find(struct file_list
**list
, const char *directory
,
2038 const char *expression
, bool match
)
2040 SMB_STRUCT_DIR
*dir
;
2041 struct file_list
*entry
;
2042 struct stat statbuf
;
2048 dir
= sys_opendir(directory
);
2052 while ((dname
= readdirname(dir
))) {
2053 if (!strcmp("..", dname
))
2055 if (!strcmp(".", dname
))
2058 if (asprintf(&path
, "%s/%s", directory
, dname
) <= 0) {
2063 if (!match
|| !gen_fnmatch(expression
, dname
)) {
2065 ret
= stat(path
, &statbuf
);
2067 if (S_ISDIR(statbuf
.st_mode
)) {
2069 ret
= file_find(list
, path
, expression
, false);
2072 d_printf("file_find: cannot stat file %s\n", path
);
2081 entry
= SMB_MALLOC_P(struct file_list
);
2083 d_printf("Out of memory in file_find\n");
2087 entry
->file_path
= path
;
2088 entry
->isdir
= isdir
;
2089 DLIST_ADD(*list
, entry
);
2099 /****************************************************************************
2101 ****************************************************************************/
2103 static int cmd_mput(void)
2105 TALLOC_CTX
*ctx
= talloc_tos();
2108 while (next_token_talloc(ctx
, &cmd_ptr
,&p
,NULL
)) {
2110 struct file_list
*temp_list
;
2111 char *quest
, *lname
, *rname
;
2115 ret
= file_find(&file_list
, ".", p
, true);
2117 free_file_list(file_list
);
2125 for (temp_list
= file_list
; temp_list
;
2126 temp_list
= temp_list
->next
) {
2129 if (asprintf(&lname
, "%s/", temp_list
->file_path
) <= 0) {
2132 trim_string(lname
, "./", "/");
2134 /* check if it's a directory */
2135 if (temp_list
->isdir
) {
2136 /* if (!recurse) continue; */
2139 if (asprintf(&quest
, "Put directory %s? ", lname
) < 0) {
2142 if (prompt
&& !yesno(quest
)) { /* No */
2143 /* Skip the directory */
2144 lname
[strlen(lname
)-1] = '/';
2145 if (!seek_list(temp_list
, lname
))
2149 if(asprintf(&rname
, "%s%s", client_get_cur_dir(), lname
) < 0) {
2152 normalize_name(rname
);
2153 if (!NT_STATUS_IS_OK(cli_chkpath(cli
, rname
)) &&
2155 DEBUG (0, ("Unable to make dir, skipping..."));
2156 /* Skip the directory */
2157 lname
[strlen(lname
)-1] = '/';
2158 if (!seek_list(temp_list
, lname
)) {
2166 if (asprintf(&quest
,"Put file %s? ", lname
) < 0) {
2169 if (prompt
&& !yesno(quest
)) {
2176 if (asprintf(&rname
, "%s%s", client_get_cur_dir(), lname
) < 0) {
2181 normalize_name(rname
);
2183 do_put(rname
, lname
, false);
2185 free_file_list(file_list
);
2194 /****************************************************************************
2196 ****************************************************************************/
2198 static int do_cancel(int job
)
2200 if (cli_printjob_del(cli
, job
)) {
2201 d_printf("Job %d cancelled\n",job
);
2204 d_printf("Error cancelling job %d : %s\n",job
,cli_errstr(cli
));
2209 /****************************************************************************
2211 ****************************************************************************/
2213 static int cmd_cancel(void)
2215 TALLOC_CTX
*ctx
= talloc_tos();
2219 if (!next_token_talloc(ctx
, &cmd_ptr
, &buf
,NULL
)) {
2220 d_printf("cancel <jobid> ...\n");
2226 } while (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
));
2231 /****************************************************************************
2233 ****************************************************************************/
2235 static int cmd_print(void)
2237 TALLOC_CTX
*ctx
= talloc_tos();
2242 if (!next_token_talloc(ctx
, &cmd_ptr
, &lname
,NULL
)) {
2243 d_printf("print <filename>\n");
2247 rname
= talloc_strdup(ctx
, lname
);
2251 p
= strrchr_m(rname
,'/');
2253 rname
= talloc_asprintf(ctx
,
2258 if (strequal(lname
,"-")) {
2259 rname
= talloc_asprintf(ctx
,
2267 return do_put(rname
, lname
, false);
2270 /****************************************************************************
2271 Show a print queue entry.
2272 ****************************************************************************/
2274 static void queue_fn(struct print_job_info
*p
)
2276 d_printf("%-6d %-9d %s\n", (int)p
->id
, (int)p
->size
, p
->name
);
2279 /****************************************************************************
2281 ****************************************************************************/
2283 static int cmd_queue(void)
2285 cli_print_queue(cli
, queue_fn
);
2289 /****************************************************************************
2291 ****************************************************************************/
2293 static NTSTATUS
do_del(struct cli_state
*cli_state
, struct file_info
*finfo
,
2296 TALLOC_CTX
*ctx
= talloc_tos();
2300 mask
= talloc_asprintf(ctx
,
2306 return NT_STATUS_NO_MEMORY
;
2309 if (finfo
->mode
& aDIR
) {
2311 return NT_STATUS_OK
;
2314 status
= cli_unlink(cli_state
, mask
, aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
);
2315 if (!NT_STATUS_IS_OK(status
)) {
2316 d_printf("%s deleting remote file %s\n",
2317 nt_errstr(status
), mask
);
2323 /****************************************************************************
2325 ****************************************************************************/
2327 static int cmd_del(void)
2329 TALLOC_CTX
*ctx
= talloc_tos();
2332 NTSTATUS status
= NT_STATUS_OK
;
2333 uint16 attribute
= aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
2339 mask
= talloc_strdup(ctx
, client_get_cur_dir());
2343 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2344 d_printf("del <filename>\n");
2347 mask
= talloc_asprintf_append(mask
, "%s", buf
);
2352 status
= do_list(mask
,attribute
,do_del
,false,false);
2353 if (!NT_STATUS_IS_OK(status
)) {
2359 /****************************************************************************
2360 Wildcard delete some files.
2361 ****************************************************************************/
2363 static int cmd_wdel(void)
2365 TALLOC_CTX
*ctx
= talloc_tos();
2369 struct cli_state
*targetcli
;
2370 char *targetname
= NULL
;
2373 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2374 d_printf("wdel 0x<attrib> <wcard>\n");
2378 attribute
= (uint16
)strtol(buf
, (char **)NULL
, 16);
2380 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2381 d_printf("wdel 0x<attrib> <wcard>\n");
2385 mask
= talloc_asprintf(ctx
, "%s%s",
2386 client_get_cur_dir(),
2392 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2393 d_printf("cmd_wdel %s: %s\n", mask
, cli_errstr(cli
));
2397 status
= cli_unlink(targetcli
, targetname
, attribute
);
2398 if (!NT_STATUS_IS_OK(status
)) {
2399 d_printf("%s deleting remote files %s\n", nt_errstr(status
),
2405 /****************************************************************************
2406 ****************************************************************************/
2408 static int cmd_open(void)
2410 TALLOC_CTX
*ctx
= talloc_tos();
2413 char *targetname
= NULL
;
2414 struct cli_state
*targetcli
;
2415 uint16_t fnum
= (uint16_t)-1;
2417 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2418 d_printf("open <filename>\n");
2421 mask
= talloc_asprintf(ctx
,
2423 client_get_cur_dir(),
2429 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2430 d_printf("open %s: %s\n", mask
, cli_errstr(cli
));
2434 if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli
, targetname
, 0,
2435 FILE_READ_DATA
|FILE_WRITE_DATA
, 0,
2436 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
, 0x0, 0x0, &fnum
))) {
2437 if (NT_STATUS_IS_OK(cli_ntcreate(targetcli
, targetname
, 0,
2439 FILE_SHARE_READ
|FILE_SHARE_WRITE
, FILE_OPEN
, 0x0, 0x0, &fnum
))) {
2440 d_printf("open file %s: for read/write fnum %d\n", targetname
, fnum
);
2442 d_printf("Failed to open file %s. %s\n", targetname
, cli_errstr(cli
));
2445 d_printf("open file %s: for read/write fnum %d\n", targetname
, fnum
);
2450 static int cmd_posix_encrypt(void)
2452 TALLOC_CTX
*ctx
= talloc_tos();
2453 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
2455 if (cli
->use_kerberos
) {
2456 status
= cli_gss_smb_encryption_start(cli
);
2458 char *domain
= NULL
;
2460 char *password
= NULL
;
2462 if (!next_token_talloc(ctx
, &cmd_ptr
,&domain
,NULL
)) {
2463 d_printf("posix_encrypt domain user password\n");
2467 if (!next_token_talloc(ctx
, &cmd_ptr
,&user
,NULL
)) {
2468 d_printf("posix_encrypt domain user password\n");
2472 if (!next_token_talloc(ctx
, &cmd_ptr
,&password
,NULL
)) {
2473 d_printf("posix_encrypt domain user password\n");
2477 status
= cli_raw_ntlm_smb_encryption_start(cli
,
2483 if (!NT_STATUS_IS_OK(status
)) {
2484 d_printf("posix_encrypt failed with error %s\n", nt_errstr(status
));
2486 d_printf("encryption on\n");
2493 /****************************************************************************
2494 ****************************************************************************/
2496 static int cmd_posix_open(void)
2498 TALLOC_CTX
*ctx
= talloc_tos();
2501 char *targetname
= NULL
;
2502 struct cli_state
*targetcli
;
2506 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2507 d_printf("posix_open <filename> 0<mode>\n");
2510 mask
= talloc_asprintf(ctx
,
2512 client_get_cur_dir(),
2518 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2519 d_printf("posix_open <filename> 0<mode>\n");
2522 mode
= (mode_t
)strtol(buf
, (char **)NULL
, 8);
2524 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2525 d_printf("posix_open %s: %s\n", mask
, cli_errstr(cli
));
2529 if (!NT_STATUS_IS_OK(cli_posix_open(targetcli
, targetname
, O_CREAT
|O_RDWR
, mode
, &fnum
))) {
2530 if (!NT_STATUS_IS_OK(cli_posix_open(targetcli
, targetname
, O_CREAT
|O_RDONLY
, mode
, &fnum
))) {
2531 d_printf("posix_open file %s: for read/write fnum %d\n", targetname
, fnum
);
2533 d_printf("Failed to open file %s. %s\n", targetname
, cli_errstr(cli
));
2536 d_printf("posix_open file %s: for read/write fnum %d\n", targetname
, fnum
);
2542 static int cmd_posix_mkdir(void)
2544 TALLOC_CTX
*ctx
= talloc_tos();
2547 char *targetname
= NULL
;
2548 struct cli_state
*targetcli
;
2551 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2552 d_printf("posix_mkdir <filename> 0<mode>\n");
2555 mask
= talloc_asprintf(ctx
,
2557 client_get_cur_dir(),
2563 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2564 d_printf("posix_mkdir <filename> 0<mode>\n");
2567 mode
= (mode_t
)strtol(buf
, (char **)NULL
, 8);
2569 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2570 d_printf("posix_mkdir %s: %s\n", mask
, cli_errstr(cli
));
2574 if (!NT_STATUS_IS_OK(cli_posix_mkdir(targetcli
, targetname
, mode
))) {
2575 d_printf("Failed to open file %s. %s\n", targetname
, cli_errstr(cli
));
2577 d_printf("posix_mkdir created directory %s\n", targetname
);
2582 static int cmd_posix_unlink(void)
2584 TALLOC_CTX
*ctx
= talloc_tos();
2587 char *targetname
= NULL
;
2588 struct cli_state
*targetcli
;
2590 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2591 d_printf("posix_unlink <filename>\n");
2594 mask
= talloc_asprintf(ctx
,
2596 client_get_cur_dir(),
2602 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2603 d_printf("posix_unlink %s: %s\n", mask
, cli_errstr(cli
));
2607 if (!NT_STATUS_IS_OK(cli_posix_unlink(targetcli
, targetname
))) {
2608 d_printf("Failed to unlink file %s. %s\n", targetname
, cli_errstr(cli
));
2610 d_printf("posix_unlink deleted file %s\n", targetname
);
2616 static int cmd_posix_rmdir(void)
2618 TALLOC_CTX
*ctx
= talloc_tos();
2621 char *targetname
= NULL
;
2622 struct cli_state
*targetcli
;
2624 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2625 d_printf("posix_rmdir <filename>\n");
2628 mask
= talloc_asprintf(ctx
,
2630 client_get_cur_dir(),
2636 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2637 d_printf("posix_rmdir %s: %s\n", mask
, cli_errstr(cli
));
2641 if (!NT_STATUS_IS_OK(cli_posix_rmdir(targetcli
, targetname
))) {
2642 d_printf("Failed to unlink directory %s. %s\n", targetname
, cli_errstr(cli
));
2644 d_printf("posix_rmdir deleted directory %s\n", targetname
);
2650 static int cmd_close(void)
2652 TALLOC_CTX
*ctx
= talloc_tos();
2656 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2657 d_printf("close <fnum>\n");
2662 /* We really should use the targetcli here.... */
2663 if (!NT_STATUS_IS_OK(cli_close(cli
, fnum
))) {
2664 d_printf("close %d: %s\n", fnum
, cli_errstr(cli
));
2670 static int cmd_posix(void)
2672 TALLOC_CTX
*ctx
= talloc_tos();
2673 uint16 major
, minor
;
2674 uint32 caplow
, caphigh
;
2678 if (!SERVER_HAS_UNIX_CIFS(cli
)) {
2679 d_printf("Server doesn't support UNIX CIFS extensions.\n");
2683 status
= cli_unix_extensions_version(cli
, &major
, &minor
, &caplow
,
2685 if (!NT_STATUS_IS_OK(status
)) {
2686 d_printf("Can't get UNIX CIFS extensions version from "
2687 "server: %s\n", nt_errstr(status
));
2691 d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major
, (unsigned int)minor
);
2693 caps
= talloc_strdup(ctx
, "");
2697 if (caplow
& CIFS_UNIX_FCNTL_LOCKS_CAP
) {
2698 caps
= talloc_asprintf_append(caps
, "locks ");
2703 if (caplow
& CIFS_UNIX_POSIX_ACLS_CAP
) {
2704 caps
= talloc_asprintf_append(caps
, "acls ");
2709 if (caplow
& CIFS_UNIX_XATTTR_CAP
) {
2710 caps
= talloc_asprintf_append(caps
, "eas ");
2715 if (caplow
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2716 caps
= talloc_asprintf_append(caps
, "pathnames ");
2721 if (caplow
& CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
) {
2722 caps
= talloc_asprintf_append(caps
, "posix_path_operations ");
2727 if (caplow
& CIFS_UNIX_LARGE_READ_CAP
) {
2728 caps
= talloc_asprintf_append(caps
, "large_read ");
2733 if (caplow
& CIFS_UNIX_LARGE_WRITE_CAP
) {
2734 caps
= talloc_asprintf_append(caps
, "large_write ");
2739 if (caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
) {
2740 caps
= talloc_asprintf_append(caps
, "posix_encrypt ");
2745 if (caplow
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
) {
2746 caps
= talloc_asprintf_append(caps
, "mandatory_posix_encrypt ");
2752 if (*caps
&& caps
[strlen(caps
)-1] == ' ') {
2753 caps
[strlen(caps
)-1] = '\0';
2756 d_printf("Server supports CIFS capabilities %s\n", caps
);
2758 status
= cli_set_unix_extensions_capabilities(cli
, major
, minor
,
2760 if (!NT_STATUS_IS_OK(status
)) {
2761 d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n",
2766 if (caplow
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
2767 CLI_DIRSEP_CHAR
= '/';
2768 *CLI_DIRSEP_STR
= '/';
2769 client_set_cur_dir(CLI_DIRSEP_STR
);
2775 static int cmd_lock(void)
2777 TALLOC_CTX
*ctx
= talloc_tos();
2779 uint64_t start
, len
;
2780 enum brl_type lock_type
;
2783 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2784 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2789 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2790 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2794 if (*buf
== 'r' || *buf
== 'R') {
2795 lock_type
= READ_LOCK
;
2796 } else if (*buf
== 'w' || *buf
== 'W') {
2797 lock_type
= WRITE_LOCK
;
2799 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2803 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2804 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2808 start
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2810 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2811 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
2815 len
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2817 if (!NT_STATUS_IS_OK(cli_posix_lock(cli
, fnum
, start
, len
, true, lock_type
))) {
2818 d_printf("lock failed %d: %s\n", fnum
, cli_errstr(cli
));
2824 static int cmd_unlock(void)
2826 TALLOC_CTX
*ctx
= talloc_tos();
2828 uint64_t start
, len
;
2831 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2832 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2837 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2838 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2842 start
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2844 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2845 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
2849 len
= (uint64_t)strtol(buf
, (char **)NULL
, 16);
2851 if (!NT_STATUS_IS_OK(cli_posix_unlock(cli
, fnum
, start
, len
))) {
2852 d_printf("unlock failed %d: %s\n", fnum
, cli_errstr(cli
));
2859 /****************************************************************************
2861 ****************************************************************************/
2863 static int cmd_rmdir(void)
2865 TALLOC_CTX
*ctx
= talloc_tos();
2868 char *targetname
= NULL
;
2869 struct cli_state
*targetcli
;
2871 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2872 d_printf("rmdir <dirname>\n");
2875 mask
= talloc_asprintf(ctx
,
2877 client_get_cur_dir(),
2883 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, mask
, &targetcli
, &targetname
)) {
2884 d_printf("rmdir %s: %s\n", mask
, cli_errstr(cli
));
2888 if (!NT_STATUS_IS_OK(cli_rmdir(targetcli
, targetname
))) {
2889 d_printf("%s removing remote directory file %s\n",
2890 cli_errstr(targetcli
),mask
);
2896 /****************************************************************************
2898 ****************************************************************************/
2900 static int cmd_link(void)
2902 TALLOC_CTX
*ctx
= talloc_tos();
2903 char *oldname
= NULL
;
2904 char *newname
= NULL
;
2907 char *targetname
= NULL
;
2908 struct cli_state
*targetcli
;
2910 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
2911 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
2912 d_printf("link <oldname> <newname>\n");
2915 oldname
= talloc_asprintf(ctx
,
2917 client_get_cur_dir(),
2922 newname
= talloc_asprintf(ctx
,
2924 client_get_cur_dir(),
2930 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, oldname
, &targetcli
, &targetname
)) {
2931 d_printf("link %s: %s\n", oldname
, cli_errstr(cli
));
2935 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
2936 d_printf("Server doesn't support UNIX CIFS calls.\n");
2940 if (!NT_STATUS_IS_OK(cli_posix_hardlink(targetcli
, targetname
, newname
))) {
2941 d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli
), newname
, oldname
);
2947 /****************************************************************************
2949 ****************************************************************************/
2951 static int cmd_readlink(void)
2953 TALLOC_CTX
*ctx
= talloc_tos();
2956 char *targetname
= NULL
;
2957 char linkname
[PATH_MAX
+1];
2958 struct cli_state
*targetcli
;
2960 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
2961 d_printf("readlink <name>\n");
2964 name
= talloc_asprintf(ctx
,
2966 client_get_cur_dir(),
2972 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, name
, &targetcli
, &targetname
)) {
2973 d_printf("readlink %s: %s\n", name
, cli_errstr(cli
));
2977 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
2978 d_printf("Server doesn't support UNIX CIFS calls.\n");
2982 if (!NT_STATUS_IS_OK(cli_posix_readlink(targetcli
, name
,
2983 linkname
, PATH_MAX
+1))) {
2984 d_printf("%s readlink on file %s\n",
2985 cli_errstr(targetcli
), name
);
2989 d_printf("%s -> %s\n", name
, linkname
);
2995 /****************************************************************************
2997 ****************************************************************************/
2999 static int cmd_symlink(void)
3001 TALLOC_CTX
*ctx
= talloc_tos();
3002 char *oldname
= NULL
;
3003 char *newname
= NULL
;
3006 struct cli_state
*newcli
;
3008 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3009 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3010 d_printf("symlink <oldname> <newname>\n");
3013 /* Oldname (link target) must be an untouched blob. */
3016 newname
= talloc_asprintf(ctx
,
3018 client_get_cur_dir(),
3024 /* New name must be present in share namespace. */
3025 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, newname
, &newcli
, &newname
)) {
3026 d_printf("link %s: %s\n", oldname
, cli_errstr(cli
));
3030 if (!SERVER_HAS_UNIX_CIFS(newcli
)) {
3031 d_printf("Server doesn't support UNIX CIFS calls.\n");
3035 if (!NT_STATUS_IS_OK(cli_posix_symlink(newcli
, oldname
, newname
))) {
3036 d_printf("%s symlinking files (%s -> %s)\n",
3037 cli_errstr(newcli
), newname
, newname
);
3044 /****************************************************************************
3046 ****************************************************************************/
3048 static int cmd_chmod(void)
3050 TALLOC_CTX
*ctx
= talloc_tos();
3054 char *targetname
= NULL
;
3055 struct cli_state
*targetcli
;
3058 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3059 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3060 d_printf("chmod mode file\n");
3063 src
= talloc_asprintf(ctx
,
3065 client_get_cur_dir(),
3071 mode
= (mode_t
)strtol(buf
, NULL
, 8);
3073 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3074 d_printf("chmod %s: %s\n", src
, cli_errstr(cli
));
3078 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3079 d_printf("Server doesn't support UNIX CIFS calls.\n");
3083 if (!NT_STATUS_IS_OK(cli_posix_chmod(targetcli
, targetname
, mode
))) {
3084 d_printf("%s chmod file %s 0%o\n",
3085 cli_errstr(targetcli
), src
, (unsigned int)mode
);
3092 static const char *filetype_to_str(mode_t mode
)
3094 if (S_ISREG(mode
)) {
3095 return "regular file";
3096 } else if (S_ISDIR(mode
)) {
3100 if (S_ISCHR(mode
)) {
3101 return "character device";
3105 if (S_ISBLK(mode
)) {
3106 return "block device";
3110 if (S_ISFIFO(mode
)) {
3115 if (S_ISLNK(mode
)) {
3116 return "symbolic link";
3120 if (S_ISSOCK(mode
)) {
3127 static char rwx_to_str(mode_t m
, mode_t bt
, char ret
)
3136 static char *unix_mode_to_str(char *s
, mode_t m
)
3139 const char *str
= filetype_to_str(m
);
3155 *p
++ = str
[1] == 'y' ? 'l' : 's';
3162 *p
++ = rwx_to_str(m
, S_IRUSR
, 'r');
3163 *p
++ = rwx_to_str(m
, S_IWUSR
, 'w');
3164 *p
++ = rwx_to_str(m
, S_IXUSR
, 'x');
3165 *p
++ = rwx_to_str(m
, S_IRGRP
, 'r');
3166 *p
++ = rwx_to_str(m
, S_IWGRP
, 'w');
3167 *p
++ = rwx_to_str(m
, S_IXGRP
, 'x');
3168 *p
++ = rwx_to_str(m
, S_IROTH
, 'r');
3169 *p
++ = rwx_to_str(m
, S_IWOTH
, 'w');
3170 *p
++ = rwx_to_str(m
, S_IXOTH
, 'x');
3175 /****************************************************************************
3176 Utility function for UNIX getfacl.
3177 ****************************************************************************/
3179 static char *perms_to_string(fstring permstr
, unsigned char perms
)
3181 fstrcpy(permstr
, "---");
3182 if (perms
& SMB_POSIX_ACL_READ
) {
3185 if (perms
& SMB_POSIX_ACL_WRITE
) {
3188 if (perms
& SMB_POSIX_ACL_EXECUTE
) {
3194 /****************************************************************************
3196 ****************************************************************************/
3198 static int cmd_getfacl(void)
3200 TALLOC_CTX
*ctx
= talloc_tos();
3203 char *targetname
= NULL
;
3204 struct cli_state
*targetcli
;
3205 uint16 major
, minor
;
3206 uint32 caplow
, caphigh
;
3207 char *retbuf
= NULL
;
3209 SMB_STRUCT_STAT sbuf
;
3210 uint16 num_file_acls
= 0;
3211 uint16 num_dir_acls
= 0;
3215 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3216 d_printf("getfacl filename\n");
3219 src
= talloc_asprintf(ctx
,
3221 client_get_cur_dir(),
3227 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3228 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3232 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3233 d_printf("Server doesn't support UNIX CIFS calls.\n");
3237 status
= cli_unix_extensions_version(targetcli
, &major
, &minor
,
3239 if (!NT_STATUS_IS_OK(status
)) {
3240 d_printf("Can't get UNIX CIFS version from server: %s.\n",
3245 if (!(caplow
& CIFS_UNIX_POSIX_ACLS_CAP
)) {
3246 d_printf("This server supports UNIX extensions "
3247 "but doesn't support POSIX ACLs.\n");
3251 if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli
, targetname
, &sbuf
))) {
3252 d_printf("%s getfacl doing a stat on file %s\n",
3253 cli_errstr(targetcli
), src
);
3257 if (!NT_STATUS_IS_OK(cli_posix_getfacl(targetcli
, targetname
, ctx
, &rb_size
, &retbuf
))) {
3258 d_printf("%s getfacl file %s\n",
3259 cli_errstr(targetcli
), src
);
3263 /* ToDo : Print out the ACL values. */
3264 if (rb_size
< 6 || SVAL(retbuf
,0) != SMB_POSIX_ACL_VERSION
) {
3265 d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
3266 src
, (unsigned int)CVAL(retbuf
,0) );
3270 num_file_acls
= SVAL(retbuf
,2);
3271 num_dir_acls
= SVAL(retbuf
,4);
3272 if (rb_size
!= SMB_POSIX_ACL_HEADER_SIZE
+ SMB_POSIX_ACL_ENTRY_SIZE
*(num_file_acls
+num_dir_acls
)) {
3273 d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
3275 (unsigned int)(SMB_POSIX_ACL_HEADER_SIZE
+ SMB_POSIX_ACL_ENTRY_SIZE
*(num_file_acls
+num_dir_acls
)),
3276 (unsigned int)rb_size
);
3280 d_printf("# file: %s\n", src
);
3281 d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf
.st_ex_uid
, (unsigned int)sbuf
.st_ex_gid
);
3283 if (num_file_acls
== 0 && num_dir_acls
== 0) {
3284 d_printf("No acls found.\n");
3287 for (i
= 0; i
< num_file_acls
; i
++) {
3290 unsigned char tagtype
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
));
3291 unsigned char perms
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+1);
3294 case SMB_POSIX_ACL_USER_OBJ
:
3297 case SMB_POSIX_ACL_USER
:
3298 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3299 d_printf("user:%u:", uorg
);
3301 case SMB_POSIX_ACL_GROUP_OBJ
:
3302 d_printf("group::");
3304 case SMB_POSIX_ACL_GROUP
:
3305 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+(i
*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3306 d_printf("group:%u:", uorg
);
3308 case SMB_POSIX_ACL_MASK
:
3311 case SMB_POSIX_ACL_OTHER
:
3312 d_printf("other::");
3315 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3316 src
, (unsigned int)tagtype
);
3321 d_printf("%s\n", perms_to_string(permstring
, perms
));
3324 for (i
= 0; i
< num_dir_acls
; i
++) {
3327 unsigned char tagtype
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
));
3328 unsigned char perms
= CVAL(retbuf
, SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+1);
3331 case SMB_POSIX_ACL_USER_OBJ
:
3332 d_printf("default:user::");
3334 case SMB_POSIX_ACL_USER
:
3335 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3336 d_printf("default:user:%u:", uorg
);
3338 case SMB_POSIX_ACL_GROUP_OBJ
:
3339 d_printf("default:group::");
3341 case SMB_POSIX_ACL_GROUP
:
3342 uorg
= IVAL(retbuf
,SMB_POSIX_ACL_HEADER_SIZE
+((i
+num_file_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
)+2);
3343 d_printf("default:group:%u:", uorg
);
3345 case SMB_POSIX_ACL_MASK
:
3346 d_printf("default:mask::");
3348 case SMB_POSIX_ACL_OTHER
:
3349 d_printf("default:other::");
3352 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3353 src
, (unsigned int)tagtype
);
3358 d_printf("%s\n", perms_to_string(permstring
, perms
));
3364 static void printf_cb(const char *buf
, void *private_data
)
3369 /****************************************************************************
3370 Get the EA list of a file
3371 ****************************************************************************/
3373 static int cmd_geteas(void)
3375 TALLOC_CTX
*ctx
= talloc_tos();
3378 char *targetname
= NULL
;
3379 struct cli_state
*targetcli
;
3382 struct ea_struct
*eas
;
3384 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3385 d_printf("geteas filename\n");
3388 src
= talloc_asprintf(ctx
,
3390 client_get_cur_dir(),
3396 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
,
3398 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3402 status
= cli_get_ea_list_path(targetcli
, targetname
, talloc_tos(),
3404 if (!NT_STATUS_IS_OK(status
)) {
3405 d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status
));
3409 for (i
=0; i
<num_eas
; i
++) {
3410 d_printf("%s (%d) =\n", eas
[i
].name
, (int)eas
[i
].flags
);
3411 dump_data_cb(eas
[i
].value
.data
, eas
[i
].value
.length
, false,
3421 /****************************************************************************
3423 ****************************************************************************/
3425 static int cmd_setea(void)
3427 TALLOC_CTX
*ctx
= talloc_tos();
3430 char *eaname
= NULL
;
3431 char *eavalue
= NULL
;
3432 char *targetname
= NULL
;
3433 struct cli_state
*targetcli
;
3436 if (!next_token_talloc(ctx
, &cmd_ptr
, &name
, NULL
)
3437 || !next_token_talloc(ctx
, &cmd_ptr
, &eaname
, NULL
)) {
3438 d_printf("setea filename eaname value\n");
3441 if (!next_token_talloc(ctx
, &cmd_ptr
, &eavalue
, NULL
)) {
3442 eavalue
= talloc_strdup(ctx
, "");
3444 src
= talloc_asprintf(ctx
,
3446 client_get_cur_dir(),
3452 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
,
3454 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3458 status
= cli_set_ea_path(targetcli
, targetname
, eaname
, eavalue
,
3460 if (!NT_STATUS_IS_OK(status
)) {
3461 d_printf("set_ea %s: %s\n", src
, nt_errstr(status
));
3468 /****************************************************************************
3470 ****************************************************************************/
3472 static int cmd_stat(void)
3474 TALLOC_CTX
*ctx
= talloc_tos();
3477 char *targetname
= NULL
;
3478 struct cli_state
*targetcli
;
3480 SMB_STRUCT_STAT sbuf
;
3484 if (!next_token_talloc(ctx
, &cmd_ptr
,&name
,NULL
)) {
3485 d_printf("stat file\n");
3488 src
= talloc_asprintf(ctx
,
3490 client_get_cur_dir(),
3496 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3497 d_printf("stat %s: %s\n", src
, cli_errstr(cli
));
3501 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3502 d_printf("Server doesn't support UNIX CIFS calls.\n");
3506 if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli
, targetname
, &sbuf
))) {
3507 d_printf("%s stat file %s\n",
3508 cli_errstr(targetcli
), src
);
3512 /* Print out the stat values. */
3513 d_printf("File: %s\n", src
);
3514 d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
3515 (double)sbuf
.st_ex_size
,
3516 (unsigned int)sbuf
.st_ex_blocks
,
3517 filetype_to_str(sbuf
.st_ex_mode
));
3519 #if defined(S_ISCHR) && defined(S_ISBLK)
3520 if (S_ISCHR(sbuf
.st_ex_mode
) || S_ISBLK(sbuf
.st_ex_mode
)) {
3521 d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
3522 (double)sbuf
.st_ex_ino
,
3523 (unsigned int)sbuf
.st_ex_nlink
,
3524 unix_dev_major(sbuf
.st_ex_rdev
),
3525 unix_dev_minor(sbuf
.st_ex_rdev
));
3528 d_printf("Inode: %.0f\tLinks: %u\n",
3529 (double)sbuf
.st_ex_ino
,
3530 (unsigned int)sbuf
.st_ex_nlink
);
3532 d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
3533 ((int)sbuf
.st_ex_mode
& 0777),
3534 unix_mode_to_str(mode_str
, sbuf
.st_ex_mode
),
3535 (unsigned int)sbuf
.st_ex_uid
,
3536 (unsigned int)sbuf
.st_ex_gid
);
3538 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_atime
);
3539 lt
= localtime(&tmp_time
);
3541 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3543 fstrcpy(mode_str
, "unknown");
3545 d_printf("Access: %s\n", mode_str
);
3547 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_mtime
);
3548 lt
= localtime(&tmp_time
);
3550 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3552 fstrcpy(mode_str
, "unknown");
3554 d_printf("Modify: %s\n", mode_str
);
3556 tmp_time
= convert_timespec_to_time_t(sbuf
.st_ex_ctime
);
3557 lt
= localtime(&tmp_time
);
3559 strftime(mode_str
, sizeof(mode_str
), "%Y-%m-%d %T %z", lt
);
3561 fstrcpy(mode_str
, "unknown");
3563 d_printf("Change: %s\n", mode_str
);
3569 /****************************************************************************
3571 ****************************************************************************/
3573 static int cmd_chown(void)
3575 TALLOC_CTX
*ctx
= talloc_tos();
3579 char *buf
, *buf2
, *buf3
;
3580 struct cli_state
*targetcli
;
3581 char *targetname
= NULL
;
3583 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3584 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
) ||
3585 !next_token_talloc(ctx
, &cmd_ptr
,&buf3
,NULL
)) {
3586 d_printf("chown uid gid file\n");
3590 uid
= (uid_t
)atoi(buf
);
3591 gid
= (gid_t
)atoi(buf2
);
3593 src
= talloc_asprintf(ctx
,
3595 client_get_cur_dir(),
3600 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
) ) {
3601 d_printf("chown %s: %s\n", src
, cli_errstr(cli
));
3605 if (!SERVER_HAS_UNIX_CIFS(targetcli
)) {
3606 d_printf("Server doesn't support UNIX CIFS calls.\n");
3610 if (!NT_STATUS_IS_OK(cli_posix_chown(targetcli
, targetname
, uid
, gid
))) {
3611 d_printf("%s chown file %s uid=%d, gid=%d\n",
3612 cli_errstr(targetcli
), src
, (int)uid
, (int)gid
);
3619 /****************************************************************************
3621 ****************************************************************************/
3623 static int cmd_rename(void)
3625 TALLOC_CTX
*ctx
= talloc_tos();
3628 struct cli_state
*targetcli
;
3632 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3633 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3634 d_printf("rename <src> <dest>\n");
3638 src
= talloc_asprintf(ctx
,
3640 client_get_cur_dir(),
3646 dest
= talloc_asprintf(ctx
,
3648 client_get_cur_dir(),
3654 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetsrc
)) {
3655 d_printf("rename %s: %s\n", src
, cli_errstr(cli
));
3659 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, dest
, &targetcli
, &targetdest
)) {
3660 d_printf("rename %s: %s\n", dest
, cli_errstr(cli
));
3664 if (!NT_STATUS_IS_OK(cli_rename(targetcli
, targetsrc
, targetdest
))) {
3665 d_printf("%s renaming files %s -> %s \n",
3666 cli_errstr(targetcli
),
3675 /****************************************************************************
3676 Print the volume name.
3677 ****************************************************************************/
3679 static int cmd_volume(void)
3686 status
= cli_get_fs_volume_info(cli
, volname
, &serial_num
,
3688 if (!NT_STATUS_IS_OK(status
)) {
3689 d_printf("Error %s getting volume info\n", nt_errstr(status
));
3693 d_printf("Volume: |%s| serial number 0x%x\n",
3694 volname
, (unsigned int)serial_num
);
3698 /****************************************************************************
3699 Hard link files using the NT call.
3700 ****************************************************************************/
3702 static int cmd_hardlink(void)
3704 TALLOC_CTX
*ctx
= talloc_tos();
3707 struct cli_state
*targetcli
;
3710 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
) ||
3711 !next_token_talloc(ctx
, &cmd_ptr
,&buf2
,NULL
)) {
3712 d_printf("hardlink <src> <dest>\n");
3716 src
= talloc_asprintf(ctx
,
3718 client_get_cur_dir(),
3724 dest
= talloc_asprintf(ctx
,
3726 client_get_cur_dir(),
3732 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, src
, &targetcli
, &targetname
)) {
3733 d_printf("hardlink %s: %s\n", src
, cli_errstr(cli
));
3737 if (!NT_STATUS_IS_OK(cli_nt_hardlink(targetcli
, targetname
, dest
))) {
3738 d_printf("%s doing an NT hard link of files\n",cli_errstr(targetcli
));
3745 /****************************************************************************
3746 Toggle the prompt flag.
3747 ****************************************************************************/
3749 static int cmd_prompt(void)
3752 DEBUG(2,("prompting is now %s\n",prompt
?"on":"off"));
3756 /****************************************************************************
3757 Set the newer than time.
3758 ****************************************************************************/
3760 static int cmd_newer(void)
3762 TALLOC_CTX
*ctx
= talloc_tos();
3765 SMB_STRUCT_STAT sbuf
;
3767 ok
= next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
);
3768 if (ok
&& (sys_stat(buf
, &sbuf
, false) == 0)) {
3769 newer_than
= convert_timespec_to_time_t(sbuf
.st_ex_mtime
);
3770 DEBUG(1,("Getting files newer than %s",
3771 time_to_asc(newer_than
)));
3776 if (ok
&& newer_than
== 0) {
3777 d_printf("Error setting newer-than time\n");
3784 /****************************************************************************
3785 Set the archive level.
3786 ****************************************************************************/
3788 static int cmd_archive(void)
3790 TALLOC_CTX
*ctx
= talloc_tos();
3793 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
3794 archive_level
= atoi(buf
);
3796 d_printf("Archive level is %d\n",archive_level
);
3802 /****************************************************************************
3803 Toggle the lowercaseflag.
3804 ****************************************************************************/
3806 static int cmd_lowercase(void)
3808 lowercase
= !lowercase
;
3809 DEBUG(2,("filename lowercasing is now %s\n",lowercase
?"on":"off"));
3813 /****************************************************************************
3814 Toggle the case sensitive flag.
3815 ****************************************************************************/
3817 static int cmd_setcase(void)
3819 bool orig_case_sensitive
= cli_set_case_sensitive(cli
, false);
3821 cli_set_case_sensitive(cli
, !orig_case_sensitive
);
3822 DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive
?
3827 /****************************************************************************
3828 Toggle the showacls flag.
3829 ****************************************************************************/
3831 static int cmd_showacls(void)
3833 showacls
= !showacls
;
3834 DEBUG(2,("showacls is now %s\n",showacls
?"on":"off"));
3839 /****************************************************************************
3840 Toggle the recurse flag.
3841 ****************************************************************************/
3843 static int cmd_recurse(void)
3846 DEBUG(2,("directory recursion is now %s\n",recurse
?"on":"off"));
3850 /****************************************************************************
3851 Toggle the translate flag.
3852 ****************************************************************************/
3854 static int cmd_translate(void)
3856 translation
= !translation
;
3857 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
3858 translation
?"on":"off"));
3862 /****************************************************************************
3864 ****************************************************************************/
3866 static int cmd_lcd(void)
3868 TALLOC_CTX
*ctx
= talloc_tos();
3872 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
3873 if (chdir(buf
) == -1) {
3874 d_printf("chdir to %s failed (%s)\n",
3875 buf
, strerror(errno
));
3878 d
= TALLOC_ARRAY(ctx
, char, PATH_MAX
+1);
3882 DEBUG(2,("the local directory is now %s\n",sys_getwd(d
)));
3886 /****************************************************************************
3887 Get a file restarting at end of local file.
3888 ****************************************************************************/
3890 static int cmd_reget(void)
3892 TALLOC_CTX
*ctx
= talloc_tos();
3893 char *local_name
= NULL
;
3894 char *remote_name
= NULL
;
3898 remote_name
= talloc_strdup(ctx
, client_get_cur_dir());
3903 if (!next_token_talloc(ctx
, &cmd_ptr
, &fname
, NULL
)) {
3904 d_printf("reget <filename>\n");
3907 remote_name
= talloc_asprintf_append(remote_name
, "%s", fname
);
3911 remote_name
= clean_name(ctx
,remote_name
);
3917 next_token_talloc(ctx
, &cmd_ptr
, &p
, NULL
);
3922 return do_get(remote_name
, local_name
, true);
3925 /****************************************************************************
3926 Put a file restarting at end of local file.
3927 ****************************************************************************/
3929 static int cmd_reput(void)
3931 TALLOC_CTX
*ctx
= talloc_tos();
3932 char *local_name
= NULL
;
3933 char *remote_name
= NULL
;
3937 remote_name
= talloc_strdup(ctx
, client_get_cur_dir());
3942 if (!next_token_talloc(ctx
, &cmd_ptr
, &local_name
, NULL
)) {
3943 d_printf("reput <filename>\n");
3947 if (!file_exist_stat(local_name
, &st
, false)) {
3948 d_printf("%s does not exist\n", local_name
);
3952 if (next_token_talloc(ctx
, &cmd_ptr
, &buf
, NULL
)) {
3953 remote_name
= talloc_asprintf_append(remote_name
,
3956 remote_name
= talloc_asprintf_append(remote_name
,
3963 remote_name
= clean_name(ctx
, remote_name
);
3968 return do_put(remote_name
, local_name
, true);
3971 /****************************************************************************
3973 ****************************************************************************/
3975 static void browse_fn(const char *name
, uint32 m
,
3976 const char *comment
, void *state
)
3978 const char *typestr
= "";
3981 case STYPE_DISKTREE
:
3985 typestr
= "Printer";
3994 /* FIXME: If the remote machine returns non-ascii characters
3995 in any of these fields, they can corrupt the output. We
3996 should remove them. */
3998 d_printf("\t%-15s %-10.10s%s\n",
3999 name
,typestr
,comment
);
4001 d_printf ("%s|%s|%s\n",typestr
,name
,comment
);
4005 static bool browse_host_rpc(bool sort
)
4008 struct rpc_pipe_client
*pipe_hnd
= NULL
;
4009 TALLOC_CTX
*frame
= talloc_stackframe();
4011 struct srvsvc_NetShareInfoCtr info_ctr
;
4012 struct srvsvc_NetShareCtr1 ctr1
;
4013 uint32_t resume_handle
= 0;
4014 uint32_t total_entries
= 0;
4016 struct dcerpc_binding_handle
*b
;
4018 status
= cli_rpc_pipe_open_noauth(cli
, &ndr_table_srvsvc
.syntax_id
,
4021 if (!NT_STATUS_IS_OK(status
)) {
4022 DEBUG(10, ("Could not connect to srvsvc pipe: %s\n",
4023 nt_errstr(status
)));
4028 b
= pipe_hnd
->binding_handle
;
4030 ZERO_STRUCT(info_ctr
);
4034 info_ctr
.ctr
.ctr1
= &ctr1
;
4036 status
= dcerpc_srvsvc_NetShareEnumAll(b
, frame
,
4044 if (!NT_STATUS_IS_OK(status
) || !W_ERROR_IS_OK(werr
)) {
4045 TALLOC_FREE(pipe_hnd
);
4050 for (i
=0; i
< info_ctr
.ctr
.ctr1
->count
; i
++) {
4051 struct srvsvc_NetShareInfo1 info
= info_ctr
.ctr
.ctr1
->array
[i
];
4052 browse_fn(info
.name
, info
.type
, info
.comment
, NULL
);
4055 TALLOC_FREE(pipe_hnd
);
4060 /****************************************************************************
4061 Try and browse available connections on a host.
4062 ****************************************************************************/
4064 static bool browse_host(bool sort
)
4068 d_printf("\n\tSharename Type Comment\n");
4069 d_printf("\t--------- ---- -------\n");
4072 if (browse_host_rpc(sort
)) {
4076 if((ret
= cli_RNetShareEnum(cli
, browse_fn
, NULL
)) == -1)
4077 d_printf("Error returning browse list: %s\n", cli_errstr(cli
));
4082 /****************************************************************************
4084 ****************************************************************************/
4086 static void server_fn(const char *name
, uint32 m
,
4087 const char *comment
, void *state
)
4091 d_printf("\t%-16s %s\n", name
, comment
);
4093 d_printf("%s|%s|%s\n",(char *)state
, name
, comment
);
4097 /****************************************************************************
4098 Try and browse available connections on a host.
4099 ****************************************************************************/
4101 static bool list_servers(const char *wk_grp
)
4105 if (!cli
->server_domain
)
4109 d_printf("\n\tServer Comment\n");
4110 d_printf("\t--------- -------\n");
4112 fstrcpy( state
, "Server" );
4113 cli_NetServerEnum(cli
, cli
->server_domain
, SV_TYPE_ALL
, server_fn
,
4117 d_printf("\n\tWorkgroup Master\n");
4118 d_printf("\t--------- -------\n");
4121 fstrcpy( state
, "Workgroup" );
4122 cli_NetServerEnum(cli
, cli
->server_domain
, SV_TYPE_DOMAIN_ENUM
,
4127 /****************************************************************************
4128 Print or set current VUID
4129 ****************************************************************************/
4131 static int cmd_vuid(void)
4133 TALLOC_CTX
*ctx
= talloc_tos();
4136 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4137 d_printf("Current VUID is %d\n", cli
->vuid
);
4141 cli
->vuid
= atoi(buf
);
4145 /****************************************************************************
4146 Setup a new VUID, by issuing a session setup
4147 ****************************************************************************/
4149 static int cmd_logon(void)
4151 TALLOC_CTX
*ctx
= talloc_tos();
4152 char *l_username
, *l_password
;
4155 if (!next_token_talloc(ctx
, &cmd_ptr
,&l_username
,NULL
)) {
4156 d_printf("logon <username> [<password>]\n");
4160 if (!next_token_talloc(ctx
, &cmd_ptr
,&l_password
,NULL
)) {
4161 char *pass
= getpass("Password: ");
4163 l_password
= talloc_strdup(ctx
,pass
);
4170 nt_status
= cli_session_setup(cli
, l_username
,
4171 l_password
, strlen(l_password
),
4172 l_password
, strlen(l_password
),
4174 if (!NT_STATUS_IS_OK(nt_status
)) {
4175 d_printf("session setup failed: %s\n", nt_errstr(nt_status
));
4179 d_printf("Current VUID is %d\n", cli
->vuid
);
4184 /****************************************************************************
4185 list active connections
4186 ****************************************************************************/
4188 static int cmd_list_connect(void)
4190 cli_cm_display(cli
);
4194 /****************************************************************************
4195 display the current active client connection
4196 ****************************************************************************/
4198 static int cmd_show_connect( void )
4200 TALLOC_CTX
*ctx
= talloc_tos();
4201 struct cli_state
*targetcli
;
4204 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, client_get_cur_dir(),
4205 &targetcli
, &targetpath
) ) {
4206 d_printf("showconnect %s: %s\n", cur_dir
, cli_errstr(cli
));
4210 d_printf("//%s/%s\n", targetcli
->desthost
, targetcli
->share
);
4214 /****************************************************************************
4216 ***************************************************************************/
4218 int cmd_iosize(void)
4220 TALLOC_CTX
*ctx
= talloc_tos();
4224 if (!next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4226 d_printf("iosize <n> or iosize 0x<n>. "
4227 "Minimum is 16384 (0x4000), "
4228 "max is 16776960 (0xFFFF00)\n");
4230 d_printf("iosize <n> or iosize 0x<n>. "
4231 "(Encrypted connection) ,"
4232 "Minimum is 16384 (0x4000), "
4233 "max is 130048 (0x1FC00)\n");
4238 iosize
= strtol(buf
,NULL
,0);
4239 if (smb_encrypt
&& (iosize
< 0x4000 || iosize
> 0xFC00)) {
4240 d_printf("iosize out of range for encrypted "
4241 "connection (min = 16384 (0x4000), "
4242 "max = 130048 (0x1FC00)");
4244 } else if (!smb_encrypt
&& (iosize
< 0x4000 || iosize
> 0xFFFF00)) {
4245 d_printf("iosize out of range (min = 16384 (0x4000), "
4246 "max = 16776960 (0xFFFF00)");
4250 io_bufsize
= iosize
;
4251 d_printf("iosize is now %d\n", io_bufsize
);
4255 /****************************************************************************
4257 ****************************************************************************/
4258 static int cmd_history(void)
4260 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
4264 hlist
= history_list();
4266 for (i
= 0; hlist
&& hlist
[i
]; i
++) {
4267 DEBUG(0, ("%d: %s\n", i
, hlist
[i
]->line
));
4270 DEBUG(0,("no history without readline support\n"));
4276 /* Some constants for completing filename arguments */
4278 #define COMPL_NONE 0 /* No completions */
4279 #define COMPL_REMOTE 1 /* Complete remote filename */
4280 #define COMPL_LOCAL 2 /* Complete local filename */
4282 /* This defines the commands supported by this client.
4283 * NOTE: The "!" must be the last one in the list because it's fn pointer
4284 * field is NULL, and NULL in that field is used in process_tok()
4285 * (below) to indicate the end of the list. crh
4290 const char *description
;
4291 char compl_args
[2]; /* Completion argument info */
4293 {"?",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
4294 {"allinfo",cmd_allinfo
,"<file> show all available info",
4295 {COMPL_NONE
,COMPL_NONE
}},
4296 {"altname",cmd_altname
,"<file> show alt name",{COMPL_NONE
,COMPL_NONE
}},
4297 {"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
}},
4298 {"blocksize",cmd_block
,"blocksize <number> (default 20)",{COMPL_NONE
,COMPL_NONE
}},
4299 {"cancel",cmd_cancel
,"<jobid> cancel a print queue entry",{COMPL_NONE
,COMPL_NONE
}},
4300 {"case_sensitive",cmd_setcase
,"toggle the case sensitive flag to server",{COMPL_NONE
,COMPL_NONE
}},
4301 {"cd",cmd_cd
,"[directory] change/report the remote directory",{COMPL_REMOTE
,COMPL_NONE
}},
4302 {"chmod",cmd_chmod
,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE
,COMPL_REMOTE
}},
4303 {"chown",cmd_chown
,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE
,COMPL_REMOTE
}},
4304 {"close",cmd_close
,"<fid> close a file given a fid",{COMPL_REMOTE
,COMPL_REMOTE
}},
4305 {"del",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4306 {"dir",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4307 {"du",cmd_du
,"<mask> computes the total size of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4308 {"echo",cmd_echo
,"ping the server",{COMPL_NONE
,COMPL_NONE
}},
4309 {"exit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
4310 {"get",cmd_get
,"<remote name> [local name] get a file",{COMPL_REMOTE
,COMPL_LOCAL
}},
4311 {"getfacl",cmd_getfacl
,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE
,COMPL_LOCAL
}},
4312 {"geteas", cmd_geteas
, "<file name> get the EA list of a file",
4313 {COMPL_REMOTE
, COMPL_LOCAL
}},
4314 {"hardlink",cmd_hardlink
,"<src> <dest> create a Windows hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
4315 {"help",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
4316 {"history",cmd_history
,"displays the command history",{COMPL_NONE
,COMPL_NONE
}},
4317 {"iosize",cmd_iosize
,"iosize <number> (default 64512)",{COMPL_NONE
,COMPL_NONE
}},
4318 {"lcd",cmd_lcd
,"[directory] change/report the local current working directory",{COMPL_LOCAL
,COMPL_NONE
}},
4319 {"link",cmd_link
,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
4320 {"lock",cmd_lock
,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE
,COMPL_REMOTE
}},
4321 {"lowercase",cmd_lowercase
,"toggle lowercasing of filenames for get",{COMPL_NONE
,COMPL_NONE
}},
4322 {"ls",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4323 {"l",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
4324 {"mask",cmd_select
,"<mask> mask all filenames against this",{COMPL_REMOTE
,COMPL_NONE
}},
4325 {"md",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
4326 {"mget",cmd_mget
,"<mask> get all the matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4327 {"mkdir",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
4328 {"more",cmd_more
,"<remote name> view a remote file with your pager",{COMPL_REMOTE
,COMPL_NONE
}},
4329 {"mput",cmd_mput
,"<mask> put all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4330 {"newer",cmd_newer
,"<file> only mget files newer than the specified local file",{COMPL_LOCAL
,COMPL_NONE
}},
4331 {"open",cmd_open
,"<mask> open a file",{COMPL_REMOTE
,COMPL_NONE
}},
4332 {"posix", cmd_posix
, "turn on all POSIX capabilities", {COMPL_REMOTE
,COMPL_NONE
}},
4333 {"posix_encrypt",cmd_posix_encrypt
,"<domain> <user> <password> start up transport encryption",{COMPL_REMOTE
,COMPL_NONE
}},
4334 {"posix_open",cmd_posix_open
,"<name> 0<mode> open_flags mode open a file using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4335 {"posix_mkdir",cmd_posix_mkdir
,"<name> 0<mode> creates a directory using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4336 {"posix_rmdir",cmd_posix_rmdir
,"<name> removes a directory using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4337 {"posix_unlink",cmd_posix_unlink
,"<name> removes a file using POSIX interface",{COMPL_REMOTE
,COMPL_NONE
}},
4338 {"print",cmd_print
,"<file name> print a file",{COMPL_NONE
,COMPL_NONE
}},
4339 {"prompt",cmd_prompt
,"toggle prompting for filenames for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
4340 {"put",cmd_put
,"<local name> [remote name] put a file",{COMPL_LOCAL
,COMPL_REMOTE
}},
4341 {"pwd",cmd_pwd
,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE
,COMPL_NONE
}},
4342 {"q",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
4343 {"queue",cmd_queue
,"show the print queue",{COMPL_NONE
,COMPL_NONE
}},
4344 {"quit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
4345 {"readlink",cmd_readlink
,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
4346 {"rd",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
4347 {"recurse",cmd_recurse
,"toggle directory recursion for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
4348 {"reget",cmd_reget
,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE
,COMPL_LOCAL
}},
4349 {"rename",cmd_rename
,"<src> <dest> rename some files",{COMPL_REMOTE
,COMPL_REMOTE
}},
4350 {"reput",cmd_reput
,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL
,COMPL_REMOTE
}},
4351 {"rm",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4352 {"rmdir",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
4353 {"showacls",cmd_showacls
,"toggle if ACLs are shown or not",{COMPL_NONE
,COMPL_NONE
}},
4354 {"setea", cmd_setea
, "<file name> <eaname> <eaval> Set an EA of a file",
4355 {COMPL_REMOTE
, COMPL_LOCAL
}},
4356 {"setmode",cmd_setmode
,"filename <setmode string> change modes of file",{COMPL_REMOTE
,COMPL_NONE
}},
4357 {"stat",cmd_stat
,"filename Do a UNIX extensions stat call on a file",{COMPL_REMOTE
,COMPL_REMOTE
}},
4358 {"symlink",cmd_symlink
,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
4359 {"tar",cmd_tar
,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE
,COMPL_NONE
}},
4360 {"tarmode",cmd_tarmode
,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE
,COMPL_NONE
}},
4361 {"translate",cmd_translate
,"toggle text translation for printing",{COMPL_NONE
,COMPL_NONE
}},
4362 {"unlock",cmd_unlock
,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE
,COMPL_REMOTE
}},
4363 {"volume",cmd_volume
,"print the volume name",{COMPL_NONE
,COMPL_NONE
}},
4364 {"vuid",cmd_vuid
,"change current vuid",{COMPL_NONE
,COMPL_NONE
}},
4365 {"wdel",cmd_wdel
,"<attrib> <mask> wildcard delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
4366 {"logon",cmd_logon
,"establish new logon",{COMPL_NONE
,COMPL_NONE
}},
4367 {"listconnect",cmd_list_connect
,"list open connections",{COMPL_NONE
,COMPL_NONE
}},
4368 {"showconnect",cmd_show_connect
,"display the current active connection",{COMPL_NONE
,COMPL_NONE
}},
4369 {"..",cmd_cd_oneup
,"change the remote directory (up one level)",{COMPL_REMOTE
,COMPL_NONE
}},
4371 /* Yes, this must be here, see crh's comment above. */
4372 {"!",NULL
,"run a shell command on the local system",{COMPL_NONE
,COMPL_NONE
}},
4373 {NULL
,NULL
,NULL
,{COMPL_NONE
,COMPL_NONE
}}
4376 /*******************************************************************
4377 Lookup a command string in the list of commands, including
4379 ******************************************************************/
4381 static int process_tok(char *tok
)
4383 int i
= 0, matches
= 0;
4385 int tok_len
= strlen(tok
);
4387 while (commands
[i
].fn
!= NULL
) {
4388 if (strequal(commands
[i
].name
,tok
)) {
4392 } else if (strnequal(commands
[i
].name
, tok
, tok_len
)) {
4401 else if (matches
== 1)
4407 /****************************************************************************
4409 ****************************************************************************/
4411 static int cmd_help(void)
4413 TALLOC_CTX
*ctx
= talloc_tos();
4417 if (next_token_talloc(ctx
, &cmd_ptr
,&buf
,NULL
)) {
4418 if ((i
= process_tok(buf
)) >= 0)
4419 d_printf("HELP %s:\n\t%s\n\n",
4420 commands
[i
].name
,commands
[i
].description
);
4422 while (commands
[i
].description
) {
4423 for (j
=0; commands
[i
].description
&& (j
<5); j
++) {
4424 d_printf("%-15s",commands
[i
].name
);
4433 /****************************************************************************
4434 Process a -c command string.
4435 ****************************************************************************/
4437 static int process_command_string(const char *cmd_in
)
4439 TALLOC_CTX
*ctx
= talloc_tos();
4440 char *cmd
= talloc_strdup(ctx
, cmd_in
);
4446 /* establish the connection if not already */
4449 cli
= cli_cm_open(talloc_tos(), NULL
,
4450 have_ip
? dest_ss_str
: desthost
,
4453 max_protocol
, port
, name_type
);
4459 while (cmd
[0] != '\0') {
4465 if ((p
= strchr_m(cmd
, ';')) == 0) {
4474 /* and get the first part of the command */
4476 if (!next_token_talloc(ctx
, &cmd_ptr
,&tok
,NULL
)) {
4480 if ((i
= process_tok(tok
)) >= 0) {
4481 rc
= commands
[i
].fn();
4482 } else if (i
== -2) {
4483 d_printf("%s: command abbreviation ambiguous\n",tok
);
4485 d_printf("%s: command not found\n",tok
);
4492 #define MAX_COMPLETIONS 100
4494 struct completion_remote
{
4502 static NTSTATUS
completion_remote_filter(const char *mnt
,
4503 struct file_info
*f
,
4507 struct completion_remote
*info
= (struct completion_remote
*)state
;
4509 if (info
->count
>= MAX_COMPLETIONS
- 1) {
4510 return NT_STATUS_OK
;
4512 if (strncmp(info
->text
, f
->name
, info
->len
) != 0) {
4513 return NT_STATUS_OK
;
4515 if (ISDOT(f
->name
) || ISDOTDOT(f
->name
)) {
4516 return NT_STATUS_OK
;
4519 if ((info
->dirmask
[0] == 0) && !(f
->mode
& aDIR
))
4520 info
->matches
[info
->count
] = SMB_STRDUP(f
->name
);
4522 TALLOC_CTX
*ctx
= talloc_stackframe();
4525 tmp
= talloc_strdup(ctx
,info
->dirmask
);
4528 return NT_STATUS_NO_MEMORY
;
4530 tmp
= talloc_asprintf_append(tmp
, "%s", f
->name
);
4533 return NT_STATUS_NO_MEMORY
;
4535 if (f
->mode
& aDIR
) {
4536 tmp
= talloc_asprintf_append(tmp
, "%s",
4541 return NT_STATUS_NO_MEMORY
;
4543 info
->matches
[info
->count
] = SMB_STRDUP(tmp
);
4546 if (info
->matches
[info
->count
] == NULL
) {
4547 return NT_STATUS_OK
;
4549 if (f
->mode
& aDIR
) {
4550 smb_readline_ca_char(0);
4552 if (info
->count
== 1) {
4553 info
->samelen
= strlen(info
->matches
[info
->count
]);
4555 while (strncmp(info
->matches
[info
->count
],
4556 info
->matches
[info
->count
-1],
4557 info
->samelen
) != 0) {
4562 return NT_STATUS_OK
;
4565 static char **remote_completion(const char *text
, int len
)
4567 TALLOC_CTX
*ctx
= talloc_stackframe();
4568 char *dirmask
= NULL
;
4569 char *targetpath
= NULL
;
4570 struct cli_state
*targetcli
= NULL
;
4572 struct completion_remote info
= { NULL
, NULL
, 1, 0, NULL
, 0 };
4575 /* can't have non-static initialisation on Sun CC, so do it
4581 info
.matches
= SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS
);
4582 if (!info
.matches
) {
4588 * We're leaving matches[0] free to fill it later with the text to
4589 * display: Either the one single match or the longest common subset
4592 info
.matches
[0] = NULL
;
4595 for (i
= len
-1; i
>= 0; i
--) {
4596 if ((text
[i
] == '/') || (text
[i
] == CLI_DIRSEP_CHAR
)) {
4601 info
.text
= text
+i
+1;
4602 info
.samelen
= info
.len
= len
-i
-1;
4605 info
.dirmask
= SMB_MALLOC_ARRAY(char, i
+2);
4606 if (!info
.dirmask
) {
4609 strncpy(info
.dirmask
, text
, i
+1);
4610 info
.dirmask
[i
+1] = 0;
4611 dirmask
= talloc_asprintf(ctx
,
4613 client_get_cur_dir(),
4617 info
.dirmask
= SMB_STRDUP("");
4618 if (!info
.dirmask
) {
4621 dirmask
= talloc_asprintf(ctx
,
4623 client_get_cur_dir());
4629 if (!cli_resolve_path(ctx
, "", auth_info
, cli
, dirmask
, &targetcli
, &targetpath
)) {
4632 status
= cli_list(targetcli
, targetpath
, aDIR
| aSYSTEM
| FILE_ATTRIBUTE_HIDDEN
,
4633 completion_remote_filter
, (void *)&info
);
4634 if (!NT_STATUS_IS_OK(status
)) {
4638 if (info
.count
== 1) {
4640 * No matches at all, NULL indicates there is nothing
4642 SAFE_FREE(info
.matches
[0]);
4643 SAFE_FREE(info
.matches
);
4648 if (info
.count
== 2) {
4650 * Exactly one match in matches[1], indicate this is the one
4653 info
.matches
[0] = info
.matches
[1];
4654 info
.matches
[1] = NULL
;
4657 return info
.matches
;
4661 * We got more than one possible match, set the result to the maximum
4665 info
.matches
[0] = SMB_STRNDUP(info
.matches
[1], info
.samelen
);
4666 info
.matches
[info
.count
] = NULL
;
4667 return info
.matches
;
4670 for (i
= 0; i
< info
.count
; i
++) {
4671 SAFE_FREE(info
.matches
[i
]);
4673 SAFE_FREE(info
.matches
);
4674 SAFE_FREE(info
.dirmask
);
4679 static char **completion_fn(const char *text
, int start
, int end
)
4681 smb_readline_ca_char(' ');
4684 const char *buf
, *sp
;
4688 buf
= smb_readline_get_line_buffer();
4692 sp
= strchr(buf
, ' ');
4696 for (i
= 0; commands
[i
].name
; i
++) {
4697 if ((strncmp(commands
[i
].name
, buf
, sp
- buf
) == 0) &&
4698 (commands
[i
].name
[sp
- buf
] == 0)) {
4702 if (commands
[i
].name
== NULL
)
4708 if (sp
== (buf
+ start
))
4709 compl_type
= commands
[i
].compl_args
[0];
4711 compl_type
= commands
[i
].compl_args
[1];
4713 if (compl_type
== COMPL_REMOTE
)
4714 return remote_completion(text
, end
- start
);
4715 else /* fall back to local filename completion */
4719 int i
, len
, samelen
= 0, count
=1;
4721 matches
= SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS
);
4728 for (i
=0;commands
[i
].fn
&& count
< MAX_COMPLETIONS
-1;i
++) {
4729 if (strncmp(text
, commands
[i
].name
, len
) == 0) {
4730 matches
[count
] = SMB_STRDUP(commands
[i
].name
);
4731 if (!matches
[count
])
4734 samelen
= strlen(matches
[count
]);
4736 while (strncmp(matches
[count
], matches
[count
-1], samelen
) != 0)
4743 case 0: /* should never happen */
4747 matches
[0] = SMB_STRDUP(matches
[1]);
4750 matches
[0] = (char *)SMB_MALLOC(samelen
+1);
4753 strncpy(matches
[0], matches
[1], samelen
);
4754 matches
[0][samelen
] = 0;
4756 matches
[count
] = NULL
;
4760 for (i
= 0; i
< count
; i
++)
4768 static bool finished
;
4770 /****************************************************************************
4771 Make sure we swallow keepalives during idle time.
4772 ****************************************************************************/
4774 static void readline_callback(void)
4776 static time_t last_t
;
4777 struct timespec now
;
4781 clock_gettime_mono(&now
);
4794 /* We deliberately use receive_smb_raw instead of
4795 client_receive_smb as we want to receive
4796 session keepalives and then drop them here.
4799 ret
= poll_intr_one_fd(cli
->fd
, POLLIN
|POLLHUP
, 0, &revents
);
4801 if ((ret
> 0) && (revents
& (POLLIN
|POLLHUP
|POLLERR
))) {
4805 set_smb_read_error(&cli
->smb_rw_error
, SMB_READ_OK
);
4807 status
= receive_smb_raw(cli
->fd
, cli
->inbuf
, cli
->bufsize
, 0, 0, &len
);
4809 if (!NT_STATUS_IS_OK(status
)) {
4810 DEBUG(0, ("Read from server failed, maybe it closed "
4811 "the connection\n"));
4814 smb_readline_done();
4815 if (NT_STATUS_EQUAL(status
, NT_STATUS_END_OF_FILE
)) {
4816 set_smb_read_error(&cli
->smb_rw_error
,
4821 if (NT_STATUS_EQUAL(status
, NT_STATUS_IO_TIMEOUT
)) {
4822 set_smb_read_error(&cli
->smb_rw_error
,
4827 set_smb_read_error(&cli
->smb_rw_error
, SMB_READ_ERROR
);
4830 if(CVAL(cli
->inbuf
,0) != SMBkeepalive
) {
4831 DEBUG(0, ("Read from server "
4832 "returned unexpected packet!\n"));
4839 /* Ping the server to keep the connection alive using SMBecho. */
4842 unsigned char garbage
[16];
4843 memset(garbage
, 0xf0, sizeof(garbage
));
4844 status
= cli_echo(cli
, 1, data_blob_const(garbage
, sizeof(garbage
)));
4846 if (!NT_STATUS_IS_OK(status
)) {
4847 DEBUG(0, ("SMBecho failed. Maybe server has closed "
4848 "the connection\n"));
4850 smb_readline_done();
4855 /****************************************************************************
4856 Process commands on stdin.
4857 ****************************************************************************/
4859 static int process_stdin(void)
4864 TALLOC_CTX
*frame
= talloc_stackframe();
4866 char *the_prompt
= NULL
;
4870 /* display a prompt */
4871 if (asprintf(&the_prompt
, "smb: %s> ", client_get_cur_dir()) < 0) {
4875 line
= smb_readline(the_prompt
, readline_callback
, completion_fn
);
4876 SAFE_FREE(the_prompt
);
4882 /* special case - first char is ! */
4884 if (system(line
+ 1) == -1) {
4885 d_printf("system() command %s failed.\n",
4893 /* and get the first part of the command */
4895 if (!next_token_talloc(frame
, &cmd_ptr
,&tok
,NULL
)) {
4901 if ((i
= process_tok(tok
)) >= 0) {
4902 rc
= commands
[i
].fn();
4903 } else if (i
== -2) {
4904 d_printf("%s: command abbreviation ambiguous\n",tok
);
4906 d_printf("%s: command not found\n",tok
);
4914 /****************************************************************************
4915 Process commands from the client.
4916 ****************************************************************************/
4918 static int process(const char *base_directory
)
4922 cli
= cli_cm_open(talloc_tos(), NULL
,
4923 have_ip
? dest_ss_str
: desthost
,
4924 service
, auth_info
, true, smb_encrypt
,
4925 max_protocol
, port
, name_type
);
4930 if (base_directory
&& *base_directory
) {
4931 rc
= do_cd(base_directory
);
4939 rc
= process_command_string(cmdstr
);
4948 /****************************************************************************
4950 ****************************************************************************/
4952 static int do_host_query(const char *query_host
)
4954 cli
= cli_cm_open(talloc_tos(), NULL
,
4955 have_ip
? dest_ss_str
: query_host
, "IPC$", auth_info
, true, smb_encrypt
,
4956 max_protocol
, port
, name_type
);
4962 /* Ensure that the host can do IPv4 */
4964 if (!interpret_addr(query_host
)) {
4965 struct sockaddr_storage ss
;
4966 if (interpret_string_addr(&ss
, query_host
, 0) &&
4967 (ss
.ss_family
!= AF_INET
)) {
4968 d_printf("%s is an IPv6 address -- no workgroup available\n",
4976 /* Workgroups simply don't make sense over anything
4977 else but port 139... */
4980 cli
= cli_cm_open(talloc_tos(), NULL
,
4981 have_ip
? dest_ss_str
: query_host
, "IPC$",
4982 auth_info
, true, smb_encrypt
,
4983 max_protocol
, 139, name_type
);
4987 d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
4991 list_servers(lp_workgroup());
4998 /****************************************************************************
4999 Handle a tar operation.
5000 ****************************************************************************/
5002 static int do_tar_op(const char *base_directory
)
5006 /* do we already have a connection? */
5008 cli
= cli_cm_open(talloc_tos(), NULL
,
5009 have_ip
? dest_ss_str
: desthost
,
5010 service
, auth_info
, true, smb_encrypt
,
5011 max_protocol
, port
, name_type
);
5018 if (base_directory
&& *base_directory
) {
5019 ret
= do_cd(base_directory
);
5033 /****************************************************************************
5034 Handle a message operation.
5035 ****************************************************************************/
5037 static int do_message_op(struct user_auth_info
*a_info
)
5039 struct sockaddr_storage ss
;
5040 struct nmb_name called
, calling
;
5041 fstring server_name
;
5042 char name_type_hex
[10];
5046 make_nmb_name(&calling
, calling_name
, 0x0);
5047 make_nmb_name(&called
, desthost
, name_type
);
5049 fstrcpy(server_name
, desthost
);
5050 snprintf(name_type_hex
, sizeof(name_type_hex
), "#%X", name_type
);
5051 fstrcat(server_name
, name_type_hex
);
5057 /* we can only do messages over port 139 (to windows clients at least) */
5059 msg_port
= port
? port
: 139;
5061 if (!(cli
=cli_initialise())) {
5062 d_printf("Connection to %s failed\n", desthost
);
5065 cli_set_port(cli
, msg_port
);
5067 status
= cli_connect(cli
, server_name
, &ss
);
5068 if (!NT_STATUS_IS_OK(status
)) {
5069 d_printf("Connection to %s failed. Error %s\n", desthost
, nt_errstr(status
));
5073 if (!cli_session_request(cli
, &calling
, &called
)) {
5074 d_printf("session request failed\n");
5079 send_message(get_cmdline_auth_info_username(a_info
));
5085 /****************************************************************************
5087 ****************************************************************************/
5089 int main(int argc
,char *argv
[])
5091 char *base_directory
= NULL
;
5093 char *query_host
= NULL
;
5094 bool message
= false;
5095 static const char *new_name_resolve_order
= NULL
;
5099 fstring new_workgroup
;
5100 bool tar_opt
= false;
5101 bool service_opt
= false;
5102 struct poptOption long_options
[] = {
5105 { "name-resolve", 'R', POPT_ARG_STRING
, &new_name_resolve_order
, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },
5106 { "message", 'M', POPT_ARG_STRING
, NULL
, 'M', "Send message", "HOST" },
5107 { "ip-address", 'I', POPT_ARG_STRING
, NULL
, 'I', "Use this IP to connect to", "IP" },
5108 { "stderr", 'E', POPT_ARG_NONE
, NULL
, 'E', "Write messages to stderr instead of stdout" },
5109 { "list", 'L', POPT_ARG_STRING
, NULL
, 'L', "Get a list of shares available on a host", "HOST" },
5110 { "max-protocol", 'm', POPT_ARG_STRING
, NULL
, 'm', "Set the max protocol level", "LEVEL" },
5111 { "tar", 'T', POPT_ARG_STRING
, NULL
, 'T', "Command line tar", "<c|x>IXFqgbNan" },
5112 { "directory", 'D', POPT_ARG_STRING
, NULL
, 'D', "Start from directory", "DIR" },
5113 { "command", 'c', POPT_ARG_STRING
, &cmdstr
, 'c', "Execute semicolon separated commands" },
5114 { "send-buffer", 'b', POPT_ARG_INT
, &io_bufsize
, 'b', "Changes the transmit/send buffer", "BYTES" },
5115 { "port", 'p', POPT_ARG_INT
, &port
, 'p', "Port to connect to", "PORT" },
5116 { "grepable", 'g', POPT_ARG_NONE
, NULL
, 'g', "Produce grepable output" },
5117 { "browse", 'B', POPT_ARG_NONE
, NULL
, 'B', "Browse SMB servers using DNS" },
5119 POPT_COMMON_CONNECTION
5120 POPT_COMMON_CREDENTIALS
5123 TALLOC_CTX
*frame
= talloc_stackframe();
5125 if (!client_set_cur_dir("\\")) {
5129 /* initialize the workgroup name so we can determine whether or
5130 not it was set by a command line option */
5132 set_global_myworkgroup( "" );
5133 set_global_myname( "" );
5135 /* set default debug level to 1 regardless of what smb.conf sets */
5136 setup_logging( "smbclient", DEBUG_DEFAULT_STDERR
);
5139 lp_set_cmdline("log level", "1");
5141 auth_info
= user_auth_info_init(frame
);
5142 if (auth_info
== NULL
) {
5145 popt_common_set_auth_info(auth_info
);
5148 pc
= poptGetContext("smbclient", argc
, (const char **) argv
, long_options
, 0);
5149 poptSetOtherOptionHelp(pc
, "service <password>");
5151 lp_set_in_client(true); /* Make sure that we tell lp_load we are */
5153 while ((opt
= poptGetNextOpt(pc
)) != -1) {
5155 /* if the tar option has been called previouslt, now we need to eat out the leftovers */
5156 /* I see no other way to keep things sane --SSS */
5157 if (tar_opt
== true) {
5158 while (poptPeekArg(pc
)) {
5164 /* if the service has not yet been specified lets see if it is available in the popt stack */
5165 if (!service_opt
&& poptPeekArg(pc
)) {
5166 service
= talloc_strdup(frame
, poptGetArg(pc
));
5173 /* if the service has already been retrieved then check if we have also a password */
5175 && (!get_cmdline_auth_info_got_pass(auth_info
))
5176 && poptPeekArg(pc
)) {
5177 set_cmdline_auth_info_password(auth_info
,
5183 /* Messages are sent to NetBIOS name type 0x3
5184 * (Messenger Service). Make sure we default
5185 * to port 139 instead of port 445. srl,crh
5188 desthost
= talloc_strdup(frame
,poptGetOptArg(pc
));
5198 if (!interpret_string_addr(&dest_ss
, poptGetOptArg(pc
), 0)) {
5202 print_sockaddr(dest_ss_str
, sizeof(dest_ss_str
), &dest_ss
);
5206 setup_logging("smbclient", DEBUG_STDERR
);
5207 display_set_stderr();
5211 query_host
= talloc_strdup(frame
, poptGetOptArg(pc
));
5217 max_protocol
= interpret_protocol(poptGetOptArg(pc
), max_protocol
);
5220 /* We must use old option processing for this. Find the
5221 * position of the -T option in the raw argv[]. */
5224 for (i
= 1; i
< argc
; i
++) {
5225 if (strncmp("-T", argv
[i
],2)==0)
5229 if (!tar_parseargs(argc
, argv
, poptGetOptArg(pc
), i
)) {
5230 poptPrintUsage(pc
, stderr
, 0);
5234 /* this must be the last option, mark we have parsed it so that we know we have */
5238 base_directory
= talloc_strdup(frame
, poptGetOptArg(pc
));
5239 if (!base_directory
) {
5250 return(do_smb_browse());
5255 /* We may still have some leftovers after the last popt option has been called */
5256 if (tar_opt
== true) {
5257 while (poptPeekArg(pc
)) {
5263 /* if the service has not yet been specified lets see if it is available in the popt stack */
5264 if (!service_opt
&& poptPeekArg(pc
)) {
5265 service
= talloc_strdup(frame
,poptGetArg(pc
));
5272 /* if the service has already been retrieved then check if we have also a password */
5274 && !get_cmdline_auth_info_got_pass(auth_info
)
5275 && poptPeekArg(pc
)) {
5276 set_cmdline_auth_info_password(auth_info
,
5280 /* save the workgroup...
5282 FIXME!! do we need to do this for other options as well
5283 (or maybe a generic way to keep lp_load() from overwriting
5286 fstrcpy( new_workgroup
, lp_workgroup() );
5287 calling_name
= talloc_strdup(frame
, global_myname() );
5288 if (!calling_name
) {
5292 if ( override_logfile
)
5293 setup_logging( lp_logfile(), DEBUG_FILE
);
5295 if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {
5296 fprintf(stderr
, "%s: Can't load %s - run testparm to debug it\n",
5297 argv
[0], get_dyn_CONFIGFILE());
5300 if (get_cmdline_auth_info_use_machine_account(auth_info
) &&
5301 !set_cmdline_auth_info_machine_account_creds(auth_info
)) {
5307 if (service_opt
&& service
) {
5310 /* Convert any '/' characters in the service name to '\' characters */
5311 string_replace(service
, '/','\\');
5312 if (count_chars(service
,'\\') < 3) {
5313 d_printf("\n%s: Not enough '\\' characters in service\n",service
);
5314 poptPrintUsage(pc
, stderr
, 0);
5317 /* Remove trailing slashes */
5318 len
= strlen(service
);
5319 while(len
> 0 && service
[len
- 1] == '\\') {
5321 service
[len
] = '\0';
5325 if ( strlen(new_workgroup
) != 0 ) {
5326 set_global_myworkgroup( new_workgroup
);
5329 if ( strlen(calling_name
) != 0 ) {
5330 set_global_myname( calling_name
);
5332 TALLOC_FREE(calling_name
);
5333 calling_name
= talloc_strdup(frame
, global_myname() );
5336 smb_encrypt
= get_cmdline_auth_info_smb_encrypt(auth_info
);
5337 if (!init_names()) {
5338 fprintf(stderr
, "init_names() failed\n");
5342 if(new_name_resolve_order
)
5343 lp_set_name_resolve_order(new_name_resolve_order
);
5345 if (!tar_type
&& !query_host
&& !service
&& !message
) {
5346 poptPrintUsage(pc
, stderr
, 0);
5350 poptFreeContext(pc
);
5352 DEBUG(3,("Client started (version %s).\n", samba_version_string()));
5354 /* Ensure we have a password (or equivalent). */
5355 set_cmdline_auth_info_getpass(auth_info
);
5359 process_command_string(cmdstr
);
5360 return do_tar_op(base_directory
);
5363 if (query_host
&& *query_host
) {
5364 char *qhost
= query_host
;
5367 while (*qhost
== '\\' || *qhost
== '/')
5370 if ((slash
= strchr_m(qhost
, '/'))
5371 || (slash
= strchr_m(qhost
, '\\'))) {
5375 if ((p
=strchr_m(qhost
, '#'))) {
5378 sscanf(p
, "%x", &name_type
);
5381 return do_host_query(qhost
);
5385 return do_message_op(auth_info
);
5388 if (process(base_directory
)) {