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-2004
7 Copyright (C) James J Myers 2003 <myersjj@samba.org>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 * TODO: remove this ... and don't use talloc_append_string()
26 * NOTE: I'm not changing the code yet, because I assume there're
27 * some bugs in the existing code and I'm not sure how to fix
30 #define TALLOC_DEPRECATED 1
34 #include "libcli/libcli.h"
35 #include "lib/events/events.h"
36 #include "lib/cmdline/cmdline.h"
37 #include "librpc/gen_ndr/ndr_srvsvc_c.h"
38 #include "librpc/gen_ndr/ndr_lsa.h"
39 #include "librpc/gen_ndr/ndr_security.h"
40 #include "libcli/util/clilsa.h"
41 #include "system/dir.h"
42 #include "system/filesys.h"
43 #include "../lib/util/dlinklist.h"
44 #include "system/readline.h"
45 #include "auth/credentials/credentials.h"
46 #include "auth/gensec/gensec.h"
47 #include "system/time.h" /* needed by some systems for asctime() */
48 #include "libcli/resolve/resolve.h"
49 #include "libcli/security/security.h"
50 #include "../libcli/smbreadline/smbreadline.h"
51 #include "librpc/gen_ndr/ndr_nbt.h"
52 #include "param/param.h"
53 #include "libcli/raw/raw_proto.h"
55 /* the default pager to use for the client "more" command. Users can
56 * override this with the PAGER environment variable */
58 #define DEFAULT_PAGER "more"
63 struct smbclient_context
{
65 struct smbcli_state
*cli
;
78 static uint64_t get_total_size
= 0;
79 static unsigned int get_total_time_ms
= 0;
80 static uint64_t put_total_size
= 0;
81 static unsigned int put_total_time_ms
= 0;
83 /* Unfortunately, there is no way to pass a context to the completion function as an argument */
84 static struct smbclient_context
*rl_ctx
;
87 static double dir_total
;
89 /*******************************************************************
90 Reduce a file name, removing .. elements.
91 ********************************************************************/
92 static void dos_clean_name(char *s
)
96 DEBUG(3,("dos_clean_name [%s]\n",s
));
98 /* remove any double slashes */
99 all_string_sub(s
, "\\\\", "\\", 0);
101 while ((p
= strstr(s
,"\\..\\")) != NULL
) {
103 if ((r
= strrchr(s
,'\\')) != NULL
)
104 memmove(r
,p
+3,strlen(p
+3)+1);
107 trim_string(s
,NULL
,"\\..");
109 all_string_sub(s
, "\\.\\", "\\", 0);
112 /****************************************************************************
113 write to a local file with CR/LF->LF translation if appropriate. return the
114 number taken from the buffer. This may not equal the number written.
115 ****************************************************************************/
116 static int writefile(int f
, const void *_b
, int n
, bool translation
)
118 const uint8_t *b
= (const uint8_t *)_b
;
127 if (*b
== '\r' && (i
<(n
-1)) && *(b
+1) == '\n') {
130 if (write(f
, b
, 1) != 1) {
140 /****************************************************************************
141 read from a file with LF->CR/LF translation if appropriate. return the
142 number read. read approx n bytes.
143 ****************************************************************************/
144 static int readfile(void *_b
, int n
, FILE *f
, bool translation
)
146 uint8_t *b
= (uint8_t *)_b
;
151 return fread(b
,1,n
,f
);
154 while (i
< (n
- 1)) {
155 if ((c
= getc(f
)) == EOF
) {
159 if (c
== '\n') { /* change all LFs to CR/LF */
170 /****************************************************************************
172 ****************************************************************************/
173 static void send_message(struct smbcli_state
*cli
, const char *desthost
)
178 struct cli_credentials
*creds
= samba_cmdline_get_creds();
180 if (!smbcli_message_start(cli
->tree
,
182 cli_credentials_get_username(creds
),
184 d_printf("message start: %s\n", smbcli_errstr(cli
->tree
));
189 d_printf("Connected. Type your message, ending it with a Control-D\n");
191 while (!feof(stdin
) && total_len
< 1600) {
192 int maxlen
= MIN(1600 - total_len
,127);
196 for (l
=0;l
<maxlen
&& (c
=fgetc(stdin
))!=EOF
;l
++) {
202 if (!smbcli_message_text(cli
->tree
, msg
, l
, grp_id
)) {
203 d_printf("SMBsendtxt failed (%s)\n",smbcli_errstr(cli
->tree
));
210 if (total_len
>= 1600)
211 d_printf("the message was truncated to 1600 bytes\n");
213 d_printf("sent %d bytes\n",total_len
);
215 if (!smbcli_message_end(cli
->tree
, grp_id
)) {
216 d_printf("SMBsendend failed (%s)\n",smbcli_errstr(cli
->tree
));
223 /****************************************************************************
224 check the space on a device
225 ****************************************************************************/
226 static int do_dskattr(struct smbclient_context
*ctx
)
229 uint64_t total
, avail
;
231 if (NT_STATUS_IS_ERR(smbcli_dskattr(ctx
->cli
->tree
, &bsize
, &total
, &avail
))) {
232 d_printf("Error in dskattr: %s\n",smbcli_errstr(ctx
->cli
->tree
));
236 d_printf("\n\t\t%llu blocks of size %u. %llu blocks available\n",
237 (unsigned long long)total
,
239 (unsigned long long)avail
);
244 /****************************************************************************
246 ****************************************************************************/
247 static int cmd_pwd(struct smbclient_context
*ctx
, const char **args
)
249 d_printf("Current directory is %s\n", ctx
->remote_cur_dir
);
254 convert a string to dos format
256 static void dos_format(char *s
)
258 string_replace(s
, '/', '\\');
261 /****************************************************************************
262 change directory - inner section
263 ****************************************************************************/
264 static int do_cd(struct smbclient_context
*ctx
, const char *newdir
)
268 /* Save the current directory in case the
269 new directory is invalid */
270 if (newdir
[0] == '\\')
271 dname
= talloc_strdup(ctx
, newdir
);
273 dname
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, newdir
);
277 if (*(dname
+strlen(dname
)-1) != '\\') {
278 dname
= talloc_append_string(NULL
, dname
, "\\");
280 dos_clean_name(dname
);
282 if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx
->cli
->tree
, dname
))) {
283 d_printf("cd %s: %s\n", dname
, smbcli_errstr(ctx
->cli
->tree
));
286 ctx
->remote_cur_dir
= dname
;
292 /****************************************************************************
294 ****************************************************************************/
295 static int cmd_cd(struct smbclient_context
*ctx
, const char **args
)
300 rc
= do_cd(ctx
, args
[1]);
302 d_printf("Current directory is %s\n",ctx
->remote_cur_dir
);
308 static bool mask_match(struct smbcli_state
*c
, const char *string
,
309 const char *pattern
, bool is_case_sensitive
)
313 if (ISDOTDOT(string
))
318 ret
= ms_fnmatch_protocol(pattern
, string
,
319 c
->transport
->negotiate
.protocol
,
326 /*******************************************************************
327 decide if a file should be operated on
328 ********************************************************************/
329 static bool do_this_one(struct smbclient_context
*ctx
, struct clilist_file_info
*finfo
)
331 if (finfo
->attrib
& FILE_ATTRIBUTE_DIRECTORY
) return(true);
333 if (ctx
->fileselection
&&
334 !mask_match(ctx
->cli
, finfo
->name
,ctx
->fileselection
,false)) {
335 DEBUG(3,("mask_match %s failed\n", finfo
->name
));
339 if (ctx
->newer_than
&& finfo
->mtime
< ctx
->newer_than
) {
340 DEBUG(3,("newer_than %s failed\n", finfo
->name
));
344 if ((ctx
->archive_level
==1 || ctx
->archive_level
==2) && !(finfo
->attrib
& FILE_ATTRIBUTE_ARCHIVE
)) {
345 DEBUG(3,("archive %s failed\n", finfo
->name
));
352 /****************************************************************************
353 display info about a file
354 ****************************************************************************/
355 static void display_finfo(struct smbclient_context
*ctx
, struct clilist_file_info
*finfo
)
357 if (do_this_one(ctx
, finfo
)) {
358 time_t t
= finfo
->mtime
; /* the time is assumed to be passed as GMT */
359 char *astr
= attrib_string(NULL
, finfo
->attrib
);
360 d_printf(" %-30s%7.7s %8.0f %s",
364 asctime(localtime(&t
)));
365 dir_total
+= finfo
->size
;
371 /****************************************************************************
372 accumulate size of a file
373 ****************************************************************************/
374 static void do_du(struct smbclient_context
*ctx
, struct clilist_file_info
*finfo
)
376 if (do_this_one(ctx
, finfo
)) {
377 dir_total
+= finfo
->size
;
381 static bool do_list_recurse
;
382 static bool do_list_dirs
;
383 static char *do_list_queue
= 0;
384 static long do_list_queue_size
= 0;
385 static long do_list_queue_start
= 0;
386 static long do_list_queue_end
= 0;
387 static void (*do_list_fn
)(struct smbclient_context
*, struct clilist_file_info
*);
389 /****************************************************************************
390 functions for do_list_queue
391 ****************************************************************************/
394 * The do_list_queue is a NUL-separated list of strings stored in a
395 * char*. Since this is a FIFO, we keep track of the beginning and
396 * ending locations of the data in the queue. When we overflow, we
397 * double the size of the char*. When the start of the data passes
398 * the midpoint, we move everything back. This is logically more
399 * complex than a linked list, but easier from a memory management
400 * angle. In any memory error condition, do_list_queue is reset.
401 * Functions check to ensure that do_list_queue is non-NULL before
404 static void reset_do_list_queue(void)
406 SAFE_FREE(do_list_queue
);
407 do_list_queue_size
= 0;
408 do_list_queue_start
= 0;
409 do_list_queue_end
= 0;
412 static void init_do_list_queue(void)
414 reset_do_list_queue();
415 do_list_queue_size
= 1024;
416 do_list_queue
= malloc_array_p(char, do_list_queue_size
);
417 if (do_list_queue
== 0) {
418 d_printf("malloc fail for size %d\n",
419 (int)do_list_queue_size
);
420 reset_do_list_queue();
422 memset(do_list_queue
, 0, do_list_queue_size
);
426 static void adjust_do_list_queue(void)
428 if (do_list_queue
== NULL
) return;
431 * If the starting point of the queue is more than half way through,
432 * move everything toward the beginning.
434 if (do_list_queue_start
== do_list_queue_end
)
436 DEBUG(4,("do_list_queue is empty\n"));
437 do_list_queue_start
= do_list_queue_end
= 0;
438 *do_list_queue
= '\0';
440 else if (do_list_queue_start
> (do_list_queue_size
/ 2))
442 DEBUG(4,("sliding do_list_queue backward\n"));
443 memmove(do_list_queue
,
444 do_list_queue
+ do_list_queue_start
,
445 do_list_queue_end
- do_list_queue_start
);
446 do_list_queue_end
-= do_list_queue_start
;
447 do_list_queue_start
= 0;
452 static void add_to_do_list_queue(const char* entry
)
461 new_end
= do_list_queue_end
+ ((long)strlen(entry
)) + 1;
462 while (new_end
> do_list_queue_size
)
464 do_list_queue_size
*= 2;
465 DEBUG(4,("enlarging do_list_queue to %d\n",
466 (int)do_list_queue_size
));
467 dlq
= realloc_p(do_list_queue
, char, do_list_queue_size
);
469 d_printf("failure enlarging do_list_queue to %d bytes\n",
470 (int)do_list_queue_size
);
471 reset_do_list_queue();
476 memset(do_list_queue
+ do_list_queue_size
/ 2,
477 0, do_list_queue_size
/ 2);
482 strlcpy(do_list_queue
+ do_list_queue_end
, entry
,
483 do_list_queue_size
- do_list_queue_end
);
484 do_list_queue_end
= new_end
;
485 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
486 entry
, (int)do_list_queue_start
, (int)do_list_queue_end
));
490 static char *do_list_queue_head(void)
492 return do_list_queue
+ do_list_queue_start
;
495 static void remove_do_list_queue_head(void)
497 if (do_list_queue_end
> do_list_queue_start
)
499 do_list_queue_start
+= strlen(do_list_queue_head()) + 1;
500 adjust_do_list_queue();
501 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
502 (int)do_list_queue_start
, (int)do_list_queue_end
));
506 static int do_list_queue_empty(void)
508 return (! (do_list_queue
&& *do_list_queue
));
511 /****************************************************************************
513 ****************************************************************************/
514 static void do_list_helper(struct clilist_file_info
*f
, const char *mask
, void *state
)
516 struct smbclient_context
*ctx
= (struct smbclient_context
*)state
;
518 if (f
->attrib
& FILE_ATTRIBUTE_DIRECTORY
) {
519 if (do_list_dirs
&& do_this_one(ctx
, f
)) {
522 if (do_list_recurse
&&
524 !ISDOTDOT(f
->name
)) {
528 mask2
= talloc_strdup(NULL
, mask
);
529 p
= strrchr_m(mask2
,'\\');
532 mask2
= talloc_asprintf_append_buffer(mask2
, "%s\\*", f
->name
);
533 add_to_do_list_queue(mask2
);
538 if (do_this_one(ctx
, f
)) {
544 /****************************************************************************
545 a wrapper around smbcli_list that adds recursion
546 ****************************************************************************/
547 static void do_list(struct smbclient_context
*ctx
, const char *mask
,uint16_t attribute
,
548 void (*fn
)(struct smbclient_context
*, struct clilist_file_info
*),bool rec
, bool dirs
)
550 static int in_do_list
= 0;
552 if (in_do_list
&& rec
)
554 fprintf(stderr
, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
560 do_list_recurse
= rec
;
566 init_do_list_queue();
567 add_to_do_list_queue(mask
);
569 while (! do_list_queue_empty())
572 * Need to copy head so that it doesn't become
573 * invalid inside the call to smbcli_list. This
574 * would happen if the list were expanded
576 * Fix from E. Jay Berkenbilt (ejb@ql.org)
579 head
= do_list_queue_head();
580 smbcli_list(ctx
->cli
->tree
, head
, attribute
, do_list_helper
, ctx
);
581 remove_do_list_queue_head();
582 if ((! do_list_queue_empty()) && (fn
== display_finfo
))
584 char* next_file
= do_list_queue_head();
586 if ((strlen(next_file
) >= 2) &&
587 (next_file
[strlen(next_file
) - 1] == '*') &&
588 (next_file
[strlen(next_file
) - 2] == '\\'))
590 save_ch
= next_file
+
591 strlen(next_file
) - 2;
594 d_printf("\n%s\n",next_file
);
604 if (smbcli_list(ctx
->cli
->tree
, mask
, attribute
, do_list_helper
, ctx
) == -1)
606 d_printf("%s listing %s\n", smbcli_errstr(ctx
->cli
->tree
), mask
);
611 reset_do_list_queue();
614 /****************************************************************************
615 get a directory listing
616 ****************************************************************************/
617 static int cmd_dir(struct smbclient_context
*ctx
, const char **args
)
619 uint16_t attribute
= FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
625 mask
= talloc_strdup(ctx
, ctx
->remote_cur_dir
);
626 if(mask
[strlen(mask
)-1]!='\\')
627 mask
= talloc_append_string(ctx
, mask
,"\\");
630 mask
= talloc_strdup(ctx
, args
[1]);
632 mask
= talloc_append_string(ctx
, mask
, "\\");
636 if (ctx
->cli
->tree
->session
->transport
->negotiate
.protocol
<=
638 mask
= talloc_append_string(ctx
, mask
, "*.*");
640 mask
= talloc_append_string(ctx
, mask
, "*");
644 do_list(ctx
, mask
, attribute
, display_finfo
, ctx
->recurse
, true);
646 rc
= do_dskattr(ctx
);
648 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total
));
654 /****************************************************************************
655 get a directory listing
656 ****************************************************************************/
657 static int cmd_du(struct smbclient_context
*ctx
, const char **args
)
659 uint16_t attribute
= FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
666 if (args
[1][0] == '\\')
667 mask
= talloc_strdup(ctx
, args
[1]);
669 mask
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, args
[1]);
672 mask
= talloc_asprintf(ctx
, "%s\\*", ctx
->remote_cur_dir
);
675 do_list(ctx
, mask
, attribute
, do_du
, ctx
->recurse
, true);
679 rc
= do_dskattr(ctx
);
681 d_printf("Total number of bytes: %.0f\n", dir_total
);
687 /****************************************************************************
688 get a file from rname to lname
689 ****************************************************************************/
690 static int do_get(struct smbclient_context
*ctx
, char *rname
, const char *p_lname
, bool reget
)
692 int handle
= 0, fnum
;
693 bool newhandle
= false;
695 struct timeval tp_start
;
696 int read_size
= ctx
->io_bufsize
;
705 GetTimeOfDay(&tp_start
);
707 if (ctx
->lowercase
) {
708 lname
= strlower_talloc(ctx
, p_lname
);
710 lname
= talloc_strdup(ctx
, p_lname
);
713 fnum
= smbcli_open(ctx
->cli
->tree
, rname
, O_RDONLY
, DENY_NONE
);
716 d_printf("%s opening remote file %s\n",smbcli_errstr(ctx
->cli
->tree
),rname
);
720 if(!strcmp(lname
,"-")) {
721 handle
= fileno(stdout
);
724 handle
= open(lname
, O_WRONLY
|O_CREAT
, 0644);
726 start
= lseek(handle
, 0, SEEK_END
);
728 d_printf("Error seeking local file\n");
734 handle
= open(lname
, O_WRONLY
|O_CREAT
|O_TRUNC
, 0644);
739 d_printf("Error opening local file %s\n",lname
);
744 if (NT_STATUS_IS_ERR(smbcli_qfileinfo(ctx
->cli
->tree
, fnum
,
745 &attr
, &size
, NULL
, NULL
, NULL
, NULL
, NULL
)) &&
746 NT_STATUS_IS_ERR(smbcli_getattrE(ctx
->cli
->tree
, fnum
,
747 &attr
, &size
, NULL
, NULL
, NULL
))) {
748 d_printf("getattrib: %s\n",smbcli_errstr(ctx
->cli
->tree
));
755 DEBUG(2,("getting file %s of size %.0f as %s ",
756 rname
, (double)size
, lname
));
758 if(!(data
= (uint8_t *)malloc(read_size
))) {
759 d_printf("malloc fail for size %d\n", read_size
);
760 smbcli_close(ctx
->cli
->tree
, fnum
);
768 int n
= smbcli_read(ctx
->cli
->tree
, fnum
, data
, nread
+ start
, read_size
);
772 if (writefile(handle
,data
, n
, ctx
->translation
) != n
) {
773 d_printf("Error writing local file\n");
781 if (nread
+ start
< size
) {
782 DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n",
783 rname
, (long)nread
));
790 if (NT_STATUS_IS_ERR(smbcli_close(ctx
->cli
->tree
, fnum
))) {
791 d_printf("Error %s closing remote file\n",smbcli_errstr(ctx
->cli
->tree
));
799 if (ctx
->archive_level
>= 2 && (attr
& FILE_ATTRIBUTE_ARCHIVE
)) {
800 smbcli_setatr(ctx
->cli
->tree
, rname
, attr
& ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE
, 0);
804 struct timeval tp_end
;
807 GetTimeOfDay(&tp_end
);
809 (tp_end
.tv_sec
- tp_start
.tv_sec
)*1000 +
810 (tp_end
.tv_usec
- tp_start
.tv_usec
)/1000;
811 get_total_time_ms
+= this_time
;
812 get_total_size
+= nread
;
814 DEBUG(2,("(%3.1f kb/s) (average %3.1f kb/s)\n",
815 nread
/ (1.024*this_time
+ 1.0e-4),
816 get_total_size
/ (1.024*get_total_time_ms
)));
823 /****************************************************************************
825 ****************************************************************************/
826 static int cmd_get(struct smbclient_context
*ctx
, const char **args
)
832 d_printf("get <filename>\n");
836 rname
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, args
[1]);
843 dos_clean_name(rname
);
845 return do_get(ctx
, rname
, lname
, false);
848 /****************************************************************************
849 Put up a yes/no prompt.
850 ****************************************************************************/
851 static bool yesno(char *p
)
856 if (!fgets(ans
,sizeof(ans
)-1,stdin
))
859 if (*ans
== 'y' || *ans
== 'Y')
865 /****************************************************************************
866 do a mget operation on one file
867 ****************************************************************************/
868 static void do_mget(struct smbclient_context
*ctx
, struct clilist_file_info
*finfo
)
877 if (ISDOT(finfo
->name
) || ISDOTDOT(finfo
->name
))
880 if (finfo
->attrib
& FILE_ATTRIBUTE_DIRECTORY
)
881 quest
= talloc_asprintf(ctx
, "Get directory %s? ",finfo
->name
);
883 quest
= talloc_asprintf(ctx
, "Get file %s? ",finfo
->name
);
885 if (ctx
->prompt
&& !yesno(quest
)) return;
889 if (!(finfo
->attrib
& FILE_ATTRIBUTE_DIRECTORY
)) {
890 rname
= talloc_asprintf(ctx
, "%s%s",ctx
->remote_cur_dir
,
892 do_get(ctx
, rname
, finfo
->name
, false);
897 /* handle directories */
898 saved_curdir
= talloc_strdup(ctx
, ctx
->remote_cur_dir
);
900 ctx
->remote_cur_dir
= talloc_asprintf_append_buffer(NULL
, "%s\\", finfo
->name
);
902 if (ctx
->lowercase
) {
903 l_fname
= strlower_talloc(ctx
, finfo
->name
);
905 l_fname
= talloc_strdup(ctx
, finfo
->name
);
908 string_replace(l_fname
, '\\', '/');
910 if (!directory_exist(l_fname
) &&
911 mkdir(l_fname
, 0777) != 0) {
912 d_printf("failed to create directory %s\n", l_fname
);
916 if (chdir(l_fname
) != 0) {
917 d_printf("failed to chdir to directory %s\n", l_fname
);
921 mget_mask
= talloc_asprintf(ctx
, "%s*", ctx
->remote_cur_dir
);
923 do_list(ctx
, mget_mask
, FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_DIRECTORY
,do_mget
,false, true);
926 d_printf("failed to chdir to '..': %s\n", strerror(errno
));
929 talloc_free(ctx
->remote_cur_dir
);
931 ctx
->remote_cur_dir
= saved_curdir
;
935 /****************************************************************************
936 view the file using the pager
937 ****************************************************************************/
938 static int cmd_more(struct smbclient_context
*ctx
, const char **args
)
948 lname
= talloc_asprintf(ctx
, "%s/smbmore.XXXXXX",tmpdir());
949 mask
= umask(S_IRWXO
| S_IRWXG
);
953 d_printf("failed to create temporary file for more\n");
959 d_printf("more <filename>\n");
963 rname
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
964 dos_clean_name(rname
);
966 rc
= do_get(ctx
, rname
, lname
, false);
968 pager
=getenv("PAGER");
970 pager_cmd
= talloc_asprintf(ctx
, "%s %s",(pager
? pager
:DEFAULT_PAGER
), lname
);
971 rc
= system(pager_cmd
);
973 d_printf("failed to call pager command\n");
983 /****************************************************************************
985 ****************************************************************************/
986 static int cmd_mget(struct smbclient_context
*ctx
, const char **args
)
988 uint16_t attribute
= FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
;
989 char *mget_mask
= NULL
;
993 attribute
|= FILE_ATTRIBUTE_DIRECTORY
;
995 for (i
= 1; args
[i
]; i
++) {
996 mget_mask
= talloc_strdup(ctx
, ctx
->remote_cur_dir
);
997 if(mget_mask
[strlen(mget_mask
)-1]!='\\')
998 mget_mask
= talloc_append_string(ctx
, mget_mask
, "\\");
1000 mget_mask
= talloc_strdup(ctx
, args
[i
]);
1001 if (mget_mask
[0] != '\\')
1002 mget_mask
= talloc_append_string(ctx
, mget_mask
, "\\");
1003 do_list(ctx
, mget_mask
, attribute
,do_mget
,false,true);
1005 talloc_free(mget_mask
);
1008 if (mget_mask
== NULL
) {
1009 mget_mask
= talloc_asprintf(ctx
, "%s\\*", ctx
->remote_cur_dir
);
1010 do_list(ctx
, mget_mask
, attribute
,do_mget
,false,true);
1011 talloc_free(mget_mask
);
1018 /****************************************************************************
1019 make a directory of name "name"
1020 ****************************************************************************/
1021 static NTSTATUS
do_mkdir(struct smbclient_context
*ctx
, char *name
)
1025 if (NT_STATUS_IS_ERR(status
= smbcli_mkdir(ctx
->cli
->tree
, name
))) {
1026 d_printf("%s making remote directory %s\n",
1027 smbcli_errstr(ctx
->cli
->tree
),name
);
1035 /****************************************************************************
1037 ****************************************************************************/
1038 static int cmd_quit(struct smbclient_context
*ctx
, const char **args
)
1047 /****************************************************************************
1049 ****************************************************************************/
1050 static int cmd_mkdir(struct smbclient_context
*ctx
, const char **args
)
1056 d_printf("mkdir <dirname>\n");
1060 mask
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
,args
[1]);
1063 dos_clean_name(mask
);
1065 trim_string(mask
,".",NULL
);
1066 for (p
= strtok(mask
,"/\\"); p
; p
= strtok(p
, "/\\")) {
1067 char *parent
= talloc_strndup(ctx
, mask
, PTR_DIFF(p
, mask
));
1069 if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx
->cli
->tree
, parent
))) {
1070 do_mkdir(ctx
, parent
);
1073 talloc_free(parent
);
1076 do_mkdir(ctx
, mask
);
1082 /****************************************************************************
1083 show 8.3 name of a file
1084 ****************************************************************************/
1085 static int cmd_altname(struct smbclient_context
*ctx
, const char **args
)
1092 d_printf("altname <file>\n");
1096 name
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
1098 if (!NT_STATUS_IS_OK(smbcli_qpathinfo_alt_name(ctx
->cli
->tree
, name
, &p
))) {
1099 d_printf("%s getting alt name for %s\n",
1100 smbcli_errstr(ctx
->cli
->tree
),name
);
1103 altname
= discard_const_p(char, p
);
1104 d_printf("%s\n", altname
);
1112 /****************************************************************************
1114 ****************************************************************************/
1115 static int do_put(struct smbclient_context
*ctx
, char *rname
, char *lname
, bool reput
)
1121 uint8_t *buf
= NULL
;
1122 int maxwrite
= ctx
->io_bufsize
;
1125 struct timeval tp_start
;
1126 GetTimeOfDay(&tp_start
);
1129 fnum
= smbcli_open(ctx
->cli
->tree
, rname
, O_RDWR
|O_CREAT
, DENY_NONE
);
1131 if (NT_STATUS_IS_ERR(smbcli_qfileinfo(ctx
->cli
->tree
, fnum
, NULL
, &start
, NULL
, NULL
, NULL
, NULL
, NULL
)) &&
1132 NT_STATUS_IS_ERR(smbcli_getattrE(ctx
->cli
->tree
, fnum
, NULL
, &start
, NULL
, NULL
, NULL
))) {
1133 d_printf("getattrib: %s\n",smbcli_errstr(ctx
->cli
->tree
));
1138 fnum
= smbcli_open(ctx
->cli
->tree
, rname
, O_RDWR
|O_CREAT
|O_TRUNC
,
1143 d_printf("%s opening remote file %s\n",smbcli_errstr(ctx
->cli
->tree
),rname
);
1147 /* allow files to be piped into smbclient
1150 Note that in this case this function will exit(0) rather
1152 if (!strcmp(lname
, "-")) {
1154 /* size of file is not known */
1156 f
= fopen(lname
, "r");
1158 if (fseek(f
, start
, SEEK_SET
) == -1) {
1159 d_printf("Error seeking local file\n");
1167 d_printf("Error opening local file %s\n",lname
);
1172 DEBUG(1,("putting file %s as %s ",lname
,
1175 buf
= (uint8_t *)malloc(maxwrite
);
1177 d_printf("ERROR: Not enough memory!\n");
1185 if ((n
= readfile(buf
,n
,f
,ctx
->translation
)) < 1) {
1186 if((n
== 0) && feof(f
))
1187 break; /* Empty local file. */
1189 d_printf("Error reading local file: %s\n", strerror(errno
));
1194 ret
= smbcli_write(ctx
->cli
->tree
, fnum
, 0, buf
, nread
+ start
, n
);
1197 d_printf("Error writing file: %s\n", smbcli_errstr(ctx
->cli
->tree
));
1205 if (NT_STATUS_IS_ERR(smbcli_close(ctx
->cli
->tree
, fnum
))) {
1206 d_printf("%s closing remote file %s\n",smbcli_errstr(ctx
->cli
->tree
),rname
);
1220 struct timeval tp_end
;
1223 GetTimeOfDay(&tp_end
);
1225 (tp_end
.tv_sec
- tp_start
.tv_sec
)*1000 +
1226 (tp_end
.tv_usec
- tp_start
.tv_usec
)/1000;
1227 put_total_time_ms
+= this_time
;
1228 put_total_size
+= nread
;
1230 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1231 nread
/ (1.024*this_time
+ 1.0e-4),
1232 put_total_size
/ (1.024*put_total_time_ms
)));
1245 /****************************************************************************
1247 ****************************************************************************/
1248 static int cmd_put(struct smbclient_context
*ctx
, const char **args
)
1254 d_printf("put <filename> [<remotename>]\n");
1258 lname
= talloc_strdup(ctx
, args
[1]);
1261 if (args
[2][0]=='\\')
1262 rname
= talloc_strdup(ctx
, args
[2]);
1264 rname
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, args
[2]);
1266 rname
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, lname
);
1269 dos_clean_name(rname
);
1271 /* allow '-' to represent stdin
1272 jdblair, 24.jun.98 */
1273 if (!file_exist(lname
) && (strcmp(lname
,"-"))) {
1274 d_printf("%s does not exist\n",lname
);
1278 return do_put(ctx
, rname
, lname
, false);
1281 /*************************************
1283 *************************************/
1285 static struct file_list
{
1286 struct file_list
*prev
, *next
;
1291 /****************************************************************************
1292 Free a file_list structure
1293 ****************************************************************************/
1295 static void free_file_list (struct file_list
* list
)
1297 struct file_list
*tmp
;
1302 DLIST_REMOVE(list
, list
);
1303 SAFE_FREE(tmp
->file_path
);
1308 /****************************************************************************
1309 seek in a directory/file list until you get something that doesn't start with
1311 ****************************************************************************/
1312 static bool seek_list(struct file_list
*list
, char *name
)
1315 trim_string(list
->file_path
,"./","\n");
1316 if (strncmp(list
->file_path
, name
, strlen(name
)) != 0) {
1325 /****************************************************************************
1326 set the file selection mask
1327 ****************************************************************************/
1328 static int cmd_select(struct smbclient_context
*ctx
, const char **args
)
1330 talloc_free(ctx
->fileselection
);
1331 ctx
->fileselection
= talloc_strdup(ctx
, args
[1]);
1336 /*******************************************************************
1337 A readdir wrapper which just returns the file name.
1338 ********************************************************************/
1339 static const char *readdirname(DIR *p
)
1347 ptr
= (struct dirent
*)readdir(p
);
1351 dname
= ptr
->d_name
;
1353 #ifdef HAVE_BROKEN_READDIR
1354 /* using /usr/ucb/cc is BAD */
1360 int len
= NAMLEN(ptr
);
1361 buf
= talloc_strndup(NULL
, dname
, len
);
1368 /****************************************************************************
1369 Recursive file matching function act as find
1370 match must be always set to true when calling this function
1371 ****************************************************************************/
1372 static int file_find(struct smbclient_context
*ctx
, struct file_list
**list
, const char *directory
,
1373 const char *expression
, bool match
)
1376 struct file_list
*entry
;
1377 struct stat statbuf
;
1383 dir
= opendir(directory
);
1384 if (!dir
) return -1;
1386 while ((dname
= readdirname(dir
))) {
1387 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
1391 if (asprintf(&path
, "%s/%s", directory
, dname
) <= 0) {
1396 if (!match
|| !gen_fnmatch(expression
, dname
)) {
1398 ret
= stat(path
, &statbuf
);
1400 if (S_ISDIR(statbuf
.st_mode
)) {
1402 ret
= file_find(ctx
, list
, path
, expression
, false);
1405 d_printf("file_find: cannot stat file %s\n", path
);
1414 entry
= malloc_p(struct file_list
);
1416 d_printf("Out of memory in file_find\n");
1420 entry
->file_path
= path
;
1421 entry
->isdir
= isdir
;
1422 DLIST_ADD(*list
, entry
);
1432 /****************************************************************************
1434 ****************************************************************************/
1435 static int cmd_mput(struct smbclient_context
*ctx
, const char **args
)
1439 for (i
= 1; args
[i
]; i
++) {
1441 struct file_list
*temp_list
;
1442 char *quest
, *lname
, *rname
;
1444 printf("%s\n", args
[i
]);
1448 ret
= file_find(ctx
, &file_list
, ".", args
[i
], true);
1450 free_file_list(file_list
);
1458 for (temp_list
= file_list
; temp_list
;
1459 temp_list
= temp_list
->next
) {
1462 if (asprintf(&lname
, "%s/", temp_list
->file_path
) <= 0)
1464 trim_string(lname
, "./", "/");
1466 /* check if it's a directory */
1467 if (temp_list
->isdir
) {
1468 /* if (!recurse) continue; */
1471 if (asprintf(&quest
, "Put directory %s? ", lname
) < 0) break;
1472 if (ctx
->prompt
&& !yesno(quest
)) { /* No */
1473 /* Skip the directory */
1474 lname
[strlen(lname
)-1] = '/';
1475 if (!seek_list(temp_list
, lname
))
1479 if(asprintf(&rname
, "%s%s", ctx
->remote_cur_dir
, lname
) < 0) break;
1481 if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx
->cli
->tree
, rname
)) &&
1482 NT_STATUS_IS_ERR(do_mkdir(ctx
, rname
))) {
1483 DEBUG (0, ("Unable to make dir, skipping...\n"));
1484 /* Skip the directory */
1485 lname
[strlen(lname
)-1] = '/';
1486 if (!seek_list(temp_list
, lname
))
1493 if (asprintf(&quest
,"Put file %s? ", lname
) < 0) break;
1494 if (ctx
->prompt
&& !yesno(quest
)) /* No */
1499 if (asprintf(&rname
, "%s%s", ctx
->remote_cur_dir
, lname
) < 0) break;
1504 do_put(ctx
, rname
, lname
, false);
1506 free_file_list(file_list
);
1516 /****************************************************************************
1518 ****************************************************************************/
1519 static int cmd_print(struct smbclient_context
*ctx
, const char **args
)
1521 char *lname
, *rname
;
1525 d_printf("print <filename>\n");
1529 lname
= talloc_strdup(ctx
, args
[1]);
1530 if (lname
== NULL
) {
1531 d_printf("Out of memory in cmd_print\n");
1535 if (strequal(lname
, "-")) {
1536 rname
= talloc_asprintf(ctx
, "stdin-%d", (int)getpid());
1538 p
= strrchr_m(lname
, '/');
1540 rname
= talloc_asprintf(ctx
, "%s-%d", p
+ 1,
1543 rname
= talloc_strdup(ctx
, lname
);
1547 if (rname
== NULL
) {
1548 d_printf("Out of memory in cmd_print (stdin)\n");
1552 return do_put(ctx
, rname
, lname
, false);
1556 static int cmd_rewrite(struct smbclient_context
*ctx
, const char **args
)
1558 d_printf("REWRITE: command not implemented (FIXME!)\n");
1563 /****************************************************************************
1565 ****************************************************************************/
1566 static int cmd_del(struct smbclient_context
*ctx
, const char **args
)
1571 d_printf("del <filename>\n");
1574 mask
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
1576 if (NT_STATUS_IS_ERR(smbcli_unlink(ctx
->cli
->tree
, mask
))) {
1577 d_printf("%s deleting remote file %s\n",smbcli_errstr(ctx
->cli
->tree
),mask
);
1584 /****************************************************************************
1585 delete a whole directory tree
1586 ****************************************************************************/
1587 static int cmd_deltree(struct smbclient_context
*ctx
, const char **args
)
1593 d_printf("deltree <dirname>\n");
1597 dname
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
1599 ret
= smbcli_deltree(ctx
->cli
->tree
, dname
);
1602 printf("Failed to delete tree %s - %s\n", dname
, smbcli_errstr(ctx
->cli
->tree
));
1606 printf("Deleted %d files in %s\n", ret
, dname
);
1612 const char *level_name
;
1613 enum smb_fsinfo_level level
;
1616 fsinfo_level_t fsinfo_levels
[] = {
1617 {"dskattr", RAW_QFS_DSKATTR
},
1618 {"allocation", RAW_QFS_ALLOCATION
},
1619 {"volume", RAW_QFS_VOLUME
},
1620 {"volumeinfo", RAW_QFS_VOLUME_INFO
},
1621 {"sizeinfo", RAW_QFS_SIZE_INFO
},
1622 {"deviceinfo", RAW_QFS_DEVICE_INFO
},
1623 {"attributeinfo", RAW_QFS_ATTRIBUTE_INFO
},
1624 {"unixinfo", RAW_QFS_UNIX_INFO
},
1625 {"volume-information", RAW_QFS_VOLUME_INFORMATION
},
1626 {"size-information", RAW_QFS_SIZE_INFORMATION
},
1627 {"device-information", RAW_QFS_DEVICE_INFORMATION
},
1628 {"attribute-information", RAW_QFS_ATTRIBUTE_INFORMATION
},
1629 {"quota-information", RAW_QFS_QUOTA_INFORMATION
},
1630 {"fullsize-information", RAW_QFS_FULL_SIZE_INFORMATION
},
1631 {"objectid", RAW_QFS_OBJECTID_INFORMATION
},
1632 {"sector-size-info", RAW_QFS_SECTOR_SIZE_INFORMATION
},
1633 {NULL
, RAW_QFS_GENERIC
}
1637 static int cmd_fsinfo(struct smbclient_context
*ctx
, const char **args
)
1639 union smb_fsinfo fsinfo
;
1641 fsinfo_level_t
*fsinfo_level
;
1644 d_printf("fsinfo <level>, where level is one of following:\n");
1645 fsinfo_level
= fsinfo_levels
;
1646 while(fsinfo_level
->level_name
) {
1647 d_printf("%s\n", fsinfo_level
->level_name
);
1653 fsinfo_level
= fsinfo_levels
;
1654 while(fsinfo_level
->level_name
&& !strequal(args
[1],fsinfo_level
->level_name
)) {
1658 if (!fsinfo_level
->level_name
) {
1659 d_printf("wrong level name!\n");
1663 fsinfo
.generic
.level
= fsinfo_level
->level
;
1664 status
= smb_raw_fsinfo(ctx
->cli
->tree
, ctx
, &fsinfo
);
1665 if (!NT_STATUS_IS_OK(status
)) {
1666 d_printf("fsinfo-level-%s - %s\n", fsinfo_level
->level_name
, nt_errstr(status
));
1670 d_printf("fsinfo-level-%s:\n", fsinfo_level
->level_name
);
1671 switch(fsinfo
.generic
.level
) {
1672 case RAW_QFS_DSKATTR
:
1673 d_printf("\tunits_total: %hu\n",
1674 (unsigned short) fsinfo
.dskattr
.out
.units_total
);
1675 d_printf("\tblocks_per_unit: %hu\n",
1676 (unsigned short) fsinfo
.dskattr
.out
.blocks_per_unit
);
1677 d_printf("\tblocks_size: %hu\n",
1678 (unsigned short) fsinfo
.dskattr
.out
.block_size
);
1679 d_printf("\tunits_free: %hu\n",
1680 (unsigned short) fsinfo
.dskattr
.out
.units_free
);
1682 case RAW_QFS_ALLOCATION
:
1683 d_printf("\tfs_id: %lu\n",
1684 (unsigned long) fsinfo
.allocation
.out
.fs_id
);
1685 d_printf("\tsectors_per_unit: %lu\n",
1686 (unsigned long) fsinfo
.allocation
.out
.sectors_per_unit
);
1687 d_printf("\ttotal_alloc_units: %lu\n",
1688 (unsigned long) fsinfo
.allocation
.out
.total_alloc_units
);
1689 d_printf("\tavail_alloc_units: %lu\n",
1690 (unsigned long) fsinfo
.allocation
.out
.avail_alloc_units
);
1691 d_printf("\tbytes_per_sector: %hu\n",
1692 (unsigned short) fsinfo
.allocation
.out
.bytes_per_sector
);
1694 case RAW_QFS_VOLUME
:
1695 d_printf("\tserial_number: %lu\n",
1696 (unsigned long) fsinfo
.volume
.out
.serial_number
);
1697 d_printf("\tvolume_name: %s\n", fsinfo
.volume
.out
.volume_name
.s
);
1699 case RAW_QFS_VOLUME_INFO
:
1700 case RAW_QFS_VOLUME_INFORMATION
:
1701 d_printf("\tcreate_time: %s\n",
1702 nt_time_string(ctx
,fsinfo
.volume_info
.out
.create_time
));
1703 d_printf("\tserial_number: %lu\n",
1704 (unsigned long) fsinfo
.volume_info
.out
.serial_number
);
1705 d_printf("\tvolume_name: %s\n", fsinfo
.volume_info
.out
.volume_name
.s
);
1707 case RAW_QFS_SIZE_INFO
:
1708 case RAW_QFS_SIZE_INFORMATION
:
1709 d_printf("\ttotal_alloc_units: %llu\n",
1710 (unsigned long long) fsinfo
.size_info
.out
.total_alloc_units
);
1711 d_printf("\tavail_alloc_units: %llu\n",
1712 (unsigned long long) fsinfo
.size_info
.out
.avail_alloc_units
);
1713 d_printf("\tsectors_per_unit: %lu\n",
1714 (unsigned long) fsinfo
.size_info
.out
.sectors_per_unit
);
1715 d_printf("\tbytes_per_sector: %lu\n",
1716 (unsigned long) fsinfo
.size_info
.out
.bytes_per_sector
);
1718 case RAW_QFS_DEVICE_INFO
:
1719 case RAW_QFS_DEVICE_INFORMATION
:
1720 d_printf("\tdevice_type: %lu\n",
1721 (unsigned long) fsinfo
.device_info
.out
.device_type
);
1722 d_printf("\tcharacteristics: 0x%lx\n",
1723 (unsigned long) fsinfo
.device_info
.out
.characteristics
);
1725 case RAW_QFS_ATTRIBUTE_INFORMATION
:
1726 case RAW_QFS_ATTRIBUTE_INFO
:
1727 d_printf("\tfs_attr: 0x%lx\n",
1728 (unsigned long) fsinfo
.attribute_info
.out
.fs_attr
);
1729 d_printf("\tmax_file_component_length: %lu\n",
1730 (unsigned long) fsinfo
.attribute_info
.out
.max_file_component_length
);
1731 d_printf("\tfs_type: %s\n", fsinfo
.attribute_info
.out
.fs_type
.s
);
1733 case RAW_QFS_UNIX_INFO
:
1734 d_printf("\tmajor_version: %hu\n",
1735 (unsigned short) fsinfo
.unix_info
.out
.major_version
);
1736 d_printf("\tminor_version: %hu\n",
1737 (unsigned short) fsinfo
.unix_info
.out
.minor_version
);
1738 d_printf("\tcapability: 0x%llx\n",
1739 (unsigned long long) fsinfo
.unix_info
.out
.capability
);
1741 case RAW_QFS_QUOTA_INFORMATION
:
1742 d_printf("\tunknown[3]: [%llu,%llu,%llu]\n",
1743 (unsigned long long) fsinfo
.quota_information
.out
.unknown
[0],
1744 (unsigned long long) fsinfo
.quota_information
.out
.unknown
[1],
1745 (unsigned long long) fsinfo
.quota_information
.out
.unknown
[2]);
1746 d_printf("\tquota_soft: %llu\n",
1747 (unsigned long long) fsinfo
.quota_information
.out
.quota_soft
);
1748 d_printf("\tquota_hard: %llu\n",
1749 (unsigned long long) fsinfo
.quota_information
.out
.quota_hard
);
1750 d_printf("\tquota_flags: 0x%llx\n",
1751 (unsigned long long) fsinfo
.quota_information
.out
.quota_flags
);
1753 case RAW_QFS_FULL_SIZE_INFORMATION
:
1754 d_printf("\ttotal_alloc_units: %llu\n",
1755 (unsigned long long) fsinfo
.full_size_information
.out
.total_alloc_units
);
1756 d_printf("\tcall_avail_alloc_units: %llu\n",
1757 (unsigned long long) fsinfo
.full_size_information
.out
.call_avail_alloc_units
);
1758 d_printf("\tactual_avail_alloc_units: %llu\n",
1759 (unsigned long long) fsinfo
.full_size_information
.out
.actual_avail_alloc_units
);
1760 d_printf("\tsectors_per_unit: %lu\n",
1761 (unsigned long) fsinfo
.full_size_information
.out
.sectors_per_unit
);
1762 d_printf("\tbytes_per_sector: %lu\n",
1763 (unsigned long) fsinfo
.full_size_information
.out
.bytes_per_sector
);
1765 case RAW_QFS_OBJECTID_INFORMATION
:
1766 d_printf("\tGUID: %s\n",
1767 GUID_string(ctx
,&fsinfo
.objectid_information
.out
.guid
));
1768 d_printf("\tunknown[6]: [%llu,%llu,%llu,%llu,%llu,%llu]\n",
1769 (unsigned long long) fsinfo
.objectid_information
.out
.unknown
[0],
1770 (unsigned long long) fsinfo
.objectid_information
.out
.unknown
[1],
1771 (unsigned long long) fsinfo
.objectid_information
.out
.unknown
[2],
1772 (unsigned long long) fsinfo
.objectid_information
.out
.unknown
[3],
1773 (unsigned long long) fsinfo
.objectid_information
.out
.unknown
[4],
1774 (unsigned long long) fsinfo
.objectid_information
.out
.unknown
[5] );
1776 case RAW_QFS_SECTOR_SIZE_INFORMATION
:
1777 d_printf("\tlogical_bytes_per_sector: %u\n",
1778 (unsigned)fsinfo
.sector_size_info
.out
.logical_bytes_per_sector
);
1779 d_printf("\tphys_bytes_per_sector_atomic: %u\n",
1780 (unsigned)fsinfo
.sector_size_info
.out
.phys_bytes_per_sector_atomic
);
1781 d_printf("\tphys_bytes_per_sector_perf: %u\n",
1782 (unsigned)fsinfo
.sector_size_info
.out
.phys_bytes_per_sector_perf
);
1783 d_printf("\tfs_effective_phys_bytes_per_sector_atomic: %u\n",
1784 (unsigned)fsinfo
.sector_size_info
.out
.fs_effective_phys_bytes_per_sector_atomic
);
1785 d_printf("\tflags: 0x%x\n",
1786 (unsigned)fsinfo
.sector_size_info
.out
.flags
);
1787 d_printf("\tbyte_off_sector_align: %u\n",
1788 (unsigned)fsinfo
.sector_size_info
.out
.byte_off_sector_align
);
1789 d_printf("\tbyte_off_partition_align: %u\n",
1790 (unsigned)fsinfo
.sector_size_info
.out
.byte_off_partition_align
);
1792 case RAW_QFS_GENERIC
:
1793 d_printf("\twrong level returned\n");
1800 /****************************************************************************
1801 show as much information as possible about a file
1802 ****************************************************************************/
1803 static int cmd_allinfo(struct smbclient_context
*ctx
, const char **args
)
1806 union smb_fileinfo finfo
;
1811 d_printf("allinfo <filename>\n");
1814 fname
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
1816 /* first a ALL_INFO QPATHINFO */
1817 finfo
.generic
.level
= RAW_FILEINFO_ALL_INFO
;
1818 finfo
.generic
.in
.file
.path
= fname
;
1819 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1820 if (!NT_STATUS_IS_OK(status
)) {
1821 d_printf("%s - %s\n", fname
, nt_errstr(status
));
1825 d_printf("\tcreate_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.create_time
));
1826 d_printf("\taccess_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.access_time
));
1827 d_printf("\twrite_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.write_time
));
1828 d_printf("\tchange_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.change_time
));
1829 d_printf("\tattrib: 0x%x\n", finfo
.all_info
.out
.attrib
);
1830 d_printf("\talloc_size: %lu\n", (unsigned long)finfo
.all_info
.out
.alloc_size
);
1831 d_printf("\tsize: %lu\n", (unsigned long)finfo
.all_info
.out
.size
);
1832 d_printf("\tnlink: %u\n", finfo
.all_info
.out
.nlink
);
1833 d_printf("\tdelete_pending: %u\n", finfo
.all_info
.out
.delete_pending
);
1834 d_printf("\tdirectory: %u\n", finfo
.all_info
.out
.directory
);
1835 d_printf("\tea_size: %u\n", finfo
.all_info
.out
.ea_size
);
1836 d_printf("\tfname: '%s'\n", finfo
.all_info
.out
.fname
.s
);
1838 /* 8.3 name if any */
1839 finfo
.generic
.level
= RAW_FILEINFO_ALT_NAME_INFO
;
1840 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1841 if (NT_STATUS_IS_OK(status
)) {
1842 d_printf("\talt_name: %s\n", finfo
.alt_name_info
.out
.fname
.s
);
1845 /* file_id if available */
1846 finfo
.generic
.level
= RAW_FILEINFO_INTERNAL_INFORMATION
;
1847 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1848 if (NT_STATUS_IS_OK(status
)) {
1849 d_printf("\tfile_id %.0f\n",
1850 (double)finfo
.internal_information
.out
.file_id
);
1853 /* the EAs, if any */
1854 finfo
.generic
.level
= RAW_FILEINFO_ALL_EAS
;
1855 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1856 if (NT_STATUS_IS_OK(status
)) {
1858 for (i
=0;i
<finfo
.all_eas
.out
.num_eas
;i
++) {
1859 d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i
,
1860 finfo
.all_eas
.out
.eas
[i
].flags
,
1861 (int)finfo
.all_eas
.out
.eas
[i
].value
.length
,
1862 finfo
.all_eas
.out
.eas
[i
].name
.s
);
1866 /* streams, if available */
1867 finfo
.generic
.level
= RAW_FILEINFO_STREAM_INFO
;
1868 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1869 if (NT_STATUS_IS_OK(status
)) {
1871 for (i
=0;i
<finfo
.stream_info
.out
.num_streams
;i
++) {
1872 d_printf("\tstream %d:\n", i
);
1873 d_printf("\t\tsize %ld\n",
1874 (long)finfo
.stream_info
.out
.streams
[i
].size
);
1875 d_printf("\t\talloc size %ld\n",
1876 (long)finfo
.stream_info
.out
.streams
[i
].alloc_size
);
1877 d_printf("\t\tname %s\n", finfo
.stream_info
.out
.streams
[i
].stream_name
.s
);
1881 /* dev/inode if available */
1882 finfo
.generic
.level
= RAW_FILEINFO_COMPRESSION_INFORMATION
;
1883 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1884 if (NT_STATUS_IS_OK(status
)) {
1885 d_printf("\tcompressed size %ld\n", (long)finfo
.compression_info
.out
.compressed_size
);
1886 d_printf("\tformat %ld\n", (long)finfo
.compression_info
.out
.format
);
1887 d_printf("\tunit_shift %ld\n", (long)finfo
.compression_info
.out
.unit_shift
);
1888 d_printf("\tchunk_shift %ld\n", (long)finfo
.compression_info
.out
.chunk_shift
);
1889 d_printf("\tcluster_shift %ld\n", (long)finfo
.compression_info
.out
.cluster_shift
);
1892 /* shadow copies if available */
1893 fnum
= smbcli_open(ctx
->cli
->tree
, fname
, O_RDONLY
, DENY_NONE
);
1895 struct smb_shadow_copy info
;
1897 info
.in
.file
.fnum
= fnum
;
1898 info
.in
.max_data
= ~0;
1899 status
= smb_raw_shadow_data(ctx
->cli
->tree
, ctx
, &info
);
1900 if (NT_STATUS_IS_OK(status
)) {
1901 d_printf("\tshadow_copy: %u volumes %u names\n",
1902 info
.out
.num_volumes
, info
.out
.num_names
);
1903 for (i
=0;i
<info
.out
.num_names
;i
++) {
1904 d_printf("\t%s\n", info
.out
.names
[i
]);
1905 finfo
.generic
.level
= RAW_FILEINFO_ALL_INFO
;
1906 finfo
.generic
.in
.file
.path
= talloc_asprintf(ctx
, "%s%s",
1907 info
.out
.names
[i
], fname
);
1908 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1909 if (NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_PATH_NOT_FOUND
) ||
1910 NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
1913 if (!NT_STATUS_IS_OK(status
)) {
1914 d_printf("%s - %s\n", finfo
.generic
.in
.file
.path
,
1919 d_printf("\t\tcreate_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.create_time
));
1920 d_printf("\t\twrite_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.write_time
));
1921 d_printf("\t\tchange_time: %s\n", nt_time_string(ctx
, finfo
.all_info
.out
.change_time
));
1922 d_printf("\t\tsize: %lu\n", (unsigned long)finfo
.all_info
.out
.size
);
1931 /****************************************************************************
1933 ****************************************************************************/
1934 static int cmd_eainfo(struct smbclient_context
*ctx
, const char **args
)
1937 union smb_fileinfo finfo
;
1942 d_printf("eainfo <filename>\n");
1945 fname
= talloc_strdup(ctx
, args
[1]);
1947 finfo
.generic
.level
= RAW_FILEINFO_ALL_EAS
;
1948 finfo
.generic
.in
.file
.path
= fname
;
1949 status
= smb_raw_pathinfo(ctx
->cli
->tree
, ctx
, &finfo
);
1951 if (!NT_STATUS_IS_OK(status
)) {
1952 d_printf("RAW_FILEINFO_ALL_EAS - %s\n", nt_errstr(status
));
1956 d_printf("%s has %d EAs\n", fname
, finfo
.all_eas
.out
.num_eas
);
1958 for (i
=0;i
<finfo
.all_eas
.out
.num_eas
;i
++) {
1959 d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i
,
1960 finfo
.all_eas
.out
.eas
[i
].flags
,
1961 (int)finfo
.all_eas
.out
.eas
[i
].value
.length
,
1962 finfo
.all_eas
.out
.eas
[i
].name
.s
);
1965 finfo
.all_eas
.out
.eas
[i
].value
.data
,
1966 finfo
.all_eas
.out
.eas
[i
].value
.length
);
1973 /****************************************************************************
1974 show any ACL on a file
1975 ****************************************************************************/
1976 static int cmd_acl(struct smbclient_context
*ctx
, const char **args
)
1979 union smb_fileinfo query
;
1984 d_printf("acl <filename>\n");
1987 fname
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
1989 fnum
= smbcli_nt_create_full(ctx
->cli
->tree
, fname
, 0,
1990 SEC_STD_READ_CONTROL
,
1992 NTCREATEX_SHARE_ACCESS_DELETE
|
1993 NTCREATEX_SHARE_ACCESS_READ
|
1994 NTCREATEX_SHARE_ACCESS_WRITE
,
1995 NTCREATEX_DISP_OPEN
,
1998 d_printf("%s - %s\n", fname
, smbcli_errstr(ctx
->cli
->tree
));
2002 query
.query_secdesc
.level
= RAW_FILEINFO_SEC_DESC
;
2003 query
.query_secdesc
.in
.file
.fnum
= fnum
;
2004 query
.query_secdesc
.in
.secinfo_flags
= 0x7;
2006 status
= smb_raw_fileinfo(ctx
->cli
->tree
, ctx
, &query
);
2007 if (!NT_STATUS_IS_OK(status
)) {
2008 d_printf("%s - %s\n", fname
, nt_errstr(status
));
2012 NDR_PRINT_DEBUG(security_descriptor
, query
.query_secdesc
.out
.sd
);
2017 /****************************************************************************
2018 lookup a name or sid
2019 ****************************************************************************/
2020 static int cmd_lookup(struct smbclient_context
*ctx
, const char **args
)
2023 struct dom_sid
*sid
;
2026 d_printf("lookup <sid|name>\n");
2030 sid
= dom_sid_parse_talloc(ctx
, args
[1]);
2033 status
= smblsa_lookup_name(ctx
->cli
, args
[1], ctx
, &sidstr
);
2034 if (!NT_STATUS_IS_OK(status
)) {
2035 d_printf("lsa_LookupNames - %s\n", nt_errstr(status
));
2039 d_printf("%s\n", sidstr
);
2042 status
= smblsa_lookup_sid(ctx
->cli
, args
[1], ctx
, &name
);
2043 if (!NT_STATUS_IS_OK(status
)) {
2044 d_printf("lsa_LookupSids - %s\n", nt_errstr(status
));
2048 d_printf("%s\n", name
);
2054 /****************************************************************************
2055 show privileges for a user
2056 ****************************************************************************/
2057 static int cmd_privileges(struct smbclient_context
*ctx
, const char **args
)
2060 struct dom_sid
*sid
;
2061 struct lsa_RightSet rights
;
2065 d_printf("privileges <sid|name>\n");
2069 sid
= dom_sid_parse_talloc(ctx
, args
[1]);
2071 const char *sid_str
;
2072 status
= smblsa_lookup_name(ctx
->cli
, args
[1], ctx
, &sid_str
);
2073 if (!NT_STATUS_IS_OK(status
)) {
2074 d_printf("lsa_LookupNames - %s\n", nt_errstr(status
));
2077 sid
= dom_sid_parse_talloc(ctx
, sid_str
);
2080 status
= smblsa_sid_privileges(ctx
->cli
, sid
, ctx
, &rights
);
2081 if (!NT_STATUS_IS_OK(status
)) {
2082 d_printf("lsa_EnumAccountRights - %s\n", nt_errstr(status
));
2086 for (i
=0;i
<rights
.count
;i
++) {
2087 d_printf("\t%s\n", rights
.names
[i
].string
);
2094 /****************************************************************************
2095 add privileges for a user
2096 ****************************************************************************/
2097 static int cmd_addprivileges(struct smbclient_context
*ctx
, const char **args
)
2100 struct dom_sid
*sid
;
2101 struct lsa_RightSet rights
;
2105 d_printf("addprivileges <sid|name> <privilege...>\n");
2109 sid
= dom_sid_parse_talloc(ctx
, args
[1]);
2111 const char *sid_str
;
2112 status
= smblsa_lookup_name(ctx
->cli
, args
[1], ctx
, &sid_str
);
2113 if (!NT_STATUS_IS_OK(status
)) {
2114 d_printf("lsa_LookupNames - %s\n", nt_errstr(status
));
2117 sid
= dom_sid_parse_talloc(ctx
, sid_str
);
2120 ZERO_STRUCT(rights
);
2121 for (i
= 2; args
[i
]; i
++) {
2122 rights
.names
= talloc_realloc(ctx
, rights
.names
,
2123 struct lsa_StringLarge
, rights
.count
+1);
2124 rights
.names
[rights
.count
].string
= talloc_strdup(ctx
, args
[i
]);
2129 status
= smblsa_sid_add_privileges(ctx
->cli
, sid
, ctx
, &rights
);
2130 if (!NT_STATUS_IS_OK(status
)) {
2131 d_printf("lsa_AddAccountRights - %s\n", nt_errstr(status
));
2138 /****************************************************************************
2139 delete privileges for a user
2140 ****************************************************************************/
2141 static int cmd_delprivileges(struct smbclient_context
*ctx
, const char **args
)
2144 struct dom_sid
*sid
;
2145 struct lsa_RightSet rights
;
2149 d_printf("delprivileges <sid|name> <privilege...>\n");
2153 sid
= dom_sid_parse_talloc(ctx
, args
[1]);
2155 const char *sid_str
;
2156 status
= smblsa_lookup_name(ctx
->cli
, args
[1], ctx
, &sid_str
);
2157 if (!NT_STATUS_IS_OK(status
)) {
2158 d_printf("lsa_LookupNames - %s\n", nt_errstr(status
));
2161 sid
= dom_sid_parse_talloc(ctx
, sid_str
);
2164 ZERO_STRUCT(rights
);
2165 for (i
= 2; args
[i
]; i
++) {
2166 rights
.names
= talloc_realloc(ctx
, rights
.names
,
2167 struct lsa_StringLarge
, rights
.count
+1);
2168 rights
.names
[rights
.count
].string
= talloc_strdup(ctx
, args
[i
]);
2173 status
= smblsa_sid_del_privileges(ctx
->cli
, sid
, ctx
, &rights
);
2174 if (!NT_STATUS_IS_OK(status
)) {
2175 d_printf("lsa_RemoveAccountRights - %s\n", nt_errstr(status
));
2183 /****************************************************************************
2185 ****************************************************************************/
2186 static int cmd_open(struct smbclient_context
*ctx
, const char **args
)
2191 TALLOC_CTX
*tmp_ctx
;
2194 d_printf("open <filename>\n");
2197 tmp_ctx
= talloc_new(ctx
);
2199 filename
= talloc_asprintf(tmp_ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
2201 io
.generic
.level
= RAW_OPEN_NTCREATEX
;
2202 io
.ntcreatex
.in
.root_fid
.fnum
= 0;
2203 io
.ntcreatex
.in
.flags
= 0;
2204 io
.ntcreatex
.in
.access_mask
= SEC_RIGHTS_FILE_ALL
;
2205 io
.ntcreatex
.in
.create_options
= 0;
2206 io
.ntcreatex
.in
.file_attr
= FILE_ATTRIBUTE_NORMAL
;
2207 io
.ntcreatex
.in
.share_access
= NTCREATEX_SHARE_ACCESS_READ
;
2208 io
.ntcreatex
.in
.alloc_size
= 0;
2209 io
.ntcreatex
.in
.open_disposition
= NTCREATEX_DISP_OPEN_IF
;
2210 io
.ntcreatex
.in
.impersonation
= NTCREATEX_IMPERSONATION_ANONYMOUS
;
2211 io
.ntcreatex
.in
.security_flags
= 0;
2212 io
.ntcreatex
.in
.fname
= filename
;
2214 status
= smb_raw_open(ctx
->cli
->tree
, tmp_ctx
, &io
);
2215 talloc_free(tmp_ctx
);
2217 if (NT_STATUS_IS_OK(status
)) {
2218 d_printf("Opened file with fnum %u\n", (unsigned)io
.ntcreatex
.out
.file
.fnum
);
2220 d_printf("Opened failed: %s\n", nt_errstr(status
));
2226 /****************************************************************************
2228 ****************************************************************************/
2229 static int cmd_close(struct smbclient_context
*ctx
, const char **args
)
2236 d_printf("close <fnum>\n");
2240 fnum
= atoi(args
[1]);
2243 io
.generic
.level
= RAW_CLOSE_CLOSE
;
2244 io
.close
.in
.file
.fnum
= fnum
;
2246 status
= smb_raw_close(ctx
->cli
->tree
, &io
);
2248 if (NT_STATUS_IS_OK(status
)) {
2249 d_printf("Closed file OK\n");
2251 d_printf("Close failed: %s\n", nt_errstr(status
));
2258 /****************************************************************************
2260 ****************************************************************************/
2261 static int cmd_rmdir(struct smbclient_context
*ctx
, const char **args
)
2266 d_printf("rmdir <dirname>\n");
2269 mask
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
2271 if (NT_STATUS_IS_ERR(smbcli_rmdir(ctx
->cli
->tree
, mask
))) {
2272 d_printf("%s removing remote directory file %s\n",
2273 smbcli_errstr(ctx
->cli
->tree
),mask
);
2279 /****************************************************************************
2281 ****************************************************************************/
2282 static int cmd_link(struct smbclient_context
*ctx
, const char **args
)
2286 if (!(ctx
->cli
->transport
->negotiate
.capabilities
& CAP_UNIX
)) {
2287 d_printf("Server doesn't support UNIX CIFS calls.\n");
2292 if (!args
[1] || !args
[2]) {
2293 d_printf("link <src> <dest>\n");
2297 src
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
2298 dest
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[2]);
2300 if (NT_STATUS_IS_ERR(smbcli_unix_hardlink(ctx
->cli
->tree
, src
, dest
))) {
2301 d_printf("%s linking files (%s -> %s)\n", smbcli_errstr(ctx
->cli
->tree
), src
, dest
);
2308 /****************************************************************************
2310 ****************************************************************************/
2312 static int cmd_symlink(struct smbclient_context
*ctx
, const char **args
)
2316 if (!(ctx
->cli
->transport
->negotiate
.capabilities
& CAP_UNIX
)) {
2317 d_printf("Server doesn't support UNIX CIFS calls.\n");
2321 if (!args
[1] || !args
[2]) {
2322 d_printf("symlink <src> <dest>\n");
2326 src
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
2327 dest
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[2]);
2329 if (NT_STATUS_IS_ERR(smbcli_unix_symlink(ctx
->cli
->tree
, src
, dest
))) {
2330 d_printf("%s symlinking files (%s -> %s)\n",
2331 smbcli_errstr(ctx
->cli
->tree
), src
, dest
);
2338 /****************************************************************************
2340 ****************************************************************************/
2342 static int cmd_chmod(struct smbclient_context
*ctx
, const char **args
)
2347 if (!(ctx
->cli
->transport
->negotiate
.capabilities
& CAP_UNIX
)) {
2348 d_printf("Server doesn't support UNIX CIFS calls.\n");
2352 if (!args
[1] || !args
[2]) {
2353 d_printf("chmod mode file\n");
2357 src
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[2]);
2359 mode
= (mode_t
)strtol(args
[1], NULL
, 8);
2361 if (NT_STATUS_IS_ERR(smbcli_unix_chmod(ctx
->cli
->tree
, src
, mode
))) {
2362 d_printf("%s chmod file %s 0%o\n",
2363 smbcli_errstr(ctx
->cli
->tree
), src
, (unsigned)mode
);
2370 /****************************************************************************
2372 ****************************************************************************/
2374 static int cmd_chown(struct smbclient_context
*ctx
, const char **args
)
2380 if (!(ctx
->cli
->transport
->negotiate
.capabilities
& CAP_UNIX
)) {
2381 d_printf("Server doesn't support UNIX CIFS calls.\n");
2385 if (!args
[1] || !args
[2] || !args
[3]) {
2386 d_printf("chown uid gid file\n");
2390 uid
= (uid_t
)atoi(args
[1]);
2391 gid
= (gid_t
)atoi(args
[2]);
2392 src
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[3]);
2394 if (NT_STATUS_IS_ERR(smbcli_unix_chown(ctx
->cli
->tree
, src
, uid
, gid
))) {
2395 d_printf("%s chown file %s uid=%d, gid=%d\n",
2396 smbcli_errstr(ctx
->cli
->tree
), src
, (int)uid
, (int)gid
);
2403 /****************************************************************************
2405 ****************************************************************************/
2406 static int cmd_rename(struct smbclient_context
*ctx
, const char **args
)
2410 if (!args
[1] || !args
[2]) {
2411 d_printf("rename <src> <dest>\n");
2415 src
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[1]);
2416 dest
= talloc_asprintf(ctx
, "%s%s", ctx
->remote_cur_dir
, args
[2]);
2418 if (NT_STATUS_IS_ERR(smbcli_rename(ctx
->cli
->tree
, src
, dest
))) {
2419 d_printf("%s renaming files\n",smbcli_errstr(ctx
->cli
->tree
));
2427 /****************************************************************************
2428 toggle the prompt flag
2429 ****************************************************************************/
2430 static int cmd_prompt(struct smbclient_context
*ctx
, const char **args
)
2432 ctx
->prompt
= !ctx
->prompt
;
2433 DEBUG(2,("prompting is now %s\n",ctx
->prompt
?"on":"off"));
2439 /****************************************************************************
2440 set the newer than time
2441 ****************************************************************************/
2442 static int cmd_newer(struct smbclient_context
*ctx
, const char **args
)
2446 if (args
[1] && (stat(args
[1],&sbuf
) == 0)) {
2447 ctx
->newer_than
= sbuf
.st_mtime
;
2448 DEBUG(1,("Getting files newer than %s",
2449 asctime(localtime(&ctx
->newer_than
))));
2451 ctx
->newer_than
= 0;
2454 if (args
[1] && ctx
->newer_than
== 0) {
2455 d_printf("Error setting newer-than time\n");
2462 /****************************************************************************
2463 set the archive level
2464 ****************************************************************************/
2465 static int cmd_archive(struct smbclient_context
*ctx
, const char **args
)
2468 ctx
->archive_level
= atoi(args
[1]);
2470 d_printf("Archive level is %d\n",ctx
->archive_level
);
2475 /****************************************************************************
2476 toggle the lowercaseflag
2477 ****************************************************************************/
2478 static int cmd_lowercase(struct smbclient_context
*ctx
, const char **args
)
2480 ctx
->lowercase
= !ctx
->lowercase
;
2481 DEBUG(2,("filename lowercasing is now %s\n",ctx
->lowercase
?"on":"off"));
2489 /****************************************************************************
2490 toggle the recurse flag
2491 ****************************************************************************/
2492 static int cmd_recurse(struct smbclient_context
*ctx
, const char **args
)
2494 ctx
->recurse
= !ctx
->recurse
;
2495 DEBUG(2,("directory recursion is now %s\n",ctx
->recurse
?"on":"off"));
2500 /****************************************************************************
2501 toggle the translate flag
2502 ****************************************************************************/
2503 static int cmd_translate(struct smbclient_context
*ctx
, const char **args
)
2505 ctx
->translation
= !ctx
->translation
;
2506 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
2507 ctx
->translation
?"on":"off"));
2513 /****************************************************************************
2514 do a printmode command
2515 ****************************************************************************/
2516 static int cmd_printmode(struct smbclient_context
*ctx
, const char **args
)
2519 if (strequal(args
[1],"text")) {
2522 if (strequal(args
[1],"graphics"))
2525 ctx
->printmode
= atoi(args
[1]);
2529 switch(ctx
->printmode
)
2532 DEBUG(2,("the printmode is now text\n"));
2535 DEBUG(2,("the printmode is now graphics\n"));
2538 DEBUG(2,("the printmode is now %d\n", ctx
->printmode
));
2545 /****************************************************************************
2547 ****************************************************************************/
2548 static int cmd_lcd(struct smbclient_context
*ctx
, const char **args
)
2555 ret
= chdir(args
[1]);
2557 d_printf("failed to chdir to dir '%s': %s\n",
2558 args
[1], strerror(errno
));
2563 DEBUG(2,("the local directory is now %s\n",getcwd(d
, PATH_MAX
)));
2568 /****************************************************************************
2570 ****************************************************************************/
2571 static int cmd_history(struct smbclient_context
*ctx
, const char **args
)
2573 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
2577 hlist
= history_list();
2579 for (i
= 0; hlist
&& hlist
[i
]; i
++) {
2580 DEBUG(0, ("%d: %s\n", i
, hlist
[i
]->line
));
2583 DEBUG(0,("no history without readline support\n"));
2589 /****************************************************************************
2590 get a file restarting at end of local file
2591 ****************************************************************************/
2592 static int cmd_reget(struct smbclient_context
*ctx
, const char **args
)
2598 d_printf("reget <filename>\n");
2601 remote_name
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, args
[1]);
2602 dos_clean_name(remote_name
);
2605 local_name
= talloc_strdup(ctx
, args
[2]);
2607 local_name
= talloc_strdup(ctx
, args
[1]);
2609 return do_get(ctx
, remote_name
, local_name
, true);
2612 /****************************************************************************
2613 put a file restarting at end of local file
2614 ****************************************************************************/
2615 static int cmd_reput(struct smbclient_context
*ctx
, const char **args
)
2621 d_printf("reput <filename>\n");
2624 local_name
= talloc_asprintf(ctx
, "%s\\%s", ctx
->remote_cur_dir
, args
[1]);
2626 if (!file_exist(local_name
)) {
2627 d_printf("%s does not exist\n", local_name
);
2632 remote_name
= talloc_strdup(ctx
, args
[2]);
2634 remote_name
= talloc_strdup(ctx
, args
[1]);
2636 dos_clean_name(remote_name
);
2638 return do_put(ctx
, remote_name
, local_name
, true);
2643 return a string representing a share type
2645 static const char *share_type_str(uint32_t type
)
2647 switch (type
& 0xF) {
2648 case STYPE_DISKTREE
:
2663 display a list of shares from a level 1 share enum
2665 static void display_share_result(struct srvsvc_NetShareCtr1
*ctr1
)
2669 for (i
=0;i
<ctr1
->count
;i
++) {
2670 struct srvsvc_NetShareInfo1
*info
= ctr1
->array
+i
;
2672 printf("\t%-15s %-10.10s %s\n",
2674 share_type_str(info
->type
),
2681 /****************************************************************************
2682 try and browse available shares on a host
2683 ****************************************************************************/
2684 static bool browse_host(struct loadparm_context
*lp_ctx
,
2685 struct tevent_context
*ev_ctx
,
2686 const char *query_host
)
2688 struct dcerpc_pipe
*p
;
2691 struct srvsvc_NetShareEnumAll r
;
2692 struct srvsvc_NetShareInfoCtr info_ctr
;
2693 uint32_t resume_handle
= 0;
2694 TALLOC_CTX
*mem_ctx
= talloc_init("browse_host");
2695 struct srvsvc_NetShareCtr1 ctr1
;
2696 uint32_t totalentries
= 0;
2697 struct cli_credentials
*creds
= samba_cmdline_get_creds();
2699 binding
= talloc_asprintf(mem_ctx
, "ncacn_np:%s", query_host
);
2701 status
= dcerpc_pipe_connect(mem_ctx
, &p
, binding
,
2706 if (!NT_STATUS_IS_OK(status
)) {
2707 d_printf("Failed to connect to %s - %s\n",
2708 binding
, nt_errstr(status
));
2709 talloc_free(mem_ctx
);
2714 info_ctr
.ctr
.ctr1
= &ctr1
;
2716 r
.in
.server_unc
= talloc_asprintf(mem_ctx
,"\\\\%s",dcerpc_server_name(p
));
2717 r
.in
.info_ctr
= &info_ctr
;
2718 r
.in
.max_buffer
= ~0;
2719 r
.in
.resume_handle
= &resume_handle
;
2720 r
.out
.resume_handle
= &resume_handle
;
2721 r
.out
.totalentries
= &totalentries
;
2722 r
.out
.info_ctr
= &info_ctr
;
2724 d_printf("\n\tSharename Type Comment\n");
2725 d_printf("\t--------- ---- -------\n");
2729 status
= dcerpc_srvsvc_NetShareEnumAll_r(p
->binding_handle
, mem_ctx
, &r
);
2731 if (NT_STATUS_IS_OK(status
) &&
2732 (W_ERROR_EQUAL(r
.out
.result
, WERR_MORE_DATA
) ||
2733 W_ERROR_IS_OK(r
.out
.result
)) &&
2734 r
.out
.info_ctr
->ctr
.ctr1
) {
2735 display_share_result(r
.out
.info_ctr
->ctr
.ctr1
);
2736 resume_handle
+= r
.out
.info_ctr
->ctr
.ctr1
->count
;
2738 } while (NT_STATUS_IS_OK(status
) && W_ERROR_EQUAL(r
.out
.result
, WERR_MORE_DATA
));
2740 talloc_free(mem_ctx
);
2742 if (!NT_STATUS_IS_OK(status
) || !W_ERROR_IS_OK(r
.out
.result
)) {
2743 d_printf("Failed NetShareEnumAll %s - %s/%s\n",
2744 binding
, nt_errstr(status
), win_errstr(r
.out
.result
));
2751 /****************************************************************************
2752 try and browse available connections on a host
2753 ****************************************************************************/
2754 static bool list_servers(const char *wk_grp
)
2756 d_printf("REWRITE: list servers not implemented\n");
2760 /* Some constants for completing filename arguments */
2762 #define COMPL_NONE 0 /* No completions */
2763 #define COMPL_REMOTE 1 /* Complete remote filename */
2764 #define COMPL_LOCAL 2 /* Complete local filename */
2766 static int cmd_help(struct smbclient_context
*ctx
, const char **args
);
2768 /* This defines the commands supported by this client.
2769 * NOTE: The "!" must be the last one in the list because it's fn pointer
2770 * field is NULL, and NULL in that field is used in process_tok()
2771 * (below) to indicate the end of the list. crh
2776 int (*fn
)(struct smbclient_context
*ctx
, const char **args
);
2777 const char *description
;
2778 char compl_args
[2]; /* Completion argument info */
2781 {"?",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
2782 {"addprivileges",cmd_addprivileges
,"<sid|name> <privilege...> add privileges for a user",{COMPL_NONE
,COMPL_NONE
}},
2783 {"altname",cmd_altname
,"<file> show alt name",{COMPL_NONE
,COMPL_NONE
}},
2784 {"acl",cmd_acl
,"<file> show file ACL",{COMPL_NONE
,COMPL_NONE
}},
2785 {"allinfo",cmd_allinfo
,"<file> show all possible info about a file",{COMPL_NONE
,COMPL_NONE
}},
2786 {"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
}},
2787 {"cancel",cmd_rewrite
,"<jobid> cancel a print queue entry",{COMPL_NONE
,COMPL_NONE
}},
2788 {"cd",cmd_cd
,"[directory] change/report the remote directory",{COMPL_REMOTE
,COMPL_NONE
}},
2789 {"chmod",cmd_chmod
,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE
,COMPL_REMOTE
}},
2790 {"chown",cmd_chown
,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE
,COMPL_REMOTE
}},
2791 {"del",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
2792 {"delprivileges",cmd_delprivileges
,"<sid|name> <privilege...> remove privileges for a user",{COMPL_NONE
,COMPL_NONE
}},
2793 {"deltree",cmd_deltree
,"<dir> delete a whole directory tree",{COMPL_REMOTE
,COMPL_NONE
}},
2794 {"dir",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
2795 {"du",cmd_du
,"<mask> computes the total size of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
2796 {"eainfo",cmd_eainfo
,"<file> show EA contents for a file",{COMPL_NONE
,COMPL_NONE
}},
2797 {"exit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
2798 {"fsinfo",cmd_fsinfo
,"query file system info",{COMPL_NONE
,COMPL_NONE
}},
2799 {"get",cmd_get
,"<remote name> [local name] get a file",{COMPL_REMOTE
,COMPL_LOCAL
}},
2800 {"help",cmd_help
,"[command] give help on a command",{COMPL_NONE
,COMPL_NONE
}},
2801 {"history",cmd_history
,"displays the command history",{COMPL_NONE
,COMPL_NONE
}},
2802 {"lcd",cmd_lcd
,"[directory] change/report the local current working directory",{COMPL_LOCAL
,COMPL_NONE
}},
2803 {"link",cmd_link
,"<src> <dest> create a UNIX hard link",{COMPL_REMOTE
,COMPL_REMOTE
}},
2804 {"lookup",cmd_lookup
,"<sid|name> show SID for name or name for SID",{COMPL_NONE
,COMPL_NONE
}},
2805 {"lowercase",cmd_lowercase
,"toggle lowercasing of filenames for get",{COMPL_NONE
,COMPL_NONE
}},
2806 {"ls",cmd_dir
,"<mask> list the contents of the current directory",{COMPL_REMOTE
,COMPL_NONE
}},
2807 {"mask",cmd_select
,"<mask> mask all filenames against this",{COMPL_REMOTE
,COMPL_NONE
}},
2808 {"md",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
2809 {"mget",cmd_mget
,"<mask> get all the matching files",{COMPL_REMOTE
,COMPL_NONE
}},
2810 {"mkdir",cmd_mkdir
,"<directory> make a directory",{COMPL_NONE
,COMPL_NONE
}},
2811 {"more",cmd_more
,"<remote name> view a remote file with your pager",{COMPL_REMOTE
,COMPL_NONE
}},
2812 {"mput",cmd_mput
,"<mask> put all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
2813 {"newer",cmd_newer
,"<file> only mget files newer than the specified local file",{COMPL_LOCAL
,COMPL_NONE
}},
2814 {"open",cmd_open
,"<mask> open a file",{COMPL_REMOTE
,COMPL_NONE
}},
2815 {"close",cmd_close
,"<fnum> close a file",{COMPL_NONE
,COMPL_NONE
}},
2816 {"privileges",cmd_privileges
,"<user> show privileges for a user",{COMPL_NONE
,COMPL_NONE
}},
2817 {"print",cmd_print
,"<file name> print a file",{COMPL_NONE
,COMPL_NONE
}},
2818 {"printmode",cmd_printmode
,"<graphics or text> set the print mode",{COMPL_NONE
,COMPL_NONE
}},
2819 {"prompt",cmd_prompt
,"toggle prompting for filenames for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
2820 {"put",cmd_put
,"<local name> [remote name] put a file",{COMPL_LOCAL
,COMPL_REMOTE
}},
2821 {"pwd",cmd_pwd
,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE
,COMPL_NONE
}},
2822 {"q",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
2823 {"queue",cmd_rewrite
,"show the print queue",{COMPL_NONE
,COMPL_NONE
}},
2824 {"quit",cmd_quit
,"logoff the server",{COMPL_NONE
,COMPL_NONE
}},
2825 {"rd",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
2826 {"recurse",cmd_recurse
,"toggle directory recursion for mget and mput",{COMPL_NONE
,COMPL_NONE
}},
2827 {"reget",cmd_reget
,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE
,COMPL_LOCAL
}},
2828 {"rename",cmd_rename
,"<src> <dest> rename some files",{COMPL_REMOTE
,COMPL_REMOTE
}},
2829 {"reput",cmd_reput
,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL
,COMPL_REMOTE
}},
2830 {"rm",cmd_del
,"<mask> delete all matching files",{COMPL_REMOTE
,COMPL_NONE
}},
2831 {"rmdir",cmd_rmdir
,"<directory> remove a directory",{COMPL_NONE
,COMPL_NONE
}},
2832 {"symlink",cmd_symlink
,"<src> <dest> create a UNIX symlink",{COMPL_REMOTE
,COMPL_REMOTE
}},
2833 {"translate",cmd_translate
,"toggle text translation for printing",{COMPL_NONE
,COMPL_NONE
}},
2835 /* Yes, this must be here, see crh's comment above. */
2836 {"!",NULL
,"run a shell command on the local system",{COMPL_NONE
,COMPL_NONE
}},
2837 {NULL
,NULL
,NULL
,{COMPL_NONE
,COMPL_NONE
}}
2841 /*******************************************************************
2842 lookup a command string in the list of commands, including
2844 ******************************************************************/
2845 static int process_tok(const char *tok
)
2847 size_t i
= 0, matches
= 0;
2849 size_t tok_len
= strlen(tok
);
2851 while (commands
[i
].fn
!= NULL
) {
2852 if (strequal(commands
[i
].name
,tok
)) {
2856 } else if (strncasecmp(commands
[i
].name
, tok
, tok_len
) == 0) {
2865 else if (matches
== 1)
2871 /****************************************************************************
2873 ****************************************************************************/
2874 static int cmd_help(struct smbclient_context
*ctx
, const char **args
)
2879 if ((i
= process_tok(args
[1])) >= 0)
2880 d_printf("HELP %s:\n\t%s\n\n",commands
[i
].name
,commands
[i
].description
);
2882 while (commands
[i
].description
) {
2883 for (j
=0; commands
[i
].description
&& (j
<5); j
++) {
2884 d_printf("%-15s",commands
[i
].name
);
2893 static int process_line(struct smbclient_context
*ctx
, const char *cline
);
2894 /****************************************************************************
2895 process a -c command string
2896 ****************************************************************************/
2897 static int process_command_string(struct smbclient_context
*ctx
, const char *cmd
)
2902 lines
= str_list_make(NULL
, cmd
, ";");
2903 for (i
= 0; lines
[i
]; i
++) {
2904 rc
|= process_line(ctx
, lines
[i
]);
2911 #define MAX_COMPLETIONS 100
2919 } completion_remote_t
;
2921 static void completion_remote_filter(struct clilist_file_info
*f
, const char *mask
, void *state
)
2923 completion_remote_t
*info
= (completion_remote_t
*)state
;
2925 if ((info
->count
< MAX_COMPLETIONS
- 1) && (strncmp(info
->text
, f
->name
, info
->len
) == 0) && (!ISDOT(f
->name
)) && (!ISDOTDOT(f
->name
))) {
2926 if ((info
->dirmask
[0] == 0) && !(f
->attrib
& FILE_ATTRIBUTE_DIRECTORY
))
2927 info
->matches
[info
->count
] = strdup(f
->name
);
2931 if (info
->dirmask
[0] != 0)
2932 tmp
= talloc_asprintf(NULL
, "%s/%s", info
->dirmask
, f
->name
);
2934 tmp
= talloc_strdup(NULL
, f
->name
);
2936 if (f
->attrib
& FILE_ATTRIBUTE_DIRECTORY
)
2937 tmp
= talloc_append_string(NULL
, tmp
, "/");
2938 info
->matches
[info
->count
] = tmp
;
2940 if (info
->matches
[info
->count
] == NULL
)
2942 if (f
->attrib
& FILE_ATTRIBUTE_DIRECTORY
)
2943 smb_readline_ca_char(0);
2945 if (info
->count
== 1)
2946 info
->samelen
= strlen(info
->matches
[info
->count
]);
2948 while (strncmp(info
->matches
[info
->count
], info
->matches
[info
->count
-1], info
->samelen
) != 0)
2954 static char **remote_completion(const char *text
, int len
)
2958 completion_remote_t info
;
2965 if (len
>= PATH_MAX
)
2968 info
.matches
= malloc_array_p(char *, MAX_COMPLETIONS
);
2969 if (!info
.matches
) return NULL
;
2970 info
.matches
[0] = NULL
;
2972 for (i
= len
-1; i
>= 0; i
--)
2973 if ((text
[i
] == '/') || (text
[i
] == '\\'))
2975 info
.text
= text
+i
+1;
2976 info
.samelen
= info
.len
= len
-i
-1;
2979 info
.dirmask
= talloc_strndup(NULL
, text
, i
+1);
2980 info
.dirmask
[i
+1] = 0;
2981 ret
= asprintf(&dirmask
, "%s%*s*", rl_ctx
->remote_cur_dir
, i
-1,
2984 ret
= asprintf(&dirmask
, "%s*", rl_ctx
->remote_cur_dir
);
2990 if (smbcli_list(rl_ctx
->cli
->tree
, dirmask
,
2991 FILE_ATTRIBUTE_DIRECTORY
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_HIDDEN
,
2992 completion_remote_filter
, &info
) < 0)
2995 if (info
.count
== 2)
2996 info
.matches
[0] = strdup(info
.matches
[1]);
2998 info
.matches
[0] = malloc_array_p(char, info
.samelen
+1);
2999 if (!info
.matches
[0])
3001 strncpy(info
.matches
[0], info
.matches
[1], info
.samelen
);
3002 info
.matches
[0][info
.samelen
] = 0;
3004 info
.matches
[info
.count
] = NULL
;
3005 return info
.matches
;
3008 for (i
= 0; i
< info
.count
; i
++)
3009 free(info
.matches
[i
]);
3014 static char **completion_fn(const char *text
, int start
, int end
)
3016 smb_readline_ca_char(' ');
3019 const char *buf
, *sp
;
3023 buf
= smb_readline_get_line_buffer();
3027 sp
= strchr(buf
, ' ');
3031 for (i
= 0; commands
[i
].name
; i
++)
3032 if ((strncmp(commands
[i
].name
, text
, sp
- buf
) == 0) && (commands
[i
].name
[sp
- buf
] == 0))
3034 if (commands
[i
].name
== NULL
)
3040 if (sp
== (buf
+ start
))
3041 compl_type
= commands
[i
].compl_args
[0];
3043 compl_type
= commands
[i
].compl_args
[1];
3045 if (compl_type
== COMPL_REMOTE
)
3046 return remote_completion(text
, end
- start
);
3047 else /* fall back to local filename completion */
3051 size_t i
, len
, samelen
= 0, count
=1;
3053 matches
= malloc_array_p(char *, MAX_COMPLETIONS
);
3054 if (!matches
) return NULL
;
3058 for (i
=0;commands
[i
].fn
&& count
< MAX_COMPLETIONS
-1;i
++) {
3059 if (strncmp(text
, commands
[i
].name
, len
) == 0) {
3060 matches
[count
] = strdup(commands
[i
].name
);
3061 if (!matches
[count
])
3064 samelen
= strlen(matches
[count
]);
3066 while (strncmp(matches
[count
], matches
[count
-1], samelen
) != 0)
3073 case 0: /* should never happen */
3077 matches
[0] = strdup(matches
[1]);
3080 matches
[0] = malloc_array_p(char, samelen
+1);
3083 strncpy(matches
[0], matches
[1], samelen
);
3084 matches
[0][samelen
] = 0;
3086 matches
[count
] = NULL
;
3090 for (i
= 0; i
< count
; i
++) {
3098 /****************************************************************************
3099 make sure we swallow keepalives during idle time
3100 ****************************************************************************/
3101 static void readline_callback(void)
3103 static time_t last_t
;
3108 if (t
- last_t
< 5) return;
3112 smbcli_transport_process(rl_ctx
->cli
->transport
);
3114 if (rl_ctx
->cli
->tree
) {
3115 smbcli_chkpath(rl_ctx
->cli
->tree
, "\\");
3119 static int process_line(struct smbclient_context
*ctx
, const char *cline
)
3124 /* and get the first part of the command */
3125 args
= str_list_make_shell(ctx
, cline
, NULL
);
3126 if (!args
|| !args
[0])
3129 if ((i
= process_tok(args
[0])) >= 0) {
3130 const char **a
= discard_const_p(const char *, args
);
3131 i
= commands
[i
].fn(ctx
, a
);
3132 } else if (i
== -2) {
3133 d_printf("%s: command abbreviation ambiguous\n",args
[0]);
3135 d_printf("%s: command not found\n",args
[0]);
3143 /****************************************************************************
3144 process commands on stdin
3145 ****************************************************************************/
3146 static int process_stdin(struct smbclient_context
*ctx
)
3150 /* display a prompt */
3151 char *the_prompt
= talloc_asprintf(ctx
, "smb: %s> ", ctx
->remote_cur_dir
);
3152 char *cline
= smb_readline(the_prompt
, readline_callback
, completion_fn
);
3153 talloc_free(the_prompt
);
3157 /* special case - first char is ! */
3158 if (*cline
== '!') {
3160 ret
= system(cline
+ 1);
3168 rc
|= process_command_string(ctx
, cline
);
3177 /*****************************************************
3178 return a connection to a server
3179 *******************************************************/
3180 static bool do_connect(struct smbclient_context
*ctx
,
3181 struct tevent_context
*ev_ctx
,
3182 struct resolve_context
*resolve_ctx
,
3183 const char *specified_server
, const char **ports
,
3184 const char *specified_share
,
3185 const char *socket_options
,
3186 struct cli_credentials
*cred
,
3187 struct smbcli_options
*options
,
3188 struct smbcli_session_options
*session_options
,
3189 struct gensec_settings
*gensec_settings
)
3192 char *server
, *share
;
3194 rl_ctx
= ctx
; /* Ugly hack */
3196 if (strncmp(specified_share
, "\\\\", 2) == 0 ||
3197 strncmp(specified_share
, "//", 2) == 0) {
3200 ok
= smbcli_parse_unc(specified_share
, ctx
, &server
, &share
);
3202 d_printf("Failed to parse UNC\n");
3207 share
= talloc_strdup(ctx
, specified_share
);
3208 server
= talloc_strdup(ctx
, specified_server
);
3209 if (share
== NULL
|| server
== NULL
) {
3210 d_printf("Failed to allocate memory for server and share\n");
3216 ctx
->remote_cur_dir
= talloc_strdup(ctx
, "\\");
3217 if (ctx
->remote_cur_dir
== NULL
) {
3222 status
= smbcli_full_connection(ctx
, &ctx
->cli
, server
, ports
,
3226 ev_ctx
, options
, session_options
,
3228 if (!NT_STATUS_IS_OK(status
)) {
3229 d_printf("Connection to \\\\%s\\%s failed - %s\n",
3230 server
, share
, nt_errstr(status
));
3238 /****************************************************************************
3240 ****************************************************************************/
3241 static int do_host_query(struct loadparm_context
*lp_ctx
,
3242 struct tevent_context
*ev_ctx
,
3243 const char *query_host
,
3244 const char *workgroup
)
3246 browse_host(lp_ctx
, ev_ctx
, query_host
);
3247 list_servers(workgroup
);
3252 /****************************************************************************
3253 handle a message operation
3254 ****************************************************************************/
3255 static int do_message_op(const char *netbios_name
, const char *desthost
,
3256 const char **destports
, const char *destip
,
3258 struct tevent_context
*ev_ctx
,
3259 struct resolve_context
*resolve_ctx
,
3260 struct smbcli_options
*options
,
3261 const char *socket_options
)
3263 struct nbt_name called
, calling
;
3264 const char *server_name
;
3265 struct smbcli_state
*cli
;
3268 make_nbt_name_client(&calling
, netbios_name
);
3270 nbt_choose_called_name(NULL
, &called
, desthost
, name_type
);
3272 server_name
= destip
? destip
: desthost
;
3274 cli
= smbcli_state_init(NULL
);
3276 d_printf("smbcli_state_init() failed\n");
3280 ok
= smbcli_socket_connect(cli
, server_name
, destports
,
3281 ev_ctx
, resolve_ctx
, options
,
3285 d_printf("Connection to %s failed\n", server_name
);
3289 send_message(cli
, desthost
);
3296 /****************************************************************************
3298 ****************************************************************************/
3299 int main(int argc
, char *argv
[])
3301 const char **const_argv
= discard_const_p(const char *, argv
);
3302 char *base_directory
= NULL
;
3303 const char *dest_ip
= NULL
;
3305 const char *query_host
= NULL
;
3306 bool message
= false;
3307 char *desthost
= NULL
;
3309 const char *service
= NULL
;
3313 int name_type
= 0x20;
3314 TALLOC_CTX
*mem_ctx
;
3315 struct tevent_context
*ev_ctx
;
3316 struct smbclient_context
*ctx
;
3317 const char *cmdstr
= NULL
;
3318 struct smbcli_options smb_options
;
3319 struct smbcli_session_options smb_session_options
;
3320 struct cli_credentials
*creds
= NULL
;
3321 struct loadparm_context
*lp_ctx
= NULL
;
3324 struct poptOption long_options
[] = {
3328 .longName
= "message",
3330 .argInfo
= POPT_ARG_STRING
,
3333 .descrip
= "Send message",
3334 .argDescrip
= "HOST",
3337 .longName
= "ip-address",
3339 .argInfo
= POPT_ARG_STRING
,
3342 .descrip
= "Use this IP to connect to",
3346 .longName
= "stderr",
3348 .argInfo
= POPT_ARG_NONE
,
3351 .descrip
= "Write messages to stderr instead of stdout",
3356 .argInfo
= POPT_ARG_STRING
,
3359 .descrip
= "Get a list of shares available on a host",
3360 .argDescrip
= "HOST",
3363 .longName
= "directory",
3365 .argInfo
= POPT_ARG_STRING
,
3368 .descrip
= "Start from directory",
3369 .argDescrip
= "DIR",
3372 .longName
= "command",
3374 .argInfo
= POPT_ARG_STRING
,
3377 .descrip
= "Execute semicolon separated commands",
3380 .longName
= "send-buffer",
3382 .argInfo
= POPT_ARG_INT
,
3385 .descrip
= "Changes the transmit/send buffer",
3386 .argDescrip
= "BYTES",
3391 .argInfo
= POPT_ARG_INT
,
3394 .descrip
= "Port to connect to",
3395 .argDescrip
= "PORT",
3398 POPT_COMMON_CONNECTION
3399 POPT_COMMON_CREDENTIALS
3405 mem_ctx
= talloc_init("client.c/main");
3407 d_printf("\nclient.c: Not enough memory\n");
3411 ctx
= talloc_zero(mem_ctx
, struct smbclient_context
);
3412 ctx
->io_bufsize
= 64512;
3414 ok
= samba_cmdline_init(mem_ctx
,
3415 SAMBA_CMDLINE_CONFIG_CLIENT
,
3416 false /* require_smbconf */);
3418 DBG_ERR("Failed to init cmdline parser!\n");
3423 pc
= samba_popt_get_context(getprogname(),
3429 DBG_ERR("Failed to setup popt context!\n");
3433 poptSetOtherOptionHelp(pc
, "[OPTIONS] service <password>");
3435 while ((opt
= poptGetNextOpt(pc
)) != -1) {
3438 /* Messages are sent to NetBIOS name type 0x3
3439 * (Messenger Service). Make sure we default
3440 * to port 139 instead of port 445. srl,crh
3443 desthost
= strdup(poptGetOptArg(pc
));
3444 if( 0 == port
) port
= 139;
3448 dest_ip
= poptGetOptArg(pc
);
3451 query_host
= strdup(poptGetOptArg(pc
));
3454 base_directory
= strdup(poptGetOptArg(pc
));
3457 ctx
->io_bufsize
= MAX(1, atoi(poptGetOptArg(pc
)));
3459 case POPT_ERROR_BADOPT
:
3460 fprintf(stderr
, "\nInvalid option %s: %s\n\n",
3461 poptBadOption(pc
, 0), poptStrerror(opt
));
3462 poptPrintUsage(pc
, stderr
, 0);
3469 if(poptPeekArg(pc
)) {
3470 char *s
= strdup(poptGetArg(pc
));
3472 /* Convert any '/' characters in the service name to '\' characters */
3473 string_replace(s
, '/','\\');
3477 if (count_chars(s
,'\\') < 3) {
3478 d_printf("\n%s: Not enough '\\' characters in service\n",s
);
3479 poptPrintUsage(pc
, stderr
, 0);
3484 creds
= samba_cmdline_get_creds();
3485 lp_ctx
= samba_cmdline_get_lp_ctx();
3487 if (poptPeekArg(pc
)) {
3488 cli_credentials_set_password(creds
,
3489 poptGetArg(pc
), CRED_SPECIFIED
);
3492 if (!query_host
&& !service
&& !message
) {
3493 poptPrintUsage(pc
, stderr
, 0);
3497 poptFreeContext(pc
);
3498 samba_cmdline_burn(argc
, argv
);
3500 lpcfg_smbcli_options(lp_ctx
, &smb_options
);
3501 lpcfg_smbcli_session_options(lp_ctx
, &smb_session_options
);
3503 ev_ctx
= s4_event_context_init(ctx
);
3505 DEBUG( 3, ( "Client started (version %s).\n", SAMBA_VERSION_STRING
) );
3507 if (query_host
&& (p
=strchr_m(query_host
,'#'))) {
3510 sscanf(p
, "%x", &name_type
);
3514 rc
= do_host_query(lp_ctx
, ev_ctx
, query_host
,
3515 lpcfg_workgroup(lp_ctx
));
3520 rc
= do_message_op(lpcfg_netbios_name(lp_ctx
), desthost
,
3521 lpcfg_smb_ports(lp_ctx
), dest_ip
,
3523 lpcfg_resolve_context(lp_ctx
),
3525 lpcfg_socket_options(lp_ctx
));
3529 if (!do_connect(ctx
, ev_ctx
, lpcfg_resolve_context(lp_ctx
),
3530 desthost
, lpcfg_smb_ports(lp_ctx
), service
,
3531 lpcfg_socket_options(lp_ctx
),
3533 &smb_options
, &smb_session_options
,
3534 lpcfg_gensec_settings(ctx
, lp_ctx
)))
3537 if (base_directory
) {
3538 do_cd(ctx
, base_directory
);
3539 free(base_directory
);
3543 rc
= process_command_string(ctx
, cmdstr
);
3545 rc
= process_stdin(ctx
);
3549 talloc_free(mem_ctx
);