1 /* $NetBSD: tftp.c,v 1.35 2014/03/20 03:13:18 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[UDP_TOTAL_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(struct iodesc *, void *, size_t, saseconds_t);
94 static int tftp_makereq(struct tftp_handle *);
95 static int tftp_getnextblock(struct tftp_handle *);
96 #ifndef TFTP_NOTERMINATE
97 static void tftp_terminate(struct tftp_handle *);
98 #endif
99 static ssize_t tftp_size_of_file(struct tftp_handle *tftpfile);
100
101 static ssize_t
recvtftp(struct iodesc * d,void * pkt,size_t len,saseconds_t tleft)102 recvtftp(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 (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;
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) */
152 static int
tftp_makereq(struct tftp_handle * h)153 tftp_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 */
195 static int
tftp_getnextblock(struct tftp_handle * h)196 tftp_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
228 static void
tftp_terminate(struct tftp_handle * h)229 tftp_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
tftp_open(const char * path,struct open_file * f)252 tftp_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
tftp_read(struct open_file * f,void * addr,size_t size,size_t * resid)279 tftp_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 #if !defined(LIBSA_NO_TWIDDLE)
292 if (!(tc++ % 16))
293 twiddle();
294 #endif
295
296 needblock = tftpfile->off / SEGSIZE + 1;
297
298 if (tftpfile->currblock > needblock) { /* seek backwards */
299 #ifndef TFTP_NOTERMINATE
300 tftp_terminate(tftpfile);
301 #endif
302 tftp_makereq(tftpfile); /* no error check, it worked
303 * for open */
304 }
305
306 while (tftpfile->currblock < needblock) {
307 int res;
308
309 res = tftp_getnextblock(tftpfile);
310 if (res) { /* no answer */
311 #ifdef DEBUG
312 printf("tftp: read error (block %d->%d)\n",
313 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 (offinblock > tftpfile->validsize) {
327 #ifdef DEBUG
328 printf("tftp: invalid offset %d\n",
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("tftp: block %d not found\n", needblock);
348 #endif
349 return EINVAL;
350 }
351
352 }
353
354 if (resid)
355 *resid = size;
356 return 0;
357 }
358
359 __compactcall int
tftp_close(struct open_file * f)360 tftp_close(struct open_file *f)
361 {
362 struct tftp_handle *tftpfile;
363 tftpfile = (struct tftp_handle *)f->f_fsdata;
364
365 #ifdef TFTP_NOTERMINATE
366 /* let it time out ... */
367 #else
368 tftp_terminate(tftpfile);
369 #endif
370
371 dealloc(tftpfile, sizeof(*tftpfile));
372 return 0;
373 }
374
375 __compactcall int
tftp_write(struct open_file * f,void * start,size_t size,size_t * resid)376 tftp_write(struct open_file *f, void *start, size_t size, size_t *resid)
377 {
378
379 return EROFS;
380 }
381
382 static ssize_t
tftp_size_of_file(struct tftp_handle * tftpfile)383 tftp_size_of_file(struct tftp_handle *tftpfile)
384 {
385 ssize_t filesize;
386
387 if (tftpfile->currblock > 1) { /* move to start of file */
388 #ifndef TFTP_NOTERMINATE
389 tftp_terminate(tftpfile);
390 #endif
391 tftp_makereq(tftpfile); /* no error check, it worked
392 * for open */
393 }
394
395 /* start with the size of block 1 */
396 filesize = tftpfile->validsize;
397
398 /* and keep adding the sizes till we hit the last block */
399 while (!tftpfile->islastblock) {
400 int res;
401
402 res = tftp_getnextblock(tftpfile);
403 if (res) { /* no answer */
404 #ifdef DEBUG
405 printf("tftp: read error (block %d)\n",
406 tftpfile->currblock);
407 #endif
408 return -1;
409 }
410 filesize += tftpfile->validsize;
411 }
412 #ifdef DEBUG
413 printf("tftp_size_of_file: file is %zu bytes\n", filesize);
414 #endif
415 return filesize;
416 }
417
418 __compactcall int
tftp_stat(struct open_file * f,struct stat * sb)419 tftp_stat(struct open_file *f, struct stat *sb)
420 {
421 struct tftp_handle *tftpfile;
422 tftpfile = (struct tftp_handle *)f->f_fsdata;
423
424 sb->st_mode = 0444;
425 sb->st_nlink = 1;
426 sb->st_uid = 0;
427 sb->st_gid = 0;
428 sb->st_size = tftp_size_of_file(tftpfile);
429 return 0;
430 }
431
432 #if defined(LIBSA_ENABLE_LS_OP)
433 #include "ls.h"
434 __compactcall void
tftp_ls(struct open_file * f,const char * pattern)435 tftp_ls(struct open_file *f, const char *pattern)
436 {
437 lsunsup("tftp");
438 }
439 #endif
440
441 __compactcall off_t
tftp_seek(struct open_file * f,off_t offset,int where)442 tftp_seek(struct open_file *f, off_t offset, int where)
443 {
444 struct tftp_handle *tftpfile;
445 tftpfile = (struct tftp_handle *)f->f_fsdata;
446
447 switch (where) {
448 case SEEK_SET:
449 tftpfile->off = offset;
450 break;
451 case SEEK_CUR:
452 tftpfile->off += offset;
453 break;
454 default:
455 errno = EOFFSET;
456 return -1;
457 }
458 return tftpfile->off;
459 }
460