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