xref: /freebsd/libexec/tftpd/tftp-io.c (revision 4b9d605768acabc460aa6dcfe8a1f8db35b16794)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (C) 2008 Edwin Groothuis. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  */
27 
28 #include <sys/types.h>
29 #include <sys/socket.h>
30 #include <sys/stat.h>
31 
32 #include <netinet/in.h>
33 #include <arpa/inet.h>
34 #include <arpa/tftp.h>
35 
36 #include <assert.h>
37 #include <errno.h>
38 #include <poll.h>
39 #include <stddef.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <syslog.h>
44 #include <unistd.h>
45 
46 #include "tftp-file.h"
47 #include "tftp-io.h"
48 #include "tftp-utils.h"
49 #include "tftp-options.h"
50 
51 struct sockaddr_storage peer_sock;
52 struct sockaddr_storage me_sock;
53 
54 static int send_packet(int peer, uint16_t block, char *pkt, int size);
55 
56 static struct errmsg {
57 	int	e_code;
58 	const char	*e_msg;
59 } errmsgs[] = {
60 	{ EUNDEF,	"Undefined error code" },
61 	{ ENOTFOUND,	"File not found" },
62 	{ EACCESS,	"Access violation" },
63 	{ ENOSPACE,	"Disk full or allocation exceeded" },
64 	{ EBADOP,	"Illegal TFTP operation" },
65 	{ EBADID,	"Unknown transfer ID" },
66 	{ EEXISTS,	"File already exists" },
67 	{ ENOUSER,	"No such user" },
68 	{ EOPTNEG,	"Option negotiation" },
69 	{ -1,		NULL }
70 };
71 
72 #define DROPPACKET(s)							\
73 	if (packetdroppercentage != 0 &&				\
74 	    random()%100 < packetdroppercentage) {			\
75 		tftp_log(LOG_DEBUG, "Artificial packet drop in %s", s);	\
76 		return;							\
77 	}
78 #define DROPPACKETn(s,n)						\
79 	if (packetdroppercentage != 0 &&				\
80 	    random()%100 < packetdroppercentage) {			\
81 		tftp_log(LOG_DEBUG, "Artificial packet drop in %s", s);	\
82 		return (n);						\
83 	}
84 
85 const char *
86 errtomsg(int error)
87 {
88 	static char ebuf[40];
89 	struct errmsg *pe;
90 
91 	if (error == 0)
92 		return ("success");
93 	for (pe = errmsgs; pe->e_code >= 0; pe++)
94 		if (pe->e_code == error)
95 			return (pe->e_msg);
96 	snprintf(ebuf, sizeof(ebuf), "error %d", error);
97 	return (ebuf);
98 }
99 
100 static int
101 send_packet(int peer, uint16_t block, char *pkt, int size)
102 {
103 	int i;
104 	int t = 1;
105 
106 	for (i = 0; i < 12 ; i++) {
107 		DROPPACKETn("send_packet", 0);
108 
109 		if (sendto(peer, pkt, size, 0, (struct sockaddr *)&peer_sock,
110 		    peer_sock.ss_len) == size) {
111 			if (i)
112 				tftp_log(LOG_ERR,
113 				    "%s block %d, attempt %d successful",
114 		    		    packettype(ntohs(((struct tftphdr *)
115 				    (pkt))->th_opcode)), block, i);
116 			return (0);
117 		}
118 		tftp_log(LOG_ERR,
119 		    "%s block %d, attempt %d failed (Error %d: %s)",
120 		    packettype(ntohs(((struct tftphdr *)(pkt))->th_opcode)),
121 		    block, i, errno, strerror(errno));
122 		sleep(t);
123 		if (t < 32)
124 			t <<= 1;
125 	}
126 	tftp_log(LOG_ERR, "send_packet: %s", strerror(errno));
127 	return (1);
128 }
129 
130 /*
131  * Send an ERROR packet (error message).
132  * Error code passed in is one of the
133  * standard TFTP codes, or a UNIX errno
134  * offset by 100.
135  */
136 void
137 send_error(int peer, int error)
138 {
139 	struct tftphdr *tp;
140 	int length;
141 	struct errmsg *pe;
142 	char buf[MAXPKTSIZE];
143 
144 	if (debug & DEBUG_PACKETS)
145 		tftp_log(LOG_DEBUG, "Sending ERROR %d", error);
146 
147 	DROPPACKET("send_error");
148 
149 	tp = (struct tftphdr *)buf;
150 	tp->th_opcode = htons((u_short)ERROR);
151 	tp->th_code = htons((u_short)error);
152 	for (pe = errmsgs; pe->e_code >= 0; pe++)
153 		if (pe->e_code == error)
154 			break;
155 	if (pe->e_code < 0) {
156 		pe->e_msg = strerror(error - 100);
157 		tp->th_code = EUNDEF;   /* set 'undef' errorcode */
158 	}
159 	strcpy(tp->th_msg, pe->e_msg);
160 	length = strlen(pe->e_msg);
161 	tp->th_msg[length] = '\0';
162 	length += 5;
163 
164 	if (debug & DEBUG_PACKETS)
165 		tftp_log(LOG_DEBUG, "Sending ERROR %d: %s", error, tp->th_msg);
166 
167 	if (sendto(peer, buf, length, 0,
168 		(struct sockaddr *)&peer_sock, peer_sock.ss_len) != length)
169 		tftp_log(LOG_ERR, "send_error: %s", strerror(errno));
170 }
171 
172 /*
173  * Send an WRQ packet (write request).
174  */
175 int
176 send_wrq(int peer, char *filename, char *mode)
177 {
178 	int n;
179 	struct tftphdr *tp;
180 	char *bp;
181 	char buf[MAXPKTSIZE];
182 	int size;
183 
184 	if (debug & DEBUG_PACKETS)
185 		tftp_log(LOG_DEBUG, "Sending WRQ: filename: '%s', mode '%s'",
186 			filename, mode
187 		);
188 
189 	DROPPACKETn("send_wrq", 0);
190 
191 	tp = (struct tftphdr *)buf;
192 	tp->th_opcode = htons((u_short)WRQ);
193 	size = offsetof(struct tftphdr, th_stuff);
194 
195 	bp = tp->th_stuff;
196 	strlcpy(bp, filename, sizeof(buf) - size);
197 	bp += strlen(filename);
198 	*bp = 0;
199 	bp++;
200 	size += strlen(filename) + 1;
201 
202 	strlcpy(bp, mode, sizeof(buf) - size);
203 	bp += strlen(mode);
204 	*bp = 0;
205 	bp++;
206 	size += strlen(mode) + 1;
207 
208 	if (options_rfc_enabled)
209 		size += make_options(peer, bp, sizeof(buf) - size);
210 
211 	n = sendto(peer, buf, size, 0,
212 	    (struct sockaddr *)&peer_sock, peer_sock.ss_len);
213 	if (n != size) {
214 		tftp_log(LOG_ERR, "send_wrq: %s", strerror(errno));
215 		return (1);
216 	}
217 	return (0);
218 }
219 
220 /*
221  * Send an RRQ packet (write request).
222  */
223 int
224 send_rrq(int peer, char *filename, char *mode)
225 {
226 	int n;
227 	struct tftphdr *tp;
228 	char *bp;
229 	char buf[MAXPKTSIZE];
230 	int size;
231 
232 	if (debug & DEBUG_PACKETS)
233 		tftp_log(LOG_DEBUG, "Sending RRQ: filename: '%s', mode '%s'",
234 			filename, mode
235 		);
236 
237 	DROPPACKETn("send_rrq", 0);
238 
239 	tp = (struct tftphdr *)buf;
240 	tp->th_opcode = htons((u_short)RRQ);
241 	size = offsetof(struct tftphdr, th_stuff);
242 
243 	bp = tp->th_stuff;
244 	strlcpy(bp, filename, sizeof(buf) - size);
245 	bp += strlen(filename);
246 	*bp = 0;
247 	bp++;
248 	size += strlen(filename) + 1;
249 
250 	strlcpy(bp, mode, sizeof(buf) - size);
251 	bp += strlen(mode);
252 	*bp = 0;
253 	bp++;
254 	size += strlen(mode) + 1;
255 
256 	if (options_rfc_enabled) {
257 		options_set_request(OPT_TSIZE, "0");
258 		size += make_options(peer, bp, sizeof(buf) - size);
259 	}
260 
261 	n = sendto(peer, buf, size, 0,
262 	    (struct sockaddr *)&peer_sock, peer_sock.ss_len);
263 	if (n != size) {
264 		tftp_log(LOG_ERR, "send_rrq: %d %s", n, strerror(errno));
265 		return (1);
266 	}
267 	return (0);
268 }
269 
270 /*
271  * Send an OACK packet (option acknowledgement).
272  */
273 int
274 send_oack(int peer)
275 {
276 	struct tftphdr *tp;
277 	int size, i, n;
278 	char *bp;
279 	char buf[MAXPKTSIZE];
280 
281 	if (debug & DEBUG_PACKETS)
282 		tftp_log(LOG_DEBUG, "Sending OACK");
283 
284 	DROPPACKETn("send_oack", 0);
285 
286 	/*
287 	 * Send back an options acknowledgement (only the ones with
288 	 * a reply for)
289 	 */
290 	tp = (struct tftphdr *)buf;
291 	bp = buf + 2;
292 	size = sizeof(buf) - 2;
293 	tp->th_opcode = htons((u_short)OACK);
294 	for (i = 0; options[i].o_type != NULL; i++) {
295 		if (options[i].o_reply != NULL) {
296 			n = snprintf(bp, size, "%s%c%s", options[i].o_type,
297 				     0, options[i].o_reply);
298 			bp += n+1;
299 			size -= n+1;
300 			if (size < 0) {
301 				tftp_log(LOG_ERR, "oack: buffer overflow");
302 				exit(1);
303 			}
304 		}
305 	}
306 	size = bp - buf;
307 
308 	if (sendto(peer, buf, size, 0,
309 		(struct sockaddr *)&peer_sock, peer_sock.ss_len) != size) {
310 		tftp_log(LOG_INFO, "send_oack: %s", strerror(errno));
311 		return (1);
312 	}
313 
314 	return (0);
315 }
316 
317 /*
318  * Send an ACK packet (acknowledgement).
319  */
320 int
321 send_ack(int fp, uint16_t block)
322 {
323 	struct tftphdr *tp;
324 	int size;
325 	char buf[MAXPKTSIZE];
326 
327 	if (debug & DEBUG_PACKETS)
328 		tftp_log(LOG_DEBUG, "Sending ACK for block %d", block);
329 
330 	DROPPACKETn("send_ack", 0);
331 
332 	tp = (struct tftphdr *)buf;
333 	size = sizeof(buf) - 2;
334 	tp->th_opcode = htons((u_short)ACK);
335 	tp->th_block = htons((u_short)block);
336 	size = 4;
337 
338 	if (sendto(fp, buf, size, 0,
339 	    (struct sockaddr *)&peer_sock, peer_sock.ss_len) != size) {
340 		tftp_log(LOG_INFO, "send_ack: %s", strerror(errno));
341 		return (1);
342 	}
343 
344 	return (0);
345 }
346 
347 /*
348  * Send a DATA packet
349  */
350 int
351 send_data(int peer, uint16_t block, char *data, int size)
352 {
353 	char buf[MAXPKTSIZE];
354 	struct tftphdr *pkt;
355 	int n;
356 
357 	if (debug & DEBUG_PACKETS)
358 		tftp_log(LOG_DEBUG, "Sending DATA packet %d of %d bytes",
359 			block, size);
360 
361 	DROPPACKETn("send_data", 0);
362 
363 	pkt = (struct tftphdr *)buf;
364 
365 	pkt->th_opcode = htons((u_short)DATA);
366 	pkt->th_block = htons((u_short)block);
367 	memcpy(pkt->th_data, data, size);
368 
369 	n = send_packet(peer, block, (char *)pkt, size + 4);
370 	return (n);
371 }
372 
373 
374 /*
375  * Receive a packet
376  *
377  * If timeout is negative, no error will be logged on timeout.
378  */
379 int
380 receive_packet(int peer, char *data, int size, struct sockaddr_storage *from,
381     int timeout)
382 {
383 	struct pollfd pfd;
384 	struct tftphdr *pkt;
385 	struct sockaddr_storage from_local;
386 	struct sockaddr_storage *pfrom;
387 	socklen_t fromlen;
388 	int n;
389 
390 	if (debug & DEBUG_PACKETS)
391 		tftp_log(LOG_DEBUG,
392 		    "Waiting %d seconds for packet", timeoutpacket);
393 
394 	pkt = (struct tftphdr *)data;
395 
396 	pfd.fd = peer;
397 	pfd.events = POLLIN;
398 	if (poll(&pfd, 1, 1000 * (timeout < 0 ? -timeout : timeout)) < 1) {
399 		if (timeout > 0)
400 			tftp_log(LOG_ERR, "receive_packet: timeout");
401 		return (RP_TIMEOUT);
402 	}
403 
404 	pfrom = (from == NULL) ? &from_local : from;
405 	fromlen = sizeof(*pfrom);
406 	n = recvfrom(peer, data, size, 0, (struct sockaddr *)pfrom, &fromlen);
407 
408 	DROPPACKETn("receive_packet", RP_TIMEOUT);
409 
410 	if (n < 0) {
411 		/* No idea what could have happened if it isn't a timeout */
412 		tftp_log(LOG_ERR, "receive_packet: %s", strerror(errno));
413 		return (RP_RECVFROM);
414 	}
415 	if (n < 4) {
416 		tftp_log(LOG_ERR,
417 		    "receive_packet: packet too small (%d bytes)", n);
418 		return (RP_TOOSMALL);
419 	}
420 
421 	pkt->th_opcode = ntohs((u_short)pkt->th_opcode);
422 	if (pkt->th_opcode == DATA ||
423 	    pkt->th_opcode == ACK)
424 		pkt->th_block = ntohs((u_short)pkt->th_block);
425 
426 	if (pkt->th_opcode == DATA && n > pktsize) {
427 		tftp_log(LOG_ERR, "receive_packet: packet too big");
428 		return (RP_TOOBIG);
429 	}
430 
431 	if (((struct sockaddr_in *)(pfrom))->sin_addr.s_addr !=
432 	    ((struct sockaddr_in *)(&peer_sock))->sin_addr.s_addr) {
433 		tftp_log(LOG_ERR,
434 			"receive_packet: received packet from wrong source");
435 		return (RP_WRONGSOURCE);
436 	}
437 
438 	if (pkt->th_opcode == ERROR) {
439 		tftp_log(pkt->th_code == EUNDEF ? LOG_DEBUG : LOG_ERR,
440 		    "Got ERROR packet: %s", pkt->th_msg);
441 		return (RP_ERROR);
442 	}
443 
444 	if (debug & DEBUG_PACKETS)
445 		tftp_log(LOG_DEBUG, "Received %d bytes in a %s packet",
446 			n, packettype(pkt->th_opcode));
447 
448 	return n - 4;
449 }
450