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