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