Home | History | Annotate | Line # | Download | only in libsa
tftp.c revision 1.20 
      1 /*	$NetBSD: tftp.c,v 1.20 2006/01/25 18:27:23 christos 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  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  *
     27  */
     28 
     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  */
     39 
     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  */
     49 
     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>
     56 
     57 #include "stand.h"
     58 #include "net.h"
     59 
     60 #include "tftp.h"
     61 
     62 extern struct in_addr servip;
     63 
     64 static int      tftpport = 2000;
     65 
     66 #define RSPACE 520		/* max data packet, rounded up */
     67 
     68 struct tftp_handle {
     69 	struct iodesc  *iodesc;
     70 	int             currblock;	/* contents of lastdata */
     71 	int             islastblock;	/* flag */
     72 	int             validsize;
     73 	int             off;
     74 	const char     *path;	/* saved for re-requests */
     75 	struct {
     76 		u_char header[HEADER_SIZE];
     77 		struct tftphdr t;
     78 		u_char space[RSPACE];
     79 	} lastdata;
     80 };
     81 
     82 static const int tftperrors[8] = {
     83 	0,			/* ??? */
     84 	ENOENT,
     85 	EPERM,
     86 	ENOSPC,
     87 	EINVAL,			/* ??? */
     88 	EINVAL,			/* ??? */
     89 	EEXIST,
     90 	EINVAL			/* ??? */
     91 };
     92 
     93 static ssize_t recvtftp __P((struct iodesc *, void *, size_t, time_t));
     94 static int tftp_makereq __P((struct tftp_handle *));
     95 static int tftp_getnextblock __P((struct tftp_handle *));
     96 #ifndef TFTP_NOTERMINATE
     97 static void tftp_terminate __P((struct tftp_handle *));
     98 #endif
     99 
    100 static ssize_t
    101 recvtftp(d, pkt, len, tleft)
    102 	struct iodesc *d;
    103 	void  *pkt;
    104 	size_t len;
    105 	time_t          tleft;
    106 {
    107 	ssize_t n;
    108 	struct tftphdr *t;
    109 
    110 	errno = 0;
    111 
    112 	n = readudp(d, pkt, len, tleft);
    113 
    114 	if (n < 4)
    115 		return (-1);
    116 
    117 	t = (struct tftphdr *) pkt;
    118 	switch (ntohs(t->th_opcode)) {
    119 	case DATA:
    120 		if (htons(t->th_block) != d->xid) {
    121 			/*
    122 			 * Expected block?
    123 			 */
    124 			return (-1);
    125 		}
    126 		if (d->xid == 1) {
    127 			/*
    128 			 * First data packet from new port.
    129 			 */
    130 			struct udphdr *uh;
    131 			uh = (struct udphdr *) pkt - 1;
    132 			d->destport = uh->uh_sport;
    133 		} /* else check uh_sport has not changed??? */
    134 		return (n - (t->th_data - (char *)t));
    135 	case ERROR:
    136 		if ((unsigned) ntohs(t->th_code) >= 8) {
    137 			printf("illegal tftp error %d\n", ntohs(t->th_code));
    138 			errno = EIO;
    139 		} else {
    140 #ifdef DEBUG
    141 			printf("tftp-error %d\n", ntohs(t->th_code));
    142 #endif
    143 			errno = tftperrors[ntohs(t->th_code)];
    144 		}
    145 		return (-1);
    146 	default:
    147 #ifdef DEBUG
    148 		printf("tftp type %d not handled\n", ntohs(t->th_opcode));
    149 #endif
    150 		return (-1);
    151 	}
    152 }
    153 
    154 /* send request, expect first block (or error) */
    155 static int
    156 tftp_makereq(h)
    157 	struct tftp_handle *h;
    158 {
    159 	struct {
    160 		u_char header[HEADER_SIZE];
    161 		struct tftphdr  t;
    162 		u_char space[FNAME_SIZE + 6];
    163 	} wbuf;
    164 	char           *wtail;
    165 	int             l;
    166 	ssize_t         res;
    167 	struct tftphdr *t;
    168 
    169 	wbuf.t.th_opcode = htons((u_short) RRQ);
    170 	wtail = wbuf.t.th_stuff;
    171 	l = strlen(h->path);
    172 	bcopy(h->path, wtail, l + 1);
    173 	wtail += l + 1;
    174 	bcopy("octet", wtail, 6);
    175 	wtail += 6;
    176 
    177 	t = &h->lastdata.t;
    178 
    179 	/* h->iodesc->myport = htons(--tftpport); */
    180 	h->iodesc->myport = htons(tftpport + (getsecs() & 0x3ff));
    181 	h->iodesc->destport = htons(IPPORT_TFTP);
    182 	h->iodesc->xid = 1;	/* expected block */
    183 
    184 	res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *) &wbuf.t,
    185 		       recvtftp, t, sizeof(*t) + RSPACE);
    186 
    187 	if (res == -1)
    188 		return (errno);
    189 
    190 	h->currblock = 1;
    191 	h->validsize = res;
    192 	h->islastblock = 0;
    193 	if (res < SEGSIZE)
    194 		h->islastblock = 1;	/* very short file */
    195 	return (0);
    196 }
    197 
    198 /* ack block, expect next */
    199 static int
    200 tftp_getnextblock(h)
    201 	struct tftp_handle *h;
    202 {
    203 	struct {
    204 		u_char header[HEADER_SIZE];
    205 		struct tftphdr t;
    206 	} wbuf;
    207 	char           *wtail;
    208 	int             res;
    209 	struct tftphdr *t;
    210 
    211 	wbuf.t.th_opcode = htons((u_short) ACK);
    212 	wbuf.t.th_block = htons((u_short) h->currblock);
    213 	wtail = (char *) &wbuf.t.th_data;
    214 
    215 	t = &h->lastdata.t;
    216 
    217 	h->iodesc->xid = h->currblock + 1;	/* expected block */
    218 
    219 	res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *) &wbuf.t,
    220 		       recvtftp, t, sizeof(*t) + RSPACE);
    221 
    222 	if (res == -1)		/* 0 is OK! */
    223 		return (errno);
    224 
    225 	h->currblock++;
    226 	h->validsize = res;
    227 	if (res < SEGSIZE)
    228 		h->islastblock = 1;	/* EOF */
    229 	return (0);
    230 }
    231 
    232 #ifndef TFTP_NOTERMINATE
    233 static void
    234 tftp_terminate(h)
    235 	struct tftp_handle *h;
    236 {
    237 	struct {
    238 		u_char header[HEADER_SIZE];
    239 		struct tftphdr t;
    240 	} wbuf;
    241 	char           *wtail;
    242 
    243 	if (h->islastblock) {
    244 		wbuf.t.th_opcode = htons((u_short) ACK);
    245 		wbuf.t.th_block = htons((u_short) h->currblock);
    246 	} else {
    247 		wbuf.t.th_opcode = htons((u_short) ERROR);
    248 		wbuf.t.th_code = htons((u_short) ENOSPACE); /* ??? */
    249 	}
    250 	wtail = (char *) &wbuf.t.th_data;
    251 
    252 	(void) sendudp(h->iodesc, &wbuf.t, wtail - (char *) &wbuf.t);
    253 }
    254 #endif
    255 
    256 int
    257 tftp_open(path, f)
    258 	const char           *path;
    259 	struct open_file *f;
    260 {
    261 	struct tftp_handle *tftpfile;
    262 	struct iodesc  *io;
    263 	int             res;
    264 
    265 	tftpfile = (struct tftp_handle *) alloc(sizeof(*tftpfile));
    266 	if (!tftpfile)
    267 		return (ENOMEM);
    268 
    269 	tftpfile->iodesc = io = socktodesc(*(int *) (f->f_devdata));
    270 	io->destip = servip;
    271 	tftpfile->off = 0;
    272 	tftpfile->path = path;	/* XXXXXXX we hope it's static */
    273 
    274 	res = tftp_makereq(tftpfile);
    275 
    276 	if (res) {
    277 		dealloc(tftpfile, sizeof(*tftpfile));
    278 		return (res);
    279 	}
    280 	f->f_fsdata = (void *) tftpfile;
    281 	return (0);
    282 }
    283 
    284 int
    285 tftp_read(f, addr, size, resid)
    286 	struct open_file *f;
    287 	void           *addr;
    288 	size_t          size;
    289 	size_t         *resid;	/* out */
    290 {
    291 	struct tftp_handle *tftpfile;
    292 #if !defined(LIBSA_NO_TWIDDLE)
    293 	static int      tc = 0;
    294 #endif
    295 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    296 
    297 	while (size > 0) {
    298 		int needblock;
    299 		size_t count;
    300 
    301 #if !defined(LIBSA_NO_TWIDDLE)
    302 		if (!(tc++ % 16))
    303 			twiddle();
    304 #endif
    305 
    306 		needblock = tftpfile->off / SEGSIZE + 1;
    307 
    308 		if (tftpfile->currblock > needblock) {	/* seek backwards */
    309 #ifndef TFTP_NOTERMINATE
    310 			tftp_terminate(tftpfile);
    311 #endif
    312 			tftp_makereq(tftpfile);	/* no error check, it worked
    313 						 * for open */
    314 		}
    315 
    316 		while (tftpfile->currblock < needblock) {
    317 			int res;
    318 
    319 			res = tftp_getnextblock(tftpfile);
    320 			if (res) {	/* no answer */
    321 #ifdef DEBUG
    322 				printf("tftp: read error (block %d->%d)\n",
    323 				       tftpfile->currblock, needblock);
    324 #endif
    325 				return (res);
    326 			}
    327 			if (tftpfile->islastblock)
    328 				break;
    329 		}
    330 
    331 		if (tftpfile->currblock == needblock) {
    332 			size_t offinblock, inbuffer;
    333 
    334 			offinblock = tftpfile->off % SEGSIZE;
    335 
    336 			inbuffer = tftpfile->validsize - offinblock;
    337 			if (inbuffer < 0) {
    338 #ifdef DEBUG
    339 				printf("tftp: invalid offset %d\n",
    340 				    tftpfile->off);
    341 #endif
    342 				return (EINVAL);
    343 			}
    344 			count = (size < inbuffer ? size : inbuffer);
    345 			bcopy(tftpfile->lastdata.t.th_data + offinblock,
    346 			    addr, count);
    347 
    348 			addr = (caddr_t)addr + count;
    349 			tftpfile->off += count;
    350 			size -= count;
    351 
    352 			if ((tftpfile->islastblock) && (count == inbuffer))
    353 				break;	/* EOF */
    354 		} else {
    355 #ifdef DEBUG
    356 			printf("tftp: block %d not found\n", needblock);
    357 #endif
    358 			return (EINVAL);
    359 		}
    360 
    361 	}
    362 
    363 	if (resid)
    364 		*resid = size;
    365 	return (0);
    366 }
    367 
    368 int
    369 tftp_close(f)
    370 	struct open_file *f;
    371 {
    372 	struct tftp_handle *tftpfile;
    373 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    374 
    375 #ifdef TFTP_NOTERMINATE
    376 	/* let it time out ... */
    377 #else
    378 	tftp_terminate(tftpfile);
    379 #endif
    380 
    381 	dealloc(tftpfile, sizeof(*tftpfile));
    382 	return (0);
    383 }
    384 
    385 int
    386 tftp_write(f, start, size, resid)
    387 	struct open_file *f;
    388 	void           *start;
    389 	size_t          size;
    390 	size_t         *resid;	/* out */
    391 {
    392 	return (EROFS);
    393 }
    394 
    395 int
    396 tftp_stat(f, sb)
    397 	struct open_file *f;
    398 	struct stat    *sb;
    399 {
    400 	struct tftp_handle *tftpfile;
    401 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    402 
    403 	sb->st_mode = 0444;
    404 	sb->st_nlink = 1;
    405 	sb->st_uid = 0;
    406 	sb->st_gid = 0;
    407 	sb->st_size = -1;
    408 	return (0);
    409 }
    410 
    411 off_t
    412 tftp_seek(f, offset, where)
    413 	struct open_file *f;
    414 	off_t           offset;
    415 	int             where;
    416 {
    417 	struct tftp_handle *tftpfile;
    418 	tftpfile = (struct tftp_handle *) f->f_fsdata;
    419 
    420 	switch (where) {
    421 	case SEEK_SET:
    422 		tftpfile->off = offset;
    423 		break;
    424 	case SEEK_CUR:
    425 		tftpfile->off += offset;
    426 		break;
    427 	default:
    428 		errno = EOFFSET;
    429 		return (-1);
    430 	}
    431 	return (tftpfile->off);
    432 }
    433