Debian Codegraph @

src/tftp.c

raw
1 /* dnsmasq is Copyright (c) 2000-2026 Simon Kelley
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 dated June, 1991, or
6 (at your option) version 3 dated 29 June, 2007.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with this program. If not, see <http://www.gnu.org/licenses/>.
15 */
16
17 #include "dnsmasq.h"
18
19 #ifdef HAVE_TFTP
20
21 static void handle_tftp(char *packet, time_t now, struct tftp_transfer *transfer, ssize_t len);
22 static struct tftp_file *check_tftp_fileperm(char *packet, ssize_t *len, char *prefix, char *client);
23 static void free_transfer(struct tftp_transfer *transfer);
24 static ssize_t tftp_err(int err, char *packet, char *message, char *file, char *arg2);
25 static ssize_t tftp_err_oops(char *packet, const char *file);
26 static ssize_t get_block(struct tftp_transfer *transfer);
27 static char *next(char **p, char *end);
28 static void sanitise(char *buf);
29
30 #define OP_RRQ 1
31 #define OP_WRQ 2
32 #define OP_DATA 3
33 #define OP_ACK 4
34 #define OP_ERR 5
35 #define OP_OACK 6
36
37 #define ERR_NOTDEF 0
38 #define ERR_FNF 1
39 #define ERR_PERM 2
40 #define ERR_FULL 3
41 #define ERR_ILL 4
42 #define ERR_TID 5
43
44 static void tftp_request(char *packet, ssize_t plen, struct listener *listen, time_t now)
45 {
46 ssize_t len;
47 char *filename, *mode, *p, *end;
48 union mysockaddr addr, peer;
49 struct msghdr msg;
50 struct iovec iov;
51 struct ifreq ifr;
52 int is_err = 1, if_index = 0, mtu = 0;
53 struct iname *tmp;
54 struct tftp_transfer *transfer = NULL, **up;
55 int port = daemon->start_tftp_port; /* may be zero to use ephemeral port */
56 #if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT)
57 int mtuflag = IP_PMTUDISC_DONT;
58 #endif
59 char namebuff[IF_NAMESIZE];
60 char *name = NULL;
61 char *prefix = daemon->tftp_prefix;
62 struct tftp_prefix *pref;
63 union all_addr addra;
64 int family = listen->addr.sa.sa_family;
65 /* Can always get recvd interface for IPv6 */
66 int check_dest = !option_bool(OPT_NOWILD) || family == AF_INET6;
67 union {
68 struct cmsghdr align; /* this ensures alignment */
69 char control6[CMSG_SPACE(sizeof(struct in6_pktinfo))];
70 #if defined(HAVE_LINUX_NETWORK)
71 char control[CMSG_SPACE(sizeof(struct in_pktinfo))];
72 #elif defined(HAVE_SOLARIS_NETWORK)
73 char control[CMSG_SPACE(sizeof(struct in_addr)) +
74 CMSG_SPACE(sizeof(unsigned int))];
75 #elif defined(IP_RECVDSTADDR) && defined(IP_RECVIF)
76 char control[CMSG_SPACE(sizeof(struct in_addr)) +
77 CMSG_SPACE(sizeof(struct sockaddr_dl))];
78 #endif
79 } control_u;
80
81 msg.msg_controllen = sizeof(control_u);
82 msg.msg_control = control_u.control;
83 msg.msg_flags = 0;
84 msg.msg_name = &peer;
85 msg.msg_namelen = sizeof(peer);
86 msg.msg_iov = &iov;
87 msg.msg_iovlen = 1;
88
89 /* packet buff is DNS name workspace. */
90 iov.iov_base = packet;
91 iov.iov_len = plen;
92
93 if ((len = recvmsg(listen->tftpfd, &msg, 0)) < 2)
94 return;
95
96 #ifdef HAVE_DUMPFILE
97 dump_packet_udp(DUMP_TFTP, (void *)packet, len, (union mysockaddr *)&peer, NULL, listen->tftpfd);
98 #endif
99
100 /* Can always get recvd interface for IPv6 */
101 if (!check_dest)
102 {
103 if (listen->iface)
104 {
105 addr = listen->iface->addr;
106 name = listen->iface->name;
107 mtu = listen->iface->mtu;
108 if (daemon->tftp_mtu != 0 && daemon->tftp_mtu < mtu)
109 mtu = daemon->tftp_mtu;
110 }
111 else
112 {
113 /* we're listening on an address that doesn't appear on an interface,
114 ask the kernel what the socket is bound to */
115 socklen_t tcp_len = sizeof(union mysockaddr);
116 if (getsockname(listen->tftpfd, (struct sockaddr *)&addr, &tcp_len) == -1)
117 return;
118 }
119 }
120 else
121 {
122 struct cmsghdr *cmptr;
123
124 if (msg.msg_controllen < sizeof(struct cmsghdr))
125 return;
126
127 addr.sa.sa_family = family;
128
129 #if defined(HAVE_LINUX_NETWORK)
130 if (family == AF_INET)
131 for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
132 if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_PKTINFO)
133 {
134 union {
135 unsigned char *c;
136 struct in_pktinfo *p;
137 } p;
138 p.c = CMSG_DATA(cmptr);
139 addr.in.sin_addr = p.p->ipi_spec_dst;
140 if_index = p.p->ipi_ifindex;
141 }
142
143 #elif defined(HAVE_SOLARIS_NETWORK)
144 if (family == AF_INET)
145 for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
146 {
147 union {
148 unsigned char *c;
149 struct in_addr *a;
150 unsigned int *i;
151 } p;
152 p.c = CMSG_DATA(cmptr);
153 if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVDSTADDR)
154 addr.in.sin_addr = *(p.a);
155 else if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVIF)
156 if_index = *(p.i);
157 }
158
159 #elif defined(IP_RECVDSTADDR) && defined(IP_RECVIF)
160 if (family == AF_INET)
161 for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
162 {
163 union {
164 unsigned char *c;
165 struct in_addr *a;
166 struct sockaddr_dl *s;
167 } p;
168 p.c = CMSG_DATA(cmptr);
169 if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVDSTADDR)
170 addr.in.sin_addr = *(p.a);
171 else if (cmptr->cmsg_level == IPPROTO_IP && cmptr->cmsg_type == IP_RECVIF)
172 if_index = p.s->sdl_index;
173 }
174
175 #endif
176
177 if (family == AF_INET6)
178 {
179 for (cmptr = CMSG_FIRSTHDR(&msg); cmptr; cmptr = CMSG_NXTHDR(&msg, cmptr))
180 if (cmptr->cmsg_level == IPPROTO_IPV6 && cmptr->cmsg_type == daemon->v6pktinfo)
181 {
182 union {
183 unsigned char *c;
184 struct in6_pktinfo *p;
185 } p;
186 p.c = CMSG_DATA(cmptr);
187
188 addr.in6.sin6_addr = p.p->ipi6_addr;
189 if_index = p.p->ipi6_ifindex;
190 }
191 }
192
193 if (!indextoname(listen->tftpfd, if_index, namebuff))
194 return;
195
196 name = namebuff;
197
198 if (family == AF_INET6)
199 addra.addr6 = addr.in6.sin6_addr;
200 else
201 addra.addr4 = addr.in.sin_addr;
202
203 if (daemon->tftp_interfaces)
204 {
205 /* dedicated tftp interface list */
206 for (tmp = daemon->tftp_interfaces; tmp; tmp = tmp->next)
207 if (tmp->name && wildcard_match(tmp->name, name))
208 break;
209
210 if (!tmp)
211 return;
212 }
213 else
214 {
215 /* Do the same as DHCP */
216 if (!iface_check(family, &addra, name, NULL))
217 {
218 if (!option_bool(OPT_CLEVERBIND))
219 enumerate_interfaces(0);
220 if (!loopback_exception(listen->tftpfd, family, &addra, name) &&
221 !label_exception(if_index, family, &addra))
222 return;
223 }
224
225 #ifdef HAVE_DHCP
226 /* allowed interfaces are the same as for DHCP */
227 for (tmp = daemon->dhcp_except; tmp; tmp = tmp->next)
228 if (tmp->name && (tmp->flags & INAME_4) && (tmp->flags & INAME_6) &&
229 wildcard_match(tmp->name, name))
230 return;
231 #endif
232 }
233
234 safe_strncpy(ifr.ifr_name, name, IF_NAMESIZE);
235 if (ioctl(listen->tftpfd, SIOCGIFMTU, &ifr) != -1)
236 {
237 mtu = ifr.ifr_mtu;
238 if (daemon->tftp_mtu != 0 && daemon->tftp_mtu < mtu)
239 mtu = daemon->tftp_mtu;
240 }
241 }
242
243 /* Failed to get interface mtu - can use configured value. */
244 if (mtu == 0)
245 mtu = daemon->tftp_mtu;
246
247 /* data transfer via server listening socket */
248 if (option_bool(OPT_SINGLE_PORT))
249 {
250 int tftp_cnt;
251
252 for (tftp_cnt = 0, transfer = daemon->tftp_trans, up = &daemon->tftp_trans; transfer; up = &transfer->next, transfer = transfer->next)
253 {
254 tftp_cnt++;
255
256 if (sockaddr_isequal(&peer, &transfer->peer))
257 {
258 if (ntohs(*((unsigned short *)packet)) == OP_RRQ)
259 {
260 /* Handle repeated RRQ or abandoned transfer from same host and port
261 by unlinking and reusing the struct transfer. */
262 *up = transfer->next;
263 break;
264 }
265 else
266 {
267 handle_tftp(packet, now, transfer, len);
268 return;
269 }
270 }
271 }
272
273 /* Enforce simultaneous transfer limit. In non-single-port mode
274 this is done by not listening on the server socket when
275 too many transfers are in progress. */
276 if (!transfer && tftp_cnt >= daemon->tftp_max)
277 return;
278 }
279
280 if (name)
281 {
282 /* check for per-interface prefix */
283 for (pref = daemon->if_prefix; pref; pref = pref->next)
284 if (strcmp(pref->interface, name) == 0)
285 prefix = pref->prefix;
286 }
287
288 if (family == AF_INET)
289 {
290 addr.in.sin_port = htons(port);
291 #ifdef HAVE_SOCKADDR_SA_LEN
292 addr.in.sin_len = sizeof(addr.in);
293 #endif
294 }
295 else
296 {
297 addr.in6.sin6_port = htons(port);
298 addr.in6.sin6_flowinfo = 0;
299 addr.in6.sin6_scope_id = 0;
300 #ifdef HAVE_SOCKADDR_SA_LEN
301 addr.in6.sin6_len = sizeof(addr.in6);
302 #endif
303 }
304
305 /* May reuse struct transfer from abandoned transfer in single port mode. */
306 if (!transfer && !(transfer = whine_malloc(sizeof(struct tftp_transfer))))
307 return;
308
309 memset(transfer, 0, sizeof(struct tftp_transfer));
310
311 if (option_bool(OPT_SINGLE_PORT))
312 transfer->sockfd = listen->tftpfd;
313 else if ((transfer->sockfd = socket(family, SOCK_DGRAM, 0)) == -1)
314 {
315 free(transfer);
316 return;
317 }
318
319 transfer->peer = peer;
320 transfer->source = addra;
321 transfer->if_index = if_index;
322 transfer->timeout = 2;
323 transfer->start = now;
324 transfer->backoff = 1;
325 transfer->block = 1;
326 transfer->ackprev = 0;
327 transfer->block_hi = 0;
328 transfer->blocksize = 512;
329 transfer->windowsize = 1;
330
331 (void)prettyprint_addr(&peer, daemon->addrbuff);
332
333 /* if we have a nailed-down range, iterate until we find a free one. */
334 while (!option_bool(OPT_SINGLE_PORT))
335 {
336 if (bind(transfer->sockfd, &addr.sa, sa_len(&addr)) == -1 ||
337 #if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DONT)
338 setsockopt(transfer->sockfd, IPPROTO_IP, IP_MTU_DISCOVER, &mtuflag, sizeof(mtuflag)) == -1 ||
339 #endif
340 !fix_fd(transfer->sockfd))
341 {
342 if (errno == EADDRINUSE && daemon->start_tftp_port != 0)
343 {
344 if (++port <= daemon->end_tftp_port)
345 {
346 if (family == AF_INET)
347 addr.in.sin_port = htons(port);
348 else
349 addr.in6.sin6_port = htons(port);
350
351 continue;
352 }
353 my_syslog(MS_TFTP | LOG_ERR, _("unable to get free port for TFTP"));
354 }
355 free_transfer(transfer);
356 return;
357 }
358 break;
359 }
360
361 p = packet + 2;
362 end = packet + len;
363
364 len = 0;
365
366 if (ntohs(*((unsigned short *)packet)) == OP_WRQ)
367 len = tftp_err(ERR_ILL, packet, _("unsupported write request from %s"),daemon->addrbuff, NULL);
368 else if (ntohs(*((unsigned short *)packet)) == OP_RRQ)
369 {
370 if (!(filename = next(&p, end)))
371 len = tftp_err(ERR_ILL, packet, _("empty filename in request from %s"), daemon->addrbuff, NULL);
372 else if (!(mode = next(&p, end)) || (strcasecmp(mode, "octet") != 0 && strcasecmp(mode, "netascii") != 0))
373 len = tftp_err(ERR_ILL, packet, _("unsupported request from %s"),daemon->addrbuff, NULL);
374 else
375 {
376 char *opt, *arg;
377
378 if (strcasecmp(mode, "netascii") == 0)
379 transfer->netascii = 1;
380
381 while ((opt = next(&p, end)) && (arg = next(&p, end)))
382 {
383 unsigned int val = atoi(arg);
384
385 if (strcasecmp(opt, "blksize") == 0 && !option_bool(OPT_TFTP_NOBLOCK))
386 {
387 /* 32 bytes for IP, UDP and TFTP headers, 52 bytes for IPv6 */
388 int overhead = (family == AF_INET) ? 32 : 52;
389 if (val < 1)
390 val = 1;
391 if (val > (unsigned)daemon->packet_buff_sz - 4)
392 val = (unsigned)daemon->packet_buff_sz - 4;
393 if (mtu != 0 && val > (unsigned)mtu - overhead)
394 val = (unsigned)mtu - overhead;
395 transfer->blocksize = val;
396 transfer->opt_blocksize = 1;
397 transfer->block = 0;
398 }
399 else if (strcasecmp(opt, "tsize") == 0 && !transfer->netascii)
400 {
401 transfer->opt_transize = 1;
402 transfer->block = 0;
403 }
404 else if (strcasecmp(opt, "timeout") == 0)
405 {
406 if (val > 255)
407 val = 255;
408 transfer->timeout = val;
409 transfer->opt_timeout = 1;
410 transfer->block = 0;
411 }
412 else if (strcasecmp(opt, "windowsize") == 0 && !transfer->netascii)
413 {
414 /* windowsize option only supported for binary transfers. */
415 if (val < 1)
416 val = 1;
417 if (val > TFTP_MAX_WINDOW)
418 val = TFTP_MAX_WINDOW;
419 transfer->windowsize = val;
420 transfer->opt_windowsize = 1;
421 transfer->block = 0;
422 }
423 }
424
425 /* cope with backslashes from windows boxen. */
426 for (p = filename; *p; p++)
427 if (*p == '\\')
428 *p = '/';
429 else if (option_bool(OPT_TFTP_LC))
430 *p = tolower((unsigned char)*p);
431
432 strcpy(daemon->namebuff, "/");
433 if (prefix)
434 {
435 if (prefix[0] == '/')
436 daemon->namebuff[0] = 0;
437 strncat(daemon->namebuff, prefix, MAXDNAMESTR - strlen(daemon->namebuff));
438 if (prefix[strlen(prefix)-1] != '/')
439 strncat(daemon->namebuff, "/", MAXDNAMESTR - strlen(daemon->namebuff));
440
441 if (option_bool(OPT_TFTP_APREF_IP))
442 {
443 size_t oldlen = strlen(daemon->namebuff);
444 struct stat statbuf;
445
446 strncat(daemon->namebuff, daemon->addrbuff, MAXDNAMESTR - strlen(daemon->namebuff));
447 strncat(daemon->namebuff, "/", MAXDNAMESTR - strlen(daemon->namebuff));
448
449 /* remove unique-directory if it doesn't exist */
450 if (stat(daemon->namebuff, &statbuf) == -1 || !S_ISDIR(statbuf.st_mode))
451 daemon->namebuff[oldlen] = 0;
452 }
453
454 if (option_bool(OPT_TFTP_APREF_MAC))
455 {
456 unsigned char *macaddr = NULL;
457 unsigned char macbuf[DHCP_CHADDR_MAX];
458
459 #ifdef HAVE_DHCP
460 if (daemon->dhcp && peer.sa.sa_family == AF_INET)
461 {
462 /* Check if the client IP is in our lease database */
463 struct dhcp_lease *lease = lease_find_by_addr(peer.in.sin_addr);
464 if (lease && lease->hwaddr_type == ARPHRD_ETHER && lease->hwaddr_len == ETHER_ADDR_LEN)
465 macaddr = lease->hwaddr;
466 }
467 #endif
468
469 /* If no luck, try to find in ARP table. This only works if client is in same (V)LAN */
470 if (!macaddr && find_mac(&peer, macbuf, 1, now) > 0)
471 macaddr = macbuf;
472
473 if (macaddr)
474 {
475 size_t oldlen = strlen(daemon->namebuff);
476 struct stat statbuf;
477
478 snprintf(daemon->namebuff + oldlen, MAXDNAMESTR - oldlen, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x/",
479 macaddr[0], macaddr[1], macaddr[2], macaddr[3], macaddr[4], macaddr[5]);
480
481 /* remove unique-directory if it doesn't exist */
482 if (stat(daemon->namebuff, &statbuf) == -1 || !S_ISDIR(statbuf.st_mode))
483 daemon->namebuff[oldlen] = 0;
484 }
485 }
486
487 /* Absolute pathnames OK if they match prefix */
488 if (filename[0] == '/')
489 {
490 if (strstr(filename, daemon->namebuff) == filename)
491 daemon->namebuff[0] = 0;
492 else
493 filename++;
494 }
495 }
496 else if (filename[0] == '/')
497 daemon->namebuff[0] = 0;
498 strncat(daemon->namebuff, filename, MAXDNAMESTR - strlen(daemon->namebuff));
499
500 /* check permissions and open file */
501 if ((transfer->file = check_tftp_fileperm(packet, &len, prefix, daemon->addrbuff)))
502 {
503 transfer->lastack = transfer->block;
504 transfer->retransmit = now + transfer->timeout;
505 /* This packet is may be the first data packet, but only if windowsize == 1
506 To get windowsize greater then one requires an option negotiation,
507 in which case this packet is the OACK. */
508 if ((len = get_block(transfer)) == -1)
509 len = tftp_err_oops(packet, daemon->namebuff);
510 else
511 {
512 is_err = 0;
513 /* get_block put the packet to send in a different buffer. */
514 packet = daemon->packet;
515 }
516 }
517 }
518 }
519
520 if (len)
521 {
522 send_from(transfer->sockfd, !option_bool(OPT_SINGLE_PORT), packet, len, &peer, &addra, if_index);
523
524 #ifdef HAVE_DUMPFILE
525 dump_packet_udp(DUMP_TFTP, (void *)packet, len, NULL, (union mysockaddr *)&peer, transfer->sockfd);
526 #endif
527 }
528
529 if (is_err)
530 free_transfer(transfer);
531 else
532 {
533 transfer->next = daemon->tftp_trans;
534 daemon->tftp_trans = transfer;
535 }
536 }
537
538 static struct tftp_file *check_tftp_fileperm(char *packet, ssize_t *len, char *prefix, char *client)
539 {
540 char *namebuff = daemon->namebuff;
541 struct tftp_file *file;
542 struct tftp_transfer *t;
543 uid_t uid = geteuid();
544 struct stat statbuf;
545 int fd = -1;
546
547 /* trick to ban moving out of the subtree */
548 if (prefix)
549 {
550 char *suspect = strstr(namebuff, "/..");
551
552 if (suspect && (suspect[3] == '/' || suspect[3] == 0))
553 goto perm;
554 }
555
556 if ((fd = open(namebuff, O_RDONLY)) == -1)
557 {
558 if (errno == ENOENT)
559 {
560 *len = tftp_err(ERR_FNF, packet, _("file %s not found for %s"), namebuff, client);
561 return NULL;
562 }
563 else if (errno == EACCES)
564 goto perm;
565 else
566 goto oops;
567 }
568
569 /* stat the file descriptor to avoid stat->open races */
570 if (fstat(fd, &statbuf) == -1)
571 goto oops;
572
573 /* running as root, must be world-readable */
574 if (uid == 0)
575 {
576 if (!(statbuf.st_mode & S_IROTH))
577 goto perm;
578 }
579 /* in secure mode, must be owned by user running dnsmasq */
580 else if (option_bool(OPT_TFTP_SECURE) && uid != statbuf.st_uid)
581 goto perm;
582
583 /* If we're doing many transfers from the same file, only
584 open it once this saves lots of file descriptors
585 when mass-booting a big cluster, for instance.
586 Be conservative and only share when inode and name match
587 this keeps error messages sane. */
588 for (t = daemon->tftp_trans; t; t = t->next)
589 if (t->file->dev == statbuf.st_dev &&
590 t->file->inode == statbuf.st_ino &&
591 strcmp(t->file->filename, namebuff) == 0)
592 {
593 close(fd);
594 t->file->refcount++;
595 return t->file;
596 }
597
598 if (!(file = whine_malloc(sizeof(struct tftp_file) + strlen(namebuff) + 1)))
599 {
600 errno = ENOMEM;
601 goto oops;
602 }
603
604 file->fd = fd;
605 file->size = statbuf.st_size;
606 file->dev = statbuf.st_dev;
607 file->inode = statbuf.st_ino;
608 file->posn = 0;
609 file->refcount = 1;
610 strcpy(file->filename, namebuff);
611 return file;
612
613 perm:
614 *len = tftp_err(ERR_PERM, packet, _("cannot access %s: %s"), namebuff, strerror(EACCES));
615 if (fd != -1)
616 close(fd);
617 return NULL;
618
619 oops:
620 *len = tftp_err_oops(packet, namebuff);
621 if (fd != -1)
622 close(fd);
623 return NULL;
624 }
625
626 void check_tftp_listeners(time_t now)
627 {
628 /* Use workspace to receive (small) request/ACK, to avoid overwriting precomputed reply */
629 char *packet = daemon->workspacename;
630 ssize_t plen = MAXDNAMESTR;
631 struct listener *listener;
632 struct tftp_transfer *transfer, *tmp, **up;
633
634 for (listener = daemon->listeners; listener; listener = listener->next)
635 if (listener->tftpfd != -1 && poll_check(listener->tftpfd, POLLIN))
636 tftp_request(packet, plen, listener, now);
637
638 /* In single port mode, all packets come via port 69 and tftp_request() */
639 if (!option_bool(OPT_SINGLE_PORT))
640 for (transfer = daemon->tftp_trans; transfer; transfer = transfer->next)
641 if (poll_check(transfer->sockfd, POLLIN))
642 {
643 union mysockaddr peer;
644 socklen_t addr_len = sizeof(union mysockaddr);
645 ssize_t len;
646
647 if ((len = recvfrom(transfer->sockfd, packet, plen, 0, &peer.sa, &addr_len)) > 0)
648 {
649 #ifdef HAVE_DUMPFILE
650 dump_packet_udp(DUMP_TFTP, (void *)packet, len, (union mysockaddr *)&peer, NULL, transfer->sockfd);
651 #endif
652
653 if (sockaddr_isequal(&peer, &transfer->peer))
654 handle_tftp(packet, now, transfer, len);
655 else
656 {
657 /* Wrong source address. See rfc1350 para 4. */
658 prettyprint_addr(&peer, daemon->addrbuff);
659 len = tftp_err(ERR_TID, packet, _("ignoring packet from %s (TID mismatch)"), daemon->addrbuff, NULL);
660 while(retry_send(sendto(transfer->sockfd, packet, len, 0, &peer.sa, sa_len(&peer))));
661
662 #ifdef HAVE_DUMPFILE
663 dump_packet_udp(DUMP_TFTP, (void *)packet, len, NULL, (union mysockaddr *)&peer, transfer->sockfd);
664 #endif
665 }
666 }
667 }
668
669 for (transfer = daemon->tftp_trans, up = &daemon->tftp_trans; transfer; transfer = tmp)
670 {
671 int endcon = 0, error = 0, timeout = 0;
672
673 tmp = transfer->next;
674
675 /* ->start set to zero in handle_tftp() when we recv an error packet. */
676 if (transfer->start == 0)
677 endcon = error = 1;
678 else if (difftime(now, transfer->start) > TFTP_TRANSFER_TIME)
679 {
680 endcon = 1;
681 /* don't complain about timeout when we're awaiting the last
682 ACK, some clients never send it */
683 if (get_block(transfer) > 0)
684 error = timeout = 1;
685 }
686 else if (difftime(now, transfer->retransmit) >= 0.0)
687 {
688 /* Do transmission or re-transmission. When we get an ACK, the call to handle_tftp()
689 bumps transfer->lastack and trips the retransmit timer so that we send the next block(s)
690 here. */
691 ssize_t len;
692 unsigned int i, winsize;
693
694 transfer->retransmit += transfer->timeout + (1<<(transfer->backoff/2));
695 transfer->backoff++;
696 transfer->block = transfer->lastack;
697
698 /* send a window'a worth of blocks unless we're retransmitting OACK */
699 winsize = transfer->block ? transfer->windowsize : 1;
700
701 for (i = 0; i < winsize; i++, transfer->block++)
702 {
703 if ((len = get_block(transfer)) == 0)
704 {
705 if (i == 0)
706 endcon = 1; /* got last ACK */
707
708 break;
709 }
710
711 if (len == -1)
712 {
713 len = tftp_err_oops(daemon->packet, transfer->file->filename);
714 endcon = error = 1;
715 }
716
717 send_from(transfer->sockfd, !option_bool(OPT_SINGLE_PORT), daemon->packet, len,
718 &transfer->peer, &transfer->source, transfer->if_index);
719 #ifdef HAVE_DUMPFILE
720 dump_packet_udp(DUMP_TFTP, (void *)daemon->packet, len, NULL, (union mysockaddr *)&transfer->peer, transfer->sockfd);
721 #endif
722 }
723
724 /* prefetch the block we'll probably need when we get an ACK. */
725 if (!endcon)
726 get_block(transfer);
727 }
728
729 if (endcon)
730 {
731 strcpy(daemon->namebuff, transfer->file->filename);
732 sanitise(daemon->namebuff);
733 (void)prettyprint_addr(&transfer->peer, daemon->addrbuff);
734 if (timeout)
735 my_syslog(MS_TFTP | LOG_ERR, _("timeout sending %s to %s"), daemon->namebuff, daemon->addrbuff);
736 else if (error)
737 my_syslog(MS_TFTP | LOG_ERR, _("failed sending %s to %s"), daemon->namebuff, daemon->addrbuff);
738 else
739 my_syslog(MS_TFTP | LOG_INFO, _("sent %s to %s"), daemon->namebuff, daemon->addrbuff);
740
741 /* unlink */
742 *up = tmp;
743 if (error)
744 free_transfer(transfer);
745 else
746 {
747 /* put on queue to be sent to script and deleted */
748 transfer->next = daemon->tftp_done_trans;
749 daemon->tftp_done_trans = transfer;
750 }
751 }
752 else
753 up = &transfer->next;
754 }
755 }
756
757 static void handle_tftp(char *packet, time_t now, struct tftp_transfer *transfer, ssize_t len)
758 {
759 struct ack {
760 unsigned short op, block;
761 } *mess = (struct ack *)packet;
762
763 if (len >= (ssize_t)sizeof(struct ack))
764 {
765 if (ntohs(mess->op) == OP_ACK)
766 {
767 /* Handle 16-bit block number wrap-around. */
768 u16 new = ntohs(mess->block);
769 u32 block;
770
771 /* If the last ack received was in the top quarter of a 64k block
772 and this one is in the bottom quarter, assume it has wrapped.
773
774 Since this is UDP and an old packet can in theory wander in we may also
775 need to drop back to a previous segment. Such an ACK is ignored below;
776 here we're just getting the most likely 32 bit value from the
777 16 bits that we have. */
778 if (new <= 0x4000 && transfer->ackprev >= 0xc000)
779 transfer->block_hi++;
780 else if (new >= 0xc000 && transfer->ackprev <= 0x4000 && transfer->block_hi != 0)
781 transfer->block_hi--;
782
783 transfer->ackprev = new;
784 block = (((u32)transfer->block_hi) << 16) + (u32)new;
785
786 /* Ignore duplicate ACKs and ACKs for blocks we've not yet sent. */
787 if (block >= transfer->lastack &&
788 block <= transfer->block)
789 {
790 /* Got ack, move forward and ensure we take the (re)transmit path */
791 transfer->retransmit = transfer->start = now;
792 transfer->backoff = 0;
793 transfer->lastack = block + 1;
794
795 /* We have no easy function from block no. to file offset when
796 expanding line breaks in netascii mode, so we update the offset here
797 as each block is acknowledged. This explains why the window size must be
798 one for a netascii transfer; to avoid the block no. doing anything
799 other than incrementing by one. */
800 if (transfer->netascii && block != 0)
801 {
802 transfer->offset += (off_t)transfer->blocksize - (off_t)transfer->expansion;
803 transfer->lastcarrylf = transfer->carrylf;
804 }
805 }
806 }
807 else if (ntohs(mess->op) == OP_ERR)
808 {
809 char *p = packet + sizeof(struct ack);
810 char *end = packet + len;
811 char *err = next(&p, end);
812
813 (void)prettyprint_addr(&transfer->peer, daemon->addrbuff);
814
815 /* Sanitise error message */
816 if (!err)
817 err = "";
818 else
819 sanitise(err);
820
821 my_syslog(MS_TFTP | LOG_ERR, _("error %d %s received from %s"),
822 (int)ntohs(mess->block), err,
823 daemon->addrbuff);
824
825 /* Got err, ensure we take abort */
826 transfer->start = 0;
827 }
828 }
829 }
830
831 static void free_transfer(struct tftp_transfer *transfer)
832 {
833 if (!option_bool(OPT_SINGLE_PORT))
834 close(transfer->sockfd);
835
836 if (transfer->file && (--transfer->file->refcount) == 0)
837 {
838 close(transfer->file->fd);
839 free(transfer->file);
840 }
841
842 free(transfer);
843 }
844
845 static char *next(char **p, char *end)
846 {
847 char *n, *ret = *p;
848
849 /* Look for end of string, without running off the end of the packet. */
850 for (n = *p; n < end && *n != 0; n++);
851
852 /* ran off the end or zero length string - failed */
853 if (n == end || n == ret)
854 return NULL;
855
856 *p = n + 1;
857 return ret;
858 }
859
860 /* If we don't do anything, don't write the the input/ouptut
861 buffer. This allows us to pass in safe read-only strings constants. */
862 static void sanitise(char *buf)
863 {
864 unsigned char *q, *r;
865
866 for (q = r = (unsigned char *)buf; *r; r++)
867 if (isprint((int)*r))
868 {
869 if (q != r)
870 *q = *r;
871 q++;
872 }
873
874 if (q != r)
875 *q = 0;
876 }
877
878 #define MAXMESSAGE 500 /* limit to make packet < 512 bytes and definitely smaller than buffer */
879 static ssize_t tftp_err(int err, char *packet, char *message, char *file, char *arg2)
880 {
881 struct errmess {
882 unsigned short op, err;
883 char message[];
884 } *mess = (struct errmess *)packet;
885 ssize_t len, ret = 4;
886
887 if (file)
888 sanitise(file);
889
890 mess->op = htons(OP_ERR);
891 mess->err = htons(err);
892 len = snprintf(mess->message, MAXMESSAGE, message, file, arg2);
893 ret += (len < MAXMESSAGE) ? len + 1 : MAXMESSAGE; /* include terminating zero */
894
895 if (err != ERR_FNF || !option_bool(OPT_QUIET_TFTP))
896 my_syslog(MS_TFTP | LOG_ERR, "%s", mess->message);
897
898 return ret;
899 }
900
901 static ssize_t tftp_err_oops(char *packet, const char *file)
902 {
903 /* May have >1 refs to file, so potentially mangle a copy of the name */
904 if (file != daemon->namebuff)
905 strcpy(daemon->namebuff, file);
906 return tftp_err(ERR_NOTDEF, packet, _("cannot read %s: %s"), daemon->namebuff, strerror(errno));
907 }
908
909 /* return -1 for error, zero for done. */
910 static ssize_t get_block(struct tftp_transfer *transfer)
911 {
912 static off_t saved_offset = 0;
913 static ssize_t saved_len = 0;
914
915 if (transfer->block == 0)
916 {
917 /* send OACK */
918 char *p;
919 struct oackmess {
920 unsigned short op;
921 char data[];
922 } *mess = (struct oackmess *)daemon->packet;
923
924 /* we overwrote the buffer... */
925 daemon->srv_save = NULL;
926 memset(daemon->packet, 0, daemon->packet_buff_sz);
927
928 p = mess->data;
929 mess->op = htons(OP_OACK);
930 if (transfer->opt_blocksize)
931 {
932 p += (sprintf(p, "blksize") + 1);
933 p += (sprintf(p, "%u", transfer->blocksize) + 1);
934 }
935 if (transfer->opt_transize)
936 {
937 p += (sprintf(p,"tsize") + 1);
938 p += (sprintf(p, "%u", (unsigned int)transfer->file->size) + 1);
939 }
940 if (transfer->opt_timeout)
941 {
942 p += (sprintf(p,"timeout") + 1);
943 p += (sprintf(p, "%u", transfer->timeout) + 1);
944 }
945 if (transfer->opt_windowsize)
946 {
947 p += (sprintf(p,"windowsize") + 1);
948 p += (sprintf(p, "%u", (unsigned int)transfer->windowsize) + 1);
949 }
950
951 return p - daemon->packet;
952 }
953 else
954 {
955 /* send data packet */
956 struct datamess {
957 unsigned short op, block;
958 unsigned char data[];
959 } *mess = (struct datamess *)daemon->packet;
960
961 size_t size;
962
963 if (!transfer->netascii)
964 transfer->offset = (off_t)(transfer->block - 1) * (off_t)transfer->blocksize;
965
966 if (transfer->offset > transfer->file->size)
967 return 0; /* finished */
968
969 /* We may have a prefetched block already in the buffer. */
970 if (daemon->srv_save == transfer && saved_offset == transfer->offset)
971 return saved_len;
972
973 /* we overwrote the buffer... */
974 daemon->srv_save = NULL;
975
976 if ((size = transfer->file->size - transfer->offset) > (size_t)transfer->blocksize)
977 size = (size_t)transfer->blocksize;
978
979 mess->op = htons(OP_DATA);
980 mess->block = htons((unsigned short)(transfer->block));
981
982 if (size != 0)
983 {
984 if (transfer->file->posn != transfer->offset &&
985 lseek(transfer->file->fd, transfer->offset, SEEK_SET) == (off_t)-1)
986 return -1;
987
988 if (!read_write(transfer->file->fd, mess->data, size, RW_READ))
989 return -1;
990
991 transfer->file->posn = transfer->offset + size;
992 }
993
994 /* Map '\n' to CR-LF in netascii mode */
995 if (transfer->netascii)
996 {
997 size_t i;
998
999 /* Map '\n' to CR-LF in netascii mode */
1000 transfer->expansion = transfer->carrylf = 0;
1001
1002 for (i = 0; i < size; i++)
1003 if (mess->data[i] == '\n' && (i != 0 || !transfer->lastcarrylf))
1004 {
1005 transfer->expansion++;
1006
1007 if (size != transfer->blocksize)
1008 size++; /* room in this block */
1009 else if (i == size - 1)
1010 transfer->carrylf = 1; /* don't expand LF again if it moves to the next block */
1011
1012 /* make space and insert CR */
1013 memmove(&mess->data[i+1], &mess->data[i], size - (i + 1));
1014 mess->data[i] = '\r';
1015
1016 i++;
1017 }
1018 }
1019
1020 daemon->srv_save = transfer;
1021 saved_offset = transfer->offset;
1022 saved_len = size + 4;
1023
1024 return saved_len;
1025 }
1026 }
1027
1028
1029 int do_tftp_script_run(void)
1030 {
1031 struct tftp_transfer *transfer;
1032
1033 if ((transfer = daemon->tftp_done_trans))
1034 {
1035 daemon->tftp_done_trans = transfer->next;
1036 #ifdef HAVE_SCRIPT
1037 queue_tftp(transfer->file->size, transfer->file->filename, &transfer->peer);
1038 #endif
1039 free_transfer(transfer);
1040 return 1;
1041 }
1042
1043 return 0;
1044 }
1045 #endif