/*      $NetBSD: tftp.c,v 1.37 2023/01/06 17:18:56 christos 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
#if 0
static char sccsid[] = "@(#)tftp.c      8.1 (Berkeley) 6/6/93";
#else
__RCSID("$NetBSD: tftp.c,v 1.37 2023/01/06 17:18:56 christos Exp $");
#endif
#endif /* not lint */

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

/*
* TFTP User Program -- Protocol Machines
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>

#include <netinet/in.h>

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

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

#include "extern.h"
#include "tftpsubs.h"

extern jmp_buf  toplevel;

char    ackbuf[PKTSIZE];
int     timeout;
jmp_buf timeoutbuf;

static void nak(int, struct sockaddr *);
static int makerequest(int, const char *, struct tftphdr *, const char *, off_t);
static void printstats(const char *, unsigned long);
static void startclock(void);
static void stopclock(void);
static __dead void timer(int);
static void tpacket(const char *, struct tftphdr *, int);
static int cmpport(struct sockaddr *, struct sockaddr *);

static void get_options(struct tftphdr *, int);
static int tftp_igmp_join(void);
static void tftp_igmp_leave(int);

static void
get_options(struct tftphdr *ap, int size)
{
       unsigned long val;
       char *opt, *endp, *nextopt, *valp;
       int l;

       size -= 2;      /* skip over opcode */
       opt = ap->th_stuff;
       endp = opt + size - 1;
       *endp = '\0';

       while (opt < endp) {
               int ismulticast;
               l = strlen(opt) + 1;
               valp = opt + l;
               ismulticast = !strcasecmp(opt, "multicast");
               if (valp < endp) {
                       val = strtoul(valp, NULL, 10);
                       l = strlen(valp) + 1;
                       nextopt = valp + l;
                       if (!ismulticast) {
                               if (val == ULONG_MAX && errno == ERANGE) {
                                       /* Report illegal value */
                                       opt = nextopt;
                                       continue;
                               }
                       }
               } else {
                       /* Badly formed OACK */
                       break;
               }
               if (strcmp(opt, "tsize") == 0) {
                       /* cool, but we'll ignore it */
               } else if (strcmp(opt, "timeout") == 0) {
                       if (val >= 1 && val <= 255) {
                               rexmtval = val;
                       } else {
                               /* Report error? */
                       }
               } else if (strcmp(opt, "blksize") == 0) {
                       if (val >= 8 && val <= MAXSEGSIZE) {
                               blksize = val;
                       } else {
                               /* Report error? */
                       }
               } else if (ismulticast) {
                       char multicast[24];
                       char *pmulticast;
                       char *addr;

                       strlcpy(multicast, valp, sizeof(multicast));
                       pmulticast = multicast;
                       addr = strsep(&pmulticast, ",");
                       if (pmulticast == NULL)
                               continue; /* Report error? */
                       mcport = atoi(strsep(&pmulticast, ","));
                       if (pmulticast == NULL)
                               continue; /* Report error? */
                       mcmasterslave = atoi(pmulticast);
                       mcaddr = inet_addr(addr);
                       if (mcaddr == INADDR_NONE)
                               continue; /* Report error? */
               } else {
                       /* unknown option */
               }
               opt = nextopt;
       }
}

static int
tftp_igmp_join(void)
{
       struct ip_mreq req;
       struct sockaddr_in s;
       int fd, rv;

       memset(&req, 0, sizeof(struct ip_mreq));
       req.imr_multiaddr.s_addr = mcaddr;
       req.imr_interface.s_addr = INADDR_ANY;

       fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
       if (fd < 0) {
               perror("socket");
               return fd;
       }

       memset(&s, 0, sizeof(struct sockaddr_in));
       s.sin_family = AF_INET;
       s.sin_port = htons(mcport);
       s.sin_len = sizeof(struct sockaddr_in);
       rv = bind(fd, (struct sockaddr *)&s, sizeof(struct sockaddr_in));
       if (rv < 0) {
               perror("bind");
               close(fd);
               return rv;
       }

       rv = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &req,
           sizeof(struct ip_mreq));
       if (rv < 0) {
               perror("setsockopt");
               close(fd);
               return rv;
       }

       return fd;
}

static void
tftp_igmp_leave(int fd)
{
       struct ip_mreq req;
       int rv;

       memset(&req, 0, sizeof(struct ip_mreq));
       req.imr_multiaddr.s_addr = mcaddr;
       req.imr_interface.s_addr = INADDR_ANY;

       rv = setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, &req,
           sizeof(struct ip_mreq));
       if (rv < 0)
               perror("setsockopt");

       close(fd);

       return;
}

/*
* Send the requested file.
*/
void
sendfile(int fd, const char *name, const char *mode)
{
       struct tftphdr *ap;        /* data and ack packets */
       struct tftphdr *dp;
       int j, n;
       volatile unsigned int block;
       volatile int size, convert;
       volatile unsigned long amount;
       struct sockaddr_storage from;
       struct stat sbuf;
       volatile off_t filesize = 0;
       socklen_t fromlen;
       FILE *file;
       struct sockaddr_storage peer;
       struct sockaddr_storage serv;   /* valid server port number */

       startclock();           /* start stat's clock */
       dp = r_init();          /* reset fillbuf/read-ahead code */
       ap = (struct tftphdr *)(void *)ackbuf;
       if (tsize) {
               if (fstat(fd, &sbuf) == 0) {
                       filesize = sbuf.st_size;
               } else {
                       filesize = -1ULL;
               }
       }
       file = fdopen(fd, "r");
       convert = !strcmp(mode, "netascii");
       block = 0;
       amount = 0;
       (void)memcpy(&peer, &peeraddr, (size_t)peeraddr.ss_len);
       (void)memset(&serv, 0, sizeof(serv));

       (void)signal(SIGALRM, timer);
       do {
               if (block == 0)
                       size = makerequest(WRQ, name, dp, mode, filesize) - 4;
               else {
               /*      size = read(fd, dp->th_data, SEGSIZE);   */
                       size = readit(file, &dp, blksize, convert);
                       if (size < 0) {
                               nak(errno + 100,
                                   (struct sockaddr *)(void *)&peer);
                               break;
                       }
                       dp->th_opcode = htons((u_short)DATA);
                       dp->th_block = htons((u_short)block);
               }
               timeout = 0;
               (void) setjmp(timeoutbuf);
send_data:
               if (trace)
                       tpacket("sent", dp, size + 4);
               n = sendto(f, dp, (socklen_t)(size + 4), 0,
                   (struct sockaddr *)(void *)&peer, (socklen_t)peer.ss_len);
               if (n != size + 4) {
                       warn("sendto");
                       goto abort;
               }
               if (block)
                       read_ahead(file, blksize, convert);
               for ( ; ; ) {
                       (void)alarm(rexmtval);
                       do {
                               int curf;
                               fromlen = sizeof(from);
                               if (mcaddr != INADDR_NONE)
                                       curf = mf;
                               else
                                       curf = f;
                               n = recvfrom(curf, ackbuf, sizeof(ackbuf), 0,
                                   (struct sockaddr *)(void *)&from, &fromlen);
                       } while (n <= 0);
                       (void)alarm(0);
                       if (n < 0) {
                               warn("recvfrom");
                               goto abort;
                       }
                       if (!serv.ss_family)
                               serv = from;
                       else if (!cmpport((struct sockaddr *)(void *)&serv,
                           (struct sockaddr *)(void *)&from)) {
                               warn("server port mismatch");
                               goto abort;
                       }
                       peer = from;
                       if (trace)
                               tpacket("received", ap, n);
                       /* should verify packet came from server */
                       ap->th_opcode = ntohs(ap->th_opcode);
                       if (ap->th_opcode == ERROR) {
                               (void)printf("Error code %d: %s\n",
                                   ntohs(ap->th_code), ap->th_msg);
                               goto abort;
                       }
                       if (ap->th_opcode == ACK) {
                               ap->th_block = ntohs(ap->th_block);

                               if (ap->th_block == 0) {
                                       /*
                                        * If the extended options are enabled,
                                        * the server just refused 'em all.
                                        * The only one that _really_
                                        * matters is blksize, but we'll
                                        * clear timeout and mcaddr, too.
                                        */
                                       blksize = def_blksize;
                                       rexmtval = def_rexmtval;
                                       mcaddr = INADDR_NONE;
                               }
                               if (ap->th_block == block) {
                                       break;
                               }
                               /* On an error, try to synchronize
                                * both sides.
                                */
                               j = synchnet(f, blksize+4);
                               if (j && trace) {
                                       (void)printf("discarded %d packets\n",
                                                       j);
                               }
                               if (ap->th_block == (block-1)) {
                                       goto send_data;
                               }
                       }
                       if (ap->th_opcode == OACK) {
                               if (block == 0) {
                                       blksize = def_blksize;
                                       rexmtval = def_rexmtval;
                                       mcaddr = INADDR_NONE;
                                       get_options(ap, n);
                                       break;
                               }
                       }
               }
               if (block > 0)
                       amount += size;
               block++;
       } while ((size_t)size == blksize || block == 1);
abort:
       (void)fclose(file);
       stopclock();
       if (amount > 0)
               printstats("Sent", amount);
}

/*
* Receive a file.
*/
void
recvfile(int fd, const char *name, const char *mode)
{
       struct tftphdr *ap;
       struct tftphdr *dp;
       int j, n;
       volatile int oack = 0;
       volatile unsigned int block;
       volatile int size, firsttrip;
       volatile unsigned long amount;
       struct sockaddr_storage from;
       socklen_t fromlen;
       volatile size_t readlen;
       FILE *file;
       volatile int convert;           /* true if converting crlf -> lf */
       struct sockaddr_storage peer;
       struct sockaddr_storage serv;   /* valid server port number */

       startclock();
       dp = w_init();
       ap = (struct tftphdr *)(void *)ackbuf;
       file = fdopen(fd, "w");
       convert = !strcmp(mode, "netascii");
       block = 1;
       firsttrip = 1;
       amount = 0;
       (void)memcpy(&peer, &peeraddr, (size_t)peeraddr.ss_len);
       (void)memset(&serv, 0, sizeof(serv));

       (void)signal(SIGALRM, timer);
       do {
               if (firsttrip) {
                       size = makerequest(RRQ, name, ap, mode, (off_t)0);
                       readlen = PKTSIZE;
                       firsttrip = 0;
               } else {
                       ap->th_opcode = htons((u_short)ACK);
                       ap->th_block = htons((u_short)(block));
                       readlen = blksize+4;
                       size = 4;
                       block++;
               }
               timeout = 0;
               (void) setjmp(timeoutbuf);
send_ack:
               if (trace)
                       tpacket("sent", ap, size);
               if (sendto(f, ackbuf, (socklen_t)size, 0,
                   (struct sockaddr *)(void *)&peer,
                   (socklen_t)peer.ss_len) != size) {
                       (void)alarm(0);
                       warn("sendto");
                       goto abort;
               }
skip_ack:
               if (write_behind(file, convert) == -1)
                       goto abort;
               for ( ; ; ) {
                       (void)alarm(rexmtval);
                       do  {
                               int readfd;
                               if (mf > 0)
                                       readfd = mf;
                               else
                                       readfd = f;
                               fromlen = sizeof(from);
                               n = recvfrom(readfd, dp, readlen, 0,
                                   (struct sockaddr *)(void *)&from, &fromlen);
                       } while (n <= 0);
                       (void)alarm(0);
                       if (n < 0) {
                               warn("recvfrom");
                               goto abort;
                       }
                       if (!serv.ss_family)
                               serv = from;
                       else if (!cmpport((struct sockaddr *)(void *)&serv,
                           (struct sockaddr *)(void *)&from)) {
                               warn("server port mismatch");
                               goto abort;
                       }
                       peer = from;
                       if (trace)
                               tpacket("received", dp, n);
                       /* should verify client address */
                       dp->th_opcode = ntohs(dp->th_opcode);
                       if (dp->th_opcode == ERROR) {
                               (void)printf("Error code %d: %s\n",
                                   ntohs(dp->th_code), dp->th_msg);
                               goto abort;
                       }
                       if (dp->th_opcode == DATA) {
                               dp->th_block = ntohs(dp->th_block);

                               if (dp->th_block == 1 && !oack) {
                                       /* no OACK, revert to defaults */
                                       blksize = def_blksize;
                                       rexmtval = def_rexmtval;
                               }
                               if (dp->th_block == block) {
                                       break;          /* have next packet */
                               }
                               /* On an error, try to synchronize
                                * both sides.
                                */
                               j = synchnet(f, blksize);
                               if (j && trace) {
                                       (void)printf("discarded %d packets\n",
                                           j);
                               }
                               if (dp->th_block == (block-1)) {
                                       goto send_ack;  /* resend ack */
                               }
                       }
                       if (dp->th_opcode == OACK) {
                               if (block == 1) {
                                       oack = 1;
                                       blksize = def_blksize;
                                       rexmtval = def_rexmtval;
                                       get_options(dp, n);
                                       ap->th_opcode = htons(ACK);
                                       ap->th_block = 0;
                                       readlen = blksize+4;
                                       size = 4;
                                       if (mcaddr != INADDR_NONE) {
                                               mf = tftp_igmp_join();
                                               if (mf < 0)
                                                       goto abort;
                                               if (mcmasterslave == 0)
                                                       goto skip_ack;
                                       }
                                       goto send_ack;
                               }
                       }
               }
       /*      size = write(fd, dp->th_data, n - 4); */
               size = writeit(file, &dp, n - 4, convert);
               if (size < 0) {
                       nak(errno + 100, (struct sockaddr *)(void *)&peer);
                       break;
               }
               amount += size;
       } while ((size_t)size == blksize);
abort:                                          /* ok to ack, since user */
       ap->th_opcode = htons((u_short)ACK);    /* has seen err msg */
       ap->th_block = htons((u_short)block);
       if (mcaddr != INADDR_NONE && mf >= 0) {
               tftp_igmp_leave(mf);
               mf = -1;
       }
       (void) sendto(f, ackbuf, 4, 0, (struct sockaddr *)(void *)&peer,
           (socklen_t)peer.ss_len);
       /*
        * flush last buffer
        * We do not check for failure because last buffer
        * can be empty, thus returning an error.
        * XXX maybe we should fix 'write_behind' instead.
        */
       (void)write_behind(file, convert);
       (void)fclose(file);
       stopclock();
       if (amount > 0)
               printstats("Received", amount);
}

static int
makerequest(int request, const char *name, struct tftphdr *tp, const char *mode,
       off_t filesize)
{
       char *cp;

       tp->th_opcode = htons((u_short)request);
#ifndef __SVR4
       cp = tp->th_stuff;
#else
       cp = (void *)&tp->th_stuff;
#endif
       (void)strcpy(cp, name);
       cp += strlen(name);
       *cp++ = '\0';
       (void)strcpy(cp, mode);
       cp += strlen(mode);
       *cp++ = '\0';
       if (tsize) {
               (void)strcpy(cp, "tsize");
               cp += strlen(cp);
               *cp++ = '\0';
               (void)sprintf(cp, "%lu", (unsigned long) filesize);
               cp += strlen(cp);
               *cp++ = '\0';
       }
       if (tout) {
               (void)strcpy(cp, "timeout");
               cp += strlen(cp);
               *cp++ = '\0';
               (void)sprintf(cp, "%d", rexmtval);
               cp += strlen(cp);
               *cp++ = '\0';
       }
       if (blksize != SEGSIZE) {
               (void)strcpy(cp, "blksize");
               cp += strlen(cp);
               *cp++ = '\0';
               (void)sprintf(cp, "%zd", blksize);
               cp += strlen(cp);
               *cp++ = '\0';
       }
       return (cp - (char *)(void *)tp);
}

const struct errmsg {
       int     e_code;
       const char *e_msg;
} errmsgs[] = {
       { EUNDEF,       "Undefined error code" },
       { ENOTFOUND,    "File not found" },
       { EACCESS,      "Access violation" },
       { ENOSPACE,     "Disk full or allocation exceeded" },
       { EBADOP,       "Illegal TFTP operation" },
       { EBADID,       "Unknown transfer ID" },
       { EEXISTS,      "File already exists" },
       { ENOUSER,      "No such user" },
       { EOPTNEG,      "Option negotiation failed" },
       { -1,           0 }
};

/*
* Send a nak packet (error message).
* Error code passed in is one of the
* standard TFTP codes, or a UNIX errno
* offset by 100.
*/
static void
nak(int error, struct sockaddr *peer)
{
       const struct errmsg *pe;
       struct tftphdr *tp;
       int length;
       size_t msglen;

       tp = (struct tftphdr *)(void *)ackbuf;
       tp->th_opcode = htons((u_short)ERROR);
       msglen = sizeof(ackbuf) - (&tp->th_msg[0] - ackbuf);
       for (pe = errmsgs; pe->e_code >= 0; pe++)
               if (pe->e_code == error)
                       break;
       if (pe->e_code < 0) {
               tp->th_code = EUNDEF;
               (void)strlcpy(tp->th_msg, strerror(error - 100), msglen);
       } else {
               tp->th_code = htons((u_short)error);
               (void)strlcpy(tp->th_msg, pe->e_msg, msglen);
       }
       length = strlen(tp->th_msg);
       msglen = &tp->th_msg[length + 1] - ackbuf;
       if (trace)
               tpacket("sent", tp, (int)msglen);
       if ((size_t)sendto(f, ackbuf, msglen, 0, peer, (socklen_t)peer->sa_len) != msglen)
               warn("nak");
}

static void
tpacket(const char *s, struct tftphdr *tp, int n)
{
       static const char *opcodes[] =
          { "#0", "RRQ", "WRQ", "DATA", "ACK", "ERROR", "OACK" };
       char *cp, *file, *endp, *opt = NULL;
       const char *spc;
       u_short op = ntohs(tp->th_opcode);
       int i, o;

       if (op < RRQ || op > OACK)
               (void)printf("%s opcode=%x ", s, op);
       else
               (void)printf("%s %s ", s, opcodes[op]);
       switch (op) {

       case RRQ:
       case WRQ:
               n -= 2;
#ifndef __SVR4
               cp = tp->th_stuff;
#else
               cp = (void *) &tp->th_stuff;
#endif
               endp = cp + n - 1;
               if (*endp != '\0') {    /* Shouldn't happen, but... */
                       *endp = '\0';
               }
               file = cp;
               cp = strchr(cp, '\0') + 1;
               (void)printf("<file=%s, mode=%s", file, cp);
               cp = strchr(cp, '\0') + 1;
               o = 0;
               while (cp < endp) {
                       i = strlen(cp) + 1;
                       if (o) {
                               (void)printf(", %s=%s", opt, cp);
                       } else {
                               opt = cp;
                       }
                       o = (o+1) % 2;
                       cp += i;
               }
               (void)printf(">\n");
               break;

       case DATA:
               (void)printf("<block=%d, %d bytes>\n", ntohs(tp->th_block),
                   n - 4);
               break;

       case ACK:
               (void)printf("<block=%d>\n", ntohs(tp->th_block));
               break;

       case ERROR:
               (void)printf("<code=%d, msg=%s>\n", ntohs(tp->th_code),
                   tp->th_msg);
               break;

       case OACK:
               o = 0;
               n -= 2;
               cp = tp->th_stuff;
               endp = cp + n - 1;
               if (*endp != '\0') {    /* Shouldn't happen, but... */
                       *endp = '\0';
               }
               (void)printf("<");
               spc = "";
               while (cp < endp) {
                       i = strlen(cp) + 1;
                       if (o) {
                               (void)printf("%s%s=%s", spc, opt, cp);
                               spc = ", ";
                       } else {
                               opt = cp;
                       }
                       o = (o+1) % 2;
                       cp += i;
               }
               (void)printf(">\n");
               break;
       }
}

struct timeval tstart;
struct timeval tstop;

static void
startclock(void)
{

       (void)gettimeofday(&tstart, NULL);
}

static void
stopclock(void)
{

       (void)gettimeofday(&tstop, NULL);
}

static void
printstats(const char *direction, unsigned long amount)
{
       double delta;

       /* compute delta in 1/10's second units */
       delta = ((tstop.tv_sec*10.)+(tstop.tv_usec/100000)) -
               ((tstart.tv_sec*10.)+(tstart.tv_usec/100000));
       delta = delta/10.;      /* back to seconds */
       (void)printf("%s %ld bytes in %.1f seconds", direction, amount, delta);
       if (verbose)
               (void)printf(" [%.0f bits/sec]", (amount*8.)/delta);
       (void)putchar('\n');
}

static void
/*ARGSUSED*/
timer(int sig)
{

       timeout += rexmtval;
       if (timeout >= maxtimeout) {
               (void)printf("Transfer timed out.");
               longjmp(toplevel, -1);
       }
       longjmp(timeoutbuf, 1);
}

static int
cmpport(struct sockaddr *sa, struct sockaddr *sb)
{
       char a[NI_MAXSERV], b[NI_MAXSERV];

       if (getnameinfo(sa, (socklen_t)sa->sa_len, NULL, 0, a, sizeof(a),
           NI_NUMERICSERV))
               return 0;
       if (getnameinfo(sb, (socklen_t)sb->sa_len, NULL, 0, b, sizeof(b),
           NI_NUMERICSERV))
               return 0;
       if (strcmp(a, b) != 0)
               return 0;

       return 1;
}

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.