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