Oops, remove comma.
[dragonfly.git] / libexec / tftpd / tftpd.c
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  * @(#) Copyright (c) 1983, 1993 The Regents of the University of California.  All rights reserved.
34  * @(#)tftpd.c  8.1 (Berkeley) 6/4/93
35  * $FreeBSD: src/libexec/tftpd/tftpd.c,v 1.15.2.5 2003/04/06 19:42:56 dwmalone Exp $
36  * $DragonFly: src/libexec/tftpd/tftpd.c,v 1.3 2003/11/20 14:32:17 eirikn Exp $
37  */
38
39 /*
40  * Trivial file transfer protocol server.
41  *
42  * This version includes many modifications by Jim Guyton
43  * <guyton@rand-unix>.
44  */
45
46 #include <sys/param.h>
47 #include <sys/ioctl.h>
48 #include <sys/stat.h>
49 #include <sys/socket.h>
50 #include <sys/types.h>
51
52 #include <netinet/in.h>
53 #include <arpa/tftp.h>
54 #include <arpa/inet.h>
55
56 #include <ctype.h>
57 #include <errno.h>
58 #include <fcntl.h>
59 #include <libutil.h>
60 #include <netdb.h>
61 #include <pwd.h>
62 #include <setjmp.h>
63 #include <signal.h>
64 #include <stdio.h>
65 #include <stdlib.h>
66 #include <string.h>
67 #include <syslog.h>
68 #include <unistd.h>
69
70 #include "tftpsubs.h"
71
72 #define TIMEOUT         5
73 #define MAX_TIMEOUTS    5
74
75 int     peer;
76 int     rexmtval = TIMEOUT;
77 int     max_rexmtval = 2*TIMEOUT;
78
79 #define PKTSIZE SEGSIZE+4
80 char    buf[PKTSIZE];
81 char    ackbuf[PKTSIZE];
82 struct  sockaddr_storage from;
83 int     fromlen;
84
85 void    tftp(struct tftphdr *, int);
86 static void unmappedaddr(struct sockaddr_in6 *);
87
88 /*
89  * Null-terminated directory prefix list for absolute pathname requests and
90  * search list for relative pathname requests.
91  *
92  * MAXDIRS should be at least as large as the number of arguments that
93  * inetd allows (currently 20).
94  */
95 #define MAXDIRS 20
96 static struct dirlist {
97         const char      *name;
98         int     len;
99 } dirs[MAXDIRS+1];
100 static int      suppress_naks;
101 static int      logging;
102 static int      ipchroot;
103
104 static const char *errtomsg(int);
105 static void  nak(int);
106 static void  oack(void);
107
108 static void  timer(int);
109 static void  justquit(int);
110
111 int
112 main(int argc, char *argv[])
113 {
114         struct tftphdr *tp;
115         int n;
116         int ch, on;
117         struct sockaddr_storage me;
118         int len;
119         char *chroot_dir = NULL;
120         struct passwd *nobody;
121         const char *chuser = "nobody";
122
123         openlog("tftpd", LOG_PID | LOG_NDELAY, LOG_FTP);
124         while ((ch = getopt(argc, argv, "cClns:u:")) != -1) {
125                 switch (ch) {
126                 case 'c':
127                         ipchroot = 1;
128                         break;
129                 case 'C':
130                         ipchroot = 2;
131                         break;
132                 case 'l':
133                         logging = 1;
134                         break;
135                 case 'n':
136                         suppress_naks = 1;
137                         break;
138                 case 's':
139                         chroot_dir = optarg;
140                         break;
141                 case 'u':
142                         chuser = optarg;
143                         break;
144                 default:
145                         syslog(LOG_WARNING, "ignoring unknown option -%c", ch);
146                 }
147         }
148         if (optind < argc) {
149                 struct dirlist *dirp;
150
151                 /* Get list of directory prefixes. Skip relative pathnames. */
152                 for (dirp = dirs; optind < argc && dirp < &dirs[MAXDIRS];
153                      optind++) {
154                         if (argv[optind][0] == '/') {
155                                 dirp->name = argv[optind];
156                                 dirp->len  = strlen(dirp->name);
157                                 dirp++;
158                         }
159                 }
160         }
161         else if (chroot_dir) {
162                 dirs->name = "/";
163                 dirs->len = 1;
164         }
165         if (ipchroot && chroot_dir == NULL) {
166                 syslog(LOG_ERR, "-c requires -s");
167                 exit(1);
168         }
169
170         on = 1;
171         if (ioctl(0, FIONBIO, &on) < 0) {
172                 syslog(LOG_ERR, "ioctl(FIONBIO): %m");
173                 exit(1);
174         }
175         fromlen = sizeof (from);
176         n = recvfrom(0, buf, sizeof (buf), 0,
177             (struct sockaddr *)&from, &fromlen);
178         if (n < 0) {
179                 syslog(LOG_ERR, "recvfrom: %m");
180                 exit(1);
181         }
182         /*
183          * Now that we have read the message out of the UDP
184          * socket, we fork and exit.  Thus, inetd will go back
185          * to listening to the tftp port, and the next request
186          * to come in will start up a new instance of tftpd.
187          *
188          * We do this so that inetd can run tftpd in "wait" mode.
189          * The problem with tftpd running in "nowait" mode is that
190          * inetd may get one or more successful "selects" on the
191          * tftp port before we do our receive, so more than one
192          * instance of tftpd may be started up.  Worse, if tftpd
193          * break before doing the above "recvfrom", inetd would
194          * spawn endless instances, clogging the system.
195          */
196         {
197                 int pid;
198                 int i, j;
199
200                 for (i = 1; i < 20; i++) {
201                     pid = fork();
202                     if (pid < 0) {
203                                 sleep(i);
204                                 /*
205                                  * flush out to most recently sent request.
206                                  *
207                                  * This may drop some request, but those
208                                  * will be resent by the clients when
209                                  * they timeout.  The positive effect of
210                                  * this flush is to (try to) prevent more
211                                  * than one tftpd being started up to service
212                                  * a single request from a single client.
213                                  */
214                                 j = sizeof from;
215                                 i = recvfrom(0, buf, sizeof (buf), 0,
216                                     (struct sockaddr *)&from, &j);
217                                 if (i > 0) {
218                                         n = i;
219                                         fromlen = j;
220                                 }
221                     } else {
222                                 break;
223                     }
224                 }
225                 if (pid < 0) {
226                         syslog(LOG_ERR, "fork: %m");
227                         exit(1);
228                 } else if (pid != 0) {
229                         exit(0);
230                 }
231         }
232
233         /*
234          * Since we exit here, we should do that only after the above
235          * recvfrom to keep inetd from constantly forking should there
236          * be a problem.  See the above comment about system clogging.
237          */
238         if (chroot_dir) {
239                 if (ipchroot) {
240                         char *tempchroot;
241                         struct stat sb;
242                         int statret;
243                         struct sockaddr_storage ss;
244                         char hbuf[NI_MAXHOST];
245
246                         memcpy(&ss, &from, from.ss_len);
247                         unmappedaddr((struct sockaddr_in6 *)&ss);
248                         getnameinfo((struct sockaddr *)&ss, ss.ss_len,
249                                     hbuf, sizeof(hbuf), NULL, 0,
250                                     NI_NUMERICHOST | NI_WITHSCOPEID);
251                         asprintf(&tempchroot, "%s/%s", chroot_dir, hbuf);
252                         statret = stat(tempchroot, &sb);
253                         if ((sb.st_mode & S_IFDIR) &&
254                             (statret == 0 || (statret == -1 && ipchroot == 1)))
255                                 chroot_dir = tempchroot;
256                 }
257                 /* Must get this before chroot because /etc might go away */
258                 if ((nobody = getpwnam(chuser)) == NULL) {
259                         syslog(LOG_ERR, "%s: no such user", chuser);
260                         exit(1);
261                 }
262                 if (chroot(chroot_dir)) {
263                         syslog(LOG_ERR, "chroot: %s: %m", chroot_dir);
264                         exit(1);
265                 }
266                 chdir( "/" );
267                 setuid(nobody->pw_uid);
268                 setgroups(1, &nobody->pw_gid);
269         }
270
271         len = sizeof(me);
272         if (getsockname(0, (struct sockaddr *)&me, &len) == 0) {
273                 switch (me.ss_family) {
274                 case AF_INET:
275                         ((struct sockaddr_in *)&me)->sin_port = 0;
276                         break;
277                 case AF_INET6:
278                         ((struct sockaddr_in6 *)&me)->sin6_port = 0;
279                         break;
280                 default:
281                         /* unsupported */
282                         break;
283                 }
284         } else {
285                 memset(&me, 0, sizeof(me));
286                 me.ss_family = from.ss_family;
287                 me.ss_len = from.ss_len;
288         }
289         alarm(0);
290         close(0);
291         close(1);
292         peer = socket(from.ss_family, SOCK_DGRAM, 0);
293         if (peer < 0) {
294                 syslog(LOG_ERR, "socket: %m");
295                 exit(1);
296         }
297         if (bind(peer, (struct sockaddr *)&me, me.ss_len) < 0) {
298                 syslog(LOG_ERR, "bind: %m");
299                 exit(1);
300         }
301         if (connect(peer, (struct sockaddr *)&from, from.ss_len) < 0) {
302                 syslog(LOG_ERR, "connect: %m");
303                 exit(1);
304         }
305         tp = (struct tftphdr *)buf;
306         tp->th_opcode = ntohs(tp->th_opcode);
307         if (tp->th_opcode == RRQ || tp->th_opcode == WRQ)
308                 tftp(tp, n);
309         exit(1);
310 }
311
312 struct formats;
313 int     validate_access(char **, int);
314 void    xmitfile(struct formats *);
315 void    recvfile(struct formats *);
316
317 struct formats {
318         const char      *f_mode;
319         int     (*f_validate)(char **, int);
320         void    (*f_send)(struct formats *);
321         void    (*f_recv)(struct formats *);
322         int     f_convert;
323 } formats[] = {
324         { "netascii",   validate_access,        xmitfile,       recvfile, 1 },
325         { "octet",      validate_access,        xmitfile,       recvfile, 0 },
326 #ifdef notdef
327         { "mail",       validate_user,          sendmail,       recvmail, 1 },
328 #endif
329         { 0,            NULL,                   NULL,           NULL,     0 }
330 };
331
332 struct options {
333         const char      *o_type;
334         char    *o_request;
335         int     o_reply;        /* turn into union if need be */
336 } options[] = {
337         { "tsize",      NULL, 0 },              /* OPT_TSIZE */
338         { "timeout",    NULL, 0 },              /* OPT_TIMEOUT */
339         { NULL,         NULL, 0 }
340 };
341
342 enum opt_enum {
343         OPT_TSIZE = 0,
344         OPT_TIMEOUT,
345 };
346
347 /*
348  * Handle initial connection protocol.
349  */
350 void
351 tftp(struct tftphdr *tp, int size)
352 {
353         char *cp;
354         int i, first = 1, has_options = 0, ecode;
355         struct formats *pf;
356         char *filename, *mode, *option, *ccp;
357         char fnbuf[MAXPATHLEN];
358
359         cp = tp->th_stuff;
360 again:
361         while (cp < buf + size) {
362                 if (*cp == '\0')
363                         break;
364                 cp++;
365         }
366         if (*cp != '\0') {
367                 nak(EBADOP);
368                 exit(1);
369         }
370         i = cp - tp->th_stuff;
371         if (i >= sizeof(fnbuf)) {
372                 nak(EBADOP);
373                 exit(1);
374         }
375         memcpy(fnbuf, tp->th_stuff, i);
376         fnbuf[i] = '\0';
377         filename = fnbuf;
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 }