![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmds.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ftp|
Return to cmds.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ftp |
1.1 root 1: /*
2: * Copyright (c) 1985, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)cmds.c 5.23 (Berkeley) 6/1/90";
22: #endif /* not lint */
23:
24: /*
25: * FTP User Program -- Command Routines.
26: */
27: #include <sys/param.h>
28: #include <sys/wait.h>
29: #include <sys/stat.h>
30: #include <sys/socket.h>
31:
32: #include <arpa/ftp.h>
33:
34: #include <signal.h>
35: #include <stdio.h>
36: #include <errno.h>
37: #include <netdb.h>
38: #include <ctype.h>
39: #include <time.h>
40: #include <netinet/in.h>
41:
42: #include "ftp_var.h"
43: #include "pathnames.h"
44:
45: extern char *globerr;
46: extern char **glob();
47: extern char *home;
48: extern char *remglob();
49: extern char *getenv();
50: extern char *index();
51: extern char *rindex();
52: extern char *strerror();
53: extern int errno;
54: extern off_t restart_point;
55: extern char reply_string[];
56:
57: char *mname;
58: jmp_buf jabort;
59: char *dotrans(), *domap();
60:
61: /*
62: * Connect to peer server and
63: * auto-login, if possible.
64: */
65: setpeer(argc, argv)
66: int argc;
67: char *argv[];
68: {
69: char *host, *hookup();
70: short port;
71:
72: if (connected) {
73: printf("Already connected to %s, use close first.\n",
74: hostname);
75: code = -1;
76: return;
77: }
78: if (argc < 2) {
79: (void) strcat(line, " ");
80: printf("(to) ");
81: (void) gets(&line[strlen(line)]);
82: makeargv();
83: argc = margc;
84: argv = margv;
85: }
86: if (argc > 3) {
87: printf("usage: %s host-name [port]\n", argv[0]);
88: code = -1;
89: return;
90: }
91: port = sp->s_port;
92: if (argc > 2) {
93: port = atoi(argv[2]);
94: if (port <= 0) {
95: printf("%s: bad port number-- %s\n", argv[1], argv[2]);
96: printf ("usage: %s host-name [port]\n", argv[0]);
97: code = -1;
98: return;
99: }
100: port = htons(port);
101: }
102: host = hookup(argv[1], port);
103: if (host) {
104: int overbose;
105:
106: connected = 1;
107: /*
108: * Set up defaults for FTP.
109: */
110: (void) strcpy(typename, "ascii"), type = TYPE_A;
111: curtype = TYPE_A;
112: (void) strcpy(formname, "non-print"), form = FORM_N;
113: (void) strcpy(modename, "stream"), mode = MODE_S;
114: (void) strcpy(structname, "file"), stru = STRU_F;
115: (void) strcpy(bytename, "8"), bytesize = 8;
116: if (autologin)
117: (void) login(argv[1]);
118:
119: #if defined(unix) && NBBY == 8
120: /*
121: * this ifdef is to keep someone form "porting" this to an incompatible
122: * system and not checking this out. This way they have to think about it.
123: */
124: overbose = verbose;
125: if (debug == 0)
126: verbose = -1;
127: if (command("SYST") == COMPLETE && overbose) {
128: register char *cp, c;
129: cp = index(reply_string+4, ' ');
130: if (cp == NULL)
131: cp = index(reply_string+4, '\r');
132: if (cp) {
133: if (cp[-1] == '.')
134: cp--;
135: c = *cp;
136: *cp = '\0';
137: }
138:
139: printf("Remote system type is %s.\n",
140: reply_string+4);
141: if (cp)
142: *cp = c;
143: }
144: if (!strncmp(reply_string, "215 UNIX Type: L8", 17)) {
145: if (proxy)
146: unix_proxy = 1;
147: else
148: unix_server = 1;
149: /*
150: * Set type to 0 (not specified by user),
151: * meaning binary by default, but don't bother
152: * telling server. We can use binary
153: * for text files unless changed by the user.
154: */
155: type = 0;
156: (void) strcpy(typename, "binary");
157: if (overbose)
158: printf("Using %s mode to transfer files.\n",
159: typename);
160: } else {
161: if (proxy)
162: unix_proxy = 0;
163: else
164: unix_server = 0;
165: if (overbose &&
166: !strncmp(reply_string, "215 TOPS20", 10))
167: printf(
168: "Remember to set tenex mode when transfering binary files from this machine.\n");
169: }
170: verbose = overbose;
171: #endif /* unix */
172: }
173: }
174:
175: struct types {
176: char *t_name;
177: char *t_mode;
178: int t_type;
179: char *t_arg;
180: } types[] = {
181: { "ascii", "A", TYPE_A, 0 },
182: { "binary", "I", TYPE_I, 0 },
183: { "image", "I", TYPE_I, 0 },
184: { "ebcdic", "E", TYPE_E, 0 },
185: { "tenex", "L", TYPE_L, bytename },
186: 0
187: };
188:
189: /*
190: * Set transfer type.
191: */
192: settype(argc, argv)
193: char *argv[];
194: {
195: register struct types *p;
196: int comret;
197:
198: if (argc > 2) {
199: char *sep;
200:
201: printf("usage: %s [", argv[0]);
202: sep = " ";
203: for (p = types; p->t_name; p++) {
204: printf("%s%s", sep, p->t_name);
205: sep = " | ";
206: }
207: printf(" ]\n");
208: code = -1;
209: return;
210: }
211: if (argc < 2) {
212: printf("Using %s mode to transfer files.\n", typename);
213: code = 0;
214: return;
215: }
216: for (p = types; p->t_name; p++)
217: if (strcmp(argv[1], p->t_name) == 0)
218: break;
219: if (p->t_name == 0) {
220: printf("%s: unknown mode\n", argv[1]);
221: code = -1;
222: return;
223: }
224: if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
225: comret = command ("TYPE %s %s", p->t_mode, p->t_arg);
226: else
227: comret = command("TYPE %s", p->t_mode);
228: if (comret == COMPLETE) {
229: (void) strcpy(typename, p->t_name);
230: curtype = type = p->t_type;
231: }
232: }
233:
234: /*
235: * Internal form of settype; changes current type in use with server
236: * without changing our notion of the type for data transfers.
237: * Used to change to and from ascii for listings.
238: */
239: changetype(newtype, show)
240: int newtype, show;
241: {
242: register struct types *p;
243: int comret, oldverbose = verbose;
244:
245: if (newtype == 0)
246: newtype = TYPE_I;
247: if (newtype == curtype)
248: return;
249: if (debug == 0 && show == 0)
250: verbose = 0;
251: for (p = types; p->t_name; p++)
252: if (newtype == p->t_type)
253: break;
254: if (p->t_name == 0) {
255: printf("ftp: internal error: unknown type %d\n", newtype);
256: return;
257: }
258: if (newtype == TYPE_L && bytename[0] != '\0')
259: comret = command("TYPE %s %s", p->t_mode, bytename);
260: else
261: comret = command("TYPE %s", p->t_mode);
262: if (comret == COMPLETE)
263: curtype = newtype;
264: verbose = oldverbose;
265: }
266:
267: char *stype[] = {
268: "type",
269: "",
270: 0
271: };
272:
273: /*
274: * Set binary transfer type.
275: */
276: /*VARARGS*/
277: setbinary()
278: {
279: stype[1] = "binary";
280: settype(2, stype);
281: }
282:
283: /*
284: * Set ascii transfer type.
285: */
286: /*VARARGS*/
287: setascii()
288: {
289: stype[1] = "ascii";
290: settype(2, stype);
291: }
292:
293: /*
294: * Set tenex transfer type.
295: */
296: /*VARARGS*/
297: settenex()
298: {
299: stype[1] = "tenex";
300: settype(2, stype);
301: }
302:
303: /*
304: * Set file transfer mode.
305: */
306: /*ARGSUSED*/
307: setmode(argc, argv)
308: char *argv[];
309: {
310:
311: printf("We only support %s mode, sorry.\n", modename);
312: code = -1;
313: }
314:
315: /*
316: * Set file transfer format.
317: */
318: /*ARGSUSED*/
319: setform(argc, argv)
320: char *argv[];
321: {
322:
323: printf("We only support %s format, sorry.\n", formname);
324: code = -1;
325: }
326:
327: /*
328: * Set file transfer structure.
329: */
330: /*ARGSUSED*/
331: setstruct(argc, argv)
332: char *argv[];
333: {
334:
335: printf("We only support %s structure, sorry.\n", structname);
336: code = -1;
337: }
338:
339: /*
340: * Send a single file.
341: */
342: put(argc, argv)
343: int argc;
344: char *argv[];
345: {
346: char *cmd;
347: int loc = 0;
348: char *oldargv1, *oldargv2;
349:
350: if (argc == 2) {
351: argc++;
352: argv[2] = argv[1];
353: loc++;
354: }
355: if (argc < 2) {
356: (void) strcat(line, " ");
357: printf("(local-file) ");
358: (void) gets(&line[strlen(line)]);
359: makeargv();
360: argc = margc;
361: argv = margv;
362: }
363: if (argc < 2) {
364: usage:
365: printf("usage:%s local-file remote-file\n", argv[0]);
366: code = -1;
367: return;
368: }
369: if (argc < 3) {
370: (void) strcat(line, " ");
371: printf("(remote-file) ");
372: (void) gets(&line[strlen(line)]);
373: makeargv();
374: argc = margc;
375: argv = margv;
376: }
377: if (argc < 3)
378: goto usage;
379: oldargv1 = argv[1];
380: oldargv2 = argv[2];
381: if (!globulize(&argv[1])) {
382: code = -1;
383: return;
384: }
385: /*
386: * If "globulize" modifies argv[1], and argv[2] is a copy of
387: * the old argv[1], make it a copy of the new argv[1].
388: */
389: if (argv[1] != oldargv1 && argv[2] == oldargv1) {
390: argv[2] = argv[1];
391: }
392: cmd = (argv[0][0] == 'a') ? "APPE" : ((sunique) ? "STOU" : "STOR");
393: if (loc && ntflag) {
394: argv[2] = dotrans(argv[2]);
395: }
396: if (loc && mapflag) {
397: argv[2] = domap(argv[2]);
398: }
399: sendrequest(cmd, argv[1], argv[2],
400: argv[1] != oldargv1 || argv[2] != oldargv2);
401: }
402:
403: /*
404: * Send multiple files.
405: */
406: mput(argc, argv)
407: int argc;
408: char **argv;
409: {
410: extern jmp_buf jabort;
411: register int i;
412: sig_t oldintr;
413: int ointer;
414: char *tp;
415: void mabort();
416:
417: if (argc < 2) {
418: (void) strcat(line, " ");
419: printf("(local-files) ");
420: (void) gets(&line[strlen(line)]);
421: makeargv();
422: argc = margc;
423: argv = margv;
424: }
425: if (argc < 2) {
426: printf("usage:%s local-files\n", argv[0]);
427: code = -1;
428: return;
429: }
430: mname = argv[0];
431: mflag = 1;
432: oldintr = signal(SIGINT, mabort);
433: (void) setjmp(jabort);
434: if (proxy) {
435: char *cp, *tp2, tmpbuf[MAXPATHLEN];
436:
437: while ((cp = remglob(argv,0)) != NULL) {
438: if (*cp == 0) {
439: mflag = 0;
440: continue;
441: }
442: if (mflag && confirm(argv[0], cp)) {
443: tp = cp;
444: if (mcase) {
445: while (*tp && !islower(*tp)) {
446: tp++;
447: }
448: if (!*tp) {
449: tp = cp;
450: tp2 = tmpbuf;
451: while ((*tp2 = *tp) != NULL) {
452: if (isupper(*tp2)) {
453: *tp2 = 'a' + *tp2 - 'A';
454: }
455: tp++;
456: tp2++;
457: }
458: }
459: tp = tmpbuf;
460: }
461: if (ntflag) {
462: tp = dotrans(tp);
463: }
464: if (mapflag) {
465: tp = domap(tp);
466: }
467: sendrequest((sunique) ? "STOU" : "STOR",
468: cp, tp, cp != tp || !interactive);
469: if (!mflag && fromatty) {
470: ointer = interactive;
471: interactive = 1;
472: if (confirm("Continue with","mput")) {
473: mflag++;
474: }
475: interactive = ointer;
476: }
477: }
478: }
479: (void) signal(SIGINT, oldintr);
480: mflag = 0;
481: return;
482: }
483: for (i = 1; i < argc; i++) {
484: register char **cpp, **gargs;
485:
486: if (!doglob) {
487: if (mflag && confirm(argv[0], argv[i])) {
488: tp = (ntflag) ? dotrans(argv[i]) : argv[i];
489: tp = (mapflag) ? domap(tp) : tp;
490: sendrequest((sunique) ? "STOU" : "STOR",
491: argv[i], tp, tp != argv[i] || !interactive);
492: if (!mflag && fromatty) {
493: ointer = interactive;
494: interactive = 1;
495: if (confirm("Continue with","mput")) {
496: mflag++;
497: }
498: interactive = ointer;
499: }
500: }
501: continue;
502: }
503: gargs = glob(argv[i]);
504: if (globerr != NULL) {
505: printf("%s\n", globerr);
506: if (gargs) {
507: blkfree(gargs);
508: free((char *)gargs);
509: }
510: continue;
511: }
512: for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
513: if (mflag && confirm(argv[0], *cpp)) {
514: tp = (ntflag) ? dotrans(*cpp) : *cpp;
515: tp = (mapflag) ? domap(tp) : tp;
516: sendrequest((sunique) ? "STOU" : "STOR",
517: *cpp, tp, *cpp != tp || !interactive);
518: if (!mflag && fromatty) {
519: ointer = interactive;
520: interactive = 1;
521: if (confirm("Continue with","mput")) {
522: mflag++;
523: }
524: interactive = ointer;
525: }
526: }
527: }
528: if (gargs != NULL) {
529: blkfree(gargs);
530: free((char *)gargs);
531: }
532: }
533: (void) signal(SIGINT, oldintr);
534: mflag = 0;
535: }
536:
537: reget(argc, argv)
538: char *argv[];
539: {
540: (void) getit(argc, argv, 1, "r+w");
541: }
542:
543: get(argc, argv)
544: char *argv[];
545: {
546: (void) getit(argc, argv, 0, restart_point ? "r+w" : "w" );
547: }
548:
549: /*
550: * Receive one file.
551: */
552: getit(argc, argv, restartit, mode)
553: char *argv[];
554: char *mode;
555: {
556: int loc = 0;
557: char *oldargv1, *oldargv2;
558:
559: if (argc == 2) {
560: argc++;
561: argv[2] = argv[1];
562: loc++;
563: }
564: if (argc < 2) {
565: (void) strcat(line, " ");
566: printf("(remote-file) ");
567: (void) gets(&line[strlen(line)]);
568: makeargv();
569: argc = margc;
570: argv = margv;
571: }
572: if (argc < 2) {
573: usage:
574: printf("usage: %s remote-file [ local-file ]\n", argv[0]);
575: code = -1;
576: return (0);
577: }
578: if (argc < 3) {
579: (void) strcat(line, " ");
580: printf("(local-file) ");
581: (void) gets(&line[strlen(line)]);
582: makeargv();
583: argc = margc;
584: argv = margv;
585: }
586: if (argc < 3)
587: goto usage;
588: oldargv1 = argv[1];
589: oldargv2 = argv[2];
590: if (!globulize(&argv[2])) {
591: code = -1;
592: return (0);
593: }
594: if (loc && mcase) {
595: char *tp = argv[1], *tp2, tmpbuf[MAXPATHLEN];
596:
597: while (*tp && !islower(*tp)) {
598: tp++;
599: }
600: if (!*tp) {
601: tp = argv[2];
602: tp2 = tmpbuf;
603: while ((*tp2 = *tp) != NULL) {
604: if (isupper(*tp2)) {
605: *tp2 = 'a' + *tp2 - 'A';
606: }
607: tp++;
608: tp2++;
609: }
610: argv[2] = tmpbuf;
611: }
612: }
613: if (loc && ntflag)
614: argv[2] = dotrans(argv[2]);
615: if (loc && mapflag)
616: argv[2] = domap(argv[2]);
617: if (restartit) {
618: struct stat stbuf;
619: int ret;
620:
621: ret = stat(argv[2], &stbuf);
622: if (restartit == 1) {
623: if (ret < 0) {
624: fprintf(stderr, "local: %s: %s\n", argv[2],
625: strerror(errno));
626: return (0);
627: }
628: restart_point = stbuf.st_size;
629: } else {
630: if (ret == 0) {
631: int overbose;
632:
633: overbose = verbose;
634: if (debug == 0)
635: verbose = -1;
636: if (command("MDTM %s", argv[1]) == COMPLETE) {
637: int yy, mo, day, hour, min, sec;
638: struct tm *tm;
639: verbose = overbose;
640: sscanf(reply_string,
641: "%*s %04d%02d%02d%02d%02d%02d",
642: &yy, &mo, &day, &hour, &min, &sec);
643: tm = gmtime(&stbuf.st_mtime);
644: tm->tm_mon++;
645: if (tm->tm_year > yy%100)
646: return (1);
647: else if (tm->tm_year == yy%100) {
648: if (tm->tm_mon > mo)
649: return (1);
650: } else if (tm->tm_mon == mo) {
651: if (tm->tm_mday > day)
652: return (1);
653: } else if (tm->tm_mday == day) {
654: if (tm->tm_hour > hour)
655: return (1);
656: } else if (tm->tm_hour == hour) {
657: if (tm->tm_min > min)
658: return (1);
659: } else if (tm->tm_min == min) {
660: if (tm->tm_sec > sec)
661: return (1);
662: }
663: } else {
664: printf("%s\n", reply_string);
665: verbose = overbose;
666: return (0);
667: }
668: }
669: }
670: }
671:
672: recvrequest("RETR", argv[2], argv[1], mode,
673: argv[1] != oldargv1 || argv[2] != oldargv2);
674: restart_point = 0;
675: return (0);
676: }
677:
678: void
679: mabort()
680: {
681: int ointer;
682: extern jmp_buf jabort;
683:
684: printf("\n");
685: (void) fflush(stdout);
686: if (mflag && fromatty) {
687: ointer = interactive;
688: interactive = 1;
689: if (confirm("Continue with", mname)) {
690: interactive = ointer;
691: longjmp(jabort,0);
692: }
693: interactive = ointer;
694: }
695: mflag = 0;
696: longjmp(jabort,0);
697: }
698:
699: /*
700: * Get multiple files.
701: */
702: mget(argc, argv)
703: int argc;
704: char **argv;
705: {
706: extern jmp_buf jabort;
707: sig_t oldintr;
708: int ointer;
709: char *cp, *tp, *tp2, tmpbuf[MAXPATHLEN];
710: void mabort();
711:
712: if (argc < 2) {
713: (void) strcat(line, " ");
714: printf("(remote-files) ");
715: (void) gets(&line[strlen(line)]);
716: makeargv();
717: argc = margc;
718: argv = margv;
719: }
720: if (argc < 2) {
721: printf("usage:%s remote-files\n", argv[0]);
722: code = -1;
723: return;
724: }
725: mname = argv[0];
726: mflag = 1;
727: oldintr = signal(SIGINT,mabort);
728: (void) setjmp(jabort);
729: while ((cp = remglob(argv,proxy)) != NULL) {
730: if (*cp == '\0') {
731: mflag = 0;
732: continue;
733: }
734: if (mflag && confirm(argv[0], cp)) {
735: tp = cp;
736: if (mcase) {
737: while (*tp && !islower(*tp)) {
738: tp++;
739: }
740: if (!*tp) {
741: tp = cp;
742: tp2 = tmpbuf;
743: while ((*tp2 = *tp) != NULL) {
744: if (isupper(*tp2)) {
745: *tp2 = 'a' + *tp2 - 'A';
746: }
747: tp++;
748: tp2++;
749: }
750: }
751: tp = tmpbuf;
752: }
753: if (ntflag) {
754: tp = dotrans(tp);
755: }
756: if (mapflag) {
757: tp = domap(tp);
758: }
759: recvrequest("RETR", tp, cp, "w",
760: tp != cp || !interactive);
761: if (!mflag && fromatty) {
762: ointer = interactive;
763: interactive = 1;
764: if (confirm("Continue with","mget")) {
765: mflag++;
766: }
767: interactive = ointer;
768: }
769: }
770: }
771: (void) signal(SIGINT,oldintr);
772: mflag = 0;
773: }
774:
775: char *
776: remglob(argv,doswitch)
777: char *argv[];
778: int doswitch;
779: {
780: char temp[16];
781: static char buf[MAXPATHLEN];
782: static FILE *ftemp = NULL;
783: static char **args;
784: int oldverbose, oldhash;
785: char *cp, *mode;
786:
787: if (!mflag) {
788: if (!doglob) {
789: args = NULL;
790: }
791: else {
792: if (ftemp) {
793: (void) fclose(ftemp);
794: ftemp = NULL;
795: }
796: }
797: return(NULL);
798: }
799: if (!doglob) {
800: if (args == NULL)
801: args = argv;
802: if ((cp = *++args) == NULL)
803: args = NULL;
804: return (cp);
805: }
806: if (ftemp == NULL) {
807: (void) strcpy(temp, _PATH_TMP);
808: (void) mktemp(temp);
809: oldverbose = verbose, verbose = 0;
810: oldhash = hash, hash = 0;
811: if (doswitch) {
812: pswitch(!proxy);
813: }
814: for (mode = "w"; *++argv != NULL; mode = "a")
815: recvrequest ("NLST", temp, *argv, mode, 0);
816: if (doswitch) {
817: pswitch(!proxy);
818: }
819: verbose = oldverbose; hash = oldhash;
820: ftemp = fopen(temp, "r");
821: (void) unlink(temp);
822: if (ftemp == NULL) {
823: printf("can't find list of remote files, oops\n");
824: return (NULL);
825: }
826: }
827: if (fgets(buf, sizeof (buf), ftemp) == NULL) {
828: (void) fclose(ftemp), ftemp = NULL;
829: return (NULL);
830: }
831: if ((cp = index(buf, '\n')) != NULL)
832: *cp = '\0';
833: return (buf);
834: }
835:
836: char *
837: onoff(bool)
838: int bool;
839: {
840:
841: return (bool ? "on" : "off");
842: }
843:
844: /*
845: * Show status.
846: */
847: /*ARGSUSED*/
848: status(argc, argv)
849: char *argv[];
850: {
851: int i;
852:
853: if (connected)
854: printf("Connected to %s.\n", hostname);
855: else
856: printf("Not connected.\n");
857: if (!proxy) {
858: pswitch(1);
859: if (connected) {
860: printf("Connected for proxy commands to %s.\n", hostname);
861: }
862: else {
863: printf("No proxy connection.\n");
864: }
865: pswitch(0);
866: }
867: printf("Mode: %s; Type: %s; Form: %s; Structure: %s\n",
868: modename, typename, formname, structname);
869: printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n",
870: onoff(verbose), onoff(bell), onoff(interactive),
871: onoff(doglob));
872: printf("Store unique: %s; Receive unique: %s\n", onoff(sunique),
873: onoff(runique));
874: printf("Case: %s; CR stripping: %s\n",onoff(mcase),onoff(crflag));
875: if (ntflag) {
876: printf("Ntrans: (in) %s (out) %s\n", ntin,ntout);
877: }
878: else {
879: printf("Ntrans: off\n");
880: }
881: if (mapflag) {
882: printf("Nmap: (in) %s (out) %s\n", mapin, mapout);
883: }
884: else {
885: printf("Nmap: off\n");
886: }
887: printf("Hash mark printing: %s; Use of PORT cmds: %s\n",
888: onoff(hash), onoff(sendport));
889: if (macnum > 0) {
890: printf("Macros:\n");
891: for (i=0; i<macnum; i++) {
892: printf("\t%s\n",macros[i].mac_name);
893: }
894: }
895: code = 0;
896: }
897:
898: /*
899: * Set beep on cmd completed mode.
900: */
901: /*VARARGS*/
902: setbell()
903: {
904:
905: bell = !bell;
906: printf("Bell mode %s.\n", onoff(bell));
907: code = bell;
908: }
909:
910: /*
911: * Turn on packet tracing.
912: */
913: /*VARARGS*/
914: settrace()
915: {
916:
917: trace = !trace;
918: printf("Packet tracing %s.\n", onoff(trace));
919: code = trace;
920: }
921:
922: /*
923: * Toggle hash mark printing during transfers.
924: */
925: /*VARARGS*/
926: sethash()
927: {
928:
929: hash = !hash;
930: printf("Hash mark printing %s", onoff(hash));
931: code = hash;
932: if (hash)
933: printf(" (%d bytes/hash mark)", 1024);
934: printf(".\n");
935: }
936:
937: /*
938: * Turn on printing of server echo's.
939: */
940: /*VARARGS*/
941: setverbose()
942: {
943:
944: verbose = !verbose;
945: printf("Verbose mode %s.\n", onoff(verbose));
946: code = verbose;
947: }
948:
949: /*
950: * Toggle PORT cmd use before each data connection.
951: */
952: /*VARARGS*/
953: setport()
954: {
955:
956: sendport = !sendport;
957: printf("Use of PORT cmds %s.\n", onoff(sendport));
958: code = sendport;
959: }
960:
961: /*
962: * Turn on interactive prompting
963: * during mget, mput, and mdelete.
964: */
965: /*VARARGS*/
966: setprompt()
967: {
968:
969: interactive = !interactive;
970: printf("Interactive mode %s.\n", onoff(interactive));
971: code = interactive;
972: }
973:
974: /*
975: * Toggle metacharacter interpretation
976: * on local file names.
977: */
978: /*VARARGS*/
979: setglob()
980: {
981:
982: doglob = !doglob;
983: printf("Globbing %s.\n", onoff(doglob));
984: code = doglob;
985: }
986:
987: /*
988: * Set debugging mode on/off and/or
989: * set level of debugging.
990: */
991: /*VARARGS*/
992: setdebug(argc, argv)
993: char *argv[];
994: {
995: int val;
996:
997: if (argc > 1) {
998: val = atoi(argv[1]);
999: if (val < 0) {
1000: printf("%s: bad debugging value.\n", argv[1]);
1001: code = -1;
1002: return;
1003: }
1004: } else
1005: val = !debug;
1006: debug = val;
1007: if (debug)
1008: options |= SO_DEBUG;
1009: else
1010: options &= ~SO_DEBUG;
1011: printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
1012: code = debug > 0;
1013: }
1014:
1015: /*
1016: * Set current working directory
1017: * on remote machine.
1018: */
1019: cd(argc, argv)
1020: char *argv[];
1021: {
1022:
1023: if (argc < 2) {
1024: (void) strcat(line, " ");
1025: printf("(remote-directory) ");
1026: (void) gets(&line[strlen(line)]);
1027: makeargv();
1028: argc = margc;
1029: argv = margv;
1030: }
1031: if (argc < 2) {
1032: printf("usage:%s remote-directory\n", argv[0]);
1033: code = -1;
1034: return;
1035: }
1036: if (command("CWD %s", argv[1]) == ERROR && code == 500) {
1037: if (verbose)
1038: printf("CWD command not recognized, trying XCWD\n");
1039: (void) command("XCWD %s", argv[1]);
1040: }
1041: }
1042:
1043: /*
1044: * Set current working directory
1045: * on local machine.
1046: */
1047: lcd(argc, argv)
1048: char *argv[];
1049: {
1050: char buf[MAXPATHLEN];
1051: extern char *getwd();
1052:
1053: if (argc < 2)
1054: argc++, argv[1] = home;
1055: if (argc != 2) {
1056: printf("usage:%s local-directory\n", argv[0]);
1057: code = -1;
1058: return;
1059: }
1060: if (!globulize(&argv[1])) {
1061: code = -1;
1062: return;
1063: }
1064: if (chdir(argv[1]) < 0) {
1065: fprintf(stderr, "local: %s: %s\n", argv[1], strerror(errno));
1066: code = -1;
1067: return;
1068: }
1069: printf("Local directory now %s\n", getwd(buf));
1070: code = 0;
1071: }
1072:
1073: /*
1074: * Delete a single file.
1075: */
1076: delete(argc, argv)
1077: char *argv[];
1078: {
1079:
1080: if (argc < 2) {
1081: (void) strcat(line, " ");
1082: printf("(remote-file) ");
1083: (void) gets(&line[strlen(line)]);
1084: makeargv();
1085: argc = margc;
1086: argv = margv;
1087: }
1088: if (argc < 2) {
1089: printf("usage:%s remote-file\n", argv[0]);
1090: code = -1;
1091: return;
1092: }
1093: (void) command("DELE %s", argv[1]);
1094: }
1095:
1096: /*
1097: * Delete multiple files.
1098: */
1099: mdelete(argc, argv)
1100: int argc;
1101: char **argv;
1102: {
1103: extern jmp_buf jabort;
1104: sig_t oldintr;
1105: int ointer;
1106: char *cp;
1107: void mabort();
1108:
1109: if (argc < 2) {
1110: (void) strcat(line, " ");
1111: printf("(remote-files) ");
1112: (void) gets(&line[strlen(line)]);
1113: makeargv();
1114: argc = margc;
1115: argv = margv;
1116: }
1117: if (argc < 2) {
1118: printf("usage:%s remote-files\n", argv[0]);
1119: code = -1;
1120: return;
1121: }
1122: mname = argv[0];
1123: mflag = 1;
1124: oldintr = signal(SIGINT, mabort);
1125: (void) setjmp(jabort);
1126: while ((cp = remglob(argv,0)) != NULL) {
1127: if (*cp == '\0') {
1128: mflag = 0;
1129: continue;
1130: }
1131: if (mflag && confirm(argv[0], cp)) {
1132: (void) command("DELE %s", cp);
1133: if (!mflag && fromatty) {
1134: ointer = interactive;
1135: interactive = 1;
1136: if (confirm("Continue with", "mdelete")) {
1137: mflag++;
1138: }
1139: interactive = ointer;
1140: }
1141: }
1142: }
1143: (void) signal(SIGINT, oldintr);
1144: mflag = 0;
1145: }
1146:
1147: /*
1148: * Rename a remote file.
1149: */
1150: renamefile(argc, argv)
1151: char *argv[];
1152: {
1153:
1154: if (argc < 2) {
1155: (void) strcat(line, " ");
1156: printf("(from-name) ");
1157: (void) gets(&line[strlen(line)]);
1158: makeargv();
1159: argc = margc;
1160: argv = margv;
1161: }
1162: if (argc < 2) {
1163: usage:
1164: printf("%s from-name to-name\n", argv[0]);
1165: code = -1;
1166: return;
1167: }
1168: if (argc < 3) {
1169: (void) strcat(line, " ");
1170: printf("(to-name) ");
1171: (void) gets(&line[strlen(line)]);
1172: makeargv();
1173: argc = margc;
1174: argv = margv;
1175: }
1176: if (argc < 3)
1177: goto usage;
1178: if (command("RNFR %s", argv[1]) == CONTINUE)
1179: (void) command("RNTO %s", argv[2]);
1180: }
1181:
1182: /*
1183: * Get a directory listing
1184: * of remote files.
1185: */
1186: ls(argc, argv)
1187: char *argv[];
1188: {
1189: char *cmd;
1190:
1191: if (argc < 2)
1192: argc++, argv[1] = NULL;
1193: if (argc < 3)
1194: argc++, argv[2] = "-";
1195: if (argc > 3) {
1196: printf("usage: %s remote-directory local-file\n", argv[0]);
1197: code = -1;
1198: return;
1199: }
1200: cmd = argv[0][0] == 'n' ? "NLST" : "LIST";
1201: if (strcmp(argv[2], "-") && !globulize(&argv[2])) {
1202: code = -1;
1203: return;
1204: }
1205: if (strcmp(argv[2], "-") && *argv[2] != '|')
1206: if (!globulize(&argv[2]) || !confirm("output to local-file:", argv[2])) {
1207: code = -1;
1208: return;
1209: }
1210: recvrequest(cmd, argv[2], argv[1], "w", 0);
1211: }
1212:
1213: /*
1214: * Get a directory listing
1215: * of multiple remote files.
1216: */
1217: mls(argc, argv)
1218: int argc;
1219: char **argv;
1220: {
1221: extern jmp_buf jabort;
1222: sig_t oldintr;
1223: int ointer, i;
1224: char *cmd, mode[1], *dest;
1225: void mabort();
1226:
1227: if (argc < 2) {
1228: (void) strcat(line, " ");
1229: printf("(remote-files) ");
1230: (void) gets(&line[strlen(line)]);
1231: makeargv();
1232: argc = margc;
1233: argv = margv;
1234: }
1235: if (argc < 3) {
1236: (void) strcat(line, " ");
1237: printf("(local-file) ");
1238: (void) gets(&line[strlen(line)]);
1239: makeargv();
1240: argc = margc;
1241: argv = margv;
1242: }
1243: if (argc < 3) {
1244: printf("usage:%s remote-files local-file\n", argv[0]);
1245: code = -1;
1246: return;
1247: }
1248: dest = argv[argc - 1];
1249: argv[argc - 1] = NULL;
1250: if (strcmp(dest, "-") && *dest != '|')
1251: if (!globulize(&dest) || !confirm("output to local-file:", dest)) {
1252: code = -1;
1253: return;
1254: }
1255: cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
1256: mname = argv[0];
1257: mflag = 1;
1258: oldintr = signal(SIGINT, mabort);
1259: (void) setjmp(jabort);
1260: for (i = 1; mflag && i < argc-1; ++i) {
1261: *mode = (i == 1) ? 'w' : 'a';
1262: recvrequest(cmd, dest, argv[i], mode, 0);
1263: if (!mflag && fromatty) {
1264: ointer = interactive;
1265: interactive = 1;
1266: if (confirm("Continue with", argv[0])) {
1267: mflag ++;
1268: }
1269: interactive = ointer;
1270: }
1271: }
1272: (void) signal(SIGINT, oldintr);
1273: mflag = 0;
1274: }
1275:
1276: /*
1277: * Do a shell escape
1278: */
1279: /*ARGSUSED*/
1280: shell(argc, argv)
1281: int argc;
1282: char **argv;
1283: {
1284: int pid;
1285: sig_t old1, old2;
1286: char shellnam[40], *shell, *namep;
1287: union wait status;
1288:
1289: old1 = signal (SIGINT, SIG_IGN);
1290: old2 = signal (SIGQUIT, SIG_IGN);
1291: if ((pid = fork()) == 0) {
1292: for (pid = 3; pid < 20; pid++)
1293: (void) close(pid);
1294: (void) signal(SIGINT, SIG_DFL);
1295: (void) signal(SIGQUIT, SIG_DFL);
1296: shell = getenv("SHELL");
1297: if (shell == NULL)
1298: shell = _PATH_BSHELL;
1299: namep = rindex(shell,'/');
1300: if (namep == NULL)
1301: namep = shell;
1302: (void) strcpy(shellnam,"-");
1303: (void) strcat(shellnam, ++namep);
1304: if (strcmp(namep, "sh") != 0)
1305: shellnam[0] = '+';
1306: if (debug) {
1307: printf ("%s\n", shell);
1308: (void) fflush (stdout);
1309: }
1310: if (argc > 1) {
1311: execl(shell,shellnam,"-c",altarg,(char *)0);
1312: }
1313: else {
1314: execl(shell,shellnam,(char *)0);
1315: }
1316: perror(shell);
1317: code = -1;
1318: exit(1);
1319: }
1320: if (pid > 0)
1321: while (wait(&status) != pid)
1322: ;
1323: (void) signal(SIGINT, old1);
1324: (void) signal(SIGQUIT, old2);
1325: if (pid == -1) {
1326: perror("Try again later");
1327: code = -1;
1328: }
1329: else {
1330: code = 0;
1331: }
1332: return (0);
1333: }
1334:
1335: /*
1336: * Send new user information (re-login)
1337: */
1338: user(argc, argv)
1339: int argc;
1340: char **argv;
1341: {
1342: char acct[80], *getpass();
1343: int n, aflag = 0;
1344:
1345: if (argc < 2) {
1346: (void) strcat(line, " ");
1347: printf("(username) ");
1348: (void) gets(&line[strlen(line)]);
1349: makeargv();
1350: argc = margc;
1351: argv = margv;
1352: }
1353: if (argc > 4) {
1354: printf("usage: %s username [password] [account]\n", argv[0]);
1355: code = -1;
1356: return (0);
1357: }
1358: n = command("USER %s", argv[1]);
1359: if (n == CONTINUE) {
1360: if (argc < 3 )
1361: argv[2] = getpass("Password: "), argc++;
1362: n = command("PASS %s", argv[2]);
1363: }
1364: if (n == CONTINUE) {
1365: if (argc < 4) {
1366: printf("Account: "); (void) fflush(stdout);
1367: (void) fgets(acct, sizeof(acct) - 1, stdin);
1368: acct[strlen(acct) - 1] = '\0';
1369: argv[3] = acct; argc++;
1370: }
1371: n = command("ACCT %s", argv[3]);
1372: aflag++;
1373: }
1374: if (n != COMPLETE) {
1375: fprintf(stdout, "Login failed.\n");
1376: return (0);
1377: }
1378: if (!aflag && argc == 4) {
1379: (void) command("ACCT %s", argv[3]);
1380: }
1381: return (1);
1382: }
1383:
1384: /*
1385: * Print working directory.
1386: */
1387: /*VARARGS*/
1388: pwd()
1389: {
1390: int oldverbose = verbose;
1391:
1392: /*
1393: * If we aren't verbose, this doesn't do anything!
1394: */
1395: verbose = 1;
1396: if (command("PWD") == ERROR && code == 500) {
1397: printf("PWD command not recognized, trying XPWD\n");
1398: (void) command("XPWD");
1399: }
1400: verbose = oldverbose;
1401: }
1402:
1403: /*
1404: * Make a directory.
1405: */
1406: makedir(argc, argv)
1407: char *argv[];
1408: {
1409:
1410: if (argc < 2) {
1411: (void) strcat(line, " ");
1412: printf("(directory-name) ");
1413: (void) gets(&line[strlen(line)]);
1414: makeargv();
1415: argc = margc;
1416: argv = margv;
1417: }
1418: if (argc < 2) {
1419: printf("usage: %s directory-name\n", argv[0]);
1420: code = -1;
1421: return;
1422: }
1423: if (command("MKD %s", argv[1]) == ERROR && code == 500) {
1424: if (verbose)
1425: printf("MKD command not recognized, trying XMKD\n");
1426: (void) command("XMKD %s", argv[1]);
1427: }
1428: }
1429:
1430: /*
1431: * Remove a directory.
1432: */
1433: removedir(argc, argv)
1434: char *argv[];
1435: {
1436:
1437: if (argc < 2) {
1438: (void) strcat(line, " ");
1439: printf("(directory-name) ");
1440: (void) gets(&line[strlen(line)]);
1441: makeargv();
1442: argc = margc;
1443: argv = margv;
1444: }
1445: if (argc < 2) {
1446: printf("usage: %s directory-name\n", argv[0]);
1447: code = -1;
1448: return;
1449: }
1450: if (command("RMD %s", argv[1]) == ERROR && code == 500) {
1451: if (verbose)
1452: printf("RMD command not recognized, trying XRMD\n");
1453: (void) command("XRMD %s", argv[1]);
1454: }
1455: }
1456:
1457: /*
1458: * Send a line, verbatim, to the remote machine.
1459: */
1460: quote(argc, argv)
1461: char *argv[];
1462: {
1463: int i;
1464: char buf[BUFSIZ];
1465:
1466: if (argc < 2) {
1467: (void) strcat(line, " ");
1468: printf("(command line to send) ");
1469: (void) gets(&line[strlen(line)]);
1470: makeargv();
1471: argc = margc;
1472: argv = margv;
1473: }
1474: if (argc < 2) {
1475: printf("usage: %s line-to-send\n", argv[0]);
1476: code = -1;
1477: return;
1478: }
1479: (void) strcpy(buf, argv[1]);
1480: for (i = 2; i < argc; i++) {
1481: (void) strcat(buf, " ");
1482: (void) strcat(buf, argv[i]);
1483: }
1484: if (command(buf) == PRELIM) {
1485: while (getreply(0) == PRELIM);
1486: }
1487: }
1488:
1489: /*
1490: * Send a SITE command to the remote machine. The line
1491: * is sent almost verbatim to the remote machine, the
1492: * first argument is changed to SITE.
1493: */
1494:
1495: site(argc, argv)
1496: char *argv[];
1497: {
1498: int i;
1499: char buf[BUFSIZ];
1500:
1501: if (argc < 2) {
1502: (void) strcat(line, " ");
1503: printf("(arguments to SITE command) ");
1504: (void) gets(&line[strlen(line)]);
1505: makeargv();
1506: argc = margc;
1507: argv = margv;
1508: }
1509: if (argc < 2) {
1510: printf("usage: %s line-to-send\n", argv[0]);
1511: code = -1;
1512: return;
1513: }
1514: (void) strcpy(buf, "SITE ");
1515: (void) strcat(buf, argv[1]);
1516: for (i = 2; i < argc; i++) {
1517: (void) strcat(buf, " ");
1518: (void) strcat(buf, argv[i]);
1519: }
1520: if (command(buf) == PRELIM) {
1521: while (getreply(0) == PRELIM);
1522: }
1523: }
1524:
1525: do_chmod(argc, argv)
1526: char *argv[];
1527: {
1528: if (argc == 2) {
1529: printf("usage: %s mode file-name\n", argv[0]);
1530: code = -1;
1531: return;
1532: }
1533: if (argc < 3) {
1534: (void) strcat(line, " ");
1535: printf("(mode and file-name) ");
1536: (void) gets(&line[strlen(line)]);
1537: makeargv();
1538: argc = margc;
1539: argv = margv;
1540: }
1541: if (argc != 3) {
1542: printf("usage: %s mode file-name\n", argv[0]);
1543: code = -1;
1544: return;
1545: }
1546: (void)command("SITE CHMOD %s %s", argv[1], argv[2]);
1547: }
1548:
1549: do_umask(argc, argv)
1550: char *argv[];
1551: {
1552: int oldverbose = verbose;
1553:
1554: verbose = 1;
1555: (void) command(argc == 1 ? "SITE UMASK" : "SITE UMASK %s", argv[1]);
1556: verbose = oldverbose;
1557: }
1558:
1559: idle(argc, argv)
1560: char *argv[];
1561: {
1562: int oldverbose = verbose;
1563:
1564: verbose = 1;
1565: (void) command(argc == 1 ? "SITE IDLE" : "SITE IDLE %s", argv[1]);
1566: verbose = oldverbose;
1567: }
1568:
1569: /*
1570: * Ask the other side for help.
1571: */
1572: rmthelp(argc, argv)
1573: char *argv[];
1574: {
1575: int oldverbose = verbose;
1576:
1577: verbose = 1;
1578: (void) command(argc == 1 ? "HELP" : "HELP %s", argv[1]);
1579: verbose = oldverbose;
1580: }
1581:
1582: /*
1583: * Terminate session and exit.
1584: */
1585: /*VARARGS*/
1586: quit()
1587: {
1588:
1589: if (connected)
1590: disconnect();
1591: pswitch(1);
1592: if (connected) {
1593: disconnect();
1594: }
1595: exit(0);
1596: }
1597:
1598: /*
1599: * Terminate session, but don't exit.
1600: */
1601: disconnect()
1602: {
1603: extern FILE *cout;
1604: extern int data;
1605:
1606: if (!connected)
1607: return;
1608: (void) command("QUIT");
1609: if (cout) {
1610: (void) fclose(cout);
1611: }
1612: cout = NULL;
1613: connected = 0;
1614: data = -1;
1615: if (!proxy) {
1616: macnum = 0;
1617: }
1618: }
1619:
1620: confirm(cmd, file)
1621: char *cmd, *file;
1622: {
1623: char line[BUFSIZ];
1624:
1625: if (!interactive)
1626: return (1);
1627: printf("%s %s? ", cmd, file);
1628: (void) fflush(stdout);
1629: (void) gets(line);
1630: return (*line != 'n' && *line != 'N');
1631: }
1632:
1633: fatal(msg)
1634: char *msg;
1635: {
1636:
1637: fprintf(stderr, "ftp: %s\n", msg);
1638: exit(1);
1639: }
1640:
1641: /*
1642: * Glob a local file name specification with
1643: * the expectation of a single return value.
1644: * Can't control multiple values being expanded
1645: * from the expression, we return only the first.
1646: */
1647: globulize(cpp)
1648: char **cpp;
1649: {
1650: char **globbed;
1651:
1652: if (!doglob)
1653: return (1);
1654: globbed = glob(*cpp);
1655: if (globerr != NULL) {
1656: printf("%s: %s\n", *cpp, globerr);
1657: if (globbed) {
1658: blkfree(globbed);
1659: free((char *)globbed);
1660: }
1661: return (0);
1662: }
1663: if (globbed) {
1664: *cpp = *globbed++;
1665: /* don't waste too much memory */
1666: if (*globbed) {
1667: blkfree(globbed);
1668: free((char *)globbed);
1669: }
1670: }
1671: return (1);
1672: }
1673:
1674: account(argc,argv)
1675: int argc;
1676: char **argv;
1677: {
1678: char acct[50], *getpass(), *ap;
1679:
1680: if (argc > 1) {
1681: ++argv;
1682: --argc;
1683: (void) strncpy(acct,*argv,49);
1684: acct[49] = '\0';
1685: while (argc > 1) {
1686: --argc;
1687: ++argv;
1688: (void) strncat(acct,*argv, 49-strlen(acct));
1689: }
1690: ap = acct;
1691: }
1692: else {
1693: ap = getpass("Account:");
1694: }
1695: (void) command("ACCT %s", ap);
1696: }
1697:
1698: jmp_buf abortprox;
1699:
1700: void
1701: proxabort()
1702: {
1703: extern int proxy;
1704:
1705: if (!proxy) {
1706: pswitch(1);
1707: }
1708: if (connected) {
1709: proxflag = 1;
1710: }
1711: else {
1712: proxflag = 0;
1713: }
1714: pswitch(0);
1715: longjmp(abortprox,1);
1716: }
1717:
1718: doproxy(argc,argv)
1719: int argc;
1720: char *argv[];
1721: {
1722: extern struct cmd cmdtab[];
1723: extern jmp_buf abortprox;
1724: register struct cmd *c;
1725: struct cmd *getcmd();
1726: sig_t oldintr;
1727: void proxabort();
1728:
1729: if (argc < 2) {
1730: (void) strcat(line, " ");
1731: printf("(command) ");
1732: (void) gets(&line[strlen(line)]);
1733: makeargv();
1734: argc = margc;
1735: argv = margv;
1736: }
1737: if (argc < 2) {
1738: printf("usage:%s command\n", argv[0]);
1739: code = -1;
1740: return;
1741: }
1742: c = getcmd(argv[1]);
1743: if (c == (struct cmd *) -1) {
1744: printf("?Ambiguous command\n");
1745: (void) fflush(stdout);
1746: code = -1;
1747: return;
1748: }
1749: if (c == 0) {
1750: printf("?Invalid command\n");
1751: (void) fflush(stdout);
1752: code = -1;
1753: return;
1754: }
1755: if (!c->c_proxy) {
1756: printf("?Invalid proxy command\n");
1757: (void) fflush(stdout);
1758: code = -1;
1759: return;
1760: }
1761: if (setjmp(abortprox)) {
1762: code = -1;
1763: return;
1764: }
1765: oldintr = signal(SIGINT, proxabort);
1766: pswitch(1);
1767: if (c->c_conn && !connected) {
1768: printf("Not connected\n");
1769: (void) fflush(stdout);
1770: pswitch(0);
1771: (void) signal(SIGINT, oldintr);
1772: code = -1;
1773: return;
1774: }
1775: (*c->c_handler)(argc-1, argv+1);
1776: if (connected) {
1777: proxflag = 1;
1778: }
1779: else {
1780: proxflag = 0;
1781: }
1782: pswitch(0);
1783: (void) signal(SIGINT, oldintr);
1784: }
1785:
1786: setcase()
1787: {
1788: mcase = !mcase;
1789: printf("Case mapping %s.\n", onoff(mcase));
1790: code = mcase;
1791: }
1792:
1793: setcr()
1794: {
1795: crflag = !crflag;
1796: printf("Carriage Return stripping %s.\n", onoff(crflag));
1797: code = crflag;
1798: }
1799:
1800: setntrans(argc,argv)
1801: int argc;
1802: char *argv[];
1803: {
1804: if (argc == 1) {
1805: ntflag = 0;
1806: printf("Ntrans off.\n");
1807: code = ntflag;
1808: return;
1809: }
1810: ntflag++;
1811: code = ntflag;
1812: (void) strncpy(ntin, argv[1], 16);
1813: ntin[16] = '\0';
1814: if (argc == 2) {
1815: ntout[0] = '\0';
1816: return;
1817: }
1818: (void) strncpy(ntout, argv[2], 16);
1819: ntout[16] = '\0';
1820: }
1821:
1822: char *
1823: dotrans(name)
1824: char *name;
1825: {
1826: static char new[MAXPATHLEN];
1827: char *cp1, *cp2 = new;
1828: register int i, ostop, found;
1829:
1830: for (ostop = 0; *(ntout + ostop) && ostop < 16; ostop++);
1831: for (cp1 = name; *cp1; cp1++) {
1832: found = 0;
1833: for (i = 0; *(ntin + i) && i < 16; i++) {
1834: if (*cp1 == *(ntin + i)) {
1835: found++;
1836: if (i < ostop) {
1837: *cp2++ = *(ntout + i);
1838: }
1839: break;
1840: }
1841: }
1842: if (!found) {
1843: *cp2++ = *cp1;
1844: }
1845: }
1846: *cp2 = '\0';
1847: return(new);
1848: }
1849:
1850: setnmap(argc, argv)
1851: int argc;
1852: char *argv[];
1853: {
1854: char *cp;
1855:
1856: if (argc == 1) {
1857: mapflag = 0;
1858: printf("Nmap off.\n");
1859: code = mapflag;
1860: return;
1861: }
1862: if (argc < 3) {
1863: (void) strcat(line, " ");
1864: printf("(mapout) ");
1865: (void) gets(&line[strlen(line)]);
1866: makeargv();
1867: argc = margc;
1868: argv = margv;
1869: }
1870: if (argc < 3) {
1871: printf("Usage: %s [mapin mapout]\n",argv[0]);
1872: code = -1;
1873: return;
1874: }
1875: mapflag = 1;
1876: code = 1;
1877: cp = index(altarg, ' ');
1878: if (proxy) {
1879: while(*++cp == ' ');
1880: altarg = cp;
1881: cp = index(altarg, ' ');
1882: }
1883: *cp = '\0';
1884: (void) strncpy(mapin, altarg, MAXPATHLEN - 1);
1885: while (*++cp == ' ');
1886: (void) strncpy(mapout, cp, MAXPATHLEN - 1);
1887: }
1888:
1889: char *
1890: domap(name)
1891: char *name;
1892: {
1893: static char new[MAXPATHLEN];
1894: register char *cp1 = name, *cp2 = mapin;
1895: char *tp[9], *te[9];
1896: int i, toks[9], toknum = 0, match = 1;
1897:
1898: for (i=0; i < 9; ++i) {
1899: toks[i] = 0;
1900: }
1901: while (match && *cp1 && *cp2) {
1902: switch (*cp2) {
1903: case '\\':
1904: if (*++cp2 != *cp1) {
1905: match = 0;
1906: }
1907: break;
1908: case '$':
1909: if (*(cp2+1) >= '1' && (*cp2+1) <= '9') {
1910: if (*cp1 != *(++cp2+1)) {
1911: toks[toknum = *cp2 - '1']++;
1912: tp[toknum] = cp1;
1913: while (*++cp1 && *(cp2+1)
1914: != *cp1);
1915: te[toknum] = cp1;
1916: }
1917: cp2++;
1918: break;
1919: }
1920: /* FALLTHROUGH */
1921: default:
1922: if (*cp2 != *cp1) {
1923: match = 0;
1924: }
1925: break;
1926: }
1927: if (match && *cp1) {
1928: cp1++;
1929: }
1930: if (match && *cp2) {
1931: cp2++;
1932: }
1933: }
1934: if (!match && *cp1) /* last token mismatch */
1935: {
1936: toks[toknum] = 0;
1937: }
1938: cp1 = new;
1939: *cp1 = '\0';
1940: cp2 = mapout;
1941: while (*cp2) {
1942: match = 0;
1943: switch (*cp2) {
1944: case '\\':
1945: if (*(cp2 + 1)) {
1946: *cp1++ = *++cp2;
1947: }
1948: break;
1949: case '[':
1950: LOOP:
1951: if (*++cp2 == '$' && isdigit(*(cp2+1))) {
1952: if (*++cp2 == '0') {
1953: char *cp3 = name;
1954:
1955: while (*cp3) {
1956: *cp1++ = *cp3++;
1957: }
1958: match = 1;
1959: }
1960: else if (toks[toknum = *cp2 - '1']) {
1961: char *cp3 = tp[toknum];
1962:
1963: while (cp3 != te[toknum]) {
1964: *cp1++ = *cp3++;
1965: }
1966: match = 1;
1967: }
1968: }
1969: else {
1970: while (*cp2 && *cp2 != ',' &&
1971: *cp2 != ']') {
1972: if (*cp2 == '\\') {
1973: cp2++;
1974: }
1975: else if (*cp2 == '$' &&
1976: isdigit(*(cp2+1))) {
1977: if (*++cp2 == '0') {
1978: char *cp3 = name;
1979:
1980: while (*cp3) {
1981: *cp1++ = *cp3++;
1982: }
1983: }
1984: else if (toks[toknum =
1985: *cp2 - '1']) {
1986: char *cp3=tp[toknum];
1987:
1988: while (cp3 !=
1989: te[toknum]) {
1990: *cp1++ = *cp3++;
1991: }
1992: }
1993: }
1994: else if (*cp2) {
1995: *cp1++ = *cp2++;
1996: }
1997: }
1998: if (!*cp2) {
1999: printf("nmap: unbalanced brackets\n");
2000: return(name);
2001: }
2002: match = 1;
2003: cp2--;
2004: }
2005: if (match) {
2006: while (*++cp2 && *cp2 != ']') {
2007: if (*cp2 == '\\' && *(cp2 + 1)) {
2008: cp2++;
2009: }
2010: }
2011: if (!*cp2) {
2012: printf("nmap: unbalanced brackets\n");
2013: return(name);
2014: }
2015: break;
2016: }
2017: switch (*++cp2) {
2018: case ',':
2019: goto LOOP;
2020: case ']':
2021: break;
2022: default:
2023: cp2--;
2024: goto LOOP;
2025: }
2026: break;
2027: case '$':
2028: if (isdigit(*(cp2 + 1))) {
2029: if (*++cp2 == '0') {
2030: char *cp3 = name;
2031:
2032: while (*cp3) {
2033: *cp1++ = *cp3++;
2034: }
2035: }
2036: else if (toks[toknum = *cp2 - '1']) {
2037: char *cp3 = tp[toknum];
2038:
2039: while (cp3 != te[toknum]) {
2040: *cp1++ = *cp3++;
2041: }
2042: }
2043: break;
2044: }
2045: /* intentional drop through */
2046: default:
2047: *cp1++ = *cp2;
2048: break;
2049: }
2050: cp2++;
2051: }
2052: *cp1 = '\0';
2053: if (!*new) {
2054: return(name);
2055: }
2056: return(new);
2057: }
2058:
2059: setsunique()
2060: {
2061: sunique = !sunique;
2062: printf("Store unique %s.\n", onoff(sunique));
2063: code = sunique;
2064: }
2065:
2066: setrunique()
2067: {
2068: runique = !runique;
2069: printf("Receive unique %s.\n", onoff(runique));
2070: code = runique;
2071: }
2072:
2073: /* change directory to perent directory */
2074: cdup()
2075: {
2076: if (command("CDUP") == ERROR && code == 500) {
2077: if (verbose)
2078: printf("CDUP command not recognized, trying XCUP\n");
2079: (void) command("XCUP");
2080: }
2081: }
2082:
2083: /* restart transfer at specific point */
2084: restart(argc, argv)
2085: int argc;
2086: char *argv[];
2087: {
2088: extern long atol();
2089: if (argc != 2)
2090: printf("restart: offset not specified\n");
2091: else {
2092: restart_point = atol(argv[1]);
2093: printf("restarting at %ld. %s\n", restart_point,
2094: "execute get, put or append to initiate transfer");
2095: }
2096: }
2097:
2098: /* show remote system type */
2099: syst()
2100: {
2101: (void) command("SYST");
2102: }
2103:
2104: macdef(argc, argv)
2105: int argc;
2106: char *argv[];
2107: {
2108: char *tmp;
2109: int c;
2110:
2111: if (macnum == 16) {
2112: printf("Limit of 16 macros have already been defined\n");
2113: code = -1;
2114: return;
2115: }
2116: if (argc < 2) {
2117: (void) strcat(line, " ");
2118: printf("(macro name) ");
2119: (void) gets(&line[strlen(line)]);
2120: makeargv();
2121: argc = margc;
2122: argv = margv;
2123: }
2124: if (argc != 2) {
2125: printf("Usage: %s macro_name\n",argv[0]);
2126: code = -1;
2127: return;
2128: }
2129: if (interactive) {
2130: printf("Enter macro line by line, terminating it with a null line\n");
2131: }
2132: (void) strncpy(macros[macnum].mac_name, argv[1], 8);
2133: if (macnum == 0) {
2134: macros[macnum].mac_start = macbuf;
2135: }
2136: else {
2137: macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
2138: }
2139: tmp = macros[macnum].mac_start;
2140: while (tmp != macbuf+4096) {
2141: if ((c = getchar()) == EOF) {
2142: printf("macdef:end of file encountered\n");
2143: code = -1;
2144: return;
2145: }
2146: if ((*tmp = c) == '\n') {
2147: if (tmp == macros[macnum].mac_start) {
2148: macros[macnum++].mac_end = tmp;
2149: code = 0;
2150: return;
2151: }
2152: if (*(tmp-1) == '\0') {
2153: macros[macnum++].mac_end = tmp - 1;
2154: code = 0;
2155: return;
2156: }
2157: *tmp = '\0';
2158: }
2159: tmp++;
2160: }
2161: while (1) {
2162: while ((c = getchar()) != '\n' && c != EOF)
2163: /* LOOP */;
2164: if (c == EOF || getchar() == '\n') {
2165: printf("Macro not defined - 4k buffer exceeded\n");
2166: code = -1;
2167: return;
2168: }
2169: }
2170: }
2171:
2172: /*
2173: * get size of file on remote machine
2174: */
2175: sizecmd(argc, argv)
2176: char *argv[];
2177: {
2178:
2179: if (argc < 2) {
2180: (void) strcat(line, " ");
2181: printf("(filename) ");
2182: (void) gets(&line[strlen(line)]);
2183: makeargv();
2184: argc = margc;
2185: argv = margv;
2186: }
2187: if (argc < 2) {
2188: printf("usage:%s filename\n", argv[0]);
2189: code = -1;
2190: return;
2191: }
2192: (void) command("SIZE %s", argv[1]);
2193: }
2194:
2195: /*
2196: * get last modification time of file on remote machine
2197: */
2198: modtime(argc, argv)
2199: char *argv[];
2200: {
2201: int overbose;
2202:
2203: if (argc < 2) {
2204: (void) strcat(line, " ");
2205: printf("(filename) ");
2206: (void) gets(&line[strlen(line)]);
2207: makeargv();
2208: argc = margc;
2209: argv = margv;
2210: }
2211: if (argc < 2) {
2212: printf("usage:%s filename\n", argv[0]);
2213: code = -1;
2214: return;
2215: }
2216: overbose = verbose;
2217: if (debug == 0)
2218: verbose = -1;
2219: if (command("MDTM %s", argv[1]) == COMPLETE) {
2220: int yy, mo, day, hour, min, sec;
2221: sscanf(reply_string, "%*s %04d%02d%02d%02d%02d%02d", &yy, &mo,
2222: &day, &hour, &min, &sec);
2223: /* might want to print this in local time */
2224: printf("%s\t%02d/%02d/%04d %02d:%02d:%02d GMT\n", argv[1],
2225: mo, day, yy, hour, min, sec);
2226: } else
2227: printf("%s\n", reply_string);
2228: verbose = overbose;
2229: }
2230:
2231: /*
2232: * show status on reomte machine
2233: */
2234: rmtstatus(argc, argv)
2235: char *argv[];
2236: {
2237: (void) command(argc > 1 ? "STAT %s" : "STAT" , argv[1]);
2238: }
2239:
2240: /*
2241: * get file if modtime is more recent than current file
2242: */
2243: newer(argc, argv)
2244: char *argv[];
2245: {
2246: if (getit(argc, argv, -1, "w"))
2247: printf("Local file \"%s\" is newer than remote file \"%s\"\n",
2248: argv[1], argv[2]);
2249: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.