root/lib/libsa/tftp.c

DEFINITIONS

1. recvtftp
2. tftp_makereq
3. tftp_getnextblock
4. tftp_terminate
5. tftp_open
6. tftp_read
7. tftp_close
8. tftp_write
9. tftp_stat
10. tftp_seek
11. tftp_readdir

    1 /*      $OpenBSD: tftp.c,v 1.2 2004/04/02 04:39:51 deraadt Exp $        */
    2 /*      $NetBSD: tftp.c,v 1.15 2003/08/18 15:45:29 dsl Exp $     */
    4 /*
    5  * Copyright (c) 1996
    6  *      Matthias Drochner.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  */
   29 /*
   30  * Simple TFTP implementation for libsa.
   31  * Assumes:
   32  *  - socket descriptor (int) at open_file->f_devdata
   33  *  - server host IP in global servip
   34  * Restrictions:
   35  *  - read only
   36  *  - lseek only with SEEK_SET or SEEK_CUR
   37  *  - no big time differences between transfers (<tftp timeout)
   38  */
   40 /*
   41  * XXX Does not currently implement:
   42  * XXX
   43  * XXX LIBSA_NO_FS_CLOSE
   44  * XXX LIBSA_NO_FS_SEEK
   45  * XXX LIBSA_NO_FS_WRITE
   46  * XXX LIBSA_NO_FS_SYMLINK (does this even make sense?)
   47  * XXX LIBSA_FS_SINGLECOMPONENT (does this even make sense?)
   48  */
   50 #include <sys/types.h>
   51 #include <sys/stat.h>
   52 #include <netinet/in.h>
   53 #include <netinet/udp.h>
   54 #include <netinet/in_systm.h>
   55 #include <lib/libkern/libkern.h>
   57 #include "stand.h"
   58 #include "net.h"
   59 #include "netif.h"
   61 #include "tftp.h"
   63 extern struct in_addr servip;
   65 static int      tftpport = 2000;
   67 #define RSPACE 520              /* max data packet, rounded up */
   69 struct tftp_handle {
   70         struct iodesc  *iodesc;
   71         int             currblock;      /* contents of lastdata */
   72         int             islastblock;    /* flag */
   73         int             validsize;
   74         int             off;
   75         const char     *path;   /* saved for re-requests */
   76         struct {
u_char header[HEADER_SIZE];
   78                 struct tftphdr t;
u_char space[RSPACE];
   80         } lastdata;
   81 };
   83 static const int tftperrors[8] = {
   84         0,                      /* ??? */
ENOENT,
EPERM,
ENOSPC,
EINVAL,                 /* ??? */
EINVAL,                 /* ??? */
EEXIST,
EINVAL                  /* ??? */
   92 };
ssize_t recvtftp(struct iodesc *, void *, size_t, time_t);
   95 int tftp_makereq(struct tftp_handle *);
   96 int tftp_getnextblock(struct tftp_handle *);
   97 #ifndef TFTP_NOTERMINATE
   98 void tftp_terminate(struct tftp_handle *);
   99 #endif
ssize_t
recvtftp(struct iodesc *d, void *pkt, size_t len, time_t tleft)
  103 {
ssize_t n;
  105         struct tftphdr *t;
errno = 0;
n = readudp(d, pkt, len, tleft);
  111         if (n < 4)
  112                 return -1;
t = (struct tftphdr *) pkt;
  115         switch (ntohs(t->th_opcode)) {
  116         case DATA:
  117                 if (htons(t->th_block) != d->xid) {
  118                         /*
  119                          * Expected block?
  120                          */
  121                         return -1;
  122                 }
  123                 if (d->xid == 1) {
  124                         /*
  125                          * First data packet from new port.
  126                          */
  127                         struct udphdr *uh;
uh = (struct udphdr *) pkt - 1;
d->destport = uh->uh_sport;
  130                 } /* else check uh_sport has not changed??? */
  131                 return (n - (t->th_data - (char *)t));
  132         case ERROR:
  133                 if ((unsigned) ntohs(t->th_code) >= 8) {
printf("illegal tftp error %d\n", ntohs(t->th_code));
errno = EIO;
  136                 } else {
  137 #ifdef DEBUG
printf("tftp-error %d\n", ntohs(t->th_code));
  139 #endif
errno = tftperrors[ntohs(t->th_code)];
  141                 }
  142                 return -1;
  143         default:
  144 #ifdef DEBUG
printf("tftp type %d not handled\n", ntohs(t->th_opcode));
  146 #endif
  147                 return -1;
  148         }
  149 }
  151 /* send request, expect first block (or error) */
  152 int
tftp_makereq(struct tftp_handle *h)
  154 {
  155         struct {
u_char header[HEADER_SIZE];
  157                 struct tftphdr  t;
u_char space[FNAME_SIZE + 6];
  159         } wbuf;
  160         char           *wtail;
  161         int             l;
ssize_t         res;
  163         struct tftphdr *t;
bzero(&wbuf, sizeof(wbuf));
wbuf.t.th_opcode = htons((u_short) RRQ);
wtail = wbuf.t.th_stuff;
l = strlen(h->path);
bcopy(h->path, wtail, l + 1);
wtail += l + 1;
bcopy("octet", wtail, 6);
wtail += 6;
t = &h->lastdata.t;
  177         /* 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);
  185         if (res == -1)
  186                 return errno;
h->currblock = 1;
h->validsize = res;
h->islastblock = 0;
  191         if (res < SEGSIZE)
h->islastblock = 1;     /* very short file */
  193         return 0;
  194 }
  196 /* ack block, expect next */
  197 int
tftp_getnextblock(struct tftp_handle *h)
  199 {
  200         struct {
u_char header[HEADER_SIZE];
  202                 struct tftphdr t;
  203         } wbuf;
  204         char           *wtail;
  205         int             res;
  206         struct tftphdr *t;
bzero(&wbuf, sizeof(wbuf));
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);
  221         if (res == -1)          /* 0 is OK! */
  222                 return errno;
h->currblock++;
h->validsize = res;
  226         if (res < SEGSIZE)
h->islastblock = 1;     /* EOF */
  228         return 0;
  229 }
  231 #ifndef TFTP_NOTERMINATE
  232 void
tftp_terminate(struct tftp_handle *h)
  234 {
  235         struct {
u_char header[HEADER_SIZE];
  237                 struct tftphdr t;
  238         } wbuf;
  239         char           *wtail;
bzero(&wbuf, sizeof(wbuf));
  243         if (h->islastblock) {
wbuf.t.th_opcode = htons((u_short) ACK);
wbuf.t.th_block = htons((u_short) h->currblock);
  246         } else {
wbuf.t.th_opcode = htons((u_short) ERROR);
wbuf.t.th_code = htons((u_short) ENOSPACE); /* ??? */
  249         }
wtail = (char *) &wbuf.t.th_data;
  252         (void) sendudp(h->iodesc, &wbuf.t, wtail - (char *) &wbuf.t);
  253 }
  254 #endif
  256 int
tftp_open(char *path, struct open_file *f)
  258 {
  259         struct tftp_handle *tftpfile;
  260         struct iodesc  *io;
  261         int             res;
tftpfile = (struct tftp_handle *) alloc(sizeof(*tftpfile));
  264         if (tftpfile == NULL)
  265                 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);
  274         if (res) {
free(tftpfile, sizeof(*tftpfile));
  276                 return res;
  277         }
f->f_fsdata = (void *) tftpfile;
  279         return 0;
  280 }
  282 int
tftp_read(struct open_file *f, void *addr, size_t size, size_t *resid)
  284 {
  285         struct tftp_handle *tftpfile;
  286 #if !defined(LIBSA_NO_TWIDDLE)
  287         static int tc = 0;
  288 #endif
tftpfile = (struct tftp_handle *) f->f_fsdata;
  291         while (size > 0) {
  292                 int needblock;
size_t count;
needblock = tftpfile->off / SEGSIZE + 1;
  297                 if (tftpfile->currblock > needblock) {  /* seek backwards */
  298 #ifndef TFTP_NOTERMINATE
tftp_terminate(tftpfile);
  300 #endif
  301                         /* Don't bother to check retval: it worked for open() */
tftp_makereq(tftpfile);
  303                 }
  305                 while (tftpfile->currblock < needblock) {
  306                         int res;
  308 #if !defined(LIBSA_NO_TWIDDLE)
  309                         if ((tc++ % 16) == 0)
twiddle();
  311 #endif
res = tftp_getnextblock(tftpfile);
  313                         if (res) {      /* no answer */
  314 #ifdef DEBUG
printf("tftp: read error (block %d->%d)\n",
tftpfile->currblock, needblock);
  317 #endif
  318                                 return res;
  319                         }
  320                         if (tftpfile->islastblock)
  321                                 break;
  322                 }
  324                 if (tftpfile->currblock == needblock) {
size_t offinblock, inbuffer;
offinblock = tftpfile->off % SEGSIZE;
inbuffer = tftpfile->validsize - offinblock;
  330                         if (inbuffer < 0) {
  331 #ifdef DEBUG
printf("tftp: invalid offset %d\n",
tftpfile->off);
  334 #endif
  335                                 return EINVAL;
  336                         }
count = (size < inbuffer ? size : inbuffer);
bcopy(tftpfile->lastdata.t.th_data + offinblock,
addr, count);
addr = (caddr_t)addr + count;
tftpfile->off += count;
size -= count;
  345                         if ((tftpfile->islastblock) && (count == inbuffer))
  346                                 break;  /* EOF */
  347                 } else {
  348 #ifdef DEBUG
printf("tftp: block %d not found\n", needblock);
  350 #endif
  351                         return EINVAL;
  352                 }
  354         }
  356         if (resid != NULL)
  357                 *resid = size;
  358         return 0;
  359 }
  361 int
tftp_close(struct open_file *f)
  363 {
  364         struct tftp_handle *tftpfile;
tftpfile = (struct tftp_handle *) f->f_fsdata;
  367 #ifdef TFTP_NOTERMINATE
  368         /* let it time out ... */
  369 #else
tftp_terminate(tftpfile);
  371 #endif
free(tftpfile, sizeof(*tftpfile));
  374         return 0;
  375 }
  377 int
tftp_write(struct open_file *f, void *start, size_t size, size_t *resid)
  379 {
  380         return EROFS;
  381 }
  383 int
tftp_stat(struct open_file *f, struct stat *sb)
  385 {
  386         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 = -1;
  395         return 0;
  396 }
off_t
tftp_seek(struct open_file *f, off_t offset, int where)
  400 {
  401         struct tftp_handle *tftpfile;
tftpfile = (struct tftp_handle *) f->f_fsdata;
  404         switch (where) {
  405         case SEEK_SET:
tftpfile->off = offset;
  407                 break;
  408         case SEEK_CUR:
tftpfile->off += offset;
  410                 break;
  411         default:
errno = EOFFSET;
  413                 return -1;
  414         }
  416         return (tftpfile->off);
  417 }
  419 /*
  420  * Not implemented.
  421  */
  422 #ifndef NO_READDIR
  423 int
tftp_readdir(struct open_file *f, char *name)
  425 {
  426         return EROFS;
  427 }
  428 #endif