?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpupdate: Remove the unnecessary url parameter
[Samba.git] / source3 / client / client.c
blobe8faed55dc4af828ee55478f18bc949be2a7bb84
1 /*
2 Unix SMB/CIFS implementation.
3 SMB client
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Simo Sorce 2001-2002
6 Copyright (C) Jelmer Vernooij 2003
7 Copyright (C) Gerald (Jerry) Carter 2004
8 Copyright (C) Jeremy Allison 1994-2007
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "system/filesys.h"
26 #include "popt_common_cmdline.h"
27 #include "rpc_client/cli_pipe.h"
28 #include "client/client_proto.h"
29 #include "client/clitar_proto.h"
30 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
31 #include "../lib/util/select.h"
32 #include "system/readline.h"
33 #include "../libcli/smbreadline/smbreadline.h"
34 #include "../libcli/security/security.h"
35 #include "system/select.h"
36 #include "libsmb/libsmb.h"
37 #include "libsmb/clirap.h"
38 #include "trans2.h"
39 #include "libsmb/nmblib.h"
40 #include "include/ntioctl.h"
41 #include "../libcli/smb/smbXcli_base.h"
42
43 #ifndef REGISTER
44 #define REGISTER 0
45 #endif
46
47 extern int do_smb_browse(void); /* mDNS browsing */
48
49 extern bool override_logfile;
50
51 static int port = 0;
52 static char *service;
53 static char *desthost;
54 static bool grepable = false;
55 static bool quiet = false;
56 static char *cmdstr = NULL;
57 const char *cmd_ptr = NULL;
58
59 static int io_bufsize = 0; /* we use the default size */
60 static int io_timeout = (CLIENT_TIMEOUT/1000); /* Per operation timeout (in seconds). */
61
62 static int name_type = 0x20;
63 static int max_protocol = -1;
64
65 static int process_tok(char *tok);
66 static int cmd_help(void);
67
68 #define CREATE_ACCESS_READ READ_CONTROL_ACCESS
69
70 /* value for unused fid field in trans2 secondary request */
71 #define FID_UNUSED (0xFFFF)
72
73 time_t newer_than = 0;
74 static int archive_level = 0;
75
76 static bool translation = false;
77 static bool have_ip;
78
79 static bool prompt = true;
80
81 static bool recurse = false;
82 static bool showacls = false;
83 bool lowercase = false;
84 static bool backup_intent = false;
85
86 static struct sockaddr_storage dest_ss;
87 static char dest_ss_str[INET6_ADDRSTRLEN];
88
89 #define SEPARATORS " \t\n\r"
90
91 static bool abort_mget = true;
92
93 /* timing globals */
94 uint64_t get_total_size = 0;
95 unsigned int get_total_time_ms = 0;
96 static uint64_t put_total_size = 0;
97 static unsigned int put_total_time_ms = 0;
98
99 /* totals globals */
100 static double dir_total;
101
102 /* encrypted state. */
103 static bool smb_encrypt;
104
105 /* root cli_state connection */
106
107 struct cli_state *cli;
108
109 static char CLI_DIRSEP_CHAR = '\\';
110 static char CLI_DIRSEP_STR[] = { '\\', '\0' };
111
112 /* Accessor functions for directory paths. */
113 static char *fileselection;
114 static const char *client_get_fileselection(void)
115 {
116 if (fileselection) {
117 return fileselection;
118 }
119 return "";
120 }
121
122 static const char *client_set_fileselection(const char *new_fs)
123 {
124 SAFE_FREE(fileselection);
125 if (new_fs) {
126 fileselection = SMB_STRDUP(new_fs);
127 }
128 return client_get_fileselection();
129 }
130
131 static char *cwd;
132 static const char *client_get_cwd(void)
133 {
134 if (cwd) {
135 return cwd;
136 }
137 return CLI_DIRSEP_STR;
138 }
139
140 static const char *client_set_cwd(const char *new_cwd)
141 {
142 SAFE_FREE(cwd);
143 if (new_cwd) {
144 cwd = SMB_STRDUP(new_cwd);
145 }
146 return client_get_cwd();
147 }
148
149 static char *cur_dir;
150 const char *client_get_cur_dir(void)
151 {
152 if (cur_dir) {
153 return cur_dir;
154 }
155 return CLI_DIRSEP_STR;
156 }
157
158 const char *client_set_cur_dir(const char *newdir)
159 {
160 SAFE_FREE(cur_dir);
161 if (newdir) {
162 cur_dir = SMB_STRDUP(newdir);
163 }
164 return client_get_cur_dir();
165 }
166
167 /****************************************************************************
168 Put up a yes/no prompt.
169 ****************************************************************************/
170
171 static bool yesno(const char *p)
172 {
173 char ans[20];
174 printf("%s",p);
175
176 if (!fgets(ans,sizeof(ans)-1,stdin))
177 return(False);
178
179 if (*ans == 'y' || *ans == 'Y')
180 return(True);
181
182 return(False);
183 }
184
185 /****************************************************************************
186 Write to a local file with CR/LF->LF translation if appropriate. Return the
187 number taken from the buffer. This may not equal the number written.
188 ****************************************************************************/
189
190 static ssize_t writefile(int f, char *b, size_t n)
191 {
192 size_t i = 0;
193
194 if (n == 0) {
195 errno = EINVAL;
196 return -1;
197 }
198
199 if (!translation) {
200 return write(f,b,n);
201 }
202
203 do {
204 if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
205 b++;i++;
206 }
207 if (write(f, b, 1) != 1) {
208 break;
209 }
210 b++;
211 i++;
212 } while (i < n);
213
214 return (ssize_t)i;
215 }
216
217 /****************************************************************************
218 Read from a file with LF->CR/LF translation if appropriate. Return the
219 number read. read approx n bytes.
220 ****************************************************************************/
221
222 static int readfile(uint8_t *b, int n, FILE *f)
223 {
224 int i;
225 int c;
226
227 if (!translation)
228 return fread(b,1,n,f);
229
230 i = 0;
231 while (i < (n - 1)) {
232 if ((c = getc(f)) == EOF) {
233 break;
234 }
235
236 if (c == '\n') { /* change all LFs to CR/LF */
237 b[i++] = '\r';
238 }
239
240 b[i++] = c;
241 }
242
243 return(i);
244 }
245
246 struct push_state {
247 FILE *f;
248 off_t nread;
249 };
250
251 static size_t push_source(uint8_t *buf, size_t n, void *priv)
252 {
253 struct push_state *state = (struct push_state *)priv;
254 int result;
255
256 if (feof(state->f)) {
257 return 0;
258 }
259
260 result = readfile(buf, n, state->f);
261 state->nread += result;
262 return result;
263 }
264
265 /****************************************************************************
266 Send a message.
267 ****************************************************************************/
268
269 static void send_message(const char *username)
270 {
271 char buf[1600];
272 NTSTATUS status;
273 int i;
274
275 d_printf("Type your message, ending it with a Control-D\n");
276
277 i = 0;
278 while (i<sizeof(buf)-2) {
279 int c = fgetc(stdin);
280 if (c == EOF) {
281 break;
282 }
283 if (c == '\n') {
284 buf[i++] = '\r';
285 }
286 buf[i++] = c;
287 }
288 buf[i] = '\0';
289
290 status = cli_message(cli, desthost, username, buf);
291 if (!NT_STATUS_IS_OK(status)) {
292 d_fprintf(stderr, "cli_message returned %s\n",
293 nt_errstr(status));
294 }
295 }
296
297 /****************************************************************************
298 Check the space on a device.
299 ****************************************************************************/
300
301 static int do_dskattr(void)
302 {
303 uint64_t total, bsize, avail;
304 struct cli_state *targetcli = NULL;
305 char *targetpath = NULL;
306 TALLOC_CTX *ctx = talloc_tos();
307 NTSTATUS status;
308
309 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(), cli,
310 client_get_cur_dir(), &targetcli,
311 &targetpath);
312 if (!NT_STATUS_IS_OK(status)) {
313 d_printf("Error in dskattr: %s\n", nt_errstr(status));
314 return 1;
315 }
316
317 status = cli_disk_size(targetcli, targetpath, &bsize, &total, &avail);
318 if (!NT_STATUS_IS_OK(status)) {
319 d_printf("Error in dskattr: %s\n", nt_errstr(status));
320 return 1;
321 }
322
323 d_printf("\n\t\t%" PRIu64
324 " blocks of size %" PRIu64
325 ". %" PRIu64 " blocks available\n",
326 total, bsize, avail);
327
328 return 0;
329 }
330
331 /****************************************************************************
332 Show cd/pwd.
333 ****************************************************************************/
334
335 static int cmd_pwd(void)
336 {
337 d_printf("Current directory is %s",service);
338 d_printf("%s\n",client_get_cur_dir());
339 return 0;
340 }
341
342 /****************************************************************************
343 Ensure name has correct directory separators.
344 ****************************************************************************/
345
346 static void normalize_name(char *newdir)
347 {
348 if (!(cli->requested_posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP)) {
349 string_replace(newdir,'/','\\');
350 }
351 }
352
353 /****************************************************************************
354 Local name cleanup before sending to server. SMB1 allows relative pathnames,
355 but SMB2 does not, so we need to resolve them locally.
356 ****************************************************************************/
357
358 char *client_clean_name(TALLOC_CTX *ctx, const char *name)
359 {
360 char *newname = NULL;
361 if (name == NULL) {
362 return NULL;
363 }
364
365 /* First ensure any path separators are correct. */
366 newname = talloc_strdup(ctx, name);
367 if (newname == NULL) {
368 return NULL;
369 }
370 normalize_name(newname);
371
372 /* Now remove any relative (..) path components. */
373 if (cli->requested_posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
374 newname = unix_clean_name(ctx, newname);
375 } else {
376 newname = clean_name(ctx, newname);
377 }
378 if (newname == NULL) {
379 return NULL;
380 }
381 return newname;
382 }
383
384 /****************************************************************************
385 Change directory - inner section.
386 ****************************************************************************/
387
388 static int do_cd(const char *new_dir)
389 {
390 char *newdir = NULL;
391 char *saved_dir = NULL;
392 char *new_cd = NULL;
393 char *targetpath = NULL;
394 struct cli_state *targetcli = NULL;
395 SMB_STRUCT_STAT sbuf;
396 uint32_t attributes;
397 int ret = 1;
398 TALLOC_CTX *ctx = talloc_stackframe();
399 NTSTATUS status;
400
401 newdir = talloc_strdup(ctx, new_dir);
402 if (!newdir) {
403 TALLOC_FREE(ctx);
404 return 1;
405 }
406
407 normalize_name(newdir);
408
409 /* Save the current directory in case the new directory is invalid */
410
411 saved_dir = talloc_strdup(ctx, client_get_cur_dir());
412 if (!saved_dir) {
413 TALLOC_FREE(ctx);
414 return 1;
415 }
416
417 if (*newdir == CLI_DIRSEP_CHAR) {
418 client_set_cur_dir(newdir);
419 new_cd = newdir;
420 } else {
421 new_cd = talloc_asprintf(ctx, "%s%s",
422 client_get_cur_dir(),
423 newdir);
424 if (!new_cd) {
425 goto out;
426 }
427 }
428
429 /* Ensure cur_dir ends in a DIRSEP */
430 if ((new_cd[0] != '\0') && (*(new_cd+strlen(new_cd)-1) != CLI_DIRSEP_CHAR)) {
431 new_cd = talloc_asprintf_append(new_cd, "%s", CLI_DIRSEP_STR);
432 if (!new_cd) {
433 goto out;
434 }
435 }
436 client_set_cur_dir(new_cd);
437
438 new_cd = client_clean_name(ctx, new_cd);
439 client_set_cur_dir(new_cd);
440
441 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
442 cli, new_cd, &targetcli, &targetpath);
443 if (!NT_STATUS_IS_OK(status)) {
444 d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
445 client_set_cur_dir(saved_dir);
446 goto out;
447 }
448
449 if (strequal(targetpath,CLI_DIRSEP_STR )) {
450 TALLOC_FREE(ctx);
451 return 0;
452 }
453
454 /* Use a trans2_qpathinfo to test directories for modern servers.
455 Except Win9x doesn't support the qpathinfo_basic() call..... */
456
457 if (smbXcli_conn_protocol(targetcli->conn) > PROTOCOL_LANMAN2 && !targetcli->win95) {
458
459 status = cli_qpathinfo_basic(targetcli, targetpath, &sbuf,
460 &attributes);
461 if (!NT_STATUS_IS_OK(status)) {
462 d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
463 client_set_cur_dir(saved_dir);
464 goto out;
465 }
466
467 if (!(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
468 d_printf("cd %s: not a directory\n", new_cd);
469 client_set_cur_dir(saved_dir);
470 goto out;
471 }
472 } else {
473
474 targetpath = talloc_asprintf(ctx,
475 "%s%s",
476 targetpath,
477 CLI_DIRSEP_STR );
478 if (!targetpath) {
479 client_set_cur_dir(saved_dir);
480 goto out;
481 }
482 targetpath = client_clean_name(ctx, targetpath);
483 if (!targetpath) {
484 client_set_cur_dir(saved_dir);
485 goto out;
486 }
487
488 status = cli_chkpath(targetcli, targetpath);
489 if (!NT_STATUS_IS_OK(status)) {
490 d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
491 client_set_cur_dir(saved_dir);
492 goto out;
493 }
494 }
495
496 ret = 0;
497
498 out:
499
500 TALLOC_FREE(ctx);
501 return ret;
502 }
503
504 /****************************************************************************
505 Change directory.
506 ****************************************************************************/
507
508 static int cmd_cd(void)
509 {
510 char *buf = NULL;
511 int rc = 0;
512
513 if (next_token_talloc(talloc_tos(), &cmd_ptr, &buf,NULL)) {
514 rc = do_cd(buf);
515 } else {
516 d_printf("Current directory is %s\n",client_get_cur_dir());
517 }
518
519 return rc;
520 }
521
522 /****************************************************************************
523 Change directory.
524 ****************************************************************************/
525
526 static int cmd_cd_oneup(void)
527 {
528 return do_cd("..");
529 }
530
531 /*******************************************************************
532 Decide if a file should be operated on.
533 ********************************************************************/
534
535 static bool do_this_one(struct file_info *finfo)
536 {
537 if (!finfo->name) {
538 return false;
539 }
540
541 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
542 return true;
543 }
544
545 if (*client_get_fileselection() &&
546 !mask_match(finfo->name,client_get_fileselection(),false)) {
547 DEBUG(3,("mask_match %s failed\n", finfo->name));
548 return false;
549 }
550
551 if (newer_than && finfo->mtime_ts.tv_sec < newer_than) {
552 DEBUG(3,("newer_than %s failed\n", finfo->name));
553 return false;
554 }
555
556 if ((archive_level==1 || archive_level==2) && !(finfo->mode & FILE_ATTRIBUTE_ARCHIVE)) {
557 DEBUG(3,("archive %s failed\n", finfo->name));
558 return false;
559 }
560
561 return true;
562 }
563
564 /****************************************************************************
565 Display info about a file.
566 ****************************************************************************/
567
568 static NTSTATUS display_finfo(struct cli_state *cli_state, struct file_info *finfo,
569 const char *dir)
570 {
571 time_t t;
572 TALLOC_CTX *ctx = talloc_tos();
573 NTSTATUS status = NT_STATUS_OK;
574
575 if (!do_this_one(finfo)) {
576 return NT_STATUS_OK;
577 }
578
579 t = finfo->mtime_ts.tv_sec; /* the time is assumed to be passed as GMT */
580 if (!showacls) {
581 d_printf(" %-30s%7.7s %8.0f %s",
582 finfo->name,
583 attrib_string(talloc_tos(), finfo->mode),
584 (double)finfo->size,
585 time_to_asc(t));
586 dir_total += finfo->size;
587 } else {
588 char *afname = NULL;
589 uint16_t fnum;
590
591 /* skip if this is . or .. */
592 if ( strequal(finfo->name,"..") || strequal(finfo->name,".") )
593 return NT_STATUS_OK;
594 /* create absolute filename for cli_ntcreate() FIXME */
595 afname = talloc_asprintf(ctx,
596 "%s%s%s",
597 dir,
598 CLI_DIRSEP_STR,
599 finfo->name);
600 if (!afname) {
601 return NT_STATUS_NO_MEMORY;
602 }
603 /* print file meta date header */
604 d_printf( "FILENAME:%s\n", finfo->name);
605 d_printf( "MODE:%s\n", attrib_string(talloc_tos(), finfo->mode));
606 d_printf( "SIZE:%.0f\n", (double)finfo->size);
607 d_printf( "MTIME:%s", time_to_asc(t));
608 status = cli_ntcreate(cli_state, afname, 0,
609 CREATE_ACCESS_READ, 0,
610 FILE_SHARE_READ|FILE_SHARE_WRITE,
611 FILE_OPEN, 0x0, 0x0, &fnum, NULL);
612 if (!NT_STATUS_IS_OK(status)) {
613 DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
614 afname, nt_errstr(status)));
615 } else {
616 struct security_descriptor *sd = NULL;
617 status = cli_query_secdesc(cli_state, fnum,
618 ctx, &sd);
619 if (!NT_STATUS_IS_OK(status)) {
620 DEBUG( 0, ("display_finfo() failed to "
621 "get security descriptor: %s",
622 nt_errstr(status)));
623 } else {
624 display_sec_desc(sd);
625 }
626 TALLOC_FREE(sd);
627 }
628 TALLOC_FREE(afname);
629 }
630 return status;
631 }
632
633 /****************************************************************************
634 Accumulate size of a file.
635 ****************************************************************************/
636
637 static NTSTATUS do_du(struct cli_state *cli_state, struct file_info *finfo,
638 const char *dir)
639 {
640 if (do_this_one(finfo)) {
641 dir_total += finfo->size;
642 }
643 return NT_STATUS_OK;
644 }
645
646 static bool do_list_recurse;
647 static bool do_list_dirs;
648 static char *do_list_queue = 0;
649 static long do_list_queue_size = 0;
650 static long do_list_queue_start = 0;
651 static long do_list_queue_end = 0;
652 static NTSTATUS (*do_list_fn)(struct cli_state *cli_state, struct file_info *,
653 const char *dir);
654
655 /****************************************************************************
656 Functions for do_list_queue.
657 ****************************************************************************/
658
659 /*
660 * The do_list_queue is a NUL-separated list of strings stored in a
661 * char*. Since this is a FIFO, we keep track of the beginning and
662 * ending locations of the data in the queue. When we overflow, we
663 * double the size of the char*. When the start of the data passes
664 * the midpoint, we move everything back. This is logically more
665 * complex than a linked list, but easier from a memory management
666 * angle. In any memory error condition, do_list_queue is reset.
667 * Functions check to ensure that do_list_queue is non-NULL before
668 * accessing it.
669 */
670
671 static void reset_do_list_queue(void)
672 {
673 SAFE_FREE(do_list_queue);
674 do_list_queue_size = 0;
675 do_list_queue_start = 0;
676 do_list_queue_end = 0;
677 }
678
679 static void init_do_list_queue(void)
680 {
681 reset_do_list_queue();
682 do_list_queue_size = 1024;
683 do_list_queue = (char *)SMB_MALLOC(do_list_queue_size);
684 if (do_list_queue == 0) {
685 d_printf("malloc fail for size %d\n",
686 (int)do_list_queue_size);
687 reset_do_list_queue();
688 } else {
689 memset(do_list_queue, 0, do_list_queue_size);
690 }
691 }
692
693 static void adjust_do_list_queue(void)
694 {
695 /*
696 * If the starting point of the queue is more than half way through,
697 * move everything toward the beginning.
698 */
699
700 if (do_list_queue == NULL) {
701 DEBUG(4,("do_list_queue is empty\n"));
702 do_list_queue_start = do_list_queue_end = 0;
703 return;
704 }
705
706 if (do_list_queue_start == do_list_queue_end) {
707 DEBUG(4,("do_list_queue is empty\n"));
708 do_list_queue_start = do_list_queue_end = 0;
709 *do_list_queue = '\0';
710 } else if (do_list_queue_start > (do_list_queue_size / 2)) {
711 DEBUG(4,("sliding do_list_queue backward\n"));
712 memmove(do_list_queue,
713 do_list_queue + do_list_queue_start,
714 do_list_queue_end - do_list_queue_start);
715 do_list_queue_end -= do_list_queue_start;
716 do_list_queue_start = 0;
717 }
718 }
719
720 static void add_to_do_list_queue(const char *entry)
721 {
722 long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
723 while (new_end > do_list_queue_size) {
724 do_list_queue_size *= 2;
725 DEBUG(4,("enlarging do_list_queue to %d\n",
726 (int)do_list_queue_size));
727 do_list_queue = (char *)SMB_REALLOC(do_list_queue, do_list_queue_size);
728 if (! do_list_queue) {
729 d_printf("failure enlarging do_list_queue to %d bytes\n",
730 (int)do_list_queue_size);
731 reset_do_list_queue();
732 } else {
733 memset(do_list_queue + do_list_queue_size / 2,
734 0, do_list_queue_size / 2);
735 }
736 }
737 if (do_list_queue) {
738 strlcpy_base(do_list_queue + do_list_queue_end,
739 entry, do_list_queue, do_list_queue_size);
740 do_list_queue_end = new_end;
741 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
742 entry, (int)do_list_queue_start, (int)do_list_queue_end));
743 }
744 }
745
746 static char *do_list_queue_head(void)
747 {
748 return do_list_queue + do_list_queue_start;
749 }
750
751 static void remove_do_list_queue_head(void)
752 {
753 if (do_list_queue_end > do_list_queue_start) {
754 do_list_queue_start += strlen(do_list_queue_head()) + 1;
755 adjust_do_list_queue();
756 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
757 (int)do_list_queue_start, (int)do_list_queue_end));
758 }
759 }
760
761 static int do_list_queue_empty(void)
762 {
763 return (! (do_list_queue && *do_list_queue));
764 }
765
766 /****************************************************************************
767 A helper for do_list.
768 ****************************************************************************/
769
770 static NTSTATUS do_list_helper(const char *mntpoint, struct file_info *f,
771 const char *mask, void *state)
772 {
773 struct cli_state *cli_state = (struct cli_state *)state;
774 TALLOC_CTX *ctx = talloc_tos();
775 char *dir = NULL;
776 char *dir_end = NULL;
777 NTSTATUS status = NT_STATUS_OK;
778
779 /* Work out the directory. */
780 dir = talloc_strdup(ctx, mask);
781 if (!dir) {
782 return NT_STATUS_NO_MEMORY;
783 }
784 if ((dir_end = strrchr(dir, CLI_DIRSEP_CHAR)) != NULL) {
785 *dir_end = '\0';
786 }
787
788 if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
789 if (do_list_dirs && do_this_one(f)) {
790 status = do_list_fn(cli_state, f, dir);
791 if (!NT_STATUS_IS_OK(status)) {
792 return status;
793 }
794 }
795 if (do_list_recurse &&
796 f->name &&
797 !strequal(f->name,".") &&
798 !strequal(f->name,"..")) {
799 char *mask2 = NULL;
800 char *p = NULL;
801
802 if (!f->name[0]) {
803 d_printf("Empty dir name returned. Possible server misconfiguration.\n");
804 TALLOC_FREE(dir);
805 return NT_STATUS_UNSUCCESSFUL;
806 }
807
808 mask2 = talloc_asprintf(ctx,
809 "%s%s",
810 mntpoint,
811 mask);
812 if (!mask2) {
813 TALLOC_FREE(dir);
814 return NT_STATUS_NO_MEMORY;
815 }
816 p = strrchr_m(mask2,CLI_DIRSEP_CHAR);
817 if (p) {
818 p[1] = 0;
819 } else {
820 mask2[0] = '\0';
821 }
822 mask2 = talloc_asprintf_append(mask2,
823 "%s%s*",
824 f->name,
825 CLI_DIRSEP_STR);
826 if (!mask2) {
827 TALLOC_FREE(dir);
828 return NT_STATUS_NO_MEMORY;
829 }
830 add_to_do_list_queue(mask2);
831 TALLOC_FREE(mask2);
832 }
833 TALLOC_FREE(dir);
834 return NT_STATUS_OK;
835 }
836
837 if (do_this_one(f)) {
838 status = do_list_fn(cli_state, f, dir);
839 }
840 TALLOC_FREE(dir);
841 return status;
842 }
843
844 /****************************************************************************
845 A wrapper around cli_list that adds recursion.
846 ****************************************************************************/
847
848 NTSTATUS do_list(const char *mask,
849 uint16_t attribute,
850 NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
851 const char *dir),
852 bool rec,
853 bool dirs)
854 {
855 static int in_do_list = 0;
856 TALLOC_CTX *ctx = talloc_tos();
857 struct cli_state *targetcli = NULL;
858 char *targetpath = NULL;
859 NTSTATUS ret_status = NT_STATUS_OK;
860 NTSTATUS status = NT_STATUS_OK;
861
862 if (in_do_list && rec) {
863 fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
864 exit(1);
865 }
866
867 in_do_list = 1;
868
869 do_list_recurse = rec;
870 do_list_dirs = dirs;
871 do_list_fn = fn;
872
873 if (rec) {
874 init_do_list_queue();
875 add_to_do_list_queue(mask);
876
877 while (!do_list_queue_empty()) {
878 /*
879 * Need to copy head so that it doesn't become
880 * invalid inside the call to cli_list. This
881 * would happen if the list were expanded
882 * during the call.
883 * Fix from E. Jay Berkenbilt (ejb@ql.org)
884 */
885 char *head = talloc_strdup(ctx, do_list_queue_head());
886
887 if (!head) {
888 return NT_STATUS_NO_MEMORY;
889 }
890
891 /* check for dfs */
892
893 status = cli_resolve_path(ctx, "",
894 popt_get_cmdline_auth_info(),
895 cli, head, &targetcli, &targetpath);
896 if (!NT_STATUS_IS_OK(status)) {
897 d_printf("do_list: [%s] %s\n", head,
898 nt_errstr(status));
899 remove_do_list_queue_head();
900 continue;
901 }
902
903 status = cli_list(targetcli, targetpath, attribute,
904 do_list_helper, targetcli);
905 if (!NT_STATUS_IS_OK(status)) {
906 d_printf("%s listing %s\n",
907 nt_errstr(status), targetpath);
908 ret_status = status;
909 }
910 remove_do_list_queue_head();
911 if ((! do_list_queue_empty()) && (fn == display_finfo)) {
912 char *next_file = do_list_queue_head();
913 char *save_ch = 0;
914 if ((strlen(next_file) >= 2) &&
915 (next_file[strlen(next_file) - 1] == '*') &&
916 (next_file[strlen(next_file) - 2] == CLI_DIRSEP_CHAR)) {
917 save_ch = next_file +
918 strlen(next_file) - 2;
919 *save_ch = '\0';
920 if (showacls) {
921 /* cwd is only used if showacls is on */
922 client_set_cwd(next_file);
923 }
924 }
925 if (!showacls) /* don't disturbe the showacls output */
926 d_printf("\n%s\n",next_file);
927 if (save_ch) {
928 *save_ch = CLI_DIRSEP_CHAR;
929 }
930 }
931 TALLOC_FREE(head);
932 TALLOC_FREE(targetpath);
933 }
934 } else {
935 /* check for dfs */
936 status = cli_resolve_path(ctx, "",
937 popt_get_cmdline_auth_info(), cli, mask,
938 &targetcli, &targetpath);
939 if (NT_STATUS_IS_OK(status)) {
940 status = cli_list(targetcli, targetpath, attribute,
941 do_list_helper, targetcli);
942 if (!NT_STATUS_IS_OK(status)) {
943 d_printf("%s listing %s\n",
944 nt_errstr(status), targetpath);
945 ret_status = status;
946 }
947 TALLOC_FREE(targetpath);
948 } else {
949 d_printf("do_list: [%s] %s\n", mask, nt_errstr(status));
950 ret_status = status;
951 }
952 }
953
954 in_do_list = 0;
955 reset_do_list_queue();
956 return ret_status;
957 }
958
959 /****************************************************************************
960 Get a directory listing.
961 ****************************************************************************/
962
963 static int cmd_dir(void)
964 {
965 TALLOC_CTX *ctx = talloc_tos();
966 uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
967 char *mask = NULL;
968 char *buf = NULL;
969 int rc = 1;
970 NTSTATUS status;
971
972 dir_total = 0;
973 mask = talloc_strdup(ctx, client_get_cur_dir());
974 if (!mask) {
975 return 1;
976 }
977
978 if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
979 normalize_name(buf);
980 if (*buf == CLI_DIRSEP_CHAR) {
981 mask = talloc_strdup(ctx, buf);
982 } else {
983 mask = talloc_asprintf_append(mask, "%s", buf);
984 }
985 } else {
986 mask = talloc_asprintf_append(mask, "*");
987 }
988 if (!mask) {
989 return 1;
990 }
991
992 mask = client_clean_name(ctx, mask);
993 if (mask == NULL) {
994 return 1;
995 }
996
997 if (showacls) {
998 /* cwd is only used if showacls is on */
999 client_set_cwd(client_get_cur_dir());
1000 }
1001
1002 status = do_list(mask, attribute, display_finfo, recurse, true);
1003 if (!NT_STATUS_IS_OK(status)) {
1004 return 1;
1005 }
1006
1007 rc = do_dskattr();
1008
1009 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
1010
1011 return rc;
1012 }
1013
1014 /****************************************************************************
1015 Get a directory listing.
1016 ****************************************************************************/
1017
1018 static int cmd_du(void)
1019 {
1020 TALLOC_CTX *ctx = talloc_tos();
1021 uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
1022 char *mask = NULL;
1023 char *buf = NULL;
1024 NTSTATUS status;
1025 int rc = 1;
1026
1027 dir_total = 0;
1028 mask = talloc_strdup(ctx, client_get_cur_dir());
1029 if (!mask) {
1030 return 1;
1031 }
1032 if ((mask[0] != '\0') && (mask[strlen(mask)-1]!=CLI_DIRSEP_CHAR)) {
1033 mask = talloc_asprintf_append(mask, "%s", CLI_DIRSEP_STR);
1034 if (!mask) {
1035 return 1;
1036 }
1037 }
1038
1039 if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1040 normalize_name(buf);
1041 if (*buf == CLI_DIRSEP_CHAR) {
1042 mask = talloc_strdup(ctx, buf);
1043 } else {
1044 mask = talloc_asprintf_append(mask, "%s", buf);
1045 }
1046 } else {
1047 mask = talloc_strdup(ctx, "*");
1048 }
1049 if (!mask) {
1050 return 1;
1051 }
1052
1053 mask = client_clean_name(ctx, mask);
1054 if (mask == NULL) {
1055 return 1;
1056 }
1057
1058 status = do_list(mask, attribute, do_du, recurse, true);
1059 if (!NT_STATUS_IS_OK(status)) {
1060 return 1;
1061 }
1062
1063 rc = do_dskattr();
1064
1065 d_printf("Total number of bytes: %.0f\n", dir_total);
1066
1067 return rc;
1068 }
1069
1070 static int cmd_echo(void)
1071 {
1072 TALLOC_CTX *ctx = talloc_tos();
1073 char *num;
1074 char *data;
1075 NTSTATUS status;
1076
1077 if (!next_token_talloc(ctx, &cmd_ptr, &num, NULL)
1078 || !next_token_talloc(ctx, &cmd_ptr, &data, NULL)) {
1079 d_printf("echo <num> <data>\n");
1080 return 1;
1081 }
1082
1083 status = cli_echo(cli, atoi(num), data_blob_const(data, strlen(data)));
1084
1085 if (!NT_STATUS_IS_OK(status)) {
1086 d_printf("echo failed: %s\n", nt_errstr(status));
1087 return 1;
1088 }
1089
1090 return 0;
1091 }
1092
1093 /****************************************************************************
1094 Get a file from rname to lname
1095 ****************************************************************************/
1096
1097 static NTSTATUS writefile_sink(char *buf, size_t n, void *priv)
1098 {
1099 int *pfd = (int *)priv;
1100 ssize_t rc;
1101
1102 rc = writefile(*pfd, buf, n);
1103 if (rc == -1) {
1104 return map_nt_error_from_unix(errno);
1105 }
1106 return NT_STATUS_OK;
1107 }
1108
1109 static int do_get(const char *rname, const char *lname_in, bool reget)
1110 {
1111 TALLOC_CTX *ctx = talloc_tos();
1112 int handle = 0;
1113 uint16_t fnum;
1114 bool newhandle = false;
1115 struct timespec tp_start;
1116 uint16_t attr;
1117 off_t size;
1118 off_t start = 0;
1119 off_t nread = 0;
1120 int rc = 0;
1121 struct cli_state *targetcli = NULL;
1122 char *targetname = NULL;
1123 char *lname = NULL;
1124 NTSTATUS status;
1125
1126 lname = talloc_strdup(ctx, lname_in);
1127 if (!lname) {
1128 return 1;
1129 }
1130
1131 if (lowercase) {
1132 if (!strlower_m(lname)) {
1133 d_printf("strlower_m %s failed\n", lname);
1134 return 1;
1135 }
1136 }
1137
1138 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
1139 cli, rname, &targetcli, &targetname);
1140 if (!NT_STATUS_IS_OK(status)) {
1141 d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
1142 return 1;
1143 }
1144
1145 clock_gettime_mono(&tp_start);
1146
1147 status = cli_open(targetcli, targetname, O_RDONLY, DENY_NONE, &fnum);
1148 if (!NT_STATUS_IS_OK(status)) {
1149 d_printf("%s opening remote file %s\n", nt_errstr(status),
1150 rname);
1151 return 1;
1152 }
1153
1154 if(!strcmp(lname,"-")) {
1155 handle = fileno(stdout);
1156 } else {
1157 if (reget) {
1158 handle = open(lname, O_WRONLY|O_CREAT, 0644);
1159 if (handle >= 0) {
1160 start = lseek(handle, 0, SEEK_END);
1161 if (start == -1) {
1162 d_printf("Error seeking local file\n");
1163 close(handle);
1164 return 1;
1165 }
1166 }
1167 } else {
1168 handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
1169 }
1170 newhandle = true;
1171 }
1172 if (handle < 0) {
1173 d_printf("Error opening local file %s\n",lname);
1174 return 1;
1175 }
1176
1177
1178 status = cli_qfileinfo_basic(targetcli, fnum, &attr, &size, NULL, NULL,
1179 NULL, NULL, NULL);
1180 if (!NT_STATUS_IS_OK(status)) {
1181 status = cli_getattrE(targetcli, fnum, &attr, &size, NULL, NULL,
1182 NULL);
1183 if(!NT_STATUS_IS_OK(status)) {
1184 d_printf("getattrib: %s\n", nt_errstr(status));
1185 if (newhandle) {
1186 close(handle);
1187 }
1188 return 1;
1189 }
1190 }
1191
1192 DEBUG(1,("getting file %s of size %.0f as %s ",
1193 rname, (double)size, lname));
1194
1195 status = cli_pull(targetcli, fnum, start, size, io_bufsize,
1196 writefile_sink, (void *)&handle, &nread);
1197 if (!NT_STATUS_IS_OK(status)) {
1198 d_fprintf(stderr, "parallel_read returned %s\n",
1199 nt_errstr(status));
1200 if (newhandle) {
1201 close(handle);
1202 }
1203 cli_close(targetcli, fnum);
1204 return 1;
1205 }
1206
1207 status = cli_close(targetcli, fnum);
1208 if (!NT_STATUS_IS_OK(status)) {
1209 d_printf("Error %s closing remote file\n", nt_errstr(status));
1210 rc = 1;
1211 }
1212
1213 if (newhandle) {
1214 close(handle);
1215 }
1216
1217 if (archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
1218 cli_setatr(cli, rname, attr & ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE, 0);
1219 }
1220
1221 {
1222 struct timespec tp_end;
1223 int this_time;
1224
1225 clock_gettime_mono(&tp_end);
1226 this_time = nsec_time_diff(&tp_end,&tp_start)/1000000;
1227 get_total_time_ms += this_time;
1228 get_total_size += nread;
1229
1230 DEBUG(1,("(%3.1f KiloBytes/sec) (average %3.1f KiloBytes/sec)\n",
1231 nread / (1.024*this_time + 1.0e-4),
1232 get_total_size / (1.024*get_total_time_ms)));
1233 }
1234
1235 TALLOC_FREE(targetname);
1236 return rc;
1237 }
1238
1239 /****************************************************************************
1240 Get a file.
1241 ****************************************************************************/
1242
1243 static int cmd_get(void)
1244 {
1245 TALLOC_CTX *ctx = talloc_tos();
1246 char *lname = NULL;
1247 char *rname = NULL;
1248 char *fname = NULL;
1249
1250 rname = talloc_strdup(ctx, client_get_cur_dir());
1251 if (!rname) {
1252 return 1;
1253 }
1254
1255 if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
1256 d_printf("get <filename> [localname]\n");
1257 return 1;
1258 }
1259 rname = talloc_asprintf_append(rname, "%s", fname);
1260 if (!rname) {
1261 return 1;
1262 }
1263 rname = client_clean_name(ctx, rname);
1264 if (!rname) {
1265 return 1;
1266 }
1267
1268 next_token_talloc(ctx, &cmd_ptr,&lname,NULL);
1269 if (!lname) {
1270 lname = fname;
1271 }
1272
1273 return do_get(rname, lname, false);
1274 }
1275
1276 /****************************************************************************
1277 Do an mget operation on one file.
1278 ****************************************************************************/
1279
1280 static NTSTATUS do_mget(struct cli_state *cli_state, struct file_info *finfo,
1281 const char *dir)
1282 {
1283 TALLOC_CTX *ctx = talloc_tos();
1284 NTSTATUS status = NT_STATUS_OK;
1285 char *rname = NULL;
1286 char *quest = NULL;
1287 char *saved_curdir = NULL;
1288 char *mget_mask = NULL;
1289 char *new_cd = NULL;
1290
1291 if (!finfo->name) {
1292 return NT_STATUS_OK;
1293 }
1294
1295 if (strequal(finfo->name,".") || strequal(finfo->name,".."))
1296 return NT_STATUS_OK;
1297
1298 if (abort_mget) {
1299 d_printf("mget aborted\n");
1300 return NT_STATUS_UNSUCCESSFUL;
1301 }
1302
1303 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
1304 if (asprintf(&quest,
1305 "Get directory %s? ",finfo->name) < 0) {
1306 return NT_STATUS_NO_MEMORY;
1307 }
1308 } else {
1309 if (asprintf(&quest,
1310 "Get file %s? ",finfo->name) < 0) {
1311 return NT_STATUS_NO_MEMORY;
1312 }
1313 }
1314
1315 if (prompt && !yesno(quest)) {
1316 SAFE_FREE(quest);
1317 return NT_STATUS_OK;
1318 }
1319 SAFE_FREE(quest);
1320
1321 if (!(finfo->mode & FILE_ATTRIBUTE_DIRECTORY)) {
1322 rname = talloc_asprintf(ctx,
1323 "%s%s",
1324 client_get_cur_dir(),
1325 finfo->name);
1326 if (!rname) {
1327 return NT_STATUS_NO_MEMORY;
1328 }
1329 rname = client_clean_name(ctx, rname);
1330 if (rname == NULL) {
1331 return NT_STATUS_NO_MEMORY;
1332 }
1333 do_get(rname, finfo->name, false);
1334 TALLOC_FREE(rname);
1335 return NT_STATUS_OK;
1336 }
1337
1338 /* handle directories */
1339 saved_curdir = talloc_strdup(ctx, client_get_cur_dir());
1340 if (!saved_curdir) {
1341 return NT_STATUS_NO_MEMORY;
1342 }
1343
1344 new_cd = talloc_asprintf(ctx,
1345 "%s%s%s",
1346 client_get_cur_dir(),
1347 finfo->name,
1348 CLI_DIRSEP_STR);
1349 if (!new_cd) {
1350 return NT_STATUS_NO_MEMORY;
1351 }
1352 new_cd = client_clean_name(ctx, new_cd);
1353 if (new_cd == NULL) {
1354 return NT_STATUS_NO_MEMORY;
1355 }
1356 client_set_cur_dir(new_cd);
1357
1358 string_replace(finfo->name,'\\','/');
1359 if (lowercase) {
1360 if (!strlower_m(finfo->name)) {
1361 return NT_STATUS_INVALID_PARAMETER;
1362 }
1363 }
1364
1365 if (!directory_exist(finfo->name) &&
1366 mkdir(finfo->name,0777) != 0) {
1367 d_printf("failed to create directory %s\n",finfo->name);
1368 client_set_cur_dir(saved_curdir);
1369 return map_nt_error_from_unix(errno);
1370 }
1371
1372 if (chdir(finfo->name) != 0) {
1373 d_printf("failed to chdir to directory %s\n",finfo->name);
1374 client_set_cur_dir(saved_curdir);
1375 return map_nt_error_from_unix(errno);
1376 }
1377
1378 mget_mask = talloc_asprintf(ctx,
1379 "%s*",
1380 client_get_cur_dir());
1381
1382 if (!mget_mask) {
1383 return NT_STATUS_NO_MEMORY;
1384 }
1385
1386 mget_mask = client_clean_name(ctx, mget_mask);
1387 if (mget_mask == NULL) {
1388 return NT_STATUS_NO_MEMORY;
1389 }
1390 status = do_list(mget_mask,
1391 (FILE_ATTRIBUTE_SYSTEM
1392 | FILE_ATTRIBUTE_HIDDEN
1393 | FILE_ATTRIBUTE_DIRECTORY),
1394 do_mget, false, true);
1395 if (!NT_STATUS_IS_OK(status)
1396 && !NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1397 /*
1398 * Ignore access denied errors to ensure all permitted files are
1399 * pulled down.
1400 */
1401 return status;
1402 }
1403
1404 if (chdir("..") == -1) {
1405 d_printf("do_mget: failed to chdir to .. (error %s)\n",
1406 strerror(errno) );
1407 return map_nt_error_from_unix(errno);
1408 }
1409 client_set_cur_dir(saved_curdir);
1410 TALLOC_FREE(mget_mask);
1411 TALLOC_FREE(saved_curdir);
1412 TALLOC_FREE(new_cd);
1413 return NT_STATUS_OK;
1414 }
1415
1416 /****************************************************************************
1417 View the file using the pager.
1418 ****************************************************************************/
1419
1420 static int cmd_more(void)
1421 {
1422 TALLOC_CTX *ctx = talloc_tos();
1423 char *rname = NULL;
1424 char *fname = NULL;
1425 char *lname = NULL;
1426 char *pager_cmd = NULL;
1427 const char *pager;
1428 int fd;
1429 int rc = 0;
1430 mode_t mask;
1431
1432 rname = talloc_strdup(ctx, client_get_cur_dir());
1433 if (!rname) {
1434 return 1;
1435 }
1436
1437 lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
1438 if (!lname) {
1439 return 1;
1440 }
1441 mask = umask(S_IRWXO | S_IRWXG);
1442 fd = mkstemp(lname);
1443 umask(mask);
1444 if (fd == -1) {
1445 d_printf("failed to create temporary file for more\n");
1446 return 1;
1447 }
1448 close(fd);
1449
1450 if (!next_token_talloc(ctx, &cmd_ptr,&fname,NULL)) {
1451 d_printf("more <filename>\n");
1452 unlink(lname);
1453 return 1;
1454 }
1455 rname = talloc_asprintf_append(rname, "%s", fname);
1456 if (!rname) {
1457 return 1;
1458 }
1459 rname = client_clean_name(ctx,rname);
1460 if (!rname) {
1461 return 1;
1462 }
1463
1464 rc = do_get(rname, lname, false);
1465
1466 pager=getenv("PAGER");
1467
1468 pager_cmd = talloc_asprintf(ctx,
1469 "%s %s",
1470 (pager? pager:PAGER),
1471 lname);
1472 if (!pager_cmd) {
1473 return 1;
1474 }
1475 if (system(pager_cmd) == -1) {
1476 d_printf("system command '%s' returned -1\n",
1477 pager_cmd);
1478 }
1479 unlink(lname);
1480
1481 return rc;
1482 }
1483
1484 /****************************************************************************
1485 Do a mget command.
1486 ****************************************************************************/
1487
1488 static int cmd_mget(void)
1489 {
1490 TALLOC_CTX *ctx = talloc_tos();
1491 uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
1492 char *mget_mask = NULL;
1493 char *buf = NULL;
1494 NTSTATUS status = NT_STATUS_OK;
1495
1496 if (recurse) {
1497 attribute |= FILE_ATTRIBUTE_DIRECTORY;
1498 }
1499
1500 abort_mget = false;
1501
1502 while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1503
1504 mget_mask = talloc_strdup(ctx, client_get_cur_dir());
1505 if (!mget_mask) {
1506 return 1;
1507 }
1508 if (*buf == CLI_DIRSEP_CHAR) {
1509 mget_mask = talloc_strdup(ctx, buf);
1510 } else {
1511 mget_mask = talloc_asprintf_append(mget_mask,
1512 "%s", buf);
1513 }
1514 if (!mget_mask) {
1515 return 1;
1516 }
1517 mget_mask = client_clean_name(ctx, mget_mask);
1518 if (mget_mask == NULL) {
1519 return 1;
1520 }
1521 status = do_list(mget_mask, attribute, do_mget, false, true);
1522 if (!NT_STATUS_IS_OK(status)) {
1523 return 1;
1524 }
1525 }
1526
1527 if (mget_mask == NULL) {
1528 d_printf("nothing to mget\n");
1529 return 0;
1530 }
1531
1532 if (!*mget_mask) {
1533 mget_mask = talloc_asprintf(ctx,
1534 "%s*",
1535 client_get_cur_dir());
1536 if (!mget_mask) {
1537 return 1;
1538 }
1539 mget_mask = client_clean_name(ctx, mget_mask);
1540 if (mget_mask == NULL) {
1541 return 1;
1542 }
1543 status = do_list(mget_mask, attribute, do_mget, false, true);
1544 if (!NT_STATUS_IS_OK(status)) {
1545 return 1;
1546 }
1547 }
1548
1549 return 0;
1550 }
1551
1552 /****************************************************************************
1553 Make a directory of name "name".
1554 ****************************************************************************/
1555
1556 static bool do_mkdir(const char *name)
1557 {
1558 TALLOC_CTX *ctx = talloc_tos();
1559 struct cli_state *targetcli;
1560 char *targetname = NULL;
1561 NTSTATUS status;
1562
1563 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
1564 cli, name, &targetcli, &targetname);
1565 if (!NT_STATUS_IS_OK(status)) {
1566 d_printf("mkdir %s: %s\n", name, nt_errstr(status));
1567 return false;
1568 }
1569
1570 status = cli_mkdir(targetcli, targetname);
1571 if (!NT_STATUS_IS_OK(status)) {
1572 d_printf("%s making remote directory %s\n",
1573 nt_errstr(status),name);
1574 return false;
1575 }
1576
1577 return true;
1578 }
1579
1580 /****************************************************************************
1581 Show 8.3 name of a file.
1582 ****************************************************************************/
1583
1584 static bool do_altname(const char *name)
1585 {
1586 fstring altname;
1587 NTSTATUS status;
1588
1589 status = cli_qpathinfo_alt_name(cli, name, altname);
1590 if (!NT_STATUS_IS_OK(status)) {
1591 d_printf("%s getting alt name for %s\n",
1592 nt_errstr(status),name);
1593 return false;
1594 }
1595 d_printf("%s\n", altname);
1596
1597 return true;
1598 }
1599
1600 /****************************************************************************
1601 Exit client.
1602 ****************************************************************************/
1603
1604 static int cmd_quit(void)
1605 {
1606 cli_shutdown(cli);
1607 popt_free_cmdline_auth_info();
1608 exit(0);
1609 /* NOTREACHED */
1610 return 0;
1611 }
1612
1613 /****************************************************************************
1614 Make a directory.
1615 ****************************************************************************/
1616
1617 static int cmd_mkdir(void)
1618 {
1619 TALLOC_CTX *ctx = talloc_tos();
1620 char *mask = NULL;
1621 char *buf = NULL;
1622 NTSTATUS status;
1623
1624 mask = talloc_strdup(ctx, client_get_cur_dir());
1625 if (!mask) {
1626 return 1;
1627 }
1628
1629 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
1630 if (!recurse) {
1631 d_printf("mkdir <dirname>\n");
1632 }
1633 return 1;
1634 }
1635 mask = talloc_asprintf_append(mask, "%s", buf);
1636 if (!mask) {
1637 return 1;
1638 }
1639 mask = client_clean_name(ctx, mask);
1640 if (mask == NULL) {
1641 return 1;
1642 }
1643
1644 if (recurse) {
1645 char *ddir = NULL;
1646 char *ddir2 = NULL;
1647 struct cli_state *targetcli;
1648 char *targetname = NULL;
1649 char *p = NULL;
1650 char *saveptr;
1651
1652 ddir2 = talloc_strdup(ctx, "");
1653 if (!ddir2) {
1654 return 1;
1655 }
1656
1657 status = cli_resolve_path(ctx, "",
1658 popt_get_cmdline_auth_info(), cli, mask,
1659 &targetcli, &targetname);
1660 if (!NT_STATUS_IS_OK(status)) {
1661 return 1;
1662 }
1663
1664 ddir = talloc_strdup(ctx, targetname);
1665 if (!ddir) {
1666 return 1;
1667 }
1668 trim_char(ddir,'.','\0');
1669 p = strtok_r(ddir, "/\\", &saveptr);
1670 while (p) {
1671 ddir2 = talloc_asprintf_append(ddir2, "%s", p);
1672 if (!ddir2) {
1673 return 1;
1674 }
1675 if (!NT_STATUS_IS_OK(cli_chkpath(targetcli, ddir2))) {
1676 do_mkdir(ddir2);
1677 }
1678 ddir2 = talloc_asprintf_append(ddir2, "%s", CLI_DIRSEP_STR);
1679 if (!ddir2) {
1680 return 1;
1681 }
1682 p = strtok_r(NULL, "/\\", &saveptr);
1683 }
1684 } else {
1685 do_mkdir(mask);
1686 }
1687
1688 return 0;
1689 }
1690
1691 /****************************************************************************
1692 Show alt name.
1693 ****************************************************************************/
1694
1695 static int cmd_altname(void)
1696 {
1697 TALLOC_CTX *ctx = talloc_tos();
1698 char *name;
1699 char *buf;
1700
1701 name = talloc_strdup(ctx, client_get_cur_dir());
1702 if (!name) {
1703 return 1;
1704 }
1705
1706 if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
1707 d_printf("altname <file>\n");
1708 return 1;
1709 }
1710 name = talloc_asprintf_append(name, "%s", buf);
1711 if (!name) {
1712 return 1;
1713 }
1714 name = client_clean_name(ctx, name);
1715 if (name == NULL) {
1716 return 1;
1717 }
1718 do_altname(name);
1719 return 0;
1720 }
1721
1722 static char *attr_str(TALLOC_CTX *mem_ctx, uint16_t mode)
1723 {
1724 char *attrs = talloc_zero_array(mem_ctx, char, 17);
1725 int i = 0;
1726
1727 if (!(mode & FILE_ATTRIBUTE_NORMAL)) {
1728 if (mode & FILE_ATTRIBUTE_ENCRYPTED) {
1729 attrs[i++] = 'E';
1730 }
1731 if (mode & FILE_ATTRIBUTE_NONINDEXED) {
1732 attrs[i++] = 'N';
1733 }
1734 if (mode & FILE_ATTRIBUTE_OFFLINE) {
1735 attrs[i++] = 'O';
1736 }
1737 if (mode & FILE_ATTRIBUTE_COMPRESSED) {
1738 attrs[i++] = 'C';
1739 }
1740 if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
1741 attrs[i++] = 'r';
1742 }
1743 if (mode & FILE_ATTRIBUTE_SPARSE) {
1744 attrs[i++] = 's';
1745 }
1746 if (mode & FILE_ATTRIBUTE_TEMPORARY) {
1747 attrs[i++] = 'T';
1748 }
1749 if (mode & FILE_ATTRIBUTE_NORMAL) {
1750 attrs[i++] = 'N';
1751 }
1752 if (mode & FILE_ATTRIBUTE_READONLY) {
1753 attrs[i++] = 'R';
1754 }
1755 if (mode & FILE_ATTRIBUTE_HIDDEN) {
1756 attrs[i++] = 'H';
1757 }
1758 if (mode & FILE_ATTRIBUTE_SYSTEM) {
1759 attrs[i++] = 'S';
1760 }
1761 if (mode & FILE_ATTRIBUTE_DIRECTORY) {
1762 attrs[i++] = 'D';
1763 }
1764 if (mode & FILE_ATTRIBUTE_ARCHIVE) {
1765 attrs[i++] = 'A';
1766 }
1767 }
1768 return attrs;
1769 }
1770
1771 /****************************************************************************
1772 Show all info we can get
1773 ****************************************************************************/
1774
1775 static int do_allinfo(const char *name)
1776 {
1777 fstring altname;
1778 struct timespec b_time, a_time, m_time, c_time;
1779 off_t size;
1780 uint16_t mode;
1781 NTTIME tmp;
1782 uint16_t fnum;
1783 unsigned int num_streams;
1784 struct stream_struct *streams;
1785 int num_snapshots;
1786 char **snapshots = NULL;
1787 unsigned int i;
1788 NTSTATUS status;
1789
1790 status = cli_qpathinfo_alt_name(cli, name, altname);
1791 if (!NT_STATUS_IS_OK(status)) {
1792 d_printf("%s getting alt name for %s\n", nt_errstr(status),
1793 name);
1794 /*
1795 * Ignore not supported or not implemented, it does not
1796 * hurt if we can't list alternate names.
1797 */
1798 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED) ||
1799 NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
1800 altname[0] = '\0';
1801 } else {
1802 return false;
1803 }
1804 }
1805 d_printf("altname: %s\n", altname);
1806
1807 status = cli_qpathinfo3(cli, name, &b_time, &a_time, &m_time, &c_time,
1808 &size, &mode, NULL);
1809 if (!NT_STATUS_IS_OK(status)) {
1810 d_printf("%s getting pathinfo for %s\n", nt_errstr(status),
1811 name);
1812 return false;
1813 }
1814
1815 tmp = unix_timespec_to_nt_time(b_time);
1816 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp));
1817
1818 tmp = unix_timespec_to_nt_time(a_time);
1819 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp));
1820
1821 tmp = unix_timespec_to_nt_time(m_time);
1822 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp));
1823
1824 tmp = unix_timespec_to_nt_time(c_time);
1825 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp));
1826
1827 d_printf("attributes: %s (%x)\n", attr_str(talloc_tos(), mode), mode);
1828
1829 status = cli_qpathinfo_streams(cli, name, talloc_tos(), &num_streams,
1830 &streams);
1831 if (!NT_STATUS_IS_OK(status)) {
1832 d_printf("%s getting streams for %s\n", nt_errstr(status),
1833 name);
1834 return false;
1835 }
1836
1837 for (i=0; i<num_streams; i++) {
1838 d_printf("stream: [%s], %lld bytes\n", streams[i].name,
1839 (unsigned long long)streams[i].size);
1840 }
1841
1842 if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
1843 char *subst, *print;
1844 uint32_t flags;
1845
1846 status = cli_readlink(cli, name, talloc_tos(), &subst, &print,
1847 &flags);
1848 if (!NT_STATUS_IS_OK(status)) {
1849 d_fprintf(stderr, "cli_readlink returned %s\n",
1850 nt_errstr(status));
1851 } else {
1852 d_printf("symlink: subst=[%s], print=[%s], flags=%x\n",
1853 subst, print, flags);
1854 TALLOC_FREE(subst);
1855 TALLOC_FREE(print);
1856 }
1857 }
1858
1859 status = cli_ntcreate(cli, name, 0,
1860 SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE |
1861 SEC_STD_SYNCHRONIZE, 0,
1862 FILE_SHARE_READ|FILE_SHARE_WRITE
1863 |FILE_SHARE_DELETE,
1864 FILE_OPEN, 0x0, 0x0, &fnum, NULL);
1865 if (!NT_STATUS_IS_OK(status)) {
1866 /*
1867 * Ignore failure, it does not hurt if we can't list
1868 * snapshots
1869 */
1870 return 0;
1871 }
1872 /*
1873 * In order to get shadow copy data over SMB1 we
1874 * must call twice, once with 'get_names = false'
1875 * to get the size, then again with 'get_names = true'
1876 * to get the data or a Windows server fails to return
1877 * valid info. Samba doesn't have this bug. JRA.
1878 */
1879
1880 status = cli_shadow_copy_data(talloc_tos(), cli, fnum,
1881 false, &snapshots, &num_snapshots);
1882 if (!NT_STATUS_IS_OK(status)) {
1883 cli_close(cli, fnum);
1884 return 0;
1885 }
1886 status = cli_shadow_copy_data(talloc_tos(), cli, fnum,
1887 true, &snapshots, &num_snapshots);
1888 if (!NT_STATUS_IS_OK(status)) {
1889 cli_close(cli, fnum);
1890 return 0;
1891 }
1892
1893 for (i=0; i<num_snapshots; i++) {
1894 char *snap_name;
1895
1896 d_printf("%s\n", snapshots[i]);
1897 snap_name = talloc_asprintf(talloc_tos(), "%s%s",
1898 snapshots[i], name);
1899 status = cli_qpathinfo3(cli, snap_name, &b_time, &a_time,
1900 &m_time, &c_time, &size,
1901 NULL, NULL);
1902 if (!NT_STATUS_IS_OK(status)) {
1903 d_fprintf(stderr, "pathinfo(%s) failed: %s\n",
1904 snap_name, nt_errstr(status));
1905 TALLOC_FREE(snap_name);
1906 continue;
1907 }
1908 tmp = unix_timespec_to_nt_time(b_time);
1909 d_printf("create_time: %s\n", nt_time_string(talloc_tos(), tmp));
1910 tmp = unix_timespec_to_nt_time(a_time);
1911 d_printf("access_time: %s\n", nt_time_string(talloc_tos(), tmp));
1912 tmp =unix_timespec_to_nt_time(m_time);
1913 d_printf("write_time: %s\n", nt_time_string(talloc_tos(), tmp));
1914 tmp = unix_timespec_to_nt_time(c_time);
1915 d_printf("change_time: %s\n", nt_time_string(talloc_tos(), tmp));
1916 d_printf("size: %d\n", (int)size);
1917 }
1918
1919 TALLOC_FREE(snapshots);
1920 cli_close(cli, fnum);
1921
1922 return 0;
1923 }
1924
1925 /****************************************************************************
1926 Show all info we can get
1927 ****************************************************************************/
1928
1929 static int cmd_allinfo(void)
1930 {
1931 TALLOC_CTX *ctx = talloc_tos();
1932 char *name;
1933 char *buf;
1934
1935 name = talloc_strdup(ctx, client_get_cur_dir());
1936 if (!name) {
1937 return 1;
1938 }
1939
1940 if (!next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
1941 d_printf("allinfo <file>\n");
1942 return 1;
1943 }
1944 name = talloc_asprintf_append(name, "%s", buf);
1945 if (!name) {
1946 return 1;
1947 }
1948 name = client_clean_name(ctx, name);
1949 if (name == NULL) {
1950 return 1;
1951 }
1952 do_allinfo(name);
1953
1954 return 0;
1955 }
1956
1957 /****************************************************************************
1958 Put a single file.
1959 ****************************************************************************/
1960
1961 static int do_put(const char *rname, const char *lname, bool reput)
1962 {
1963 TALLOC_CTX *ctx = talloc_tos();
1964 uint16_t fnum;
1965 FILE *f;
1966 off_t start = 0;
1967 int rc = 0;
1968 struct timespec tp_start;
1969 struct cli_state *targetcli;
1970 char *targetname = NULL;
1971 struct push_state state;
1972 NTSTATUS status;
1973
1974 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
1975 cli, rname, &targetcli, &targetname);
1976 if (!NT_STATUS_IS_OK(status)) {
1977 d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
1978 return 1;
1979 }
1980
1981 clock_gettime_mono(&tp_start);
1982
1983 if (reput) {
1984 status = cli_open(targetcli, targetname, O_RDWR|O_CREAT, DENY_NONE, &fnum);
1985 if (NT_STATUS_IS_OK(status)) {
1986 if (!NT_STATUS_IS_OK(status = cli_qfileinfo_basic(
1987 targetcli, fnum, NULL,
1988 &start, NULL, NULL,
1989 NULL, NULL, NULL)) &&
1990 !NT_STATUS_IS_OK(status = cli_getattrE(
1991 targetcli, fnum, NULL,
1992 &start, NULL, NULL,
1993 NULL))) {
1994 d_printf("getattrib: %s\n", nt_errstr(status));
1995 return 1;
1996 }
1997 }
1998 } else {
1999 status = cli_open(targetcli, targetname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE, &fnum);
2000 }
2001
2002 if (!NT_STATUS_IS_OK(status)) {
2003 d_printf("%s opening remote file %s\n", nt_errstr(status),
2004 rname);
2005 return 1;
2006 }
2007
2008 /* allow files to be piped into smbclient
2009 jdblair 24.jun.98
2010
2011 Note that in this case this function will exit(0) rather
2012 than returning. */
2013 if (!strcmp(lname, "-")) {
2014 f = stdin;
2015 /* size of file is not known */
2016 } else {
2017 f = fopen(lname, "r");
2018 if (f && reput) {
2019 if (fseek(f, start, SEEK_SET) == -1) {
2020 d_printf("Error seeking local file\n");
2021 fclose(f);
2022 return 1;
2023 }
2024 }
2025 }
2026
2027 if (!f) {
2028 d_printf("Error opening local file %s\n",lname);
2029 return 1;
2030 }
2031
2032 DEBUG(1,("putting file %s as %s ",lname,
2033 rname));
2034
2035 setvbuf(f, NULL, _IOFBF, io_bufsize);
2036
2037 state.f = f;
2038 state.nread = 0;
2039
2040 status = cli_push(targetcli, fnum, 0, 0, io_bufsize, push_source,
2041 &state);
2042 if (!NT_STATUS_IS_OK(status)) {
2043 d_fprintf(stderr, "cli_push returned %s\n", nt_errstr(status));
2044 rc = 1;
2045 }
2046
2047 status = cli_close(targetcli, fnum);
2048 if (!NT_STATUS_IS_OK(status)) {
2049 d_printf("%s closing remote file %s\n", nt_errstr(status),
2050 rname);
2051 if (f != stdin) {
2052 fclose(f);
2053 }
2054 return 1;
2055 }
2056
2057 if (f != stdin) {
2058 fclose(f);
2059 }
2060
2061 {
2062 struct timespec tp_end;
2063 int this_time;
2064
2065 clock_gettime_mono(&tp_end);
2066 this_time = nsec_time_diff(&tp_end,&tp_start)/1000000;
2067 put_total_time_ms += this_time;
2068 put_total_size += state.nread;
2069
2070 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
2071 state.nread / (1.024*this_time + 1.0e-4),
2072 put_total_size / (1.024*put_total_time_ms)));
2073 }
2074
2075 if (f == stdin) {
2076 cli_shutdown(cli);
2077 popt_free_cmdline_auth_info();
2078 exit(rc);
2079 }
2080
2081 return rc;
2082 }
2083
2084 /****************************************************************************
2085 Put a file.
2086 ****************************************************************************/
2087
2088 static int cmd_put(void)
2089 {
2090 TALLOC_CTX *ctx = talloc_tos();
2091 char *lname;
2092 char *rname;
2093 char *buf;
2094
2095 rname = talloc_strdup(ctx, client_get_cur_dir());
2096 if (!rname) {
2097 return 1;
2098 }
2099
2100 if (!next_token_talloc(ctx, &cmd_ptr,&lname,NULL)) {
2101 d_printf("put <filename>\n");
2102 return 1;
2103 }
2104
2105 if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2106 rname = talloc_asprintf_append(rname, "%s", buf);
2107 } else {
2108 rname = talloc_asprintf_append(rname, "%s", lname);
2109 }
2110 if (!rname) {
2111 return 1;
2112 }
2113
2114 rname = client_clean_name(ctx, rname);
2115 if (!rname) {
2116 return 1;
2117 }
2118
2119 {
2120 SMB_STRUCT_STAT st;
2121 /* allow '-' to represent stdin
2122 jdblair, 24.jun.98 */
2123 if (!file_exist_stat(lname, &st, false) &&
2124 (strcmp(lname,"-"))) {
2125 d_printf("%s does not exist\n",lname);
2126 return 1;
2127 }
2128 }
2129
2130 return do_put(rname, lname, false);
2131 }
2132
2133 /*************************************
2134 File list structure.
2135 *************************************/
2136
2137 static struct file_list {
2138 struct file_list *prev, *next;
2139 char *file_path;
2140 bool isdir;
2141 } *file_list;
2142
2143 /****************************************************************************
2144 Free a file_list structure.
2145 ****************************************************************************/
2146
2147 static void free_file_list (struct file_list *l_head)
2148 {
2149 struct file_list *list, *next;
2150
2151 for (list = l_head; list; list = next) {
2152 next = list->next;
2153 DLIST_REMOVE(l_head, list);
2154 TALLOC_FREE(list);
2155 }
2156 }
2157
2158 /****************************************************************************
2159 Seek in a directory/file list until you get something that doesn't start with
2160 the specified name.
2161 ****************************************************************************/
2162
2163 static bool seek_list(struct file_list *list, char *name)
2164 {
2165 while (list) {
2166 trim_string(list->file_path,"./","\n");
2167 if (strncmp(list->file_path, name, strlen(name)) != 0) {
2168 return true;
2169 }
2170 list = list->next;
2171 }
2172
2173 return false;
2174 }
2175
2176 /****************************************************************************
2177 Set the file selection mask.
2178 ****************************************************************************/
2179
2180 static int cmd_select(void)
2181 {
2182 TALLOC_CTX *ctx = talloc_tos();
2183 char *new_fs = NULL;
2184 next_token_talloc(ctx, &cmd_ptr,&new_fs,NULL)
2185 ;
2186 if (new_fs) {
2187 client_set_fileselection(new_fs);
2188 } else {
2189 client_set_fileselection("");
2190 }
2191 return 0;
2192 }
2193
2194 /****************************************************************************
2195 Recursive file matching function act as find
2196 match must be always set to true when calling this function
2197 ****************************************************************************/
2198
2199 static int file_find(TALLOC_CTX *ctx,
2200 struct file_list **list,
2201 const char *directory,
2202 const char *expression,
2203 bool match)
2204 {
2205 DIR *dir;
2206 struct file_list *entry;
2207 struct stat statbuf;
2208 int ret;
2209 char *path;
2210 bool isdir;
2211 const char *dname;
2212
2213 dir = opendir(directory);
2214 if (!dir)
2215 return -1;
2216
2217 while ((dname = readdirname(dir))) {
2218 if (!strcmp("..", dname))
2219 continue;
2220 if (!strcmp(".", dname))
2221 continue;
2222
2223 path = talloc_asprintf(ctx, "%s/%s", directory, dname);
2224 if (path == NULL) {
2225 continue;
2226 }
2227
2228 isdir = false;
2229 if (!match || !gen_fnmatch(expression, dname)) {
2230 if (recurse) {
2231 ret = stat(path, &statbuf);
2232 if (ret == 0) {
2233 if (S_ISDIR(statbuf.st_mode)) {
2234 isdir = true;
2235 ret = file_find(ctx,
2236 list,
2237 path,
2238 expression,
2239 false);
2240 }
2241 } else {
2242 d_printf("file_find: cannot stat file %s\n", path);
2243 }
2244
2245 if (ret == -1) {
2246 TALLOC_FREE(path);
2247 closedir(dir);
2248 return -1;
2249 }
2250 }
2251 entry = talloc_zero(ctx, struct file_list);
2252 if (!entry) {
2253 d_printf("Out of memory in file_find\n");
2254 closedir(dir);
2255 return -1;
2256 }
2257 entry->file_path = talloc_move(entry, &path);
2258 entry->isdir = isdir;
2259 DLIST_ADD(*list, entry);
2260 } else {
2261 TALLOC_FREE(path);
2262 }
2263 }
2264
2265 closedir(dir);
2266 return 0;
2267 }
2268
2269 /****************************************************************************
2270 mput some files.
2271 ****************************************************************************/
2272
2273 static int cmd_mput(void)
2274 {
2275 TALLOC_CTX *ctx = talloc_tos();
2276 char *p = NULL;
2277
2278 while (next_token_talloc(ctx, &cmd_ptr,&p,NULL)) {
2279 int ret;
2280 struct file_list *temp_list;
2281 char *quest, *lname, *rname;
2282
2283 file_list = NULL;
2284
2285 ret = file_find(ctx, &file_list, ".", p, true);
2286 if (ret) {
2287 free_file_list(file_list);
2288 continue;
2289 }
2290
2291 quest = NULL;
2292 lname = NULL;
2293 rname = NULL;
2294
2295 for (temp_list = file_list; temp_list;
2296 temp_list = temp_list->next) {
2297
2298 SAFE_FREE(lname);
2299 if (asprintf(&lname, "%s/", temp_list->file_path) <= 0) {
2300 continue;
2301 }
2302 trim_string(lname, "./", "/");
2303
2304 /* check if it's a directory */
2305 if (temp_list->isdir) {
2306 /* if (!recurse) continue; */
2307
2308 SAFE_FREE(quest);
2309 if (asprintf(&quest, "Put directory %s? ", lname) < 0) {
2310 break;
2311 }
2312 if (prompt && !yesno(quest)) { /* No */
2313 /* Skip the directory */
2314 lname[strlen(lname)-1] = '/';
2315 if (!seek_list(temp_list, lname))
2316 break;
2317 } else { /* Yes */
2318 SAFE_FREE(rname);
2319 if(asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
2320 break;
2321 }
2322 normalize_name(rname);
2323 {
2324 char *tmp_rname =
2325 client_clean_name(ctx, rname);
2326 if (tmp_rname == NULL) {
2327 break;
2328 }
2329 SAFE_FREE(rname);
2330 rname = smb_xstrdup(tmp_rname);
2331 TALLOC_FREE(tmp_rname);
2332 if (rname == NULL) {
2333 break;
2334 }
2335 }
2336 if (!NT_STATUS_IS_OK(cli_chkpath(cli, rname)) &&
2337 !do_mkdir(rname)) {
2338 DEBUG (0, ("Unable to make dir, skipping..."));
2339 /* Skip the directory */
2340 lname[strlen(lname)-1] = '/';
2341 if (!seek_list(temp_list, lname)) {
2342 break;
2343 }
2344 }
2345 }
2346 continue;
2347 } else {
2348 SAFE_FREE(quest);
2349 if (asprintf(&quest,"Put file %s? ", lname) < 0) {
2350 break;
2351 }
2352 if (prompt && !yesno(quest)) {
2353 /* No */
2354 continue;
2355 }
2356
2357 /* Yes */
2358 SAFE_FREE(rname);
2359 if (asprintf(&rname, "%s%s", client_get_cur_dir(), lname) < 0) {
2360 break;
2361 }
2362 }
2363
2364 normalize_name(rname);
2365
2366 {
2367 char *tmp_rname = client_clean_name(ctx, rname);
2368 if (tmp_rname == NULL) {
2369 break;
2370 }
2371 SAFE_FREE(rname);
2372 rname = smb_xstrdup(tmp_rname);
2373 TALLOC_FREE(tmp_rname);
2374 if (rname == NULL) {
2375 break;
2376 }
2377 }
2378 do_put(rname, lname, false);
2379 }
2380 free_file_list(file_list);
2381 SAFE_FREE(quest);
2382 SAFE_FREE(lname);
2383 SAFE_FREE(rname);
2384 }
2385
2386 return 0;
2387 }
2388
2389 /****************************************************************************
2390 Cancel a print job.
2391 ****************************************************************************/
2392
2393 static int do_cancel(int job)
2394 {
2395 if (cli_printjob_del(cli, job)) {
2396 d_printf("Job %d cancelled\n",job);
2397 return 0;
2398 } else {
2399 NTSTATUS status = cli_nt_error(cli);
2400 d_printf("Error cancelling job %d : %s\n",
2401 job, nt_errstr(status));
2402 return 1;
2403 }
2404 }
2405
2406 /****************************************************************************
2407 Cancel a print job.
2408 ****************************************************************************/
2409
2410 static int cmd_cancel(void)
2411 {
2412 TALLOC_CTX *ctx = talloc_tos();
2413 char *buf = NULL;
2414 int job;
2415
2416 if (!next_token_talloc(ctx, &cmd_ptr, &buf,NULL)) {
2417 d_printf("cancel <jobid> ...\n");
2418 return 1;
2419 }
2420 do {
2421 job = atoi(buf);
2422 do_cancel(job);
2423 } while (next_token_talloc(ctx, &cmd_ptr,&buf,NULL));
2424
2425 return 0;
2426 }
2427
2428 /****************************************************************************
2429 Print a file.
2430 ****************************************************************************/
2431
2432 static int cmd_print(void)
2433 {
2434 TALLOC_CTX *ctx = talloc_tos();
2435 char *lname = NULL;
2436 char *rname = NULL;
2437 char *p = NULL;
2438
2439 if (!next_token_talloc(ctx, &cmd_ptr, &lname,NULL)) {
2440 d_printf("print <filename>\n");
2441 return 1;
2442 }
2443
2444 rname = talloc_strdup(ctx, lname);
2445 if (!rname) {
2446 return 1;
2447 }
2448 p = strrchr_m(rname,'/');
2449 if (p) {
2450 rname = talloc_asprintf(ctx,
2451 "%s-%d",
2452 p+1,
2453 (int)getpid());
2454 }
2455 if (strequal(lname,"-")) {
2456 rname = talloc_asprintf(ctx,
2457 "stdin-%d",
2458 (int)getpid());
2459 }
2460 if (!rname) {
2461 return 1;
2462 }
2463
2464 return do_put(rname, lname, false);
2465 }
2466
2467 /****************************************************************************
2468 Show a print queue entry.
2469 ****************************************************************************/
2470
2471 static void queue_fn(struct print_job_info *p)
2472 {
2473 d_printf("%-6d %-9d %s\n", (int)p->id, (int)p->size, p->name);
2474 }
2475
2476 /****************************************************************************
2477 Show a print queue.
2478 ****************************************************************************/
2479
2480 static int cmd_queue(void)
2481 {
2482 cli_print_queue(cli, queue_fn);
2483 return 0;
2484 }
2485
2486 /****************************************************************************
2487 Delete some files.
2488 ****************************************************************************/
2489
2490 static NTSTATUS do_del(struct cli_state *cli_state, struct file_info *finfo,
2491 const char *dir)
2492 {
2493 TALLOC_CTX *ctx = talloc_tos();
2494 char *mask = NULL;
2495 NTSTATUS status;
2496
2497 mask = talloc_asprintf(ctx,
2498 "%s%c%s",
2499 dir,
2500 CLI_DIRSEP_CHAR,
2501 finfo->name);
2502 if (!mask) {
2503 return NT_STATUS_NO_MEMORY;
2504 }
2505
2506 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
2507 TALLOC_FREE(mask);
2508 return NT_STATUS_OK;
2509 }
2510
2511 status = cli_unlink(cli_state, mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2512 if (!NT_STATUS_IS_OK(status)) {
2513 d_printf("%s deleting remote file %s\n",
2514 nt_errstr(status), mask);
2515 }
2516 TALLOC_FREE(mask);
2517 return status;
2518 }
2519
2520 /****************************************************************************
2521 Delete some files.
2522 ****************************************************************************/
2523
2524 static int cmd_del(void)
2525 {
2526 TALLOC_CTX *ctx = talloc_tos();
2527 char *mask = NULL;
2528 char *buf = NULL;
2529 NTSTATUS status = NT_STATUS_OK;
2530 uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
2531
2532 if (recurse) {
2533 attribute |= FILE_ATTRIBUTE_DIRECTORY;
2534 }
2535
2536 mask = talloc_strdup(ctx, client_get_cur_dir());
2537 if (!mask) {
2538 return 1;
2539 }
2540 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2541 d_printf("del <filename>\n");
2542 return 1;
2543 }
2544 mask = talloc_asprintf_append(mask, "%s", buf);
2545 if (!mask) {
2546 return 1;
2547 }
2548 mask = client_clean_name(ctx, mask);
2549 if (mask == NULL) {
2550 return 1;
2551 }
2552
2553 status = do_list(mask,attribute,do_del,false,false);
2554 if (!NT_STATUS_IS_OK(status)) {
2555 return 1;
2556 }
2557 return 0;
2558 }
2559
2560 /****************************************************************************
2561 Delete some files.
2562 ****************************************************************************/
2563
2564 static NTSTATUS delete_remote_files_list(struct cli_state *cli_state,
2565 struct file_list *flist)
2566 {
2567 NTSTATUS status = NT_STATUS_OK;
2568 struct file_list *deltree_list_iter = NULL;
2569
2570 for (deltree_list_iter = flist;
2571 deltree_list_iter != NULL;
2572 deltree_list_iter = deltree_list_iter->next) {
2573 if (CLI_DIRSEP_CHAR == '/') {
2574 /* POSIX. */
2575 status = cli_posix_unlink(cli_state,
2576 deltree_list_iter->file_path);
2577 } else if (deltree_list_iter->isdir) {
2578 status = cli_rmdir(cli_state,
2579 deltree_list_iter->file_path);
2580 } else {
2581 status = cli_unlink(cli_state,
2582 deltree_list_iter->file_path,
2583 FILE_ATTRIBUTE_SYSTEM |
2584 FILE_ATTRIBUTE_HIDDEN);
2585 }
2586 if (!NT_STATUS_IS_OK(status)) {
2587 d_printf("%s deleting remote %s %s\n",
2588 nt_errstr(status),
2589 deltree_list_iter->isdir ?
2590 "directory" : "file",
2591 deltree_list_iter->file_path);
2592 return status;
2593 }
2594 }
2595 return NT_STATUS_OK;
2596 }
2597
2598 /****************************************************************************
2599 Save a list of files to delete.
2600 ****************************************************************************/
2601
2602 static struct file_list *deltree_list_head;
2603
2604 static NTSTATUS do_deltree_list(struct cli_state *cli_state,
2605 struct file_info *finfo,
2606 const char *dir)
2607 {
2608 struct file_list **file_list_head_pp = &deltree_list_head;
2609 struct file_list *dt = NULL;
2610
2611 if (!do_this_one(finfo)) {
2612 return NT_STATUS_OK;
2613 }
2614
2615 /* skip if this is . or .. */
2616 if (ISDOT(finfo->name) || ISDOTDOT(finfo->name)) {
2617 return NT_STATUS_OK;
2618 }
2619
2620 dt = talloc_zero(NULL, struct file_list);
2621 if (dt == NULL) {
2622 return NT_STATUS_NO_MEMORY;
2623 }
2624
2625 /* create absolute filename for cli_ntcreate() */
2626 dt->file_path = talloc_asprintf(dt,
2627 "%s%s%s",
2628 dir,
2629 CLI_DIRSEP_STR,
2630 finfo->name);
2631 if (dt->file_path == NULL) {
2632 TALLOC_FREE(dt);
2633 return NT_STATUS_NO_MEMORY;
2634 }
2635
2636 if (finfo->mode & FILE_ATTRIBUTE_DIRECTORY) {
2637 dt->isdir = true;
2638 }
2639
2640 DLIST_ADD(*file_list_head_pp, dt);
2641 return NT_STATUS_OK;
2642 }
2643
2644 static int cmd_deltree(void)
2645 {
2646 TALLOC_CTX *ctx = talloc_tos();
2647 char *buf = NULL;
2648 NTSTATUS status = NT_STATUS_OK;
2649 struct file_list *deltree_list_norecurse = NULL;
2650 struct file_list *deltree_list_iter = NULL;
2651 uint16_t attribute = FILE_ATTRIBUTE_SYSTEM |
2652 FILE_ATTRIBUTE_HIDDEN |
2653 FILE_ATTRIBUTE_DIRECTORY;
2654 bool ok;
2655 char *mask = talloc_strdup(ctx, client_get_cur_dir());
2656 if (mask == NULL) {
2657 return 1;
2658 }
2659 ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
2660 if (!ok) {
2661 d_printf("deltree <filename>\n");
2662 return 1;
2663 }
2664 mask = talloc_asprintf_append(mask, "%s", buf);
2665 if (mask == NULL) {
2666 return 1;
2667 }
2668 mask = client_clean_name(ctx, mask);
2669 if (mask == NULL) {
2670 return 1;
2671 }
2672
2673 deltree_list_head = NULL;
2674
2675 /*
2676 * Get the list of directories to
2677 * delete (in case mask has a wildcard).
2678 */
2679 status = do_list(mask, attribute, do_deltree_list, false, true);
2680 if (!NT_STATUS_IS_OK(status)) {
2681 goto err;
2682 }
2683 deltree_list_norecurse = deltree_list_head;
2684 deltree_list_head = NULL;
2685
2686 for (deltree_list_iter = deltree_list_norecurse;
2687 deltree_list_iter != NULL;
2688 deltree_list_iter = deltree_list_iter->next) {
2689
2690 if (deltree_list_iter->isdir == false) {
2691 /* Just a regular file. */
2692 if (CLI_DIRSEP_CHAR == '/') {
2693 /* POSIX. */
2694 status = cli_posix_unlink(cli,
2695 deltree_list_iter->file_path);
2696 } else {
2697 status = cli_unlink(cli,
2698 deltree_list_iter->file_path,
2699 FILE_ATTRIBUTE_SYSTEM |
2700 FILE_ATTRIBUTE_HIDDEN);
2701 }
2702 if (!NT_STATUS_IS_OK(status)) {
2703 goto err;
2704 }
2705 continue;
2706 }
2707
2708 /*
2709 * Get the list of files or directories to
2710 * delete in depth order.
2711 */
2712 status = do_list(deltree_list_iter->file_path,
2713 attribute,
2714 do_deltree_list,
2715 true,
2716 true);
2717 if (!NT_STATUS_IS_OK(status)) {
2718 goto err;
2719 }
2720 status = delete_remote_files_list(cli, deltree_list_head);
2721 free_file_list(deltree_list_head);
2722 deltree_list_head = NULL;
2723 if (!NT_STATUS_IS_OK(status)) {
2724 goto err;
2725 }
2726 }
2727
2728 free_file_list(deltree_list_norecurse);
2729 free_file_list(deltree_list_head);
2730 return 0;
2731
2732 err:
2733
2734 free_file_list(deltree_list_norecurse);
2735 free_file_list(deltree_list_head);
2736 deltree_list_head = NULL;
2737 return 1;
2738 }
2739
2740
2741 /****************************************************************************
2742 Wildcard delete some files.
2743 ****************************************************************************/
2744
2745 static int cmd_wdel(void)
2746 {
2747 TALLOC_CTX *ctx = talloc_tos();
2748 char *mask = NULL;
2749 char *buf = NULL;
2750 uint16_t attribute;
2751 struct cli_state *targetcli;
2752 char *targetname = NULL;
2753 NTSTATUS status;
2754
2755 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2756 d_printf("wdel 0x<attrib> <wcard>\n");
2757 return 1;
2758 }
2759
2760 attribute = (uint16_t)strtol(buf, (char **)NULL, 16);
2761
2762 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2763 d_printf("wdel 0x<attrib> <wcard>\n");
2764 return 1;
2765 }
2766
2767 mask = talloc_asprintf(ctx, "%s%s",
2768 client_get_cur_dir(),
2769 buf);
2770 if (!mask) {
2771 return 1;
2772 }
2773 mask = client_clean_name(ctx, mask);
2774 if (mask == NULL) {
2775 return 1;
2776 }
2777
2778 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
2779 cli, mask, &targetcli, &targetname);
2780 if (!NT_STATUS_IS_OK(status)) {
2781 d_printf("cmd_wdel %s: %s\n", mask, nt_errstr(status));
2782 return 1;
2783 }
2784
2785 status = cli_unlink(targetcli, targetname, attribute);
2786 if (!NT_STATUS_IS_OK(status)) {
2787 d_printf("%s deleting remote files %s\n", nt_errstr(status),
2788 targetname);
2789 }
2790 return 0;
2791 }
2792
2793 /****************************************************************************
2794 ****************************************************************************/
2795
2796 static int cmd_open(void)
2797 {
2798 TALLOC_CTX *ctx = talloc_tos();
2799 char *mask = NULL;
2800 char *buf = NULL;
2801 char *targetname = NULL;
2802 struct cli_state *targetcli;
2803 uint16_t fnum = (uint16_t)-1;
2804 NTSTATUS status;
2805
2806 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2807 d_printf("open <filename>\n");
2808 return 1;
2809 }
2810 mask = talloc_asprintf(ctx,
2811 "%s%s",
2812 client_get_cur_dir(),
2813 buf);
2814 if (!mask) {
2815 return 1;
2816 }
2817
2818 mask = client_clean_name(ctx, mask);
2819 if (mask == NULL) {
2820 return 1;
2821 }
2822
2823 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
2824 cli, mask, &targetcli, &targetname);
2825 if (!NT_STATUS_IS_OK(status)) {
2826 d_printf("open %s: %s\n", mask, nt_errstr(status));
2827 return 1;
2828 }
2829
2830 status = cli_ntcreate(targetcli, targetname, 0,
2831 FILE_READ_DATA|FILE_WRITE_DATA, 0,
2832 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
2833 0x0, 0x0, &fnum, NULL);
2834 if (!NT_STATUS_IS_OK(status)) {
2835 status = cli_ntcreate(targetcli, targetname, 0,
2836 FILE_READ_DATA, 0,
2837 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
2838 0x0, 0x0, &fnum, NULL);
2839 if (NT_STATUS_IS_OK(status)) {
2840 d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
2841 } else {
2842 d_printf("Failed to open file %s. %s\n",
2843 targetname, nt_errstr(status));
2844 }
2845 } else {
2846 d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
2847 }
2848 return 0;
2849 }
2850
2851 static int cmd_posix_encrypt(void)
2852 {
2853 TALLOC_CTX *ctx = talloc_tos();
2854 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
2855 char *domain = NULL;
2856 char *user = NULL;
2857 char *password = NULL;
2858 struct cli_credentials *creds = NULL;
2859 struct cli_credentials *lcreds = NULL;
2860
2861 if (next_token_talloc(ctx, &cmd_ptr, &domain, NULL)) {
2862
2863 if (!next_token_talloc(ctx, &cmd_ptr, &user, NULL)) {
2864 d_printf("posix_encrypt domain user password\n");
2865 return 1;
2866 }
2867
2868 if (!next_token_talloc(ctx, &cmd_ptr, &password, NULL)) {
2869 d_printf("posix_encrypt domain user password\n");
2870 return 1;
2871 }
2872
2873 lcreds = cli_session_creds_init(ctx,
2874 user,
2875 domain,
2876 NULL, /* realm */
2877 password,
2878 false, /* use_kerberos */
2879 false, /* fallback_after_kerberos */
2880 false, /* use_ccache */
2881 false); /* password_is_nt_hash */
2882 if (lcreds == NULL) {
2883 d_printf("cli_session_creds_init() failed.\n");
2884 return -1;
2885 }
2886 creds = lcreds;
2887 } else {
2888 bool auth_requested = false;
2889
2890 creds = get_cmdline_auth_info_creds(
2891 popt_get_cmdline_auth_info());
2892
2893 auth_requested = cli_credentials_authentication_requested(creds);
2894 if (!auth_requested) {
2895 d_printf("posix_encrypt domain user password\n");
2896 return 1;
2897 }
2898 }
2899
2900 status = cli_smb1_setup_encryption(cli, creds);
2901 /* gensec currently references the creds so we can't free them here */
2902 talloc_unlink(ctx, lcreds);
2903 if (!NT_STATUS_IS_OK(status)) {
2904 d_printf("posix_encrypt failed with error %s\n", nt_errstr(status));
2905 } else {
2906 d_printf("encryption on\n");
2907 smb_encrypt = true;
2908 }
2909
2910 return 0;
2911 }
2912
2913 /****************************************************************************
2914 ****************************************************************************/
2915
2916 static int cmd_posix_open(void)
2917 {
2918 TALLOC_CTX *ctx = talloc_tos();
2919 char *mask = NULL;
2920 char *buf = NULL;
2921 char *targetname = NULL;
2922 struct cli_state *targetcli;
2923 mode_t mode;
2924 uint16_t fnum;
2925 NTSTATUS status;
2926
2927 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2928 d_printf("posix_open <filename> 0<mode>\n");
2929 return 1;
2930 }
2931 mask = talloc_asprintf(ctx,
2932 "%s%s",
2933 client_get_cur_dir(),
2934 buf);
2935 if (!mask) {
2936 return 1;
2937 }
2938 mask = client_clean_name(ctx, mask);
2939 if (mask == NULL) {
2940 return 1;
2941 }
2942
2943 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2944 d_printf("posix_open <filename> 0<mode>\n");
2945 return 1;
2946 }
2947 mode = (mode_t)strtol(buf, (char **)NULL, 8);
2948
2949 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
2950 cli, mask, &targetcli, &targetname);
2951 if (!NT_STATUS_IS_OK(status)) {
2952 d_printf("posix_open %s: %s\n", mask, nt_errstr(status));
2953 return 1;
2954 }
2955
2956 status = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode,
2957 &fnum);
2958 if (!NT_STATUS_IS_OK(status)) {
2959 status = cli_posix_open(targetcli, targetname,
2960 O_CREAT|O_RDONLY, mode, &fnum);
2961 if (!NT_STATUS_IS_OK(status)) {
2962 d_printf("Failed to open file %s. %s\n", targetname,
2963 nt_errstr(status));
2964 } else {
2965 d_printf("posix_open file %s: for readonly fnum %d\n",
2966 targetname, fnum);
2967 }
2968 } else {
2969 d_printf("posix_open file %s: for read/write fnum %d\n",
2970 targetname, fnum);
2971 }
2972
2973 return 0;
2974 }
2975
2976 static int cmd_posix_mkdir(void)
2977 {
2978 TALLOC_CTX *ctx = talloc_tos();
2979 char *mask = NULL;
2980 char *buf = NULL;
2981 char *targetname = NULL;
2982 struct cli_state *targetcli;
2983 mode_t mode;
2984 NTSTATUS status;
2985
2986 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
2987 d_printf("posix_mkdir <filename> 0<mode>\n");
2988 return 1;
2989 }
2990 mask = talloc_asprintf(ctx,
2991 "%s%s",
2992 client_get_cur_dir(),
2993 buf);
2994 if (!mask) {
2995 return 1;
2996 }
2997 mask = client_clean_name(ctx, mask);
2998 if (mask == NULL) {
2999 return 1;
3000 }
3001
3002 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3003 d_printf("posix_mkdir <filename> 0<mode>\n");
3004 return 1;
3005 }
3006 mode = (mode_t)strtol(buf, (char **)NULL, 8);
3007
3008 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3009 cli, mask, &targetcli, &targetname);
3010 if (!NT_STATUS_IS_OK(status)) {
3011 d_printf("posix_mkdir %s: %s\n", mask, nt_errstr(status));
3012 return 1;
3013 }
3014
3015 status = cli_posix_mkdir(targetcli, targetname, mode);
3016 if (!NT_STATUS_IS_OK(status)) {
3017 d_printf("Failed to open file %s. %s\n",
3018 targetname, nt_errstr(status));
3019 } else {
3020 d_printf("posix_mkdir created directory %s\n", targetname);
3021 }
3022 return 0;
3023 }
3024
3025 static int cmd_posix_unlink(void)
3026 {
3027 TALLOC_CTX *ctx = talloc_tos();
3028 char *mask = NULL;
3029 char *buf = NULL;
3030 char *targetname = NULL;
3031 struct cli_state *targetcli;
3032 NTSTATUS status;
3033
3034 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3035 d_printf("posix_unlink <filename>\n");
3036 return 1;
3037 }
3038 mask = talloc_asprintf(ctx,
3039 "%s%s",
3040 client_get_cur_dir(),
3041 buf);
3042 if (!mask) {
3043 return 1;
3044 }
3045 mask = client_clean_name(ctx, mask);
3046 if (mask == NULL) {
3047 return 1;
3048 }
3049
3050 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3051 cli, mask, &targetcli, &targetname);
3052 if (!NT_STATUS_IS_OK(status)) {
3053 d_printf("posix_unlink %s: %s\n", mask, nt_errstr(status));
3054 return 1;
3055 }
3056
3057 status = cli_posix_unlink(targetcli, targetname);
3058 if (!NT_STATUS_IS_OK(status)) {
3059 d_printf("Failed to unlink file %s. %s\n",
3060 targetname, nt_errstr(status));
3061 } else {
3062 d_printf("posix_unlink deleted file %s\n", targetname);
3063 }
3064
3065 return 0;
3066 }
3067
3068 static int cmd_posix_rmdir(void)
3069 {
3070 TALLOC_CTX *ctx = talloc_tos();
3071 char *mask = NULL;
3072 char *buf = NULL;
3073 char *targetname = NULL;
3074 struct cli_state *targetcli;
3075 NTSTATUS status;
3076
3077 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3078 d_printf("posix_rmdir <filename>\n");
3079 return 1;
3080 }
3081 mask = talloc_asprintf(ctx,
3082 "%s%s",
3083 client_get_cur_dir(),
3084 buf);
3085 if (!mask) {
3086 return 1;
3087 }
3088 mask = client_clean_name(ctx, mask);
3089 if (mask == NULL) {
3090 return 1;
3091 }
3092
3093 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3094 cli, mask, &targetcli, &targetname);
3095 if (!NT_STATUS_IS_OK(status)) {
3096 d_printf("posix_rmdir %s: %s\n", mask, nt_errstr(status));
3097 return 1;
3098 }
3099
3100 status = cli_posix_rmdir(targetcli, targetname);
3101 if (!NT_STATUS_IS_OK(status)) {
3102 d_printf("Failed to unlink directory %s. %s\n",
3103 targetname, nt_errstr(status));
3104 } else {
3105 d_printf("posix_rmdir deleted directory %s\n", targetname);
3106 }
3107
3108 return 0;
3109 }
3110
3111 static int cmd_close(void)
3112 {
3113 TALLOC_CTX *ctx = talloc_tos();
3114 char *buf = NULL;
3115 int fnum;
3116 NTSTATUS status;
3117
3118 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3119 d_printf("close <fnum>\n");
3120 return 1;
3121 }
3122
3123 fnum = atoi(buf);
3124 /* We really should use the targetcli here.... */
3125 status = cli_close(cli, fnum);
3126 if (!NT_STATUS_IS_OK(status)) {
3127 d_printf("close %d: %s\n", fnum, nt_errstr(status));
3128 return 1;
3129 }
3130 return 0;
3131 }
3132
3133 static int cmd_posix(void)
3134 {
3135 TALLOC_CTX *ctx = talloc_tos();
3136 uint16_t major, minor;
3137 uint32_t caplow, caphigh;
3138 char *caps;
3139 NTSTATUS status;
3140
3141 if (!SERVER_HAS_UNIX_CIFS(cli)) {
3142 d_printf("Server doesn't support UNIX CIFS extensions.\n");
3143 return 1;
3144 }
3145
3146 status = cli_unix_extensions_version(cli, &major, &minor, &caplow,
3147 &caphigh);
3148 if (!NT_STATUS_IS_OK(status)) {
3149 d_printf("Can't get UNIX CIFS extensions version from "
3150 "server: %s\n", nt_errstr(status));
3151 return 1;
3152 }
3153
3154 d_printf("Server supports CIFS extensions %u.%u\n", (unsigned int)major, (unsigned int)minor);
3155
3156 caps = talloc_strdup(ctx, "");
3157 if (!caps) {
3158 return 1;
3159 }
3160 if (caplow & CIFS_UNIX_FCNTL_LOCKS_CAP) {
3161 caps = talloc_asprintf_append(caps, "locks ");
3162 if (!caps) {
3163 return 1;
3164 }
3165 }
3166 if (caplow & CIFS_UNIX_POSIX_ACLS_CAP) {
3167 caps = talloc_asprintf_append(caps, "acls ");
3168 if (!caps) {
3169 return 1;
3170 }
3171 }
3172 if (caplow & CIFS_UNIX_XATTTR_CAP) {
3173 caps = talloc_asprintf_append(caps, "eas ");
3174 if (!caps) {
3175 return 1;
3176 }
3177 }
3178 if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3179 caps = talloc_asprintf_append(caps, "pathnames ");
3180 if (!caps) {
3181 return 1;
3182 }
3183 }
3184 if (caplow & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP) {
3185 caps = talloc_asprintf_append(caps, "posix_path_operations ");
3186 if (!caps) {
3187 return 1;
3188 }
3189 }
3190 if (caplow & CIFS_UNIX_LARGE_READ_CAP) {
3191 caps = talloc_asprintf_append(caps, "large_read ");
3192 if (!caps) {
3193 return 1;
3194 }
3195 }
3196 if (caplow & CIFS_UNIX_LARGE_WRITE_CAP) {
3197 caps = talloc_asprintf_append(caps, "large_write ");
3198 if (!caps) {
3199 return 1;
3200 }
3201 }
3202 if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP) {
3203 caps = talloc_asprintf_append(caps, "posix_encrypt ");
3204 if (!caps) {
3205 return 1;
3206 }
3207 }
3208 if (caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP) {
3209 caps = talloc_asprintf_append(caps, "mandatory_posix_encrypt ");
3210 if (!caps) {
3211 return 1;
3212 }
3213 }
3214
3215 if (*caps && caps[strlen(caps)-1] == ' ') {
3216 caps[strlen(caps)-1] = '\0';
3217 }
3218
3219 d_printf("Server supports CIFS capabilities %s\n", caps);
3220
3221 status = cli_set_unix_extensions_capabilities(cli, major, minor,
3222 caplow, caphigh);
3223 if (!NT_STATUS_IS_OK(status)) {
3224 d_printf("Can't set UNIX CIFS extensions capabilities. %s.\n",
3225 nt_errstr(status));
3226 return 1;
3227 }
3228
3229 if (caplow & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3230 CLI_DIRSEP_CHAR = '/';
3231 *CLI_DIRSEP_STR = '/';
3232 client_set_cur_dir(CLI_DIRSEP_STR);
3233 }
3234
3235 return 0;
3236 }
3237
3238 static int cmd_lock(void)
3239 {
3240 TALLOC_CTX *ctx = talloc_tos();
3241 char *buf = NULL;
3242 uint64_t start, len;
3243 enum brl_type lock_type;
3244 int fnum;
3245 NTSTATUS status;
3246
3247 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3248 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
3249 return 1;
3250 }
3251 fnum = atoi(buf);
3252
3253 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3254 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
3255 return 1;
3256 }
3257
3258 if (*buf == 'r' || *buf == 'R') {
3259 lock_type = READ_LOCK;
3260 } else if (*buf == 'w' || *buf == 'W') {
3261 lock_type = WRITE_LOCK;
3262 } else {
3263 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
3264 return 1;
3265 }
3266
3267 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3268 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
3269 return 1;
3270 }
3271
3272 start = (uint64_t)strtol(buf, (char **)NULL, 16);
3273
3274 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3275 d_printf("lock <fnum> [r|w] <hex-start> <hex-len>\n");
3276 return 1;
3277 }
3278
3279 len = (uint64_t)strtol(buf, (char **)NULL, 16);
3280
3281 status = cli_posix_lock(cli, fnum, start, len, true, lock_type);
3282 if (!NT_STATUS_IS_OK(status)) {
3283 d_printf("lock failed %d: %s\n", fnum, nt_errstr(status));
3284 }
3285
3286 return 0;
3287 }
3288
3289 static int cmd_unlock(void)
3290 {
3291 TALLOC_CTX *ctx = talloc_tos();
3292 char *buf = NULL;
3293 uint64_t start, len;
3294 int fnum;
3295 NTSTATUS status;
3296
3297 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3298 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
3299 return 1;
3300 }
3301 fnum = atoi(buf);
3302
3303 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3304 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
3305 return 1;
3306 }
3307
3308 start = (uint64_t)strtol(buf, (char **)NULL, 16);
3309
3310 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3311 d_printf("unlock <fnum> <hex-start> <hex-len>\n");
3312 return 1;
3313 }
3314
3315 len = (uint64_t)strtol(buf, (char **)NULL, 16);
3316
3317 status = cli_posix_unlock(cli, fnum, start, len);
3318 if (!NT_STATUS_IS_OK(status)) {
3319 d_printf("unlock failed %d: %s\n", fnum, nt_errstr(status));
3320 }
3321
3322 return 0;
3323 }
3324
3325 static int cmd_posix_whoami(void)
3326 {
3327 TALLOC_CTX *ctx = talloc_tos();
3328 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
3329 uint64_t uid = 0;
3330 uint64_t gid = 0;
3331 uint32_t num_gids = 0;
3332 uint32_t num_sids = 0;
3333 uint64_t *gids = NULL;
3334 struct dom_sid *sids = NULL;
3335 bool guest = false;
3336 uint32_t i;
3337
3338 status = cli_posix_whoami(cli,
3339 ctx,
3340 &uid,
3341 &gid,
3342 &num_gids,
3343 &gids,
3344 &num_sids,
3345 &sids,
3346 &guest);
3347
3348 if (!NT_STATUS_IS_OK(status)) {
3349 d_printf("posix_whoami failed with error %s\n", nt_errstr(status));
3350 return 1;
3351 }
3352
3353 d_printf("GUEST:%s\n", guest ? "True" : "False");
3354 d_printf("UID:%" PRIu64 "\n", uid);
3355 d_printf("GID:%" PRIu64 "\n", gid);
3356 d_printf("NUM_GIDS:%" PRIu32 "\n", num_gids);
3357 for (i = 0; i < num_gids; i++) {
3358 d_printf("GIDS[%" PRIu32 "]:%" PRIu64 "\n", i, gids[i]);
3359 }
3360 d_printf("NUM_SIDS:%" PRIu32 "\n", num_sids);
3361 for (i = 0; i < num_sids; i++) {
3362 char *sid_str = dom_sid_string(ctx, &sids[i]);
3363 d_printf("SIDS[%" PRIu32 "]:%s\n", i, sid_str);
3364 TALLOC_FREE(sid_str);
3365 }
3366 return 0;
3367 }
3368
3369
3370 /****************************************************************************
3371 Remove a directory.
3372 ****************************************************************************/
3373
3374 static int cmd_rmdir(void)
3375 {
3376 TALLOC_CTX *ctx = talloc_tos();
3377 char *mask = NULL;
3378 char *buf = NULL;
3379 char *targetname = NULL;
3380 struct cli_state *targetcli;
3381 NTSTATUS status;
3382
3383 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3384 d_printf("rmdir <dirname>\n");
3385 return 1;
3386 }
3387 mask = talloc_asprintf(ctx,
3388 "%s%s",
3389 client_get_cur_dir(),
3390 buf);
3391 if (!mask) {
3392 return 1;
3393 }
3394 mask = client_clean_name(ctx, mask);
3395 if (mask == NULL) {
3396 return 1;
3397 }
3398
3399 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3400 cli, mask, &targetcli, &targetname);
3401 if (!NT_STATUS_IS_OK(status)) {
3402 d_printf("rmdir %s: %s\n", mask, nt_errstr(status));
3403 return 1;
3404 }
3405
3406 status = cli_rmdir(targetcli, targetname);
3407 if (!NT_STATUS_IS_OK(status)) {
3408 d_printf("%s removing remote directory file %s\n",
3409 nt_errstr(status), mask);
3410 }
3411
3412 return 0;
3413 }
3414
3415 /****************************************************************************
3416 UNIX hardlink.
3417 ****************************************************************************/
3418
3419 static int cmd_link(void)
3420 {
3421 TALLOC_CTX *ctx = talloc_tos();
3422 char *oldname = NULL;
3423 char *newname = NULL;
3424 char *buf = NULL;
3425 char *buf2 = NULL;
3426 char *targetname = NULL;
3427 struct cli_state *targetcli;
3428 NTSTATUS status;
3429
3430 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3431 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3432 d_printf("link <oldname> <newname>\n");
3433 return 1;
3434 }
3435 oldname = talloc_asprintf(ctx,
3436 "%s%s",
3437 client_get_cur_dir(),
3438 buf);
3439 if (!oldname) {
3440 return 1;
3441 }
3442 oldname = client_clean_name(ctx, oldname);
3443 if (oldname == NULL) {
3444 return 1;
3445 }
3446 newname = talloc_asprintf(ctx,
3447 "%s%s",
3448 client_get_cur_dir(),
3449 buf2);
3450 if (!newname) {
3451 return 1;
3452 }
3453 newname = client_clean_name(ctx, newname);
3454 if (newname == NULL) {
3455 return 1;
3456 }
3457
3458 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3459 cli, oldname, &targetcli, &targetname);
3460 if (!NT_STATUS_IS_OK(status)) {
3461 d_printf("link %s: %s\n", oldname, nt_errstr(status));
3462 return 1;
3463 }
3464
3465 if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3466 d_printf("Server doesn't support UNIX CIFS calls.\n");
3467 return 1;
3468 }
3469
3470 status = cli_posix_hardlink(targetcli, targetname, newname);
3471 if (!NT_STATUS_IS_OK(status)) {
3472 d_printf("%s linking files (%s -> %s)\n",
3473 nt_errstr(status), newname, oldname);
3474 return 1;
3475 }
3476 return 0;
3477 }
3478
3479 /****************************************************************************
3480 UNIX readlink.
3481 ****************************************************************************/
3482
3483 static int cmd_readlink(void)
3484 {
3485 TALLOC_CTX *ctx = talloc_tos();
3486 char *name= NULL;
3487 char *buf = NULL;
3488 char *targetname = NULL;
3489 char linkname[PATH_MAX+1];
3490 struct cli_state *targetcli;
3491 NTSTATUS status;
3492
3493 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
3494 d_printf("readlink <name>\n");
3495 return 1;
3496 }
3497 name = talloc_asprintf(ctx,
3498 "%s%s",
3499 client_get_cur_dir(),
3500 buf);
3501 if (!name) {
3502 return 1;
3503 }
3504 name = client_clean_name(ctx, name);
3505 if (name == NULL) {
3506 return 1;
3507 }
3508
3509 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3510 cli, name, &targetcli, &targetname);
3511 if (!NT_STATUS_IS_OK(status)) {
3512 d_printf("readlink %s: %s\n", name, nt_errstr(status));
3513 return 1;
3514 }
3515
3516 if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3517 d_printf("Server doesn't support UNIX CIFS calls.\n");
3518 return 1;
3519 }
3520
3521 status = cli_posix_readlink(targetcli, name, linkname, PATH_MAX+1);
3522 if (!NT_STATUS_IS_OK(status)) {
3523 d_printf("%s readlink on file %s\n",
3524 nt_errstr(status), name);
3525 return 1;
3526 }
3527
3528 d_printf("%s -> %s\n", name, linkname);
3529
3530 return 0;
3531 }
3532
3533
3534 /****************************************************************************
3535 UNIX symlink.
3536 ****************************************************************************/
3537
3538 static int cmd_symlink(void)
3539 {
3540 TALLOC_CTX *ctx = talloc_tos();
3541 char *link_target = NULL;
3542 char *newname = NULL;
3543 char *buf = NULL;
3544 char *buf2 = NULL;
3545 struct cli_state *newcli;
3546 NTSTATUS status;
3547
3548 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3549 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3550 d_printf("symlink <link_target> <newname>\n");
3551 return 1;
3552 }
3553 /* Oldname (link target) must be an untouched blob. */
3554 link_target = buf;
3555
3556 if (SERVER_HAS_UNIX_CIFS(cli)) {
3557 newname = talloc_asprintf(ctx, "%s%s", client_get_cur_dir(),
3558 buf2);
3559 if (!newname) {
3560 return 1;
3561 }
3562 newname = client_clean_name(ctx, newname);
3563 if (newname == NULL) {
3564 return 1;
3565 }
3566 /* New name must be present in share namespace. */
3567 status = cli_resolve_path(ctx, "",
3568 popt_get_cmdline_auth_info(), cli, newname,
3569 &newcli, &newname);
3570 if (!NT_STATUS_IS_OK(status)) {
3571 d_printf("link %s: %s\n", newname,
3572 nt_errstr(status));
3573 return 1;
3574 }
3575 status = cli_posix_symlink(newcli, link_target, newname);
3576 } else {
3577 status = cli_symlink(
3578 cli, link_target, buf2,
3579 buf2[0] == '\\' ? 0 : SYMLINK_FLAG_RELATIVE);
3580 }
3581
3582 if (!NT_STATUS_IS_OK(status)) {
3583 d_printf("%s symlinking files (%s -> %s)\n",
3584 nt_errstr(status), newname, link_target);
3585 return 1;
3586 }
3587
3588 return 0;
3589 }
3590
3591 /****************************************************************************
3592 UNIX chmod.
3593 ****************************************************************************/
3594
3595 static int cmd_chmod(void)
3596 {
3597 TALLOC_CTX *ctx = talloc_tos();
3598 char *src = NULL;
3599 char *buf = NULL;
3600 char *buf2 = NULL;
3601 char *targetname = NULL;
3602 struct cli_state *targetcli;
3603 mode_t mode;
3604 NTSTATUS status;
3605
3606 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
3607 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
3608 d_printf("chmod mode file\n");
3609 return 1;
3610 }
3611 src = talloc_asprintf(ctx,
3612 "%s%s",
3613 client_get_cur_dir(),
3614 buf2);
3615 if (!src) {
3616 return 1;
3617 }
3618 src = client_clean_name(ctx, src);
3619 if (src == NULL) {
3620 return 1;
3621 }
3622
3623 mode = (mode_t)strtol(buf, NULL, 8);
3624
3625 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3626 cli, src, &targetcli, &targetname);
3627 if (!NT_STATUS_IS_OK(status)) {
3628 d_printf("chmod %s: %s\n", src, nt_errstr(status));
3629 return 1;
3630 }
3631
3632 if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3633 d_printf("Server doesn't support UNIX CIFS calls.\n");
3634 return 1;
3635 }
3636
3637 status = cli_posix_chmod(targetcli, targetname, mode);
3638 if (!NT_STATUS_IS_OK(status)) {
3639 d_printf("%s chmod file %s 0%o\n",
3640 nt_errstr(status), src, (unsigned int)mode);
3641 return 1;
3642 }
3643
3644 return 0;
3645 }
3646
3647 static const char *filetype_to_str(mode_t mode)
3648 {
3649 if (S_ISREG(mode)) {
3650 return "regular file";
3651 } else if (S_ISDIR(mode)) {
3652 return "directory";
3653 } else
3654 #ifdef S_ISCHR
3655 if (S_ISCHR(mode)) {
3656 return "character device";
3657 } else
3658 #endif
3659 #ifdef S_ISBLK
3660 if (S_ISBLK(mode)) {
3661 return "block device";
3662 } else
3663 #endif
3664 #ifdef S_ISFIFO
3665 if (S_ISFIFO(mode)) {
3666 return "fifo";
3667 } else
3668 #endif
3669 #ifdef S_ISLNK
3670 if (S_ISLNK(mode)) {
3671 return "symbolic link";
3672 } else
3673 #endif
3674 #ifdef S_ISSOCK
3675 if (S_ISSOCK(mode)) {
3676 return "socket";
3677 } else
3678 #endif
3679 return "";
3680 }
3681
3682 static char rwx_to_str(mode_t m, mode_t bt, char ret)
3683 {
3684 if (m & bt) {
3685 return ret;
3686 } else {
3687 return '-';
3688 }
3689 }
3690
3691 static char *unix_mode_to_str(char *s, mode_t m)
3692 {
3693 char *p = s;
3694 const char *str = filetype_to_str(m);
3695
3696 switch(str[0]) {
3697 case 'd':
3698 *p++ = 'd';
3699 break;
3700 case 'c':
3701 *p++ = 'c';
3702 break;
3703 case 'b':
3704 *p++ = 'b';
3705 break;
3706 case 'f':
3707 *p++ = 'p';
3708 break;
3709 case 's':
3710 *p++ = str[1] == 'y' ? 'l' : 's';
3711 break;
3712 case 'r':
3713 default:
3714 *p++ = '-';
3715 break;
3716 }
3717 *p++ = rwx_to_str(m, S_IRUSR, 'r');
3718 *p++ = rwx_to_str(m, S_IWUSR, 'w');
3719 *p++ = rwx_to_str(m, S_IXUSR, 'x');
3720 *p++ = rwx_to_str(m, S_IRGRP, 'r');
3721 *p++ = rwx_to_str(m, S_IWGRP, 'w');
3722 *p++ = rwx_to_str(m, S_IXGRP, 'x');
3723 *p++ = rwx_to_str(m, S_IROTH, 'r');
3724 *p++ = rwx_to_str(m, S_IWOTH, 'w');
3725 *p++ = rwx_to_str(m, S_IXOTH, 'x');
3726 *p++ = '\0';
3727 return s;
3728 }
3729
3730 /****************************************************************************
3731 Utility function for UNIX getfacl.
3732 ****************************************************************************/
3733
3734 static char *perms_to_string(fstring permstr, unsigned char perms)
3735 {
3736 fstrcpy(permstr, "---");
3737 if (perms & SMB_POSIX_ACL_READ) {
3738 permstr[0] = 'r';
3739 }
3740 if (perms & SMB_POSIX_ACL_WRITE) {
3741 permstr[1] = 'w';
3742 }
3743 if (perms & SMB_POSIX_ACL_EXECUTE) {
3744 permstr[2] = 'x';
3745 }
3746 return permstr;
3747 }
3748
3749 /****************************************************************************
3750 UNIX getfacl.
3751 ****************************************************************************/
3752
3753 static int cmd_getfacl(void)
3754 {
3755 TALLOC_CTX *ctx = talloc_tos();
3756 char *src = NULL;
3757 char *name = NULL;
3758 char *targetname = NULL;
3759 struct cli_state *targetcli;
3760 uint16_t major, minor;
3761 uint32_t caplow, caphigh;
3762 char *retbuf = NULL;
3763 size_t rb_size = 0;
3764 SMB_STRUCT_STAT sbuf;
3765 uint16_t num_file_acls = 0;
3766 uint16_t num_dir_acls = 0;
3767 uint16_t i;
3768 NTSTATUS status;
3769
3770 if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
3771 d_printf("getfacl filename\n");
3772 return 1;
3773 }
3774 src = talloc_asprintf(ctx,
3775 "%s%s",
3776 client_get_cur_dir(),
3777 name);
3778 if (!src) {
3779 return 1;
3780 }
3781 src = client_clean_name(ctx, src);
3782 if (src == NULL) {
3783 return 1;
3784 }
3785
3786 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3787 cli, src, &targetcli, &targetname);
3788 if (!NT_STATUS_IS_OK(status)) {
3789 d_printf("stat %s: %s\n", src, nt_errstr(status));
3790 return 1;
3791 }
3792
3793 if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
3794 d_printf("Server doesn't support UNIX CIFS calls.\n");
3795 return 1;
3796 }
3797
3798 status = cli_unix_extensions_version(targetcli, &major, &minor,
3799 &caplow, &caphigh);
3800 if (!NT_STATUS_IS_OK(status)) {
3801 d_printf("Can't get UNIX CIFS version from server: %s.\n",
3802 nt_errstr(status));
3803 return 1;
3804 }
3805
3806 if (!(caplow & CIFS_UNIX_POSIX_ACLS_CAP)) {
3807 d_printf("This server supports UNIX extensions "
3808 "but doesn't support POSIX ACLs.\n");
3809 return 1;
3810 }
3811
3812 status = cli_posix_stat(targetcli, targetname, &sbuf);
3813 if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli, targetname, &sbuf))) {
3814 d_printf("%s getfacl doing a stat on file %s\n",
3815 nt_errstr(status), src);
3816 return 1;
3817 }
3818
3819 status = cli_posix_getacl(targetcli, targetname, ctx, &rb_size, &retbuf);
3820 if (!NT_STATUS_IS_OK(status)) {
3821 d_printf("%s getfacl file %s\n",
3822 nt_errstr(status), src);
3823 return 1;
3824 }
3825
3826 /* ToDo : Print out the ACL values. */
3827 if (rb_size < 6 || SVAL(retbuf,0) != SMB_POSIX_ACL_VERSION) {
3828 d_printf("getfacl file %s, unknown POSIX acl version %u.\n",
3829 src, (unsigned int)CVAL(retbuf,0) );
3830 return 1;
3831 }
3832
3833 num_file_acls = SVAL(retbuf,2);
3834 num_dir_acls = SVAL(retbuf,4);
3835 if (rb_size != SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)) {
3836 d_printf("getfacl file %s, incorrect POSIX acl buffer size (should be %u, was %u).\n",
3837 src,
3838 (unsigned int)(SMB_POSIX_ACL_HEADER_SIZE + SMB_POSIX_ACL_ENTRY_SIZE*(num_file_acls+num_dir_acls)),
3839 (unsigned int)rb_size);
3840 return 1;
3841 }
3842
3843 d_printf("# file: %s\n", src);
3844 d_printf("# owner: %u\n# group: %u\n", (unsigned int)sbuf.st_ex_uid, (unsigned int)sbuf.st_ex_gid);
3845
3846 if (num_file_acls == 0 && num_dir_acls == 0) {
3847 d_printf("No acls found.\n");
3848 }
3849
3850 for (i = 0; i < num_file_acls; i++) {
3851 uint32_t uorg;
3852 fstring permstring;
3853 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE));
3854 unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+1);
3855
3856 switch(tagtype) {
3857 case SMB_POSIX_ACL_USER_OBJ:
3858 d_printf("user::");
3859 break;
3860 case SMB_POSIX_ACL_USER:
3861 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3862 d_printf("user:%u:", uorg);
3863 break;
3864 case SMB_POSIX_ACL_GROUP_OBJ:
3865 d_printf("group::");
3866 break;
3867 case SMB_POSIX_ACL_GROUP:
3868 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3869 d_printf("group:%u:", uorg);
3870 break;
3871 case SMB_POSIX_ACL_MASK:
3872 d_printf("mask::");
3873 break;
3874 case SMB_POSIX_ACL_OTHER:
3875 d_printf("other::");
3876 break;
3877 default:
3878 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3879 src, (unsigned int)tagtype );
3880 SAFE_FREE(retbuf);
3881 return 1;
3882 }
3883
3884 d_printf("%s\n", perms_to_string(permstring, perms));
3885 }
3886
3887 for (i = 0; i < num_dir_acls; i++) {
3888 uint32_t uorg;
3889 fstring permstring;
3890 unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE));
3891 unsigned char perms = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+1);
3892
3893 switch(tagtype) {
3894 case SMB_POSIX_ACL_USER_OBJ:
3895 d_printf("default:user::");
3896 break;
3897 case SMB_POSIX_ACL_USER:
3898 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3899 d_printf("default:user:%u:", uorg);
3900 break;
3901 case SMB_POSIX_ACL_GROUP_OBJ:
3902 d_printf("default:group::");
3903 break;
3904 case SMB_POSIX_ACL_GROUP:
3905 uorg = IVAL(retbuf,SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE)+2);
3906 d_printf("default:group:%u:", uorg);
3907 break;
3908 case SMB_POSIX_ACL_MASK:
3909 d_printf("default:mask::");
3910 break;
3911 case SMB_POSIX_ACL_OTHER:
3912 d_printf("default:other::");
3913 break;
3914 default:
3915 d_printf("getfacl file %s, incorrect POSIX acl tagtype (%u).\n",
3916 src, (unsigned int)tagtype );
3917 SAFE_FREE(retbuf);
3918 return 1;
3919 }
3920
3921 d_printf("%s\n", perms_to_string(permstring, perms));
3922 }
3923
3924 return 0;
3925 }
3926
3927 /****************************************************************************
3928 Get the EA list of a file
3929 ****************************************************************************/
3930
3931 static int cmd_geteas(void)
3932 {
3933 TALLOC_CTX *ctx = talloc_tos();
3934 char *src = NULL;
3935 char *name = NULL;
3936 char *targetname = NULL;
3937 struct cli_state *targetcli;
3938 NTSTATUS status;
3939 size_t i, num_eas;
3940 struct ea_struct *eas;
3941
3942 if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
3943 d_printf("geteas filename\n");
3944 return 1;
3945 }
3946 src = talloc_asprintf(ctx,
3947 "%s%s",
3948 client_get_cur_dir(),
3949 name);
3950 if (!src) {
3951 return 1;
3952 }
3953 src = client_clean_name(ctx, src);
3954 if (src == NULL) {
3955 return 1;
3956 }
3957
3958 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
3959 cli, src, &targetcli, &targetname);
3960 if (!NT_STATUS_IS_OK(status)) {
3961 d_printf("stat %s: %s\n", src, nt_errstr(status));
3962 return 1;
3963 }
3964
3965 status = cli_get_ea_list_path(targetcli, targetname, talloc_tos(),
3966 &num_eas, &eas);
3967 if (!NT_STATUS_IS_OK(status)) {
3968 d_printf("cli_get_ea_list_path: %s\n", nt_errstr(status));
3969 return 1;
3970 }
3971
3972 for (i=0; i<num_eas; i++) {
3973 d_printf("%s (%d) =\n", eas[i].name, (int)eas[i].flags);
3974 dump_data_file(eas[i].value.data, eas[i].value.length, false,
3975 stdout);
3976 d_printf("\n");
3977 }
3978
3979 TALLOC_FREE(eas);
3980
3981 return 0;
3982 }
3983
3984 /****************************************************************************
3985 Set an EA of a file
3986 ****************************************************************************/
3987
3988 static int cmd_setea(void)
3989 {
3990 TALLOC_CTX *ctx = talloc_tos();
3991 char *src = NULL;
3992 char *name = NULL;
3993 char *eaname = NULL;
3994 char *eavalue = NULL;
3995 char *targetname = NULL;
3996 struct cli_state *targetcli;
3997 NTSTATUS status;
3998
3999 if (!next_token_talloc(ctx, &cmd_ptr, &name, NULL)
4000 || !next_token_talloc(ctx, &cmd_ptr, &eaname, NULL)) {
4001 d_printf("setea filename eaname value\n");
4002 return 1;
4003 }
4004 if (!next_token_talloc(ctx, &cmd_ptr, &eavalue, NULL)) {
4005 eavalue = talloc_strdup(ctx, "");
4006 }
4007 src = talloc_asprintf(ctx,
4008 "%s%s",
4009 client_get_cur_dir(),
4010 name);
4011 if (!src) {
4012 return 1;
4013 }
4014 src = client_clean_name(ctx, src);
4015 if (src == NULL) {
4016 return 1;
4017 }
4018
4019 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4020 cli, src, &targetcli, &targetname);
4021 if (!NT_STATUS_IS_OK(status)) {
4022 d_printf("stat %s: %s\n", src, nt_errstr(status));
4023 return 1;
4024 }
4025
4026 status = cli_set_ea_path(targetcli, targetname, eaname, eavalue,
4027 strlen(eavalue));
4028 if (!NT_STATUS_IS_OK(status)) {
4029 d_printf("set_ea %s: %s\n", src, nt_errstr(status));
4030 return 1;
4031 }
4032
4033 return 0;
4034 }
4035
4036 /****************************************************************************
4037 UNIX stat.
4038 ****************************************************************************/
4039
4040 static int cmd_stat(void)
4041 {
4042 TALLOC_CTX *ctx = talloc_tos();
4043 char *src = NULL;
4044 char *name = NULL;
4045 char *targetname = NULL;
4046 struct cli_state *targetcli;
4047 fstring mode_str;
4048 SMB_STRUCT_STAT sbuf;
4049 struct tm *lt;
4050 time_t tmp_time;
4051 NTSTATUS status;
4052
4053 if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
4054 d_printf("stat file\n");
4055 return 1;
4056 }
4057 src = talloc_asprintf(ctx,
4058 "%s%s",
4059 client_get_cur_dir(),
4060 name);
4061 if (!src) {
4062 return 1;
4063 }
4064 src = client_clean_name(ctx, src);
4065 if (src == NULL) {
4066 return 1;
4067 }
4068
4069 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4070 cli, src, &targetcli, &targetname);
4071 if (!NT_STATUS_IS_OK(status)) {
4072 d_printf("stat %s: %s\n", src, nt_errstr(status));
4073 return 1;
4074 }
4075
4076 if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
4077 d_printf("Server doesn't support UNIX CIFS calls.\n");
4078 return 1;
4079 }
4080
4081 status = cli_posix_stat(targetcli, targetname, &sbuf);
4082 if (!NT_STATUS_IS_OK(status)) {
4083 d_printf("%s stat file %s\n",
4084 nt_errstr(status), src);
4085 return 1;
4086 }
4087
4088 /* Print out the stat values. */
4089 d_printf("File: %s\n", src);
4090 d_printf("Size: %-12.0f\tBlocks: %u\t%s\n",
4091 (double)sbuf.st_ex_size,
4092 (unsigned int)sbuf.st_ex_blocks,
4093 filetype_to_str(sbuf.st_ex_mode));
4094
4095 #if defined(S_ISCHR) && defined(S_ISBLK)
4096 if (S_ISCHR(sbuf.st_ex_mode) || S_ISBLK(sbuf.st_ex_mode)) {
4097 d_printf("Inode: %.0f\tLinks: %u\tDevice type: %u,%u\n",
4098 (double)sbuf.st_ex_ino,
4099 (unsigned int)sbuf.st_ex_nlink,
4100 unix_dev_major(sbuf.st_ex_rdev),
4101 unix_dev_minor(sbuf.st_ex_rdev));
4102 } else
4103 #endif
4104 d_printf("Inode: %.0f\tLinks: %u\n",
4105 (double)sbuf.st_ex_ino,
4106 (unsigned int)sbuf.st_ex_nlink);
4107
4108 d_printf("Access: (0%03o/%s)\tUid: %u\tGid: %u\n",
4109 ((int)sbuf.st_ex_mode & 0777),
4110 unix_mode_to_str(mode_str, sbuf.st_ex_mode),
4111 (unsigned int)sbuf.st_ex_uid,
4112 (unsigned int)sbuf.st_ex_gid);
4113
4114 tmp_time = convert_timespec_to_time_t(sbuf.st_ex_atime);
4115 lt = localtime(&tmp_time);
4116 if (lt) {
4117 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
4118 } else {
4119 fstrcpy(mode_str, "unknown");
4120 }
4121 d_printf("Access: %s\n", mode_str);
4122
4123 tmp_time = convert_timespec_to_time_t(sbuf.st_ex_mtime);
4124 lt = localtime(&tmp_time);
4125 if (lt) {
4126 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
4127 } else {
4128 fstrcpy(mode_str, "unknown");
4129 }
4130 d_printf("Modify: %s\n", mode_str);
4131
4132 tmp_time = convert_timespec_to_time_t(sbuf.st_ex_ctime);
4133 lt = localtime(&tmp_time);
4134 if (lt) {
4135 strftime(mode_str, sizeof(mode_str), "%Y-%m-%d %T %z", lt);
4136 } else {
4137 fstrcpy(mode_str, "unknown");
4138 }
4139 d_printf("Change: %s\n", mode_str);
4140
4141 return 0;
4142 }
4143
4144
4145 /****************************************************************************
4146 UNIX chown.
4147 ****************************************************************************/
4148
4149 static int cmd_chown(void)
4150 {
4151 TALLOC_CTX *ctx = talloc_tos();
4152 char *src = NULL;
4153 uid_t uid;
4154 gid_t gid;
4155 char *buf, *buf2, *buf3;
4156 struct cli_state *targetcli;
4157 char *targetname = NULL;
4158 NTSTATUS status;
4159
4160 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
4161 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL) ||
4162 !next_token_talloc(ctx, &cmd_ptr,&buf3,NULL)) {
4163 d_printf("chown uid gid file\n");
4164 return 1;
4165 }
4166
4167 uid = (uid_t)atoi(buf);
4168 gid = (gid_t)atoi(buf2);
4169
4170 src = talloc_asprintf(ctx,
4171 "%s%s",
4172 client_get_cur_dir(),
4173 buf3);
4174 if (!src) {
4175 return 1;
4176 }
4177 src = client_clean_name(ctx, src);
4178 if (src == NULL) {
4179 return 1;
4180 }
4181 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4182 cli, src, &targetcli, &targetname);
4183 if (!NT_STATUS_IS_OK(status)) {
4184 d_printf("chown %s: %s\n", src, nt_errstr(status));
4185 return 1;
4186 }
4187
4188 if (!SERVER_HAS_UNIX_CIFS(targetcli)) {
4189 d_printf("Server doesn't support UNIX CIFS calls.\n");
4190 return 1;
4191 }
4192
4193 status = cli_posix_chown(targetcli, targetname, uid, gid);
4194 if (!NT_STATUS_IS_OK(status)) {
4195 d_printf("%s chown file %s uid=%d, gid=%d\n",
4196 nt_errstr(status), src, (int)uid, (int)gid);
4197 return 1;
4198 }
4199
4200 return 0;
4201 }
4202
4203 /****************************************************************************
4204 Rename some file.
4205 ****************************************************************************/
4206
4207 static int cmd_rename(void)
4208 {
4209 TALLOC_CTX *ctx = talloc_tos();
4210 char *src, *dest;
4211 char *buf, *buf2;
4212 struct cli_state *targetcli;
4213 char *targetsrc;
4214 char *targetdest;
4215 NTSTATUS status;
4216 bool replace = false;
4217
4218 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
4219 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
4220 d_printf("rename <src> <dest> [-f]\n");
4221 return 1;
4222 }
4223
4224 src = talloc_asprintf(ctx,
4225 "%s%s",
4226 client_get_cur_dir(),
4227 buf);
4228 if (!src) {
4229 return 1;
4230 }
4231 src = client_clean_name(ctx, src);
4232 if (src == NULL) {
4233 return 1;
4234 }
4235
4236 dest = talloc_asprintf(ctx,
4237 "%s%s",
4238 client_get_cur_dir(),
4239 buf2);
4240 if (!dest) {
4241 return 1;
4242 }
4243 dest = client_clean_name(ctx, dest);
4244 if (dest == NULL) {
4245 return 1;
4246 }
4247
4248 if (next_token_talloc(ctx, &cmd_ptr, &buf, NULL) &&
4249 strcsequal(buf, "-f")) {
4250 replace = true;
4251 }
4252
4253 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4254 cli, src, &targetcli, &targetsrc);
4255 if (!NT_STATUS_IS_OK(status)) {
4256 d_printf("rename %s: %s\n", src, nt_errstr(status));
4257 return 1;
4258 }
4259
4260 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4261 cli, dest, &targetcli, &targetdest);
4262 if (!NT_STATUS_IS_OK(status)) {
4263 d_printf("rename %s: %s\n", dest, nt_errstr(status));
4264 return 1;
4265 }
4266
4267 status = cli_rename(targetcli, targetsrc, targetdest, replace);
4268 if (!NT_STATUS_IS_OK(status)) {
4269 d_printf("%s renaming files %s -> %s \n",
4270 nt_errstr(status),
4271 targetsrc,
4272 targetdest);
4273 return 1;
4274 }
4275
4276 return 0;
4277 }
4278
4279 struct scopy_timing {
4280 struct timespec tp_start;
4281 };
4282
4283 static int scopy_status(off_t written, void *priv)
4284 {
4285 struct timespec tp_end;
4286 unsigned int scopy_total_time_ms;
4287 struct scopy_timing *st = priv;
4288
4289 clock_gettime_mono(&tp_end);
4290 scopy_total_time_ms = nsec_time_diff(&tp_end,&st->tp_start)/1000000;
4291
4292 DEBUG(5,("Copied %jd bytes at an average %3.1f kb/s\n",
4293 (intmax_t)written, written / (1.024*scopy_total_time_ms)));
4294
4295 return true;
4296 }
4297
4298 /****************************************************************************
4299 Server-Side copy some file.
4300 ****************************************************************************/
4301
4302 static int cmd_scopy(void)
4303 {
4304 TALLOC_CTX *ctx = talloc_tos();
4305 char *src, *dest;
4306 char *buf, *buf2;
4307 struct cli_state *targetcli;
4308 char *targetsrc;
4309 char *targetdest;
4310 uint32_t DesiredAccess, ShareAccess, CreateDisposition, CreateOptions;
4311 struct smb_create_returns cr;
4312 uint16_t destfnum = (uint16_t)-1;
4313 uint16_t srcfnum = (uint16_t)-1;
4314 off_t written = 0;
4315 struct scopy_timing st;
4316 int rc = 0;
4317 NTSTATUS status;
4318
4319 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
4320 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
4321 d_printf("scopy <src> <dest>\n");
4322 return 1;
4323 }
4324
4325 src = talloc_asprintf(ctx,
4326 "%s%s",
4327 client_get_cur_dir(),
4328 buf);
4329 if (!src) {
4330 return 1;
4331 }
4332 src = client_clean_name(ctx, src);
4333 if (src == NULL) {
4334 return 1;
4335 }
4336
4337 dest = talloc_asprintf(ctx,
4338 "%s%s",
4339 client_get_cur_dir(),
4340 buf2);
4341 if (!dest) {
4342 return 1;
4343 }
4344 dest = client_clean_name(ctx, dest);
4345 if (dest == NULL) {
4346 return 1;
4347 }
4348
4349 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4350 cli, src, &targetcli, &targetsrc);
4351 if (!NT_STATUS_IS_OK(status)) {
4352 d_printf("scopy %s: %s\n", src, nt_errstr(status));
4353 return 1;
4354 }
4355
4356 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4357 cli, dest, &targetcli, &targetdest);
4358 if (!NT_STATUS_IS_OK(status)) {
4359 d_printf("scopy %s: %s\n", dest, nt_errstr(status));
4360 return 1;
4361 }
4362
4363
4364 DesiredAccess = (FILE_READ_DATA|FILE_READ_EA|FILE_READ_ATTRIBUTES|
4365 READ_CONTROL_ACCESS|SYNCHRONIZE_ACCESS);
4366 ShareAccess = FILE_SHARE_READ|FILE_SHARE_DELETE;
4367 CreateDisposition = FILE_OPEN;
4368 CreateOptions = (FILE_SEQUENTIAL_ONLY|FILE_NON_DIRECTORY_FILE|
4369 FILE_OPEN_REPARSE_POINT);
4370 status = cli_ntcreate(targetcli, targetsrc, 0, DesiredAccess, 0,
4371 ShareAccess, CreateDisposition, CreateOptions, 0x0,
4372 &srcfnum, &cr);
4373 if (!NT_STATUS_IS_OK(status)) {
4374 d_printf("Failed to open file %s. %s\n",
4375 targetsrc, nt_errstr(status));
4376 return 1;
4377 }
4378
4379 DesiredAccess = (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_READ_EA|
4380 FILE_WRITE_EA|FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES|
4381 DELETE_ACCESS|READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|SYNCHRONIZE_ACCESS);
4382 ShareAccess = FILE_SHARE_NONE;
4383 CreateDisposition = FILE_CREATE;
4384 CreateOptions = FILE_SEQUENTIAL_ONLY|FILE_NON_DIRECTORY_FILE;
4385 status = cli_ntcreate(targetcli, targetdest, 0, DesiredAccess,
4386 FILE_ATTRIBUTE_ARCHIVE, ShareAccess, CreateDisposition,
4387 CreateOptions, 0x0, &destfnum, NULL);
4388 if (!NT_STATUS_IS_OK(status)) {
4389 d_printf("Failed to create file %s. %s\n",
4390 targetdest, nt_errstr(status));
4391 cli_close(targetcli, srcfnum);
4392 return 1;
4393 }
4394
4395 clock_gettime_mono(&st.tp_start);
4396 status = cli_splice(targetcli, targetcli, srcfnum, destfnum,
4397 cr.end_of_file, 0, 0, &written, scopy_status, &st);
4398 if (!NT_STATUS_IS_OK(status)) {
4399 d_printf("%s copying file %s -> %s \n",
4400 nt_errstr(status),
4401 targetsrc,
4402 targetdest);
4403 rc = 1;
4404 }
4405
4406 status = cli_close(targetcli, srcfnum);
4407 if (!NT_STATUS_IS_OK(status)) {
4408 d_printf("Error %s closing remote source file\n", nt_errstr(status));
4409 rc = 1;
4410 }
4411 status = cli_close(targetcli, destfnum);
4412 if (!NT_STATUS_IS_OK(status)) {
4413 d_printf("Error %s closing remote dest file\n", nt_errstr(status));
4414 rc = 1;
4415 }
4416
4417 return rc;
4418 }
4419
4420 /****************************************************************************
4421 Print the volume name.
4422 ****************************************************************************/
4423
4424 static int cmd_volume(void)
4425 {
4426 char *volname;
4427 uint32_t serial_num;
4428 time_t create_date;
4429 NTSTATUS status;
4430
4431 status = cli_get_fs_volume_info(cli, talloc_tos(),
4432 &volname, &serial_num,
4433 &create_date);
4434 if (!NT_STATUS_IS_OK(status)) {
4435 d_printf("Error %s getting volume info\n", nt_errstr(status));
4436 return 1;
4437 }
4438
4439 d_printf("Volume: |%s| serial number 0x%x\n",
4440 volname, (unsigned int)serial_num);
4441 return 0;
4442 }
4443
4444 /****************************************************************************
4445 Hard link files using the NT call.
4446 ****************************************************************************/
4447
4448 static int cmd_hardlink(void)
4449 {
4450 TALLOC_CTX *ctx = talloc_tos();
4451 char *src, *dest;
4452 char *buf, *buf2;
4453 struct cli_state *targetcli;
4454 char *targetname;
4455 NTSTATUS status;
4456
4457 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
4458 !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
4459 d_printf("hardlink <src> <dest>\n");
4460 return 1;
4461 }
4462
4463 src = talloc_asprintf(ctx,
4464 "%s%s",
4465 client_get_cur_dir(),
4466 buf);
4467 if (!src) {
4468 return 1;
4469 }
4470 src = client_clean_name(ctx, src);
4471 if (src == NULL) {
4472 return 1;
4473 }
4474
4475 dest = talloc_asprintf(ctx,
4476 "%s%s",
4477 client_get_cur_dir(),
4478 buf2);
4479 if (!dest) {
4480 return 1;
4481 }
4482 dest = client_clean_name(ctx, dest);
4483 if (dest == NULL) {
4484 return 1;
4485 }
4486
4487 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
4488 cli, src, &targetcli, &targetname);
4489 if (!NT_STATUS_IS_OK(status)) {
4490 d_printf("hardlink %s: %s\n", src, nt_errstr(status));
4491 return 1;
4492 }
4493
4494 status = cli_nt_hardlink(targetcli, targetname, dest);
4495 if (!NT_STATUS_IS_OK(status)) {
4496 d_printf("%s doing an NT hard link of files\n",
4497 nt_errstr(status));
4498 return 1;
4499 }
4500
4501 return 0;
4502 }
4503
4504 /****************************************************************************
4505 Toggle the prompt flag.
4506 ****************************************************************************/
4507
4508 static int cmd_prompt(void)
4509 {
4510 prompt = !prompt;
4511 DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
4512 return 1;
4513 }
4514
4515 /****************************************************************************
4516 Set the newer than time.
4517 ****************************************************************************/
4518
4519 static int cmd_newer(void)
4520 {
4521 TALLOC_CTX *ctx = talloc_tos();
4522 char *buf;
4523 bool ok;
4524 SMB_STRUCT_STAT sbuf;
4525
4526 ok = next_token_talloc(ctx, &cmd_ptr,&buf,NULL);
4527 if (ok && (sys_stat(buf, &sbuf, false) == 0)) {
4528 newer_than = convert_timespec_to_time_t(sbuf.st_ex_mtime);
4529 DEBUG(1,("Getting files newer than %s",
4530 time_to_asc(newer_than)));
4531 } else {
4532 newer_than = 0;
4533 }
4534
4535 if (ok && newer_than == 0) {
4536 d_printf("Error setting newer-than time\n");
4537 return 1;
4538 }
4539
4540 return 0;
4541 }
4542
4543 /****************************************************************************
4544 Watch directory changes
4545 ****************************************************************************/
4546
4547 static int cmd_notify(void)
4548 {
4549 TALLOC_CTX *frame = talloc_stackframe();
4550 char *name, *buf;
4551 NTSTATUS status;
4552 uint16_t fnum;
4553
4554 name = talloc_strdup(talloc_tos(), client_get_cur_dir());
4555 if (name == NULL) {
4556 goto fail;
4557 }
4558 if (!next_token_talloc(talloc_tos(), &cmd_ptr, &buf, NULL)) {
4559 goto usage;
4560 }
4561 name = talloc_asprintf_append(name, "%s", buf);
4562 if (name == NULL) {
4563 goto fail;
4564 }
4565 name = client_clean_name(talloc_tos(), name);
4566 if (name == NULL) {
4567 return 1;
4568 }
4569 status = cli_ntcreate(
4570 cli, name, 0, FILE_READ_DATA, 0,
4571 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
4572 FILE_OPEN, 0, 0, &fnum, NULL);
4573 if (!NT_STATUS_IS_OK(status)) {
4574 d_printf("Could not open file: %s\n", nt_errstr(status));
4575 goto fail;
4576 }
4577
4578 while (1) {
4579 uint32_t i;
4580 uint32_t num_changes = 0;
4581 struct notify_change *changes = NULL;
4582
4583 status = cli_notify(cli, fnum, 1000, FILE_NOTIFY_CHANGE_ALL,
4584 true,
4585 talloc_tos(), &num_changes, &changes);
4586 if (NT_STATUS_EQUAL(status, STATUS_NOTIFY_ENUM_DIR)) {
4587 printf("NOTIFY_ENUM_DIR\n");
4588 status = NT_STATUS_OK;
4589 }
4590 if (!NT_STATUS_IS_OK(status)) {
4591 d_printf("notify returned %s\n",
4592 nt_errstr(status));
4593 goto fail;
4594 }
4595 for (i=0; i<num_changes; i++) {
4596 printf("%4.4x %s\n", changes[i].action,
4597 changes[i].name);
4598 }
4599 TALLOC_FREE(changes);
4600 }
4601 usage:
4602 d_printf("notify <dir name>\n");
4603 fail:
4604 TALLOC_FREE(frame);
4605 return 1;
4606 }
4607
4608 /****************************************************************************
4609 Set the archive level.
4610 ****************************************************************************/
4611
4612 static int cmd_archive(void)
4613 {
4614 TALLOC_CTX *ctx = talloc_tos();
4615 char *buf;
4616
4617 if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4618 archive_level = atoi(buf);
4619 } else {
4620 d_printf("Archive level is %d\n",archive_level);
4621 }
4622
4623 return 0;
4624 }
4625
4626 /****************************************************************************
4627 Toggle the backup_intent state.
4628 ****************************************************************************/
4629
4630 static int cmd_backup(void)
4631 {
4632 backup_intent = !backup_intent;
4633 cli_set_backup_intent(cli, backup_intent);
4634 DEBUG(2,("backup intent is now %s\n",backup_intent?"on":"off"));
4635 return 1;
4636 }
4637
4638 /****************************************************************************
4639 Toggle the lowercaseflag.
4640 ****************************************************************************/
4641
4642 static int cmd_lowercase(void)
4643 {
4644 lowercase = !lowercase;
4645 DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
4646 return 0;
4647 }
4648
4649 /****************************************************************************
4650 Toggle the case sensitive flag.
4651 ****************************************************************************/
4652
4653 static int cmd_setcase(void)
4654 {
4655 bool orig_case_sensitive = cli_set_case_sensitive(cli, false);
4656
4657 cli_set_case_sensitive(cli, !orig_case_sensitive);
4658 DEBUG(2,("filename case sensitivity is now %s\n",!orig_case_sensitive ?
4659 "on":"off"));
4660 return 0;
4661 }
4662
4663 /****************************************************************************
4664 Toggle the showacls flag.
4665 ****************************************************************************/
4666
4667 static int cmd_showacls(void)
4668 {
4669 showacls = !showacls;
4670 DEBUG(2,("showacls is now %s\n",showacls?"on":"off"));
4671 return 0;
4672 }
4673
4674
4675 /****************************************************************************
4676 Toggle the recurse flag.
4677 ****************************************************************************/
4678
4679 static int cmd_recurse(void)
4680 {
4681 recurse = !recurse;
4682 DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
4683 return 0;
4684 }
4685
4686 /****************************************************************************
4687 Toggle the translate flag.
4688 ****************************************************************************/
4689
4690 static int cmd_translate(void)
4691 {
4692 translation = !translation;
4693 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
4694 translation?"on":"off"));
4695 return 0;
4696 }
4697
4698 /****************************************************************************
4699 Do the lcd command.
4700 ****************************************************************************/
4701
4702 static int cmd_lcd(void)
4703 {
4704 TALLOC_CTX *ctx = talloc_tos();
4705 char *buf;
4706 char *d;
4707
4708 if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4709 if (chdir(buf) == -1) {
4710 d_printf("chdir to %s failed (%s)\n",
4711 buf, strerror(errno));
4712 }
4713 }
4714 d = sys_getwd();
4715 if (!d) {
4716 return 1;
4717 }
4718 DEBUG(2,("the local directory is now %s\n",d));
4719 SAFE_FREE(d);
4720 return 0;
4721 }
4722
4723 /****************************************************************************
4724 Get a file restarting at end of local file.
4725 ****************************************************************************/
4726
4727 static int cmd_reget(void)
4728 {
4729 TALLOC_CTX *ctx = talloc_tos();
4730 char *local_name = NULL;
4731 char *remote_name = NULL;
4732 char *fname = NULL;
4733 char *p = NULL;
4734
4735 remote_name = talloc_strdup(ctx, client_get_cur_dir());
4736 if (!remote_name) {
4737 return 1;
4738 }
4739
4740 if (!next_token_talloc(ctx, &cmd_ptr, &fname, NULL)) {
4741 d_printf("reget <filename>\n");
4742 return 1;
4743 }
4744 remote_name = talloc_asprintf_append(remote_name, "%s", fname);
4745 if (!remote_name) {
4746 return 1;
4747 }
4748 remote_name = client_clean_name(ctx,remote_name);
4749 if (!remote_name) {
4750 return 1;
4751 }
4752
4753 local_name = fname;
4754 next_token_talloc(ctx, &cmd_ptr, &p, NULL);
4755 if (p) {
4756 local_name = p;
4757 }
4758
4759 return do_get(remote_name, local_name, true);
4760 }
4761
4762 /****************************************************************************
4763 Put a file restarting at end of local file.
4764 ****************************************************************************/
4765
4766 static int cmd_reput(void)
4767 {
4768 TALLOC_CTX *ctx = talloc_tos();
4769 char *local_name = NULL;
4770 char *remote_name = NULL;
4771 char *buf;
4772 SMB_STRUCT_STAT st;
4773
4774 remote_name = talloc_strdup(ctx, client_get_cur_dir());
4775 if (!remote_name) {
4776 return 1;
4777 }
4778
4779 if (!next_token_talloc(ctx, &cmd_ptr, &local_name, NULL)) {
4780 d_printf("reput <filename>\n");
4781 return 1;
4782 }
4783
4784 if (!file_exist_stat(local_name, &st, false)) {
4785 d_printf("%s does not exist\n", local_name);
4786 return 1;
4787 }
4788
4789 if (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
4790 remote_name = talloc_asprintf_append(remote_name,
4791 "%s", buf);
4792 } else {
4793 remote_name = talloc_asprintf_append(remote_name,
4794 "%s", local_name);
4795 }
4796 if (!remote_name) {
4797 return 1;
4798 }
4799
4800 remote_name = client_clean_name(ctx, remote_name);
4801 if (!remote_name) {
4802 return 1;
4803 }
4804
4805 return do_put(remote_name, local_name, true);
4806 }
4807
4808 /****************************************************************************
4809 List a share name.
4810 ****************************************************************************/
4811
4812 static void browse_fn(const char *name, uint32_t m,
4813 const char *comment, void *state)
4814 {
4815 const char *typestr = "";
4816
4817 switch (m & 7) {
4818 case STYPE_DISKTREE:
4819 typestr = "Disk";
4820 break;
4821 case STYPE_PRINTQ:
4822 typestr = "Printer";
4823 break;
4824 case STYPE_DEVICE:
4825 typestr = "Device";
4826 break;
4827 case STYPE_IPC:
4828 typestr = "IPC";
4829 break;
4830 }
4831 /* FIXME: If the remote machine returns non-ascii characters
4832 in any of these fields, they can corrupt the output. We
4833 should remove them. */
4834 if (!grepable) {
4835 d_printf("\t%-15s %-10.10s%s\n",
4836 name,typestr,comment);
4837 } else {
4838 d_printf ("%s|%s|%s\n",typestr,name,comment);
4839 }
4840 }
4841
4842 static bool browse_host_rpc(bool sort)
4843 {
4844 NTSTATUS status;
4845 struct rpc_pipe_client *pipe_hnd = NULL;
4846 TALLOC_CTX *frame = talloc_stackframe();
4847 WERROR werr;
4848 struct srvsvc_NetShareInfoCtr info_ctr;
4849 struct srvsvc_NetShareCtr1 ctr1;
4850 uint32_t resume_handle = 0;
4851 uint32_t total_entries = 0;
4852 int i;
4853 struct dcerpc_binding_handle *b;
4854
4855 status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc,
4856 &pipe_hnd);
4857
4858 if (!NT_STATUS_IS_OK(status)) {
4859 DEBUG(10, ("Could not connect to srvsvc pipe: %s\n",
4860 nt_errstr(status)));
4861 TALLOC_FREE(frame);
4862 return false;
4863 }
4864
4865 b = pipe_hnd->binding_handle;
4866
4867 ZERO_STRUCT(info_ctr);
4868 ZERO_STRUCT(ctr1);
4869
4870 info_ctr.level = 1;
4871 info_ctr.ctr.ctr1 = &ctr1;
4872
4873 status = dcerpc_srvsvc_NetShareEnumAll(b, frame,
4874 pipe_hnd->desthost,
4875 &info_ctr,
4876 0xffffffff,
4877 &total_entries,
4878 &resume_handle,
4879 &werr);
4880
4881 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(werr)) {
4882 TALLOC_FREE(pipe_hnd);
4883 TALLOC_FREE(frame);
4884 return false;
4885 }
4886
4887 for (i=0; i < info_ctr.ctr.ctr1->count; i++) {
4888 struct srvsvc_NetShareInfo1 info = info_ctr.ctr.ctr1->array[i];
4889 browse_fn(info.name, info.type, info.comment, NULL);
4890 }
4891
4892 TALLOC_FREE(pipe_hnd);
4893 TALLOC_FREE(frame);
4894 return true;
4895 }
4896
4897 /****************************************************************************
4898 Try and browse available connections on a host.
4899 ****************************************************************************/
4900
4901 static bool browse_host(bool sort)
4902 {
4903 int ret;
4904
4905 if (!grepable) {
4906 d_printf("\n\tSharename Type Comment\n");
4907 d_printf("\t--------- ---- -------\n");
4908 }
4909
4910 if (browse_host_rpc(sort)) {
4911 return true;
4912 }
4913
4914 if (lp_client_min_protocol() > PROTOCOL_NT1) {
4915 return false;
4916 }
4917
4918 ret = cli_RNetShareEnum(cli, browse_fn, NULL);
4919 if (ret == -1) {
4920 NTSTATUS status = cli_nt_error(cli);
4921 d_printf("Error returning browse list: %s\n",
4922 nt_errstr(status));
4923 }
4924
4925 return (ret != -1);
4926 }
4927
4928 /****************************************************************************
4929 List a server name.
4930 ****************************************************************************/
4931
4932 static void server_fn(const char *name, uint32_t m,
4933 const char *comment, void *state)
4934 {
4935
4936 if (!grepable){
4937 d_printf("\t%-16s %s\n", name, comment);
4938 } else {
4939 d_printf("%s|%s|%s\n",(char *)state, name, comment);
4940 }
4941 }
4942
4943 /****************************************************************************
4944 Try and browse available connections on a host.
4945 ****************************************************************************/
4946
4947 static bool list_servers(const char *wk_grp)
4948 {
4949 fstring state;
4950
4951 if (!cli->server_domain)
4952 return false;
4953
4954 if (!grepable) {
4955 d_printf("\n\tServer Comment\n");
4956 d_printf("\t--------- -------\n");
4957 };
4958 fstrcpy( state, "Server" );
4959 cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL, server_fn,
4960 state);
4961
4962 if (!grepable) {
4963 d_printf("\n\tWorkgroup Master\n");
4964 d_printf("\t--------- -------\n");
4965 };
4966
4967 fstrcpy( state, "Workgroup" );
4968 cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM,
4969 server_fn, state);
4970 return true;
4971 }
4972
4973 /****************************************************************************
4974 Print or set current VUID
4975 ****************************************************************************/
4976
4977 static int cmd_vuid(void)
4978 {
4979 TALLOC_CTX *ctx = talloc_tos();
4980 char *buf;
4981
4982 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
4983 d_printf("Current VUID is %d\n",
4984 cli_state_get_uid(cli));
4985 return 0;
4986 }
4987
4988 cli_state_set_uid(cli, atoi(buf));
4989 return 0;
4990 }
4991
4992 /****************************************************************************
4993 Setup a new VUID, by issuing a session setup
4994 ****************************************************************************/
4995
4996 static int cmd_logon(void)
4997 {
4998 TALLOC_CTX *ctx = talloc_tos();
4999 char *l_username, *l_password;
5000 struct cli_credentials *creds = NULL;
5001 NTSTATUS nt_status;
5002
5003 if (!next_token_talloc(ctx, &cmd_ptr,&l_username,NULL)) {
5004 d_printf("logon <username> [<password>]\n");
5005 return 0;
5006 }
5007
5008 if (!next_token_talloc(ctx, &cmd_ptr,&l_password,NULL)) {
5009 char pwd[256] = {0};
5010 int rc;
5011
5012 rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
5013 if (rc == 0) {
5014 l_password = talloc_strdup(ctx, pwd);
5015 }
5016 }
5017 if (!l_password) {
5018 return 1;
5019 }
5020
5021 creds = cli_session_creds_init(ctx,
5022 l_username,
5023 lp_workgroup(),
5024 NULL, /* realm */
5025 l_password,
5026 false, /* use_kerberos */
5027 false, /* fallback_after_kerberos */
5028 false, /* use_ccache */
5029 false); /* password_is_nt_hash */
5030 if (creds == NULL) {
5031 d_printf("cli_session_creds_init() failed.\n");
5032 return -1;
5033 }
5034 nt_status = cli_session_setup_creds(cli, creds);
5035 TALLOC_FREE(creds);
5036 if (!NT_STATUS_IS_OK(nt_status)) {
5037 d_printf("session setup failed: %s\n", nt_errstr(nt_status));
5038 return -1;
5039 }
5040
5041 d_printf("Current VUID is %d\n", cli_state_get_uid(cli));
5042 return 0;
5043 }
5044
5045 /**
5046 * close the session
5047 */
5048
5049 static int cmd_logoff(void)
5050 {
5051 NTSTATUS status;
5052
5053 status = cli_ulogoff(cli);
5054 if (!NT_STATUS_IS_OK(status)) {
5055 d_printf("logoff failed: %s\n", nt_errstr(status));
5056 return -1;
5057 }
5058
5059 d_printf("logoff successful\n");
5060 return 0;
5061 }
5062
5063
5064 /**
5065 * tree connect (connect to a share)
5066 */
5067
5068 static int cmd_tcon(void)
5069 {
5070 TALLOC_CTX *ctx = talloc_tos();
5071 char *sharename;
5072 NTSTATUS status;
5073
5074 if (!next_token_talloc(ctx, &cmd_ptr, &sharename, NULL)) {
5075 d_printf("tcon <sharename>\n");
5076 return 0;
5077 }
5078
5079 if (!sharename) {
5080 return 1;
5081 }
5082
5083 status = cli_tree_connect(cli, sharename, "?????", NULL);
5084 if (!NT_STATUS_IS_OK(status)) {
5085 d_printf("tcon failed: %s\n", nt_errstr(status));
5086 return -1;
5087 }
5088
5089 talloc_free(sharename);
5090
5091 d_printf("tcon to %s successful, tid: %u\n", sharename,
5092 cli_state_get_tid(cli));
5093 return 0;
5094 }
5095
5096 /**
5097 * tree disconnect (disconnect from a share)
5098 */
5099
5100 static int cmd_tdis(void)
5101 {
5102 NTSTATUS status;
5103
5104 status = cli_tdis(cli);
5105 if (!NT_STATUS_IS_OK(status)) {
5106 d_printf("tdis failed: %s\n", nt_errstr(status));
5107 return -1;
5108 }
5109
5110 d_printf("tdis successful\n");
5111 return 0;
5112 }
5113
5114
5115 /**
5116 * get or set tid
5117 */
5118
5119 static int cmd_tid(void)
5120 {
5121 TALLOC_CTX *ctx = talloc_tos();
5122 char *tid_str;
5123
5124 if (!next_token_talloc(ctx, &cmd_ptr, &tid_str, NULL)) {
5125 if (cli_state_has_tcon(cli)) {
5126 d_printf("current tid is %d\n", cli_state_get_tid(cli));
5127 } else {
5128 d_printf("no tcon currently\n");
5129 }
5130 } else {
5131 uint32_t tid = atoi(tid_str);
5132 if (!cli_state_has_tcon(cli)) {
5133 d_printf("no tcon currently\n");
5134 }
5135 cli_state_set_tid(cli, tid);
5136 }
5137
5138 return 0;
5139 }
5140
5141
5142 /****************************************************************************
5143 list active connections
5144 ****************************************************************************/
5145
5146 static int cmd_list_connect(void)
5147 {
5148 cli_cm_display(cli);
5149 return 0;
5150 }
5151
5152 /****************************************************************************
5153 display the current active client connection
5154 ****************************************************************************/
5155
5156 static int cmd_show_connect( void )
5157 {
5158 TALLOC_CTX *ctx = talloc_tos();
5159 struct cli_state *targetcli;
5160 char *targetpath;
5161 NTSTATUS status;
5162
5163 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(), cli,
5164 client_get_cur_dir(), &targetcli,
5165 &targetpath);
5166 if (!NT_STATUS_IS_OK(status)) {
5167 d_printf("showconnect %s: %s\n", cur_dir, nt_errstr(status));
5168 return 1;
5169 }
5170
5171 d_printf("//%s/%s\n", smbXcli_conn_remote_name(targetcli->conn), targetcli->share);
5172 return 0;
5173 }
5174
5175 /**
5176 * set_remote_times - set times of a remote file
5177 * @filename: path to the file name
5178 * @create_time: New create time
5179 * @access_time: New access time
5180 * @write_time: New write time
5181 * @change_time: New metadata change time
5182 *
5183 * Update the file times with the ones provided.
5184 */
5185 static int set_remote_times(const char *filename, time_t create_time,
5186 time_t access_time, time_t write_time,
5187 time_t change_time)
5188 {
5189 extern struct cli_state *cli;
5190 NTSTATUS status;
5191
5192 status = cli_setpathinfo_basic(cli, filename, create_time,
5193 access_time, write_time,
5194 change_time, -1);
5195 if (!NT_STATUS_IS_OK(status)) {
5196 d_printf("cli_setpathinfo_basic failed: %s\n",
5197 nt_errstr(status));
5198 return 1;
5199 }
5200
5201 return 0;
5202 }
5203
5204 /**
5205 * cmd_utimes - interactive command to set the four times
5206 *
5207 * Read a filename and four times from the client command line and update
5208 * the file times. A value of -1 for a time means don't change.
5209 */
5210 static int cmd_utimes(void)
5211 {
5212 const extern char *cmd_ptr;
5213 char *buf;
5214 char *fname = NULL;
5215 time_t times[4] = {0, 0, 0, 0};
5216 int time_count = 0;
5217 int err = 0;
5218 bool ok;
5219 TALLOC_CTX *ctx = talloc_new(NULL);
5220 if (ctx == NULL) {
5221 return 1;
5222 }
5223
5224 ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
5225 if (!ok) {
5226 d_printf("utimes <filename> <create-time> <access-time> "
5227 "<write-time> <change-time>\n");
5228 d_printf("Dates should be in YY:MM:DD-HH:MM:SS format "
5229 "or -1 for no change\n");
5230 err = 1;
5231 goto out;
5232 }
5233
5234 fname = talloc_asprintf(ctx,
5235 "%s%s",
5236 client_get_cur_dir(),
5237 buf);
5238 if (fname == NULL) {
5239 err = 1;
5240 goto out;
5241 }
5242 fname = client_clean_name(ctx, fname);
5243 if (fname == NULL) {
5244 err = 1;
5245 goto out;
5246 }
5247
5248 while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL) &&
5249 time_count < 4) {
5250 const char *s = buf;
5251 struct tm tm = {0,};
5252 char *ret;
5253
5254 if (strlen(s) == 2 && strcmp(s, "-1") == 0) {
5255 times[time_count] = 0;
5256 time_count++;
5257 continue;
5258 } else {
5259 ret = strptime(s, "%y:%m:%d-%H:%M:%S", &tm);
5260 }
5261
5262 /* We could not match all the chars, so print error */
5263 if (ret == NULL || *ret != 0) {
5264 d_printf("Invalid date format: %s\n", s);
5265 d_printf("utimes <filename> <create-time> "
5266 "<access-time> <write-time> <change-time>\n");
5267 d_printf("Dates should be in YY:MM:DD-HH:MM:SS format "
5268 "or -1 for no change\n");
5269 err = 1;
5270 goto out;
5271 }
5272
5273 /* Convert tm to a time_t */
5274 times[time_count] = mktime(&tm);
5275 time_count++;
5276 }
5277
5278 if (time_count < 4) {
5279 d_printf("Insufficient dates: %d\n", time_count);
5280 d_printf("utimes <filename> <create-time> <access-time> "
5281 "<write-time> <change-time>\n");
5282 d_printf("Dates should be in YY:MM:DD-HH:MM:SS format "
5283 "or -1 for no change\n");
5284 err = 1;
5285 goto out;
5286 }
5287
5288 DEBUG(10, ("times\nCreate: %sAccess: %s Write: %sChange: %s\n",
5289 talloc_strdup(ctx, ctime(&times[0])),
5290 talloc_strdup(ctx, ctime(&times[1])),
5291 talloc_strdup(ctx, ctime(&times[2])),
5292 talloc_strdup(ctx, ctime(&times[3]))));
5293
5294 set_remote_times(fname, times[0], times[1], times[2], times[3]);
5295 out:
5296 talloc_free(ctx);
5297 return err;
5298 }
5299
5300 /**
5301 * set_remote_attr - set DOS attributes of a remote file
5302 * @filename: path to the file name
5303 * @new_attr: attribute bit mask to use
5304 * @mode: one of ATTR_SET or ATTR_UNSET
5305 *
5306 * Update the file attributes with the one provided.
5307 */
5308 int set_remote_attr(const char *filename, uint16_t new_attr, int mode)
5309 {
5310 extern struct cli_state *cli;
5311 uint16_t old_attr;
5312 NTSTATUS status;
5313
5314 status = cli_getatr(cli, filename, &old_attr, NULL, NULL);
5315 if (!NT_STATUS_IS_OK(status)) {
5316 d_printf("cli_getatr failed: %s\n", nt_errstr(status));
5317 return 1;
5318 }
5319
5320 if (mode == ATTR_SET) {
5321 new_attr |= old_attr;
5322 } else {
5323 new_attr = old_attr & ~new_attr;
5324 }
5325
5326 status = cli_setatr(cli, filename, new_attr, 0);
5327 if (!NT_STATUS_IS_OK(status)) {
5328 d_printf("cli_setatr failed: %s\n", nt_errstr(status));
5329 return 1;
5330 }
5331
5332 return 0;
5333 }
5334
5335 /**
5336 * cmd_setmode - interactive command to set DOS attributes
5337 *
5338 * Read a filename and mode from the client command line and update
5339 * the file DOS attributes.
5340 */
5341 int cmd_setmode(void)
5342 {
5343 const extern char *cmd_ptr;
5344 char *buf;
5345 char *fname = NULL;
5346 uint16_t attr[2] = {0};
5347 int mode = ATTR_SET;
5348 int err = 0;
5349 bool ok;
5350 TALLOC_CTX *ctx = talloc_new(NULL);
5351 if (ctx == NULL) {
5352 return 1;
5353 }
5354
5355 ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
5356 if (!ok) {
5357 d_printf("setmode <filename> <[+|-]rsha>\n");
5358 err = 1;
5359 goto out;
5360 }
5361
5362 fname = talloc_asprintf(ctx,
5363 "%s%s",
5364 client_get_cur_dir(),
5365 buf);
5366 if (fname == NULL) {
5367 err = 1;
5368 goto out;
5369 }
5370 fname = client_clean_name(ctx, fname);
5371 if (fname == NULL) {
5372 err = 1;
5373 goto out;
5374 }
5375
5376 while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
5377 const char *s = buf;
5378
5379 while (*s) {
5380 switch (*s++) {
5381 case '+':
5382 mode = ATTR_SET;
5383 break;
5384 case '-':
5385 mode = ATTR_UNSET;
5386 break;
5387 case 'r':
5388 attr[mode] |= FILE_ATTRIBUTE_READONLY;
5389 break;
5390 case 'h':
5391 attr[mode] |= FILE_ATTRIBUTE_HIDDEN;
5392 break;
5393 case 's':
5394 attr[mode] |= FILE_ATTRIBUTE_SYSTEM;
5395 break;
5396 case 'a':
5397 attr[mode] |= FILE_ATTRIBUTE_ARCHIVE;
5398 break;
5399 default:
5400 d_printf("setmode <filename> <perm=[+|-]rsha>\n");
5401 err = 1;
5402 goto out;
5403 }
5404 }
5405 }
5406
5407 if (attr[ATTR_SET] == 0 && attr[ATTR_UNSET] == 0) {
5408 d_printf("setmode <filename> <[+|-]rsha>\n");
5409 err = 1;
5410 goto out;
5411 }
5412
5413 DEBUG(2, ("perm set %d %d\n", attr[ATTR_SET], attr[ATTR_UNSET]));
5414
5415 /* ignore return value: server might not store DOS attributes */
5416 set_remote_attr(fname, attr[ATTR_SET], ATTR_SET);
5417 set_remote_attr(fname, attr[ATTR_UNSET], ATTR_UNSET);
5418 out:
5419 talloc_free(ctx);
5420 return err;
5421 }
5422
5423 /****************************************************************************
5424 iosize command
5425 ***************************************************************************/
5426
5427 int cmd_iosize(void)
5428 {
5429 TALLOC_CTX *ctx = talloc_tos();
5430 char *buf;
5431 int iosize;
5432
5433 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
5434 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
5435 if (!smb_encrypt) {
5436 d_printf("iosize <n> or iosize 0x<n>. "
5437 "Minimum is 0 (default), "
5438 "max is 16776960 (0xFFFF00)\n");
5439 } else {
5440 d_printf("iosize <n> or iosize 0x<n>. "
5441 "(Encrypted connection) ,"
5442 "Minimum is 0 (default), "
5443 "max is 130048 (0x1FC00)\n");
5444 }
5445 } else {
5446 d_printf("iosize <n> or iosize 0x<n>.\n");
5447 }
5448 return 1;
5449 }
5450
5451 iosize = strtol(buf,NULL,0);
5452 if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
5453 if (smb_encrypt && (iosize < 0 || iosize > 0xFC00)) {
5454 d_printf("iosize out of range for encrypted "
5455 "connection (min = 0 (default), "
5456 "max = 130048 (0x1FC00)\n");
5457 return 1;
5458 } else if (!smb_encrypt && (iosize < 0 || iosize > 0xFFFF00)) {
5459 d_printf("iosize out of range (min = 0 (default), "
5460 "max = 16776960 (0xFFFF00)\n");
5461 return 1;
5462 }
5463 }
5464
5465 io_bufsize = iosize;
5466 d_printf("iosize is now %d\n", io_bufsize);
5467 return 0;
5468 }
5469
5470 /****************************************************************************
5471 timeout command
5472 ***************************************************************************/
5473
5474 static int cmd_timeout(void)
5475 {
5476 TALLOC_CTX *ctx = talloc_tos();
5477 char *buf;
5478
5479 if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
5480 unsigned int old_timeout = cli_set_timeout(cli, 0);
5481 cli_set_timeout(cli, old_timeout);
5482 d_printf("timeout <n> (per-operation timeout "
5483 "in seconds - currently %u).\n",
5484 old_timeout/1000);
5485 return 1;
5486 }
5487
5488 io_timeout = strtol(buf,NULL,0);
5489 cli_set_timeout(cli, io_timeout*1000);
5490 d_printf("io_timeout per operation is now %d\n", io_timeout);
5491 return 0;
5492 }
5493
5494
5495 /****************************************************************************
5496 history
5497 ****************************************************************************/
5498 static int cmd_history(void)
5499 {
5500 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
5501 HIST_ENTRY **hlist;
5502 int i;
5503
5504 hlist = history_list();
5505
5506 for (i = 0; hlist && hlist[i]; i++) {
5507 DEBUG(0, ("%d: %s\n", i, hlist[i]->line));
5508 }
5509 #else
5510 DEBUG(0,("no history without readline support\n"));
5511 #endif
5512
5513 return 0;
5514 }
5515
5516 /* Some constants for completing filename arguments */
5517
5518 #define COMPL_NONE 0 /* No completions */
5519 #define COMPL_REMOTE 1 /* Complete remote filename */
5520 #define COMPL_LOCAL 2 /* Complete local filename */
5521
5522 /* This defines the commands supported by this client.
5523 * NOTE: The "!" must be the last one in the list because it's fn pointer
5524 * field is NULL, and NULL in that field is used in process_tok()
5525 * (below) to indicate the end of the list. crh
5526 */
5527 static struct {
5528 const char *name;
5529 int (*fn)(void);
5530 const char *description;
5531 char compl_args[2]; /* Completion argument info */
5532 } commands[] = {
5533 {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
5534 {"allinfo",cmd_allinfo,"<file> show all available info",
5535 {COMPL_NONE,COMPL_NONE}},
5536 {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
5537 {"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}},
5538 {"backup",cmd_backup,"toggle backup intent state",{COMPL_NONE,COMPL_NONE}},
5539 {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},
5540 {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
5541 {"case_sensitive",cmd_setcase,"toggle the case sensitive flag to server",{COMPL_NONE,COMPL_NONE}},
5542 {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
5543 {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_NONE}},
5544 {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_NONE}},
5545 {"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_NONE}},
5546 {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
5547 {"deltree",cmd_deltree,"<mask> recursively delete all matching files and directories",{COMPL_REMOTE,COMPL_NONE}},
5548 {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
5549 {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},
5550 {"echo",cmd_echo,"ping the server",{COMPL_NONE,COMPL_NONE}},
5551 {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
5552 {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
5553 {"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_NONE}},
5554 {"geteas", cmd_geteas, "<file name> get the EA list of a file",
5555 {COMPL_REMOTE, COMPL_NONE}},
5556 {"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},
5557 {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
5558 {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
5559 {"iosize",cmd_iosize,"iosize <number> (default 64512)",{COMPL_NONE,COMPL_NONE}},
5560 {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
5561 {"link",cmd_link,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
5562 {"lock",cmd_lock,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
5563 {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
5564 {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
5565 {"l",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
5566 {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},
5567 {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
5568 {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
5569 {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
5570 {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
5571 {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
5572 {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
5573 {"notify",cmd_notify,"<file>Get notified of dir changes",{COMPL_REMOTE,COMPL_NONE}},
5574 {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
5575 {"posix", cmd_posix, "turn on all POSIX capabilities", {COMPL_REMOTE,COMPL_NONE}},
5576 {"posix_encrypt",cmd_posix_encrypt,"<domain> <user> <password> start up transport encryption",{COMPL_REMOTE,COMPL_NONE}},
5577 {"posix_open",cmd_posix_open,"<name> 0<mode> open_flags mode open a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
5578 {"posix_mkdir",cmd_posix_mkdir,"<name> 0<mode> creates a directory using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
5579 {"posix_rmdir",cmd_posix_rmdir,"<name> removes a directory using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
5580 {"posix_unlink",cmd_posix_unlink,"<name> removes a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
5581 {"posix_whoami",cmd_posix_whoami,"return logged on user information "
5582 "using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
5583 {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
5584 {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
5585 {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
5586 {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
5587 {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
5588 {"queue",cmd_queue,"show the print queue",{COMPL_NONE,COMPL_NONE}},
5589 {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
5590 {"readlink",cmd_readlink,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE,COMPL_REMOTE}},
5591 {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
5592 {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
5593 {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
5594 {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
5595 {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
5596 {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
5597 {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_REMOTE,COMPL_NONE}},
5598 {"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}},
5599 {"setea", cmd_setea, "<file name> <eaname> <eaval> Set an EA of a file",
5600 {COMPL_REMOTE, COMPL_LOCAL}},
5601 {"setmode",cmd_setmode,"<file name> <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
5602 {"scopy",cmd_scopy,"<src> <dest> server-side copy file",{COMPL_REMOTE,COMPL_REMOTE}},
5603 {"stat",cmd_stat,"<file name> Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_NONE}},
5604 {"symlink",cmd_symlink,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
5605 {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},
5606 {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},
5607 {"timeout",cmd_timeout,"timeout <number> - set the per-operation timeout in seconds (default 20)",{COMPL_NONE,COMPL_NONE}},
5608 {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
5609 {"unlock",cmd_unlock,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
5610 {"volume",cmd_volume,"print the volume name",{COMPL_NONE,COMPL_NONE}},
5611 {"vuid",cmd_vuid,"change current vuid",{COMPL_NONE,COMPL_NONE}},
5612 {"wdel",cmd_wdel,"<attrib> <mask> wildcard delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
5613 {"logon",cmd_logon,"establish new logon",{COMPL_NONE,COMPL_NONE}},
5614 {"listconnect",cmd_list_connect,"list open connections",{COMPL_NONE,COMPL_NONE}},
5615 {"showconnect",cmd_show_connect,"display the current active connection",{COMPL_NONE,COMPL_NONE}},
5616 {"tcon",cmd_tcon,"connect to a share" ,{COMPL_NONE,COMPL_NONE}},
5617 {"tdis",cmd_tdis,"disconnect from a share",{COMPL_NONE,COMPL_NONE}},
5618 {"tid",cmd_tid,"show or set the current tid (tree-id)",{COMPL_NONE,COMPL_NONE}},
5619 {"utimes", cmd_utimes,"<file name> <create_time> <access_time> <mod_time> "
5620 "<ctime> set times", {COMPL_REMOTE,COMPL_NONE}},
5621 {"logoff",cmd_logoff,"log off (close the session)",{COMPL_NONE,COMPL_NONE}},
5622 {"..",cmd_cd_oneup,"change the remote directory (up one level)",{COMPL_REMOTE,COMPL_NONE}},
5623
5624 /* Yes, this must be here, see crh's comment above. */
5625 {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
5626 {NULL,NULL,NULL,{COMPL_NONE,COMPL_NONE}}
5627 };
5628
5629 /*******************************************************************
5630 Lookup a command string in the list of commands, including
5631 abbreviations.
5632 ******************************************************************/
5633
5634 static int process_tok(char *tok)
5635 {
5636 size_t i = 0, matches = 0;
5637 size_t cmd=0;
5638 size_t tok_len = strlen(tok);
5639
5640 while (commands[i].fn != NULL) {
5641 if (strequal(commands[i].name,tok)) {
5642 matches = 1;
5643 cmd = i;
5644 break;
5645 } else if (strnequal(commands[i].name, tok, tok_len)) {
5646 matches++;
5647 cmd = i;
5648 }
5649 i++;
5650 }
5651
5652 if (matches == 0)
5653 return(-1);
5654 else if (matches == 1)
5655 return(cmd);
5656 else
5657 return(-2);
5658 }
5659
5660 /****************************************************************************
5661 Help.
5662 ****************************************************************************/
5663
5664 static int cmd_help(void)
5665 {
5666 TALLOC_CTX *ctx = talloc_tos();
5667 int i=0,j;
5668 char *buf;
5669
5670 if (next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
5671 if ((i = process_tok(buf)) >= 0)
5672 d_printf("HELP %s:\n\t%s\n\n",
5673 commands[i].name,commands[i].description);
5674 } else {
5675 while (commands[i].description) {
5676 for (j=0; commands[i].description && (j<5); j++) {
5677 d_printf("%-15s",commands[i].name);
5678 i++;
5679 }
5680 d_printf("\n");
5681 }
5682 }
5683 return 0;
5684 }
5685
5686 /****************************************************************************
5687 Process a -c command string.
5688 ****************************************************************************/
5689
5690 static int process_command_string(const char *cmd_in)
5691 {
5692 TALLOC_CTX *ctx = talloc_tos();
5693 char *cmd = talloc_strdup(ctx, cmd_in);
5694 int rc = 0;
5695
5696 if (!cmd) {
5697 return 1;
5698 }
5699 /* establish the connection if not already */
5700
5701 if (!cli) {
5702 NTSTATUS status;
5703
5704 status = cli_cm_open(talloc_tos(), NULL,
5705 have_ip ? dest_ss_str : desthost,
5706 service, popt_get_cmdline_auth_info(),
5707 smb_encrypt,
5708 max_protocol, port, name_type,
5709 &cli);
5710 if (!NT_STATUS_IS_OK(status)) {
5711 return 1;
5712 }
5713 cli_set_timeout(cli, io_timeout*1000);
5714 }
5715
5716 while (cmd[0] != '\0') {
5717 char *line;
5718 char *p;
5719 char *tok;
5720 int i;
5721
5722 if ((p = strchr_m(cmd, ';')) == 0) {
5723 line = cmd;
5724 cmd += strlen(cmd);
5725 } else {
5726 *p = '\0';
5727 line = cmd;
5728 cmd = p + 1;
5729 }
5730
5731 /* and get the first part of the command */
5732 cmd_ptr = line;
5733 if (!next_token_talloc(ctx, &cmd_ptr,&tok,NULL)) {
5734 continue;
5735 }
5736
5737 if ((i = process_tok(tok)) >= 0) {
5738 rc = commands[i].fn();
5739 } else if (i == -2) {
5740 d_printf("%s: command abbreviation ambiguous\n",tok);
5741 } else {
5742 d_printf("%s: command not found\n",tok);
5743 }
5744 }
5745
5746 return rc;
5747 }
5748
5749 #define MAX_COMPLETIONS 100
5750
5751 struct completion_remote {
5752 char *dirmask;
5753 char **matches;
5754 int count, samelen;
5755 const char *text;
5756 int len;
5757 };
5758
5759 static NTSTATUS completion_remote_filter(const char *mnt,
5760 struct file_info *f,
5761 const char *mask,
5762 void *state)
5763 {
5764 struct completion_remote *info = (struct completion_remote *)state;
5765
5766 if (info->count >= MAX_COMPLETIONS - 1) {
5767 return NT_STATUS_OK;
5768 }
5769 if (strncmp(info->text, f->name, info->len) != 0) {
5770 return NT_STATUS_OK;
5771 }
5772 if (ISDOT(f->name) || ISDOTDOT(f->name)) {
5773 return NT_STATUS_OK;
5774 }
5775
5776 if ((info->dirmask[0] == 0) && !(f->mode & FILE_ATTRIBUTE_DIRECTORY))
5777 info->matches[info->count] = SMB_STRDUP(f->name);
5778 else {
5779 TALLOC_CTX *ctx = talloc_stackframe();
5780 char *tmp;
5781
5782 tmp = talloc_strdup(ctx,info->dirmask);
5783 if (!tmp) {
5784 TALLOC_FREE(ctx);
5785 return NT_STATUS_NO_MEMORY;
5786 }
5787 tmp = talloc_asprintf_append(tmp, "%s", f->name);
5788 if (!tmp) {
5789 TALLOC_FREE(ctx);
5790 return NT_STATUS_NO_MEMORY;
5791 }
5792 if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
5793 tmp = talloc_asprintf_append(tmp, "%s",
5794 CLI_DIRSEP_STR);
5795 }
5796 if (!tmp) {
5797 TALLOC_FREE(ctx);
5798 return NT_STATUS_NO_MEMORY;
5799 }
5800 info->matches[info->count] = SMB_STRDUP(tmp);
5801 TALLOC_FREE(ctx);
5802 }
5803 if (info->matches[info->count] == NULL) {
5804 return NT_STATUS_OK;
5805 }
5806 if (f->mode & FILE_ATTRIBUTE_DIRECTORY) {
5807 smb_readline_ca_char(0);
5808 }
5809 if (info->count == 1) {
5810 info->samelen = strlen(info->matches[info->count]);
5811 } else {
5812 while (strncmp(info->matches[info->count],
5813 info->matches[info->count-1],
5814 info->samelen) != 0) {
5815 info->samelen--;
5816 }
5817 }
5818 info->count++;
5819 return NT_STATUS_OK;
5820 }
5821
5822 static char **remote_completion(const char *text, int len)
5823 {
5824 TALLOC_CTX *ctx = talloc_stackframe();
5825 char *dirmask = NULL;
5826 char *targetpath = NULL;
5827 struct cli_state *targetcli = NULL;
5828 int i;
5829 struct completion_remote info = { NULL, NULL, 1, 0, NULL, 0 };
5830 NTSTATUS status;
5831
5832 /* can't have non-static initialisation on Sun CC, so do it
5833 at run time here */
5834 info.samelen = len;
5835 info.text = text;
5836 info.len = len;
5837
5838 info.matches = SMB_MALLOC_ARRAY(char *,MAX_COMPLETIONS);
5839 if (!info.matches) {
5840 TALLOC_FREE(ctx);
5841 return NULL;
5842 }
5843
5844 /*
5845 * We're leaving matches[0] free to fill it later with the text to
5846 * display: Either the one single match or the longest common subset
5847 * of the matches.
5848 */
5849 info.matches[0] = NULL;
5850 info.count = 1;
5851
5852 for (i = len-1; i >= 0; i--) {
5853 if ((text[i] == '/') || (text[i] == CLI_DIRSEP_CHAR)) {
5854 break;
5855 }
5856 }
5857
5858 info.text = text+i+1;
5859 info.samelen = info.len = len-i-1;
5860
5861 if (i > 0) {
5862 info.dirmask = SMB_MALLOC_ARRAY(char, i+2);
5863 if (!info.dirmask) {
5864 goto cleanup;
5865 }
5866 strncpy(info.dirmask, text, i+1);
5867 info.dirmask[i+1] = 0;
5868 dirmask = talloc_asprintf(ctx,
5869 "%s%*s*",
5870 client_get_cur_dir(),
5871 i-1,
5872 text);
5873 } else {
5874 info.dirmask = SMB_STRDUP("");
5875 if (!info.dirmask) {
5876 goto cleanup;
5877 }
5878 dirmask = talloc_asprintf(ctx,
5879 "%s*",
5880 client_get_cur_dir());
5881 }
5882 if (!dirmask) {
5883 goto cleanup;
5884 }
5885 dirmask = client_clean_name(ctx, dirmask);
5886 if (dirmask == NULL) {
5887 goto cleanup;
5888 }
5889
5890 status = cli_resolve_path(ctx, "", popt_get_cmdline_auth_info(),
5891 cli, dirmask, &targetcli, &targetpath);
5892 if (!NT_STATUS_IS_OK(status)) {
5893 goto cleanup;
5894 }
5895 status = cli_list(targetcli, targetpath, FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
5896 completion_remote_filter, (void *)&info);
5897 if (!NT_STATUS_IS_OK(status)) {
5898 goto cleanup;
5899 }
5900
5901 if (info.count == 1) {
5902 /*
5903 * No matches at all, NULL indicates there is nothing
5904 */
5905 SAFE_FREE(info.matches[0]);
5906 SAFE_FREE(info.matches);
5907 TALLOC_FREE(ctx);
5908 return NULL;
5909 }
5910
5911 if (info.count == 2) {
5912 /*
5913 * Exactly one match in matches[1], indicate this is the one
5914 * in matches[0].
5915 */
5916 info.matches[0] = info.matches[1];
5917 info.matches[1] = NULL;
5918 info.count -= 1;
5919 TALLOC_FREE(ctx);
5920 return info.matches;
5921 }
5922
5923 /*
5924 * We got more than one possible match, set the result to the maximum
5925 * common subset
5926 */
5927
5928 info.matches[0] = SMB_STRNDUP(info.matches[1], info.samelen);
5929 info.matches[info.count] = NULL;
5930 TALLOC_FREE(ctx);
5931 return info.matches;
5932
5933 cleanup:
5934 for (i = 0; i < info.count; i++) {
5935 SAFE_FREE(info.matches[i]);
5936 }
5937 SAFE_FREE(info.matches);
5938 SAFE_FREE(info.dirmask);
5939 TALLOC_FREE(ctx);
5940 return NULL;
5941 }
5942
5943 static char **completion_fn(const char *text, int start, int end)
5944 {
5945 smb_readline_ca_char(' ');
5946
5947 if (start) {
5948 const char *buf, *sp;
5949 int i;
5950 char compl_type;
5951
5952 buf = smb_readline_get_line_buffer();
5953 if (buf == NULL)
5954 return NULL;
5955
5956 sp = strchr(buf, ' ');
5957 if (sp == NULL)
5958 return NULL;
5959
5960 for (i = 0; commands[i].name; i++) {
5961 if ((strncmp(commands[i].name, buf, sp - buf) == 0) &&
5962 (commands[i].name[sp - buf] == 0)) {
5963 break;
5964 }
5965 }
5966 if (commands[i].name == NULL)
5967 return NULL;
5968
5969 while (*sp == ' ')
5970 sp++;
5971
5972 if (sp == (buf + start))
5973 compl_type = commands[i].compl_args[0];
5974 else
5975 compl_type = commands[i].compl_args[1];
5976
5977 if (compl_type == COMPL_REMOTE)
5978 return remote_completion(text, end - start);
5979 else /* fall back to local filename completion */
5980 return NULL;
5981 } else {
5982 char **matches;
5983 size_t i, len, samelen = 0, count=1;
5984
5985 matches = SMB_MALLOC_ARRAY(char *, MAX_COMPLETIONS);
5986 if (!matches) {
5987 return NULL;
5988 }
5989 matches[0] = NULL;
5990
5991 len = strlen(text);
5992 for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
5993 if (strncmp(text, commands[i].name, len) == 0) {
5994 matches[count] = SMB_STRDUP(commands[i].name);
5995 if (!matches[count])
5996 goto cleanup;
5997 if (count == 1)
5998 samelen = strlen(matches[count]);
5999 else
6000 while (strncmp(matches[count], matches[count-1], samelen) != 0)
6001 samelen--;
6002 count++;
6003 }
6004 }
6005
6006 switch (count) {
6007 case 0: /* should never happen */
6008 case 1:
6009 goto cleanup;
6010 case 2:
6011 matches[0] = SMB_STRDUP(matches[1]);
6012 break;
6013 default:
6014 matches[0] = (char *)SMB_MALLOC(samelen+1);
6015 if (!matches[0])
6016 goto cleanup;
6017 strncpy(matches[0], matches[1], samelen);
6018 matches[0][samelen] = 0;
6019 }
6020 matches[count] = NULL;
6021 return matches;
6022
6023 cleanup:
6024 for (i = 0; i < count; i++)
6025 free(matches[i]);
6026
6027 free(matches);
6028 return NULL;
6029 }
6030 }
6031
6032 static bool finished;
6033
6034 /****************************************************************************
6035 Make sure we swallow keepalives during idle time.
6036 ****************************************************************************/
6037
6038 static void readline_callback(void)
6039 {
6040 static time_t last_t;
6041 struct timespec now;
6042 time_t t;
6043 NTSTATUS status;
6044 unsigned char garbage[16];
6045
6046 clock_gettime_mono(&now);
6047 t = now.tv_sec;
6048
6049 if (t - last_t < 5)
6050 return;
6051
6052 last_t = t;
6053
6054 /* Ping the server to keep the connection alive using SMBecho. */
6055 memset(garbage, 0xf0, sizeof(garbage));
6056 status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
6057 if (NT_STATUS_IS_OK(status) ||
6058 NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
6059 /*
6060 * Even if server returns NT_STATUS_INVALID_PARAMETER
6061 * it still responded.
6062 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=13007
6063 */
6064 return;
6065 }
6066
6067 if (!cli_state_is_connected(cli)) {
6068 DEBUG(0,("SMBecho failed (%s). The connection is "
6069 "disconnected now\n", nt_errstr(status)));
6070 finished = true;
6071 smb_readline_done();
6072 }
6073 }
6074
6075 /****************************************************************************
6076 Process commands on stdin.
6077 ****************************************************************************/
6078
6079 static int process_stdin(void)
6080 {
6081 int rc = 0;
6082
6083 if (!quiet) {
6084 d_printf("Try \"help\" to get a list of possible commands.\n");
6085 }
6086
6087 while (!finished) {
6088 TALLOC_CTX *frame = talloc_stackframe();
6089 char *tok = NULL;
6090 char *the_prompt = NULL;
6091 char *line = NULL;
6092 int i;
6093
6094 /* display a prompt */
6095 if (asprintf(&the_prompt, "smb: %s> ", client_get_cur_dir()) < 0) {
6096 TALLOC_FREE(frame);
6097 break;
6098 }
6099 line = smb_readline(the_prompt, readline_callback, completion_fn);
6100 SAFE_FREE(the_prompt);
6101 if (!line) {
6102 TALLOC_FREE(frame);
6103 break;
6104 }
6105
6106 /* special case - first char is ! */
6107 if (*line == '!') {
6108 if (system(line + 1) == -1) {
6109 d_printf("system() command %s failed.\n",
6110 line+1);
6111 }
6112 SAFE_FREE(line);
6113 TALLOC_FREE(frame);
6114 continue;
6115 }
6116
6117 /* and get the first part of the command */
6118 cmd_ptr = line;
6119 if (!next_token_talloc(frame, &cmd_ptr,&tok,NULL)) {
6120 TALLOC_FREE(frame);
6121 SAFE_FREE(line);
6122 continue;
6123 }
6124
6125 if ((i = process_tok(tok)) >= 0) {
6126 rc = commands[i].fn();
6127 } else if (i == -2) {
6128 d_printf("%s: command abbreviation ambiguous\n",tok);
6129 } else {
6130 d_printf("%s: command not found\n",tok);
6131 }
6132 SAFE_FREE(line);
6133 TALLOC_FREE(frame);
6134 }
6135 return rc;
6136 }
6137
6138 /****************************************************************************
6139 Process commands from the client.
6140 ****************************************************************************/
6141
6142 static int process(const char *base_directory)
6143 {
6144 int rc = 0;
6145 NTSTATUS status;
6146
6147 status = cli_cm_open(talloc_tos(), NULL,
6148 have_ip ? dest_ss_str : desthost,
6149 service, popt_get_cmdline_auth_info(),
6150 smb_encrypt, max_protocol, port,
6151 name_type, &cli);
6152 if (!NT_STATUS_IS_OK(status)) {
6153 return 1;
6154 }
6155
6156 cli_set_timeout(cli, io_timeout*1000);
6157
6158 if (base_directory && *base_directory) {
6159 rc = do_cd(base_directory);
6160 if (rc) {
6161 cli_shutdown(cli);
6162 return rc;
6163 }
6164 }
6165
6166 if (cmdstr) {
6167 rc = process_command_string(cmdstr);
6168 } else {
6169 process_stdin();
6170 }
6171
6172 cli_shutdown(cli);
6173 return rc;
6174 }
6175
6176 /****************************************************************************
6177 Handle a -L query.
6178 ****************************************************************************/
6179
6180 static int do_host_query(const char *query_host)
6181 {
6182 NTSTATUS status;
6183
6184 status = cli_cm_open(talloc_tos(), NULL,
6185 have_ip ? dest_ss_str : query_host,
6186 "IPC$", popt_get_cmdline_auth_info(),
6187 smb_encrypt, max_protocol, port,
6188 name_type, &cli);
6189 if (!NT_STATUS_IS_OK(status)) {
6190 return 1;
6191 }
6192
6193 cli_set_timeout(cli, io_timeout*1000);
6194 browse_host(true);
6195
6196 /* Ensure that the host can do IPv4 */
6197
6198 if (!interpret_addr(query_host)) {
6199 struct sockaddr_storage ss;
6200 if (interpret_string_addr(&ss, query_host, 0) &&
6201 (ss.ss_family != AF_INET)) {
6202 d_printf("%s is an IPv6 address -- no workgroup available\n",
6203 query_host);
6204 return 1;
6205 }
6206 }
6207
6208 if (lp_client_min_protocol() > PROTOCOL_NT1) {
6209 d_printf("SMB1 disabled -- no workgroup available\n");
6210 goto out;
6211 }
6212
6213 if (lp_disable_netbios()) {
6214 d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
6215 goto out;
6216 }
6217
6218 if (port != NBT_SMB_PORT ||
6219 smbXcli_conn_protocol(cli->conn) > PROTOCOL_NT1)
6220 {
6221 int max_proto = MIN(max_protocol, PROTOCOL_NT1);
6222
6223 /*
6224 * Workgroups simply don't make sense over anything
6225 * else but port 139 and SMB1.
6226 */
6227
6228 cli_shutdown(cli);
6229 d_printf("Reconnecting with SMB1 for workgroup listing.\n");
6230 status = cli_cm_open(talloc_tos(), NULL,
6231 have_ip ? dest_ss_str : query_host,
6232 "IPC$", popt_get_cmdline_auth_info(),
6233 smb_encrypt, max_proto,
6234 NBT_SMB_PORT, name_type, &cli);
6235 if (!NT_STATUS_IS_OK(status)) {
6236 d_printf("Unable to connect with SMB1 "
6237 "-- no workgroup available\n");
6238 return 0;
6239 }
6240 }
6241
6242 cli_set_timeout(cli, io_timeout*1000);
6243 list_servers(lp_workgroup());
6244 out:
6245 cli_shutdown(cli);
6246
6247 return(0);
6248 }
6249
6250 /****************************************************************************
6251 Handle a tar operation.
6252 ****************************************************************************/
6253
6254 static int do_tar_op(const char *base_directory)
6255 {
6256 struct tar *tar_ctx = tar_get_ctx();
6257 int ret = 0;
6258
6259 /* do we already have a connection? */
6260 if (!cli) {
6261 NTSTATUS status;
6262
6263 status = cli_cm_open(talloc_tos(), NULL,
6264 have_ip ? dest_ss_str : desthost,
6265 service, popt_get_cmdline_auth_info(),
6266 smb_encrypt, max_protocol,
6267 port, name_type, &cli);
6268 if (!NT_STATUS_IS_OK(status)) {
6269 ret = 1;
6270 goto out;
6271 }
6272 cli_set_timeout(cli, io_timeout*1000);
6273 }
6274
6275 recurse = true;
6276
6277 if (base_directory && *base_directory) {
6278 ret = do_cd(base_directory);
6279 if (ret) {
6280 goto out_cli;
6281 }
6282 }
6283
6284 ret = tar_process(tar_ctx);
6285
6286 out_cli:
6287 cli_shutdown(cli);
6288 out:
6289 return ret;
6290 }
6291
6292 /****************************************************************************
6293 Handle a message operation.
6294 ****************************************************************************/
6295
6296 static int do_message_op(struct user_auth_info *a_info)
6297 {
6298 NTSTATUS status;
6299
6300 if (lp_disable_netbios()) {
6301 d_printf("NetBIOS over TCP disabled.\n");
6302 return 1;
6303 }
6304
6305 status = cli_connect_nb(desthost, have_ip ? &dest_ss : NULL,
6306 port ? port : NBT_SMB_PORT, name_type,
6307 lp_netbios_name(), SMB_SIGNING_DEFAULT, 0, &cli);
6308 if (!NT_STATUS_IS_OK(status)) {
6309 d_printf("Connection to %s failed. Error %s\n", desthost, nt_errstr(status));
6310 return 1;
6311 }
6312
6313 cli_set_timeout(cli, io_timeout*1000);
6314 send_message(get_cmdline_auth_info_username(a_info));
6315 cli_shutdown(cli);
6316
6317 return 0;
6318 }
6319
6320 /****************************************************************************
6321 main program
6322 ****************************************************************************/
6323
6324 int main(int argc,char *argv[])
6325 {
6326 const char **const_argv = discard_const_p(const char *, argv);
6327 char *base_directory = NULL;
6328 int opt;
6329 char *query_host = NULL;
6330 bool message = false;
6331 static const char *new_name_resolve_order = NULL;
6332 poptContext pc;
6333 char *p;
6334 int rc = 0;
6335 bool tar_opt = false;
6336 bool service_opt = false;
6337 struct tar *tar_ctx = tar_get_ctx();
6338
6339 struct poptOption long_options[] = {
6340 POPT_AUTOHELP
6341
6342 { "name-resolve", 'R', POPT_ARG_STRING, &new_name_resolve_order, 'R', "Use these name resolution services only", "NAME-RESOLVE-ORDER" },
6343 { "message", 'M', POPT_ARG_STRING, NULL, 'M', "Send message", "HOST" },
6344 { "ip-address", 'I', POPT_ARG_STRING, NULL, 'I', "Use this IP to connect to", "IP" },
6345 { "stderr", 'E', POPT_ARG_NONE, NULL, 'E', "Write messages to stderr instead of stdout" },
6346 { "list", 'L', POPT_ARG_STRING, NULL, 'L', "Get a list of shares available on a host", "HOST" },
6347 { "max-protocol", 'm', POPT_ARG_STRING, NULL, 'm', "Set the max protocol level", "LEVEL" },
6348 { "tar", 'T', POPT_ARG_STRING, NULL, 'T', "Command line tar", "<c|x>IXFqgbNan" },
6349 { "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
6350 { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },
6351 { "send-buffer", 'b', POPT_ARG_INT, &io_bufsize, 'b', "Changes the transmit/send buffer", "BYTES" },
6352 { "timeout", 't', POPT_ARG_INT, &io_timeout, 'b', "Changes the per-operation timeout", "SECONDS" },
6353 { "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
6354 { "grepable", 'g', POPT_ARG_NONE, NULL, 'g', "Produce grepable output" },
6355 { "quiet", 'q', POPT_ARG_NONE, NULL, 'q', "Suppress help message" },
6356 { "browse", 'B', POPT_ARG_NONE, NULL, 'B', "Browse SMB servers using DNS" },
6357 POPT_COMMON_SAMBA
6358 POPT_COMMON_CONNECTION
6359 POPT_COMMON_CREDENTIALS
6360 POPT_TABLEEND
6361 };
6362 TALLOC_CTX *frame = talloc_stackframe();
6363
6364 if (!client_set_cur_dir("\\")) {
6365 exit(ENOMEM);
6366 }
6367
6368 /* set default debug level to 1 regardless of what smb.conf sets */
6369 setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
6370 smb_init_locale();
6371
6372 lp_set_cmdline("log level", "1");
6373
6374 popt_common_credentials_set_ignore_missing_conf();
6375 popt_common_credentials_set_delay_post();
6376
6377 /* skip argv(0) */
6378 pc = poptGetContext("smbclient", argc, const_argv, long_options, 0);
6379 poptSetOtherOptionHelp(pc, "service <password>");
6380
6381 while ((opt = poptGetNextOpt(pc)) != -1) {
6382
6383 /* if the tar option has been called previouslt, now we need to eat out the leftovers */
6384 /* I see no other way to keep things sane --SSS */
6385 if (tar_opt == true) {
6386 while (poptPeekArg(pc)) {
6387 poptGetArg(pc);
6388 }
6389 tar_opt = false;
6390 }
6391
6392 /* if the service has not yet been specified lets see if it is available in the popt stack */
6393 if (!service_opt && poptPeekArg(pc)) {
6394 service = talloc_strdup(frame, poptGetArg(pc));
6395 if (!service) {
6396 exit(ENOMEM);
6397 }
6398 service_opt = true;
6399 }
6400
6401 /* if the service has already been retrieved then check if we have also a password */
6402 if (service_opt
6403 && (!get_cmdline_auth_info_got_pass(
6404 popt_get_cmdline_auth_info()))
6405 && poptPeekArg(pc)) {
6406 set_cmdline_auth_info_password(
6407 popt_get_cmdline_auth_info(), poptGetArg(pc));
6408 }
6409
6410
6411 switch (opt) {
6412 case 'M':
6413 /* Messages are sent to NetBIOS name type 0x3
6414 * (Messenger Service). Make sure we default
6415 * to port 139 instead of port 445. srl,crh
6416 */
6417 name_type = 0x03;
6418 desthost = talloc_strdup(frame,poptGetOptArg(pc));
6419 if (!desthost) {
6420 exit(ENOMEM);
6421 }
6422 if( !port )
6423 port = NBT_SMB_PORT;
6424 message = true;
6425 break;
6426 case 'I':
6427 {
6428 if (!interpret_string_addr(&dest_ss, poptGetOptArg(pc), 0)) {
6429 exit(1);
6430 }
6431 have_ip = true;
6432 print_sockaddr(dest_ss_str, sizeof(dest_ss_str), &dest_ss);
6433 }
6434 break;
6435 case 'E':
6436 setup_logging("smbclient", DEBUG_STDERR );
6437 display_set_stderr();
6438 break;
6439
6440 case 'L':
6441 query_host = talloc_strdup(frame, poptGetOptArg(pc));
6442 if (!query_host) {
6443 exit(ENOMEM);
6444 }
6445 break;
6446 case 'm':
6447 lp_set_cmdline("client max protocol", poptGetOptArg(pc));
6448 break;
6449 case 'T':
6450 /* We must use old option processing for this. Find the
6451 * position of the -T option in the raw argv[]. */
6452 {
6453 int i;
6454
6455 for (i = 1; i < argc; i++) {
6456 if (strncmp("-T", argv[i],2)==0)
6457 break;
6458 }
6459 i++;
6460 if (tar_parse_args(tar_ctx, poptGetOptArg(pc),
6461 const_argv + i, argc - i)) {
6462 poptPrintUsage(pc, stderr, 0);
6463 exit(1);
6464 }
6465 }
6466 /* this must be the last option, mark we have parsed it so that we know we have */
6467 tar_opt = true;
6468 break;
6469 case 'D':
6470 base_directory = talloc_strdup(frame, poptGetOptArg(pc));
6471 if (!base_directory) {
6472 exit(ENOMEM);
6473 }
6474 break;
6475 case 'g':
6476 grepable=true;
6477 break;
6478 case 'q':
6479 quiet=true;
6480 break;
6481 case 'e':
6482 smb_encrypt=true;
6483 break;
6484 case 'B':
6485 return(do_smb_browse());
6486
6487 }
6488 }
6489
6490 /* We may still have some leftovers after the last popt option has been called */
6491 if (tar_opt == true) {
6492 while (poptPeekArg(pc)) {
6493 poptGetArg(pc);
6494 }
6495 tar_opt = false;
6496 }
6497
6498 /* if the service has not yet been specified lets see if it is available in the popt stack */
6499 if (!service_opt && poptPeekArg(pc)) {
6500 service = talloc_strdup(frame,poptGetArg(pc));
6501 if (!service) {
6502 exit(ENOMEM);
6503 }
6504 service_opt = true;
6505 }
6506
6507 /* if the service has already been retrieved then check if we have also a password */
6508 if (service_opt
6509 && !get_cmdline_auth_info_got_pass(popt_get_cmdline_auth_info())
6510 && poptPeekArg(pc)) {
6511 set_cmdline_auth_info_password(popt_get_cmdline_auth_info(),
6512 poptGetArg(pc));
6513 }
6514
6515 if (service_opt && service) {
6516 size_t len;
6517
6518 /* Convert any '/' characters in the service name to '\' characters */
6519 string_replace(service, '/','\\');
6520 if (count_chars(service,'\\') < 3) {
6521 d_printf("\n%s: Not enough '\\' characters in service\n",service);
6522 poptPrintUsage(pc, stderr, 0);
6523 exit(1);
6524 }
6525 /* Remove trailing slashes */
6526 len = strlen(service);
6527 while(len > 0 && service[len - 1] == '\\') {
6528 --len;
6529 service[len] = '\0';
6530 }
6531 }
6532
6533 if (!init_names()) {
6534 fprintf(stderr, "init_names() failed\n");
6535 exit(1);
6536 }
6537
6538 if(new_name_resolve_order)
6539 lp_set_cmdline("name resolve order", new_name_resolve_order);
6540
6541 if (!tar_to_process(tar_ctx) && !query_host && !service && !message) {
6542 poptPrintUsage(pc, stderr, 0);
6543 exit(1);
6544 }
6545
6546 poptFreeContext(pc);
6547 popt_burn_cmdline_password(argc, argv);
6548
6549 DEBUG(3,("Client started (version %s).\n", samba_version_string()));
6550
6551 /* Ensure we have a password (or equivalent). */
6552 popt_common_credentials_post();
6553 smb_encrypt = get_cmdline_auth_info_smb_encrypt(
6554 popt_get_cmdline_auth_info());
6555
6556 max_protocol = lp_client_max_protocol();
6557
6558 if (tar_to_process(tar_ctx)) {
6559 if (cmdstr)
6560 process_command_string(cmdstr);
6561 rc = do_tar_op(base_directory);
6562 } else if (query_host && *query_host) {
6563 char *qhost = query_host;
6564 char *slash;
6565
6566 while (*qhost == '\\' || *qhost == '/')
6567 qhost++;
6568
6569 if ((slash = strchr_m(qhost, '/'))
6570 || (slash = strchr_m(qhost, '\\'))) {
6571 *slash = 0;
6572 }
6573
6574 if ((p=strchr_m(qhost, '#'))) {
6575 *p = 0;
6576 p++;
6577 sscanf(p, "%x", &name_type);
6578 }
6579
6580 rc = do_host_query(qhost);
6581 } else if (message) {
6582 rc = do_message_op(popt_get_cmdline_auth_info());
6583 } else if (process(base_directory)) {
6584 rc = 1;
6585 }
6586
6587 popt_free_cmdline_auth_info();
6588 TALLOC_FREE(frame);
6589 return rc;
6590 }
Samba GIT mirror