lib/libstand/tftp.c

   1 /*      $NetBSD: tftp.c,v 1.4 1997/09/17 16:57:07 drochner Exp $         */
   2
   3 /*
   4  * Copyright (c) 1996
   5  *      Matthias Drochner.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed for the NetBSD Project
  18  *      by Matthias Drochner.
  19  * 4. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * $FreeBSD: src/lib/libstand/tftp.c,v 1.2.6.4 2001/07/14 14:00:03 mikeh Exp $
  34  */
  35
  36 /*
  37  * Simple TFTP implementation for libsa.
  38  * Assumes:
  39  *  - socket descriptor (int) at open_file->f_devdata
  40  *  - server host IP in global servip
  41  * Restrictions:
  42  *  - read only
  43  *  - lseek only with SEEK_SET or SEEK_CUR
  44  *  - no big time differences between transfers (<tftp timeout)
  45  */
  46
  47 #include <sys/param.h>
  48 #include <sys/stat.h>
  49 #include <netinet/in.h>
  50 #include <netinet/udp.h>
  51 #include <netinet/ip.h>
  52 #include <netinet/in_systm.h>
  53 #include <arpa/tftp.h>
  54
  55 #include <string.h>
  56
  57 #include "stand.h"
  58 #include "net.h"
  59 #include "netif.h"
  60
  61 #include "tftp.h"
  62
  63 static int      tftp_open(const char *path, struct open_file *f);
  64 static int      tftp_close(struct open_file *f);
  65 static int      tftp_read(struct open_file *f, void *buf, size_t size, size_t *resid);
  66 static int      tftp_write(struct open_file *f, void *buf, size_t size, size_t *resid);
  67 static off_t    tftp_seek(struct open_file *f, off_t offset, int where);
  68 static int      tftp_stat(struct open_file *f, struct stat *sb);
  69
  70 struct fs_ops tftp_fsops = {
  71         "tftp",
  72         tftp_open,
  73         tftp_close,
  74         tftp_read,
  75         tftp_write,
  76         tftp_seek,
  77         tftp_stat,
  78         null_readdir
  79 };
  80
  81 extern struct in_addr servip;
  82
  83 static int      tftpport = 2000;
  84
  85 #define RSPACE 520              /* max data packet, rounded up */
  86
  87 struct tftp_handle {
  88         struct iodesc  *iodesc;
  89         int             currblock;      /* contents of lastdata */
  90         int             islastblock;    /* flag */
  91         int             validsize;
  92         int             off;
  93         char           *path;   /* saved for re-requests */
  94         struct {
  95                 u_char header[HEADER_SIZE];
  96                 struct tftphdr t;
  97                 u_char space[RSPACE];
  98         } __packed __aligned(4) lastdata;
  99 };
 100
 101 static int tftperrors[8] = {
 102         0,                      /* ??? */
 103         ENOENT,
 104         EPERM,
 105         ENOSPC,
 106         EINVAL,                 /* ??? */
 107         EINVAL,                 /* ??? */
 108         EEXIST,
 109         EINVAL                  /* ??? */
 110 };
 111
 112 static ssize_t
 113 recvtftp(struct iodesc *d, void *pkt, size_t max_len, time_t tleft)
 114 {
 115         struct tftphdr *t;
 116         ssize_t len;
 117         ssize_t tmp_len;
 118
 119         /*
 120          * Note: errno of 0 with -1 return means udp poll failed or
 121          * packet was not for us.
 122          *
 123          * We may end up broadcasting the initial TFTP request.  Take the
 124          * first DATA result and save any ERROR result in case we do not
 125          * get a DATA.
 126          */
 127         errno = 0;
 128         bzero(pkt, max_len);
 129         if (d->xid == 1) {
 130                 len = -1;
 131                 while ((tmp_len = readudp(d, pkt, max_len, tleft)) > 0) {
 132                         len = tmp_len;
 133                         t = (struct tftphdr *)pkt;
 134                         if (ntohs(t->th_opcode) == DATA)
 135                                 break;
 136                 }
 137         } else {
 138                 len = readudp(d, pkt, max_len, tleft);
 139         }
 140         if ((int)len < (int)sizeof(*t))
 141                 return (-1);
 142         t = (struct tftphdr *)pkt;
 143         errno = 0;
 144
 145         switch (ntohs(t->th_opcode)) {
 146         case DATA: {
 147                 int got;
 148
 149                 if (htons(t->th_block) != d->xid) {
 150                         /*
 151                          * Expected block?
 152                          */
 153                         return (-1);
 154                 }
 155                 if (d->xid == 1) {
 156                         /*
 157                          * First data packet from new port.  Set destip in
 158                          * case we got replies from multiple hosts, so only
 159                          * one host is selected.
 160                          */
 161                         struct udphdr *uh;
 162                         struct ip *ip;
 163
 164                         uh = (struct udphdr *) pkt - 1;
 165                         ip = (struct ip *)uh - 1;
 166                         d->destport = uh->uh_sport;
 167                         d->destip = ip->ip_src;
 168                 } /* else check uh_sport has not changed??? */
 169                 got = len - (t->th_data - (char *)t);
 170                 return got;
 171         }
 172         case ERROR:
 173                 if ((unsigned) ntohs(t->th_code) >= 8) {
 174                         printf("illegal tftp error %d\n", ntohs(t->th_code));
 175                         errno = EIO;
 176                 } else {
 177 #ifdef DEBUG
 178                         printf("tftp-error %d\n", ntohs(t->th_code));
 179 #endif
 180                         errno = tftperrors[ntohs(t->th_code)];
 181                 }
 182                 return (-1);
 183         default:
 184 #ifdef DEBUG
 185                 printf("tftp type %d not handled\n", ntohs(t->th_opcode));
 186 #endif
 187                 return (-1);
 188         }
 189 }
 190
 191 /* send request, expect first block (or error) */
 192 static int
 193 tftp_makereq(struct tftp_handle *h)
 194 {
 195         struct {
 196                 u_char header[HEADER_SIZE];
 197                 struct tftphdr  t;
 198                 u_char space[FNAME_SIZE + 6];
 199         } __packed __aligned(4) wbuf;
 200         char           *wtail;
 201         int             l;
 202         ssize_t         res;
 203         struct tftphdr *t;
 204
 205         wbuf.t.th_opcode = htons((u_short) RRQ);
 206         wtail = wbuf.t.th_stuff;
 207         l = strlen(h->path);
 208         bcopy(h->path, wtail, l + 1);
 209         wtail += l + 1;
 210         bcopy("octet", wtail, 6);
 211         wtail += 6;
 212
 213         t = &h->lastdata.t;
 214
 215         /* h->iodesc->myport = htons(--tftpport); */
 216         h->iodesc->myport = htons(tftpport + (getsecs() & 0x3ff));
 217         h->iodesc->destport = htons(IPPORT_TFTP);
 218         h->iodesc->xid = 1;     /* expected block */
 219
 220         res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *) &wbuf.t,
 221                        recvtftp, t, sizeof(*t) + RSPACE);
 222
 223         if (res == -1)
 224                 return (errno);
 225
 226         h->currblock = 1;
 227         h->validsize = res;
 228         h->islastblock = 0;
 229         if (res < SEGSIZE)
 230                 h->islastblock = 1;     /* very short file */
 231         return (0);
 232 }
 233
 234 /* ack block, expect next */
 235 static int
 236 tftp_getnextblock(struct tftp_handle *h)
 237 {
 238         struct {
 239                 u_char header[HEADER_SIZE];
 240                 struct tftphdr t;
 241         } __packed __aligned(4) wbuf;
 242         char           *wtail;
 243         int             res;
 244         struct tftphdr *t;
 245
 246         /*
 247          * Ack previous block
 248          */
 249         wbuf.t.th_opcode = htons((u_short) ACK);
 250         wtail = (char *) &wbuf.t.th_block;
 251         wbuf.t.th_block = htons((u_short) h->currblock);
 252         wtail += 2;
 253
 254         t = &h->lastdata.t;
 255
 256         h->iodesc->xid = h->currblock + 1;      /* expected block */
 257
 258         res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *) &wbuf.t,
 259                        recvtftp, t, sizeof(*t) + RSPACE);
 260
 261         if (res == -1)          /* 0 is OK! */
 262                 return (errno);
 263
 264         h->currblock++;
 265         h->validsize = res;
 266         if (res < SEGSIZE)
 267                 h->islastblock = 1;     /* EOF */
 268         return (0);
 269 }
 270
 271 static int
 272 tftp_open(const char *path, struct open_file *f)
 273 {
 274         struct tftp_handle *tftpfile;
 275         struct iodesc  *io;
 276         int             res;
 277
 278         /* Avoid trying out tftp_open for disk devices in the EFI loader */
 279 #ifndef __i386__
 280         if (strcmp(f->f_dev->dv_name, "net") != 0)
 281                 return (EINVAL);
 282 #endif
 283
 284         tftpfile = (struct tftp_handle *) malloc(sizeof(*tftpfile));
 285         if (!tftpfile)
 286                 return (ENOMEM);
 287
 288         tftpfile->iodesc = io = socktodesc(*(int *) (f->f_devdata));
 289         if (io == NULL) {
 290                 free(tftpfile);
 291                 return (EINVAL);
 292         }
 293
 294         io->destip = servip;
 295         tftpfile->off = 0;
 296         tftpfile->path = strdup(path);
 297         if (tftpfile->path == NULL) {
 298             free(tftpfile);
 299             return(ENOMEM);
 300         }
 301
 302         res = tftp_makereq(tftpfile);
 303
 304         if (res) {
 305                 free(tftpfile->path);
 306                 free(tftpfile);
 307                 return (res);
 308         }
 309         f->f_fsdata = (void *) tftpfile;
 310         return (0);
 311 }
 312
 313 /*
 314  * Parameters:
 315  *      resid:  out
 316  */
 317 static int
 318 tftp_read(struct open_file *f, void *addr, size_t size, size_t *resid)
 319 {
 320         struct tftp_handle *tftpfile;
 321         static int      tc = 0;
 322         tftpfile = (struct tftp_handle *) f->f_fsdata;
 323
 324         while (size > 0) {
 325                 int needblock, count;
 326
 327                 if (!(tc++ % 16))
 328                         twiddle();
 329
 330                 needblock = tftpfile->off / SEGSIZE + 1;
 331
 332                 if (tftpfile->currblock > needblock)    /* seek backwards */
 333                         tftp_makereq(tftpfile); /* no error check, it worked
 334                                                  * for open */
 335
 336                 while (tftpfile->currblock < needblock) {
 337                         int res;
 338
 339                         res = tftp_getnextblock(tftpfile);
 340                         if (res) {      /* no answer */
 341 #ifdef DEBUG
 342                                 printf("tftp: read error\n");
 343 #endif
 344                                 return (res);
 345                         }
 346                         if (tftpfile->islastblock)
 347                                 break;
 348                 }
 349
 350                 if (tftpfile->currblock == needblock) {
 351                         int offinblock, inbuffer;
 352
 353                         offinblock = tftpfile->off % SEGSIZE;
 354
 355                         inbuffer = tftpfile->validsize - offinblock;
 356                         if (inbuffer < 0) {
 357 #ifdef DEBUG
 358                                 printf("tftp: invalid offset %d\n",
 359                                     tftpfile->off);
 360 #endif
 361                                 return (EINVAL);
 362                         }
 363                         count = (size < inbuffer ? size : inbuffer);
 364                         bcopy(tftpfile->lastdata.t.th_data + offinblock,
 365                               addr, count);
 366
 367                         addr = (char *)addr + count;
 368                         tftpfile->off += count;
 369                         size -= count;
 370
 371                         if ((tftpfile->islastblock) && (count == inbuffer))
 372                                 break;  /* EOF */
 373                 } else {
 374 #ifdef DEBUG
 375                         printf("tftp: block %d not found\n", needblock);
 376 #endif
 377                         return (EINVAL);
 378                 }
 379
 380         }
 381
 382         if (resid)
 383                 *resid = size;
 384         return (0);
 385 }
 386
 387 static int
 388 tftp_close(struct open_file *f)
 389 {
 390         struct tftp_handle *tftpfile;
 391         tftpfile = (struct tftp_handle *) f->f_fsdata;
 392
 393         /* let it time out ... */
 394         f->f_fsdata = NULL;
 395         if (tftpfile) {
 396                 free(tftpfile->path);
 397                 free(tftpfile);
 398                 f->f_fsdata = NULL;
 399         }
 400         return (0);
 401 }
 402
 403 /*
 404  * Parameters:
 405  *      resid:  out
 406  */
 407 static int
 408 tftp_write(struct open_file *f, void *start, size_t size, size_t *resid)
 409 {
 410         return (EROFS);
 411 }
 412
 413 static int
 414 tftp_stat(struct open_file *f, struct stat *sb)
 415 {
 416         sb->st_mode = 0444 | S_IFREG;
 417         sb->st_nlink = 1;
 418         sb->st_uid = 0;
 419         sb->st_gid = 0;
 420         sb->st_size = -1;
 421         return (0);
 422 }
 423
 424 static off_t
 425 tftp_seek(struct open_file *f, off_t offset, int where)
 426 {
 427         struct tftp_handle *tftpfile;
 428         tftpfile = (struct tftp_handle *) f->f_fsdata;
 429
 430         switch (where) {
 431         case SEEK_SET:
 432                 tftpfile->off = offset;
 433                 break;
 434         case SEEK_CUR:
 435                 tftpfile->off += offset;
 436                 break;
 437         default:
 438                 errno = EOFFSET;
 439                 return (-1);
 440         }
 441         return (tftpfile->off);
 442 }