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