Initial import from FreeBSD RELENG_4:
[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
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: src/libexec/tftpd/tftpd.c,v 1.15.2.5 2003/04/06 19:42:56 dwmalone Exp $";
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 }