![[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] / 43BSDTahoe / new / xns / examples / filing_client|
Return to cmds.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / filing_client |
1.1 root 1: #ifndef lint
2: static char RCSid[] = "$Header: cmds.c,v 2.5 87/04/01 09:32:37 ed Exp $";
3: #endif
4: /* $Log: cmds.c,v $
5: * Revision 2.5 87/04/01 09:32:37 ed
6: * Fixed bug in setpeer if no host accompanies -F (from Chris Liebman)
7: *
8: * Revision 2.4 87/01/09 16:52:00 ed
9: * Use FilingSubset, if rejected attempt Filing
10: * Allows user override with -F switch
11: * Maintain FilingSubset mandatory attributes
12: * User niceties: echo file name/type on transfer commands
13: * prompt on delete
14: * guess type which will determine file type implied by content
15: * New commands: (type related) Guess, Whatis
16: * (file transfer) Copy, Move, Rename
17: *
18: * Revision 2.3 86/12/15 11:40:49 jqj
19: * Added support for more ViewPoint file types (no other attributes, though)
20: *
21: * Revision 2.2 86/12/11 06:11:30 jqj
22: * Eliminated form, mode, and struct commands. Started adding support for
23: * more file types.
24: *
25: * Revision 2.1 86/06/30 12:18:56 jqj
26: * get proper order of args to allow mget to work right.
27: *
28: * Revision 2.0 85/11/21 07:22:41 jqj
29: * 4.3BSD standard release
30: *
31: * Revision 1.2 85/10/30 08:06:37 root
32: * if prompt=off but verbose=on, print the name of each file during
33: * multiplefile transfers.
34: *
35: * Revision 1.1 85/05/27 06:30:51 jqj
36: * Initial revision
37: *
38: * based on Berkeley tcp/ftp
39: */
40: /* static char sccsid[] = "@(#)cmds.c 4.9 (Berkeley) 7/26/83"; */
41:
42: /*
43: * FTP User Program -- Command Routines.
44: */
45: #include <sys/param.h>
46: #include <sys/stat.h>
47: #include <sys/socket.h>
48: #include <sys/file.h>
49:
50: #include <signal.h>
51: #include <stdio.h>
52: #include <errno.h>
53:
54: #include "ftp_var.h"
55:
56: extern char *globerr;
57: extern char **glob();
58: extern char *home;
59: extern short gflag;
60: extern char *remglob();
61: extern char *getenv();
62: extern char *index();
63: extern char *rindex();
64:
65: /*
66: * Connect to peer server and
67: * auto-login, if possible.
68: */
69: setpeer(argc, argv)
70: int argc;
71: char *argv[];
72: {
73: CourierConnection *hookup();
74:
75: if (connected != (CourierConnection*)0) {
76: printf("Already connected to %s, use disconnect first.\n",
77: hostname);
78: return;
79: }
80:
81: if (argc < 2) {
82: strcat(line, " ");
83: printf("(to) ");
84: gets(&line[strlen(line)]);
85: makeargv();
86: argc = margc;
87: argv = margv;
88: } else if (strcmp(argv[1], "-F") == 0) {
89: usefiling= 1;
90: if (argc < 3) {
91: strcat(line, " ");
92: printf("(to) ");
93: gets(&line[strlen(line)]);
94: makeargv();
95: argc = margc;
96: argv = margv;
97: }
98: argc--;
99: argv[1]= argv[2];
100: }
101:
102: if (argc > 2) {
103: printf("usage: %s [-F] fileservice-name\n", argv[0]);
104: return;
105: }
106: connected = hookup(argv[1]);
107: if (connected != (CourierConnection*)0) {
108: if (autologin) {
109: login(0,0);
110: }
111: }
112: }
113:
114: struct types {
115: char *t_name;
116: int t_type;
117: } types[] = {
118: { "ascii", TYPE_A },
119: { "binary", TYPE_I },
120: { "image", TYPE_I },
121: { "interpress", TYPE_Interpress },
122: { "viewpoint", TYPE_VP },
123: { "vpcanvas", TYPE_VPCanvas },
124: { "vpdictionary",TYPE_VPDictionary },
125: { "vpmailnote", TYPE_VPMailNote },
126: { "vpreference",TYPE_VPReference },
127: { "serialized", TYPE_S },
128: { "guess", TYPE_Guess },
129: 0
130: };
131:
132: /*
133: * Set transfer type.
134: */
135: settype(argc, argv)
136: char *argv[];
137: {
138: register struct types *p;
139: int comret;
140:
141: if (argc > 2 || (argc == 2 && strcmp(argv[1],"?") == 0)) {
142: char *sep;
143:
144: printf("usage: %s [ <integer> ", argv[0]);
145: sep = " | ";
146: for (p = types; p->t_name; p++) {
147: printf("%s%s", sep, p->t_name);
148: }
149: printf(" ]\n");
150: return;
151: }
152: if (argc < 2) {
153: printf("Using %s mode to transfer files.\n", typename);
154: return;
155: }
156: for (p = types; p->t_name; p++)
157: if (strcmp(argv[1], p->t_name) == 0)
158: break;
159: if (p->t_name == 0) {
160: int tmp = atoi(argv[1]);
161: if (tmp == 0 && strcmp(argv[1],"0") != 0) {
162: printf("%s: unknown mode (\"%s ?\" for help)\n",
163: argv[1], argv[0]);
164: return;
165: }
166: sprintf(typename,"%d",tmp);
167: typevalue = tmp;
168: return;
169: }
170: strcpy(typename, p->t_name);
171: typevalue = p->t_type;
172: }
173:
174: /*
175: * Set binary transfer type.
176: */
177: /*VARARGS*/
178: setbinary()
179: {
180:
181: call(settype, "type", "binary", 0);
182: }
183:
184: /*
185: * Set ascii transfer type.
186: */
187: /*VARARGS*/
188: setascii()
189: {
190:
191: call(settype, "type", "ascii", 0);
192: }
193:
194: /*
195: * Set guess transfer type.
196: * basically make educated guess of file type as stored
197: */
198: /*VARARGS*/
199: setguess()
200: {
201: call(settype, "type", "guess", 0);
202: }
203:
204: put(argc, argv)
205: int argc;
206: char *argv[];
207: {
208: char *cmd;
209:
210: if (argc == 2)
211: argc++, argv[2] = argv[1];
212: if (argc < 2) {
213: strcat(line, " ");
214: printf("(local-file) ");
215: gets(&line[strlen(line)]);
216: makeargv();
217: argc = margc;
218: argv = margv;
219: }
220: if (argc < 2) {
221: usage:
222: printf("%s local-file remote-file\n", argv[0]);
223: return;
224: }
225: if (argc < 3) {
226: strcat(line, " ");
227: printf("(remote-file) ");
228: gets(&line[strlen(line)]);
229: makeargv();
230: argc = margc;
231: argv = margv;
232: }
233: if (argc < 3)
234: goto usage;
235: if (!globulize(&argv[1]))
236: return;
237: cmd = (argv[0][0] == 'a') ? "APPE" : "STOR";
238:
239: sendrequest(cmd, argv[1], argv[2]);
240:
241: }
242:
243: /*
244: * Send multiple files.
245: */
246: mput(argc, argv)
247: char *argv[];
248: {
249: register int i;
250:
251: if (argc < 2) {
252: strcat(line, " ");
253: printf("(local-files) ");
254: gets(&line[strlen(line)]);
255: makeargv();
256: argc = margc;
257: argv = margv;
258: }
259: if (argc < 2) {
260: printf("%s local-files\n", argv[0]);
261: return;
262: }
263: for (i = 1; i < argc; i++) {
264: register char **cpp, **gargs;
265:
266: if (!doglob) {
267: if (confirm(argv[0], argv[i]))
268: sendrequest("STOR", argv[i], argv[i]);
269: continue;
270: }
271: gargs = glob(argv[i]);
272: if (globerr != NULL) {
273: printf("%s\n", globerr);
274: if (gargs)
275: blkfree(gargs);
276: continue;
277: }
278: for (cpp = gargs; cpp && *cpp != NULL; cpp++)
279: if (confirm(argv[0], *cpp))
280: sendrequest("STOR", *cpp, *cpp);
281: if (gargs != NULL)
282: blkfree(gargs);
283: }
284: }
285:
286: /*
287: * Receive one file.
288: */
289: get(argc, argv)
290: char *argv[];
291: {
292:
293: if (argc == 2)
294: argc++, argv[2] = argv[1];
295: if (argc < 2) {
296: strcat(line, " ");
297: printf("(remote-file) ");
298: gets(&line[strlen(line)]);
299: makeargv();
300: argc = margc;
301: argv = margv;
302: }
303: if (argc < 2) {
304: usage:
305: printf("%s remote-file [ local-file ]\n", argv[0]);
306: return;
307: }
308: if (argc < 3) {
309: strcat(line, " ");
310: printf("(local-file) ");
311: gets(&line[strlen(line)]);
312: makeargv();
313: argc = margc;
314: argv = margv;
315: }
316: if (argc < 3)
317: goto usage;
318: if (!globulize(&argv[2]))
319: return;
320:
321: recvrequest("RETR", argv[2], argv[1], "w");
322: }
323: /*
324: * given a remote file name, strip directory path and version number
325: */
326: char *
327: getlocalname(cp)
328: char *cp;
329: {
330: char *result;
331: static char buf[MAXPATHLEN];
332:
333: result = rindex(cp,'/'); /* find last component */
334: if (result == NULL) result = cp;
335: else result += 1;
336: strcpy(buf, result);
337: result = index(buf,'!'); /* strip version # if any */
338: if (result != NULL && result != buf) *result = '\000';
339: return(buf);
340: }
341:
342: /*
343: * Get multiple files.
344: */
345: mget(argc, argv)
346: char *argv[];
347: {
348: char *cp;
349: char *tailp;
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: tailp = getlocalname(cp);
366: recvrequest("RETR", tailp, cp, "w");
367: }
368: }
369:
370: /*
371: * Deserialize a file to file/descendants]
372: */
373: restore(argc, argv)
374: int argc;
375: char *argv[];
376: {
377: char *cmd;
378:
379: if (argc == 2)
380: argc++, argv[2] = argv[1];
381: if (argc < 2) {
382: strcat(line, " ");
383: printf("(local-file) ");
384: gets(&line[strlen(line)]);
385: makeargv();
386: argc = margc;
387: argv = margv;
388: }
389: if (argc < 2) {
390: usage:
391: printf("%s local-file remote-file\n", argv[0]);
392: return;
393: }
394: if (argc < 3) {
395: strcat(line, " ");
396: printf("(remote-file) ");
397: gets(&line[strlen(line)]);
398: makeargv();
399: argc = margc;
400: argv = margv;
401: }
402: if (argc < 3)
403: goto usage;
404: if (!globulize(&argv[1]))
405: return;
406: cmd = "DSER";
407:
408: sendrequest(cmd, argv[1], argv[2]);
409:
410: }
411:
412: /*
413: * Serialize a file/descendants.
414: */
415: archive(argc, argv)
416: char *argv[];
417: {
418:
419: if (argc == 2)
420: argc++, argv[2] = argv[1];
421: if (argc < 2) {
422: strcat(line, " ");
423: printf("(remote-file) ");
424: gets(&line[strlen(line)]);
425: makeargv();
426: argc = margc;
427: argv = margv;
428: }
429: if (argc < 2) {
430: usage:
431: printf("%s remote-file [ local-file ]\n", argv[0]);
432: return;
433: }
434: if (argc < 3) {
435: strcat(line, " ");
436: printf("(local-file) ");
437: gets(&line[strlen(line)]);
438: makeargv();
439: argc = margc;
440: argv = margv;
441: }
442: if (argc < 3)
443: goto usage;
444: if (!globulize(&argv[2]))
445: return;
446:
447: recvrequest("SER", argv[2], argv[1], "w");
448: }
449:
450: char *
451: remglob(argc, argv)
452: char *argv[];
453: {
454: char temp[16];
455: static char buf[MAXPATHLEN];
456: static FILE *ftemp = NULL;
457: static char **args;
458: int oldverbose, oldhash;
459: char *cp, *mode;
460:
461: if (!doglob) {
462: if (args == NULL)
463: args = argv;
464: if ((cp = *++args) == NULL)
465: args = NULL;
466: return (cp);
467: }
468: if (ftemp == NULL) {
469: strcpy(temp, "/tmp/ftpXXXXXX");
470: mktemp(temp);
471: oldverbose = verbose, verbose = 0;
472: oldhash = hash, hash = 0;
473: for (mode = "w"; *++argv != NULL; mode = "a")
474: recvrequest("NLST", temp, *argv, mode);
475: verbose = oldverbose; hash = oldhash;
476: ftemp = fopen(temp, "r");
477: unlink(temp);
478: if (ftemp == NULL) {
479: printf("can't find list of remote files, oops\n");
480: return (NULL);
481: }
482: }
483: if (fgets(buf, sizeof (buf), ftemp) == NULL) {
484: fclose(ftemp), ftemp = NULL;
485: return (NULL);
486: }
487: if ((cp = index(buf, '\n')) != NULL)
488: *cp = '\0';
489: return (buf);
490: }
491:
492: char *
493: onoff(bool)
494: int bool;
495: {
496:
497: return (bool ? "on" : "off");
498: }
499:
500: /*
501: * Show status.
502: */
503: status(argc, argv)
504: char *argv[];
505: {
506:
507: if (connected)
508: printf("Connected to %s.\n", hostname);
509: else
510: printf("Not connected.\n");
511: printf("Type: %s\n", typename);
512: printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n",
513: onoff(verbose), onoff(bell), onoff(interactive),
514: onoff(doglob));
515: printf("Hash mark printing: %s\n",
516: onoff(hash));
517: }
518:
519: /*
520: * Set beep on cmd completed mode.
521: */
522: /*VARARGS*/
523: setbell()
524: {
525:
526: bell = !bell;
527: printf("Bell mode %s.\n", onoff(bell));
528: }
529:
530: /*
531: * Turn on packet tracing.
532: */
533: /*VARARGS*/
534: settrace()
535: {
536:
537: trace = !trace;
538: printf("Packet tracing %s.\n", onoff(trace));
539: }
540:
541: /*
542: * Toggle hash mark printing during transfers.
543: */
544: /*VARARGS*/
545: sethash()
546: {
547:
548: hash = !hash;
549: printf("Hash mark printing %s", onoff(hash));
550: if (hash)
551: printf(" (1 packet/hash mark)");
552: printf(".\n");
553: }
554:
555: /*
556: * Turn on printing of server echo's.
557: */
558: /*VARARGS*/
559: setverbose()
560: {
561:
562: verbose = !verbose;
563: printf("Verbose mode %s.\n", onoff(verbose));
564: }
565:
566: /*
567: * Turn on interactive prompting
568: * during mget, mput, and mdelete.
569: */
570: /*VARARGS*/
571: setprompt()
572: {
573:
574: interactive = !interactive;
575: printf("Interactive mode %s.\n", onoff(interactive));
576: }
577:
578: /*
579: * Toggle metacharacter interpretation
580: * on local file names.
581: */
582: /*VARARGS*/
583: setglob()
584: {
585:
586: doglob = !doglob;
587: printf("Globbing %s.\n", onoff(doglob));
588: }
589:
590: /*
591: * Set debugging mode on/off and/or
592: * set level of debugging.
593: */
594: /*VARARGS*/
595: setdebug(argc, argv)
596: char *argv[];
597: {
598: int val;
599:
600: if (argc > 1) {
601: val = atoi(argv[1]);
602: if (val < 0) {
603: printf("%s: bad debugging value.\n", argv[1]);
604: return;
605: }
606: } else
607: val = !debug;
608: debug = val;
609: printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
610: }
611:
612: /*
613: * Set current working directory
614: * on remote machine.
615: */
616: cd(argc, argv)
617: char *argv[];
618: {
619:
620: if (argc < 2) {
621: strcat(line, " ");
622: printf("(remote-directory) ");
623: gets(&line[strlen(line)]);
624: makeargv();
625: argc = margc;
626: argv = margv;
627: }
628: if (argc < 2) {
629: printf("%s remote-directory\n", argv[0]);
630: return;
631: }
632: (void) docd(argv[1]);
633: }
634:
635: /*
636: * Set current working directory
637: * on local machine.
638: */
639: lcd(argc, argv)
640: char *argv[];
641: {
642: char buf[MAXPATHLEN];
643:
644: if (argc < 2)
645: argc++, argv[1] = home;
646: if (argc != 2) {
647: printf("%s local-directory\n", argv[0]);
648: return;
649: }
650: if (!globulize(&argv[1]))
651: return;
652: if (chdir(argv[1]) < 0) {
653: perror(argv[1]);
654: return;
655: }
656: printf("Local directory now %s\n", getwd(buf));
657: }
658:
659: /*
660: * Delete a single file.
661: */
662: delete(argc, argv)
663: char *argv[];
664: {
665:
666: if (argc < 2) {
667: strcat(line, " ");
668: printf("(remote-file) ");
669: gets(&line[strlen(line)]);
670: makeargv();
671: argc = margc;
672: argv = margv;
673: }
674: if (argc < 2) {
675: printf("%s remote-file\n", argv[0]);
676: return;
677: }
678: (void) dodelete( argv[1]);
679: }
680:
681: /*
682: * Delete multiple files.
683: */
684: mdelete(argc, argv)
685: char *argv[];
686: {
687: char *cp;
688:
689: if (argc < 2) {
690: strcat(line, " ");
691: printf("(remote-files) ");
692: gets(&line[strlen(line)]);
693: makeargv();
694: argc = margc;
695: argv = margv;
696: }
697: if (argc < 2) {
698: printf("%s remote-files\n", argv[0]);
699: return;
700: }
701: while ((cp = remglob(argc, argv)) != NULL)
702: if (confirm(argv[0], cp))
703: (void) dodelete( cp);
704: }
705:
706: /*
707: * Rename a remote file.
708: */
709: renamefile(argc, argv)
710: char *argv[];
711: {
712:
713: if (argc < 2) {
714: strcat(line, " ");
715: printf("(from-name) ");
716: gets(&line[strlen(line)]);
717: makeargv();
718: argc = margc;
719: argv = margv;
720: }
721: if (argc < 2) {
722: usage:
723: printf("%s from-name to-name\n", argv[0]);
724: return;
725: }
726: if (argc < 3) {
727: strcat(line, " ");
728: printf("(to-name) ");
729: gets(&line[strlen(line)]);
730: makeargv();
731: argc = margc;
732: argv = margv;
733: }
734: if (argc < 3)
735: goto usage;
736: dorename(argv[1], argv[2]);
737: }
738:
739: /*
740: * Copy a remote file.
741: */
742: copyfile(argc, argv)
743: char *argv[];
744: {
745:
746: if (argc < 2) {
747: strcat(line, " ");
748: printf("(from-name) ");
749: gets(&line[strlen(line)]);
750: makeargv();
751: argc = margc;
752: argv = margv;
753: }
754: if (argc < 2) {
755: usage:
756: printf("%s from-name to-name\n", argv[0]);
757: return;
758: }
759: if (argc < 3) {
760: strcat(line, " ");
761: printf("(to-name) ");
762: gets(&line[strlen(line)]);
763: makeargv();
764: argc = margc;
765: argv = margv;
766: }
767: if (argc < 3)
768: goto usage;
769: docopy("COPY", argv[1], argv[2]);
770: }
771:
772: /*
773: * Move a remote file.
774: */
775: movefile(argc, argv)
776: char *argv[];
777: {
778:
779: if (argc < 2) {
780: strcat(line, " ");
781: printf("(from-name) ");
782: gets(&line[strlen(line)]);
783: makeargv();
784: argc = margc;
785: argv = margv;
786: }
787: if (argc < 2) {
788: usage:
789: printf("%s from-name to-name\n", argv[0]);
790: return;
791: }
792: if (argc < 3) {
793: strcat(line, " ");
794: printf("(to-directory) ");
795: gets(&line[strlen(line)]);
796: makeargv();
797: argc = margc;
798: argv = margv;
799: }
800: if (argc < 3)
801: goto usage;
802: docopy("MOVE", argv[1], argv[2]);
803: }
804:
805: /*
806: * Get a directory listing
807: * of remote files.
808: */
809: ls(argc, argv)
810: char *argv[];
811: {
812: char *cmd;
813:
814: if (argc < 2)
815: argc++, argv[1] = "*";
816: if (argc < 3)
817: argc++, argv[2] = "-";
818: if (argc > 3) {
819: printf("usage: %s remote-directory local-file\n", argv[0]);
820: return;
821: }
822: cmd = argv[0][0] == 'l' ? "NLST" : "LIST";
823: if (strcmp(argv[2], "-") && !globulize(&argv[2]))
824: return;
825: recvrequest(cmd, argv[2], argv[1], "w");
826: }
827:
828: /*
829: * Get a directory listing
830: * of multiple remote files.
831: */
832: mls(argc, argv)
833: char *argv[];
834: {
835: char *cmd, *mode, *cp, *dest;
836:
837: if (argc < 2) {
838: strcat(line, " ");
839: printf("(remote-files) ");
840: gets(&line[strlen(line)]);
841: makeargv();
842: argc = margc;
843: argv = margv;
844: }
845: if (argc < 3) {
846: strcat(line, " ");
847: printf("(local-file) ");
848: gets(&line[strlen(line)]);
849: makeargv();
850: argc = margc;
851: argv = margv;
852: }
853: if (argc < 3) {
854: printf("%s remote-files local-file\n", argv[0]);
855: return;
856: }
857: dest = argv[argc - 1];
858: argv[argc - 1] = NULL;
859: if (strcmp(dest, "-"))
860: if (globulize(&dest) && confirm("local-file", dest))
861: return;
862: cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
863: for (mode = "w"; cp = remglob(argc, argv); mode = "a")
864: if (confirm(argv[0], cp))
865: recvrequest(cmd, argv[2], argv[1], "w");
866: }
867:
868: /*
869: * Unify Accesslists for a single file.
870: */
871: unify(argc, argv)
872: char *argv[];
873: {
874:
875: if (argc < 2) {
876: strcat(line, " ");
877: printf("(remote-directory) ");
878: gets(&line[strlen(line)]);
879: makeargv();
880: argc = margc;
881: argv = margv;
882: }
883: if (argc < 2) {
884: printf("%s remote-directory\n", argv[0]);
885: return;
886: }
887: (void) dounify( argv[1]);
888: }
889:
890: /*
891: * Do a shell escape
892: */
893: shell(argc, argv)
894: char *argv[];
895: {
896: int pid, status, (*old1)(), (*old2)();
897: char shellnam[40], *shell, *namep;
898: char **cpp, **gargs;
899:
900: old1 = signal (SIGINT, SIG_IGN);
901: old2 = signal (SIGQUIT, SIG_IGN);
902: if ((pid = fork()) == 0) {
903: for (pid = 3; pid < 20; pid++)
904: close(pid);
905: signal(SIGINT, SIG_DFL);
906: signal(SIGQUIT, SIG_DFL);
907: if (argc <= 1) {
908: shell = getenv("SHELL");
909: if (shell == NULL)
910: shell = "/bin/sh";
911: namep = rindex(shell,'/');
912: if (namep == NULL)
913: namep = shell;
914: strcpy(shellnam,"-");
915: strcat(shellnam, ++namep);
916: if (strcmp(namep, "sh") != 0)
917: shellnam[0] = '+';
918: if (debug) {
919: printf ("%s\n", shell);
920: fflush (stdout);
921: }
922: execl(shell, shellnam, 0);
923: perror(shell);
924: exit(1);
925: }
926: cpp = &argv[1];
927: if (argc > 2) {
928: if ((gargs = glob(cpp)) != NULL)
929: cpp = gargs;
930: if (globerr != NULL) {
931: printf("%s\n", globerr);
932: exit(1);
933: }
934: }
935: if (debug) {
936: register char **zip = cpp;
937:
938: printf("%s", *zip);
939: while (*++zip != NULL)
940: printf(" %s", *zip);
941: printf("\n");
942: fflush(stdout);
943: }
944: execvp(argv[1], cpp);
945: perror(argv[1]);
946: exit(1);
947: }
948: if (pid > 0)
949: while (wait(&status) != pid)
950: ;
951: signal(SIGINT, old1);
952: signal(SIGQUIT, old2);
953: if (pid == -1)
954: perror("Try again later");
955: return (0);
956: }
957:
958: /*
959: * Send new user information (re-login)
960: */
961: user(argc, argv)
962: int argc;
963: char **argv;
964: {
965:
966: if (argc < 2) {
967: login(0,0);
968: }
969: if (argc > 3) {
970: printf("usage: %s username [password]\n", argv[0]);
971: return (0);
972: }
973: login(argv[1], argv[2]);
974: return (1);
975: }
976:
977: /*
978: * Print working directory.
979: */
980: /*VARARGS*/
981: pwd()
982: {
983: dopwd();
984: }
985:
986: /*
987: * Make a directory.
988: */
989: makedir(argc, argv)
990: char *argv[];
991: {
992:
993: if (argc < 2) {
994: strcat(line, " ");
995: printf("(directory-name) ");
996: gets(&line[strlen(line)]);
997: makeargv();
998: argc = margc;
999: argv = margv;
1000: }
1001: if (argc < 2) {
1002: printf("%s directory-name\n", argv[0]);
1003: return;
1004: }
1005: domakedir(argv[1]);
1006: }
1007:
1008: /*
1009: * Remove a directory.
1010: */
1011: removedir(argc, argv)
1012: char *argv[];
1013: {
1014:
1015: if (argc < 2) {
1016: strcat(line, " ");
1017: printf("(directory-name) ");
1018: gets(&line[strlen(line)]);
1019: makeargv();
1020: argc = margc;
1021: argv = margv;
1022: }
1023: if (argc < 2) {
1024: printf("%s directory-name\n", argv[0]);
1025: return;
1026: }
1027: doremovedir(argv[1]);
1028: }
1029:
1030: /*
1031: * Terminate session and exit.
1032: */
1033: /*VARARGS*/
1034: quit()
1035: {
1036:
1037: disconnect();
1038: exit(0);
1039: }
1040:
1041: /*
1042: * Terminate session, but don't exit.
1043: */
1044: disconnect()
1045: {
1046: extern FILE *cout;
1047: extern int data;
1048:
1049: if (!connected)
1050: return;
1051: logout();
1052: CourierClose(connected);
1053: connected = (CourierConnection *)0;
1054: }
1055:
1056: confirm(cmd, file)
1057: char *cmd, *file;
1058: {
1059: char line[BUFSIZ];
1060:
1061: if (!interactive) {
1062: if (verbose)
1063: printf("%s %s\n", cmd, file);
1064: return (1);
1065: }
1066: printf("%s %s? ", cmd, file);
1067: fflush(stdout);
1068: gets(line);
1069: return (*line != 'n' && *line != 'N');
1070: }
1071:
1072: fatal(msg)
1073: char *msg;
1074: {
1075:
1076: fprintf(stderr, "ftp: %s\n");
1077: exit(1);
1078: }
1079:
1080: /*
1081: * Glob a local file name specification with
1082: * the expectation of a single return value.
1083: * Can't control multiple values being expanded
1084: * from the expression, we return only the first.
1085: */
1086: globulize(cpp)
1087: char **cpp;
1088: {
1089: char **globbed;
1090:
1091: if (!doglob)
1092: return (1);
1093: globbed = glob(*cpp);
1094: if (globerr != NULL) {
1095: printf("%s: %s\n", *cpp, globerr);
1096: if (globbed)
1097: blkfree(globbed);
1098: return (0);
1099: }
1100: if (globbed) {
1101: *cpp = *globbed++;
1102: /* don't waste too much memory */
1103: if (*globbed)
1104: blkfree(globbed);
1105: }
1106: return (1);
1107: }
1108:
1109: whatis(argc, argv)
1110: int argc;
1111: char *argv[];
1112: {
1113: FILE *fin, *fopen();
1114: int type;
1115: char *typetostring();
1116:
1117: if (argc < 2) {
1118: strcat(line, " ");
1119: printf("(local-file) ");
1120: gets(&line[strlen(line)]);
1121: makeargv();
1122: argc = margc;
1123: argv = margv;
1124: }
1125: if (argc < 2) {
1126: usage:
1127: printf("%s local-file\n", argv[0]);
1128: return;
1129: }
1130:
1131: if ( access(argv[1], R_OK | F_OK ) == -1 ) {
1132: perror("file error: ");
1133: return;
1134: }
1135:
1136: type= get_type(argv[1]);
1137:
1138: printf("file %s is assumed to be %s\n", argv[1], typetostring(type));
1139: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.