![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / tftp|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / tftp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)main.c 4.7 (Berkeley) 8/11/83";
3: #endif
4:
5: /*
6: * TFTP User Program -- Command Interface.
7: */
8: #include <sys/types.h>
9: #include <sys/socket.h>
10: #include <sys/file.h>
11:
12: #include <netinet/in.h>
13:
14: #include <signal.h>
15: #include <stdio.h>
16: #include <errno.h>
17: #include <setjmp.h>
18: #include <ctype.h>
19: #include <netdb.h>
20:
21: #define TIMEOUT 5 /* secs between rexmt's */
22:
23: struct sockaddr_in sin;
24: int f;
25: int trace;
26: int verbose;
27: int connected;
28: char mode[32];
29: char line[200];
30: int margc;
31: char *margv[20];
32: char *prompt = "tftp";
33: jmp_buf toplevel;
34: int intr();
35: struct servent *sp;
36:
37: int quit(), help(), setverbose(), settrace(), status();
38: int get(), put(), setpeer(), setmode(), setrexmt(), settimeout();
39:
40: #define HELPINDENT (sizeof("connect"))
41:
42: struct cmd {
43: char *name;
44: char *help;
45: int (*handler)();
46: };
47:
48: char vhelp[] = "toggle verbose mode";
49: char thelp[] = "toggle packet tracing";
50: char chelp[] = "connect to remote tftp";
51: char qhelp[] = "exit tftp";
52: char hhelp[] = "print help information";
53: char shelp[] = "send file";
54: char rhelp[] = "receive file";
55: char mhelp[] = "set file transfer mode";
56: char sthelp[] = "show current status";
57: char xhelp[] = "set per-packet retransmission timeout";
58: char ihelp[] = "set total retransmission timeout";
59:
60: struct cmd cmdtab[] = {
61: { "connect", chelp, setpeer },
62: { "mode", mhelp, setmode },
63: { "put", shelp, put },
64: { "get", rhelp, get },
65: { "quit", qhelp, quit },
66: { "verbose", vhelp, setverbose },
67: { "trace", thelp, settrace },
68: { "status", sthelp, status },
69: { "rexmt", xhelp, setrexmt },
70: { "timeout", ihelp, settimeout },
71: { "?", hhelp, help },
72: 0
73: };
74:
75: struct cmd *getcmd();
76: char *tail();
77: char *index();
78: char *rindex();
79:
80: main(argc, argv)
81: char *argv[];
82: {
83: struct sockaddr_in sin;
84: int top;
85:
86: sp = getservbyname("tftp", "udp");
87: if (sp == 0) {
88: fprintf(stderr, "tftp: udp/tftp: unknown service\n");
89: exit(1);
90: }
91: f = socket(AF_INET, SOCK_DGRAM, 0, 0);
92: if (f < 0) {
93: perror("tftp: socket");
94: exit(3);
95: }
96: bzero((char *)&sin, sizeof (sin));
97: sin.sin_family = AF_INET;
98: if (bind(f, &sin, sizeof (sin)) < 0) {
99: perror("tftp: bind");
100: exit(1);
101: }
102: strcpy(mode, "netascii");
103: signal(SIGINT, intr);
104: if (argc > 1) {
105: if (setjmp(toplevel) != 0)
106: exit(0);
107: setpeer(argc, argv);
108: }
109: top = setjmp(toplevel) == 0;
110: for (;;)
111: command(top);
112: }
113:
114: char *hostname;
115: char hnamebuf[32];
116:
117: setpeer(argc, argv)
118: int argc;
119: char *argv[];
120: {
121: register int c;
122: struct hostent *host;
123:
124: if (argc < 2) {
125: strcpy(line, "Connect ");
126: printf("(to) ");
127: gets(&line[strlen(line)]);
128: makeargv();
129: argc = margc;
130: argv = margv;
131: }
132: if (argc > 3) {
133: printf("usage: %s host-name [port]\n", argv[0]);
134: return;
135: }
136: host = gethostbyname(argv[1]);
137: if (host) {
138: sin.sin_family = host->h_addrtype;
139: bcopy(host->h_addr, &sin.sin_addr, host->h_length);
140: hostname = host->h_name;
141: } else {
142: sin.sin_family = AF_INET;
143: sin.sin_addr.s_addr = inet_addr(argv[1]);
144: if (sin.sin_addr.s_addr == -1) {
145: connected = 0;
146: printf("%s: unknown host\n", argv[1]);
147: return;
148: }
149: strcpy(hnamebuf, argv[1]);
150: hostname = hnamebuf;
151: }
152: sin.sin_port = sp->s_port;
153: if (argc == 3) {
154: sin.sin_port = atoi(argv[2]);
155: if (sin.sin_port < 0) {
156: printf("%s: bad port number\n", argv[2]);
157: connected = 0;
158: return;
159: }
160: sin.sin_port = htons((u_short)sin.sin_port);
161: }
162: connected = 1;
163: }
164:
165: struct modes {
166: char *m_name;
167: char *m_mode;
168: } modes[] = {
169: { "ascii", "netascii" },
170: { "binary", "octect" },
171: { "mail", "mail" },
172: { 0, 0 }
173: };
174:
175: setmode(argc, argv)
176: char *argv[];
177: {
178: register struct modes *p;
179:
180: if (argc > 2) {
181: char *sep;
182:
183: printf("usage: %s [", argv[0]);
184: sep = " ";
185: for (p = modes; p->m_name; p++) {
186: printf("%s%s", sep, p->m_name);
187: if (*sep == ' ')
188: sep = " | ";
189: }
190: printf(" ]\n");
191: return;
192: }
193: if (argc < 2) {
194: printf("Using %s mode to transfer files.\n", mode);
195: return;
196: }
197: for (p = modes; p->m_name; p++)
198: if (strcmp(argv[1], p->m_name) == 0)
199: break;
200: if (p->m_name)
201: strcpy(mode, p->m_mode);
202: else
203: printf("%s: unknown mode\n", argv[1]);
204: }
205:
206: /*
207: * Send file(s).
208: */
209: put(argc, argv)
210: char *argv[];
211: {
212: int fd;
213: register int n, addr;
214: register char *cp, *targ;
215:
216: if (argc < 2) {
217: strcpy(line, "send ");
218: printf("(file) ");
219: gets(&line[strlen(line)]);
220: makeargv();
221: argc = margc;
222: argv = margv;
223: }
224: if (argc < 2) {
225: putusage(argv[0]);
226: return;
227: }
228: targ = argv[argc - 1];
229: if (index(argv[argc - 1], ':')) {
230: char *cp;
231: struct hostent *hp;
232:
233: for (n = 1; n < argc - 1; n++)
234: if (index(argv[n], ':')) {
235: putusage(argv[0]);
236: return;
237: }
238: cp = argv[argc - 1];
239: targ = index(cp, ':');
240: *targ++ = 0;
241: hp = gethostbyname(cp);
242: if (hp == 0) {
243: printf("%s: Unknown host.\n", cp);
244: return;
245: }
246: bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
247: sin.sin_family = hp->h_addrtype;
248: connected = 1;
249: hostname = hp->h_name;
250: }
251: if (!connected) {
252: printf("No target machine specified.\n");
253: return;
254: }
255: if (argc < 4) {
256: cp = argc == 2 ? tail(targ) : argv[1];
257: fd = open(cp, O_RDONLY);
258: if (fd < 0) {
259: fprintf(stderr, "tftp: "); perror(cp);
260: return;
261: }
262: sendfile(fd, targ);
263: return;
264: }
265: cp = index(targ, '\0');
266: *cp++ = '/';
267: for (n = 1; n < argc - 1; n++) {
268: strcpy(cp, tail(argv[n]));
269: fd = open(argv[n], O_RDONLY);
270: if (fd < 0) {
271: fprintf(stderr, "tftp: "); perror(argv[n]);
272: continue;
273: }
274: sendfile(fd, targ);
275: }
276: }
277:
278: putusage(s)
279: char *s;
280: {
281: printf("usage: %s file ... host:target, or\n", s);
282: printf(" %s file ... target (when already connected)\n", s);
283: }
284:
285: /*
286: * Receive file(s).
287: */
288: get(argc, argv)
289: char *argv[];
290: {
291: int fd;
292: register int n, addr;
293: register char *cp;
294: char *src;
295:
296: if (argc < 2) {
297: strcpy(line, "get ");
298: printf("(files) ");
299: gets(&line[strlen(line)]);
300: makeargv();
301: argc = margc;
302: argv = margv;
303: }
304: if (argc < 2) {
305: getusage(argv[0]);
306: return;
307: }
308: if (!connected)
309: for (n = 1; n < argc - 1; n++)
310: if (index(argv[n], ':') == 0) {
311: getusage(argv[0]);
312: return;
313: }
314: for (n = 1; argc == 2 || n < argc - 1; n++) {
315: src = index(argv[n], ':');
316: if (src == NULL)
317: src = argv[n];
318: else {
319: struct hostent *hp;
320:
321: *src++ = 0;
322: hp = gethostbyname(argv[n]);
323: if (hp == 0) {
324: printf("%s: Unknown host.\n", argv[n]);
325: continue;
326: }
327: bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
328: sin.sin_family = hp->h_addrtype;
329: connected = 1;
330: hostname = hp->h_name;
331: }
332: if (argc < 4) {
333: cp = argc == 3 ? argv[2] : tail(src);
334: fd = creat(cp, 0644);
335: if (fd < 0) {
336: fprintf(stderr, "tftp: "); perror(cp);
337: return;
338: }
339: recvfile(fd, src);
340: break;
341: }
342: cp = index(argv[argc - 1], '\0');
343: *cp++ = '/';
344: strcpy(cp, tail(src));
345: fd = creat(src, 0644);
346: if (fd < 0) {
347: fprintf(stderr, "tftp: "); perror(src);
348: continue;
349: }
350: recvfile(fd, src);
351: }
352: }
353:
354: getusage(s)
355: {
356: printf("usage: %s host:file host:file ... file, or\n", s);
357: printf(" %s file file ... file if connected\n", s);
358: }
359:
360: int rexmtval = TIMEOUT;
361:
362: setrexmt(argc, argv)
363: char *argv[];
364: {
365: int t;
366:
367: if (argc < 2) {
368: strcpy(line, "Rexmt-timeout ");
369: printf("(value) ");
370: gets(&line[strlen(line)]);
371: makeargv();
372: argc = margc;
373: argv = margv;
374: }
375: if (argc != 2) {
376: printf("usage: %s value\n", argv[0]);
377: return;
378: }
379: t = atoi(argv[1]);
380: if (t < 0)
381: printf("%s: bad value\n", t);
382: else
383: rexmtval = t;
384: }
385:
386: int maxtimeout = 5 * TIMEOUT;
387:
388: settimeout(argc, argv)
389: char *argv[];
390: {
391: int t;
392:
393: if (argc < 2) {
394: strcpy(line, "Maximum-timeout ");
395: printf("(value) ");
396: gets(&line[strlen(line)]);
397: makeargv();
398: argc = margc;
399: argv = margv;
400: }
401: if (argc != 2) {
402: printf("usage: %s value\n", argv[0]);
403: return;
404: }
405: t = atoi(argv[1]);
406: if (t < 0)
407: printf("%s: bad value\n", t);
408: else
409: maxtimeout = t;
410: }
411:
412: status(argc, argv)
413: char *argv[];
414: {
415: if (connected)
416: printf("Connected to %s.\n", hostname);
417: else
418: printf("Not connected.\n");
419: printf("Mode: %s Verbose: %s Tracing: %s\n", mode,
420: verbose ? "on" : "off", trace ? "on" : "off");
421: printf("Rexmt-interval: %d seconds, Max-timeout: %d seconds\n",
422: rexmtval, maxtimeout);
423: }
424:
425: intr()
426: {
427:
428: longjmp(toplevel, -1);
429: }
430:
431: char *
432: tail(filename)
433: char *filename;
434: {
435: register char *s;
436:
437: while (*filename) {
438: s = rindex(filename, '/');
439: if (s == NULL)
440: break;
441: if (s[1])
442: return (s + 1);
443: *s = '\0';
444: }
445: return (filename);
446: }
447:
448: /*
449: * Command parser.
450: */
451: command(top)
452: int top;
453: {
454: register struct cmd *c;
455:
456: if (!top)
457: putchar('\n');
458: for (;;) {
459: printf("%s> ", prompt);
460: if (gets(line) == 0)
461: continue;
462: if (line[0] == 0)
463: continue;
464: makeargv();
465: c = getcmd(margv[0]);
466: if (c == (struct cmd *)-1) {
467: printf("?Ambiguous command\n");
468: continue;
469: }
470: if (c == 0) {
471: printf("?Invalid command\n");
472: continue;
473: }
474: (*c->handler)(margc, margv);
475: }
476: }
477:
478: struct cmd *
479: getcmd(name)
480: register char *name;
481: {
482: register char *p, *q;
483: register struct cmd *c, *found;
484: register int nmatches, longest;
485:
486: longest = 0;
487: nmatches = 0;
488: found = 0;
489: for (c = cmdtab; p = c->name; c++) {
490: for (q = name; *q == *p++; q++)
491: if (*q == 0) /* exact match? */
492: return (c);
493: if (!*q) { /* the name was a prefix */
494: if (q - name > longest) {
495: longest = q - name;
496: nmatches = 1;
497: found = c;
498: } else if (q - name == longest)
499: nmatches++;
500: }
501: }
502: if (nmatches > 1)
503: return ((struct cmd *)-1);
504: return (found);
505: }
506:
507: /*
508: * Slice a string up into argc/argv.
509: */
510: makeargv()
511: {
512: register char *cp;
513: register char **argp = margv;
514:
515: margc = 0;
516: for (cp = line; *cp;) {
517: while (isspace(*cp))
518: cp++;
519: if (*cp == '\0')
520: break;
521: *argp++ = cp;
522: margc += 1;
523: while (*cp != '\0' && !isspace(*cp))
524: cp++;
525: if (*cp == '\0')
526: break;
527: *cp++ = '\0';
528: }
529: *argp++ = 0;
530: }
531:
532: /*VARARGS*/
533: quit()
534: {
535: exit(0);
536: }
537:
538: /*
539: * Help command.
540: */
541: help(argc, argv)
542: int argc;
543: char *argv[];
544: {
545: register struct cmd *c;
546:
547: if (argc == 1) {
548: printf("Commands may be abbreviated. Commands are:\n\n");
549: for (c = cmdtab; c->name; c++)
550: printf("%-*s\t%s\n", HELPINDENT, c->name, c->help);
551: return;
552: }
553: while (--argc > 0) {
554: register char *arg;
555: arg = *++argv;
556: c = getcmd(arg);
557: if (c == (struct cmd *)-1)
558: printf("?Ambiguous help command %s\n", arg);
559: else if (c == (struct cmd *)0)
560: printf("?Invalid help command %s\n", arg);
561: else
562: printf("%s\n", c->help);
563: }
564: }
565:
566: /*
567: * Call routine with argc, argv set from args (terminated by 0).
568: */
569: /* VARARGS2 */
570: call(routine, args)
571: int (*routine)();
572: int args;
573: {
574: register int *argp;
575: register int argc;
576:
577: for (argc = 0, argp = &args; *argp++ != 0; argc++)
578: ;
579: (*routine)(argc, &args);
580: }
581:
582: /*VARARGS*/
583: settrace()
584: {
585: trace = !trace;
586: printf("Packet tracing %s.\n", trace ? "on" : "off");
587: }
588:
589: /*VARARGS*/
590: setverbose()
591: {
592: verbose = !verbose;
593: printf("Verbose mode %s.\n", verbose ? "on" : "off");
594: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.