tftp.c revision 1.38 
1/*	$NetBSD: tftp.c,v 1.38 2022/08/07 05:51:55 rin 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
62extern struct in_addr servip;
63
64static int      tftpport = 2000;
65
66#define RSPACE 520		/* max data packet, rounded up */
67
68struct 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[UDP_TOTAL_HEADER_SIZE];
77		struct tftphdr t;
78		u_char space[RSPACE];
79	} lastdata;
80};
81
82static const int tftperrors[8] = {
83	0,			/* ??? */
84	ENOENT,
85	EPERM,
86	ENOSPC,
87	EINVAL,			/* ??? */
88	EINVAL,			/* ??? */
89	EEXIST,
90	EINVAL,			/* ??? */
91};
92
93static ssize_t recvtftp(struct iodesc *, void *, size_t, saseconds_t);
94static int tftp_makereq(struct tftp_handle *);
95static int tftp_getnextblock(struct tftp_handle *);
96#ifndef TFTP_NOTERMINATE
97static void tftp_terminate(struct tftp_handle *);
98#endif
99static ssize_t tftp_size_of_file(struct tftp_handle *tftpfile);
100
101static ssize_t
102recvtftp(struct iodesc *d, void *pkt, size_t len, saseconds_t tleft)
103{
104	ssize_t n;
105	struct tftphdr *t;
106
107	errno = 0;
108
109	n = readudp(d, pkt, len, tleft);
110
111	if (n < 4)
112		return -1;
113
114	t = (struct tftphdr *)pkt;
115	switch (ntohs(t->th_opcode)) {
116	case DATA:
117		if (ntohs(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;
128			uh = (struct udphdr *)pkt - 1;
129			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 int)ntohs(t->th_code) >= 8) {
134			printf("illegal tftp error %d\n", ntohs(t->th_code));
135			errno = EIO;
136		} else {
137#ifdef DEBUG
138			printf("tftp-error %d\n", ntohs(t->th_code));
139#endif
140			errno = tftperrors[ntohs(t->th_code)];
141		}
142		return -1;
143	default:
144#ifdef DEBUG
145		printf("tftp type %d not handled\n", ntohs(t->th_opcode));
146#endif
147		return -1;
148	}
149}
150
151/* send request, expect first block (or error) */
152static int
153tftp_makereq(struct tftp_handle *h)
154{
155	struct {
156		u_char header[UDP_TOTAL_HEADER_SIZE];
157		struct tftphdr t;
158		u_char space[FNAME_SIZE + 6];
159	} wbuf;
160	char           *wtail;
161	int             l;
162	ssize_t         res;
163	struct tftphdr *t;
164
165	wbuf.t.th_opcode = htons((u_short)RRQ);
166	wtail = wbuf.t.th_stuff;
167	l = strlen(h->path);
168	(void)memcpy(wtail, h->path, l + 1);
169	wtail += l + 1;
170	(void)memcpy(wtail, "octet", 6);
171	wtail += 6;
172
173	t = &h->lastdata.t;
174
175	/* h->iodesc->myport = htons(--tftpport); */
176	h->iodesc->myport = htons(tftpport + (getsecs() & 0x3ff));
177	h->iodesc->destport = htons(IPPORT_TFTP);
178	h->iodesc->xid = 1;	/* expected block */
179
180	res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *)&wbuf.t,
181		       recvtftp, t, sizeof(*t) + RSPACE);
182
183	if (res == -1)
184		return errno;
185
186	h->currblock = 1;
187	h->validsize = res;
188	h->islastblock = 0;
189	if (res < SEGSIZE)
190		h->islastblock = 1;	/* very short file */
191	return 0;
192}
193
194/* ack block, expect next */
195static int
196tftp_getnextblock(struct tftp_handle *h)
197{
198	struct {
199		u_char header[UDP_TOTAL_HEADER_SIZE];
200		struct tftphdr t;
201	} wbuf;
202	char           *wtail;
203	int             res;
204	struct tftphdr *t;
205
206	wbuf.t.th_opcode = htons((u_short)ACK);
207	wbuf.t.th_block = htons((u_short)h->currblock);
208	wtail = (char *)&wbuf.t.th_data;
209
210	t = &h->lastdata.t;
211
212	h->iodesc->xid = h->currblock + 1;	/* expected block */
213
214	res = sendrecv(h->iodesc, sendudp, &wbuf.t, wtail - (char *)&wbuf.t,
215		       recvtftp, t, sizeof(*t) + RSPACE);
216
217	if (res == -1)		/* 0 is OK! */
218		return errno;
219
220	h->currblock++;
221	h->validsize = res;
222	if (res < SEGSIZE)
223		h->islastblock = 1;	/* EOF */
224	return 0;
225}
226
227#ifndef TFTP_NOTERMINATE
228static void
229tftp_terminate(struct tftp_handle *h)
230{
231	struct {
232		u_char header[UDP_TOTAL_HEADER_SIZE];
233		struct tftphdr t;
234	} wbuf;
235	char           *wtail;
236
237	wtail = (char *)&wbuf.t.th_data;
238	if (h->islastblock) {
239		wbuf.t.th_opcode = htons((u_short)ACK);
240		wbuf.t.th_block = htons((u_short)h->currblock);
241	} else {
242		wbuf.t.th_opcode = htons((u_short)ERROR);
243		wbuf.t.th_code = htons((u_short)ENOSPACE); /* ??? */
244		*wtail++ = '\0'; /* empty error string */
245	}
246
247	(void)sendudp(h->iodesc, &wbuf.t, wtail - (char *)&wbuf.t);
248}
249#endif
250
251__compactcall int
252tftp_open(const char *path, struct open_file *f)
253{
254	struct tftp_handle *tftpfile;
255	struct iodesc  *io;
256	int             res;
257
258	tftpfile = (struct tftp_handle *)alloc(sizeof(*tftpfile));
259	if (!tftpfile)
260		return ENOMEM;
261
262	tftpfile->iodesc = io = socktodesc(*(int *)(f->f_devdata));
263	io->destip = servip;
264	tftpfile->off = 0;
265	tftpfile->path = path;	/* XXXXXXX we hope it's static */
266
267	res = tftp_makereq(tftpfile);
268
269	if (res) {
270		dealloc(tftpfile, sizeof(*tftpfile));
271		return res;
272	}
273	f->f_fsdata = (void *)tftpfile;
274	fsmod = "nfs";
275	return 0;
276}
277
278__compactcall int
279tftp_read(struct open_file *f, void *addr, size_t size, size_t *resid)
280{
281	struct tftp_handle *tftpfile;
282#if !defined(LIBSA_NO_TWIDDLE)
283	static int      tc = 0;
284#endif
285	tftpfile = (struct tftp_handle *)f->f_fsdata;
286
287	while (size > 0) {
288		int needblock;
289		size_t count;
290
291		needblock = tftpfile->off / SEGSIZE + 1;
292
293		if (tftpfile->currblock > needblock) {	/* seek backwards */
294#ifndef TFTP_NOTERMINATE
295			tftp_terminate(tftpfile);
296#endif
297			tftp_makereq(tftpfile);	/* no error check, it worked
298			                         * for open */
299		}
300
301		while (tftpfile->currblock < needblock) {
302			int res;
303
304#if !defined(LIBSA_NO_TWIDDLE)
305			if (!(tc++ % 16))
306				twiddle();
307#endif
308
309			res = tftp_getnextblock(tftpfile);
310			if (res) {	/* no answer */
311#ifdef DEBUG
312				printf("%s: read error (block %d->%d)\n",
313				    __func__, tftpfile->currblock, needblock);
314#endif
315				return res;
316			}
317			if (tftpfile->islastblock)
318				break;
319		}
320
321		if (tftpfile->currblock == needblock) {
322			size_t offinblock, inbuffer;
323
324			offinblock = tftpfile->off % SEGSIZE;
325
326			if ((int)offinblock > tftpfile->validsize) {
327#ifdef DEBUG
328				printf("%s: invalid offset %d\n", __func__,
329				    tftpfile->off);
330#endif
331				return EINVAL;
332			}
333			inbuffer = tftpfile->validsize - offinblock;
334			count = (size < inbuffer ? size : inbuffer);
335			(void)memcpy(addr,
336			    tftpfile->lastdata.t.th_data + offinblock,
337			    count);
338
339			addr = (char *)addr + count;
340			tftpfile->off += count;
341			size -= count;
342
343			if ((tftpfile->islastblock) && (count == inbuffer))
344				break;	/* EOF */
345		} else {
346#ifdef DEBUG
347			printf("%s: block %d not found\n",
348			    __func__, needblock);
349#endif
350			return EINVAL;
351		}
352
353	}
354
355	if (resid)
356		*resid = size;
357	return 0;
358}
359
360__compactcall int
361tftp_close(struct open_file *f)
362{
363	struct tftp_handle *tftpfile;
364	tftpfile = (struct tftp_handle *)f->f_fsdata;
365
366#ifdef TFTP_NOTERMINATE
367	/* let it time out ... */
368#else
369	tftp_terminate(tftpfile);
370#endif
371
372	dealloc(tftpfile, sizeof(*tftpfile));
373	return 0;
374}
375
376__compactcall int
377tftp_write(struct open_file *f, void *start, size_t size, size_t *resid)
378{
379
380	return EROFS;
381}
382
383static ssize_t
384tftp_size_of_file(struct tftp_handle *tftpfile)
385{
386	ssize_t filesize;
387
388	if (tftpfile->currblock > 1) {	/* move to start of file */
389#ifndef TFTP_NOTERMINATE
390		tftp_terminate(tftpfile);
391#endif
392		tftp_makereq(tftpfile);	/* no error check, it worked
393		      			 * for open */
394	}
395
396	/* start with the size of block 1 */
397	filesize = tftpfile->validsize;
398
399	/* and keep adding the sizes till we hit the last block */
400	while (!tftpfile->islastblock) {
401		int res;
402
403		res = tftp_getnextblock(tftpfile);
404		if (res) {	/* no answer */
405#ifdef DEBUG
406			printf("%s: read error (block %d)\n",
407			    __func__, tftpfile->currblock);
408#endif
409			return -1;
410		}
411		filesize += tftpfile->validsize;
412	}
413#ifdef DEBUG
414	printf("%s: file is %zu bytes\n", __func__, filesize);
415#endif
416	return filesize;
417}
418
419__compactcall int
420tftp_stat(struct open_file *f, struct stat *sb)
421{
422	struct tftp_handle *tftpfile;
423	tftpfile = (struct tftp_handle *)f->f_fsdata;
424
425	sb->st_mode = 0444;
426	sb->st_nlink = 1;
427	sb->st_uid = 0;
428	sb->st_gid = 0;
429	sb->st_size = tftp_size_of_file(tftpfile);
430	return 0;
431}
432
433#if defined(LIBSA_ENABLE_LS_OP)
434#include "ls.h"
435__compactcall void
436tftp_ls(struct open_file *f, const char *pattern)
437{
438	lsunsup("tftp");
439}
440#endif
441
442__compactcall off_t
443tftp_seek(struct open_file *f, off_t offset, int where)
444{
445	struct tftp_handle *tftpfile;
446	tftpfile = (struct tftp_handle *)f->f_fsdata;
447
448	switch (where) {
449	case SEEK_SET:
450		tftpfile->off = offset;
451		break;
452	case SEEK_CUR:
453		tftpfile->off += offset;
454		break;
455	default:
456		errno = EOFFSET;
457		return -1;
458	}
459	return tftpfile->off;
460}
461