?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Progress on CR 601
[Samba.git] / source / client / client.c
blob5da12fd984f3ed807558cac73139a77e1717682f
1 /*
2 Unix SMB/CIFS implementation.
3 SMB client
4 Copyright (C) Andrew Tridgell 1994-1998
5 Copyright (C) Simo Sorce 2001-2002
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #define NO_SYSLOG
23
24 #include "includes.h"
25 #include "../client/client_proto.h"
26 #ifndef REGISTER
27 #define REGISTER 0
28 #endif
29
30 const char prog_name[] = "smbclient";
31
32 struct cli_state *cli;
33 extern BOOL in_client;
34 extern BOOL AllowDebugChange;
35 static int port = 0;
36 pstring cur_dir = "\\";
37 static pstring cd_path = "";
38 static pstring service;
39 static pstring desthost;
40 static pstring password;
41 static pstring username;
42 static pstring workgroup;
43 static char *cmdstr;
44 static BOOL got_user;
45 static BOOL got_pass;
46 static int io_bufsize = 64512;
47 static BOOL use_kerberos;
48
49 static int name_type = 0x20;
50 static int max_protocol = PROTOCOL_NT1;
51 extern pstring user_socket_options;
52
53 static int process_tok(fstring tok);
54 static int cmd_help(void);
55
56 /* 30 second timeout on most commands */
57 #define CLIENT_TIMEOUT (30*1000)
58 #define SHORT_TIMEOUT (5*1000)
59
60 /* value for unused fid field in trans2 secondary request */
61 #define FID_UNUSED (0xFFFF)
62
63 time_t newer_than = 0;
64 static int archive_level = 0;
65
66 static BOOL translation = False;
67
68 static BOOL have_ip;
69
70 /* clitar bits insert */
71 extern int blocksize;
72 extern BOOL tar_inc;
73 extern BOOL tar_reset;
74 /* clitar bits end */
75
76
77 static BOOL prompt = True;
78
79 static int printmode = 1;
80
81 static BOOL recurse = False;
82 BOOL lowercase = False;
83
84 static struct in_addr dest_ip;
85
86 #define SEPARATORS " \t\n\r"
87
88 static BOOL abort_mget = True;
89
90 static pstring fileselection = "";
91
92 extern file_info def_finfo;
93
94 /* timing globals */
95 SMB_BIG_UINT get_total_size = 0;
96 unsigned int get_total_time_ms = 0;
97 static SMB_BIG_UINT put_total_size = 0;
98 static unsigned int put_total_time_ms = 0;
99
100 /* totals globals */
101 static double dir_total;
102
103 #define USENMB
104
105 /* some forward declarations */
106 static struct cli_state *do_connect(const char *server, const char *share);
107
108 /****************************************************************************
109 write to a local file with CR/LF->LF translation if appropriate. return the
110 number taken from the buffer. This may not equal the number written.
111 ****************************************************************************/
112 static int writefile(int f, char *b, int n)
113 {
114 int i;
115
116 if (!translation) {
117 return write(f,b,n);
118 }
119
120 i = 0;
121 while (i < n) {
122 if (*b == '\r' && (i<(n-1)) && *(b+1) == '\n') {
123 b++;i++;
124 }
125 if (write(f, b, 1) != 1) {
126 break;
127 }
128 b++;
129 i++;
130 }
131
132 return(i);
133 }
134
135 /****************************************************************************
136 read from a file with LF->CR/LF translation if appropriate. return the
137 number read. read approx n bytes.
138 ****************************************************************************/
139 static int readfile(char *b, int n, XFILE *f)
140 {
141 int i;
142 int c;
143
144 if (!translation)
145 return x_fread(b,1,n,f);
146
147 i = 0;
148 while (i < (n - 1) && (i < BUFFER_SIZE)) {
149 if ((c = x_getc(f)) == EOF) {
150 break;
151 }
152
153 if (c == '\n') { /* change all LFs to CR/LF */
154 b[i++] = '\r';
155 }
156
157 b[i++] = c;
158 }
159
160 return(i);
161 }
162
163
164 /****************************************************************************
165 send a message
166 ****************************************************************************/
167 static void send_message(void)
168 {
169 int total_len = 0;
170 int grp_id;
171
172 if (!cli_message_start(cli, desthost, username, &grp_id)) {
173 d_printf("message start: %s\n", cli_errstr(cli));
174 return;
175 }
176
177
178 d_printf("Connected. Type your message, ending it with a Control-D\n");
179
180 while (!feof(stdin) && total_len < 1600) {
181 int maxlen = MIN(1600 - total_len,127);
182 pstring msg;
183 int l=0;
184 int c;
185
186 ZERO_ARRAY(msg);
187
188 for (l=0;l<maxlen && (c=fgetc(stdin))!=EOF;l++) {
189 if (c == '\n')
190 msg[l++] = '\r';
191 msg[l] = c;
192 }
193
194 if (!cli_message_text(cli, msg, l, grp_id)) {
195 d_printf("SMBsendtxt failed (%s)\n",cli_errstr(cli));
196 return;
197 }
198
199 total_len += l;
200 }
201
202 if (total_len >= 1600)
203 d_printf("the message was truncated to 1600 bytes\n");
204 else
205 d_printf("sent %d bytes\n",total_len);
206
207 if (!cli_message_end(cli, grp_id)) {
208 d_printf("SMBsendend failed (%s)\n",cli_errstr(cli));
209 return;
210 }
211 }
212
213
214
215 /****************************************************************************
216 check the space on a device
217 ****************************************************************************/
218 static int do_dskattr(void)
219 {
220 int total, bsize, avail;
221
222 if (!cli_dskattr(cli, &bsize, &total, &avail)) {
223 d_printf("Error in dskattr: %s\n",cli_errstr(cli));
224 return 1;
225 }
226
227 d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
228 total, bsize, avail);
229
230 return 0;
231 }
232
233 /****************************************************************************
234 show cd/pwd
235 ****************************************************************************/
236 static int cmd_pwd(void)
237 {
238 d_printf("Current directory is %s",service);
239 d_printf("%s\n",cur_dir);
240 return 0;
241 }
242
243
244 /****************************************************************************
245 change directory - inner section
246 ****************************************************************************/
247 static int do_cd(char *newdir)
248 {
249 char *p = newdir;
250 pstring saved_dir;
251 pstring dname;
252
253 dos_format(newdir);
254
255 /* Save the current directory in case the
256 new directory is invalid */
257 pstrcpy(saved_dir, cur_dir);
258 if (*p == '\\')
259 pstrcpy(cur_dir,p);
260 else
261 pstrcat(cur_dir,p);
262 if (*(cur_dir+strlen(cur_dir)-1) != '\\') {
263 pstrcat(cur_dir, "\\");
264 }
265 dos_clean_name(cur_dir);
266 pstrcpy(dname,cur_dir);
267 pstrcat(cur_dir,"\\");
268 dos_clean_name(cur_dir);
269
270 if (!strequal(cur_dir,"\\")) {
271 if (!cli_chkpath(cli, dname)) {
272 d_printf("cd %s: %s\n", dname, cli_errstr(cli));
273 pstrcpy(cur_dir,saved_dir);
274 }
275 }
276
277 pstrcpy(cd_path,cur_dir);
278
279 return 0;
280 }
281
282 /****************************************************************************
283 change directory
284 ****************************************************************************/
285 static int cmd_cd(void)
286 {
287 fstring buf;
288 int rc = 0;
289
290 if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
291 rc = do_cd(buf);
292 else
293 d_printf("Current directory is %s\n",cur_dir);
294
295 return rc;
296 }
297
298
299 /*******************************************************************
300 decide if a file should be operated on
301 ********************************************************************/
302 static BOOL do_this_one(file_info *finfo)
303 {
304 if (finfo->mode & aDIR) return(True);
305
306 if (*fileselection &&
307 !mask_match(finfo->name,fileselection,False)) {
308 DEBUG(3,("mask_match %s failed\n", finfo->name));
309 return False;
310 }
311
312 if (newer_than && finfo->mtime < newer_than) {
313 DEBUG(3,("newer_than %s failed\n", finfo->name));
314 return(False);
315 }
316
317 if ((archive_level==1 || archive_level==2) && !(finfo->mode & aARCH)) {
318 DEBUG(3,("archive %s failed\n", finfo->name));
319 return(False);
320 }
321
322 return(True);
323 }
324
325 /****************************************************************************
326 display info about a file
327 ****************************************************************************/
328 static void display_finfo(file_info *finfo)
329 {
330 if (do_this_one(finfo)) {
331 time_t t = finfo->mtime; /* the time is assumed to be passed as GMT */
332 d_printf(" %-30s%7.7s %8.0f %s",
333 finfo->name,
334 attrib_string(finfo->mode),
335 (double)finfo->size,
336 asctime(LocalTime(&t)));
337 dir_total += finfo->size;
338 }
339 }
340
341
342 /****************************************************************************
343 accumulate size of a file
344 ****************************************************************************/
345 static void do_du(file_info *finfo)
346 {
347 if (do_this_one(finfo)) {
348 dir_total += finfo->size;
349 }
350 }
351
352 static BOOL do_list_recurse;
353 static BOOL do_list_dirs;
354 static char *do_list_queue = 0;
355 static long do_list_queue_size = 0;
356 static long do_list_queue_start = 0;
357 static long do_list_queue_end = 0;
358 static void (*do_list_fn)(file_info *);
359
360 /****************************************************************************
361 functions for do_list_queue
362 ****************************************************************************/
363
364 /*
365 * The do_list_queue is a NUL-separated list of strings stored in a
366 * char*. Since this is a FIFO, we keep track of the beginning and
367 * ending locations of the data in the queue. When we overflow, we
368 * double the size of the char*. When the start of the data passes
369 * the midpoint, we move everything back. This is logically more
370 * complex than a linked list, but easier from a memory management
371 * angle. In any memory error condition, do_list_queue is reset.
372 * Functions check to ensure that do_list_queue is non-NULL before
373 * accessing it.
374 */
375 static void reset_do_list_queue(void)
376 {
377 SAFE_FREE(do_list_queue);
378 do_list_queue_size = 0;
379 do_list_queue_start = 0;
380 do_list_queue_end = 0;
381 }
382
383 static void init_do_list_queue(void)
384 {
385 reset_do_list_queue();
386 do_list_queue_size = 1024;
387 do_list_queue = malloc(do_list_queue_size);
388 if (do_list_queue == 0) {
389 d_printf("malloc fail for size %d\n",
390 (int)do_list_queue_size);
391 reset_do_list_queue();
392 } else {
393 memset(do_list_queue, 0, do_list_queue_size);
394 }
395 }
396
397 static void adjust_do_list_queue(void)
398 {
399 /*
400 * If the starting point of the queue is more than half way through,
401 * move everything toward the beginning.
402 */
403 if (do_list_queue && (do_list_queue_start == do_list_queue_end))
404 {
405 DEBUG(4,("do_list_queue is empty\n"));
406 do_list_queue_start = do_list_queue_end = 0;
407 *do_list_queue = '\0';
408 }
409 else if (do_list_queue_start > (do_list_queue_size / 2))
410 {
411 DEBUG(4,("sliding do_list_queue backward\n"));
412 memmove(do_list_queue,
413 do_list_queue + do_list_queue_start,
414 do_list_queue_end - do_list_queue_start);
415 do_list_queue_end -= do_list_queue_start;
416 do_list_queue_start = 0;
417 }
418
419 }
420
421 static void add_to_do_list_queue(const char* entry)
422 {
423 char *dlq;
424 long new_end = do_list_queue_end + ((long)strlen(entry)) + 1;
425 while (new_end > do_list_queue_size)
426 {
427 do_list_queue_size *= 2;
428 DEBUG(4,("enlarging do_list_queue to %d\n",
429 (int)do_list_queue_size));
430 dlq = Realloc(do_list_queue, do_list_queue_size);
431 if (! dlq) {
432 d_printf("failure enlarging do_list_queue to %d bytes\n",
433 (int)do_list_queue_size);
434 reset_do_list_queue();
435 }
436 else
437 {
438 do_list_queue = dlq;
439 memset(do_list_queue + do_list_queue_size / 2,
440 0, do_list_queue_size / 2);
441 }
442 }
443 if (do_list_queue)
444 {
445 pstrcpy(do_list_queue + do_list_queue_end, entry);
446 do_list_queue_end = new_end;
447 DEBUG(4,("added %s to do_list_queue (start=%d, end=%d)\n",
448 entry, (int)do_list_queue_start, (int)do_list_queue_end));
449 }
450 }
451
452 static char *do_list_queue_head(void)
453 {
454 return do_list_queue + do_list_queue_start;
455 }
456
457 static void remove_do_list_queue_head(void)
458 {
459 if (do_list_queue_end > do_list_queue_start)
460 {
461 do_list_queue_start += strlen(do_list_queue_head()) + 1;
462 adjust_do_list_queue();
463 DEBUG(4,("removed head of do_list_queue (start=%d, end=%d)\n",
464 (int)do_list_queue_start, (int)do_list_queue_end));
465 }
466 }
467
468 static int do_list_queue_empty(void)
469 {
470 return (! (do_list_queue && *do_list_queue));
471 }
472
473 /****************************************************************************
474 a helper for do_list
475 ****************************************************************************/
476 static void do_list_helper(file_info *f, const char *mask, void *state)
477 {
478 if (f->mode & aDIR) {
479 if (do_list_dirs && do_this_one(f)) {
480 do_list_fn(f);
481 }
482 if (do_list_recurse &&
483 !strequal(f->name,".") &&
484 !strequal(f->name,"..")) {
485 pstring mask2;
486 char *p;
487
488 pstrcpy(mask2, mask);
489 p = strrchr_m(mask2,'\\');
490 if (!p) return;
491 p[1] = 0;
492 pstrcat(mask2, f->name);
493 pstrcat(mask2,"\\*");
494 add_to_do_list_queue(mask2);
495 }
496 return;
497 }
498
499 if (do_this_one(f)) {
500 do_list_fn(f);
501 }
502 }
503
504
505 /****************************************************************************
506 a wrapper around cli_list that adds recursion
507 ****************************************************************************/
508 void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),BOOL rec, BOOL dirs)
509 {
510 static int in_do_list = 0;
511
512 if (in_do_list && rec)
513 {
514 fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
515 exit(1);
516 }
517
518 in_do_list = 1;
519
520 do_list_recurse = rec;
521 do_list_dirs = dirs;
522 do_list_fn = fn;
523
524 if (rec)
525 {
526 init_do_list_queue();
527 add_to_do_list_queue(mask);
528
529 while (! do_list_queue_empty())
530 {
531 /*
532 * Need to copy head so that it doesn't become
533 * invalid inside the call to cli_list. This
534 * would happen if the list were expanded
535 * during the call.
536 * Fix from E. Jay Berkenbilt (ejb@ql.org)
537 */
538 pstring head;
539 pstrcpy(head, do_list_queue_head());
540 cli_list(cli, head, attribute, do_list_helper, NULL);
541 remove_do_list_queue_head();
542 if ((! do_list_queue_empty()) && (fn == display_finfo))
543 {
544 char* next_file = do_list_queue_head();
545 char* save_ch = 0;
546 if ((strlen(next_file) >= 2) &&
547 (next_file[strlen(next_file) - 1] == '*') &&
548 (next_file[strlen(next_file) - 2] == '\\'))
549 {
550 save_ch = next_file +
551 strlen(next_file) - 2;
552 *save_ch = '\0';
553 }
554 d_printf("\n%s\n",next_file);
555 if (save_ch)
556 {
557 *save_ch = '\\';
558 }
559 }
560 }
561 }
562 else
563 {
564 if (cli_list(cli, mask, attribute, do_list_helper, NULL) == -1)
565 {
566 d_printf("%s listing %s\n", cli_errstr(cli), mask);
567 }
568 }
569
570 in_do_list = 0;
571 reset_do_list_queue();
572 }
573
574 /****************************************************************************
575 get a directory listing
576 ****************************************************************************/
577 static int cmd_dir(void)
578 {
579 uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
580 pstring mask;
581 fstring buf;
582 char *p=buf;
583 int rc;
584
585 dir_total = 0;
586 pstrcpy(mask,cur_dir);
587 if(mask[strlen(mask)-1]!='\\')
588 pstrcat(mask,"\\");
589
590 if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
591 dos_format(p);
592 if (*p == '\\')
593 pstrcpy(mask,p);
594 else
595 pstrcat(mask,p);
596 }
597 else {
598 pstrcat(mask,"*");
599 }
600
601 do_list(mask, attribute, display_finfo, recurse, True);
602
603 rc = do_dskattr();
604
605 DEBUG(3, ("Total bytes listed: %.0f\n", dir_total));
606
607 return rc;
608 }
609
610
611 /****************************************************************************
612 get a directory listing
613 ****************************************************************************/
614 static int cmd_du(void)
615 {
616 uint16 attribute = aDIR | aSYSTEM | aHIDDEN;
617 pstring mask;
618 fstring buf;
619 char *p=buf;
620 int rc;
621
622 dir_total = 0;
623 pstrcpy(mask,cur_dir);
624 if(mask[strlen(mask)-1]!='\\')
625 pstrcat(mask,"\\");
626
627 if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
628 dos_format(p);
629 if (*p == '\\')
630 pstrcpy(mask,p);
631 else
632 pstrcat(mask,p);
633 } else {
634 pstrcat(mask,"*");
635 }
636
637 do_list(mask, attribute, do_du, recurse, True);
638
639 rc = do_dskattr();
640
641 d_printf("Total number of bytes: %.0f\n", dir_total);
642
643 return rc;
644 }
645
646
647 /****************************************************************************
648 get a file from rname to lname
649 ****************************************************************************/
650 static int do_get(char *rname, char *lname, BOOL reget)
651 {
652 int handle = 0, fnum;
653 BOOL newhandle = False;
654 char *data;
655 struct timeval tp_start;
656 int read_size = io_bufsize;
657 uint16 attr;
658 size_t size;
659 off_t start = 0;
660 off_t nread = 0;
661 int rc = 0;
662
663 GetTimeOfDay(&tp_start);
664
665 if (lowercase) {
666 strlower(lname);
667 }
668
669 fnum = cli_open(cli, rname, O_RDONLY, DENY_NONE);
670
671 if (fnum == -1) {
672 d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
673 return 1;
674 }
675
676 if(!strcmp(lname,"-")) {
677 handle = fileno(stdout);
678 } else {
679 if (reget) {
680 handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
681 if (handle >= 0) {
682 start = sys_lseek(handle, 0, SEEK_END);
683 if (start == -1) {
684 d_printf("Error seeking local file\n");
685 return 1;
686 }
687 }
688 } else {
689 handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
690 }
691 newhandle = True;
692 }
693 if (handle < 0) {
694 d_printf("Error opening local file %s\n",lname);
695 return 1;
696 }
697
698
699 if (!cli_qfileinfo(cli, fnum,
700 &attr, &size, NULL, NULL, NULL, NULL, NULL) &&
701 !cli_getattrE(cli, fnum,
702 &attr, &size, NULL, NULL, NULL)) {
703 d_printf("getattrib: %s\n",cli_errstr(cli));
704 return 1;
705 }
706
707 DEBUG(2,("getting file %s of size %.0f as %s ",
708 rname, (double)size, lname));
709
710 if(!(data = (char *)malloc(read_size))) {
711 d_printf("malloc fail for size %d\n", read_size);
712 cli_close(cli, fnum);
713 return 1;
714 }
715
716 while (1) {
717 int n = cli_read(cli, fnum, data, nread + start, read_size);
718
719 if (n <= 0) break;
720
721 if (writefile(handle,data, n) != n) {
722 d_printf("Error writing local file\n");
723 rc = 1;
724 break;
725 }
726
727 nread += n;
728 }
729
730 if (nread + start < size) {
731 DEBUG (0, ("Short read when getting file %s. Only got %ld bytes.\n",
732 rname, (long)nread));
733
734 rc = 1;
735 }
736
737 SAFE_FREE(data);
738
739 if (!cli_close(cli, fnum)) {
740 d_printf("Error %s closing remote file\n",cli_errstr(cli));
741 rc = 1;
742 }
743
744 if (newhandle) {
745 close(handle);
746 }
747
748 if (archive_level >= 2 && (attr & aARCH)) {
749 cli_setatr(cli, rname, attr & ~(uint16)aARCH, 0);
750 }
751
752 {
753 struct timeval tp_end;
754 int this_time;
755
756 GetTimeOfDay(&tp_end);
757 this_time =
758 (tp_end.tv_sec - tp_start.tv_sec)*1000 +
759 (tp_end.tv_usec - tp_start.tv_usec)/1000;
760 get_total_time_ms += this_time;
761 get_total_size += nread;
762
763 DEBUG(2,("(%3.1f kb/s) (average %3.1f kb/s)\n",
764 nread / (1.024*this_time + 1.0e-4),
765 get_total_size / (1.024*get_total_time_ms)));
766 }
767
768 return rc;
769 }
770
771
772 /****************************************************************************
773 get a file
774 ****************************************************************************/
775 static int cmd_get(void)
776 {
777 pstring lname;
778 pstring rname;
779 char *p;
780
781 pstrcpy(rname,cur_dir);
782 pstrcat(rname,"\\");
783
784 p = rname + strlen(rname);
785
786 if (!next_token_nr(NULL,p,NULL,sizeof(rname)-strlen(rname))) {
787 d_printf("get <filename>\n");
788 return 1;
789 }
790 pstrcpy(lname,p);
791 dos_clean_name(rname);
792
793 next_token_nr(NULL,lname,NULL,sizeof(lname));
794
795 return do_get(rname, lname, False);
796 }
797
798
799 /****************************************************************************
800 do a mget operation on one file
801 ****************************************************************************/
802 static void do_mget(file_info *finfo)
803 {
804 pstring rname;
805 pstring quest;
806 pstring saved_curdir;
807 pstring mget_mask;
808
809 if (strequal(finfo->name,".") || strequal(finfo->name,".."))
810 return;
811
812 if (abort_mget) {
813 d_printf("mget aborted\n");
814 return;
815 }
816
817 if (finfo->mode & aDIR)
818 slprintf(quest,sizeof(pstring)-1,
819 "Get directory %s? ",finfo->name);
820 else
821 slprintf(quest,sizeof(pstring)-1,
822 "Get file %s? ",finfo->name);
823
824 if (prompt && !yesno(quest)) return;
825
826 if (!(finfo->mode & aDIR)) {
827 pstrcpy(rname,cur_dir);
828 pstrcat(rname,finfo->name);
829 do_get(rname, finfo->name, False);
830 return;
831 }
832
833 /* handle directories */
834 pstrcpy(saved_curdir,cur_dir);
835
836 pstrcat(cur_dir,finfo->name);
837 pstrcat(cur_dir,"\\");
838
839 unix_format(finfo->name);
840 if (lowercase)
841 strlower(finfo->name);
842
843 if (!directory_exist(finfo->name,NULL) &&
844 mkdir(finfo->name,0777) != 0) {
845 d_printf("failed to create directory %s\n",finfo->name);
846 pstrcpy(cur_dir,saved_curdir);
847 return;
848 }
849
850 if (chdir(finfo->name) != 0) {
851 d_printf("failed to chdir to directory %s\n",finfo->name);
852 pstrcpy(cur_dir,saved_curdir);
853 return;
854 }
855
856 pstrcpy(mget_mask,cur_dir);
857 pstrcat(mget_mask,"*");
858
859 do_list(mget_mask, aSYSTEM | aHIDDEN | aDIR,do_mget,False, True);
860 chdir("..");
861 pstrcpy(cur_dir,saved_curdir);
862 }
863
864
865 /****************************************************************************
866 view the file using the pager
867 ****************************************************************************/
868 static int cmd_more(void)
869 {
870 fstring rname,lname,pager_cmd;
871 char *pager;
872 int fd;
873 int rc = 0;
874
875 fstrcpy(rname,cur_dir);
876 fstrcat(rname,"\\");
877
878 slprintf(lname,sizeof(lname)-1, "%s/smbmore.XXXXXX",tmpdir());
879 fd = smb_mkstemp(lname);
880 if (fd == -1) {
881 d_printf("failed to create temporary file for more\n");
882 return 1;
883 }
884 close(fd);
885
886 if (!next_token_nr(NULL,rname+strlen(rname),NULL,sizeof(rname)-strlen(rname))) {
887 d_printf("more <filename>\n");
888 unlink(lname);
889 return 1;
890 }
891 dos_clean_name(rname);
892
893 rc = do_get(rname, lname, False);
894
895 pager=getenv("PAGER");
896
897 slprintf(pager_cmd,sizeof(pager_cmd)-1,
898 "%s %s",(pager? pager:PAGER), lname);
899 system(pager_cmd);
900 unlink(lname);
901
902 return rc;
903 }
904
905
906
907 /****************************************************************************
908 do a mget command
909 ****************************************************************************/
910 static int cmd_mget(void)
911 {
912 uint16 attribute = aSYSTEM | aHIDDEN;
913 pstring mget_mask;
914 fstring buf;
915 char *p=buf;
916
917 *mget_mask = 0;
918
919 if (recurse)
920 attribute |= aDIR;
921
922 abort_mget = False;
923
924 while (next_token_nr(NULL,p,NULL,sizeof(buf))) {
925 pstrcpy(mget_mask,cur_dir);
926 if(mget_mask[strlen(mget_mask)-1]!='\\')
927 pstrcat(mget_mask,"\\");
928
929 if (*p == '\\')
930 pstrcpy(mget_mask,p);
931 else
932 pstrcat(mget_mask,p);
933 do_list(mget_mask, attribute,do_mget,False,True);
934 }
935
936 if (!*mget_mask) {
937 pstrcpy(mget_mask,cur_dir);
938 if(mget_mask[strlen(mget_mask)-1]!='\\')
939 pstrcat(mget_mask,"\\");
940 pstrcat(mget_mask,"*");
941 do_list(mget_mask, attribute,do_mget,False,True);
942 }
943
944 return 0;
945 }
946
947
948 /****************************************************************************
949 make a directory of name "name"
950 ****************************************************************************/
951 static BOOL do_mkdir(char *name)
952 {
953 if (!cli_mkdir(cli, name)) {
954 d_printf("%s making remote directory %s\n",
955 cli_errstr(cli),name);
956 return(False);
957 }
958
959 return(True);
960 }
961
962 /****************************************************************************
963 show 8.3 name of a file
964 ****************************************************************************/
965 static BOOL do_altname(char *name)
966 {
967 fstring altname;
968 if (!NT_STATUS_IS_OK(cli_qpathinfo_alt_name(cli, name, altname))) {
969 d_printf("%s getting alt name for %s\n",
970 cli_errstr(cli),name);
971 return(False);
972 }
973 d_printf("%s\n", altname);
974
975 return(True);
976 }
977
978
979 /****************************************************************************
980 Exit client.
981 ****************************************************************************/
982 static int cmd_quit(void)
983 {
984 cli_shutdown(cli);
985 exit(0);
986 /* NOTREACHED */
987 return 0;
988 }
989
990
991 /****************************************************************************
992 make a directory
993 ****************************************************************************/
994 static int cmd_mkdir(void)
995 {
996 pstring mask;
997 fstring buf;
998 char *p=buf;
999
1000 pstrcpy(mask,cur_dir);
1001
1002 if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
1003 if (!recurse)
1004 d_printf("mkdir <dirname>\n");
1005 return 1;
1006 }
1007 pstrcat(mask,p);
1008
1009 if (recurse) {
1010 pstring ddir;
1011 pstring ddir2;
1012 *ddir2 = 0;
1013
1014 pstrcpy(ddir,mask);
1015 trim_string(ddir,".",NULL);
1016 p = strtok(ddir,"/\\");
1017 while (p) {
1018 pstrcat(ddir2,p);
1019 if (!cli_chkpath(cli, ddir2)) {
1020 do_mkdir(ddir2);
1021 }
1022 pstrcat(ddir2,"\\");
1023 p = strtok(NULL,"/\\");
1024 }
1025 } else {
1026 do_mkdir(mask);
1027 }
1028
1029 return 0;
1030 }
1031
1032
1033 /****************************************************************************
1034 show alt name
1035 ****************************************************************************/
1036 static int cmd_altname(void)
1037 {
1038 pstring name;
1039 fstring buf;
1040 char *p=buf;
1041
1042 pstrcpy(name,cur_dir);
1043
1044 if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
1045 d_printf("altname <file>\n");
1046 return 1;
1047 }
1048 pstrcat(name,p);
1049
1050 do_altname(name);
1051
1052 return 0;
1053 }
1054
1055
1056 /****************************************************************************
1057 put a single file
1058 ****************************************************************************/
1059 static int do_put(char *rname, char *lname, BOOL reput)
1060 {
1061 int fnum;
1062 XFILE *f;
1063 int start = 0;
1064 off_t nread = 0;
1065 char *buf = NULL;
1066 int maxwrite = io_bufsize;
1067 int rc = 0;
1068
1069 struct timeval tp_start;
1070 GetTimeOfDay(&tp_start);
1071
1072 if (reput) {
1073 fnum = cli_open(cli, rname, O_RDWR|O_CREAT, DENY_NONE);
1074 if (fnum >= 0) {
1075 if (!cli_qfileinfo(cli, fnum, NULL, &start, NULL, NULL, NULL, NULL, NULL) &&
1076 !cli_getattrE(cli, fnum, NULL, &start, NULL, NULL, NULL)) {
1077 d_printf("getattrib: %s\n",cli_errstr(cli));
1078 return 1;
1079 }
1080 }
1081 } else {
1082 fnum = cli_open(cli, rname, O_RDWR|O_CREAT|O_TRUNC, DENY_NONE);
1083 }
1084
1085 if (fnum == -1) {
1086 d_printf("%s opening remote file %s\n",cli_errstr(cli),rname);
1087 return 1;
1088 }
1089
1090 /* allow files to be piped into smbclient
1091 jdblair 24.jun.98
1092
1093 Note that in this case this function will exit(0) rather
1094 than returning. */
1095 if (!strcmp(lname, "-")) {
1096 f = x_stdin;
1097 /* size of file is not known */
1098 } else {
1099 f = x_fopen(lname,O_RDONLY, 0);
1100 if (f && reput) {
1101 if (x_tseek(f, start, SEEK_SET) == -1) {
1102 d_printf("Error seeking local file\n");
1103 return 1;
1104 }
1105 }
1106 }
1107
1108 if (!f) {
1109 d_printf("Error opening local file %s\n",lname);
1110 return 1;
1111 }
1112
1113
1114 DEBUG(1,("putting file %s as %s ",lname,
1115 rname));
1116
1117 buf = (char *)malloc(maxwrite);
1118 if (!buf) {
1119 d_printf("ERROR: Not enough memory!\n");
1120 return 1;
1121 }
1122 while (!x_feof(f)) {
1123 int n = maxwrite;
1124 int ret;
1125
1126 if ((n = readfile(buf,n,f)) < 1) {
1127 if((n == 0) && x_feof(f))
1128 break; /* Empty local file. */
1129
1130 d_printf("Error reading local file: %s\n", strerror(errno));
1131 rc = 1;
1132 break;
1133 }
1134
1135 ret = cli_write(cli, fnum, 0, buf, nread + start, n);
1136
1137 if (n != ret) {
1138 d_printf("Error writing file: %s\n", cli_errstr(cli));
1139 rc = 1;
1140 break;
1141 }
1142
1143 nread += n;
1144 }
1145
1146 if (!cli_close(cli, fnum)) {
1147 d_printf("%s closing remote file %s\n",cli_errstr(cli),rname);
1148 x_fclose(f);
1149 SAFE_FREE(buf);
1150 return 1;
1151 }
1152
1153
1154 if (f != x_stdin) {
1155 x_fclose(f);
1156 }
1157
1158 SAFE_FREE(buf);
1159
1160 {
1161 struct timeval tp_end;
1162 int this_time;
1163
1164 GetTimeOfDay(&tp_end);
1165 this_time =
1166 (tp_end.tv_sec - tp_start.tv_sec)*1000 +
1167 (tp_end.tv_usec - tp_start.tv_usec)/1000;
1168 put_total_time_ms += this_time;
1169 put_total_size += nread;
1170
1171 DEBUG(1,("(%3.1f kb/s) (average %3.1f kb/s)\n",
1172 nread / (1.024*this_time + 1.0e-4),
1173 put_total_size / (1.024*put_total_time_ms)));
1174 }
1175
1176 if (f == x_stdin) {
1177 cli_shutdown(cli);
1178 exit(0);
1179 }
1180
1181 return rc;
1182 }
1183
1184
1185
1186 /****************************************************************************
1187 put a file
1188 ****************************************************************************/
1189 static int cmd_put(void)
1190 {
1191 pstring lname;
1192 pstring rname;
1193 fstring buf;
1194 char *p=buf;
1195
1196 pstrcpy(rname,cur_dir);
1197 pstrcat(rname,"\\");
1198
1199 if (!next_token_nr(NULL,p,NULL,sizeof(buf))) {
1200 d_printf("put <filename>\n");
1201 return 1;
1202 }
1203 pstrcpy(lname,p);
1204
1205 if (next_token_nr(NULL,p,NULL,sizeof(buf)))
1206 pstrcat(rname,p);
1207 else
1208 pstrcat(rname,lname);
1209
1210 dos_clean_name(rname);
1211
1212 {
1213 SMB_STRUCT_STAT st;
1214 /* allow '-' to represent stdin
1215 jdblair, 24.jun.98 */
1216 if (!file_exist(lname,&st) &&
1217 (strcmp(lname,"-"))) {
1218 d_printf("%s does not exist\n",lname);
1219 return 1;
1220 }
1221 }
1222
1223 return do_put(rname, lname, False);
1224 }
1225
1226 /*************************************
1227 File list structure
1228 *************************************/
1229
1230 static struct file_list {
1231 struct file_list *prev, *next;
1232 char *file_path;
1233 BOOL isdir;
1234 } *file_list;
1235
1236 /****************************************************************************
1237 Free a file_list structure
1238 ****************************************************************************/
1239
1240 static void free_file_list (struct file_list * list)
1241 {
1242 struct file_list *tmp;
1243
1244 while (list)
1245 {
1246 tmp = list;
1247 DLIST_REMOVE(list, list);
1248 SAFE_FREE(tmp->file_path);
1249 SAFE_FREE(tmp);
1250 }
1251 }
1252
1253 /****************************************************************************
1254 seek in a directory/file list until you get something that doesn't start with
1255 the specified name
1256 ****************************************************************************/
1257 static BOOL seek_list(struct file_list *list, char *name)
1258 {
1259 while (list) {
1260 trim_string(list->file_path,"./","\n");
1261 if (strncmp(list->file_path, name, strlen(name)) != 0) {
1262 return(True);
1263 }
1264 list = list->next;
1265 }
1266
1267 return(False);
1268 }
1269
1270 /****************************************************************************
1271 set the file selection mask
1272 ****************************************************************************/
1273 static int cmd_select(void)
1274 {
1275 pstrcpy(fileselection,"");
1276 next_token_nr(NULL,fileselection,NULL,sizeof(fileselection));
1277
1278 return 0;
1279 }
1280
1281 /****************************************************************************
1282 Recursive file matching function act as find
1283 match must be always set to True when calling this function
1284 ****************************************************************************/
1285 static int file_find(struct file_list **list, const char *directory,
1286 const char *expression, BOOL match)
1287 {
1288 DIR *dir;
1289 struct file_list *entry;
1290 struct stat statbuf;
1291 int ret;
1292 char *path;
1293 BOOL isdir;
1294 char *dname;
1295
1296 dir = opendir(directory);
1297 if (!dir) return -1;
1298
1299 while ((dname = readdirname(dir))) {
1300 if (!strcmp("..", dname)) continue;
1301 if (!strcmp(".", dname)) continue;
1302
1303 if (asprintf(&path, "%s/%s", directory, dname) <= 0) {
1304 continue;
1305 }
1306
1307 isdir = False;
1308 if (!match || !gen_fnmatch(expression, dname)) {
1309 if (recurse) {
1310 ret = stat(path, &statbuf);
1311 if (ret == 0) {
1312 if (S_ISDIR(statbuf.st_mode)) {
1313 isdir = True;
1314 ret = file_find(list, path, expression, False);
1315 }
1316 } else {
1317 d_printf("file_find: cannot stat file %s\n", path);
1318 }
1319
1320 if (ret == -1) {
1321 SAFE_FREE(path);
1322 closedir(dir);
1323 return -1;
1324 }
1325 }
1326 entry = (struct file_list *) malloc(sizeof (struct file_list));
1327 if (!entry) {
1328 d_printf("Out of memory in file_find\n");
1329 closedir(dir);
1330 return -1;
1331 }
1332 entry->file_path = path;
1333 entry->isdir = isdir;
1334 DLIST_ADD(*list, entry);
1335 } else {
1336 SAFE_FREE(path);
1337 }
1338 }
1339
1340 closedir(dir);
1341 return 0;
1342 }
1343
1344 /****************************************************************************
1345 mput some files
1346 ****************************************************************************/
1347 static int cmd_mput(void)
1348 {
1349 fstring buf;
1350 char *p=buf;
1351
1352 while (next_token_nr(NULL,p,NULL,sizeof(buf))) {
1353 int ret;
1354 struct file_list *temp_list;
1355 char *quest, *lname, *rname;
1356
1357 file_list = NULL;
1358
1359 ret = file_find(&file_list, ".", p, True);
1360 if (ret) {
1361 free_file_list(file_list);
1362 continue;
1363 }
1364
1365 quest = NULL;
1366 lname = NULL;
1367 rname = NULL;
1368
1369 for (temp_list = file_list; temp_list;
1370 temp_list = temp_list->next) {
1371
1372 SAFE_FREE(lname);
1373 if (asprintf(&lname, "%s/", temp_list->file_path) <= 0)
1374 continue;
1375 trim_string(lname, "./", "/");
1376
1377 /* check if it's a directory */
1378 if (temp_list->isdir) {
1379 /* if (!recurse) continue; */
1380
1381 SAFE_FREE(quest);
1382 if (asprintf(&quest, "Put directory %s? ", lname) < 0) break;
1383 if (prompt && !yesno(quest)) { /* No */
1384 /* Skip the directory */
1385 lname[strlen(lname)-1] = '/';
1386 if (!seek_list(temp_list, lname))
1387 break;
1388 } else { /* Yes */
1389 SAFE_FREE(rname);
1390 if(asprintf(&rname, "%s%s", cur_dir, lname) < 0) break;
1391 dos_format(rname);
1392 if (!cli_chkpath(cli, rname) &&
1393 !do_mkdir(rname)) {
1394 DEBUG (0, ("Unable to make dir, skipping..."));
1395 /* Skip the directory */
1396 lname[strlen(lname)-1] = '/';
1397 if (!seek_list(temp_list, lname))
1398 break;
1399 }
1400 }
1401 continue;
1402 } else {
1403 SAFE_FREE(quest);
1404 if (asprintf(&quest,"Put file %s? ", lname) < 0) break;
1405 if (prompt && !yesno(quest)) /* No */
1406 continue;
1407
1408 /* Yes */
1409 SAFE_FREE(rname);
1410 if (asprintf(&rname, "%s%s", cur_dir, lname) < 0) break;
1411 }
1412
1413 dos_format(rname);
1414
1415 do_put(rname, lname, False);
1416 }
1417 free_file_list(file_list);
1418 SAFE_FREE(quest);
1419 SAFE_FREE(lname);
1420 SAFE_FREE(rname);
1421 }
1422
1423 return 0;
1424 }
1425
1426
1427 /****************************************************************************
1428 cancel a print job
1429 ****************************************************************************/
1430 static int do_cancel(int job)
1431 {
1432 if (cli_printjob_del(cli, job)) {
1433 d_printf("Job %d cancelled\n",job);
1434 return 0;
1435 } else {
1436 d_printf("Error cancelling job %d : %s\n",job,cli_errstr(cli));
1437 return 1;
1438 }
1439 }
1440
1441
1442 /****************************************************************************
1443 cancel a print job
1444 ****************************************************************************/
1445 static int cmd_cancel(void)
1446 {
1447 fstring buf;
1448 int job;
1449
1450 if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
1451 d_printf("cancel <jobid> ...\n");
1452 return 1;
1453 }
1454 do {
1455 job = atoi(buf);
1456 do_cancel(job);
1457 } while (next_token_nr(NULL,buf,NULL,sizeof(buf)));
1458
1459 return 0;
1460 }
1461
1462
1463 /****************************************************************************
1464 print a file
1465 ****************************************************************************/
1466 static int cmd_print(void)
1467 {
1468 pstring lname;
1469 pstring rname;
1470 char *p;
1471
1472 if (!next_token_nr(NULL,lname,NULL, sizeof(lname))) {
1473 d_printf("print <filename>\n");
1474 return 1;
1475 }
1476
1477 pstrcpy(rname,lname);
1478 p = strrchr_m(rname,'/');
1479 if (p) {
1480 slprintf(rname, sizeof(rname)-1, "%s-%d", p+1, (int)sys_getpid());
1481 }
1482
1483 if (strequal(lname,"-")) {
1484 slprintf(rname, sizeof(rname)-1, "stdin-%d", (int)sys_getpid());
1485 }
1486
1487 return do_put(rname, lname, False);
1488 }
1489
1490
1491 /****************************************************************************
1492 show a print queue entry
1493 ****************************************************************************/
1494 static void queue_fn(struct print_job_info *p)
1495 {
1496 d_printf("%-6d %-9d %s\n", (int)p->id, (int)p->size, p->name);
1497 }
1498
1499 /****************************************************************************
1500 show a print queue
1501 ****************************************************************************/
1502 static int cmd_queue(void)
1503 {
1504 cli_print_queue(cli, queue_fn);
1505
1506 return 0;
1507 }
1508
1509 /****************************************************************************
1510 delete some files
1511 ****************************************************************************/
1512 static void do_del(file_info *finfo)
1513 {
1514 pstring mask;
1515
1516 pstrcpy(mask,cur_dir);
1517 pstrcat(mask,finfo->name);
1518
1519 if (finfo->mode & aDIR)
1520 return;
1521
1522 if (!cli_unlink(cli, mask)) {
1523 d_printf("%s deleting remote file %s\n",cli_errstr(cli),mask);
1524 }
1525 }
1526
1527 /****************************************************************************
1528 delete some files
1529 ****************************************************************************/
1530 static int cmd_del(void)
1531 {
1532 pstring mask;
1533 fstring buf;
1534 uint16 attribute = aSYSTEM | aHIDDEN;
1535
1536 if (recurse)
1537 attribute |= aDIR;
1538
1539 pstrcpy(mask,cur_dir);
1540
1541 if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
1542 d_printf("del <filename>\n");
1543 return 1;
1544 }
1545 pstrcat(mask,buf);
1546
1547 do_list(mask, attribute,do_del,False,False);
1548
1549 return 0;
1550 }
1551
1552 /****************************************************************************
1553 ****************************************************************************/
1554 static int cmd_open(void)
1555 {
1556 pstring mask;
1557 fstring buf;
1558
1559 pstrcpy(mask,cur_dir);
1560
1561 if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
1562 d_printf("open <filename>\n");
1563 return 1;
1564 }
1565 pstrcat(mask,buf);
1566
1567 cli_open(cli, mask, O_RDWR, DENY_ALL);
1568
1569 return 0;
1570 }
1571
1572
1573 /****************************************************************************
1574 remove a directory
1575 ****************************************************************************/
1576 static int cmd_rmdir(void)
1577 {
1578 pstring mask;
1579 fstring buf;
1580
1581 pstrcpy(mask,cur_dir);
1582
1583 if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) {
1584 d_printf("rmdir <dirname>\n");
1585 return 1;
1586 }
1587 pstrcat(mask,buf);
1588
1589 if (!cli_rmdir(cli, mask)) {
1590 d_printf("%s removing remote directory file %s\n",
1591 cli_errstr(cli),mask);
1592 }
1593
1594 return 0;
1595 }
1596
1597 /****************************************************************************
1598 UNIX hardlink.
1599 ****************************************************************************/
1600
1601 static int cmd_link(void)
1602 {
1603 pstring src,dest;
1604 fstring buf,buf2;
1605
1606 if (!SERVER_HAS_UNIX_CIFS(cli)) {
1607 d_printf("Server doesn't support UNIX CIFS calls.\n");
1608 return 1;
1609 }
1610
1611 pstrcpy(src,cur_dir);
1612 pstrcpy(dest,cur_dir);
1613
1614 if (!next_token(NULL,buf,NULL,sizeof(buf)) ||
1615 !next_token(NULL,buf2,NULL, sizeof(buf2))) {
1616 d_printf("link <src> <dest>\n");
1617 return 1;
1618 }
1619
1620 pstrcat(src,buf);
1621 pstrcat(dest,buf2);
1622
1623 if (!cli_unix_hardlink(cli, src, dest)) {
1624 d_printf("%s linking files (%s -> %s)\n", cli_errstr(cli), src, dest);
1625 return 1;
1626 }
1627
1628 return 0;
1629 }
1630
1631 /****************************************************************************
1632 UNIX symlink.
1633 ****************************************************************************/
1634
1635 static int cmd_symlink(void)
1636 {
1637 pstring src,dest;
1638 fstring buf,buf2;
1639
1640 if (!SERVER_HAS_UNIX_CIFS(cli)) {
1641 d_printf("Server doesn't support UNIX CIFS calls.\n");
1642 return 1;
1643 }
1644
1645 pstrcpy(src,cur_dir);
1646 pstrcpy(dest,cur_dir);
1647
1648 if (!next_token(NULL,buf,NULL,sizeof(buf)) ||
1649 !next_token(NULL,buf2,NULL, sizeof(buf2))) {
1650 d_printf("symlink <src> <dest>\n");
1651 return 1;
1652 }
1653
1654 pstrcat(src,buf);
1655 pstrcat(dest,buf2);
1656
1657 if (!cli_unix_symlink(cli, src, dest)) {
1658 d_printf("%s symlinking files (%s -> %s)\n",
1659 cli_errstr(cli), src, dest);
1660 return 1;
1661 }
1662
1663 return 0;
1664 }
1665
1666 /****************************************************************************
1667 UNIX chmod.
1668 ****************************************************************************/
1669
1670 static int cmd_chmod(void)
1671 {
1672 pstring src;
1673 mode_t mode;
1674 fstring buf, buf2;
1675
1676 if (!SERVER_HAS_UNIX_CIFS(cli)) {
1677 d_printf("Server doesn't support UNIX CIFS calls.\n");
1678 return 1;
1679 }
1680
1681 pstrcpy(src,cur_dir);
1682
1683 if (!next_token(NULL,buf,NULL,sizeof(buf)) ||
1684 !next_token(NULL,buf2,NULL, sizeof(buf2))) {
1685 d_printf("chmod mode file\n");
1686 return 1;
1687 }
1688
1689 mode = (mode_t)strtol(buf, NULL, 8);
1690 pstrcat(src,buf2);
1691
1692 if (!cli_unix_chmod(cli, src, mode)) {
1693 d_printf("%s chmod file %s 0%o\n",
1694 cli_errstr(cli), src, (unsigned int)mode);
1695 return 1;
1696 }
1697
1698 return 0;
1699 }
1700
1701 /****************************************************************************
1702 UNIX chown.
1703 ****************************************************************************/
1704
1705 static int cmd_chown(void)
1706 {
1707 pstring src;
1708 uid_t uid;
1709 gid_t gid;
1710 fstring buf, buf2, buf3;
1711
1712 if (!SERVER_HAS_UNIX_CIFS(cli)) {
1713 d_printf("Server doesn't support UNIX CIFS calls.\n");
1714 return 1;
1715 }
1716
1717 pstrcpy(src,cur_dir);
1718
1719 if (!next_token(NULL,buf,NULL,sizeof(buf)) ||
1720 !next_token(NULL,buf2,NULL, sizeof(buf2)) ||
1721 !next_token(NULL,buf3,NULL, sizeof(buf3))) {
1722 d_printf("chown uid gid file\n");
1723 return 1;
1724 }
1725
1726 uid = (uid_t)atoi(buf);
1727 gid = (gid_t)atoi(buf2);
1728 pstrcat(src,buf3);
1729
1730 if (!cli_unix_chown(cli, src, uid, gid)) {
1731 d_printf("%s chown file %s uid=%d, gid=%d\n",
1732 cli_errstr(cli), src, (int)uid, (int)gid);
1733 return 1;
1734 }
1735
1736 return 0;
1737 }
1738
1739 /****************************************************************************
1740 rename some files
1741 ****************************************************************************/
1742 static int cmd_rename(void)
1743 {
1744 pstring src,dest;
1745 fstring buf,buf2;
1746
1747 pstrcpy(src,cur_dir);
1748 pstrcpy(dest,cur_dir);
1749
1750 if (!next_token_nr(NULL,buf,NULL,sizeof(buf)) ||
1751 !next_token_nr(NULL,buf2,NULL, sizeof(buf2))) {
1752 d_printf("rename <src> <dest>\n");
1753 return 1;
1754 }
1755
1756 pstrcat(src,buf);
1757 pstrcat(dest,buf2);
1758
1759 if (!cli_rename(cli, src, dest)) {
1760 d_printf("%s renaming files\n",cli_errstr(cli));
1761 return 1;
1762 }
1763
1764 return 0;
1765 }
1766
1767
1768 /****************************************************************************
1769 toggle the prompt flag
1770 ****************************************************************************/
1771 static int cmd_prompt(void)
1772 {
1773 prompt = !prompt;
1774 DEBUG(2,("prompting is now %s\n",prompt?"on":"off"));
1775
1776 return 1;
1777 }
1778
1779
1780 /****************************************************************************
1781 set the newer than time
1782 ****************************************************************************/
1783 static int cmd_newer(void)
1784 {
1785 fstring buf;
1786 BOOL ok;
1787 SMB_STRUCT_STAT sbuf;
1788
1789 ok = next_token_nr(NULL,buf,NULL,sizeof(buf));
1790 if (ok && (sys_stat(buf,&sbuf) == 0)) {
1791 newer_than = sbuf.st_mtime;
1792 DEBUG(1,("Getting files newer than %s",
1793 asctime(LocalTime(&newer_than))));
1794 } else {
1795 newer_than = 0;
1796 }
1797
1798 if (ok && newer_than == 0) {
1799 d_printf("Error setting newer-than time\n");
1800 return 1;
1801 }
1802
1803 return 0;
1804 }
1805
1806 /****************************************************************************
1807 set the archive level
1808 ****************************************************************************/
1809 static int cmd_archive(void)
1810 {
1811 fstring buf;
1812
1813 if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
1814 archive_level = atoi(buf);
1815 } else
1816 d_printf("Archive level is %d\n",archive_level);
1817
1818 return 0;
1819 }
1820
1821 /****************************************************************************
1822 toggle the lowercaseflag
1823 ****************************************************************************/
1824 static int cmd_lowercase(void)
1825 {
1826 lowercase = !lowercase;
1827 DEBUG(2,("filename lowercasing is now %s\n",lowercase?"on":"off"));
1828
1829 return 0;
1830 }
1831
1832
1833
1834
1835 /****************************************************************************
1836 toggle the recurse flag
1837 ****************************************************************************/
1838 static int cmd_recurse(void)
1839 {
1840 recurse = !recurse;
1841 DEBUG(2,("directory recursion is now %s\n",recurse?"on":"off"));
1842
1843 return 0;
1844 }
1845
1846 /****************************************************************************
1847 toggle the translate flag
1848 ****************************************************************************/
1849 static int cmd_translate(void)
1850 {
1851 translation = !translation;
1852 DEBUG(2,("CR/LF<->LF and print text translation now %s\n",
1853 translation?"on":"off"));
1854
1855 return 0;
1856 }
1857
1858
1859 /****************************************************************************
1860 do a printmode command
1861 ****************************************************************************/
1862 static int cmd_printmode(void)
1863 {
1864 fstring buf;
1865 fstring mode;
1866
1867 if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
1868 if (strequal(buf,"text")) {
1869 printmode = 0;
1870 } else {
1871 if (strequal(buf,"graphics"))
1872 printmode = 1;
1873 else
1874 printmode = atoi(buf);
1875 }
1876 }
1877
1878 switch(printmode)
1879 {
1880 case 0:
1881 fstrcpy(mode,"text");
1882 break;
1883 case 1:
1884 fstrcpy(mode,"graphics");
1885 break;
1886 default:
1887 slprintf(mode,sizeof(mode)-1,"%d",printmode);
1888 break;
1889 }
1890
1891 DEBUG(2,("the printmode is now %s\n",mode));
1892
1893 return 0;
1894 }
1895
1896 /****************************************************************************
1897 do the lcd command
1898 ****************************************************************************/
1899 static int cmd_lcd(void)
1900 {
1901 fstring buf;
1902 pstring d;
1903
1904 if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
1905 chdir(buf);
1906 DEBUG(2,("the local directory is now %s\n",sys_getwd(d)));
1907
1908 return 0;
1909 }
1910
1911 /****************************************************************************
1912 get a file restarting at end of local file
1913 ****************************************************************************/
1914 static int cmd_reget(void)
1915 {
1916 pstring local_name;
1917 pstring remote_name;
1918 char *p;
1919
1920 pstrcpy(remote_name, cur_dir);
1921 pstrcat(remote_name, "\\");
1922
1923 p = remote_name + strlen(remote_name);
1924
1925 if (!next_token_nr(NULL, p, NULL, sizeof(remote_name) - strlen(remote_name))) {
1926 d_printf("reget <filename>\n");
1927 return 1;
1928 }
1929 pstrcpy(local_name, p);
1930 dos_clean_name(remote_name);
1931
1932 next_token_nr(NULL, local_name, NULL, sizeof(local_name));
1933
1934 return do_get(remote_name, local_name, True);
1935 }
1936
1937 /****************************************************************************
1938 put a file restarting at end of local file
1939 ****************************************************************************/
1940 static int cmd_reput(void)
1941 {
1942 pstring local_name;
1943 pstring remote_name;
1944 fstring buf;
1945 char *p = buf;
1946 SMB_STRUCT_STAT st;
1947
1948 pstrcpy(remote_name, cur_dir);
1949 pstrcat(remote_name, "\\");
1950
1951 if (!next_token_nr(NULL, p, NULL, sizeof(buf))) {
1952 d_printf("reput <filename>\n");
1953 return 1;
1954 }
1955 pstrcpy(local_name, p);
1956
1957 if (!file_exist(local_name, &st)) {
1958 d_printf("%s does not exist\n", local_name);
1959 return 1;
1960 }
1961
1962 if (next_token_nr(NULL, p, NULL, sizeof(buf)))
1963 pstrcat(remote_name, p);
1964 else
1965 pstrcat(remote_name, local_name);
1966
1967 dos_clean_name(remote_name);
1968
1969 return do_put(remote_name, local_name, True);
1970 }
1971
1972
1973 /****************************************************************************
1974 list a share name
1975 ****************************************************************************/
1976 static void browse_fn(const char *name, uint32 m,
1977 const char *comment, void *state)
1978 {
1979 fstring typestr;
1980
1981 *typestr=0;
1982
1983 switch (m)
1984 {
1985 case STYPE_DISKTREE:
1986 fstrcpy(typestr,"Disk"); break;
1987 case STYPE_PRINTQ:
1988 fstrcpy(typestr,"Printer"); break;
1989 case STYPE_DEVICE:
1990 fstrcpy(typestr,"Device"); break;
1991 case STYPE_IPC:
1992 fstrcpy(typestr,"IPC"); break;
1993 }
1994 /* FIXME: If the remote machine returns non-ascii characters
1995 in any of these fields, they can corrupt the output. We
1996 should remove them. */
1997 d_printf("\t%-15.15s%-10.10s%s\n",
1998 name,typestr,comment);
1999 }
2000
2001
2002 /****************************************************************************
2003 try and browse available connections on a host
2004 ****************************************************************************/
2005 static BOOL browse_host(BOOL sort)
2006 {
2007 int ret;
2008
2009 d_printf("\n\tSharename Type Comment\n");
2010 d_printf("\t--------- ---- -------\n");
2011
2012 if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1)
2013 d_printf("Error returning browse list: %s\n", cli_errstr(cli));
2014
2015 return (ret != -1);
2016 }
2017
2018 /****************************************************************************
2019 list a server name
2020 ****************************************************************************/
2021 static void server_fn(const char *name, uint32 m,
2022 const char *comment, void *state)
2023 {
2024 d_printf("\t%-16.16s %s\n", name, comment);
2025 }
2026
2027 /****************************************************************************
2028 try and browse available connections on a host
2029 ****************************************************************************/
2030 static BOOL list_servers(char *wk_grp)
2031 {
2032 if (!cli->server_domain) return False;
2033
2034 d_printf("\n\tServer Comment\n");
2035 d_printf("\t--------- -------\n");
2036
2037 cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_ALL, server_fn, NULL);
2038
2039 d_printf("\n\tWorkgroup Master\n");
2040 d_printf("\t--------- -------\n");
2041
2042 cli_NetServerEnum(cli, cli->server_domain, SV_TYPE_DOMAIN_ENUM, server_fn, NULL);
2043 return True;
2044 }
2045
2046 /* Some constants for completing filename arguments */
2047
2048 #define COMPL_NONE 0 /* No completions */
2049 #define COMPL_REMOTE 1 /* Complete remote filename */
2050 #define COMPL_LOCAL 2 /* Complete local filename */
2051
2052 /* This defines the commands supported by this client.
2053 * NOTE: The "!" must be the last one in the list because it's fn pointer
2054 * field is NULL, and NULL in that field is used in process_tok()
2055 * (below) to indicate the end of the list. crh
2056 */
2057 static struct
2058 {
2059 const char *name;
2060 int (*fn)(void);
2061 const char *description;
2062 char compl_args[2]; /* Completion argument info */
2063 } commands[] =
2064 {
2065 {"?",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
2066 {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
2067 {"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}},
2068 {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},
2069 {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
2070 {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
2071 {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},
2072 {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},
2073 {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
2074 {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2075 {"du",cmd_du,"<mask> computes the total size of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2076 {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2077 {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
2078 {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
2079 {"history",cmd_history,"displays the command history",{COMPL_NONE,COMPL_NONE}},
2080 {"lcd",cmd_lcd,"[directory] change/report the local current working directory",{COMPL_LOCAL,COMPL_NONE}},
2081 {"link",cmd_link,"<src> <dest> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
2082 {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
2083 {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
2084 {"mask",cmd_select,"<mask> mask all filenames against this",{COMPL_REMOTE,COMPL_NONE}},
2085 {"md",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
2086 {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
2087 {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
2088 {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
2089 {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
2090 {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
2091 {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
2092 {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
2093 {"printmode",cmd_printmode,"<graphics or text> set the print mode",{COMPL_NONE,COMPL_NONE}},
2094 {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
2095 {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
2096 {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
2097 {"q",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2098 {"queue",cmd_queue,"show the print queue",{COMPL_NONE,COMPL_NONE}},
2099 {"quit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
2100 {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
2101 {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
2102 {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
2103 {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
2104 {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
2105 {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
2106 {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
2107 {"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
2108 {"symlink",cmd_symlink,"<src> <dest> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
2109 {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},
2110 {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},
2111 {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
2112
2113 /* Yes, this must be here, see crh's comment above. */
2114 {"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
2115 {"",NULL,NULL,{COMPL_NONE,COMPL_NONE}}
2116 };
2117
2118
2119 /*******************************************************************
2120 lookup a command string in the list of commands, including
2121 abbreviations
2122 ******************************************************************/
2123 static int process_tok(fstring tok)
2124 {
2125 int i = 0, matches = 0;
2126 int cmd=0;
2127 int tok_len = strlen(tok);
2128
2129 while (commands[i].fn != NULL) {
2130 if (strequal(commands[i].name,tok)) {
2131 matches = 1;
2132 cmd = i;
2133 break;
2134 } else if (strnequal(commands[i].name, tok, tok_len)) {
2135 matches++;
2136 cmd = i;
2137 }
2138 i++;
2139 }
2140
2141 if (matches == 0)
2142 return(-1);
2143 else if (matches == 1)
2144 return(cmd);
2145 else
2146 return(-2);
2147 }
2148
2149 /****************************************************************************
2150 help
2151 ****************************************************************************/
2152 static int cmd_help(void)
2153 {
2154 int i=0,j;
2155 fstring buf;
2156
2157 if (next_token_nr(NULL,buf,NULL,sizeof(buf))) {
2158 if ((i = process_tok(buf)) >= 0)
2159 d_printf("HELP %s:\n\t%s\n\n",commands[i].name,commands[i].description);
2160 } else {
2161 while (commands[i].description) {
2162 for (j=0; commands[i].description && (j<5); j++) {
2163 d_printf("%-15s",commands[i].name);
2164 i++;
2165 }
2166 d_printf("\n");
2167 }
2168 }
2169 return 0;
2170 }
2171
2172 /****************************************************************************
2173 process a -c command string
2174 ****************************************************************************/
2175 static int process_command_string(char *cmd)
2176 {
2177 pstring line;
2178 const char *ptr;
2179 int rc = 0;
2180
2181 /* establish the connection if not already */
2182
2183 if (!cli) {
2184 cli = do_connect(desthost, service);
2185 if (!cli)
2186 return 0;
2187 }
2188
2189 while (cmd[0] != '\0') {
2190 char *p;
2191 fstring tok;
2192 int i;
2193
2194 if ((p = strchr_m(cmd, ';')) == 0) {
2195 strncpy(line, cmd, 999);
2196 line[1000] = '\0';
2197 cmd += strlen(cmd);
2198 } else {
2199 if (p - cmd > 999) p = cmd + 999;
2200 strncpy(line, cmd, p - cmd);
2201 line[p - cmd] = '\0';
2202 cmd = p + 1;
2203 }
2204
2205 /* and get the first part of the command */
2206 ptr = line;
2207 if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
2208
2209 if ((i = process_tok(tok)) >= 0) {
2210 rc = commands[i].fn();
2211 } else if (i == -2) {
2212 d_printf("%s: command abbreviation ambiguous\n",tok);
2213 } else {
2214 d_printf("%s: command not found\n",tok);
2215 }
2216 }
2217
2218 return rc;
2219 }
2220
2221 /****************************************************************************
2222 handle completion of commands for readline
2223 ****************************************************************************/
2224 static char **completion_fn(char *text, int start, int end)
2225 {
2226 #define MAX_COMPLETIONS 100
2227 char **matches;
2228 int i, count=0;
2229
2230 /* for words not at the start of the line fallback to filename completion */
2231 if (start) return NULL;
2232
2233 matches = (char **)malloc(sizeof(matches[0])*MAX_COMPLETIONS);
2234 if (!matches) return NULL;
2235
2236 matches[count++] = strdup(text);
2237 if (!matches[0]) return NULL;
2238
2239 for (i=0;commands[i].fn && count < MAX_COMPLETIONS-1;i++) {
2240 if (strncmp(text, commands[i].name, strlen(text)) == 0) {
2241 matches[count] = strdup(commands[i].name);
2242 if (!matches[count]) return NULL;
2243 count++;
2244 }
2245 }
2246
2247 if (count == 2) {
2248 SAFE_FREE(matches[0]);
2249 matches[0] = strdup(matches[1]);
2250 }
2251 matches[count] = NULL;
2252 return matches;
2253 }
2254
2255
2256 /****************************************************************************
2257 make sure we swallow keepalives during idle time
2258 ****************************************************************************/
2259 static void readline_callback(void)
2260 {
2261 fd_set fds;
2262 struct timeval timeout;
2263 static time_t last_t;
2264 time_t t;
2265
2266 t = time(NULL);
2267
2268 if (t - last_t < 5) return;
2269
2270 last_t = t;
2271
2272 again:
2273 FD_ZERO(&fds);
2274 FD_SET(cli->fd,&fds);
2275
2276 timeout.tv_sec = 0;
2277 timeout.tv_usec = 0;
2278 sys_select_intr(cli->fd+1,&fds,NULL,NULL,&timeout);
2279
2280 /* We deliberately use receive_smb instead of
2281 client_receive_smb as we want to receive
2282 session keepalives and then drop them here.
2283 */
2284 if (FD_ISSET(cli->fd,&fds)) {
2285 receive_smb(cli->fd,cli->inbuf,0);
2286 goto again;
2287 }
2288
2289 cli_chkpath(cli, "\\");
2290 }
2291
2292
2293 /****************************************************************************
2294 process commands on stdin
2295 ****************************************************************************/
2296 static void process_stdin(void)
2297 {
2298 const char *ptr;
2299
2300 while (1) {
2301 fstring tok;
2302 fstring the_prompt;
2303 char *cline;
2304 pstring line;
2305 int i;
2306
2307 /* display a prompt */
2308 slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir);
2309 cline = smb_readline(the_prompt, readline_callback, completion_fn);
2310
2311 if (!cline) break;
2312
2313 pstrcpy(line, cline);
2314
2315 /* special case - first char is ! */
2316 if (*line == '!') {
2317 system(line + 1);
2318 continue;
2319 }
2320
2321 /* and get the first part of the command */
2322 ptr = line;
2323 if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue;
2324
2325 if ((i = process_tok(tok)) >= 0) {
2326 commands[i].fn();
2327 } else if (i == -2) {
2328 d_printf("%s: command abbreviation ambiguous\n",tok);
2329 } else {
2330 d_printf("%s: command not found\n",tok);
2331 }
2332 }
2333 }
2334
2335
2336 /*****************************************************
2337 return a connection to a server
2338 *******************************************************/
2339 static struct cli_state *do_connect(const char *server, const char *share)
2340 {
2341 struct cli_state *c;
2342 struct nmb_name called, calling;
2343 const char *server_n;
2344 struct in_addr ip;
2345 fstring servicename;
2346 char *sharename;
2347
2348 /* make a copy so we don't modify the global string 'service' */
2349 safe_strcpy(servicename, share, sizeof(servicename)-1);
2350 sharename = servicename;
2351 if (*sharename == '\\') {
2352 server = sharename+2;
2353 sharename = strchr_m(server,'\\');
2354 if (!sharename) return NULL;
2355 *sharename = 0;
2356 sharename++;
2357 }
2358
2359 server_n = server;
2360
2361 zero_ip(&ip);
2362
2363 make_nmb_name(&calling, global_myname(), 0x0);
2364 make_nmb_name(&called , server, name_type);
2365
2366 again:
2367 zero_ip(&ip);
2368 if (have_ip) ip = dest_ip;
2369
2370 /* have to open a new connection */
2371 if (!(c=cli_initialise(NULL)) || (cli_set_port(c, port) != port) ||
2372 !cli_connect(c, server_n, &ip)) {
2373 d_printf("Connection to %s failed\n", server_n);
2374 return NULL;
2375 }
2376
2377 c->protocol = max_protocol;
2378 c->use_kerberos = use_kerberos;
2379
2380 if (!cli_session_request(c, &calling, &called)) {
2381 char *p;
2382 d_printf("session request to %s failed (%s)\n",
2383 called.name, cli_errstr(c));
2384 cli_shutdown(c);
2385 if ((p=strchr_m(called.name, '.'))) {
2386 *p = 0;
2387 goto again;
2388 }
2389 if (strcmp(called.name, "*SMBSERVER")) {
2390 make_nmb_name(&called , "*SMBSERVER", 0x20);
2391 goto again;
2392 }
2393 return NULL;
2394 }
2395
2396 DEBUG(4,(" session request ok\n"));
2397
2398 if (!cli_negprot(c)) {
2399 d_printf("protocol negotiation failed\n");
2400 cli_shutdown(c);
2401 return NULL;
2402 }
2403
2404 if (!got_pass) {
2405 char *pass = getpass("Password: ");
2406 if (pass) {
2407 pstrcpy(password, pass);
2408 }
2409 }
2410
2411 if (!cli_session_setup(c, username,
2412 password, strlen(password),
2413 password, strlen(password),
2414 workgroup)) {
2415 /* if a password was not supplied then try again with a null username */
2416 if (password[0] || !username[0] || use_kerberos ||
2417 !cli_session_setup(c, "", "", 0, "", 0, workgroup)) {
2418 d_printf("session setup failed: %s\n", cli_errstr(c));
2419 cli_shutdown(c);
2420 return NULL;
2421 }
2422 d_printf("Anonymous login successful\n");
2423 }
2424
2425 if (*c->server_domain) {
2426 DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",
2427 c->server_domain,c->server_os,c->server_type));
2428 } else if (*c->server_os || *c->server_type){
2429 DEBUG(1,("OS=[%s] Server=[%s]\n",
2430 c->server_os,c->server_type));
2431 }
2432
2433 DEBUG(4,(" session setup ok\n"));
2434
2435 if (!cli_send_tconX(c, sharename, "?????",
2436 password, strlen(password)+1)) {
2437 d_printf("tree connect failed: %s\n", cli_errstr(c));
2438 cli_shutdown(c);
2439 return NULL;
2440 }
2441
2442 DEBUG(4,(" tconx ok\n"));
2443
2444 return c;
2445 }
2446
2447
2448 /****************************************************************************
2449 process commands from the client
2450 ****************************************************************************/
2451 static int process(char *base_directory)
2452 {
2453 int rc = 0;
2454
2455 cli = do_connect(desthost, service);
2456 if (!cli) {
2457 return 1;
2458 }
2459
2460 if (*base_directory) do_cd(base_directory);
2461
2462 if (cmdstr) {
2463 rc = process_command_string(cmdstr);
2464 } else {
2465 process_stdin();
2466 }
2467
2468 cli_shutdown(cli);
2469 return rc;
2470 }
2471
2472 /****************************************************************************
2473 usage on the program
2474 ****************************************************************************/
2475 static void usage(char *pname)
2476 {
2477 d_printf("Usage: %s service <password> [options]", pname);
2478
2479 d_printf("\nVersion %s\n",VERSION);
2480 d_printf("\t-s smb.conf pathname to smb.conf file\n");
2481 d_printf("\t-O socket_options socket options to use\n");
2482 d_printf("\t-R name resolve order use these name resolution services only\n");
2483 d_printf("\t-M host send a winpopup message to the host\n");
2484 d_printf("\t-i scope use this NetBIOS scope\n");
2485 d_printf("\t-N don't ask for a password\n");
2486 d_printf("\t-n netbios name. Use this name as my netbios name\n");
2487 d_printf("\t-d debuglevel set the debuglevel\n");
2488 d_printf("\t-p port connect to the specified port\n");
2489 d_printf("\t-l log basename. Basename for log/debug files\n");
2490 d_printf("\t-h Print this help message.\n");
2491 d_printf("\t-I dest IP use this IP to connect to\n");
2492 d_printf("\t-E write messages to stderr instead of stdout\n");
2493 d_printf("\t-k use kerberos (active directory) authentication\n");
2494 d_printf("\t-U username set the network username\n");
2495 d_printf("\t-L host get a list of shares available on a host\n");
2496 d_printf("\t-t terminal code terminal i/o code {sjis|euc|jis7|jis8|junet|hex}\n");
2497 d_printf("\t-m max protocol set the max protocol level\n");
2498 d_printf("\t-A filename get the credentials from a file\n");
2499 d_printf("\t-W workgroup set the workgroup name\n");
2500 d_printf("\t-T<c|x>IXFqgbNan command line tar\n");
2501 d_printf("\t-D directory start from directory\n");
2502 d_printf("\t-c command string execute semicolon separated commands\n");
2503 d_printf("\t-b xmit/send buffer changes the transmit/send buffer (default: 65520)\n");
2504 d_printf("\n");
2505 }
2506
2507
2508 /****************************************************************************
2509 get a password from a a file or file descriptor
2510 exit on failure
2511 ****************************************************************************/
2512 static void get_password_file(void)
2513 {
2514 int fd = -1;
2515 char *p;
2516 BOOL close_it = False;
2517 pstring spec;
2518 char pass[128];
2519
2520 if ((p = getenv("PASSWD_FD")) != NULL) {
2521 pstrcpy(spec, "descriptor ");
2522 pstrcat(spec, p);
2523 sscanf(p, "%d", &fd);
2524 close_it = False;
2525 } else if ((p = getenv("PASSWD_FILE")) != NULL) {
2526 fd = sys_open(p, O_RDONLY, 0);
2527 pstrcpy(spec, p);
2528 if (fd < 0) {
2529 fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",
2530 spec, strerror(errno));
2531 exit(1);
2532 }
2533 close_it = True;
2534 }
2535
2536 for(p = pass, *p = '\0'; /* ensure that pass is null-terminated */
2537 p && p - pass < sizeof(pass);) {
2538 switch (read(fd, p, 1)) {
2539 case 1:
2540 if (*p != '\n' && *p != '\0') {
2541 *++p = '\0'; /* advance p, and null-terminate pass */
2542 break;
2543 }
2544 case 0:
2545 if (p - pass) {
2546 *p = '\0'; /* null-terminate it, just in case... */
2547 p = NULL; /* then force the loop condition to become false */
2548 break;
2549 } else {
2550 fprintf(stderr, "Error reading password from file %s: %s\n",
2551 spec, "empty password\n");
2552 exit(1);
2553 }
2554
2555 default:
2556 fprintf(stderr, "Error reading password from file %s: %s\n",
2557 spec, strerror(errno));
2558 exit(1);
2559 }
2560 }
2561 pstrcpy(password, pass);
2562 if (close_it)
2563 close(fd);
2564 }
2565
2566
2567
2568 /****************************************************************************
2569 handle a -L query
2570 ****************************************************************************/
2571 static int do_host_query(char *query_host)
2572 {
2573 cli = do_connect(query_host, "IPC$");
2574 if (!cli)
2575 return 1;
2576
2577 browse_host(True);
2578 list_servers(workgroup);
2579
2580 cli_shutdown(cli);
2581
2582 return(0);
2583 }
2584
2585
2586 /****************************************************************************
2587 handle a tar operation
2588 ****************************************************************************/
2589 static int do_tar_op(char *base_directory)
2590 {
2591 int ret;
2592
2593 /* do we already have a connection? */
2594 if (!cli) {
2595 cli = do_connect(desthost, service);
2596 if (!cli)
2597 return 1;
2598 }
2599
2600 recurse=True;
2601
2602 if (*base_directory) do_cd(base_directory);
2603
2604 ret=process_tar();
2605
2606 cli_shutdown(cli);
2607
2608 return(ret);
2609 }
2610
2611 /****************************************************************************
2612 handle a message operation
2613 ****************************************************************************/
2614 static int do_message_op(void)
2615 {
2616 struct in_addr ip;
2617 struct nmb_name called, calling;
2618 fstring server_name;
2619 char name_type_hex[10];
2620
2621 make_nmb_name(&calling, global_myname(), 0x0);
2622 make_nmb_name(&called , desthost, name_type);
2623
2624 safe_strcpy(server_name, desthost, sizeof(server_name));
2625 snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);
2626 safe_strcat(server_name, name_type_hex, sizeof(server_name));
2627
2628 zero_ip(&ip);
2629 if (have_ip) ip = dest_ip;
2630
2631 if (!(cli=cli_initialise(NULL)) || (cli_set_port(cli, port) != port) ||
2632 !cli_connect(cli, server_name, &ip)) {
2633 d_printf("Connection to %s failed\n", desthost);
2634 return 1;
2635 }
2636
2637 if (!cli_session_request(cli, &calling, &called)) {
2638 d_printf("session request failed\n");
2639 cli_shutdown(cli);
2640 return 1;
2641 }
2642
2643 send_message();
2644 cli_shutdown(cli);
2645
2646 return 0;
2647 }
2648
2649
2650 /**
2651 * Process "-L hostname" option.
2652 *
2653 * We don't actually do anything yet -- we just stash the name in a
2654 * global variable and do the query when all options have been read.
2655 **/
2656 static void remember_query_host(const char *arg,
2657 pstring query_host)
2658 {
2659 char *slash;
2660
2661 while (*arg == '\\' || *arg == '/')
2662 arg++;
2663 pstrcpy(query_host, arg);
2664 if ((slash = strchr(query_host, '/'))
2665 || (slash = strchr(query_host, '\\'))) {
2666 *slash = 0;
2667 }
2668 }
2669
2670
2671 /****************************************************************************
2672 main program
2673 ****************************************************************************/
2674 int main(int argc,char *argv[])
2675 {
2676 fstring base_directory;
2677 char *pname = argv[0];
2678 int opt;
2679 extern char *optarg;
2680 extern int optind;
2681 int old_debug;
2682 pstring query_host;
2683 BOOL message = False;
2684 extern char tar_type;
2685 pstring term_code;
2686 pstring new_name_resolve_order;
2687 pstring logfile;
2688 char *p;
2689 int rc = 0;
2690
2691 #ifdef KANJI
2692 pstrcpy(term_code, KANJI);
2693 #else /* KANJI */
2694 *term_code = 0;
2695 #endif /* KANJI */
2696
2697 *query_host = 0;
2698 *base_directory = 0;
2699
2700 *new_name_resolve_order = 0;
2701
2702 DEBUGLEVEL = 2;
2703 AllowDebugChange = False;
2704
2705 setup_logging(pname,True);
2706
2707 /*
2708 * If the -E option is given, be careful not to clobber stdout
2709 * before processing the options. 28.Feb.99, richard@hacom.nl.
2710 * Also pre-parse the -s option to get the service file name.
2711 */
2712
2713 for (opt = 1; opt < argc; opt++) {
2714 if (strcmp(argv[opt], "-E") == 0)
2715 dbf = x_stderr;
2716 else if(strncmp(argv[opt], "-s", 2) == 0) {
2717 if(argv[opt][2] != '\0')
2718 pstrcpy(dyn_CONFIGFILE, &argv[opt][2]);
2719 else if(argv[opt+1] != NULL) {
2720 /*
2721 * At least one more arg left.
2722 */
2723 pstrcpy(dyn_CONFIGFILE, argv[opt+1]);
2724 } else {
2725 usage(pname);
2726 exit(1);
2727 }
2728 }
2729 }
2730
2731 in_client = True; /* Make sure that we tell lp_load we are */
2732
2733 old_debug = DEBUGLEVEL;
2734 if (!lp_load(dyn_CONFIGFILE,True,False,False)) {
2735 fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",
2736 prog_name, dyn_CONFIGFILE);
2737 }
2738 DEBUGLEVEL = old_debug;
2739
2740 pstrcpy(workgroup,lp_workgroup());
2741
2742 load_interfaces();
2743
2744 if (getenv("USER")) {
2745 pstrcpy(username,getenv("USER"));
2746
2747 /* modification to support userid%passwd syntax in the USER var
2748 25.Aug.97, jdblair@uab.edu */
2749
2750 if ((p=strchr_m(username,'%'))) {
2751 *p = 0;
2752 pstrcpy(password,p+1);
2753 got_pass = True;
2754 memset(strchr_m(getenv("USER"),'%')+1,'X',strlen(password));
2755 }
2756 }
2757
2758 /* modification to support PASSWD environmental var
2759 25.Aug.97, jdblair@uab.edu */
2760 if (getenv("PASSWD")) {
2761 pstrcpy(password,getenv("PASSWD"));
2762 got_pass = True;
2763 }
2764
2765 if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
2766 get_password_file();
2767 got_pass = True;
2768 }
2769
2770 if (*username == 0 && getenv("LOGNAME")) {
2771 pstrcpy(username,getenv("LOGNAME"));
2772 }
2773
2774 if (*username == 0) {
2775 pstrcpy(username,"GUEST");
2776 }
2777
2778 if (argc < 2) {
2779 usage(pname);
2780 exit(1);
2781 }
2782
2783 /* FIXME: At the moment, if the user should happen to give the
2784 * options ahead of the service name (in standard Unix
2785 * fashion) then smbclient just spits out the usage message
2786 * with no explanation of what in particular was wrong. Is
2787 * there any reason we can't just parse out the service name
2788 * and password after running getopt?? -- mbp */
2789 if (*argv[1] != '-') {
2790 pstrcpy(service,argv[1]);
2791 /* Convert any '/' characters in the service name to '\' characters */
2792 string_replace( service, '/','\\');
2793 argc--;
2794 argv++;
2795
2796 if (count_chars(service,'\\') < 3) {
2797 usage(pname);
2798 d_printf("\n%s: Not enough '\\' characters in service\n",service);
2799 exit(1);
2800 }
2801
2802 if (argc > 1 && (*argv[1] != '-')) {
2803 got_pass = True;
2804 pstrcpy(password,argv[1]);
2805 memset(argv[1],'X',strlen(argv[1]));
2806 argc--;
2807 argv++;
2808 }
2809 }
2810
2811 while ((opt =
2812 getopt(argc, argv,"s:O:R:M:i:Nn:d:Pp:l:hI:EU:L:t:m:W:T:D:c:b:A:k")) != EOF) {
2813 switch (opt) {
2814 case 's':
2815 pstrcpy(dyn_CONFIGFILE, optarg);
2816 break;
2817 case 'O':
2818 pstrcpy(user_socket_options,optarg);
2819 break;
2820 case 'R':
2821 pstrcpy(new_name_resolve_order, optarg);
2822 break;
2823 case 'M':
2824 /* Messages are sent to NetBIOS name type 0x3
2825 * (Messenger Service). Make sure we default
2826 * to port 139 instead of port 445. srl,crh
2827 */
2828 name_type = 0x03;
2829 pstrcpy(desthost,optarg);
2830 if( 0 == port )
2831 port = 139;
2832 message = True;
2833 break;
2834 case 'i':
2835 set_global_scope(optarg);
2836 break;
2837 case 'N':
2838 got_pass = True;
2839 break;
2840 case 'n':
2841 set_global_myname(optarg);
2842 break;
2843 case 'd':
2844 if (*optarg == 'A')
2845 DEBUGLEVEL = 10000;
2846 else
2847 DEBUGLEVEL = atoi(optarg);
2848 break;
2849 case 'P':
2850 /* not needed anymore */
2851 break;
2852 case 'p':
2853 port = atoi(optarg);
2854 break;
2855 case 'l':
2856 slprintf(logfile,sizeof(logfile)-1, "%s.client",optarg);
2857 lp_set_logfile(logfile);
2858 break;
2859 case 'h':
2860 usage(pname);
2861 exit(0);
2862 break;
2863 case 'I':
2864 {
2865 dest_ip = *interpret_addr2(optarg);
2866 if (is_zero_ip(dest_ip))
2867 exit(1);
2868 have_ip = True;
2869 }
2870 break;
2871 case 'E':
2872 display_set_stderr();
2873 dbf = x_stderr;
2874 break;
2875 case 'U':
2876 {
2877 char *lp;
2878
2879 got_user = True;
2880 pstrcpy(username,optarg);
2881 if ((lp=strchr_m(username,'%'))) {
2882 *lp = 0;
2883 pstrcpy(password,lp+1);
2884 got_pass = True;
2885 memset(strchr_m(optarg,'%')+1,'X',strlen(password));
2886 }
2887 }
2888 break;
2889
2890 case 'A':
2891 {
2892 XFILE *auth;
2893 fstring buf;
2894 uint16 len = 0;
2895 char *ptr, *val, *param;
2896
2897 if ((auth=x_fopen(optarg, O_RDONLY, 0)) == NULL)
2898 {
2899 /* fail if we can't open the credentials file */
2900 d_printf("ERROR: Unable to open credentials file!\n");
2901 exit (-1);
2902 }
2903
2904 while (!x_feof(auth))
2905 {
2906 /* get a line from the file */
2907 if (!x_fgets(buf, sizeof(buf), auth))
2908 continue;
2909 len = strlen(buf);
2910
2911 if ((len) && (buf[len-1]=='\n'))
2912 {
2913 buf[len-1] = '\0';
2914 len--;
2915 }
2916 if (len == 0)
2917 continue;
2918
2919 /* break up the line into parameter & value.
2920 will need to eat a little whitespace possibly */
2921 param = buf;
2922 if (!(ptr = strchr_m (buf, '=')))
2923 continue;
2924 val = ptr+1;
2925 *ptr = '\0';
2926
2927 /* eat leading white space */
2928 while ((*val!='\0') && ((*val==' ') || (*val=='\t')))
2929 val++;
2930
2931 if (strwicmp("password", param) == 0)
2932 {
2933 pstrcpy(password, val);
2934 got_pass = True;
2935 }
2936 else if (strwicmp("username", param) == 0)
2937 pstrcpy(username, val);
2938 else if (strwicmp("domain", param) == 0)
2939 pstrcpy(workgroup,val);
2940 memset(buf, 0, sizeof(buf));
2941 }
2942 x_fclose(auth);
2943 }
2944 break;
2945
2946 case 'L':
2947 remember_query_host(optarg, query_host);
2948 break;
2949 case 't':
2950 pstrcpy(term_code, optarg);
2951 break;
2952 case 'm':
2953 max_protocol = interpret_protocol(optarg, max_protocol);
2954 break;
2955 case 'W':
2956 pstrcpy(workgroup,optarg);
2957 break;
2958 case 'T':
2959 if (!tar_parseargs(argc, argv, optarg, optind)) {
2960 usage(pname);
2961 exit(1);
2962 }
2963 break;
2964 case 'D':
2965 fstrcpy(base_directory,optarg);
2966 break;
2967 case 'c':
2968 cmdstr = optarg;
2969 break;
2970 case 'b':
2971 io_bufsize = MAX(1, atoi(optarg));
2972 break;
2973 case 'k':
2974 #ifdef HAVE_KRB5
2975 use_kerberos = True;
2976 #else
2977 d_printf("No kerberos support compiled in\n");
2978 exit(1);
2979 #endif
2980 break;
2981 default:
2982 usage(pname);
2983 exit(1);
2984 }
2985 }
2986
2987 if (use_kerberos && !got_user)
2988 got_pass = True;
2989
2990 init_names();
2991
2992 if(*new_name_resolve_order)
2993 lp_set_name_resolve_order(new_name_resolve_order);
2994
2995 if (!tar_type && !*query_host && !*service && !message) {
2996 usage(pname);
2997 exit(1);
2998 }
2999
3000 DEBUG( 3, ( "Client started (version %s).\n", VERSION ) );
3001
3002 if (tar_type) {
3003 if (cmdstr)
3004 process_command_string(cmdstr);
3005 return do_tar_op(base_directory);
3006 }
3007
3008 if ((p=strchr_m(query_host,'#'))) {
3009 *p = 0;
3010 p++;
3011 sscanf(p, "%x", &name_type);
3012 }
3013
3014 if (*query_host) {
3015 return do_host_query(query_host);
3016 }
3017
3018 if (message) {
3019 return do_message_op();
3020 }
3021
3022 if (process(base_directory)) {
3023 return 1;
3024 }
3025
3026 return rc;
3027 }
Samba GIT mirror