Home | History | Annotate | Line # | Download | only in libsa
tftp.c revision 1.10 
      1 /*	$NetBSD: tftp.c,v 1.10 2000/03/30 12:19:49 augustss 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  */
     34 
     35 /*
     36  * Simple TFTP implementation for libsa.
     37  * Assumes:
     38  *  - socket descriptor (int) at open_file->f_devdata
     39  *  - server host IP in global servip
     40  * Restrictions:
     41  *  - read only
     42  *  - lseek only with SEEK_SET or SEEK_CUR
     43  *  - no big time differences between transfers (<tftp timeout)
     44  */
     45 
     46 /*
     47  * XXX Does not currently implement:
     48  * XXX
     49  * XXX LIBSA_NO_FS_CLOSE
     50  * XXX LIBSA_NO_FS_SEEK
     51  * XXX LIBSA_NO_FS_WRITE
     52  * XXX LIBSA_NO_FS_SYMLINK (does this even make sense?)
     53  * XXX LIBSA_FS_SINGLECOMPONENT (does this even make sense?)
     54  */
     55 
     56 #include <sys/types.h>
     57 #include <sys/stat.h>
     58 #include <netinet/in.h>
     59 #include <netinet/udp.h>
     60 #include <netinet/in_systm.h>
     61 #include <lib/libkern/libkern.h>
     62 #ifdef _STANDALONE
     63 #include "/usr/include/arpa/tftp.h" /* XXX */
     64 #else
     65 #include <arpa/tftp.h>
     66 #endif
     67 
     68 #include "stand.h"
     69 #include "net.h"
     70 #include "netif.h"
     71 
     72 #include "tftp.h"
     73 
     74 extern struct in_addr servip;
     75 
     76 static int      tftpport = 2000;
     77 
     78 #define RSPACE 520		/* max data packet, rounded up */
     79 
     80 struct tftp_handle {
     81 	struct iodesc  *iodesc;
     82 	int             currblock;	/* contents of lastdata */
     83 	int             islastblock;	/* flag */
     84 	int             validsize;
     85 	int             off;
     86 	char           *path;	/* saved for re-requests */
     87 	struct {
     88 		u_char header[HEADER_SIZE];
     89 		struct tftphdr t;
     90 		u_char space[RSPACE];
     91 	} lastdata;
     92 };
     93 
     94 static int tftperrors[8] = {
     95 	0,			/* ??? */
     96 	ENOENT,
     97 	EPERM,
     98 	ENOSPC,
     99 	EINVAL,			/* ??? */
    100 	EINVAL,			/* ??? */
    101 	EEXIST,
    102 	EINVAL			/* ??? */
    103 };
    104 
    105 static ssize_t recvtftp __P((struct iodesc *, void *, size_t, time_t));
    106 static int tftp_makereq __P((struct tftp_handle *));
    107 static int tftp_getnextblock __P((struct tftp_handle *));
    108 #ifndef TFTP_NOTERMINATE
    109 static void tftp_terminate __P((struct tftp_handle *));
    110 #endif
    111 
    112 static ssize_t
    113 recvtftp(d, pkt, len, tleft)
    114 	struct iodesc *d;
    115 	void  *pkt;
    116 	size_t len;
    117 	time_t          tleft;
    118 {
    119 	ssize_t n;
    120 	struct tftphdr *t;
    121 
    122 	errno = 0;
    123 
    124 	n = readudp(d, pkt, len, tleft);
    125 
    126 	if (n < 4)
    127 		return (-1);
    128 
    129 	t = (struct tftphdr *) pkt;
    130 	switch (ntohs(t->th_opcode)) {
    131 	case DATA:
    132 		if (htons(t->th_block) != d->xid) {
    133 			/*
    134 			 * Expected block?
    135 			 */
    136 			return (-1);
    137 		}
    138 		if (d->xid == 1) {
    139 			/*
    140 			 * First data packet from new port.
    141 			 */
    142 			struct udphdr *uh;
    143 			uh = (struct udphdr *) pkt - 1;
    144 			d->destport = uh->uh_sport;
    145 		} /* else check uh_sport has not changed??? */
    146 		return (n - (t->th_data - (char *)t));
    147 	case ERROR:
    148 		if ((unsigned) ntohs(t->th_code) >= 8) {
    149 			printf("illegal tftp error %d\n", ntohs(t->th_code));
    150 			errno = EIO;
    151 		} else {
    152 #ifdef DEBUG
    153 			printf("tftp-error %d\n", ntohs(t->th_code));
    154 #endif
    155 			errno = tftperrors[ntohs(t->th_code)];
    156 		}
    157 		return (-1);
    158 	default:
    159 #ifdef DEBUG
    160 		printf("tftp type %d not handled\n", ntohs(t->th_opcode));
    161 #endif
    162 		return (-1);
    163 	}
    164 }
    165 
    166 /* send request, expect first block (or error) */
    167 static int
    168 tftp_makereq(h)
    169 	struct tftp_handle *h;
    170 {
    171 	struct {
    172 		u_char header[HEADER_SIZE];
    173 		struct tftphdr  t;
    174 		u_char space[FNAME_SIZE + 6];
    175 	} wbuf;
    176 	char           *wtail;
    177 	int             l;
    178 	ssize_t         res;
    179 	struct tftphdr *t;
    180 
    181 	wbuf.t.th_opcode = htons((u_short) RRQ);
    182 	wtail = wbuf.t.th_stuff;
    183 	l = strlen(h->path);
    184 	bcopy(h->path, wtail, l + 1);
    185 	wtail += l + 1;
    186 	bcopy("octet", wtail, 6);
    187 	wtail += 6;
    188 
    189 	t = &h->lastdata.t;
    190 
    191 	/* h->iodesc->myport = htons(--tftpport); */
    192 	h->iodesc->myport = htons(tftpport + (getsecs() & 0x3ff));
    193 	h->iodesc->destport = htons(IPPORT_TFTP);
    194 	h->iodesc->xid = 1;	/* expected block */
    195 
    196 	res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *) &wbuf.t,
    197 		       recvtftp, t, sizeof(*t) + RSPACE);
    198 
    199 	if (res == -1)
    200 		return (errno);
    201 
    202 	h->currblock = 1;
    203 	h->validsize = res;
    204 	h->islastblock = 0;
    205 	if (res < SEGSIZE)
    206 		h->islastblock = 1;	/* very short file */
    207 	return (0);
    208 }
    209 
    210 /* ack block, expect next */
    211 static int
    212 tftp_getnextblock(h)
    213 	struct tftp_handle *h;
    214 {
    215 	struct {
    216 		u_char header[HEADER_SIZE];
    217 		struct tftphdr t;
    218 	} wbuf;
    219 	char           *wtail;
    220 	int             res;
    221 	struct tftphdr *t;
    222 
    223 	wbuf.t.th_opcode = htons((u_short) ACK);
    224 	wbuf.t.th_block = htons((u_short) h->currblock);
    225 	wtail = (char *) &wbuf.t.th_data;
    226 
    227 	t = &h->lastdata.t;
    228 
    229 	h->iodesc->xid = h->currblock + 1;	/* expected block */
    230 
    231 	res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *) &wbuf.t,
    232 		       recvtftp, t, sizeof(*t) + RSPACE);
    233 
    234 	if (res == -1)		/* 0 is OK! */
    235 		return (errno);
    236 
    237 	h->currblock++;
    238 	h->validsize = res;
    239 	if (res < SEGSIZE)
    240 		h->islastblock = 1;	/* EOF */
    241 	return (0);
    242 }
    243 
    244 #ifndef TFTP_NOTERMINATE
    245 static void
    246 tftp_terminate(h)
    247 	struct tftp_handle *h;
    248 {
    249 	struct {
    250 		u_char header[HEADER_SIZE];
    251 		struct tftphdr t;
    252 	} wbuf;
    253 	char           *wtail;
    254 
    255 	if (h->islastblock) {
    256 		wbuf.t.th_opcode = htons((u_short) ACK);
    257 		wbuf.t.th_block = htons((u_short) h->currblock);
    258 	} else {
    259 		wbuf.t.th_opcode = htons((u_short) ERROR);
    260 		wbuf.t.th_code = htons((u_short) ENOSPACE); /* ??? */
    261 	}
    262 	wtail = (char *) &wbuf.t.th_data;
    263 
    264 	(void) sendudp(h->iodesc, &wbuf.t, wtail - (char *) &wbuf.t);
    265 }
    266 #endif
    267 
    268 int
    269 tftp_open(path, f)
    270 	char           *path;
    271 	struct open_file *f;
    272 {
    273 	struct tftp_handle *tftpfile;
    274 	struct iodesc  *io;
    275 	int             res;
    276 
    277 	tftpfile = (struct tftp_handle *) alloc(sizeof(*tftpfile));
    278 	if (!tftpfile)
    279 		return (ENOMEM);
    280 
    281 	tftpfile->iodesc = io = socktodesc(*(int *) (f->f_devdata));
    282 	io->destip = servip;
    283 	tftpfile->off = 0;
    284 	tftpfile->path = path;	/* XXXXXXX we hope it's static */
    285 
    286 	res = tftp_makereq(tftpfile);
    287 
    288 	if (res) {
    289 		free(tftpfile, sizeof(*tftpfile));
    290 		return (res);
    291 	}
    292 	f->f_fsdata = (void *) tftpfile;
    293 	return (0);
    294 }
    295 
    296 int
    297 tftp_read(f, addr, size, resid)
    298 	struct open_file *f;
    299 	void           *addr;
    300 	size_t          size;
    301 	size_t         *resid;	/* out */
    302 {
    303 	struct tftp_handle *tftpfile;
    304 #if !defined(LIBSA_NO_TWIDDLE)
    305 	static int      tc = 0;
    306 #endif
    307 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    308 
    309 	while (size > 0) {
    310 		int needblock, count;
    311 
    312 #if !defined(LIBSA_NO_TWIDDLE)
    313 		if (!(tc++ % 16))
    314 			twiddle();
    315 #endif
    316 
    317 		needblock = tftpfile->off / SEGSIZE + 1;
    318 
    319 		if (tftpfile->currblock > needblock) {	/* seek backwards */
    320 #ifndef TFTP_NOTERMINATE
    321 			tftp_terminate(tftpfile);
    322 #endif
    323 			tftp_makereq(tftpfile);	/* no error check, it worked
    324 						 * for open */
    325 		}
    326 
    327 		while (tftpfile->currblock < needblock) {
    328 			int res;
    329 
    330 			res = tftp_getnextblock(tftpfile);
    331 			if (res) {	/* no answer */
    332 #ifdef DEBUG
    333 				printf("tftp: read error (block %d->%d)\n",
    334 				       tftpfile->currblock, needblock);
    335 #endif
    336 				return (res);
    337 			}
    338 			if (tftpfile->islastblock)
    339 				break;
    340 		}
    341 
    342 		if (tftpfile->currblock == needblock) {
    343 			int offinblock, inbuffer;
    344 
    345 			offinblock = tftpfile->off % SEGSIZE;
    346 
    347 			inbuffer = tftpfile->validsize - offinblock;
    348 			if (inbuffer < 0) {
    349 #ifdef DEBUG
    350 				printf("tftp: invalid offset %d\n",
    351 				    tftpfile->off);
    352 #endif
    353 				return (EINVAL);
    354 			}
    355 			count = (size < inbuffer ? size : inbuffer);
    356 			bcopy(tftpfile->lastdata.t.th_data + offinblock,
    357 			    addr, count);
    358 
    359 			addr = (caddr_t)addr + count;
    360 			tftpfile->off += count;
    361 			size -= count;
    362 
    363 			if ((tftpfile->islastblock) && (count == inbuffer))
    364 				break;	/* EOF */
    365 		} else {
    366 #ifdef DEBUG
    367 			printf("tftp: block %d not found\n", needblock);
    368 #endif
    369 			return (EINVAL);
    370 		}
    371 
    372 	}
    373 
    374 	if (resid)
    375 		*resid = size;
    376 	return (0);
    377 }
    378 
    379 int
    380 tftp_close(f)
    381 	struct open_file *f;
    382 {
    383 	struct tftp_handle *tftpfile;
    384 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    385 
    386 #ifdef TFTP_NOTERMINATE
    387 	/* let it time out ... */
    388 #else
    389 	tftp_terminate(tftpfile);
    390 #endif
    391 
    392 	free(tftpfile, sizeof(*tftpfile));
    393 	return (0);
    394 }
    395 
    396 int
    397 tftp_write(f, start, size, resid)
    398 	struct open_file *f;
    399 	void           *start;
    400 	size_t          size;
    401 	size_t         *resid;	/* out */
    402 {
    403 	return (EROFS);
    404 }
    405 
    406 int
    407 tftp_stat(f, sb)
    408 	struct open_file *f;
    409 	struct stat    *sb;
    410 {
    411 	struct tftp_handle *tftpfile;
    412 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    413 
    414 	sb->st_mode = 0444;
    415 	sb->st_nlink = 1;
    416 	sb->st_uid = 0;
    417 	sb->st_gid = 0;
    418 	sb->st_size = -1;
    419 	return (0);
    420 }
    421 
    422 off_t
    423 tftp_seek(f, offset, where)
    424 	struct open_file *f;
    425 	off_t           offset;
    426 	int             where;
    427 {
    428 	struct tftp_handle *tftpfile;
    429 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    430 
    431 	switch (where) {
    432 	case SEEK_SET:
    433 		tftpfile->off = offset;
    434 		break;
    435 	case SEEK_CUR:
    436 		tftpfile->off += offset;
    437 		break;
    438 	default:
    439 		errno = EOFFSET;
    440 		return (-1);
    441 	}
    442 	return (tftpfile->off);
    443 }
    444