/*      $NetBSD: tftp.c,v 1.38 2022/08/07 05:51:55 rin Exp $     */

/*
* Copyright (c) 1996
*      Matthias Drochner.  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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*
*/

/*
* Simple TFTP implementation for libsa.
* Assumes:
*  - socket descriptor (int) at open_file->f_devdata
*  - server host IP in global servip
* Restrictions:
*  - read only
*  - lseek only with SEEK_SET or SEEK_CUR
*  - no big time differences between transfers (<tftp timeout)
*/

/*
* XXX Does not currently implement:
* XXX
* XXX LIBSA_NO_FS_CLOSE
* XXX LIBSA_NO_FS_SEEK
* XXX LIBSA_NO_FS_WRITE
* XXX LIBSA_NO_FS_SYMLINK (does this even make sense?)
* XXX LIBSA_FS_SINGLECOMPONENT (does this even make sense?)
*/

#include <sys/types.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <netinet/udp.h>
#include <netinet/in_systm.h>
#include <lib/libkern/libkern.h>

#include "stand.h"
#include "net.h"

#include "tftp.h"

extern struct in_addr servip;

static int      tftpport = 2000;

#define RSPACE 520              /* max data packet, rounded up */

struct tftp_handle {
       struct iodesc  *iodesc;
       int             currblock;      /* contents of lastdata */
       int             islastblock;    /* flag */
       int             validsize;
       int             off;
       const char     *path;   /* saved for re-requests */
       struct {
               u_char header[UDP_TOTAL_HEADER_SIZE];
               struct tftphdr t;
               u_char space[RSPACE];
       } lastdata;
};

static const int tftperrors[8] = {
       0,                      /* ??? */
       ENOENT,
       EPERM,
       ENOSPC,
       EINVAL,                 /* ??? */
       EINVAL,                 /* ??? */
       EEXIST,
       EINVAL,                 /* ??? */
};

static ssize_t recvtftp(struct iodesc *, void *, size_t, saseconds_t);
static int tftp_makereq(struct tftp_handle *);
static int tftp_getnextblock(struct tftp_handle *);
#ifndef TFTP_NOTERMINATE
static void tftp_terminate(struct tftp_handle *);
#endif
static ssize_t tftp_size_of_file(struct tftp_handle *tftpfile);

static ssize_t
recvtftp(struct iodesc *d, void *pkt, size_t len, saseconds_t tleft)
{
       ssize_t n;
       struct tftphdr *t;

       errno = 0;

       n = readudp(d, pkt, len, tleft);

       if (n < 4)
               return -1;

       t = (struct tftphdr *)pkt;
       switch (ntohs(t->th_opcode)) {
       case DATA:
               if (ntohs(t->th_block) != d->xid) {
                       /*
                        * Expected block?
                        */
                       return -1;
               }
               if (d->xid == 1) {
                       /*
                        * First data packet from new port.
                        */
                       struct udphdr *uh;
                       uh = (struct udphdr *)pkt - 1;
                       d->destport = uh->uh_sport;
               } /* else check uh_sport has not changed??? */
               return (n - (t->th_data - (char *)t));
       case ERROR:
               if ((unsigned int)ntohs(t->th_code) >= 8) {
                       printf("illegal tftp error %d\n", ntohs(t->th_code));
                       errno = EIO;
               } else {
#ifdef DEBUG
                       printf("tftp-error %d\n", ntohs(t->th_code));
#endif
                       errno = tftperrors[ntohs(t->th_code)];
               }
               return -1;
       default:
#ifdef DEBUG
               printf("tftp type %d not handled\n", ntohs(t->th_opcode));
#endif
               return -1;
       }
}

/* send request, expect first block (or error) */
static int
tftp_makereq(struct tftp_handle *h)
{
       struct {
               u_char header[UDP_TOTAL_HEADER_SIZE];
               struct tftphdr t;
               u_char space[FNAME_SIZE + 6];
       } wbuf;
       char           *wtail;
       int             l;
       ssize_t         res;
       struct tftphdr *t;

       wbuf.t.th_opcode = htons((u_short)RRQ);
       wtail = wbuf.t.th_stuff;
       l = strlen(h->path);
       (void)memcpy(wtail, h->path, l + 1);
       wtail += l + 1;
       (void)memcpy(wtail, "octet", 6);
       wtail += 6;

       t = &h->lastdata.t;

       /* h->iodesc->myport = htons(--tftpport); */
       h->iodesc->myport = htons(tftpport + (getsecs() & 0x3ff));
       h->iodesc->destport = htons(IPPORT_TFTP);
       h->iodesc->xid = 1;     /* expected block */

       res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *)&wbuf.t,
                      recvtftp, t, sizeof(*t) + RSPACE);

       if (res == -1)
               return errno;

       h->currblock = 1;
       h->validsize = res;
       h->islastblock = 0;
       if (res < SEGSIZE)
               h->islastblock = 1;     /* very short file */
       return 0;
}

/* ack block, expect next */
static int
tftp_getnextblock(struct tftp_handle *h)
{
       struct {
               u_char header[UDP_TOTAL_HEADER_SIZE];
               struct tftphdr t;
       } wbuf;
       char           *wtail;
       int             res;
       struct tftphdr *t;

       wbuf.t.th_opcode = htons((u_short)ACK);
       wbuf.t.th_block = htons((u_short)h->currblock);
       wtail = (char *)&wbuf.t.th_data;

       t = &h->lastdata.t;

       h->iodesc->xid = h->currblock + 1;      /* expected block */

       res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *)&wbuf.t,
                      recvtftp, t, sizeof(*t) + RSPACE);

       if (res == -1)          /* 0 is OK! */
               return errno;

       h->currblock++;
       h->validsize = res;
       if (res < SEGSIZE)
               h->islastblock = 1;     /* EOF */
       return 0;
}

#ifndef TFTP_NOTERMINATE
static void
tftp_terminate(struct tftp_handle *h)
{
       struct {
               u_char header[UDP_TOTAL_HEADER_SIZE];
               struct tftphdr t;
       } wbuf;
       char           *wtail;

       wtail = (char *)&wbuf.t.th_data;
       if (h->islastblock) {
               wbuf.t.th_opcode = htons((u_short)ACK);
               wbuf.t.th_block = htons((u_short)h->currblock);
       } else {
               wbuf.t.th_opcode = htons((u_short)ERROR);
               wbuf.t.th_code = htons((u_short)ENOSPACE); /* ??? */
               *wtail++ = '\0'; /* empty error string */
       }

       (void)sendudp(h->iodesc, &wbuf.t, wtail - (char *)&wbuf.t);
}
#endif

__compactcall int
tftp_open(const char *path, struct open_file *f)
{
       struct tftp_handle *tftpfile;
       struct iodesc  *io;
       int             res;

       tftpfile = (struct tftp_handle *)alloc(sizeof(*tftpfile));
       if (!tftpfile)
               return ENOMEM;

       tftpfile->iodesc = io = socktodesc(*(int *)(f->f_devdata));
       io->destip = servip;
       tftpfile->off = 0;
       tftpfile->path = path;  /* XXXXXXX we hope it's static */

       res = tftp_makereq(tftpfile);

       if (res) {
               dealloc(tftpfile, sizeof(*tftpfile));
               return res;
       }
       f->f_fsdata = (void *)tftpfile;
       fsmod = "nfs";
       return 0;
}

__compactcall int
tftp_read(struct open_file *f, void *addr, size_t size, size_t *resid)
{
       struct tftp_handle *tftpfile;
#if !defined(LIBSA_NO_TWIDDLE)
       static int      tc = 0;
#endif
       tftpfile = (struct tftp_handle *)f->f_fsdata;

       while (size > 0) {
               int needblock;
               size_t count;

               needblock = tftpfile->off / SEGSIZE + 1;

               if (tftpfile->currblock > needblock) {  /* seek backwards */
#ifndef TFTP_NOTERMINATE
                       tftp_terminate(tftpfile);
#endif
                       tftp_makereq(tftpfile); /* no error check, it worked
                                                * for open */
               }

               while (tftpfile->currblock < needblock) {
                       int res;

#if !defined(LIBSA_NO_TWIDDLE)
                       if (!(tc++ % 16))
                               twiddle();
#endif

                       res = tftp_getnextblock(tftpfile);
                       if (res) {      /* no answer */
#ifdef DEBUG
                               printf("%s: read error (block %d->%d)\n",
                                   __func__, tftpfile->currblock, needblock);
#endif
                               return res;
                       }
                       if (tftpfile->islastblock)
                               break;
               }

               if (tftpfile->currblock == needblock) {
                       size_t offinblock, inbuffer;

                       offinblock = tftpfile->off % SEGSIZE;

                       if ((int)offinblock > tftpfile->validsize) {
#ifdef DEBUG
                               printf("%s: invalid offset %d\n", __func__,
                                   tftpfile->off);
#endif
                               return EINVAL;
                       }
                       inbuffer = tftpfile->validsize - offinblock;
                       count = (size < inbuffer ? size : inbuffer);
                       (void)memcpy(addr,
                           tftpfile->lastdata.t.th_data + offinblock,
                           count);

                       addr = (char *)addr + count;
                       tftpfile->off += count;
                       size -= count;

                       if ((tftpfile->islastblock) && (count == inbuffer))
                               break;  /* EOF */
               } else {
#ifdef DEBUG
                       printf("%s: block %d not found\n",
                           __func__, needblock);
#endif
                       return EINVAL;
               }

       }

       if (resid)
               *resid = size;
       return 0;
}

__compactcall int
tftp_close(struct open_file *f)
{
       struct tftp_handle *tftpfile;
       tftpfile = (struct tftp_handle *)f->f_fsdata;

#ifdef TFTP_NOTERMINATE
       /* let it time out ... */
#else
       tftp_terminate(tftpfile);
#endif

       dealloc(tftpfile, sizeof(*tftpfile));
       return 0;
}

__compactcall int
tftp_write(struct open_file *f, void *start, size_t size, size_t *resid)
{

       return EROFS;
}

static ssize_t
tftp_size_of_file(struct tftp_handle *tftpfile)
{
       ssize_t filesize;

       if (tftpfile->currblock > 1) {  /* move to start of file */
#ifndef TFTP_NOTERMINATE
               tftp_terminate(tftpfile);
#endif
               tftp_makereq(tftpfile); /* no error check, it worked
                                        * for open */
       }

       /* start with the size of block 1 */
       filesize = tftpfile->validsize;

       /* and keep adding the sizes till we hit the last block */
       while (!tftpfile->islastblock) {
               int res;

               res = tftp_getnextblock(tftpfile);
               if (res) {      /* no answer */
#ifdef DEBUG
                       printf("%s: read error (block %d)\n",
                           __func__, tftpfile->currblock);
#endif
                       return -1;
               }
               filesize += tftpfile->validsize;
       }
#ifdef DEBUG
       printf("%s: file is %zu bytes\n", __func__, filesize);
#endif
       return filesize;
}

__compactcall int
tftp_stat(struct open_file *f, struct stat *sb)
{
       struct tftp_handle *tftpfile;
       tftpfile = (struct tftp_handle *)f->f_fsdata;

       sb->st_mode = 0444;
       sb->st_nlink = 1;
       sb->st_uid = 0;
       sb->st_gid = 0;
       sb->st_size = tftp_size_of_file(tftpfile);
       return 0;
}

#if defined(LIBSA_ENABLE_LS_OP)
#include "ls.h"
__compactcall void
tftp_ls(struct open_file *f, const char *pattern)
{
       lsunsup("tftp");
}
#endif

__compactcall off_t
tftp_seek(struct open_file *f, off_t offset, int where)
{
       struct tftp_handle *tftpfile;
       tftpfile = (struct tftp_handle *)f->f_fsdata;

       switch (where) {
       case SEEK_SET:
               tftpfile->off = offset;
               break;
       case SEEK_CUR:
               tftpfile->off += offset;
               break;
       default:
               errno = EOFFSET;
               return -1;
       }
       return tftpfile->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.