?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:selftest: correctly copy a python list into a temporary variable
[Samba.git] / source4 / client / client.c
bloba069443d0cf86452175006947ee4911f6acfb8a7
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-2004
7 Copyright (C) James J Myers 2003 <myersjj@samba.org>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 /*
24 * TODO: remove this ... and don't use talloc_append_string()
25 *
26 * NOTE: I'm not changing the code yet, because I assume there're
27 * some bugs in the existing code and I'm not sure how to fix
28 * them correctly.
29 */
30 #define TALLOC_DEPRECATED 1
31
32 #include "includes.h"
33 #include "version.h"
34 #include "libcli/libcli.h"
35 #include "lib/events/events.h"
36 #include "lib/cmdline/popt_common.h"
37 #include "librpc/gen_ndr/ndr_srvsvc_c.h"
38 #include "librpc/gen_ndr/ndr_lsa.h"
39 #include "librpc/gen_ndr/ndr_security.h"
40 #include "libcli/util/clilsa.h"
41 #include "system/dir.h"
42 #include "system/filesys.h"
43 #include "../lib/util/dlinklist.h"
44 #include "system/readline.h"
45 #include "auth/credentials/credentials.h"
46 #include "auth/gensec/gensec.h"
47 #include "system/time.h" /* needed by some systems for asctime() */
48 #include "libcli/resolve/resolve.h"
49 #include "libcli/security/security.h"
50 #include "../libcli/smbreadline/smbreadline.h"
51 #include "librpc/gen_ndr/ndr_nbt.h"
52 #include "param/param.h"
53 #include "libcli/raw/raw_proto.h"
54
55 /* the default pager to use for the client "more" command. Users can
56 * override this with the PAGER environment variable */
57 #ifndef DEFAULT_PAGER
58 #define DEFAULT_PAGER "more"
59 #endif
60
61 struct smbclient_context {
62 char *remote_cur_dir;
63 struct smbcli_state *cli;
64 char *fileselection;
65 time_t newer_than;
66 bool prompt;
67 bool recurse;
68 int archive_level;
69 bool lowercase;
70 int printmode;
71 bool translation;
72 int io_bufsize;
73 };
74
75 /* timing globals */
76 static uint64_t get_total_size = 0;
77 static unsigned int get_total_time_ms = 0;
78 static uint64_t put_total_size = 0;
79 static unsigned int put_total_time_ms = 0;
80
81 /* Unfortunately, there is no way to pass the a context to the completion function as an argument */
82 static struct smbclient_context *rl_ctx;
83
84 /* totals globals */
85 static double dir_total;
86
87 /*******************************************************************
88 Reduce a file name, removing .. elements.
89 ********************************************************************/
90 static void dos_clean_name(char *s)
91 {
92 char *p=NULL,*r;
93
94 DEBUG(3,("dos_clean_name [%s]\n",s));
95
96 /* remove any double slashes */
97 all_string_sub(s, "\\\\", "\\", 0);
98
99 while ((p = strstr(s,"\\..\\")) != NULL) {
100 *p = '\0';
101 if ((r = strrchr(s,'\\')) != NULL)
102 memmove(r,p+3,strlen(p+3)+1);
103 }
104
105 trim_string(s,NULL,"\\..");
106
107 all_string_sub(s, "\\.\\", "\\", 0);
108 }
109
110 /****************************************************************************
111 write to a local file with CR/LF->LF translation if appropriate. return the
112 number taken from the buffer. This may not equal the number written.
113 ****************************************************************************/
114 static int writefile(int f, const void *_b, int n, bool translation)
115 {
116 const uint8_t *b = (const uint8_t *)_b;
117 int i;
118
119 if (!translation) {
120 return write(f,b,n);
121 }
122
123 i = 0;
124 while (i < n) {
125 if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
126 b++;i++;
127 }
128 if (write(f, b, 1) != 1) {
129 break;
130 }
131 b++;
132 i++;
133 }
134
135 return(i);
136 }
137
138 /****************************************************************************
139 read from a file with LF->CR/LF translation if appropriate. return the
140 number read. read approx n bytes.
141 ****************************************************************************/
142 static int readfile(void *_b, int n, XFILE *f, bool translation)
143 {
144 uint8_t *b = (uint8_t *)_b;
145 int i;
146 int c;
147
148 if (!translation)
149 return x_fread(b,1,n,f);
150
151 i = 0;
152 while (i < (n - 1)) {
153 if ((c = x_getc(f)) == EOF) {
154 break;
155 }
156
157 if (c == '\n') { /* change all LFs to CR/LF */
158 b[i++] = '\r';
159 }
160
161 b[i++] = c;
162 }
163
164 return(i);
165 }
166
167
168 /****************************************************************************
169 send a message
170 ****************************************************************************/
171 static void send_message(struct smbcli_state *cli, const char *desthost)
172 {
173 char msg[1600];
174 int total_len = 0;
175 int grp_id;
176
177 if (!smbcli_message_start(cli->tree, desthost, cli_credentials_get_username(cmdline_credentials), &grp_id)) {
178 d_printf("message start: %s\n", smbcli_errstr(cli->tree));
179 return;
180 }
181
182
183 d_printf("Connected. Type your message, ending it with a Control-D\n");
184
185 while (!feof(stdin) && total_len < 1600) {
186 int maxlen = MIN(1600 - total_len,127);
187 int l=0;
188 int c;
189
190 for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
191 if (c == '\n')
192 msg[l++] = '\r';
193 msg[l] = c;
194 }
195
196 if (!smbcli_message_text(cli->tree, msg, l, grp_id)) {
197 d_printf("SMBsendtxt failed (%s)\n",smbcli_errstr(cli->tree));
198 return;
199 }
200
201 total_len += l;
202 }
203
204 if (total_len >= 1600)
205 d_printf("the message was truncated to 1600 bytes\n");
206 else
207 d_printf("sent %d bytes\n",total_len);
208
209 if (!smbcli_message_end(cli->tree, grp_id)) {
210 d_printf("SMBsendend failed (%s)\n",smbcli_errstr(cli->tree));
211 return;
212 }
213 }
214
215
216
217 /****************************************************************************
218 check the space on a device
219 ****************************************************************************/
220 static int do_dskattr(struct smbclient_context *ctx)
221 {
222 uint32_t bsize;
223 uint64_t total, avail;
224
225 if (NT_STATUS_IS_ERR(smbcli_dskattr(ctx->cli->tree, &bsize, &total, &avail))) {
226 d_printf("Error in dskattr: %s\n",smbcli_errstr(ctx->cli->tree));
227 return 1;
228 }
229
230 d_printf("\n\t\t%llu blocks of size %u. %llu blocks available\n",
231 (unsigned long long)total,
232 (unsigned)bsize,
233 (unsigned long long)avail);
234
235 return 0;
236 }
237
238 /****************************************************************************
239 show cd/pwd
240 ****************************************************************************/
241 static int cmd_pwd(struct smbclient_context *ctx, const char **args)
242 {
243 d_printf("Current directory is %s\n", ctx->remote_cur_dir);
244 return 0;
245 }
246
247 /*
248 convert a string to dos format
249 */
250 static void dos_format(char *s)
251 {
252 string_replace(s, '/', '\\');
253 }
254
255 /****************************************************************************
256 change directory - inner section
257 ****************************************************************************/
258 static int do_cd(struct smbclient_context *ctx, const char *newdir)
259 {
260 char *dname;
261
262 /* Save the current directory in case the
263 new directory is invalid */
264 if (newdir[0] == '\\')
265 dname = talloc_strdup(ctx, newdir);
266 else
267 dname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, newdir);
268
269 dos_format(dname);
270
271 if (*(dname+strlen(dname)-1) != '\\') {
272 dname = talloc_append_string(NULL, dname, "\\");
273 }
274 dos_clean_name(dname);
275
276 if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx->cli->tree, dname))) {
277 d_printf("cd %s: %s\n", dname, smbcli_errstr(ctx->cli->tree));
278 talloc_free(dname);
279 } else {
280 ctx->remote_cur_dir = dname;
281 }
282
283 return 0;
284 }
285
286 /****************************************************************************
287 change directory
288 ****************************************************************************/
289 static int cmd_cd(struct smbclient_context *ctx, const char **args)
290 {
291 int rc = 0;
292
293 if (args[1])
294 rc = do_cd(ctx, args[1]);
295 else
296 d_printf("Current directory is %s\n",ctx->remote_cur_dir);
297
298 return rc;
299 }
300
301
302 static bool mask_match(struct smbcli_state *c, const char *string,
303 const char *pattern, bool is_case_sensitive)
304 {
305 char *p2, *s2;
306 bool ret;
307
308 if (ISDOTDOT(string))
309 string = ".";
310 if (ISDOT(pattern))
311 return false;
312
313 if (is_case_sensitive)
314 return ms_fnmatch_protocol(pattern, string,
315 c->transport->negotiate.protocol) == 0;
316
317 p2 = strlower_talloc(NULL, pattern);
318 s2 = strlower_talloc(NULL, string);
319 ret = ms_fnmatch_protocol(p2, s2, c->transport->negotiate.protocol) == 0;
320 talloc_free(p2);
321 talloc_free(s2);
322
323 return ret;
324 }
325
326
327
328 /*******************************************************************
329 decide if a file should be operated on
330 ********************************************************************/
331 static bool do_this_one(struct smbclient_context *ctx, struct clilist_file_info *finfo)
332 {
333 if (finfo->attrib & FILE_ATTRIBUTE_DIRECTORY) return(true);
334
335 if (ctx->fileselection &&
336 !mask_match(ctx->cli, finfo->name,ctx->fileselection,false)) {
337 DEBUG(3,("mask_match %s failed\n", finfo->name));
338 return false;
339 }
340
341 if (ctx->newer_than && finfo->mtime < ctx->newer_than) {
342 DEBUG(3,("newer_than %s failed\n", finfo->name));
343 return(false);
344 }
345
346 if ((ctx->archive_level==1 || ctx->archive_level==2) && !(finfo->attrib & FILE_ATTRIBUTE_ARCHIVE)) {
347 DEBUG(3,("archive %s failed\n", finfo->name));
348 return(false);
349 }
350
351 return(true);
352 }
353
354 /****************************************************************************
355 display info about a file
356 ****************************************************************************/
357 static void display_finfo(struct smbclient_context *ctx, struct clilist_file_info *finfo)
358 {
359 if (do_this_one(ctx, finfo)) {
360 time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */
361 char *astr = attrib_string(NULL, finfo->attrib);
362 d_printf(" %-30s%7.7s %8.0f %s",
363 finfo->name,
364 astr,
365 (double)finfo->size,
366 asctime(localtime(&t)));
367 dir_total += finfo->size;
368 talloc_free(astr);
369 }
370 }
371
372
373 /****************************************************************************
374 accumulate size of a file
375 ****************************************************************************/
376 static void do_du(struct smbclient_context *ctx, struct clilist_file_info *finfo)
377 {
378 if (do_this_one(ctx, finfo)) {
379 dir_total += finfo->size;
380 }
381 }
382
383 static bool do_list_recurse;
384 static bool do_list_dirs;
385 static char *do_list_queue = 0;
386 static long do_list_queue_size = 0;
387 static long do_list_queue_start = 0;
388 static long do_list_queue_end = 0;
389 static void (*do_list_fn)(struct smbclient_context *, struct clilist_file_info *);
390
391 /****************************************************************************
392 functions for do_list_queue
393 ****************************************************************************/
394
395 /*
396 * The do_list_queue is a NUL-separated list of strings stored in a
397 * char*. Since this is a FIFO, we keep track of the beginning and
398 * ending locations of the data in the queue. When we overflow, we
399 * double the size of the char*. When the start of the data passes
400 * the midpoint, we move everything back. This is logically more
401 * complex than a linked list, but easier from a memory management
402 * angle. In any memory error condition, do_list_queue is reset.
403 * Functions check to ensure that do_list_queue is non-NULL before
404 * accessing it.
405 */
406 static void reset_do_list_queue(void)
407 {
408 SAFE_FREE(do_list_queue);
409 do_list_queue_size = 0;
410 do_list_queue_start = 0;
411 do_list_queue_end = 0;
412 }
413
414 static void init_do_list_queue(void)
415 {
416 reset_do_list_queue();
417 do_list_queue_size = 1024;
418 do_list_queue = malloc_array_p(char, do_list_queue_size);
419 if (do_list_queue == 0) {
420 d_printf("malloc fail for size %d\n",
421 (int)do_list_queue_size);
422 reset_do_list_queue();
423 } else {
424 memset(do_list_queue, 0, do_list_queue_size);
425 }
426 }
427
428 static void adjust_do_list_queue(void)
429 {
430 if (do_list_queue == NULL) return;
431
432 /*
433 * If the starting point of the queue is more than half way through,
434 * move everything toward the beginning.
435 */
436 if (do_list_queue_start == do_list_queue_end)
437 {
438 DEBUG(4,("do_list_queue is empty\n"));
439 do_list_queue_start = do_list_queue_end = 0;
440 *do_list_queue = '\0';
441 }
442 else if (do_list_queue_start > (do_list_queue_size / 2))
443 {
444 DEBUG(4,("sliding do_list_queue backward\n"));
445 memmove(do_list_queue,
446 do_list_queue + do_list_queue_start,
447 do_list_queue_end - do_list_queue_start);
448 do_list_queue_end -= do_list_queue_start;
449 do_list_queue_start = 0;
450 }
451
452 }
453
454 static void add_to_do_list_queue(const char* entry)
455 {
456 char *dlq;
457 long new_end;
458
459 if (entry == NULL) {
460 entry = "";
461 }
462
463 new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
464 while (new_end > do_list_queue_size)
465 {
466 do_list_queue_size *= 2;
467 DEBUG(4,("enlarging do_list_queue to %d\n",
468 (int)do_list_queue_size));
469 dlq = realloc_p(do_list_queue, char, do_list_queue_size);
470 if (! dlq) {
471 d_printf("failure enlarging do_list_queue to %d bytes\n",
472 (int)do_list_queue_size);
473 reset_do_list_queue();
474 }
475 else
476 {
477 do_list_queue = dlq;
478 memset(do_list_queue + do_list_queue_size / 2,
479 0, do_list_queue_size / 2);
480 }
481 }
482 if (do_list_queue)
483 {
484 strlcpy(do_list_queue + do_list_queue_end, entry,
485 do_list_queue_size - do_list_queue_end);
486 do_list_queue_end = new_end;
487 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
488 entry, (int)do_list_queue_start, (int)do_list_queue_end));
489 }
490 }
491
492 static char *do_list_queue_head(void)
493 {
494 return do_list_queue + do_list_queue_start;
495 }
496
497 static void remove_do_list_queue_head(void)
498 {
499 if (do_list_queue_end > do_list_queue_start)
500 {
501 do_list_queue_start += strlen(do_list_queue_head()) + 1;
502 adjust_do_list_queue();
503 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
504 (int)do_list_queue_start, (int)do_list_queue_end));
505 }
506 }
507
508 static int do_list_queue_empty(void)
509 {
510 return (! (do_list_queue && *do_list_queue));
511 }
512
513 /****************************************************************************
514 a helper for do_list
515 ****************************************************************************/
516 static void do_list_helper(struct clilist_file_info *f, const char *mask, void *state)
517 {
518 struct smbclient_context *ctx = (struct smbclient_context *)state;
519
520 if (f->attrib & FILE_ATTRIBUTE_DIRECTORY) {
521 if (do_list_dirs && do_this_one(ctx, f)) {
522 do_list_fn(ctx, f);
523 }
524 if (do_list_recurse &&
525 !ISDOT(f->name) &&
526 !ISDOTDOT(f->name)) {
527 char *mask2;
528 char *p;
529
530 mask2 = talloc_strdup(NULL, mask);
531 p = strrchr_m(mask2,'\\');
532 if (!p) return;
533 p[1] = 0;
534 mask2 = talloc_asprintf_append_buffer(mask2, "%s\\*", f->name);
535 add_to_do_list_queue(mask2);
536 }
537 return;
538 }
539
540 if (do_this_one(ctx, f)) {
541 do_list_fn(ctx, f);
542 }
543 }
544
545
546 /****************************************************************************
547 a wrapper around smbcli_list that adds recursion
548 ****************************************************************************/
549 static void do_list(struct smbclient_context *ctx, const char *mask,uint16_t attribute,
550 void (*fn)(struct smbclient_context *, struct clilist_file_info *),bool rec, bool dirs)
551 {
552 static int in_do_list = 0;
553
554 if (in_do_list && rec)
555 {
556 fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
557 exit(1);
558 }
559
560 in_do_list = 1;
561
562 do_list_recurse = rec;
563 do_list_dirs = dirs;
564 do_list_fn = fn;
565
566 if (rec)
567 {
568 init_do_list_queue();
569 add_to_do_list_queue(mask);
570
571 while (! do_list_queue_empty())
572 {
573 /*
574 * Need to copy head so that it doesn't become
575 * invalid inside the call to smbcli_list. This
576 * would happen if the list were expanded
577 * during the call.
578 * Fix from E. Jay Berkenbilt (ejb@ql.org)
579 */
580 char *head;
581 head = do_list_queue_head();
582 smbcli_list(ctx->cli->tree, head, attribute, do_list_helper, ctx);
583 remove_do_list_queue_head();
584 if ((! do_list_queue_empty()) && (fn == display_finfo))
585 {
586 char* next_file = do_list_queue_head();
587 char* save_ch = 0;
588 if ((strlen(next_file) >= 2) &&
589 (next_file[strlen(next_file) - 1] == '*') &&
590 (next_file[strlen(next_file) - 2] == '\\'))
591 {
592 save_ch = next_file +
593 strlen(next_file) - 2;
594 *save_ch = '\0';
595 }
596 d_printf("\n%s\n",next_file);
597 if (save_ch)
598 {
599 *save_ch = '\\';
600 }
601 }
602 }
603 }
604 else
605 {
606 if (smbcli_list(ctx->cli->tree, mask, attribute, do_list_helper, ctx) == -1)
607 {
608 d_printf("%s listing %s\n", smbcli_errstr(ctx->cli->tree), mask);
609 }
610 }
611
612 in_do_list = 0;
613 reset_do_list_queue();
614 }
615
616 /****************************************************************************
617 get a directory listing
618 ****************************************************************************/
619 static int cmd_dir(struct smbclient_context *ctx, const char **args)
620 {
621 uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
622 char *mask;
623 int rc;
624
625 dir_total = 0;
626
627 mask = talloc_strdup(ctx, ctx->remote_cur_dir);
628 if(mask[strlen(mask)-1]!='\\')
629 mask = talloc_append_string(ctx, mask,"\\");
630
631 if (args[1]) {
632 mask = talloc_strdup(ctx, args[1]);
633 if (mask[0] != '\\')
634 mask = talloc_append_string(ctx, mask, "\\");
635 dos_format(mask);
636 }
637 else {
638 if (ctx->cli->tree->session->transport->negotiate.protocol <=
639 PROTOCOL_LANMAN1) {
640 mask = talloc_append_string(ctx, mask, "*.*");
641 } else {
642 mask = talloc_append_string(ctx, mask, "*");
643 }
644 }
645
646 do_list(ctx, mask, attribute, display_finfo, ctx->recurse, true);
647
648 rc = do_dskattr(ctx);
649
650 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
651
652 return rc;
653 }
654
655
656 /****************************************************************************
657 get a directory listing
658 ****************************************************************************/
659 static int cmd_du(struct smbclient_context *ctx, const char **args)
660 {
661 uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
662 int rc;
663 char *mask;
664
665 dir_total = 0;
666
667 if (args[1]) {
668 if (args[1][0] == '\\')
669 mask = talloc_strdup(ctx, args[1]);
670 else
671 mask = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
672 dos_format(mask);
673 } else {
674 mask = talloc_asprintf(ctx, "%s\\*", ctx->remote_cur_dir);
675 }
676
677 do_list(ctx, mask, attribute, do_du, ctx->recurse, true);
678
679 talloc_free(mask);
680
681 rc = do_dskattr(ctx);
682
683 d_printf("Total number of bytes: %.0f\n", dir_total);
684
685 return rc;
686 }
687
688
689 /****************************************************************************
690 get a file from rname to lname
691 ****************************************************************************/
692 static int do_get(struct smbclient_context *ctx, char *rname, const char *p_lname, bool reget)
693 {
694 int handle = 0, fnum;
695 bool newhandle = false;
696 uint8_t *data;
697 struct timeval tp_start;
698 int read_size = ctx->io_bufsize;
699 uint16_t attr;
700 size_t size;
701 off_t start = 0;
702 off_t nread = 0;
703 int rc = 0;
704 char *lname;
705
706
707 GetTimeOfDay(&tp_start);
708
709 if (ctx->lowercase) {
710 lname = strlower_talloc(ctx, p_lname);
711 } else {
712 lname = talloc_strdup(ctx, p_lname);
713 }
714
715 fnum = smbcli_open(ctx->cli->tree, rname, O_RDONLY, DENY_NONE);
716
717 if (fnum == -1) {
718 d_printf("%s opening remote file %s\n",smbcli_errstr(ctx->cli->tree),rname);
719 return 1;
720 }
721
722 if(!strcmp(lname,"-")) {
723 handle = fileno(stdout);
724 } else {
725 if (reget) {
726 handle = open(lname, O_WRONLY|O_CREAT, 0644);
727 if (handle >= 0) {
728 start = lseek(handle, 0, SEEK_END);
729 if (start == -1) {
730 d_printf("Error seeking local file\n");
731 close(handle);
732 return 1;
733 }
734 }
735 } else {
736 handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
737 }
738 newhandle = true;
739 }
740 if (handle < 0) {
741 d_printf("Error opening local file %s\n",lname);
742 return 1;
743 }
744
745
746 if (NT_STATUS_IS_ERR(smbcli_qfileinfo(ctx->cli->tree, fnum,
747 &attr, &size, NULL, NULL, NULL, NULL, NULL)) &&
748 NT_STATUS_IS_ERR(smbcli_getattrE(ctx->cli->tree, fnum,
749 &attr, &size, NULL, NULL, NULL))) {
750 d_printf("getattrib: %s\n",smbcli_errstr(ctx->cli->tree));
751 if (newhandle) {
752 close(handle);
753 }
754 return 1;
755 }
756
757 DEBUG(2,("getting file %s of size %.0f as %s ",
758 rname, (double)size, lname));
759
760 if(!(data = (uint8_t *)malloc(read_size))) {
761 d_printf("malloc fail for size %d\n", read_size);
762 smbcli_close(ctx->cli->tree, fnum);
763 if (newhandle) {
764 close(handle);
765 }
766 return 1;
767 }
768
769 while (1) {
770 int n = smbcli_read(ctx->cli->tree, fnum, data, nread + start, read_size);
771
772 if (n <= 0) break;
773
774 if (writefile(handle,data, n, ctx->translation) != n) {
775 d_printf("Error writing local file\n");
776 rc = 1;
777 break;
778 }
779
780 nread += n;
781 }
782
783 if (nread + start < size) {
784 DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n",
785 rname, (long)nread));
786
787 rc = 1;
788 }
789
790 SAFE_FREE(data);
791
792 if (NT_STATUS_IS_ERR(smbcli_close(ctx->cli->tree, fnum))) {
793 d_printf("Error %s closing remote file\n",smbcli_errstr(ctx->cli->tree));
794 rc = 1;
795 }
796
797 if (newhandle) {
798 close(handle);
799 }
800
801 if (ctx->archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
802 smbcli_setatr(ctx->cli->tree, rname, attr & ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE, 0);
803 }
804
805 {
806 struct timeval tp_end;
807 int this_time;
808
809 GetTimeOfDay(&tp_end);
810 this_time =
811 (tp_end.tv_sec - tp_start.tv_sec)*1000 +
812 (tp_end.tv_usec - tp_start.tv_usec)/1000;
813 get_total_time_ms += this_time;
814 get_total_size += nread;
815
816 DEBUG(2,("(%3.1f kb/s) (average %3.1f kb/s)\n",
817 nread / (1.024*this_time + 1.0e-4),
818 get_total_size / (1.024*get_total_time_ms)));
819 }
820
821 return rc;
822 }
823
824
825 /****************************************************************************
826 get a file
827 ****************************************************************************/
828 static int cmd_get(struct smbclient_context *ctx, const char **args)
829 {
830 const char *lname;
831 char *rname;
832
833 if (!args[1]) {
834 d_printf("get <filename>\n");
835 return 1;
836 }
837
838 rname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
839
840 if (args[2])
841 lname = args[2];
842 else
843 lname = args[1];
844
845 dos_clean_name(rname);
846
847 return do_get(ctx, rname, lname, false);
848 }
849
850 /****************************************************************************
851 Put up a yes/no prompt.
852 ****************************************************************************/
853 static bool yesno(char *p)
854 {
855 char ans[4];
856 printf("%s",p);
857
858 if (!fgets(ans,sizeof(ans)-1,stdin))
859 return(false);
860
861 if (*ans == 'y' || *ans == 'Y')
862 return(true);
863
864 return(false);
865 }
866
867 /****************************************************************************
868 do a mget operation on one file
869 ****************************************************************************/
870 static void do_mget(struct smbclient_context *ctx, struct clilist_file_info *finfo)
871 {
872 char *rname;
873 char *quest;
874 char *mget_mask;
875 char *saved_curdir;
876 char *l_fname;
877
878 if (ISDOT(finfo->name) || ISDOTDOT(finfo->name))
879 return;
880
881 if (finfo->attrib & FILE_ATTRIBUTE_DIRECTORY)
882 quest = talloc_asprintf(ctx, "Get directory %s? ",finfo->name);
883 else
884 quest = talloc_asprintf(ctx, "Get file %s? ",finfo->name);
885
886 if (ctx->prompt && !yesno(quest)) return;
887
888 talloc_free(quest);
889
890 if (!(finfo->attrib & FILE_ATTRIBUTE_DIRECTORY)) {
891 rname = talloc_asprintf(ctx, "%s%s",ctx->remote_cur_dir,
892 finfo->name);
893 do_get(ctx, rname, finfo->name, false);
894 talloc_free(rname);
895 return;
896 }
897
898 /* handle directories */
899 saved_curdir = talloc_strdup(ctx, ctx->remote_cur_dir);
900
901 ctx->remote_cur_dir = talloc_asprintf_append_buffer(NULL, "%s\\", finfo->name);
902
903 if (ctx->lowercase) {
904 l_fname = strlower_talloc(ctx, finfo->name);
905 } else {
906 l_fname = talloc_strdup(ctx, finfo->name);
907 }
908
909 string_replace(l_fname, '\\', '/');
910
911 if (!directory_exist(l_fname) &&
912 mkdir(l_fname, 0777) != 0) {
913 d_printf("failed to create directory %s\n", l_fname);
914 return;
915 }
916
917 if (chdir(l_fname) != 0) {
918 d_printf("failed to chdir to directory %s\n", l_fname);
919 return;
920 }
921
922 mget_mask = talloc_asprintf(ctx, "%s*", ctx->remote_cur_dir);
923
924 do_list(ctx, mget_mask, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,do_mget,false, true);
925 chdir("..");
926 talloc_free(ctx->remote_cur_dir);
927
928 ctx->remote_cur_dir = saved_curdir;
929 }
930
931
932 /****************************************************************************
933 view the file using the pager
934 ****************************************************************************/
935 static int cmd_more(struct smbclient_context *ctx, const char **args)
936 {
937 char *rname;
938 char *pager_cmd;
939 char *lname;
940 char *pager;
941 int fd;
942 int rc = 0;
943 mode_t mask;
944
945 lname = talloc_asprintf(ctx, "%s/smbmore.XXXXXX",tmpdir());
946 mask = umask(S_IRWXO | S_IRWXG);
947 fd = mkstemp(lname);
948 umask(mask);
949 if (fd == -1) {
950 d_printf("failed to create temporary file for more\n");
951 return 1;
952 }
953 close(fd);
954
955 if (!args[1]) {
956 d_printf("more <filename>\n");
957 unlink(lname);
958 return 1;
959 }
960 rname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
961 dos_clean_name(rname);
962
963 rc = do_get(ctx, rname, lname, false);
964
965 pager=getenv("PAGER");
966
967 pager_cmd = talloc_asprintf(ctx, "%s %s",(pager? pager:DEFAULT_PAGER), lname);
968 system(pager_cmd);
969 unlink(lname);
970
971 return rc;
972 }
973
974
975
976 /****************************************************************************
977 do a mget command
978 ****************************************************************************/
979 static int cmd_mget(struct smbclient_context *ctx, const char **args)
980 {
981 uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
982 char *mget_mask = NULL;
983 int i;
984
985 if (ctx->recurse)
986 attribute |= FILE_ATTRIBUTE_DIRECTORY;
987
988 for (i = 1; args[i]; i++) {
989 mget_mask = talloc_strdup(ctx, ctx->remote_cur_dir);
990 if(mget_mask[strlen(mget_mask)-1]!='\\')
991 mget_mask = talloc_append_string(ctx, mget_mask, "\\");
992
993 mget_mask = talloc_strdup(ctx, args[i]);
994 if (mget_mask[0] != '\\')
995 mget_mask = talloc_append_string(ctx, mget_mask, "\\");
996 do_list(ctx, mget_mask, attribute,do_mget,false,true);
997
998 talloc_free(mget_mask);
999 }
1000
1001 if (mget_mask == NULL) {
1002 mget_mask = talloc_asprintf(ctx, "%s\\*", ctx->remote_cur_dir);
1003 do_list(ctx, mget_mask, attribute,do_mget,false,true);
1004 talloc_free(mget_mask);
1005 }
1006
1007 return 0;
1008 }
1009
1010
1011 /****************************************************************************
1012 make a directory of name "name"
1013 ****************************************************************************/
1014 static NTSTATUS do_mkdir(struct smbclient_context *ctx, char *name)
1015 {
1016 NTSTATUS status;
1017
1018 if (NT_STATUS_IS_ERR(status = smbcli_mkdir(ctx->cli->tree, name))) {
1019 d_printf("%s making remote directory %s\n",
1020 smbcli_errstr(ctx->cli->tree),name);
1021 return status;
1022 }
1023
1024 return status;
1025 }
1026
1027
1028 /****************************************************************************
1029 Exit client.
1030 ****************************************************************************/
1031 static int cmd_quit(struct smbclient_context *ctx, const char **args)
1032 {
1033 talloc_free(ctx);
1034 exit(0);
1035 /* NOTREACHED */
1036 return 0;
1037 }
1038
1039
1040 /****************************************************************************
1041 make a directory
1042 ****************************************************************************/
1043 static int cmd_mkdir(struct smbclient_context *ctx, const char **args)
1044 {
1045 char *mask, *p;
1046
1047 if (!args[1]) {
1048 if (!ctx->recurse)
1049 d_printf("mkdir <dirname>\n");
1050 return 1;
1051 }
1052
1053 mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir,args[1]);
1054
1055 if (ctx->recurse) {
1056 dos_clean_name(mask);
1057
1058 trim_string(mask,".",NULL);
1059 for (p = strtok(mask,"/\\"); p; p = strtok(p, "/\\")) {
1060 char *parent = talloc_strndup(ctx, mask, PTR_DIFF(p, mask));
1061
1062 if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx->cli->tree, parent))) {
1063 do_mkdir(ctx, parent);
1064 }
1065
1066 talloc_free(parent);
1067 }
1068 } else {
1069 do_mkdir(ctx, mask);
1070 }
1071
1072 return 0;
1073 }
1074
1075 /****************************************************************************
1076 show 8.3 name of a file
1077 ****************************************************************************/
1078 static int cmd_altname(struct smbclient_context *ctx, const char **args)
1079 {
1080 const char *p;
1081 char *altname;
1082 char *name;
1083
1084 if (!args[1]) {
1085 d_printf("altname <file>\n");
1086 return 1;
1087 }
1088
1089 name = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1090
1091 if (!NT_STATUS_IS_OK(smbcli_qpathinfo_alt_name(ctx->cli->tree, name, &p))) {
1092 d_printf("%s getting alt name for %s\n",
1093 smbcli_errstr(ctx->cli->tree),name);
1094 return(false);
1095 }
1096 altname = discard_const_p(char, p);
1097 d_printf("%s\n", altname);
1098
1099 SAFE_FREE(altname);
1100
1101 return 0;
1102 }
1103
1104
1105 /****************************************************************************
1106 put a single file
1107 ****************************************************************************/
1108 static int do_put(struct smbclient_context *ctx, char *rname, char *lname, bool reput)
1109 {
1110 int fnum;
1111 XFILE *f;
1112 size_t start = 0;
1113 off_t nread = 0;
1114 uint8_t *buf = NULL;
1115 int maxwrite = ctx->io_bufsize;
1116 int rc = 0;
1117
1118 struct timeval tp_start;
1119 GetTimeOfDay(&tp_start);
1120
1121 if (reput) {
1122 fnum = smbcli_open(ctx->cli->tree, rname, O_RDWR|O_CREAT, DENY_NONE);
1123 if (fnum >= 0) {
1124 if (NT_STATUS_IS_ERR(smbcli_qfileinfo(ctx->cli->tree, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL)) &&
1125 NT_STATUS_IS_ERR(smbcli_getattrE(ctx->cli->tree, fnum, NULL, &start, NULL, NULL, NULL))) {
1126 d_printf("getattrib: %s\n",smbcli_errstr(ctx->cli->tree));
1127 return 1;
1128 }
1129 }
1130 } else {
1131 fnum = smbcli_open(ctx->cli->tree, rname, O_RDWR|O_CREAT|O_TRUNC,
1132 DENY_NONE);
1133 }
1134
1135 if (fnum == -1) {
1136 d_printf("%s opening remote file %s\n",smbcli_errstr(ctx->cli->tree),rname);
1137 return 1;
1138 }
1139
1140 /* allow files to be piped into smbclient
1141 jdblair 24.jun.98
1142
1143 Note that in this case this function will exit(0) rather
1144 than returning. */
1145 if (!strcmp(lname, "-")) {
1146 f = x_stdin;
1147 /* size of file is not known */
1148 } else {
1149 f = x_fopen(lname,O_RDONLY, 0);
1150 if (f && reput) {
1151 if (x_tseek(f, start, SEEK_SET) == -1) {
1152 d_printf("Error seeking local file\n");
1153 x_fclose(f);
1154 return 1;
1155 }
1156 }
1157 }
1158
1159 if (!f) {
1160 d_printf("Error opening local file %s\n",lname);
1161 return 1;
1162 }
1163
1164
1165 DEBUG(1,("putting file %s as %s ",lname,
1166 rname));
1167
1168 buf = (uint8_t *)malloc(maxwrite);
1169 if (!buf) {
1170 d_printf("ERROR: Not enough memory!\n");
1171 x_fclose(f);
1172 return 1;
1173 }
1174 while (!x_feof(f)) {
1175 int n = maxwrite;
1176 int ret;
1177
1178 if ((n = readfile(buf,n,f,ctx->translation)) < 1) {
1179 if((n == 0) && x_feof(f))
1180 break; /* Empty local file. */
1181
1182 d_printf("Error reading local file: %s\n", strerror(errno));
1183 rc = 1;
1184 break;
1185 }
1186
1187 ret = smbcli_write(ctx->cli->tree, fnum, 0, buf, nread + start, n);
1188
1189 if (n != ret) {
1190 d_printf("Error writing file: %s\n", smbcli_errstr(ctx->cli->tree));
1191 rc = 1;
1192 break;
1193 }
1194
1195 nread += n;
1196 }
1197
1198 if (NT_STATUS_IS_ERR(smbcli_close(ctx->cli->tree, fnum))) {
1199 d_printf("%s closing remote file %s\n",smbcli_errstr(ctx->cli->tree),rname);
1200 x_fclose(f);
1201 SAFE_FREE(buf);
1202 return 1;
1203 }
1204
1205
1206 if (f != x_stdin) {
1207 x_fclose(f);
1208 }
1209
1210 SAFE_FREE(buf);
1211
1212 {
1213 struct timeval tp_end;
1214 int this_time;
1215
1216 GetTimeOfDay(&tp_end);
1217 this_time =
1218 (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1219 (tp_end.tv_usec - tp_start.tv_usec)/1000;
1220 put_total_time_ms += this_time;
1221 put_total_size += nread;
1222
1223 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1224 nread / (1.024*this_time + 1.0e-4),
1225 put_total_size / (1.024*put_total_time_ms)));
1226 }
1227
1228 if (f == x_stdin) {
1229 talloc_free(ctx);
1230 exit(0);
1231 }
1232
1233 return rc;
1234 }
1235
1236
1237
1238 /****************************************************************************
1239 put a file
1240 ****************************************************************************/
1241 static int cmd_put(struct smbclient_context *ctx, const char **args)
1242 {
1243 char *lname;
1244 char *rname;
1245
1246 if (!args[1]) {
1247 d_printf("put <filename> [<remotename>]\n");
1248 return 1;
1249 }
1250
1251 lname = talloc_strdup(ctx, args[1]);
1252
1253 if (args[2]) {
1254 if (args[2][0]=='\\')
1255 rname = talloc_strdup(ctx, args[2]);
1256 else
1257 rname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[2]);
1258 } else {
1259 rname = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, lname);
1260 }
1261
1262 dos_clean_name(rname);
1263
1264 /* allow '-' to represent stdin
1265 jdblair, 24.jun.98 */
1266 if (!file_exist(lname) && (strcmp(lname,"-"))) {
1267 d_printf("%s does not exist\n",lname);
1268 return 1;
1269 }
1270
1271 return do_put(ctx, rname, lname, false);
1272 }
1273
1274 /*************************************
1275 File list structure
1276 *************************************/
1277
1278 static struct file_list {
1279 struct file_list *prev, *next;
1280 char *file_path;
1281 bool isdir;
1282 } *file_list;
1283
1284 /****************************************************************************
1285 Free a file_list structure
1286 ****************************************************************************/
1287
1288 static void free_file_list (struct file_list * list)
1289 {
1290 struct file_list *tmp;
1291
1292 while (list)
1293 {
1294 tmp = list;
1295 DLIST_REMOVE(list, list);
1296 SAFE_FREE(tmp->file_path);
1297 SAFE_FREE(tmp);
1298 }
1299 }
1300
1301 /****************************************************************************
1302 seek in a directory/file list until you get something that doesn't start with
1303 the specified name
1304 ****************************************************************************/
1305 static bool seek_list(struct file_list *list, char *name)
1306 {
1307 while (list) {
1308 trim_string(list->file_path,"./","\n");
1309 if (strncmp(list->file_path, name, strlen(name)) != 0) {
1310 return(true);
1311 }
1312 list = list->next;
1313 }
1314
1315 return(false);
1316 }
1317
1318 /****************************************************************************
1319 set the file selection mask
1320 ****************************************************************************/
1321 static int cmd_select(struct smbclient_context *ctx, const char **args)
1322 {
1323 talloc_free(ctx->fileselection);
1324 ctx->fileselection = talloc_strdup(ctx, args[1]);
1325
1326 return 0;
1327 }
1328
1329 /*******************************************************************
1330 A readdir wrapper which just returns the file name.
1331 ********************************************************************/
1332 static const char *readdirname(DIR *p)
1333 {
1334 struct dirent *ptr;
1335 char *dname;
1336
1337 if (!p)
1338 return(NULL);
1339
1340 ptr = (struct dirent *)readdir(p);
1341 if (!ptr)
1342 return(NULL);
1343
1344 dname = ptr->d_name;
1345
1346 #ifdef NEXT2
1347 if (telldir(p) < 0)
1348 return(NULL);
1349 #endif
1350
1351 #ifdef HAVE_BROKEN_READDIR
1352 /* using /usr/ucb/cc is BAD */
1353 dname = dname - 2;
1354 #endif
1355
1356 {
1357 static char *buf;
1358 int len = NAMLEN(ptr);
1359 buf = talloc_strndup(NULL, dname, len);
1360 dname = buf;
1361 }
1362
1363 return(dname);
1364 }
1365
1366 /****************************************************************************
1367 Recursive file matching function act as find
1368 match must be always set to true when calling this function
1369 ****************************************************************************/
1370 static int file_find(struct smbclient_context *ctx, struct file_list **list, const char *directory,
1371 const char *expression, bool match)
1372 {
1373 DIR *dir;
1374 struct file_list *entry;
1375 struct stat statbuf;
1376 int ret;
1377 char *path;
1378 bool isdir;
1379 const char *dname;
1380
1381 dir = opendir(directory);
1382 if (!dir) return -1;
1383
1384 while ((dname = readdirname(dir))) {
1385 if (ISDOT(dname) || ISDOTDOT(dname)) {
1386 continue;
1387 }
1388
1389 if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
1390 continue;
1391 }
1392
1393 isdir = false;
1394 if (!match || !gen_fnmatch(expression, dname)) {
1395 if (ctx->recurse) {
1396 ret = stat(path, &statbuf);
1397 if (ret == 0) {
1398 if (S_ISDIR(statbuf.st_mode)) {
1399 isdir = true;
1400 ret = file_find(ctx, list, path, expression, false);
1401 }
1402 } else {
1403 d_printf("file_find: cannot stat file %s\n", path);
1404 }
1405
1406 if (ret == -1) {
1407 SAFE_FREE(path);
1408 closedir(dir);
1409 return -1;
1410 }
1411 }
1412 entry = malloc_p(struct file_list);
1413 if (!entry) {
1414 d_printf("Out of memory in file_find\n");
1415 closedir(dir);
1416 return -1;
1417 }
1418 entry->file_path = path;
1419 entry->isdir = isdir;
1420 DLIST_ADD(*list, entry);
1421 } else {
1422 SAFE_FREE(path);
1423 }
1424 }
1425
1426 closedir(dir);
1427 return 0;
1428 }
1429
1430 /****************************************************************************
1431 mput some files
1432 ****************************************************************************/
1433 static int cmd_mput(struct smbclient_context *ctx, const char **args)
1434 {
1435 int i;
1436
1437 for (i = 1; args[i]; i++) {
1438 int ret;
1439 struct file_list *temp_list;
1440 char *quest, *lname, *rname;
1441
1442 printf("%s\n", args[i]);
1443
1444 file_list = NULL;
1445
1446 ret = file_find(ctx, &file_list, ".", args[i], true);
1447 if (ret) {
1448 free_file_list(file_list);
1449 continue;
1450 }
1451
1452 quest = NULL;
1453 lname = NULL;
1454 rname = NULL;
1455
1456 for (temp_list = file_list; temp_list;
1457 temp_list = temp_list->next) {
1458
1459 SAFE_FREE(lname);
1460 if (asprintf(&lname, "%s/", temp_list->file_path) <= 0)
1461 continue;
1462 trim_string(lname, "./", "/");
1463
1464 /* check if it's a directory */
1465 if (temp_list->isdir) {
1466 /* if (!recurse) continue; */
1467
1468 SAFE_FREE(quest);
1469 if (asprintf(&quest, "Put directory %s? ", lname) < 0) break;
1470 if (ctx->prompt && !yesno(quest)) { /* No */
1471 /* Skip the directory */
1472 lname[strlen(lname)-1] = '/';
1473 if (!seek_list(temp_list, lname))
1474 break;
1475 } else { /* Yes */
1476 SAFE_FREE(rname);
1477 if(asprintf(&rname, "%s%s", ctx->remote_cur_dir, lname) < 0) break;
1478 dos_format(rname);
1479 if (NT_STATUS_IS_ERR(smbcli_chkpath(ctx->cli->tree, rname)) &&
1480 NT_STATUS_IS_ERR(do_mkdir(ctx, rname))) {
1481 DEBUG (0, ("Unable to make dir, skipping..."));
1482 /* Skip the directory */
1483 lname[strlen(lname)-1] = '/';
1484 if (!seek_list(temp_list, lname))
1485 break;
1486 }
1487 }
1488 continue;
1489 } else {
1490 SAFE_FREE(quest);
1491 if (asprintf(&quest,"Put file %s? ", lname) < 0) break;
1492 if (ctx->prompt && !yesno(quest)) /* No */
1493 continue;
1494
1495 /* Yes */
1496 SAFE_FREE(rname);
1497 if (asprintf(&rname, "%s%s", ctx->remote_cur_dir, lname) < 0) break;
1498 }
1499
1500 dos_format(rname);
1501
1502 do_put(ctx, rname, lname, false);
1503 }
1504 free_file_list(file_list);
1505 SAFE_FREE(quest);
1506 SAFE_FREE(lname);
1507 SAFE_FREE(rname);
1508 }
1509
1510 return 0;
1511 }
1512
1513
1514 /****************************************************************************
1515 print a file
1516 ****************************************************************************/
1517 static int cmd_print(struct smbclient_context *ctx, const char **args)
1518 {
1519 char *lname, *rname;
1520 char *p;
1521
1522 if (!args[1]) {
1523 d_printf("print <filename>\n");
1524 return 1;
1525 }
1526
1527 lname = talloc_strdup(ctx, args[1]);
1528
1529 rname = talloc_strdup(ctx, lname);
1530 p = strrchr_m(rname,'/');
1531 if (p) {
1532 slprintf(rname, sizeof(rname)-1, "%s-%d", p+1, (int)getpid());
1533 }
1534
1535 if (strequal(lname,"-")) {
1536 slprintf(rname, sizeof(rname)-1, "stdin-%d", (int)getpid());
1537 }
1538
1539 return do_put(ctx, rname, lname, false);
1540 }
1541
1542
1543 static int cmd_rewrite(struct smbclient_context *ctx, const char **args)
1544 {
1545 d_printf("REWRITE: command not implemented (FIXME!)\n");
1546
1547 return 0;
1548 }
1549
1550 /****************************************************************************
1551 delete some files
1552 ****************************************************************************/
1553 static int cmd_del(struct smbclient_context *ctx, const char **args)
1554 {
1555 char *mask;
1556 uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
1557
1558 if (ctx->recurse)
1559 attribute |= FILE_ATTRIBUTE_DIRECTORY;
1560
1561 if (!args[1]) {
1562 d_printf("del <filename>\n");
1563 return 1;
1564 }
1565 mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1566
1567 if (NT_STATUS_IS_ERR(smbcli_unlink(ctx->cli->tree, mask))) {
1568 d_printf("%s deleting remote file %s\n",smbcli_errstr(ctx->cli->tree),mask);
1569 }
1570
1571 return 0;
1572 }
1573
1574
1575 /****************************************************************************
1576 delete a whole directory tree
1577 ****************************************************************************/
1578 static int cmd_deltree(struct smbclient_context *ctx, const char **args)
1579 {
1580 char *dname;
1581 int ret;
1582
1583 if (!args[1]) {
1584 d_printf("deltree <dirname>\n");
1585 return 1;
1586 }
1587
1588 dname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1589
1590 ret = smbcli_deltree(ctx->cli->tree, dname);
1591
1592 if (ret == -1) {
1593 printf("Failed to delete tree %s - %s\n", dname, smbcli_errstr(ctx->cli->tree));
1594 return -1;
1595 }
1596
1597 printf("Deleted %d files in %s\n", ret, dname);
1598
1599 return 0;
1600 }
1601
1602 typedef struct {
1603 const char *level_name;
1604 enum smb_fsinfo_level level;
1605 } fsinfo_level_t;
1606
1607 fsinfo_level_t fsinfo_levels[] = {
1608 {"dskattr", RAW_QFS_DSKATTR},
1609 {"allocation", RAW_QFS_ALLOCATION},
1610 {"volume", RAW_QFS_VOLUME},
1611 {"volumeinfo", RAW_QFS_VOLUME_INFO},
1612 {"sizeinfo", RAW_QFS_SIZE_INFO},
1613 {"deviceinfo", RAW_QFS_DEVICE_INFO},
1614 {"attributeinfo", RAW_QFS_ATTRIBUTE_INFO},
1615 {"unixinfo", RAW_QFS_UNIX_INFO},
1616 {"volume-information", RAW_QFS_VOLUME_INFORMATION},
1617 {"size-information", RAW_QFS_SIZE_INFORMATION},
1618 {"device-information", RAW_QFS_DEVICE_INFORMATION},
1619 {"attribute-information", RAW_QFS_ATTRIBUTE_INFORMATION},
1620 {"quota-information", RAW_QFS_QUOTA_INFORMATION},
1621 {"fullsize-information", RAW_QFS_FULL_SIZE_INFORMATION},
1622 {"objectid", RAW_QFS_OBJECTID_INFORMATION},
1623 {"sector-size-info", RAW_QFS_SECTOR_SIZE_INFORMATION},
1624 {NULL, RAW_QFS_GENERIC}
1625 };
1626
1627
1628 static int cmd_fsinfo(struct smbclient_context *ctx, const char **args)
1629 {
1630 union smb_fsinfo fsinfo;
1631 NTSTATUS status;
1632 fsinfo_level_t *fsinfo_level;
1633
1634 if (!args[1]) {
1635 d_printf("fsinfo <level>, where level is one of following:\n");
1636 fsinfo_level = fsinfo_levels;
1637 while(fsinfo_level->level_name) {
1638 d_printf("%s\n", fsinfo_level->level_name);
1639 fsinfo_level++;
1640 }
1641 return 1;
1642 }
1643
1644 fsinfo_level = fsinfo_levels;
1645 while(fsinfo_level->level_name && !strequal(args[1],fsinfo_level->level_name)) {
1646 fsinfo_level++;
1647 }
1648
1649 if (!fsinfo_level->level_name) {
1650 d_printf("wrong level name!\n");
1651 return 1;
1652 }
1653
1654 fsinfo.generic.level = fsinfo_level->level;
1655 status = smb_raw_fsinfo(ctx->cli->tree, ctx, &fsinfo);
1656 if (!NT_STATUS_IS_OK(status)) {
1657 d_printf("fsinfo-level-%s - %s\n", fsinfo_level->level_name, nt_errstr(status));
1658 return 1;
1659 }
1660
1661 d_printf("fsinfo-level-%s:\n", fsinfo_level->level_name);
1662 switch(fsinfo.generic.level) {
1663 case RAW_QFS_DSKATTR:
1664 d_printf("\tunits_total: %hu\n",
1665 (unsigned short) fsinfo.dskattr.out.units_total);
1666 d_printf("\tblocks_per_unit: %hu\n",
1667 (unsigned short) fsinfo.dskattr.out.blocks_per_unit);
1668 d_printf("\tblocks_size: %hu\n",
1669 (unsigned short) fsinfo.dskattr.out.block_size);
1670 d_printf("\tunits_free: %hu\n",
1671 (unsigned short) fsinfo.dskattr.out.units_free);
1672 break;
1673 case RAW_QFS_ALLOCATION:
1674 d_printf("\tfs_id: %lu\n",
1675 (unsigned long) fsinfo.allocation.out.fs_id);
1676 d_printf("\tsectors_per_unit: %lu\n",
1677 (unsigned long) fsinfo.allocation.out.sectors_per_unit);
1678 d_printf("\ttotal_alloc_units: %lu\n",
1679 (unsigned long) fsinfo.allocation.out.total_alloc_units);
1680 d_printf("\tavail_alloc_units: %lu\n",
1681 (unsigned long) fsinfo.allocation.out.avail_alloc_units);
1682 d_printf("\tbytes_per_sector: %hu\n",
1683 (unsigned short) fsinfo.allocation.out.bytes_per_sector);
1684 break;
1685 case RAW_QFS_VOLUME:
1686 d_printf("\tserial_number: %lu\n",
1687 (unsigned long) fsinfo.volume.out.serial_number);
1688 d_printf("\tvolume_name: %s\n", fsinfo.volume.out.volume_name.s);
1689 break;
1690 case RAW_QFS_VOLUME_INFO:
1691 case RAW_QFS_VOLUME_INFORMATION:
1692 d_printf("\tcreate_time: %s\n",
1693 nt_time_string(ctx,fsinfo.volume_info.out.create_time));
1694 d_printf("\tserial_number: %lu\n",
1695 (unsigned long) fsinfo.volume_info.out.serial_number);
1696 d_printf("\tvolume_name: %s\n", fsinfo.volume_info.out.volume_name.s);
1697 break;
1698 case RAW_QFS_SIZE_INFO:
1699 case RAW_QFS_SIZE_INFORMATION:
1700 d_printf("\ttotal_alloc_units: %llu\n",
1701 (unsigned long long) fsinfo.size_info.out.total_alloc_units);
1702 d_printf("\tavail_alloc_units: %llu\n",
1703 (unsigned long long) fsinfo.size_info.out.avail_alloc_units);
1704 d_printf("\tsectors_per_unit: %lu\n",
1705 (unsigned long) fsinfo.size_info.out.sectors_per_unit);
1706 d_printf("\tbytes_per_sector: %lu\n",
1707 (unsigned long) fsinfo.size_info.out.bytes_per_sector);
1708 break;
1709 case RAW_QFS_DEVICE_INFO:
1710 case RAW_QFS_DEVICE_INFORMATION:
1711 d_printf("\tdevice_type: %lu\n",
1712 (unsigned long) fsinfo.device_info.out.device_type);
1713 d_printf("\tcharacteristics: 0x%lx\n",
1714 (unsigned long) fsinfo.device_info.out.characteristics);
1715 break;
1716 case RAW_QFS_ATTRIBUTE_INFORMATION:
1717 case RAW_QFS_ATTRIBUTE_INFO:
1718 d_printf("\tfs_attr: 0x%lx\n",
1719 (unsigned long) fsinfo.attribute_info.out.fs_attr);
1720 d_printf("\tmax_file_component_length: %lu\n",
1721 (unsigned long) fsinfo.attribute_info.out.max_file_component_length);
1722 d_printf("\tfs_type: %s\n", fsinfo.attribute_info.out.fs_type.s);
1723 break;
1724 case RAW_QFS_UNIX_INFO:
1725 d_printf("\tmajor_version: %hu\n",
1726 (unsigned short) fsinfo.unix_info.out.major_version);
1727 d_printf("\tminor_version: %hu\n",
1728 (unsigned short) fsinfo.unix_info.out.minor_version);
1729 d_printf("\tcapability: 0x%llx\n",
1730 (unsigned long long) fsinfo.unix_info.out.capability);
1731 break;
1732 case RAW_QFS_QUOTA_INFORMATION:
1733 d_printf("\tunknown[3]: [%llu,%llu,%llu]\n",
1734 (unsigned long long) fsinfo.quota_information.out.unknown[0],
1735 (unsigned long long) fsinfo.quota_information.out.unknown[1],
1736 (unsigned long long) fsinfo.quota_information.out.unknown[2]);
1737 d_printf("\tquota_soft: %llu\n",
1738 (unsigned long long) fsinfo.quota_information.out.quota_soft);
1739 d_printf("\tquota_hard: %llu\n",
1740 (unsigned long long) fsinfo.quota_information.out.quota_hard);
1741 d_printf("\tquota_flags: 0x%llx\n",
1742 (unsigned long long) fsinfo.quota_information.out.quota_flags);
1743 break;
1744 case RAW_QFS_FULL_SIZE_INFORMATION:
1745 d_printf("\ttotal_alloc_units: %llu\n",
1746 (unsigned long long) fsinfo.full_size_information.out.total_alloc_units);
1747 d_printf("\tcall_avail_alloc_units: %llu\n",
1748 (unsigned long long) fsinfo.full_size_information.out.call_avail_alloc_units);
1749 d_printf("\tactual_avail_alloc_units: %llu\n",
1750 (unsigned long long) fsinfo.full_size_information.out.actual_avail_alloc_units);
1751 d_printf("\tsectors_per_unit: %lu\n",
1752 (unsigned long) fsinfo.full_size_information.out.sectors_per_unit);
1753 d_printf("\tbytes_per_sector: %lu\n",
1754 (unsigned long) fsinfo.full_size_information.out.bytes_per_sector);
1755 break;
1756 case RAW_QFS_OBJECTID_INFORMATION:
1757 d_printf("\tGUID: %s\n",
1758 GUID_string(ctx,&fsinfo.objectid_information.out.guid));
1759 d_printf("\tunknown[6]: [%llu,%llu,%llu,%llu,%llu,%llu]\n",
1760 (unsigned long long) fsinfo.objectid_information.out.unknown[0],
1761 (unsigned long long) fsinfo.objectid_information.out.unknown[1],
1762 (unsigned long long) fsinfo.objectid_information.out.unknown[2],
1763 (unsigned long long) fsinfo.objectid_information.out.unknown[3],
1764 (unsigned long long) fsinfo.objectid_information.out.unknown[4],
1765 (unsigned long long) fsinfo.objectid_information.out.unknown[5] );
1766 break;
1767 case RAW_QFS_SECTOR_SIZE_INFORMATION:
1768 d_printf("\tlogical_bytes_per_sector: %u\n",
1769 (unsigned)fsinfo.sector_size_info.out.logical_bytes_per_sector);
1770 d_printf("\tphys_bytes_per_sector_atomic: %u\n",
1771 (unsigned)fsinfo.sector_size_info.out.phys_bytes_per_sector_atomic);
1772 d_printf("\tphys_bytes_per_sector_perf: %u\n",
1773 (unsigned)fsinfo.sector_size_info.out.phys_bytes_per_sector_perf);
1774 d_printf("\tfs_effective_phys_bytes_per_sector_atomic: %u\n",
1775 (unsigned)fsinfo.sector_size_info.out.fs_effective_phys_bytes_per_sector_atomic);
1776 d_printf("\tflags: 0x%x\n",
1777 (unsigned)fsinfo.sector_size_info.out.flags);
1778 d_printf("\tbyte_off_sector_align: %u\n",
1779 (unsigned)fsinfo.sector_size_info.out.byte_off_sector_align);
1780 d_printf("\tbyte_off_partition_align: %u\n",
1781 (unsigned)fsinfo.sector_size_info.out.byte_off_partition_align);
1782 break;
1783 case RAW_QFS_GENERIC:
1784 d_printf("\twrong level returned\n");
1785 break;
1786 }
1787
1788 return 0;
1789 }
1790
1791 /****************************************************************************
1792 show as much information as possible about a file
1793 ****************************************************************************/
1794 static int cmd_allinfo(struct smbclient_context *ctx, const char **args)
1795 {
1796 char *fname;
1797 union smb_fileinfo finfo;
1798 NTSTATUS status;
1799 int fnum;
1800
1801 if (!args[1]) {
1802 d_printf("allinfo <filename>\n");
1803 return 1;
1804 }
1805 fname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1806
1807 /* first a ALL_INFO QPATHINFO */
1808 finfo.generic.level = RAW_FILEINFO_ALL_INFO;
1809 finfo.generic.in.file.path = fname;
1810 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1811 if (!NT_STATUS_IS_OK(status)) {
1812 d_printf("%s - %s\n", fname, nt_errstr(status));
1813 return 1;
1814 }
1815
1816 d_printf("\tcreate_time: %s\n", nt_time_string(ctx, finfo.all_info.out.create_time));
1817 d_printf("\taccess_time: %s\n", nt_time_string(ctx, finfo.all_info.out.access_time));
1818 d_printf("\twrite_time: %s\n", nt_time_string(ctx, finfo.all_info.out.write_time));
1819 d_printf("\tchange_time: %s\n", nt_time_string(ctx, finfo.all_info.out.change_time));
1820 d_printf("\tattrib: 0x%x\n", finfo.all_info.out.attrib);
1821 d_printf("\talloc_size: %lu\n", (unsigned long)finfo.all_info.out.alloc_size);
1822 d_printf("\tsize: %lu\n", (unsigned long)finfo.all_info.out.size);
1823 d_printf("\tnlink: %u\n", finfo.all_info.out.nlink);
1824 d_printf("\tdelete_pending: %u\n", finfo.all_info.out.delete_pending);
1825 d_printf("\tdirectory: %u\n", finfo.all_info.out.directory);
1826 d_printf("\tea_size: %u\n", finfo.all_info.out.ea_size);
1827 d_printf("\tfname: '%s'\n", finfo.all_info.out.fname.s);
1828
1829 /* 8.3 name if any */
1830 finfo.generic.level = RAW_FILEINFO_ALT_NAME_INFO;
1831 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1832 if (NT_STATUS_IS_OK(status)) {
1833 d_printf("\talt_name: %s\n", finfo.alt_name_info.out.fname.s);
1834 }
1835
1836 /* file_id if available */
1837 finfo.generic.level = RAW_FILEINFO_INTERNAL_INFORMATION;
1838 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1839 if (NT_STATUS_IS_OK(status)) {
1840 d_printf("\tfile_id %.0f\n",
1841 (double)finfo.internal_information.out.file_id);
1842 }
1843
1844 /* the EAs, if any */
1845 finfo.generic.level = RAW_FILEINFO_ALL_EAS;
1846 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1847 if (NT_STATUS_IS_OK(status)) {
1848 int i;
1849 for (i=0;i<finfo.all_eas.out.num_eas;i++) {
1850 d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i,
1851 finfo.all_eas.out.eas[i].flags,
1852 (int)finfo.all_eas.out.eas[i].value.length,
1853 finfo.all_eas.out.eas[i].name.s);
1854 }
1855 }
1856
1857 /* streams, if available */
1858 finfo.generic.level = RAW_FILEINFO_STREAM_INFO;
1859 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1860 if (NT_STATUS_IS_OK(status)) {
1861 int i;
1862 for (i=0;i<finfo.stream_info.out.num_streams;i++) {
1863 d_printf("\tstream %d:\n", i);
1864 d_printf("\t\tsize %ld\n",
1865 (long)finfo.stream_info.out.streams[i].size);
1866 d_printf("\t\talloc size %ld\n",
1867 (long)finfo.stream_info.out.streams[i].alloc_size);
1868 d_printf("\t\tname %s\n", finfo.stream_info.out.streams[i].stream_name.s);
1869 }
1870 }
1871
1872 /* dev/inode if available */
1873 finfo.generic.level = RAW_FILEINFO_COMPRESSION_INFORMATION;
1874 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1875 if (NT_STATUS_IS_OK(status)) {
1876 d_printf("\tcompressed size %ld\n", (long)finfo.compression_info.out.compressed_size);
1877 d_printf("\tformat %ld\n", (long)finfo.compression_info.out.format);
1878 d_printf("\tunit_shift %ld\n", (long)finfo.compression_info.out.unit_shift);
1879 d_printf("\tchunk_shift %ld\n", (long)finfo.compression_info.out.chunk_shift);
1880 d_printf("\tcluster_shift %ld\n", (long)finfo.compression_info.out.cluster_shift);
1881 }
1882
1883 /* shadow copies if available */
1884 fnum = smbcli_open(ctx->cli->tree, fname, O_RDONLY, DENY_NONE);
1885 if (fnum != -1) {
1886 struct smb_shadow_copy info;
1887 int i;
1888 info.in.file.fnum = fnum;
1889 info.in.max_data = ~0;
1890 status = smb_raw_shadow_data(ctx->cli->tree, ctx, &info);
1891 if (NT_STATUS_IS_OK(status)) {
1892 d_printf("\tshadow_copy: %u volumes %u names\n",
1893 info.out.num_volumes, info.out.num_names);
1894 for (i=0;i<info.out.num_names;i++) {
1895 d_printf("\t%s\n", info.out.names[i]);
1896 finfo.generic.level = RAW_FILEINFO_ALL_INFO;
1897 finfo.generic.in.file.path = talloc_asprintf(ctx, "%s%s",
1898 info.out.names[i], fname);
1899 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1900 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_PATH_NOT_FOUND) ||
1901 NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
1902 continue;
1903 }
1904 if (!NT_STATUS_IS_OK(status)) {
1905 d_printf("%s - %s\n", finfo.generic.in.file.path,
1906 nt_errstr(status));
1907 return 1;
1908 }
1909
1910 d_printf("\t\tcreate_time: %s\n", nt_time_string(ctx, finfo.all_info.out.create_time));
1911 d_printf("\t\twrite_time: %s\n", nt_time_string(ctx, finfo.all_info.out.write_time));
1912 d_printf("\t\tchange_time: %s\n", nt_time_string(ctx, finfo.all_info.out.change_time));
1913 d_printf("\t\tsize: %lu\n", (unsigned long)finfo.all_info.out.size);
1914 }
1915 }
1916 }
1917
1918 return 0;
1919 }
1920
1921
1922 /****************************************************************************
1923 shows EA contents
1924 ****************************************************************************/
1925 static int cmd_eainfo(struct smbclient_context *ctx, const char **args)
1926 {
1927 char *fname;
1928 union smb_fileinfo finfo;
1929 NTSTATUS status;
1930 int i;
1931
1932 if (!args[1]) {
1933 d_printf("eainfo <filename>\n");
1934 return 1;
1935 }
1936 fname = talloc_strdup(ctx, args[1]);
1937
1938 finfo.generic.level = RAW_FILEINFO_ALL_EAS;
1939 finfo.generic.in.file.path = fname;
1940 status = smb_raw_pathinfo(ctx->cli->tree, ctx, &finfo);
1941
1942 if (!NT_STATUS_IS_OK(status)) {
1943 d_printf("RAW_FILEINFO_ALL_EAS - %s\n", nt_errstr(status));
1944 return 1;
1945 }
1946
1947 d_printf("%s has %d EAs\n", fname, finfo.all_eas.out.num_eas);
1948
1949 for (i=0;i<finfo.all_eas.out.num_eas;i++) {
1950 d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i,
1951 finfo.all_eas.out.eas[i].flags,
1952 (int)finfo.all_eas.out.eas[i].value.length,
1953 finfo.all_eas.out.eas[i].name.s);
1954 fflush(stdout);
1955 dump_data(0,
1956 finfo.all_eas.out.eas[i].value.data,
1957 finfo.all_eas.out.eas[i].value.length);
1958 }
1959
1960 return 0;
1961 }
1962
1963
1964 /****************************************************************************
1965 show any ACL on a file
1966 ****************************************************************************/
1967 static int cmd_acl(struct smbclient_context *ctx, const char **args)
1968 {
1969 char *fname;
1970 union smb_fileinfo query;
1971 NTSTATUS status;
1972 int fnum;
1973
1974 if (!args[1]) {
1975 d_printf("acl <filename>\n");
1976 return 1;
1977 }
1978 fname = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
1979
1980 fnum = smbcli_nt_create_full(ctx->cli->tree, fname, 0,
1981 SEC_STD_READ_CONTROL,
1982 0,
1983 NTCREATEX_SHARE_ACCESS_DELETE|
1984 NTCREATEX_SHARE_ACCESS_READ|
1985 NTCREATEX_SHARE_ACCESS_WRITE,
1986 NTCREATEX_DISP_OPEN,
1987 0, 0);
1988 if (fnum == -1) {
1989 d_printf("%s - %s\n", fname, smbcli_errstr(ctx->cli->tree));
1990 return -1;
1991 }
1992
1993 query.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1994 query.query_secdesc.in.file.fnum = fnum;
1995 query.query_secdesc.in.secinfo_flags = 0x7;
1996
1997 status = smb_raw_fileinfo(ctx->cli->tree, ctx, &query);
1998 if (!NT_STATUS_IS_OK(status)) {
1999 d_printf("%s - %s\n", fname, nt_errstr(status));
2000 return 1;
2001 }
2002
2003 NDR_PRINT_DEBUG(security_descriptor, query.query_secdesc.out.sd);
2004
2005 return 0;
2006 }
2007
2008 /****************************************************************************
2009 lookup a name or sid
2010 ****************************************************************************/
2011 static int cmd_lookup(struct smbclient_context *ctx, const char **args)
2012 {
2013 NTSTATUS status;
2014 struct dom_sid *sid;
2015
2016 if (!args[1]) {
2017 d_printf("lookup <sid|name>\n");
2018 return 1;
2019 }
2020
2021 sid = dom_sid_parse_talloc(ctx, args[1]);
2022 if (sid == NULL) {
2023 const char *sidstr;
2024 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sidstr);
2025 if (!NT_STATUS_IS_OK(status)) {
2026 d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
2027 return 1;
2028 }
2029
2030 d_printf("%s\n", sidstr);
2031 } else {
2032 const char *name;
2033 status = smblsa_lookup_sid(ctx->cli, args[1], ctx, &name);
2034 if (!NT_STATUS_IS_OK(status)) {
2035 d_printf("lsa_LookupSids - %s\n", nt_errstr(status));
2036 return 1;
2037 }
2038
2039 d_printf("%s\n", name);
2040 }
2041
2042 return 0;
2043 }
2044
2045 /****************************************************************************
2046 show privileges for a user
2047 ****************************************************************************/
2048 static int cmd_privileges(struct smbclient_context *ctx, const char **args)
2049 {
2050 NTSTATUS status;
2051 struct dom_sid *sid;
2052 struct lsa_RightSet rights;
2053 unsigned i;
2054
2055 if (!args[1]) {
2056 d_printf("privileges <sid|name>\n");
2057 return 1;
2058 }
2059
2060 sid = dom_sid_parse_talloc(ctx, args[1]);
2061 if (sid == NULL) {
2062 const char *sid_str;
2063 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sid_str);
2064 if (!NT_STATUS_IS_OK(status)) {
2065 d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
2066 return 1;
2067 }
2068 sid = dom_sid_parse_talloc(ctx, sid_str);
2069 }
2070
2071 status = smblsa_sid_privileges(ctx->cli, sid, ctx, &rights);
2072 if (!NT_STATUS_IS_OK(status)) {
2073 d_printf("lsa_EnumAccountRights - %s\n", nt_errstr(status));
2074 return 1;
2075 }
2076
2077 for (i=0;i<rights.count;i++) {
2078 d_printf("\t%s\n", rights.names[i].string);
2079 }
2080
2081 return 0;
2082 }
2083
2084
2085 /****************************************************************************
2086 add privileges for a user
2087 ****************************************************************************/
2088 static int cmd_addprivileges(struct smbclient_context *ctx, const char **args)
2089 {
2090 NTSTATUS status;
2091 struct dom_sid *sid;
2092 struct lsa_RightSet rights;
2093 int i;
2094
2095 if (!args[1]) {
2096 d_printf("addprivileges <sid|name> <privilege...>\n");
2097 return 1;
2098 }
2099
2100 sid = dom_sid_parse_talloc(ctx, args[1]);
2101 if (sid == NULL) {
2102 const char *sid_str;
2103 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sid_str);
2104 if (!NT_STATUS_IS_OK(status)) {
2105 d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
2106 return 1;
2107 }
2108 sid = dom_sid_parse_talloc(ctx, sid_str);
2109 }
2110
2111 ZERO_STRUCT(rights);
2112 for (i = 2; args[i]; i++) {
2113 rights.names = talloc_realloc(ctx, rights.names,
2114 struct lsa_StringLarge, rights.count+1);
2115 rights.names[rights.count].string = talloc_strdup(ctx, args[i]);
2116 rights.count++;
2117 }
2118
2119
2120 status = smblsa_sid_add_privileges(ctx->cli, sid, ctx, &rights);
2121 if (!NT_STATUS_IS_OK(status)) {
2122 d_printf("lsa_AddAccountRights - %s\n", nt_errstr(status));
2123 return 1;
2124 }
2125
2126 return 0;
2127 }
2128
2129 /****************************************************************************
2130 delete privileges for a user
2131 ****************************************************************************/
2132 static int cmd_delprivileges(struct smbclient_context *ctx, const char **args)
2133 {
2134 NTSTATUS status;
2135 struct dom_sid *sid;
2136 struct lsa_RightSet rights;
2137 int i;
2138
2139 if (!args[1]) {
2140 d_printf("delprivileges <sid|name> <privilege...>\n");
2141 return 1;
2142 }
2143
2144 sid = dom_sid_parse_talloc(ctx, args[1]);
2145 if (sid == NULL) {
2146 const char *sid_str;
2147 status = smblsa_lookup_name(ctx->cli, args[1], ctx, &sid_str);
2148 if (!NT_STATUS_IS_OK(status)) {
2149 d_printf("lsa_LookupNames - %s\n", nt_errstr(status));
2150 return 1;
2151 }
2152 sid = dom_sid_parse_talloc(ctx, sid_str);
2153 }
2154
2155 ZERO_STRUCT(rights);
2156 for (i = 2; args[i]; i++) {
2157 rights.names = talloc_realloc(ctx, rights.names,
2158 struct lsa_StringLarge, rights.count+1);
2159 rights.names[rights.count].string = talloc_strdup(ctx, args[i]);
2160 rights.count++;
2161 }
2162
2163
2164 status = smblsa_sid_del_privileges(ctx->cli, sid, ctx, &rights);
2165 if (!NT_STATUS_IS_OK(status)) {
2166 d_printf("lsa_RemoveAccountRights - %s\n", nt_errstr(status));
2167 return 1;
2168 }
2169
2170 return 0;
2171 }
2172
2173
2174 /****************************************************************************
2175 open a file
2176 ****************************************************************************/
2177 static int cmd_open(struct smbclient_context *ctx, const char **args)
2178 {
2179 char *filename;
2180 union smb_open io;
2181 NTSTATUS status;
2182 TALLOC_CTX *tmp_ctx;
2183
2184 if (!args[1]) {
2185 d_printf("open <filename>\n");
2186 return 1;
2187 }
2188 tmp_ctx = talloc_new(ctx);
2189
2190 filename = talloc_asprintf(tmp_ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2191
2192 io.generic.level = RAW_OPEN_NTCREATEX;
2193 io.ntcreatex.in.root_fid.fnum = 0;
2194 io.ntcreatex.in.flags = 0;
2195 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2196 io.ntcreatex.in.create_options = 0;
2197 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2198 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ;
2199 io.ntcreatex.in.alloc_size = 0;
2200 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2201 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2202 io.ntcreatex.in.security_flags = 0;
2203 io.ntcreatex.in.fname = filename;
2204
2205 status = smb_raw_open(ctx->cli->tree, tmp_ctx, &io);
2206 talloc_free(tmp_ctx);
2207
2208 if (NT_STATUS_IS_OK(status)) {
2209 d_printf("Opened file with fnum %u\n", (unsigned)io.ntcreatex.out.file.fnum);
2210 } else {
2211 d_printf("Opened failed: %s\n", nt_errstr(status));
2212 }
2213
2214 return 0;
2215 }
2216
2217 /****************************************************************************
2218 close a file
2219 ****************************************************************************/
2220 static int cmd_close(struct smbclient_context *ctx, const char **args)
2221 {
2222 union smb_close io;
2223 NTSTATUS status;
2224 uint16_t fnum;
2225
2226 if (!args[1]) {
2227 d_printf("close <fnum>\n");
2228 return 1;
2229 }
2230
2231 fnum = atoi(args[1]);
2232
2233 ZERO_STRUCT(io);
2234 io.generic.level = RAW_CLOSE_CLOSE;
2235 io.close.in.file.fnum = fnum;
2236
2237 status = smb_raw_close(ctx->cli->tree, &io);
2238
2239 if (NT_STATUS_IS_OK(status)) {
2240 d_printf("Closed file OK\n");
2241 } else {
2242 d_printf("Close failed: %s\n", nt_errstr(status));
2243 }
2244
2245 return 0;
2246 }
2247
2248
2249 /****************************************************************************
2250 remove a directory
2251 ****************************************************************************/
2252 static int cmd_rmdir(struct smbclient_context *ctx, const char **args)
2253 {
2254 char *mask;
2255
2256 if (!args[1]) {
2257 d_printf("rmdir <dirname>\n");
2258 return 1;
2259 }
2260 mask = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2261
2262 if (NT_STATUS_IS_ERR(smbcli_rmdir(ctx->cli->tree, mask))) {
2263 d_printf("%s removing remote directory file %s\n",
2264 smbcli_errstr(ctx->cli->tree),mask);
2265 }
2266
2267 return 0;
2268 }
2269
2270 /****************************************************************************
2271 UNIX hardlink.
2272 ****************************************************************************/
2273 static int cmd_link(struct smbclient_context *ctx, const char **args)
2274 {
2275 char *src,*dest;
2276
2277 if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2278 d_printf("Server doesn't support UNIX CIFS calls.\n");
2279 return 1;
2280 }
2281
2282
2283 if (!args[1] || !args[2]) {
2284 d_printf("link <src> <dest>\n");
2285 return 1;
2286 }
2287
2288 src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2289 dest = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2290
2291 if (NT_STATUS_IS_ERR(smbcli_unix_hardlink(ctx->cli->tree, src, dest))) {
2292 d_printf("%s linking files (%s -> %s)\n", smbcli_errstr(ctx->cli->tree), src, dest);
2293 return 1;
2294 }
2295
2296 return 0;
2297 }
2298
2299 /****************************************************************************
2300 UNIX symlink.
2301 ****************************************************************************/
2302
2303 static int cmd_symlink(struct smbclient_context *ctx, const char **args)
2304 {
2305 char *src,*dest;
2306
2307 if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2308 d_printf("Server doesn't support UNIX CIFS calls.\n");
2309 return 1;
2310 }
2311
2312 if (!args[1] || !args[2]) {
2313 d_printf("symlink <src> <dest>\n");
2314 return 1;
2315 }
2316
2317 src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2318 dest = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2319
2320 if (NT_STATUS_IS_ERR(smbcli_unix_symlink(ctx->cli->tree, src, dest))) {
2321 d_printf("%s symlinking files (%s -> %s)\n",
2322 smbcli_errstr(ctx->cli->tree), src, dest);
2323 return 1;
2324 }
2325
2326 return 0;
2327 }
2328
2329 /****************************************************************************
2330 UNIX chmod.
2331 ****************************************************************************/
2332
2333 static int cmd_chmod(struct smbclient_context *ctx, const char **args)
2334 {
2335 char *src;
2336 mode_t mode;
2337
2338 if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2339 d_printf("Server doesn't support UNIX CIFS calls.\n");
2340 return 1;
2341 }
2342
2343 if (!args[1] || !args[2]) {
2344 d_printf("chmod mode file\n");
2345 return 1;
2346 }
2347
2348 src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2349
2350 mode = (mode_t)strtol(args[1], NULL, 8);
2351
2352 if (NT_STATUS_IS_ERR(smbcli_unix_chmod(ctx->cli->tree, src, mode))) {
2353 d_printf("%s chmod file %s 0%o\n",
2354 smbcli_errstr(ctx->cli->tree), src, (unsigned)mode);
2355 return 1;
2356 }
2357
2358 return 0;
2359 }
2360
2361 /****************************************************************************
2362 UNIX chown.
2363 ****************************************************************************/
2364
2365 static int cmd_chown(struct smbclient_context *ctx, const char **args)
2366 {
2367 char *src;
2368 uid_t uid;
2369 gid_t gid;
2370
2371 if (!(ctx->cli->transport->negotiate.capabilities & CAP_UNIX)) {
2372 d_printf("Server doesn't support UNIX CIFS calls.\n");
2373 return 1;
2374 }
2375
2376 if (!args[1] || !args[2] || !args[3]) {
2377 d_printf("chown uid gid file\n");
2378 return 1;
2379 }
2380
2381 uid = (uid_t)atoi(args[1]);
2382 gid = (gid_t)atoi(args[2]);
2383 src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[3]);
2384
2385 if (NT_STATUS_IS_ERR(smbcli_unix_chown(ctx->cli->tree, src, uid, gid))) {
2386 d_printf("%s chown file %s uid=%d, gid=%d\n",
2387 smbcli_errstr(ctx->cli->tree), src, (int)uid, (int)gid);
2388 return 1;
2389 }
2390
2391 return 0;
2392 }
2393
2394 /****************************************************************************
2395 rename some files
2396 ****************************************************************************/
2397 static int cmd_rename(struct smbclient_context *ctx, const char **args)
2398 {
2399 char *src,*dest;
2400
2401 if (!args[1] || !args[2]) {
2402 d_printf("rename <src> <dest>\n");
2403 return 1;
2404 }
2405
2406 src = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[1]);
2407 dest = talloc_asprintf(ctx, "%s%s", ctx->remote_cur_dir, args[2]);
2408
2409 if (NT_STATUS_IS_ERR(smbcli_rename(ctx->cli->tree, src, dest))) {
2410 d_printf("%s renaming files\n",smbcli_errstr(ctx->cli->tree));
2411 return 1;
2412 }
2413
2414 return 0;
2415 }
2416
2417
2418 /****************************************************************************
2419 toggle the prompt flag
2420 ****************************************************************************/
2421 static int cmd_prompt(struct smbclient_context *ctx, const char **args)
2422 {
2423 ctx->prompt = !ctx->prompt;
2424 DEBUG(2,("prompting is now %s\n",ctx->prompt?"on":"off"));
2425
2426 return 1;
2427 }
2428
2429
2430 /****************************************************************************
2431 set the newer than time
2432 ****************************************************************************/
2433 static int cmd_newer(struct smbclient_context *ctx, const char **args)
2434 {
2435 struct stat sbuf;
2436
2437 if (args[1] && (stat(args[1],&sbuf) == 0)) {
2438 ctx->newer_than = sbuf.st_mtime;
2439 DEBUG(1,("Getting files newer than %s",
2440 asctime(localtime(&ctx->newer_than))));
2441 } else {
2442 ctx->newer_than = 0;
2443 }
2444
2445 if (args[1] && ctx->newer_than == 0) {
2446 d_printf("Error setting newer-than time\n");
2447 return 1;
2448 }
2449
2450 return 0;
2451 }
2452
2453 /****************************************************************************
2454 set the archive level
2455 ****************************************************************************/
2456 static int cmd_archive(struct smbclient_context *ctx, const char **args)
2457 {
2458 if (args[1]) {
2459 ctx->archive_level = atoi(args[1]);
2460 } else
2461 d_printf("Archive level is %d\n",ctx->archive_level);
2462
2463 return 0;
2464 }
2465
2466 /****************************************************************************
2467 toggle the lowercaseflag
2468 ****************************************************************************/
2469 static int cmd_lowercase(struct smbclient_context *ctx, const char **args)
2470 {
2471 ctx->lowercase = !ctx->lowercase;
2472 DEBUG(2,("filename lowercasing is now %s\n",ctx->lowercase?"on":"off"));
2473
2474 return 0;
2475 }
2476
2477
2478
2479
2480 /****************************************************************************
2481 toggle the recurse flag
2482 ****************************************************************************/
2483 static int cmd_recurse(struct smbclient_context *ctx, const char **args)
2484 {
2485 ctx->recurse = !ctx->recurse;
2486 DEBUG(2,("directory recursion is now %s\n",ctx->recurse?"on":"off"));
2487
2488 return 0;
2489 }
2490
2491 /****************************************************************************
2492 toggle the translate flag
2493 ****************************************************************************/
2494 static int cmd_translate(struct smbclient_context *ctx, const char **args)
2495 {
2496 ctx->translation = !ctx->translation;
2497 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
2498 ctx->translation?"on":"off"));
2499
2500 return 0;
2501 }
2502
2503
2504 /****************************************************************************
2505 do a printmode command
2506 ****************************************************************************/
2507 static int cmd_printmode(struct smbclient_context *ctx, const char **args)
2508 {
2509 if (args[1]) {
2510 if (strequal(args[1],"text")) {
2511 ctx->printmode = 0;
2512 } else {
2513 if (strequal(args[1],"graphics"))
2514 ctx->printmode = 1;
2515 else
2516 ctx->printmode = atoi(args[1]);
2517 }
2518 }
2519
2520 switch(ctx->printmode)
2521 {
2522 case 0:
2523 DEBUG(2,("the printmode is now text\n"));
2524 break;
2525 case 1:
2526 DEBUG(2,("the printmode is now graphics\n"));
2527 break;
2528 default:
2529 DEBUG(2,("the printmode is now %d\n", ctx->printmode));
2530 break;
2531 }
2532
2533 return 0;
2534 }
2535
2536 /****************************************************************************
2537 do the lcd command
2538 ****************************************************************************/
2539 static int cmd_lcd(struct smbclient_context *ctx, const char **args)
2540 {
2541 char d[PATH_MAX];
2542
2543 if (args[1])
2544 chdir(args[1]);
2545 DEBUG(2,("the local directory is now %s\n",getcwd(d, PATH_MAX)));
2546
2547 return 0;
2548 }
2549
2550 /****************************************************************************
2551 history
2552 ****************************************************************************/
2553 static int cmd_history(struct smbclient_context *ctx, const char **args)
2554 {
2555 #if defined(HAVE_LIBREADLINE) && defined(HAVE_HISTORY_LIST)
2556 HIST_ENTRY **hlist;
2557 int i;
2558
2559 hlist = history_list();
2560
2561 for (i = 0; hlist && hlist[i]; i++) {
2562 DEBUG(0, ("%d: %s\n", i, hlist[i]->line));
2563 }
2564 #else
2565 DEBUG(0,("no history without readline support\n"));
2566 #endif
2567
2568 return 0;
2569 }
2570
2571 /****************************************************************************
2572 get a file restarting at end of local file
2573 ****************************************************************************/
2574 static int cmd_reget(struct smbclient_context *ctx, const char **args)
2575 {
2576 char *local_name;
2577 char *remote_name;
2578
2579 if (!args[1]) {
2580 d_printf("reget <filename>\n");
2581 return 1;
2582 }
2583 remote_name = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
2584 dos_clean_name(remote_name);
2585
2586 if (args[2])
2587 local_name = talloc_strdup(ctx, args[2]);
2588 else
2589 local_name = talloc_strdup(ctx, args[1]);
2590
2591 return do_get(ctx, remote_name, local_name, true);
2592 }
2593
2594 /****************************************************************************
2595 put a file restarting at end of local file
2596 ****************************************************************************/
2597 static int cmd_reput(struct smbclient_context *ctx, const char **args)
2598 {
2599 char *local_name;
2600 char *remote_name;
2601
2602 if (!args[1]) {
2603 d_printf("reput <filename>\n");
2604 return 1;
2605 }
2606 local_name = talloc_asprintf(ctx, "%s\\%s", ctx->remote_cur_dir, args[1]);
2607
2608 if (!file_exist(local_name)) {
2609 d_printf("%s does not exist\n", local_name);
2610 return 1;
2611 }
2612
2613 if (args[2])
2614 remote_name = talloc_strdup(ctx, args[2]);
2615 else
2616 remote_name = talloc_strdup(ctx, args[1]);
2617
2618 dos_clean_name(remote_name);
2619
2620 return do_put(ctx, remote_name, local_name, true);
2621 }
2622
2623
2624 /*
2625 return a string representing a share type
2626 */
2627 static const char *share_type_str(uint32_t type)
2628 {
2629 switch (type & 0xF) {
2630 case STYPE_DISKTREE:
2631 return "Disk";
2632 case STYPE_PRINTQ:
2633 return "Printer";
2634 case STYPE_DEVICE:
2635 return "Device";
2636 case STYPE_IPC:
2637 return "IPC";
2638 default:
2639 return "Unknown";
2640 }
2641 }
2642
2643
2644 /*
2645 display a list of shares from a level 1 share enum
2646 */
2647 static void display_share_result(struct srvsvc_NetShareCtr1 *ctr1)
2648 {
2649 int i;
2650
2651 for (i=0;i<ctr1->count;i++) {
2652 struct srvsvc_NetShareInfo1 *info = ctr1->array+i;
2653
2654 printf("\t%-15s %-10.10s %s\n",
2655 info->name,
2656 share_type_str(info->type),
2657 info->comment);
2658 }
2659 }
2660
2661
2662
2663 /****************************************************************************
2664 try and browse available shares on a host
2665 ****************************************************************************/
2666 static bool browse_host(struct loadparm_context *lp_ctx,
2667 struct tevent_context *ev_ctx,
2668 const char *query_host)
2669 {
2670 struct dcerpc_pipe *p;
2671 char *binding;
2672 NTSTATUS status;
2673 struct srvsvc_NetShareEnumAll r;
2674 struct srvsvc_NetShareInfoCtr info_ctr;
2675 uint32_t resume_handle = 0;
2676 TALLOC_CTX *mem_ctx = talloc_init("browse_host");
2677 struct srvsvc_NetShareCtr1 ctr1;
2678 uint32_t totalentries = 0;
2679
2680 binding = talloc_asprintf(mem_ctx, "ncacn_np:%s", query_host);
2681
2682 status = dcerpc_pipe_connect(mem_ctx, &p, binding,
2683 &ndr_table_srvsvc,
2684 cmdline_credentials, ev_ctx,
2685 lp_ctx);
2686 if (!NT_STATUS_IS_OK(status)) {
2687 d_printf("Failed to connect to %s - %s\n",
2688 binding, nt_errstr(status));
2689 talloc_free(mem_ctx);
2690 return false;
2691 }
2692
2693 info_ctr.level = 1;
2694 info_ctr.ctr.ctr1 = &ctr1;
2695
2696 r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
2697 r.in.info_ctr = &info_ctr;
2698 r.in.max_buffer = ~0;
2699 r.in.resume_handle = &resume_handle;
2700 r.out.resume_handle = &resume_handle;
2701 r.out.totalentries = &totalentries;
2702 r.out.info_ctr = &info_ctr;
2703
2704 d_printf("\n\tSharename Type Comment\n");
2705 d_printf("\t--------- ---- -------\n");
2706
2707 do {
2708 ZERO_STRUCT(ctr1);
2709 status = dcerpc_srvsvc_NetShareEnumAll_r(p->binding_handle, mem_ctx, &r);
2710
2711 if (NT_STATUS_IS_OK(status) &&
2712 (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA) ||
2713 W_ERROR_IS_OK(r.out.result)) &&
2714 r.out.info_ctr->ctr.ctr1) {
2715 display_share_result(r.out.info_ctr->ctr.ctr1);
2716 resume_handle += r.out.info_ctr->ctr.ctr1->count;
2717 }
2718 } while (NT_STATUS_IS_OK(status) && W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA));
2719
2720 talloc_free(mem_ctx);
2721
2722 if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
2723 d_printf("Failed NetShareEnumAll %s - %s/%s\n",
2724 binding, nt_errstr(status), win_errstr(r.out.result));
2725 return false;
2726 }
2727
2728 return false;
2729 }
2730
2731 /****************************************************************************
2732 try and browse available connections on a host
2733 ****************************************************************************/
2734 static bool list_servers(const char *wk_grp)
2735 {
2736 d_printf("REWRITE: list servers not implemented\n");
2737 return false;
2738 }
2739
2740 /* Some constants for completing filename arguments */
2741
2742 #define COMPL_NONE 0 /* No completions */
2743 #define COMPL_REMOTE 1 /* Complete remote filename */
2744 #define COMPL_LOCAL 2 /* Complete local filename */
2745
2746 static int cmd_help(struct smbclient_context *ctx, const char **args);
2747
2748 /* This defines the commands supported by this client.
2749 * NOTE: The "!" must be the last one in the list because it's fn pointer
2750 * field is NULL, and NULL in that field is used in process_tok()
2751 * (below) to indicate the end of the list. crh
2752 */
2753 static struct
2754 {
2755 const char *name;
2756 int (*fn)(struct smbclient_context *ctx, const char **args);
2757 const char *description;
2758 char compl_args[2]; /* Completion argument info */
2759 } commands[] =
2760 {
2761 {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
2762 {"addprivileges",cmd_addprivileges,"<sid|name> <privilege...> add privileges for a user",{COMPL_NONE,COMPL_NONE}},
2763 {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
2764 {"acl",cmd_acl,"<file> show file ACL",{COMPL_NONE,COMPL_NONE}},
2765 {"allinfo",cmd_allinfo,"<file> show all possible info about a file",{COMPL_NONE,COMPL_NONE}},
2766 {"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}},
2767 {"cancel",cmd_rewrite,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
2768 {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
2769 {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},
2770 {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},
2771 {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
2772 {"delprivileges",cmd_delprivileges,"<sid|name> <privilege...> remove privileges for a user",{COMPL_NONE,COMPL_NONE}},
2773 {"deltree",cmd_deltree,"<dir> delete a whole directory tree",{COMPL_REMOTE,COMPL_NONE}},
2774 {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2775 {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2776 {"eainfo",cmd_eainfo,"<file> show EA contents for a file",{COMPL_NONE,COMPL_NONE}},
2777 {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2778 {"fsinfo",cmd_fsinfo,"query file system info",{COMPL_NONE,COMPL_NONE}},
2779 {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
2780 {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
2781 {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
2782 {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
2783 {"link",cmd_link,"<src> <dest> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
2784 {"lookup",cmd_lookup,"<sid|name> show SID for name or name for SID",{COMPL_NONE,COMPL_NONE}},
2785 {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
2786 {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2787 {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},
2788 {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
2789 {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
2790 {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
2791 {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
2792 {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
2793 {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
2794 {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
2795 {"close",cmd_close,"<fnum> close a file",{COMPL_NONE,COMPL_NONE}},
2796 {"privileges",cmd_privileges,"<user> show privileges for a user",{COMPL_NONE,COMPL_NONE}},
2797 {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
2798 {"printmode",cmd_printmode,"<graphics or text> set the print mode",{COMPL_NONE,COMPL_NONE}},
2799 {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
2800 {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
2801 {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
2802 {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2803 {"queue",cmd_rewrite,"show the print queue",{COMPL_NONE,COMPL_NONE}},
2804 {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2805 {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
2806 {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
2807 {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
2808 {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
2809 {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
2810 {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
2811 {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
2812 {"symlink",cmd_symlink,"<src> <dest> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
2813 {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
2814
2815 /* Yes, this must be here, see crh's comment above. */
2816 {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
2817 {NULL,NULL,NULL,{COMPL_NONE,COMPL_NONE}}
2818 };
2819
2820
2821 /*******************************************************************
2822 lookup a command string in the list of commands, including
2823 abbreviations
2824 ******************************************************************/
2825 static int process_tok(const char *tok)
2826 {
2827 int i = 0, matches = 0;
2828 int cmd=0;
2829 int tok_len = strlen(tok);
2830
2831 while (commands[i].fn != NULL) {
2832 if (strequal(commands[i].name,tok)) {
2833 matches = 1;
2834 cmd = i;
2835 break;
2836 } else if (strncasecmp(commands[i].name, tok, tok_len) == 0) {
2837 matches++;
2838 cmd = i;
2839 }
2840 i++;
2841 }
2842
2843 if (matches == 0)
2844 return(-1);
2845 else if (matches == 1)
2846 return(cmd);
2847 else
2848 return(-2);
2849 }
2850
2851 /****************************************************************************
2852 help
2853 ****************************************************************************/
2854 static int cmd_help(struct smbclient_context *ctx, const char **args)
2855 {
2856 int i=0,j;
2857
2858 if (args[1]) {
2859 if ((i = process_tok(args[1])) >= 0)
2860 d_printf("HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description);
2861 } else {
2862 while (commands[i].description) {
2863 for (j=0; commands[i].description && (j<5); j++) {
2864 d_printf("%-15s",commands[i].name);
2865 i++;
2866 }
2867 d_printf("\n");
2868 }
2869 }
2870 return 0;
2871 }
2872
2873 static int process_line(struct smbclient_context *ctx, const char *cline);
2874 /****************************************************************************
2875 process a -c command string
2876 ****************************************************************************/
2877 static int process_command_string(struct smbclient_context *ctx, const char *cmd)
2878 {
2879 char **lines;
2880 int i, rc = 0;
2881
2882 lines = str_list_make(NULL, cmd, ";");
2883 for (i = 0; lines[i]; i++) {
2884 rc |= process_line(ctx, lines[i]);
2885 }
2886 talloc_free(lines);
2887
2888 return rc;
2889 }
2890
2891 #define MAX_COMPLETIONS 100
2892
2893 typedef struct {
2894 char *dirmask;
2895 char **matches;
2896 int count, samelen;
2897 const char *text;
2898 int len;
2899 } completion_remote_t;
2900
2901 static void completion_remote_filter(struct clilist_file_info *f, const char *mask, void *state)
2902 {
2903 completion_remote_t *info = (completion_remote_t *)state;
2904
2905 if ((info->count < MAX_COMPLETIONS - 1) && (strncmp(info->text, f->name, info->len) == 0) && (!ISDOT(f->name)) && (!ISDOTDOT(f->name))) {
2906 if ((info->dirmask[0] == 0) && !(f->attrib & FILE_ATTRIBUTE_DIRECTORY))
2907 info->matches[info->count] = strdup(f->name);
2908 else {
2909 char *tmp;
2910
2911 if (info->dirmask[0] != 0)
2912 tmp = talloc_asprintf(NULL, "%s/%s", info->dirmask, f->name);
2913 else
2914 tmp = talloc_strdup(NULL, f->name);
2915
2916 if (f->attrib & FILE_ATTRIBUTE_DIRECTORY)
2917 tmp = talloc_append_string(NULL, tmp, "/");
2918 info->matches[info->count] = tmp;
2919 }
2920 if (info->matches[info->count] == NULL)
2921 return;
2922 if (f->attrib & FILE_ATTRIBUTE_DIRECTORY)
2923 smb_readline_ca_char(0);
2924
2925 if (info->count == 1)
2926 info->samelen = strlen(info->matches[info->count]);
2927 else
2928 while (strncmp(info->matches[info->count], info->matches[info->count-1], info->samelen) != 0)
2929 info->samelen--;
2930 info->count++;
2931 }
2932 }
2933
2934 static char **remote_completion(const char *text, int len)
2935 {
2936 char *dirmask;
2937 int i, ret;
2938 completion_remote_t info;
2939
2940 info.samelen = len;
2941 info.text = text;
2942 info.len = len;
2943 info.count = 0;
2944
2945 if (len >= PATH_MAX)
2946 return(NULL);
2947
2948 info.matches = malloc_array_p(char *, MAX_COMPLETIONS);
2949 if (!info.matches) return NULL;
2950 info.matches[0] = NULL;
2951
2952 for (i = len-1; i >= 0; i--)
2953 if ((text[i] == '/') || (text[i] == '\\'))
2954 break;
2955 info.text = text+i+1;
2956 info.samelen = info.len = len-i-1;
2957
2958 if (i > 0) {
2959 info.dirmask = talloc_strndup(NULL, text, i+1);
2960 info.dirmask[i+1] = 0;
2961 ret = asprintf(&dirmask, "%s%*s*", rl_ctx->remote_cur_dir, i-1,
2962 text);
2963 } else {
2964 ret = asprintf(&dirmask, "%s*", rl_ctx->remote_cur_dir);
2965 }
2966 if (ret < 0) {
2967 goto cleanup;
2968 }
2969
2970 if (smbcli_list(rl_ctx->cli->tree, dirmask,
2971 FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
2972 completion_remote_filter, &info) < 0)
2973 goto cleanup;
2974
2975 if (info.count == 2)
2976 info.matches[0] = strdup(info.matches[1]);
2977 else {
2978 info.matches[0] = malloc_array_p(char, info.samelen+1);
2979 if (!info.matches[0])
2980 goto cleanup;
2981 strncpy(info.matches[0], info.matches[1], info.samelen);
2982 info.matches[0][info.samelen] = 0;
2983 }
2984 info.matches[info.count] = NULL;
2985 return info.matches;
2986
2987 cleanup:
2988 for (i = 0; i < info.count; i++)
2989 free(info.matches[i]);
2990 free(info.matches);
2991 return NULL;
2992 }
2993
2994 static char **completion_fn(const char *text, int start, int end)
2995 {
2996 smb_readline_ca_char(' ');
2997
2998 if (start) {
2999 const char *buf, *sp;
3000 int i;
3001 char compl_type;
3002
3003 buf = smb_readline_get_line_buffer();
3004 if (buf == NULL)
3005 return NULL;
3006
3007 sp = strchr(buf, ' ');
3008 if (sp == NULL)
3009 return NULL;
3010
3011 for (i = 0; commands[i].name; i++)
3012 if ((strncmp(commands[i].name, text, sp - buf) == 0) && (commands[i].name[sp - buf] == 0))
3013 break;
3014 if (commands[i].name == NULL)
3015 return NULL;
3016
3017 while (*sp == ' ')
3018 sp++;
3019
3020 if (sp == (buf + start))
3021 compl_type = commands[i].compl_args[0];
3022 else
3023 compl_type = commands[i].compl_args[1];
3024
3025 if (compl_type == COMPL_REMOTE)
3026 return remote_completion(text, end - start);
3027 else /* fall back to local filename completion */
3028 return NULL;
3029 } else {
3030 char **matches;
3031 int i, len, samelen = 0, count=1;
3032
3033 matches = malloc_array_p(char *, MAX_COMPLETIONS);
3034 if (!matches) return NULL;
3035 matches[0] = NULL;
3036
3037 len = strlen(text);
3038 for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
3039 if (strncmp(text, commands[i].name, len) == 0) {
3040 matches[count] = strdup(commands[i].name);
3041 if (!matches[count])
3042 goto cleanup;
3043 if (count == 1)
3044 samelen = strlen(matches[count]);
3045 else
3046 while (strncmp(matches[count], matches[count-1], samelen) != 0)
3047 samelen--;
3048 count++;
3049 }
3050 }
3051
3052 switch (count) {
3053 case 0: /* should never happen */
3054 case 1:
3055 goto cleanup;
3056 case 2:
3057 matches[0] = strdup(matches[1]);
3058 break;
3059 default:
3060 matches[0] = malloc_array_p(char, samelen+1);
3061 if (!matches[0])
3062 goto cleanup;
3063 strncpy(matches[0], matches[1], samelen);
3064 matches[0][samelen] = 0;
3065 }
3066 matches[count] = NULL;
3067 return matches;
3068
3069 cleanup:
3070 count--;
3071 while (count >= 0) {
3072 free(matches[count]);
3073 count--;
3074 }
3075 free(matches);
3076 return NULL;
3077 }
3078 }
3079
3080 /****************************************************************************
3081 make sure we swallow keepalives during idle time
3082 ****************************************************************************/
3083 static void readline_callback(void)
3084 {
3085 static time_t last_t;
3086 time_t t;
3087
3088 t = time(NULL);
3089
3090 if (t - last_t < 5) return;
3091
3092 last_t = t;
3093
3094 smbcli_transport_process(rl_ctx->cli->transport);
3095
3096 if (rl_ctx->cli->tree) {
3097 smbcli_chkpath(rl_ctx->cli->tree, "\\");
3098 }
3099 }
3100
3101 static int process_line(struct smbclient_context *ctx, const char *cline)
3102 {
3103 char **args;
3104 int i;
3105
3106 /* and get the first part of the command */
3107 args = str_list_make_shell(ctx, cline, NULL);
3108 if (!args || !args[0])
3109 return 0;
3110
3111 if ((i = process_tok(args[0])) >= 0) {
3112 const char **a = discard_const_p(const char *, args);
3113 i = commands[i].fn(ctx, a);
3114 } else if (i == -2) {
3115 d_printf("%s: command abbreviation ambiguous\n",args[0]);
3116 } else {
3117 d_printf("%s: command not found\n",args[0]);
3118 }
3119
3120 talloc_free(args);
3121
3122 return i;
3123 }
3124
3125 /****************************************************************************
3126 process commands on stdin
3127 ****************************************************************************/
3128 static int process_stdin(struct smbclient_context *ctx)
3129 {
3130 int rc = 0;
3131 while (1) {
3132 /* display a prompt */
3133 char *the_prompt = talloc_asprintf(ctx, "smb: %s> ", ctx->remote_cur_dir);
3134 char *cline = smb_readline(the_prompt, readline_callback, completion_fn);
3135 talloc_free(the_prompt);
3136
3137 if (!cline) break;
3138
3139 /* special case - first char is ! */
3140 if (*cline == '!') {
3141 system(cline + 1);
3142 free(cline);
3143 continue;
3144 }
3145
3146 rc |= process_command_string(ctx, cline);
3147 free(cline);
3148
3149 }
3150
3151 return rc;
3152 }
3153
3154
3155 /*****************************************************
3156 return a connection to a server
3157 *******************************************************/
3158 static bool do_connect(struct smbclient_context *ctx,
3159 struct tevent_context *ev_ctx,
3160 struct resolve_context *resolve_ctx,
3161 const char *specified_server, const char **ports,
3162 const char *specified_share,
3163 const char *socket_options,
3164 struct cli_credentials *cred,
3165 struct smbcli_options *options,
3166 struct smbcli_session_options *session_options,
3167 struct gensec_settings *gensec_settings)
3168 {
3169 NTSTATUS status;
3170 char *server, *share;
3171
3172 rl_ctx = ctx; /* Ugly hack */
3173
3174 if (strncmp(specified_share, "\\\\", 2) == 0 ||
3175 strncmp(specified_share, "//", 2) == 0) {
3176 bool ok;
3177
3178 ok = smbcli_parse_unc(specified_share, ctx, &server, &share);
3179 if (!ok) {
3180 d_printf("Failed to parse UNC\n");
3181 talloc_free(ctx);
3182 return false;
3183 }
3184 } else {
3185 share = talloc_strdup(ctx, specified_share);
3186 server = talloc_strdup(ctx, specified_server);
3187 if (share == NULL || server == NULL) {
3188 d_printf("Failed to allocate memory for server and share\n");
3189 talloc_free(ctx);
3190 return false;
3191 }
3192 }
3193
3194 ctx->remote_cur_dir = talloc_strdup(ctx, "\\");
3195 if (ctx->remote_cur_dir == NULL) {
3196 talloc_free(ctx);
3197 return false;
3198 }
3199
3200 status = smbcli_full_connection(ctx, &ctx->cli, server, ports,
3201 share, NULL,
3202 socket_options,
3203 cred, resolve_ctx,
3204 ev_ctx, options, session_options,
3205 gensec_settings);
3206 if (!NT_STATUS_IS_OK(status)) {
3207 d_printf("Connection to \\\\%s\\%s failed - %s\n",
3208 server, share, nt_errstr(status));
3209 talloc_free(ctx);
3210 return false;
3211 }
3212
3213 return true;
3214 }
3215
3216 /****************************************************************************
3217 handle a -L query
3218 ****************************************************************************/
3219 static int do_host_query(struct loadparm_context *lp_ctx,
3220 struct tevent_context *ev_ctx,
3221 const char *query_host,
3222 const char *workgroup)
3223 {
3224 browse_host(lp_ctx, ev_ctx, query_host);
3225 list_servers(workgroup);
3226 return(0);
3227 }
3228
3229
3230 /****************************************************************************
3231 handle a message operation
3232 ****************************************************************************/
3233 static int do_message_op(const char *netbios_name, const char *desthost,
3234 const char **destports, const char *destip,
3235 int name_type,
3236 struct tevent_context *ev_ctx,
3237 struct resolve_context *resolve_ctx,
3238 struct smbcli_options *options,
3239 const char *socket_options)
3240 {
3241 struct nbt_name called, calling;
3242 const char *server_name;
3243 struct smbcli_state *cli;
3244 bool ok;
3245
3246 make_nbt_name_client(&calling, netbios_name);
3247
3248 nbt_choose_called_name(NULL, &called, desthost, name_type);
3249
3250 server_name = destip ? destip : desthost;
3251
3252 cli = smbcli_state_init(NULL);
3253 if (cli == NULL) {
3254 d_printf("smbcli_state_init() failed\n");
3255 return 1;
3256 }
3257
3258 ok = smbcli_socket_connect(cli, server_name, destports,
3259 ev_ctx, resolve_ctx, options,
3260 socket_options,
3261 &calling, &called);
3262 if (!ok) {
3263 d_printf("Connection to %s failed\n", server_name);
3264 return 1;
3265 }
3266
3267 send_message(cli, desthost);
3268 talloc_free(cli);
3269
3270 return 0;
3271 }
3272
3273
3274 /****************************************************************************
3275 main program
3276 ****************************************************************************/
3277 int main(int argc, const char *argv[])
3278 {
3279 char *base_directory = NULL;
3280 const char *dest_ip = NULL;
3281 int opt;
3282 const char *query_host = NULL;
3283 bool message = false;
3284 char *desthost = NULL;
3285 poptContext pc;
3286 const char *service = NULL;
3287 int port = 0;
3288 char *p;
3289 int rc = 0;
3290 int name_type = 0x20;
3291 TALLOC_CTX *mem_ctx;
3292 struct tevent_context *ev_ctx;
3293 struct smbclient_context *ctx;
3294 const char *cmdstr = NULL;
3295 struct smbcli_options smb_options;
3296 struct smbcli_session_options smb_session_options;
3297
3298 struct poptOption long_options[] = {
3299 POPT_AUTOHELP
3300
3301 { "message", 'M', POPT_ARG_STRING, NULL, 'M', "Send message", "HOST" },
3302 { "ip-address", 'I', POPT_ARG_STRING, NULL, 'I', "Use this IP to connect to", "IP" },
3303 { "stderr", 'E', POPT_ARG_NONE, NULL, 'E', "Write messages to stderr instead of stdout" },
3304 { "list", 'L', POPT_ARG_STRING, NULL, 'L', "Get a list of shares available on a host", "HOST" },
3305 { "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
3306 { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },
3307 { "send-buffer", 'b', POPT_ARG_INT, NULL, 'b', "Changes the transmit/send buffer", "BYTES" },
3308 { "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
3309 POPT_COMMON_SAMBA
3310 POPT_COMMON_CONNECTION
3311 POPT_COMMON_CREDENTIALS
3312 POPT_COMMON_VERSION
3313 { NULL }
3314 };
3315
3316 mem_ctx = talloc_init("client.c/main");
3317 if (!mem_ctx) {
3318 d_printf("\nclient.c: Not enough memory\n");
3319 exit(1);
3320 }
3321
3322 ctx = talloc_zero(mem_ctx, struct smbclient_context);
3323 ctx->io_bufsize = 64512;
3324
3325 pc = poptGetContext("smbclient", argc, argv, long_options, 0);
3326 poptSetOtherOptionHelp(pc, "[OPTIONS] service <password>");
3327
3328 while ((opt = poptGetNextOpt(pc)) != -1) {
3329 switch (opt) {
3330 case 'M':
3331 /* Messages are sent to NetBIOS name type 0x3
3332 * (Messenger Service). Make sure we default
3333 * to port 139 instead of port 445. srl,crh
3334 */
3335 name_type = 0x03;
3336 desthost = strdup(poptGetOptArg(pc));
3337 if( 0 == port ) port = 139;
3338 message = true;
3339 break;
3340 case 'I':
3341 dest_ip = poptGetOptArg(pc);
3342 break;
3343 case 'L':
3344 query_host = strdup(poptGetOptArg(pc));
3345 break;
3346 case 'D':
3347 base_directory = strdup(poptGetOptArg(pc));
3348 break;
3349 case 'b':
3350 ctx->io_bufsize = MAX(1, atoi(poptGetOptArg(pc)));
3351 break;
3352 }
3353 }
3354
3355 gensec_init();
3356
3357 if(poptPeekArg(pc)) {
3358 char *s = strdup(poptGetArg(pc));
3359
3360 /* Convert any '/' characters in the service name to '\' characters */
3361 string_replace(s, '/','\\');
3362
3363 service = s;
3364
3365 if (count_chars(s,'\\') < 3) {
3366 d_printf("\n%s: Not enough '\\' characters in service\n",s);
3367 poptPrintUsage(pc, stderr, 0);
3368 exit(1);
3369 }
3370 }
3371
3372 if (poptPeekArg(pc)) {
3373 cli_credentials_set_password(cmdline_credentials, poptGetArg(pc), CRED_SPECIFIED);
3374 }
3375
3376 /*init_names(); */
3377
3378 if (!query_host && !service && !message) {
3379 poptPrintUsage(pc, stderr, 0);
3380 exit(1);
3381 }
3382
3383 poptFreeContext(pc);
3384
3385 lpcfg_smbcli_options(cmdline_lp_ctx, &smb_options);
3386 lpcfg_smbcli_session_options(cmdline_lp_ctx, &smb_session_options);
3387
3388 ev_ctx = s4_event_context_init(talloc_autofree_context());
3389
3390 DEBUG( 3, ( "Client started (version %s).\n", SAMBA_VERSION_STRING ) );
3391
3392 if (query_host && (p=strchr_m(query_host,'#'))) {
3393 *p = 0;
3394 p++;
3395 sscanf(p, "%x", &name_type);
3396 }
3397
3398 if (query_host) {
3399 rc = do_host_query(cmdline_lp_ctx, ev_ctx, query_host,
3400 lpcfg_workgroup(cmdline_lp_ctx));
3401 return rc;
3402 }
3403
3404 if (message) {
3405 rc = do_message_op(lpcfg_netbios_name(cmdline_lp_ctx), desthost,
3406 lpcfg_smb_ports(cmdline_lp_ctx), dest_ip,
3407 name_type, ev_ctx,
3408 lpcfg_resolve_context(cmdline_lp_ctx),
3409 &smb_options,
3410 lpcfg_socket_options(cmdline_lp_ctx));
3411 return rc;
3412 }
3413
3414 if (!do_connect(ctx, ev_ctx, lpcfg_resolve_context(cmdline_lp_ctx),
3415 desthost, lpcfg_smb_ports(cmdline_lp_ctx), service,
3416 lpcfg_socket_options(cmdline_lp_ctx),
3417 cmdline_credentials, &smb_options, &smb_session_options,
3418 lpcfg_gensec_settings(ctx, cmdline_lp_ctx)))
3419 return 1;
3420
3421 if (base_directory) {
3422 do_cd(ctx, base_directory);
3423 free(base_directory);
3424 }
3425
3426 if (cmdstr) {
3427 rc = process_command_string(ctx, cmdstr);
3428 } else {
3429 rc = process_stdin(ctx);
3430 }
3431
3432 free(desthost);
3433 talloc_free(mem_ctx);
3434
3435 return rc;
3436 }
Samba GIT mirror