xref: /freebsd/libexec/tftpd/tftpd.c (revision ec3a1a66aad80b656971dcff4277d8ea4967fbb5)
1 /*
2  * Copyright (c) 1983, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33 
34 #ifndef lint
35 static const char copyright[] =
36 "@(#) Copyright (c) 1983, 1993\n\
37 	The Regents of the University of California.  All rights reserved.\n";
38 #endif /* not lint */
39 
40 #ifndef lint
41 #if 0
42 static char sccsid[] = "@(#)tftpd.c	8.1 (Berkeley) 6/4/93";
43 #endif
44 static const char rcsid[] =
45   "$FreeBSD$";
46 #endif /* not lint */
47 
48 /*
49  * Trivial file transfer protocol server.
50  *
51  * This version includes many modifications by Jim Guyton
52  * <guyton@rand-unix>.
53  */
54 
55 #include <sys/param.h>
56 #include <sys/ioctl.h>
57 #include <sys/stat.h>
58 #include <sys/socket.h>
59 #include <sys/types.h>
60 
61 #include <netinet/in.h>
62 #include <arpa/tftp.h>
63 #include <arpa/inet.h>
64 
65 #include <ctype.h>
66 #include <errno.h>
67 #include <fcntl.h>
68 #include <libutil.h>
69 #include <netdb.h>
70 #include <pwd.h>
71 #include <setjmp.h>
72 #include <signal.h>
73 #include <stdio.h>
74 #include <stdlib.h>
75 #include <string.h>
76 #include <syslog.h>
77 #include <unistd.h>
78 
79 #include "tftpsubs.h"
80 
81 #define	TIMEOUT		5
82 #define	MAX_TIMEOUTS	5
83 
84 int	peer;
85 int	rexmtval = TIMEOUT;
86 int	max_rexmtval = 2*TIMEOUT;
87 
88 #define	PKTSIZE	SEGSIZE+4
89 char	buf[PKTSIZE];
90 char	ackbuf[PKTSIZE];
91 struct	sockaddr_storage from;
92 int	fromlen;
93 
94 void	tftp(struct tftphdr *, int);
95 static void unmappedaddr(struct sockaddr_in6 *);
96 
97 /*
98  * Null-terminated directory prefix list for absolute pathname requests and
99  * search list for relative pathname requests.
100  *
101  * MAXDIRS should be at least as large as the number of arguments that
102  * inetd allows (currently 20).
103  */
104 #define MAXDIRS	20
105 static struct dirlist {
106 	const char	*name;
107 	int	len;
108 } dirs[MAXDIRS+1];
109 static int	suppress_naks;
110 static int	logging;
111 static int	ipchroot;
112 
113 static const char *errtomsg(int);
114 static void  nak(int);
115 static void  oack(void);
116 
117 static void  timer(int);
118 static void  justquit(int);
119 
120 int
121 main(int argc, char *argv[])
122 {
123 	struct tftphdr *tp;
124 	int n;
125 	int ch, on;
126 	struct sockaddr_storage me;
127 	int len;
128 	char *chroot_dir = NULL;
129 	struct passwd *nobody;
130 	const char *chuser = "nobody";
131 
132 	openlog("tftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
133 	while ((ch = getopt(argc, argv, "cClns:u:")) != -1) {
134 		switch (ch) {
135 		case 'c':
136 			ipchroot = 1;
137 			break;
138 		case 'C':
139 			ipchroot = 2;
140 			break;
141 		case 'l':
142 			logging = 1;
143 			break;
144 		case 'n':
145 			suppress_naks = 1;
146 			break;
147 		case 's':
148 			chroot_dir = optarg;
149 			break;
150 		case 'u':
151 			chuser = optarg;
152 			break;
153 		default:
154 			syslog(LOG_WARNING, "ignoring unknown option -%c", ch);
155 		}
156 	}
157 	if (optind < argc) {
158 		struct dirlist *dirp;
159 
160 		/* Get list of directory prefixes. Skip relative pathnames. */
161 		for (dirp = dirs; optind < argc && dirp < &dirs[MAXDIRS];
162 		     optind++) {
163 			if (argv[optind][0] == '/') {
164 				dirp->name = argv[optind];
165 				dirp->len  = strlen(dirp->name);
166 				dirp++;
167 			}
168 		}
169 	}
170 	else if (chroot_dir) {
171 		dirs->name = "/";
172 		dirs->len = 1;
173 	}
174 	if (ipchroot && chroot_dir == NULL) {
175 		syslog(LOG_ERR, "-c requires -s");
176 		exit(1);
177 	}
178 
179 	on = 1;
180 	if (ioctl(0, FIONBIO, &on) < 0) {
181 		syslog(LOG_ERR, "ioctl(FIONBIO): %m");
182 		exit(1);
183 	}
184 	fromlen = sizeof (from);
185 	n = recvfrom(0, buf, sizeof (buf), 0,
186 	    (struct sockaddr *)&from, &fromlen);
187 	if (n < 0) {
188 		syslog(LOG_ERR, "recvfrom: %m");
189 		exit(1);
190 	}
191 	/*
192 	 * Now that we have read the message out of the UDP
193 	 * socket, we fork and exit.  Thus, inetd will go back
194 	 * to listening to the tftp port, and the next request
195 	 * to come in will start up a new instance of tftpd.
196 	 *
197 	 * We do this so that inetd can run tftpd in "wait" mode.
198 	 * The problem with tftpd running in "nowait" mode is that
199 	 * inetd may get one or more successful "selects" on the
200 	 * tftp port before we do our receive, so more than one
201 	 * instance of tftpd may be started up.  Worse, if tftpd
202 	 * break before doing the above "recvfrom", inetd would
203 	 * spawn endless instances, clogging the system.
204 	 */
205 	{
206 		int pid;
207 		int i, j;
208 
209 		for (i = 1; i < 20; i++) {
210 		    pid = fork();
211 		    if (pid < 0) {
212 				sleep(i);
213 				/*
214 				 * flush out to most recently sent request.
215 				 *
216 				 * This may drop some request, but those
217 				 * will be resent by the clients when
218 				 * they timeout.  The positive effect of
219 				 * this flush is to (try to) prevent more
220 				 * than one tftpd being started up to service
221 				 * a single request from a single client.
222 				 */
223 				j = sizeof from;
224 				i = recvfrom(0, buf, sizeof (buf), 0,
225 				    (struct sockaddr *)&from, &j);
226 				if (i > 0) {
227 					n = i;
228 					fromlen = j;
229 				}
230 		    } else {
231 				break;
232 		    }
233 		}
234 		if (pid < 0) {
235 			syslog(LOG_ERR, "fork: %m");
236 			exit(1);
237 		} else if (pid != 0) {
238 			exit(0);
239 		}
240 	}
241 
242 	/*
243 	 * Since we exit here, we should do that only after the above
244 	 * recvfrom to keep inetd from constantly forking should there
245 	 * be a problem.  See the above comment about system clogging.
246 	 */
247 	if (chroot_dir) {
248 		if (ipchroot) {
249 			char *tempchroot;
250 			struct stat sb;
251 			int statret;
252 			struct sockaddr_storage ss;
253 			char hbuf[NI_MAXHOST];
254 
255 			memcpy(&ss, &from, from.ss_len);
256 			unmappedaddr((struct sockaddr_in6 *)&ss);
257 			getnameinfo((struct sockaddr *)&ss, ss.ss_len,
258 				    hbuf, sizeof(hbuf), NULL, 0,
259 				    NI_NUMERICHOST | NI_WITHSCOPEID);
260 			asprintf(&tempchroot, "%s/%s", chroot_dir, hbuf);
261 			statret = stat(tempchroot, &sb);
262 			if ((sb.st_mode & S_IFDIR) &&
263 			    (statret == 0 || (statret == -1 && ipchroot == 1)))
264 				chroot_dir = tempchroot;
265 		}
266 		/* Must get this before chroot because /etc might go away */
267 		if ((nobody = getpwnam(chuser)) == NULL) {
268 			syslog(LOG_ERR, "%s: no such user", chuser);
269 			exit(1);
270 		}
271 		if (chroot(chroot_dir)) {
272 			syslog(LOG_ERR, "chroot: %s: %m", chroot_dir);
273 			exit(1);
274 		}
275 		chdir( "/" );
276 		setuid(nobody->pw_uid);
277 		setgroups(1, &nobody->pw_gid);
278 	}
279 
280 	len = sizeof(me);
281 	if (getsockname(0, (struct sockaddr *)&me, &len) == 0) {
282 		switch (me.ss_family) {
283 		case AF_INET:
284 			((struct sockaddr_in *)&me)->sin_port = 0;
285 			break;
286 		case AF_INET6:
287 			((struct sockaddr_in6 *)&me)->sin6_port = 0;
288 			break;
289 		default:
290 			/* unsupported */
291 			break;
292 		}
293 	} else {
294 		memset(&me, 0, sizeof(me));
295 		me.ss_family = from.ss_family;
296 		me.ss_len = from.ss_len;
297 	}
298 	alarm(0);
299 	close(0);
300 	close(1);
301 	peer = socket(from.ss_family, SOCK_DGRAM, 0);
302 	if (peer < 0) {
303 		syslog(LOG_ERR, "socket: %m");
304 		exit(1);
305 	}
306 	if (bind(peer, (struct sockaddr *)&me, me.ss_len) < 0) {
307 		syslog(LOG_ERR, "bind: %m");
308 		exit(1);
309 	}
310 	if (connect(peer, (struct sockaddr *)&from, from.ss_len) < 0) {
311 		syslog(LOG_ERR, "connect: %m");
312 		exit(1);
313 	}
314 	tp = (struct tftphdr *)buf;
315 	tp->th_opcode = ntohs(tp->th_opcode);
316 	if (tp->th_opcode == RRQ || tp->th_opcode == WRQ)
317 		tftp(tp, n);
318 	exit(1);
319 }
320 
321 struct formats;
322 int	validate_access(char **, int);
323 void	xmitfile(struct formats *);
324 void	recvfile(struct formats *);
325 
326 struct formats {
327 	const char	*f_mode;
328 	int	(*f_validate)(char **, int);
329 	void	(*f_send)(struct formats *);
330 	void	(*f_recv)(struct formats *);
331 	int	f_convert;
332 } formats[] = {
333 	{ "netascii",	validate_access,	xmitfile,	recvfile, 1 },
334 	{ "octet",	validate_access,	xmitfile,	recvfile, 0 },
335 #ifdef notdef
336 	{ "mail",	validate_user,		sendmail,	recvmail, 1 },
337 #endif
338 	{ 0,		NULL,			NULL,		NULL,	  0 }
339 };
340 
341 struct options {
342 	const char	*o_type;
343 	char	*o_request;
344 	int	o_reply;	/* turn into union if need be */
345 } options[] = {
346 	{ "tsize",	NULL, 0 },		/* OPT_TSIZE */
347 	{ "timeout",	NULL, 0 },		/* OPT_TIMEOUT */
348 	{ NULL,		NULL, 0 }
349 };
350 
351 enum opt_enum {
352 	OPT_TSIZE = 0,
353 	OPT_TIMEOUT,
354 };
355 
356 /*
357  * Handle initial connection protocol.
358  */
359 void
360 tftp(struct tftphdr *tp, int size)
361 {
362 	char *cp;
363 	int i, first = 1, has_options = 0, ecode;
364 	struct formats *pf;
365 	char *filename, *mode, *option, *ccp;
366 
367 	filename = cp = tp->th_stuff;
368 again:
369 	while (cp < buf + size) {
370 		if (*cp == '\0')
371 			break;
372 		cp++;
373 	}
374 	if (*cp != '\0') {
375 		nak(EBADOP);
376 		exit(1);
377 	}
378 	if (first) {
379 		mode = ++cp;
380 		first = 0;
381 		goto again;
382 	}
383 	for (cp = mode; *cp; cp++)
384 		if (isupper(*cp))
385 			*cp = tolower(*cp);
386 	for (pf = formats; pf->f_mode; pf++)
387 		if (strcmp(pf->f_mode, mode) == 0)
388 			break;
389 	if (pf->f_mode == 0) {
390 		nak(EBADOP);
391 		exit(1);
392 	}
393 	while (++cp < buf + size) {
394 		for (i = 2, ccp = cp; i > 0; ccp++) {
395 			if (ccp >= buf + size) {
396 				/*
397 				 * Don't reject the request, just stop trying
398 				 * to parse the option and get on with it.
399 				 * Some Apple OpenFirmware versions have
400 				 * trailing garbage on the end of otherwise
401 				 * valid requests.
402 				 */
403 				goto option_fail;
404 			} else if (*ccp == '\0')
405 				i--;
406 		}
407 		for (option = cp; *cp; cp++)
408 			if (isupper(*cp))
409 				*cp = tolower(*cp);
410 		for (i = 0; options[i].o_type != NULL; i++)
411 			if (strcmp(option, options[i].o_type) == 0) {
412 				options[i].o_request = ++cp;
413 				has_options = 1;
414 			}
415 		cp = ccp-1;
416 	}
417 
418 option_fail:
419 	if (options[OPT_TIMEOUT].o_request) {
420 		int to = atoi(options[OPT_TIMEOUT].o_request);
421 		if (to < 1 || to > 255) {
422 			nak(EBADOP);
423 			exit(1);
424 		}
425 		else if (to <= max_rexmtval)
426 			options[OPT_TIMEOUT].o_reply = rexmtval = to;
427 		else
428 			options[OPT_TIMEOUT].o_request = NULL;
429 	}
430 
431 	ecode = (*pf->f_validate)(&filename, tp->th_opcode);
432 	if (has_options)
433 		oack();
434 	if (logging) {
435 		char hbuf[NI_MAXHOST];
436 
437 		getnameinfo((struct sockaddr *)&from, from.ss_len,
438 			    hbuf, sizeof(hbuf), NULL, 0,
439 			    NI_WITHSCOPEID);
440 		syslog(LOG_INFO, "%s: %s request for %s: %s", hbuf,
441 			tp->th_opcode == WRQ ? "write" : "read",
442 			filename, errtomsg(ecode));
443 	}
444 	if (ecode) {
445 		/*
446 		 * Avoid storms of naks to a RRQ broadcast for a relative
447 		 * bootfile pathname from a diskless Sun.
448 		 */
449 		if (suppress_naks && *filename != '/' && ecode == ENOTFOUND)
450 			exit(0);
451 		nak(ecode);
452 		exit(1);
453 	}
454 	if (tp->th_opcode == WRQ)
455 		(*pf->f_recv)(pf);
456 	else
457 		(*pf->f_send)(pf);
458 	exit(0);
459 }
460 
461 
462 FILE *file;
463 
464 /*
465  * Validate file access.  Since we
466  * have no uid or gid, for now require
467  * file to exist and be publicly
468  * readable/writable.
469  * If we were invoked with arguments
470  * from inetd then the file must also be
471  * in one of the given directory prefixes.
472  * Note also, full path name must be
473  * given as we have no login directory.
474  */
475 int
476 validate_access(char **filep, int mode)
477 {
478 	struct stat stbuf;
479 	int	fd;
480 	struct dirlist *dirp;
481 	static char pathname[MAXPATHLEN];
482 	char *filename = *filep;
483 
484 	/*
485 	 * Prevent tricksters from getting around the directory restrictions
486 	 */
487 	if (strstr(filename, "/../"))
488 		return (EACCESS);
489 
490 	if (*filename == '/') {
491 		/*
492 		 * Allow the request if it's in one of the approved locations.
493 		 * Special case: check the null prefix ("/") by looking
494 		 * for length = 1 and relying on the arg. processing that
495 		 * it's a /.
496 		 */
497 		for (dirp = dirs; dirp->name != NULL; dirp++) {
498 			if (dirp->len == 1 ||
499 			    (!strncmp(filename, dirp->name, dirp->len) &&
500 			     filename[dirp->len] == '/'))
501 				    break;
502 		}
503 		/* If directory list is empty, allow access to any file */
504 		if (dirp->name == NULL && dirp != dirs)
505 			return (EACCESS);
506 		if (stat(filename, &stbuf) < 0)
507 			return (errno == ENOENT ? ENOTFOUND : EACCESS);
508 		if ((stbuf.st_mode & S_IFMT) != S_IFREG)
509 			return (ENOTFOUND);
510 		if (mode == RRQ) {
511 			if ((stbuf.st_mode & S_IROTH) == 0)
512 				return (EACCESS);
513 		} else {
514 			if ((stbuf.st_mode & S_IWOTH) == 0)
515 				return (EACCESS);
516 		}
517 	} else {
518 		int err;
519 
520 		/*
521 		 * Relative file name: search the approved locations for it.
522 		 * Don't allow write requests that avoid directory
523 		 * restrictions.
524 		 */
525 
526 		if (!strncmp(filename, "../", 3))
527 			return (EACCESS);
528 
529 		/*
530 		 * If the file exists in one of the directories and isn't
531 		 * readable, continue looking. However, change the error code
532 		 * to give an indication that the file exists.
533 		 */
534 		err = ENOTFOUND;
535 		for (dirp = dirs; dirp->name != NULL; dirp++) {
536 			snprintf(pathname, sizeof(pathname), "%s/%s",
537 				dirp->name, filename);
538 			if (stat(pathname, &stbuf) == 0 &&
539 			    (stbuf.st_mode & S_IFMT) == S_IFREG) {
540 				if ((stbuf.st_mode & S_IROTH) != 0) {
541 					break;
542 				}
543 				err = EACCESS;
544 			}
545 		}
546 		if (dirp->name == NULL)
547 			return (err);
548 		*filep = filename = pathname;
549 	}
550 	if (options[OPT_TSIZE].o_request) {
551 		if (mode == RRQ)
552 			options[OPT_TSIZE].o_reply = stbuf.st_size;
553 		else
554 			/* XXX Allows writes of all sizes. */
555 			options[OPT_TSIZE].o_reply =
556 				atoi(options[OPT_TSIZE].o_request);
557 	}
558 	fd = open(filename, mode == RRQ ? O_RDONLY : O_WRONLY|O_TRUNC);
559 	if (fd < 0)
560 		return (errno + 100);
561 	file = fdopen(fd, (mode == RRQ)? "r":"w");
562 	if (file == NULL) {
563 		return errno+100;
564 	}
565 	return (0);
566 }
567 
568 int	timeouts;
569 jmp_buf	timeoutbuf;
570 
571 void
572 timer(int sig __unused)
573 {
574 	if (++timeouts > MAX_TIMEOUTS)
575 		exit(1);
576 	longjmp(timeoutbuf, 1);
577 }
578 
579 /*
580  * Send the requested file.
581  */
582 void
583 xmitfile(struct formats *pf)
584 {
585 	struct tftphdr *dp;
586 	struct tftphdr *ap;    /* ack packet */
587 	int size, n;
588 	volatile unsigned short block;
589 
590 	signal(SIGALRM, timer);
591 	dp = r_init();
592 	ap = (struct tftphdr *)ackbuf;
593 	block = 1;
594 	do {
595 		size = readit(file, &dp, pf->f_convert);
596 		if (size < 0) {
597 			nak(errno + 100);
598 			goto abort;
599 		}
600 		dp->th_opcode = htons((u_short)DATA);
601 		dp->th_block = htons((u_short)block);
602 		timeouts = 0;
603 		(void)setjmp(timeoutbuf);
604 
605 send_data:
606 		{
607 			int i, t = 1;
608 			for (i = 0; ; i++){
609 				if (send(peer, dp, size + 4, 0) != size + 4) {
610 					sleep(t);
611 					t = (t < 32) ? t<< 1 : t;
612 					if (i >= 12) {
613 						syslog(LOG_ERR, "write: %m");
614 						goto abort;
615 					}
616 				}
617 				break;
618 			}
619 		}
620 		read_ahead(file, pf->f_convert);
621 		for ( ; ; ) {
622 			alarm(rexmtval);        /* read the ack */
623 			n = recv(peer, ackbuf, sizeof (ackbuf), 0);
624 			alarm(0);
625 			if (n < 0) {
626 				syslog(LOG_ERR, "read: %m");
627 				goto abort;
628 			}
629 			ap->th_opcode = ntohs((u_short)ap->th_opcode);
630 			ap->th_block = ntohs((u_short)ap->th_block);
631 
632 			if (ap->th_opcode == ERROR)
633 				goto abort;
634 
635 			if (ap->th_opcode == ACK) {
636 				if (ap->th_block == block)
637 					break;
638 				/* Re-synchronize with the other side */
639 				(void) synchnet(peer);
640 				if (ap->th_block == (block -1))
641 					goto send_data;
642 			}
643 
644 		}
645 		block++;
646 	} while (size == SEGSIZE);
647 abort:
648 	(void) fclose(file);
649 }
650 
651 void
652 justquit(int sig __unused)
653 {
654 	exit(0);
655 }
656 
657 
658 /*
659  * Receive a file.
660  */
661 void
662 recvfile(struct formats *pf)
663 {
664 	struct tftphdr *dp;
665 	struct tftphdr *ap;    /* ack buffer */
666 	int n, size;
667 	volatile unsigned short block;
668 
669 	signal(SIGALRM, timer);
670 	dp = w_init();
671 	ap = (struct tftphdr *)ackbuf;
672 	block = 0;
673 	do {
674 		timeouts = 0;
675 		ap->th_opcode = htons((u_short)ACK);
676 		ap->th_block = htons((u_short)block);
677 		block++;
678 		(void) setjmp(timeoutbuf);
679 send_ack:
680 		if (send(peer, ackbuf, 4, 0) != 4) {
681 			syslog(LOG_ERR, "write: %m");
682 			goto abort;
683 		}
684 		write_behind(file, pf->f_convert);
685 		for ( ; ; ) {
686 			alarm(rexmtval);
687 			n = recv(peer, dp, PKTSIZE, 0);
688 			alarm(0);
689 			if (n < 0) {            /* really? */
690 				syslog(LOG_ERR, "read: %m");
691 				goto abort;
692 			}
693 			dp->th_opcode = ntohs((u_short)dp->th_opcode);
694 			dp->th_block = ntohs((u_short)dp->th_block);
695 			if (dp->th_opcode == ERROR)
696 				goto abort;
697 			if (dp->th_opcode == DATA) {
698 				if (dp->th_block == block) {
699 					break;   /* normal */
700 				}
701 				/* Re-synchronize with the other side */
702 				(void) synchnet(peer);
703 				if (dp->th_block == (block-1))
704 					goto send_ack;          /* rexmit */
705 			}
706 		}
707 		/*  size = write(file, dp->th_data, n - 4); */
708 		size = writeit(file, &dp, n - 4, pf->f_convert);
709 		if (size != (n-4)) {                    /* ahem */
710 			if (size < 0) nak(errno + 100);
711 			else nak(ENOSPACE);
712 			goto abort;
713 		}
714 	} while (size == SEGSIZE);
715 	write_behind(file, pf->f_convert);
716 	(void) fclose(file);            /* close data file */
717 
718 	ap->th_opcode = htons((u_short)ACK);    /* send the "final" ack */
719 	ap->th_block = htons((u_short)(block));
720 	(void) send(peer, ackbuf, 4, 0);
721 
722 	signal(SIGALRM, justquit);      /* just quit on timeout */
723 	alarm(rexmtval);
724 	n = recv(peer, buf, sizeof (buf), 0); /* normally times out and quits */
725 	alarm(0);
726 	if (n >= 4 &&                   /* if read some data */
727 	    dp->th_opcode == DATA &&    /* and got a data block */
728 	    block == dp->th_block) {	/* then my last ack was lost */
729 		(void) send(peer, ackbuf, 4, 0);     /* resend final ack */
730 	}
731 abort:
732 	return;
733 }
734 
735 struct errmsg {
736 	int	e_code;
737 	const char	*e_msg;
738 } errmsgs[] = {
739 	{ EUNDEF,	"Undefined error code" },
740 	{ ENOTFOUND,	"File not found" },
741 	{ EACCESS,	"Access violation" },
742 	{ ENOSPACE,	"Disk full or allocation exceeded" },
743 	{ EBADOP,	"Illegal TFTP operation" },
744 	{ EBADID,	"Unknown transfer ID" },
745 	{ EEXISTS,	"File already exists" },
746 	{ ENOUSER,	"No such user" },
747 	{ EOPTNEG,	"Option negotiation" },
748 	{ -1,		0 }
749 };
750 
751 static const char *
752 errtomsg(int error)
753 {
754 	static char ebuf[20];
755 	struct errmsg *pe;
756 	if (error == 0)
757 		return "success";
758 	for (pe = errmsgs; pe->e_code >= 0; pe++)
759 		if (pe->e_code == error)
760 			return pe->e_msg;
761 	snprintf(ebuf, sizeof(buf), "error %d", error);
762 	return ebuf;
763 }
764 
765 /*
766  * Send a nak packet (error message).
767  * Error code passed in is one of the
768  * standard TFTP codes, or a UNIX errno
769  * offset by 100.
770  */
771 static void
772 nak(int error)
773 {
774 	struct tftphdr *tp;
775 	int length;
776 	struct errmsg *pe;
777 
778 	tp = (struct tftphdr *)buf;
779 	tp->th_opcode = htons((u_short)ERROR);
780 	tp->th_code = htons((u_short)error);
781 	for (pe = errmsgs; pe->e_code >= 0; pe++)
782 		if (pe->e_code == error)
783 			break;
784 	if (pe->e_code < 0) {
785 		pe->e_msg = strerror(error - 100);
786 		tp->th_code = EUNDEF;   /* set 'undef' errorcode */
787 	}
788 	strcpy(tp->th_msg, pe->e_msg);
789 	length = strlen(pe->e_msg);
790 	tp->th_msg[length] = '\0';
791 	length += 5;
792 	if (send(peer, buf, length, 0) != length)
793 		syslog(LOG_ERR, "nak: %m");
794 }
795 
796 /* translate IPv4 mapped IPv6 address to IPv4 address */
797 static void
798 unmappedaddr(struct sockaddr_in6 *sin6)
799 {
800 	struct sockaddr_in *sin4;
801 	u_int32_t addr;
802 	int port;
803 
804 	if (sin6->sin6_family != AF_INET6 ||
805 	    !IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
806 		return;
807 	sin4 = (struct sockaddr_in *)sin6;
808 	addr = *(u_int32_t *)&sin6->sin6_addr.s6_addr[12];
809 	port = sin6->sin6_port;
810 	memset(sin4, 0, sizeof(struct sockaddr_in));
811 	sin4->sin_addr.s_addr = addr;
812 	sin4->sin_port = port;
813 	sin4->sin_family = AF_INET;
814 	sin4->sin_len = sizeof(struct sockaddr_in);
815 }
816 
817 /*
818  * Send an oack packet (option acknowledgement).
819  */
820 static void
821 oack(void)
822 {
823 	struct tftphdr *tp, *ap;
824 	int size, i, n;
825 	char *bp;
826 
827 	tp = (struct tftphdr *)buf;
828 	bp = buf + 2;
829 	size = sizeof(buf) - 2;
830 	tp->th_opcode = htons((u_short)OACK);
831 	for (i = 0; options[i].o_type != NULL; i++) {
832 		if (options[i].o_request) {
833 			n = snprintf(bp, size, "%s%c%d", options[i].o_type,
834 				     0, options[i].o_reply);
835 			bp += n+1;
836 			size -= n+1;
837 			if (size < 0) {
838 				syslog(LOG_ERR, "oack: buffer overflow");
839 				exit(1);
840 			}
841 		}
842 	}
843 	size = bp - buf;
844 	ap = (struct tftphdr *)ackbuf;
845 	signal(SIGALRM, timer);
846 	timeouts = 0;
847 
848 	(void)setjmp(timeoutbuf);
849 	if (send(peer, buf, size, 0) != size) {
850 		syslog(LOG_INFO, "oack: %m");
851 		exit(1);
852 	}
853 
854 	for (;;) {
855 		alarm(rexmtval);
856 		n = recv(peer, ackbuf, sizeof (ackbuf), 0);
857 		alarm(0);
858 		if (n < 0) {
859 			syslog(LOG_ERR, "recv: %m");
860 			exit(1);
861 		}
862 		ap->th_opcode = ntohs((u_short)ap->th_opcode);
863 		ap->th_block = ntohs((u_short)ap->th_block);
864 		if (ap->th_opcode == ERROR)
865 			exit(1);
866 		if (ap->th_opcode == ACK && ap->th_block == 0)
867 			break;
868 	}
869 }
870