![[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 [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb / ftp|
Return to cmds.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / ucb / ftp |
1.1 root 1: #ifdef lint
2: static char sccsid[] = "@(#)cmds.c 4.9 (Berkeley) 7/26/83";
3: #endif
4:
5: /*
6: * FTP User Program -- Command Routines.
7: */
8: /*
9: * Changes
10: * . fix shell() so that arguments of shell commands are passed to
11: * to the commands.
12: *
13: * . fix mget() so that files are copied to current local directory
14: * (instead of using the remote file name as destination file).
15: *
16: * . fix shell() so that to give commands to shell (instead of
17: * running the commands directly) for expanding of metacharacters.
18: *
19: * . fix mls() so that it aborts the command if globulize() returns
20: * w/ error and reverse the logics of confirm(), i.e. if user answers
21: * 'y' the command is carried out. Otherwise, it is ignored.
22: *
23: * . fix remglob(), so that it can distinguish the first time it is
24: * called within a calling routine and the subsequent calls, by
25: * introducing firstime flag. The old logic doesn't work if the calling
26: * routine - mdelete(), mget(), mls() - is interrupted.
27: *
28: */
29: #include <sys/param.h>
30: #include <sys/stat.h>
31: #include <sys/socket.h>
32:
33: #include <arpa/ftp.h>
34:
35: #include <signal.h>
36: #include <stdio.h>
37: #include <errno.h>
38: #include <netdb.h>
39:
40: #include "ftp_var.h"
41:
42: extern char *globerr;
43: extern char **glob();
44: extern char *home;
45: extern short gflag;
46: extern char *remglob();
47: extern char *getenv();
48: extern char *index();
49: extern char *rindex();
50: extern char *malloc();
51:
52: /*
53: * Connect to peer server and
54: * auto-login, if possible.
55: */
56:
57: setpeer(argc, argv)
58: int argc;
59: char *argv[];
60: {
61: struct hostent *host, *hookup();
62: int port;
63:
64: if (connected) {
65: printf("Already connected to %s, use close first.\n",
66: hostname);
67: return;
68: }
69: if (argc < 2) {
70: strcat(line, " ");
71: printf("(to) ");
72: gets(&line[strlen(line)]);
73: makeargv();
74: argc = margc;
75: argv = margv;
76: }
77: if (argc > 3) {
78: printf("usage: %s host-name [port]\n", argv[0]);
79: return;
80: }
81: port = sp->s_port;
82: if (argc > 2) {
83: port = atoi(argv[2]);
84: if (port <= 0) {
85: printf("%s: bad port number-- %s\n", argv[1], argv[2]);
86: printf ("usage: %s host-name [port]\n", argv[0]);
87: return;
88: }
89: port = htons(port);
90: }
91: host = hookup(argv[1], port);
92: if (host) {
93: connected = 1;
94: if (autologin)
95: login(host);
96: }
97: }
98:
99: struct types {
100: char *t_name;
101: char *t_mode;
102: int t_type;
103: char *t_arg;
104: } types[] = {
105: { "ascii", "A", TYPE_A, 0 },
106: { "binary", "I", TYPE_I, 0 },
107: { "image", "I", TYPE_I, 0 },
108: { "ebcdic", "E", TYPE_E, 0 },
109: { "tenex", "L", TYPE_L, bytename },
110: 0
111: };
112:
113: /*
114: * Set transfer type.
115: */
116: settype(argc, argv)
117: char *argv[];
118: {
119: register struct types *p;
120: int comret;
121:
122: if (argc > 2) {
123: char *sep;
124:
125: printf("usage: %s [", argv[0]);
126: sep = " ";
127: for (p = types; p->t_name; p++) {
128: printf("%s%s", sep, p->t_name);
129: if (*sep == ' ')
130: sep = " | ";
131: }
132: printf(" ]\n");
133: return;
134: }
135: if (argc < 2) {
136: printf("Using %s mode to transfer files.\n", typename);
137: return;
138: }
139: for (p = types; p->t_name; p++)
140: if (strcmp(argv[1], p->t_name) == 0)
141: break;
142: if (p->t_name == 0) {
143: printf("%s: unknown mode\n", argv[1]);
144: return;
145: }
146: if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
147: comret = command ("TYPE %s %s", p->t_mode, p->t_arg);
148: else
149: comret = command("TYPE %s", p->t_mode);
150: if (comret == COMPLETE) {
151: strcpy(typename, p->t_name);
152: type = p->t_type;
153: }
154: }
155:
156: /*
157: * Set binary transfer type.
158: */
159: /*VARARGS*/
160: setbinary()
161: {
162:
163: call(settype, "type", "binary", 0);
164: }
165:
166: /*
167: * Set ascii transfer type.
168: */
169: /*VARARGS*/
170: setascii()
171: {
172:
173: call(settype, "type", "ascii", 0);
174: }
175:
176: /*
177: * Set tenex transfer type.
178: */
179: /*VARARGS*/
180: settenex()
181: {
182:
183: call(settype, "type", "tenex", 0);
184: }
185:
186: /*
187: * Set ebcdic transfer type.
188: */
189: /*VARARGS*/
190: setebcdic()
191: {
192:
193: call(settype, "type", "ebcdic", 0);
194: }
195:
196: /*
197: * Set file transfer mode.
198: */
199: setmode(argc, argv)
200: char *argv[];
201: {
202:
203: printf("We only support %s mode, sorry.\n", modename);
204: }
205:
206: /*
207: * Set file transfer format.
208: */
209: setform(argc, argv)
210: char *argv[];
211: {
212:
213: printf("We only support %s format, sorry.\n", formname);
214: }
215:
216: /*
217: * Set file transfer structure.
218: */
219: setstruct(argc, argv)
220: char *argv[];
221: {
222:
223: printf("We only support %s structure, sorry.\n", structname);
224: }
225:
226: put(argc, argv)
227: int argc;
228: char *argv[];
229: {
230: char *cmd;
231:
232: if (argc == 2)
233: argc++, argv[2] = argv[1];
234: if (argc < 2) {
235: strcat(line, " ");
236: printf("(local-file) ");
237: gets(&line[strlen(line)]);
238: makeargv();
239: argc = margc;
240: argv = margv;
241: }
242: if (argc < 2) {
243: usage:
244: printf("%s local-file remote-file\n", argv[0]);
245: return;
246: }
247: if (argc < 3) {
248: strcat(line, " ");
249: printf("(remote-file) ");
250: gets(&line[strlen(line)]);
251: makeargv();
252: argc = margc;
253: argv = margv;
254: }
255: if (argc < 3)
256: goto usage;
257: if (!globulize(&argv[1]))
258: return;
259: cmd = (argv[0][0] == 'a') ? "APPE" : "STOR";
260: sendrequest(cmd, argv[1], argv[2]);
261: }
262:
263: /*
264: * Send multiple files.
265: */
266: mput(argc, argv)
267: char *argv[];
268: {
269: register int i;
270:
271: if (argc < 2) {
272: strcat(line, " ");
273: printf("(local-files) ");
274: gets(&line[strlen(line)]);
275: makeargv();
276: argc = margc;
277: argv = margv;
278: }
279: if (argc < 2) {
280: printf("%s local-files\n", argv[0]);
281: return;
282: }
283: for (i = 1; i < argc; i++) {
284: register char **cpp, **gargs;
285:
286: if (!doglob) {
287: if (confirm(argv[0], argv[i]))
288: sendrequest("STOR", argv[i], argv[i]);
289: continue;
290: }
291: gargs = glob(argv[i]);
292: if (globerr != NULL) {
293: printf("%s\n", globerr);
294: if (gargs)
295: blkfree(gargs);
296: continue;
297: }
298: for (cpp = gargs; cpp && *cpp != NULL; cpp++)
299: if (confirm(argv[0], *cpp))
300: sendrequest("STOR", *cpp, *cpp);
301: if (gargs != NULL)
302: blkfree(gargs);
303: }
304: }
305:
306: /*
307: * Receive one file.
308: */
309: get(argc, argv)
310: char *argv[];
311: {
312:
313: if (argc == 2)
314: argc++, argv[2] = argv[1];
315: if (argc < 2) {
316: strcat(line, " ");
317: printf("(remote-file) ");
318: gets(&line[strlen(line)]);
319: makeargv();
320: argc = margc;
321: argv = margv;
322: }
323: if (argc < 2) {
324: usage:
325: printf("%s remote-file [ local-file ]\n", argv[0]);
326: return;
327: }
328: if (argc < 3) {
329: strcat(line, " ");
330: printf("(local-file) ");
331: gets(&line[strlen(line)]);
332: makeargv();
333: argc = margc;
334: argv = margv;
335: }
336: if (argc < 3)
337: goto usage;
338: if (!globulize(&argv[2]))
339: return;
340: recvrequest("RETR", argv[2], argv[1], "w");
341: }
342:
343: /*
344: * Get multiple files.
345: */
346: mget(argc, argv)
347: char *argv[];
348: {
349: char *cp;
350:
351: if (argc < 2) {
352: strcat(line, " ");
353: printf("(remote-files) ");
354: gets(&line[strlen(line)]);
355: makeargv();
356: argc = margc;
357: argv = margv;
358: }
359: if (argc < 2) {
360: printf("%s remote-files\n", argv[0]);
361: return;
362: }
363: while ((cp = remglob(argc, argv)) != NULL)
364: if (confirm(argv[0], cp)) {
365: char *local;
366:
367: local = malloc((unsigned)(strlen(cp)+1));
368: if (!local) {
369: fprintf(stderr,"ftp: %s.\n",
370: "Cannot allocate memory");
371: exit(1);
372: }
373: if (rindex(cp,'/'))
374: strcpy(local, rindex(cp,'/')+1);
375: else
376: strcpy(local, cp);
377: recvrequest("RETR", local, cp, "w");
378: }
379: }
380:
381: extern int firstime;
382:
383: char *
384: remglob(argc, argv)
385: char *argv[];
386: {
387: char temp[16];
388: static char buf[MAXPATHLEN];
389: static FILE *ftemp = NULL;
390: static char **args;
391: int oldverbose, oldhash;
392: char *cp, *mode;
393:
394: if (!doglob) {
395: if (args == NULL)
396: args = argv;
397: if ((cp = *++args) == NULL)
398: args = NULL;
399: return (cp);
400: }
401: if (firstime == YES) {
402: strcpy(temp, "/tmp/ftpXXXXXX");
403: mktemp(temp);
404: oldverbose = verbose, verbose = 0;
405: oldhash = hash, hash = 0;
406: for (mode = "w"; *++argv != NULL; mode = "a")
407: recvrequest ("NLST", temp, *argv, mode);
408: verbose = oldverbose; hash = oldhash;
409: ftemp = fopen(temp, "r");
410: unlink(temp);
411: if (ftemp == NULL) {
412: printf("can't find list of remote files, oops\n");
413: return (NULL);
414: }
415: }
416: if (fgets(buf, sizeof (buf), ftemp) == NULL) {
417: fclose(ftemp), ftemp = NULL;
418: return (NULL);
419: }
420: if ((cp = index(buf, '\n')) != NULL)
421: *cp = '\0';
422: firstime = NO;
423: return (buf);
424: }
425:
426: char *
427: onoff(bool)
428: int bool;
429: {
430:
431: return (bool ? "on" : "off");
432: }
433:
434: /*
435: * Show status.
436: */
437: status(argc, argv)
438: char *argv[];
439: {
440:
441: if (connected)
442: printf("Connected to %s.\n", hostname);
443: else
444: printf("Not connected.\n");
445: printf("Mode: %s; Type: %s; Form: %s; Structure: %s\n",
446: modename, typename, formname, structname);
447: printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n",
448: onoff(verbose), onoff(bell), onoff(interactive),
449: onoff(doglob));
450: printf("Hash mark printing: %s; Use of PORT cmds: %s\n",
451: onoff(hash), onoff(sendport));
452: }
453:
454: /*
455: * Set beep on cmd completed mode.
456: */
457: /*VARARGS*/
458: setbell()
459: {
460:
461: bell = !bell;
462: printf("Bell mode %s.\n", onoff(bell));
463: }
464:
465: /*
466: * Turn on packet tracing.
467: */
468: /*VARARGS*/
469: settrace()
470: {
471:
472: trace = !trace;
473: printf("Packet tracing %s.\n", onoff(trace));
474: }
475:
476: /*
477: * Toggle hash mark printing during transfers.
478: */
479: /*VARARGS*/
480: sethash()
481: {
482:
483: hash = !hash;
484: printf("Hash mark printing %s", onoff(hash));
485: if (hash)
486: printf(" (%d bytes/hash mark)", BUFSIZ);
487: printf(".\n");
488: }
489:
490: /*
491: * Turn on printing of server echo's.
492: */
493: /*VARARGS*/
494: setverbose()
495: {
496:
497: verbose = !verbose;
498: printf("Verbose mode %s.\n", onoff(verbose));
499: }
500:
501: /*
502: * Toggle PORT cmd use before each data connection.
503: */
504: /*VARARGS*/
505: setport()
506: {
507:
508: sendport = !sendport;
509: printf("Use of PORT cmds %s.\n", onoff(sendport));
510: }
511:
512: /*
513: * Turn on interactive prompting
514: * during mget, mput, and mdelete.
515: */
516: /*VARARGS*/
517: setprompt()
518: {
519:
520: interactive = !interactive;
521: printf("Interactive mode %s.\n", onoff(interactive));
522: }
523:
524: /*
525: * Toggle metacharacter interpretation
526: * on local file names.
527: */
528: /*VARARGS*/
529: setglob()
530: {
531:
532: doglob = !doglob;
533: printf("Globbing %s.\n", onoff(doglob));
534: }
535:
536: /*
537: * Set debugging mode on/off and/or
538: * set level of debugging.
539: */
540: /*VARARGS*/
541: setdebug(argc, argv)
542: char *argv[];
543: {
544: int val;
545:
546: if (argc > 1) {
547: val = atoi(argv[1]);
548: if (val < 0) {
549: printf("%s: bad debugging value.\n", argv[1]);
550: return;
551: }
552: } else
553: val = !debug;
554: debug = val;
555: if (debug)
556: options |= SO_DEBUG;
557: else
558: options &= ~SO_DEBUG;
559: printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
560: }
561:
562: /*
563: * Set current working directory
564: * on remote machine.
565: */
566: cd(argc, argv)
567: char *argv[];
568: {
569:
570: if (argc < 2) {
571: strcat(line, " ");
572: printf("(remote-directory) ");
573: gets(&line[strlen(line)]);
574: makeargv();
575: argc = margc;
576: argv = margv;
577: }
578: if (argc < 2) {
579: printf("%s remote-directory\n", argv[0]);
580: return;
581: }
582: (void) command("CWD %s", argv[1]);
583: }
584:
585: /*
586: * Set current working directory
587: * on local machine.
588: */
589: lcd(argc, argv)
590: char *argv[];
591: {
592: char buf[MAXPATHLEN];
593:
594: if (argc < 2)
595: argc++, argv[1] = home;
596: if (argc != 2) {
597: printf("%s local-directory\n", argv[0]);
598: return;
599: }
600: if (!globulize(&argv[1]))
601: return;
602: if (chdir(argv[1]) < 0) {
603: perror(argv[1]);
604: return;
605: }
606: printf("Local directory now %s\n", getwd(buf));
607: }
608:
609: /*
610: * Delete a single file.
611: */
612: delete(argc, argv)
613: char *argv[];
614: {
615:
616: if (argc < 2) {
617: strcat(line, " ");
618: printf("(remote-file) ");
619: gets(&line[strlen(line)]);
620: makeargv();
621: argc = margc;
622: argv = margv;
623: }
624: if (argc < 2) {
625: printf("%s remote-file\n", argv[0]);
626: return;
627: }
628: (void) command("DELE %s", argv[1]);
629: }
630:
631: /*
632: * Delete multiple files.
633: */
634: mdelete(argc, argv)
635: char *argv[];
636: {
637: char *cp;
638:
639: if (argc < 2) {
640: strcat(line, " ");
641: printf("(remote-files) ");
642: gets(&line[strlen(line)]);
643: makeargv();
644: argc = margc;
645: argv = margv;
646: }
647: if (argc < 2) {
648: printf("%s remote-files\n", argv[0]);
649: return;
650: }
651: while ((cp = remglob(argc, argv)) != NULL)
652: if (confirm(argv[0], cp))
653: (void) command("DELE %s", cp);
654: }
655:
656: /*
657: * Rename a remote file.
658: */
659: renamefile(argc, argv)
660: char *argv[];
661: {
662:
663: if (argc < 2) {
664: strcat(line, " ");
665: printf("(from-name) ");
666: gets(&line[strlen(line)]);
667: makeargv();
668: argc = margc;
669: argv = margv;
670: }
671: if (argc < 2) {
672: usage:
673: printf("%s from-name to-name\n", argv[0]);
674: return;
675: }
676: if (argc < 3) {
677: strcat(line, " ");
678: printf("(to-name) ");
679: gets(&line[strlen(line)]);
680: makeargv();
681: argc = margc;
682: argv = margv;
683: }
684: if (argc < 3)
685: goto usage;
686: if (command("RNFR %s", argv[1]) == CONTINUE)
687: (void) command("RNTO %s", argv[2]);
688: }
689:
690: /*
691: * Get a directory listing
692: * of remote files.
693: */
694: ls(argc, argv)
695: char *argv[];
696: {
697: char *cmd;
698:
699: if (argc < 2)
700: argc++, argv[1] = NULL;
701: if (argc < 3)
702: argc++, argv[2] = "-";
703: if (argc > 3) {
704: printf("usage: %s remote-directory local-file\n", argv[0]);
705: return;
706: }
707: cmd = argv[0][0] == 'l' ? "NLST" : "LIST";
708: if (strcmp(argv[2], "-") && !globulize(&argv[2]))
709: return;
710: recvrequest(cmd, argv[2], argv[1], "w");
711: }
712:
713: /*
714: * Get a directory listing
715: * of multiple remote files.
716: */
717: mls(argc, argv)
718: char *argv[];
719: {
720: char *cmd, *mode, *cp, *dest;
721:
722: if (argc < 2) {
723: strcat(line, " ");
724: printf("(remote-files) ");
725: gets(&line[strlen(line)]);
726: makeargv();
727: argc = margc;
728: argv = margv;
729: }
730: if (argc < 3) {
731: strcat(line, " ");
732: printf("(local-file) ");
733: gets(&line[strlen(line)]);
734: makeargv();
735: argc = margc;
736: argv = margv;
737: }
738: if (argc < 3) {
739: printf("%s remote-files local-file\n", argv[0]);
740: return;
741: }
742: dest = argv[argc - 1];
743: argv[argc - 1] = NULL;
744: if (strcmp(dest, "-"))
745: if (!globulize(&dest) || !confirm("local-file", dest))
746: return; /* not this local file. Cancel action */
747: cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
748: for (mode = "w"; cp = remglob(argc, argv); mode = "a")
749: if (confirm(argv[0], cp))
750: recvrequest(cmd, dest, cp, mode);
751: }
752:
753: /*
754: * Do a shell escape
755: */
756: shell(argc, argv)
757: char *argv[];
758: {
759: int pid, status, (*old1)(), (*old2)();
760: char shellnam[40], *shell, *namep;
761: char **cpp, **gargs;
762:
763: if (debug) {
764: register char **zip = argv;
765:
766: printf("argc: %d\n", argc);
767: printf("%s", *zip);
768: while (*++zip != NULL)
769: printf(" %s", *zip);
770: printf("\n");
771: fflush(stdout);
772: }
773: old1 = signal (SIGINT, SIG_IGN);
774: old2 = signal (SIGQUIT, SIG_IGN);
775: if ((pid = fork()) == 0) {
776:
777: char *cmd;
778:
779: for (pid = 3; pid < 20; pid++)
780: close(pid);
781: signal(SIGINT, SIG_DFL);
782: signal(SIGQUIT, SIG_DFL);
783: shell = getenv("SHELL");
784: if (shell == NULL)
785: shell = "/bin/sh";
786: if (argc <= 1) {
787: namep = rindex(shell,'/');
788: if (namep == NULL)
789: namep = shell;
790: strcpy(shellnam,"-");
791: strcat(shellnam, ++namep);
792: if (debug)
793: printf("namep: %s\n", namep);
794: if (strcmp(namep, "sh") != 0)
795: shellnam[0] = '+';
796: if (debug)
797: printf("shellname: %s\n", shellnam);
798: execl(shell, shellnam, (char *)0);
799: perror(shell);
800: exit(1);
801: }
802: if (debug)
803: printf("run %s %s %s %s\n",shell,
804: shellnam,"-c",argv[1]), fflush(stdout);
805: execl(shell, shellnam, "-c", argv[1], 0);
806: perror(shell);
807: exit(1);
808: }
809: if (pid > 0)
810: while (wait(&status) != pid)
811: ;
812: signal(SIGINT, old1);
813: signal(SIGQUIT, old2);
814: if (pid == -1)
815: perror("Try again later");
816: return (0);
817: }
818:
819: /*
820: * Send new user information (re-login)
821: */
822: user(argc, argv)
823: int argc;
824: char **argv;
825: {
826: char acct[80], *getpass();
827: int n;
828:
829: if (argc < 2) {
830: strcat(line, " ");
831: printf("(username) ");
832: gets(&line[strlen(line)]);
833: makeargv();
834: argc = margc;
835: argv = margv;
836: }
837: if (argc > 4) {
838: printf("usage: %s username [password] [account]\n", argv[0]);
839: return (0);
840: }
841: n = command("USER %s", argv[1]);
842: if (n == CONTINUE) {
843: if (argc < 3 )
844: argv[2] = getpass("Password: "), argc++;
845: n = command("PASS %s", argv[2]);
846: }
847: if (n == CONTINUE) {
848: if (argc < 4) {
849: printf("Account: "); (void) fflush(stdout);
850: (void) fgets(acct, sizeof(acct) - 1, stdin);
851: acct[strlen(acct) - 1] = '\0';
852: argv[3] = acct; argc++;
853: }
854: n = command("ACCT %s", acct);
855: }
856: if (n != COMPLETE) {
857: fprintf(stderr, "Login failed.\n");
858: return (0);
859: }
860: return (1);
861: }
862:
863: /*
864: * Print working directory.
865: */
866: /*VARARGS*/
867: pwd()
868: {
869:
870: (void) command("XPWD");
871: }
872:
873: /*
874: * Make a directory.
875: */
876: makedir(argc, argv)
877: char *argv[];
878: {
879:
880: if (argc < 2) {
881: strcat(line, " ");
882: printf("(directory-name) ");
883: gets(&line[strlen(line)]);
884: makeargv();
885: argc = margc;
886: argv = margv;
887: }
888: if (argc < 2) {
889: printf("%s directory-name\n", argv[0]);
890: return;
891: }
892: (void) command("XMKD %s", argv[1]);
893: }
894:
895: /*
896: * Remove a directory.
897: */
898: removedir(argc, argv)
899: char *argv[];
900: {
901:
902: if (argc < 2) {
903: strcat(line, " ");
904: printf("(directory-name) ");
905: gets(&line[strlen(line)]);
906: makeargv();
907: argc = margc;
908: argv = margv;
909: }
910: if (argc < 2) {
911: printf("%s directory-name\n", argv[0]);
912: return;
913: }
914: (void) command("XRMD %s", argv[1]);
915: }
916:
917: /*
918: * Send a line, verbatim, to the remote machine.
919: */
920: quote(argc, argv)
921: char *argv[];
922: {
923: int i;
924: char buf[BUFSIZ];
925:
926: if (argc < 2) {
927: strcat(line, " ");
928: printf("(command line to send) ");
929: gets(&line[strlen(line)]);
930: makeargv();
931: argc = margc;
932: argv = margv;
933: }
934: if (argc < 2) {
935: printf("usage: %s line-to-send\n", argv[0]);
936: return;
937: }
938: strcpy(buf, argv[1]);
939: for (i = 2; i < argc; i++) {
940: strcat(buf, " ");
941: strcat(buf, argv[i]);
942: }
943: (void) command(buf);
944: }
945:
946: /*
947: * Ask the other side for help.
948: */
949: rmthelp(argc, argv)
950: char *argv[];
951: {
952: int oldverbose = verbose;
953:
954: verbose = 1;
955: (void) command(argc == 1 ? "HELP" : "HELP %s", argv[1]);
956: verbose = oldverbose;
957: }
958:
959: /*
960: * Terminate session and exit.
961: */
962: /*VARARGS*/
963: quit()
964: {
965:
966: disconnect();
967: exit(0);
968: }
969:
970: /*
971: * Terminate session, but don't exit.
972: */
973: disconnect()
974: {
975: extern FILE *cout;
976: extern int data;
977:
978: if (!connected)
979: return;
980: (void) command("QUIT");
981: (void) fclose(cout);
982: cout = NULL;
983: connected = 0;
984: data = -1;
985: }
986:
987: confirm(cmd, file)
988: char *cmd, *file;
989: {
990: char line[BUFSIZ];
991:
992: if (!interactive)
993: return (1);
994: printf("%s %s? ", cmd, file);
995: fflush(stdout);
996: gets(line);
997: return (*line != 'n' && *line != 'N');
998: }
999:
1000: fatal(msg)
1001: char *msg;
1002: {
1003:
1004: fprintf(stderr, "ftp: %s\n");
1005: exit(1);
1006: }
1007:
1008: /*
1009: * Glob a local file name specification with
1010: * the expectation of a single return value.
1011: * Can't control multiple values being expanded
1012: * from the expression, we return only the first.
1013: */
1014: globulize(cpp)
1015: char **cpp;
1016: {
1017: char **globbed;
1018:
1019: if (!doglob)
1020: return (1);
1021: globbed = glob(*cpp);
1022: if (globerr != NULL) {
1023: printf("%s: %s\n", *cpp, globerr);
1024: if (globbed)
1025: blkfree(globbed);
1026: return (0);
1027: }
1028: if (globbed) {
1029: *cpp = *globbed++;
1030: /* don't waste too much memory */
1031: if (*globbed)
1032: blkfree(globbed);
1033: }
1034: return (1);
1035: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.