/*      $NetBSD: main.c,v 1.32 2012/07/16 09:20:26 he Exp $     */

/*
* Copyright (c) 1983, 1993
*      The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1983, 1993\
The Regents of the University of California.  All rights reserved.");
#if 0
static char sccsid[] = "@(#)main.c      8.1 (Berkeley) 6/6/93";
#else
__RCSID("$NetBSD: main.c,v 1.32 2012/07/16 09:20:26 he Exp $");
#endif
#endif /* not lint */

/* Many bug fixes are from Jim Guyton <guyton@rand-unix> */

/*
* TFTP User Program -- Command Interface.
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>
#include <arpa/tftp.h>

#include <ctype.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <netdb.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "extern.h"

#define TIMEOUT         5               /* secs between rexmt's */
#define LBUFLEN         200             /* size of input buffer */

struct  sockaddr_storage peeraddr;
int     f;
int     mf;
int     trace;
int     verbose;
int     tsize=0;
int     tout=0;
size_t  def_blksize = SEGSIZE;
size_t  blksize = SEGSIZE;
in_addr_t       mcaddr = INADDR_NONE;
uint16_t        mcport;
u_int   def_rexmtval = TIMEOUT;
u_int   rexmtval = TIMEOUT;
ushort  mcmasterslave;
int     maxtimeout = 5 * TIMEOUT;

jmp_buf toplevel;

static int      connected;
static char     mode[32];
static char     line[LBUFLEN];
static int      margc;
static char     *margv[20];
static const    char *prompt = "tftp";
static char    hostname[MAXHOSTNAMELEN];

static void     get(int, char **);
static void     help(int, char **);
static void     modecmd(int, char **);
static void     put(int, char **);
static __dead void quit(int, char **);
static void     setascii(int, char **);
static void     setbinary(int, char **);
static void     setpeer0(const char *, const char *);
static void     setpeer(int, char **);
static void     setrexmt(int, char **);
static void     settimeout(int, char **);
static void     settrace(int, char **);
static void     setverbose(int, char **);
static void     setblksize(int, char **);
static void     settsize(int, char **);
static void     settimeoutopt(int, char **);
static void     status(int, char **);
static char     *tail(char *);
static __dead void intr(int);
static const    struct cmd *getcmd(const char *);

static __dead void command(void);

static void getUsage(char *);
static void makeargv(void);
static void putUsage(const char *);
static void settftpmode(const char *);

#define HELPINDENT sizeof("connect")

struct cmd {
       const char *name;
       const char *help;
       void    (*handler)(int, char **);
};

static const char vhelp[] = "toggle verbose mode";
static const char thelp[] = "toggle packet tracing";
static const char tshelp[] = "toggle extended tsize option";
static const char tohelp[] = "toggle extended timeout option";
static const char blhelp[] = "set an alternative blocksize (def. 512)";
static const char chelp[] = "connect to remote tftp";
static const char qhelp[] = "exit tftp";
static const char hhelp[] = "print help information";
static const char shelp[] = "send file";
static const char rhelp[] = "receive file";
static const char mhelp[] = "set file transfer mode";
static const char sthelp[] = "show current status";
static const char xhelp[] = "set per-packet retransmission timeout";
static const char ihelp[] = "set total retransmission timeout";
static const char ashelp[] = "set mode to netascii";
static const char bnhelp[] = "set mode to octet";

static const struct cmd cmdtab[] = {
       { "connect",    chelp,          setpeer },
       { "mode",       mhelp,          modecmd },
       { "put",        shelp,          put },
       { "get",        rhelp,          get },
       { "quit",       qhelp,          quit },
       { "verbose",    vhelp,          setverbose },
       { "blksize",    blhelp,         setblksize },
       { "tsize",      tshelp,         settsize },
       { "trace",      thelp,          settrace },
       { "status",     sthelp,         status },
       { "binary",     bnhelp,         setbinary },
       { "ascii",      ashelp,         setascii },
       { "rexmt",      xhelp,          setrexmt },
       { "timeout",    ihelp,          settimeout },
       { "tout",       tohelp,         settimeoutopt },
       { "?",          hhelp,          help },
       { .name = NULL }
};

static struct   modes {
       const char *m_name;
       const char *m_mode;
} modes[] = {
       { "ascii",      "netascii" },
       { "netascii",   "netascii" },
       { "binary",     "octet" },
       { "image",      "octet" },
       { "octet",     "octet" },
/*      { "mail",       "mail" },       */
       { 0,            0 }
};

int
main(int argc, char *argv[])
{
       int     c;

       f = mf = -1;
       (void)strlcpy(mode, "netascii", sizeof(mode));
       (void)signal(SIGINT, intr);

       setprogname(argv[0]);
       while ((c = getopt(argc, argv, "e")) != -1) {
               switch (c) {
               case 'e':
                       blksize = MAXSEGSIZE;
                       (void)strlcpy(mode, "octet", sizeof(mode));
                       tsize = 1;
                       tout = 1;
                       break;
               default:
                       (void)fprintf(stderr,
                           "Usage: %s [-e] host-name [port]\n", getprogname());
                       exit(1);
               }
       }
       argc -= optind;
       argv += optind;

       if (argc >= 1) {
               if (setjmp(toplevel) != 0)
                       exit(0);
               argc++;
               argv--;
               setpeer(argc, argv);
       }
       if (setjmp(toplevel) != 0)
               (void)putchar('\n');
       command();
       return 0;
}

static void
getmore(const char *cmd, const char *prm)
{
       (void)strlcpy(line, cmd, sizeof(line));
       (void)printf("%s", prm);
       (void)fgets(&line[strlen(line)], (int)(LBUFLEN-strlen(line)), stdin);
       makeargv();
}

static void
setpeer0(const char *host, const char *port)
{
       struct addrinfo hints, *res0, *res;
       int error, soopt;
       struct sockaddr_storage ss;
       const char *cause = "unknown";

       if (connected) {
               (void)close(f);
               f = -1;
       }
       connected = 0;

       (void)memset(&hints, 0, sizeof(hints));
       hints.ai_family = PF_UNSPEC;
       hints.ai_socktype = SOCK_DGRAM;
       hints.ai_protocol = IPPROTO_UDP;
       hints.ai_flags = AI_CANONNAME;
       if (!port)
               port = "tftp";
       error = getaddrinfo(host, port, &hints, &res0);
       if (error) {
               warnx("%s", gai_strerror(error));
               return;
       }

       for (res = res0; res; res = res->ai_next) {
               if (res->ai_addrlen > sizeof(peeraddr))
                       continue;
               f = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
               if (f == -1) {
                       cause = "socket";
                       continue;
               }

               (void)memset(&ss, 0, sizeof(ss));
               ss.ss_family = res->ai_family;
               ss.ss_len = res->ai_addrlen;
               if (bind(f, (struct sockaddr *)(void *)&ss,
                   (socklen_t)ss.ss_len) == -1) {
                       cause = "bind";
                       (void)close(f);
                       f = -1;
                       continue;
               }

               break;
       }

       if (f >= 0) {
               soopt = 65536;
               if (setsockopt(f, SOL_SOCKET, SO_SNDBUF, &soopt, sizeof(soopt))
                   == -1) {
                       (void)close(f);
                       f = -1;
                       cause = "setsockopt SNDBUF";
               }
               else if (setsockopt(f, SOL_SOCKET, SO_RCVBUF, &soopt,
                   sizeof(soopt)) == -1) {
                       (void)close(f);
                       f = -1;
                       cause = "setsockopt RCVBUF";
               }
       }

       if (f == -1 || res == NULL)
               warn("%s", cause);
       else {
               /* res->ai_addr <= sizeof(peeraddr) is guaranteed */
               (void)memcpy(&peeraddr, res->ai_addr, res->ai_addrlen);
               if (res->ai_canonname) {
                       (void)strlcpy(hostname, res->ai_canonname,
                           sizeof(hostname));
               } else
                       (void)strlcpy(hostname, host, sizeof(hostname));
               connected = 1;
       }

       freeaddrinfo(res0);
}

static void
setpeer(int argc, char *argv[])
{

       if (argc < 2) {
               getmore("Connect ", "(to) ");
               argc = margc;
               argv = margv;
       }
       if (argc < 2 || argc > 3) {
               (void)printf("Usage: %s [-e] host-name [port]\n",
                   getprogname());
               return;
       }
       if (argc == 2)
               setpeer0(argv[1], NULL);
       else
               setpeer0(argv[1], argv[2]);
}

static void
modecmd(int argc, char *argv[])
{
       struct modes *p;
       const char *sep;

       if (argc < 2) {
               (void)printf("Using %s mode to transfer files.\n", mode);
               return;
       }
       if (argc == 2) {
               for (p = modes; p->m_name; p++)
                       if (strcmp(argv[1], p->m_name) == 0)
                               break;
               if (p->m_name) {
                       settftpmode(p->m_mode);
                       return;
               }
               (void)printf("%s: unknown mode\n", argv[1]);
               /* drop through and print Usage message */
       }

       (void)printf("Usage: %s [", argv[0]);
       sep = " ";
       for (p = modes; p->m_name; p++) {
               (void)printf("%s%s", sep, p->m_name);
               if (*sep == ' ')
                       sep = " | ";
       }
       (void)printf(" ]\n");
       return;
}

static void
/*ARGSUSED*/
setbinary(int argc, char *argv[])
{

       settftpmode("octet");
}

static void
/*ARGSUSED*/
setascii(int argc, char *argv[])
{

       settftpmode("netascii");
}

static void
settftpmode(const char *newmode)
{
       (void)strlcpy(mode, newmode, sizeof(mode));
       if (verbose)
               (void)printf("mode set to %s\n", mode);
}


/*
* Send file(s).
*/
static void
put(int argc, char *argv[])
{
       int fd;
       int n;
       char *targ, *p;

       if (argc < 2) {
               getmore("send ", "(file) ");
               argc = margc;
               argv = margv;
       }
       if (argc < 2) {
               putUsage(argv[0]);
               return;
       }
       targ = argv[argc - 1];
       if (strrchr(argv[argc - 1], ':')) {
               char *cp;

               for (n = 1; n < argc - 1; n++)
                       if (strchr(argv[n], ':')) {
                               putUsage(argv[0]);
                               return;
                       }
               cp = argv[argc - 1];
               targ = strrchr(cp, ':');
               *targ++ = 0;
               if (cp[0] == '[' && cp[strlen(cp) - 1] == ']') {
                       cp[strlen(cp) - 1] = '\0';
                       cp++;
               }
               setpeer0(cp, NULL);
       }
       if (!connected) {
               (void)printf("No target machine specified.\n");
               return;
       }
       if (argc < 4) {
               char *cp = argc == 2 ? tail(targ) : argv[1];
               fd = open(cp, O_RDONLY);
               if (fd == -1) {
                       warn("%s", cp);
                       return;
               }
               if (verbose)
                       (void)printf("putting %s to %s:%s [%s]\n",
                               cp, hostname, targ, mode);
               sendfile(fd, targ, mode);
               return;
       }
                               /* this assumes the target is a directory */
                               /* on a remote unix system.  hmmmm.  */
       p = strchr(targ, '\0');
       *p++ = '/';
       for (n = 1; n < argc - 1; n++) {
               (void)strcpy(p, tail(argv[n]));
               fd = open(argv[n], O_RDONLY);
               if (fd == -1) {
                       warn("%s", argv[n]);
                       continue;
               }
               if (verbose)
                       (void)printf("putting %s to %s:%s [%s]\n",
                               argv[n], hostname, targ, mode);
               sendfile(fd, targ, mode);
       }
}

static void
putUsage(const char *s)
{
       (void)printf("Usage: %s file ... host:target, or\n", s);
       (void)printf("       %s file ... target (when already connected)\n", s);
}

/*
* Receive file(s).
*/
static void
get(int argc, char *argv[])
{
       int fd;
       int n;
       char *p;
       char *src;

       if (argc < 2) {
               getmore("get ", "(files) ");
               argc = margc;
               argv = margv;
       }
       if (argc < 2) {
               getUsage(argv[0]);
               return;
       }
       if (!connected) {
               for (n = 1; n < argc ; n++)
                       if (strrchr(argv[n], ':') == 0) {
                               getUsage(argv[0]);
                               return;
                       }
       }
       for (n = 1; n < argc ; n++) {
               src = strrchr(argv[n], ':');
               if (src == NULL)
                       src = argv[n];
               else {
                       char *cp;
                       *src++ = 0;
                       cp = argv[n];
                       if (cp[0] == '[' && cp[strlen(cp) - 1] == ']') {
                               cp[strlen(cp) - 1] = '\0';
                               cp++;
                       }
                       setpeer0(cp, NULL);
                       if (!connected)
                               continue;
               }
               if (argc < 4) {
                       char *cp = argc == 3 ? argv[2] : tail(src);
                       fd = creat(cp, 0644);
                       if (fd == -1) {
                               warn("%s", cp);
                               return;
                       }
                       if (verbose)
                               (void)printf("getting from %s:%s to %s [%s]\n",
                                       hostname, src, cp, mode);
                       recvfile(fd, src, mode);
                       break;
               }
               p = tail(src);         /* new .. jdg */
               fd = creat(p, 0644);
               if (fd == -1) {
                       warn("%s", p);
                       continue;
               }
               if (verbose)
                       (void)printf("getting from %s:%s to %s [%s]\n",
                               hostname, src, p, mode);
               recvfile(fd, src, mode);
       }
}

static void
getUsage(char *s)
{
       (void)printf("Usage: %s host:file host:file ... file, or\n", s);
       (void)printf("       %s file file ... file if connected\n", s);
}

void
setblksize(int argc, char *argv[])
{
       int t;

       if (argc < 2) {
               getmore("blksize ", "(blksize) ");
               argc = margc;
               argv = margv;
       }
       if (argc != 2) {
               (void)printf("Usage: %s value\n", argv[0]);
               return;
       }
       t = atoi(argv[1]);
       if (t < 8 || t > 65464)
               (void)printf("%s: bad value\n", argv[1]);
       else
               blksize = t;
}

static void
setrexmt(int argc, char *argv[])
{
       int t;

       if (argc < 2) {
               getmore("Rexmt-timeout ", "(value) ");
               argc = margc;
               argv = margv;
       }
       if (argc != 2) {
               (void)printf("Usage: %s value\n", argv[0]);
               return;
       }
       t = atoi(argv[1]);
       if (t < 0)
               (void)printf("%s: bad value\n", argv[1]);
       else
               rexmtval = t;
}

static void
settimeout(int argc, char *argv[])
{
       int t;

       if (argc < 2) {
               getmore("Maximum-timeout ", "(value) ");
               argc = margc;
               argv = margv;
       }
       if (argc != 2) {
               (void)printf("Usage: %s value\n", argv[0]);
               return;
       }
       t = atoi(argv[1]);
       if (t < 0)
               (void)printf("%s: bad value\n", argv[1]);
       else
               maxtimeout = t;
}

static void
/*ARGSUSED*/
status(int argc, char *argv[])
{
       if (connected)
               (void)printf("Connected to %s.\n", hostname);
       else
               (void)printf("Not connected.\n");
       (void)printf("Mode: %s Verbose: %s Tracing: %s\n", mode,
               verbose ? "on" : "off", trace ? "on" : "off");
       (void)printf("Rexmt-interval: %d seconds, Max-timeout: %d seconds\n",
               rexmtval, maxtimeout);
}

static void
/*ARGSUSED*/
intr(int dummy)
{

       (void)signal(SIGALRM, SIG_IGN);
       (void)alarm(0);
       longjmp(toplevel, -1);
}

static char *
tail(char *filename)
{
       char *s;

       while (*filename) {
               s = strrchr(filename, '/');
               if (s == NULL)
                       break;
               if (s[1])
                       return s + 1;
               *s = '\0';
       }
       return filename;
}

/*
* Command parser.
*/
static __dead void
command(void)
{
       const struct cmd *c;

       for (;;) {
               (void)printf("%s> ", prompt);
               if (fgets(line, LBUFLEN, stdin) == NULL) {
                       if (feof(stdin)) {
                               exit(0);
                       } else {
                               continue;
                       }
               }
               if (line[0] == '\0' || line[0] == '\n')
                       continue;
               makeargv();
               if (margc == 0)
                       continue;
               c = getcmd(margv[0]);
               if (c == (struct cmd *)-1) {
                       (void)printf("?Ambiguous command\n");
                       continue;
               }
               if (c == 0) {
                       (void)printf("?Invalid command\n");
                       continue;
               }
               (*c->handler)(margc, margv);
       }
}

static const struct cmd *
getcmd(const char *name)
{
       const char *p, *q;
       const struct cmd *c, *found;
       int nmatches, longest;

       longest = 0;
       nmatches = 0;
       found = 0;
       for (c = cmdtab; (p = c->name) != NULL; c++) {
               for (q = name; *q == *p++; q++)
                       if (*q == 0)            /* exact match? */
                               return c;
               if (!*q) {                      /* the name was a prefix */
                       if (q - name > longest) {
                               longest = q - name;
                               nmatches = 1;
                               found = c;
                       } else if (q - name == longest)
                               nmatches++;
               }
       }
       if (nmatches > 1)
               return (struct cmd *)-1;
       return found;
}

/*
* Slice a string up into argc/argv.
*/
static void
makeargv(void)
{
       char *cp;
       char **argp = margv;

       margc = 0;
       for (cp = line; *cp;) {
               while (isspace((unsigned char)*cp))
                       cp++;
               if (*cp == '\0')
                       break;
               *argp++ = cp;
               margc += 1;
               while (*cp != '\0' && !isspace((unsigned char)*cp))
                       cp++;
               if (*cp == '\0')
                       break;
               *cp++ = '\0';
       }
       *argp++ = NULL;
}

static void
/*ARGSUSED*/
quit(int argc, char *argv[])
{

       exit(0);
}

/*
* Help command.
*/
static void
help(int argc, char *argv[])
{
       const struct cmd *c;

       if (argc == 1) {
               (void)printf("Commands may be abbreviated.  Commands are:\n\n");
               for (c = cmdtab; c->name; c++)
                       (void)printf("%-*s\t%s\n", (int)HELPINDENT, c->name,
                           c->help);
               return;
       }
       while (--argc > 0) {
               char *arg;
               arg = *++argv;
               c = getcmd(arg);
               if (c == (struct cmd *)-1)
                       (void)printf("?Ambiguous help command %s\n", arg);
               else if (c == NULL)
                       (void)printf("?Invalid help command %s\n", arg);
               else
                       (void)printf("%s\n", c->help);
       }
}

static void
/*ARGSUSED*/
settrace(int argc, char **argv)
{
       trace = !trace;
       (void)printf("Packet tracing %s.\n", trace ? "on" : "off");
}

static void
/*ARGSUSED*/
setverbose(int argc, char **argv)
{
       verbose = !verbose;
       (void)printf("Verbose mode %s.\n", verbose ? "on" : "off");
}

static void
/*ARGSUSED*/
settsize(int argc, char **argv)
{
       tsize = !tsize;
       (void)printf("Tsize mode %s.\n", tsize ? "on" : "off");
}

static void
/*ARGSUSED*/
settimeoutopt(int argc, char **argv)
{
       tout = !tout;
       (void)printf("Timeout option %s.\n", tout ? "on" : "off");
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.