path: root/networking/tftp.c (plain)
blob: ed86720257aab7b62ba39ed9f218aa6724040741

1	/* vi: set sw=4 ts=4: */
2	/*
3	* A simple tftp client/server for busybox.
4	* Tries to follow RFC1350.
5	* Only "octet" mode supported.
6	* Optional blocksize negotiation (RFC2347 + RFC2348)
7	*
8	* Copyright (C) 2001 Magnus Damm <damm@opensource.se>
9	*
10	* Parts of the code based on:
11	*
12	* atftp: Copyright (C) 2000 Jean-Pierre Lefebvre <helix@step.polymtl.ca>
13	* and Remi Lefebvre <remi@debian.org>
14	*
15	* utftp: Copyright (C) 1999 Uwe Ohse <uwe@ohse.de>
16	*
17	* tftpd added by Denys Vlasenko & Vladimir Dronnikov
18	*
19	* Licensed under GPLv2 or later, see file LICENSE in this source tree.
20	*/
21	//config:config TFTP
22	//config: bool "tftp"
23	//config: default y
24	//config: help
25	//config: This enables the Trivial File Transfer Protocol client program. TFTP
26	//config: is usually used for simple, small transfers such as a root image
27	//config: for a network-enabled bootloader.
28	//config:
29	//config:config TFTPD
30	//config: bool "tftpd"
31	//config: default y
32	//config: help
33	//config: This enables the Trivial File Transfer Protocol server program.
34	//config: It expects that stdin is a datagram socket and a packet
35	//config: is already pending on it. It will exit after one transfer.
36	//config: In other words: it should be run from inetd in nowait mode,
37	//config: or from udpsvd. Example: "udpsvd -E 0 69 tftpd DIR"
38	//config:
39	//config:comment "Common options for tftp/tftpd"
40	//config: depends on TFTP || TFTPD
41	//config:
42	//config:config FEATURE_TFTP_GET
43	//config: bool "Enable 'tftp get' and/or tftpd upload code"
44	//config: default y
45	//config: depends on TFTP || TFTPD
46	//config: help
47	//config: Add support for the GET command within the TFTP client. This allows
48	//config: a client to retrieve a file from a TFTP server.
49	//config: Also enable upload support in tftpd, if tftpd is selected.
50	//config:
51	//config: Note: this option does _not_ make tftpd capable of download
52	//config: (the usual operation people need from it)!
53	//config:
54	//config:config FEATURE_TFTP_PUT
55	//config: bool "Enable 'tftp put' and/or tftpd download code"
56	//config: default y
57	//config: depends on TFTP || TFTPD
58	//config: help
59	//config: Add support for the PUT command within the TFTP client. This allows
60	//config: a client to transfer a file to a TFTP server.
61	//config: Also enable download support in tftpd, if tftpd is selected.
62	//config:
63	//config:config FEATURE_TFTP_BLOCKSIZE
64	//config: bool "Enable 'blksize' and 'tsize' protocol options"
65	//config: default y
66	//config: depends on TFTP || TFTPD
67	//config: help
68	//config: Allow tftp to specify block size, and tftpd to understand
69	//config: "blksize" and "tsize" options.
70	//config:
71	//config:config FEATURE_TFTP_PROGRESS_BAR
72	//config: bool "Enable tftp progress meter"
73	//config: default y
74	//config: depends on TFTP && FEATURE_TFTP_BLOCKSIZE
75	//config: help
76	//config: Show progress bar.
77	//config:
78	//config:config TFTP_DEBUG
79	//config: bool "Enable debug"
80	//config: default n
81	//config: depends on TFTP || TFTPD
82	//config: help
83	//config: Make tftp[d] print debugging messages on stderr.
84	//config: This is useful if you are diagnosing a bug in tftp[d].
85
86	//applet:#if ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT
87	//applet:IF_TFTP(APPLET(tftp, BB_DIR_USR_BIN, BB_SUID_DROP))
88	//applet:IF_TFTPD(APPLET(tftpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
89	//applet:#endif
90
91	//kbuild:lib-$(CONFIG_TFTP) += tftp.o
92	//kbuild:lib-$(CONFIG_TFTPD) += tftp.o
93
94	//usage:#define tftp_trivial_usage
95	//usage: "[OPTIONS] HOST [PORT]"
96	//usage:#define tftp_full_usage "\n\n"
97	//usage: "Transfer a file from/to tftp server\n"
98	//usage: "\n -l FILE Local FILE"
99	//usage: "\n -r FILE Remote FILE"
100	//usage: IF_FEATURE_TFTP_GET(
101	//usage: "\n -g Get file"
102	//usage: )
103	//usage: IF_FEATURE_TFTP_PUT(
104	//usage: "\n -p Put file"
105	//usage: )
106	//usage: IF_FEATURE_TFTP_BLOCKSIZE(
107	//usage: "\n -b SIZE Transfer blocks of SIZE octets"
108	//usage: )
109	//usage:
110	//usage:#define tftpd_trivial_usage
111	//usage: "[-cr] [-u USER] [DIR]"
112	//usage:#define tftpd_full_usage "\n\n"
113	//usage: "Transfer a file on tftp client's request\n"
114	//usage: "\n"
115	//usage: "tftpd should be used as an inetd service.\n"
116	//usage: "tftpd's line for inetd.conf:\n"
117	//usage: " 69 dgram udp nowait root tftpd tftpd -l /files/to/serve\n"
118	//usage: "It also can be ran from udpsvd:\n"
119	//usage: " udpsvd -vE 0.0.0.0 69 tftpd /files/to/serve\n"
120	//usage: "\n -r Prohibit upload"
121	//usage: "\n -c Allow file creation via upload"
122	//usage: "\n -u Access files as USER"
123	//usage: "\n -l Log to syslog (inetd mode requires this)"
124
125	#include "libbb.h"
126	#include "common_bufsiz.h"
127	#include <syslog.h>
128
129	#if ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT
130
131	#define TFTP_BLKSIZE_DEFAULT 512 /* according to RFC 1350, don't change */
132	#define TFTP_BLKSIZE_DEFAULT_STR "512"
133	/* Was 50 ms but users asked to bump it up a bit */
134	#define TFTP_TIMEOUT_MS 100
135	#define TFTP_MAXTIMEOUT_MS 2000
136	#define TFTP_NUM_RETRIES 12 /* number of backed-off retries */
137
138	/* opcodes we support */
139	#define TFTP_RRQ 1
140	#define TFTP_WRQ 2
141	#define TFTP_DATA 3
142	#define TFTP_ACK 4
143	#define TFTP_ERROR 5
144	#define TFTP_OACK 6
145
146	/* error codes sent over network (we use only 0, 1, 3 and 8) */
147	/* generic (error message is included in the packet) */
148	#define ERR_UNSPEC 0
149	#define ERR_NOFILE 1
150	#define ERR_ACCESS 2
151	/* disk full or allocation exceeded */
152	#define ERR_WRITE 3
153	#define ERR_OP 4
154	#define ERR_BAD_ID 5
155	#define ERR_EXIST 6
156	#define ERR_BAD_USER 7
157	#define ERR_BAD_OPT 8
158
159	/* masks coming from getopt32 */
160	enum {
161	TFTP_OPT_GET = (1 << 0),
162	TFTP_OPT_PUT = (1 << 1),
163	/* pseudo option: if set, it's tftpd */
164	TFTPD_OPT = (1 << 7) * ENABLE_TFTPD,
165	TFTPD_OPT_r = (1 << 8) * ENABLE_TFTPD,
166	TFTPD_OPT_c = (1 << 9) * ENABLE_TFTPD,
167	TFTPD_OPT_u = (1 << 10) * ENABLE_TFTPD,
168	TFTPD_OPT_l = (1 << 11) * ENABLE_TFTPD,
169	};
170
171	#if ENABLE_FEATURE_TFTP_GET && !ENABLE_FEATURE_TFTP_PUT
172	#define IF_GETPUT(...)
173	#define CMD_GET(cmd) 1
174	#define CMD_PUT(cmd) 0
175	#elif !ENABLE_FEATURE_TFTP_GET && ENABLE_FEATURE_TFTP_PUT
176	#define IF_GETPUT(...)
177	#define CMD_GET(cmd) 0
178	#define CMD_PUT(cmd) 1
179	#else
180	#define IF_GETPUT(...) __VA_ARGS__
181	#define CMD_GET(cmd) ((cmd) & TFTP_OPT_GET)
182	#define CMD_PUT(cmd) ((cmd) & TFTP_OPT_PUT)
183	#endif
184	/* NB: in the code below
185	* CMD_GET(cmd) and CMD_PUT(cmd) are mutually exclusive
186	*/
187
188
189	struct globals {
190	/* u16 TFTP_ERROR; u16 reason; both network-endian, then error text: */
191	uint8_t error_pkt[4 + 32];
192	struct passwd *pw;
193	/* Used in tftpd_main() for initial packet */
194	/* Some HP PA-RISC firmware always sends fixed 516-byte requests */
195	char block_buf[516];
196	char block_buf_tail[1];
197	#if ENABLE_FEATURE_TFTP_PROGRESS_BAR
198	off_t pos;
199	off_t size;
200	const char *file;
201	bb_progress_t pmt;
202	#endif
203	} FIX_ALIASING;
204	#define G (*(struct globals*)bb_common_bufsiz1)
205	#define INIT_G() do { \
206	setup_common_bufsiz(); \
207	BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
208	} while (0)
209
210	#define G_error_pkt_reason (G.error_pkt[3])
211	#define G_error_pkt_str ((char*)(G.error_pkt + 4))
212
213	#if ENABLE_FEATURE_TFTP_PROGRESS_BAR
214	static void tftp_progress_update(void)
215	{
216	bb_progress_update(&G.pmt, 0, G.pos, G.size);
217	}
218	static void tftp_progress_init(void)
219	{
220	bb_progress_init(&G.pmt, G.file);
221	tftp_progress_update();
222	}
223	static void tftp_progress_done(void)
224	{
225	if (is_bb_progress_inited(&G.pmt)) {
226	tftp_progress_update();
227	bb_putchar_stderr('\n');
228	bb_progress_free(&G.pmt);
229	}
230	}
231	#else
232	# define tftp_progress_init() ((void)0)
233	# define tftp_progress_done() ((void)0)
234	#endif
235
236	#if ENABLE_FEATURE_TFTP_BLOCKSIZE
237
238	static int tftp_blksize_check(const char *blksize_str, int maxsize)
239	{
240	/* Check if the blksize is valid:
241	* RFC2348 says between 8 and 65464,
242	* but our implementation makes it impossible
243	* to use blksizes smaller than 22 octets. */
244	unsigned blksize = bb_strtou(blksize_str, NULL, 10);
245	if (errno
246	|| (blksize < 24) || (blksize > maxsize)
247	) {
248	bb_error_msg("bad blocksize '%s'", blksize_str);
249	return -1;
250	}
251	# if ENABLE_TFTP_DEBUG
252	bb_error_msg("using blksize %u", blksize);
253	# endif
254	return blksize;
255	}
256
257	static char *tftp_get_option(const char *option, char *buf, int len)
258	{
259	int opt_val = 0;
260	int opt_found = 0;
261	int k;
262
263	/* buf points to:
264	* "opt_name<NUL>opt_val<NUL>opt_name2<NUL>opt_val2<NUL>..." */
265
266	while (len > 0) {
267	/* Make sure options are terminated correctly */
268	for (k = 0; k < len; k++) {
269	if (buf[k] == '\0') {
270	goto nul_found;
271	}
272	}
273	return NULL;
274	nul_found:
275	if (opt_val == 0) { /* it's "name" part */
276	if (strcasecmp(buf, option) == 0) {
277	opt_found = 1;
278	}
279	} else if (opt_found) {
280	return buf;
281	}
282
283	k++;
284	buf += k;
285	len -= k;
286	opt_val ^= 1;
287	}
288
289	return NULL;
290	}
291
292	#endif
293
294	static int tftp_protocol(
295	/* NULL if tftp, !NULL if tftpd: */
296	len_and_sockaddr *our_lsa,
297	len_and_sockaddr *peer_lsa,
298	const char *local_file
299	IF_TFTP(, const char *remote_file)
300	#if !ENABLE_TFTP
301	# define remote_file NULL
302	#endif
303	/* 1 for tftp; 1/0 for tftpd depending whether client asked about it: */
304	IF_FEATURE_TFTP_BLOCKSIZE(, int want_transfer_size)
305	IF_FEATURE_TFTP_BLOCKSIZE(, int blksize))
306	{
307	#if !ENABLE_FEATURE_TFTP_BLOCKSIZE
308	enum { blksize = TFTP_BLKSIZE_DEFAULT };
309	#endif
310
311	struct pollfd pfd[1];
312	#define socket_fd (pfd[0].fd)
313	int len;
314	int send_len;
315	IF_FEATURE_TFTP_BLOCKSIZE(smallint expect_OACK = 0;)
316	smallint finished = 0;
317	uint16_t opcode;
318	uint16_t block_nr;
319	uint16_t recv_blk;
320	int open_mode, local_fd;
321	int retries, waittime_ms;
322	int io_bufsize = blksize + 4;
323	char *cp;
324	/* Can't use RESERVE_CONFIG_BUFFER here since the allocation
325	* size varies meaning BUFFERS_GO_ON_STACK would fail.
326	*
327	* We must keep the transmit and receive buffers separate
328	* in case we rcv a garbage pkt - we need to rexmit the last pkt.
329	*/
330	char *xbuf = xmalloc(io_bufsize);
331	char *rbuf = xmalloc(io_bufsize);
332
333	socket_fd = xsocket(peer_lsa->u.sa.sa_family, SOCK_DGRAM, 0);
334	setsockopt_reuseaddr(socket_fd);
335
336	if (!ENABLE_TFTP || our_lsa) { /* tftpd */
337	/* Create a socket which is:
338	* 1. bound to IP:port peer sent 1st datagram to,
339	* 2. connected to peer's IP:port
340	* This way we will answer from the IP:port peer
341	* expects, will not get any other packets on
342	* the socket, and also plain read/write will work. */
343	xbind(socket_fd, &our_lsa->u.sa, our_lsa->len);
344	xconnect(socket_fd, &peer_lsa->u.sa, peer_lsa->len);
345
346	/* Is there an error already? Send pkt and bail out */
347	if (G_error_pkt_reason || G_error_pkt_str[0])
348	goto send_err_pkt;
349
350	if (G.pw) {
351	change_identity(G.pw); /* initgroups, setgid, setuid */
352	}
353	}
354
355	/* Prepare open mode */
356	if (CMD_PUT(option_mask32)) {
357	open_mode = O_RDONLY;
358	} else {
359	open_mode = O_WRONLY | O_TRUNC | O_CREAT;
360	#if ENABLE_TFTPD
361	if ((option_mask32 & (TFTPD_OPT+TFTPD_OPT_c)) == TFTPD_OPT) {
362	/* tftpd without -c */
363	open_mode = O_WRONLY | O_TRUNC;
364	}
365	#endif
366	}
367
368	/* Examples of network traffic.
369	* Note two cases when ACKs with block# of 0 are sent.
370	*
371	* Download without options:
372	* tftp -> "\0\1FILENAME\0octet\0"
373	* "\0\3\0\1FILEDATA..." <- tftpd
374	* tftp -> "\0\4\0\1"
375	* ...
376	* Download with option of blksize 16384:
377	* tftp -> "\0\1FILENAME\0octet\0blksize\00016384\0"
378	* "\0\6blksize\00016384\0" <- tftpd
379	* tftp -> "\0\4\0\0"
380	* "\0\3\0\1FILEDATA..." <- tftpd
381	* tftp -> "\0\4\0\1"
382	* ...
383	* Upload without options:
384	* tftp -> "\0\2FILENAME\0octet\0"
385	* "\0\4\0\0" <- tftpd
386	* tftp -> "\0\3\0\1FILEDATA..."
387	* "\0\4\0\1" <- tftpd
388	* ...
389	* Upload with option of blksize 16384:
390	* tftp -> "\0\2FILENAME\0octet\0blksize\00016384\0"
391	* "\0\6blksize\00016384\0" <- tftpd
392	* tftp -> "\0\3\0\1FILEDATA..."
393	* "\0\4\0\1" <- tftpd
394	* ...
395	*/
396	block_nr = 1;
397	cp = xbuf + 2;
398
399	if (!ENABLE_TFTP || our_lsa) { /* tftpd */
400	/* Open file (must be after changing user) */
401	local_fd = open(local_file, open_mode, 0666);
402	if (local_fd < 0) {
403	G_error_pkt_reason = ERR_NOFILE;
404	strcpy(G_error_pkt_str, "can't open file");
405	goto send_err_pkt;
406	}
407	/* gcc 4.3.1 would NOT optimize it out as it should! */
408	#if ENABLE_FEATURE_TFTP_BLOCKSIZE
409	if (blksize != TFTP_BLKSIZE_DEFAULT || want_transfer_size) {
410	/* Create and send OACK packet. */
411	/* For the download case, block_nr is still 1 -
412	* we expect 1st ACK from peer to be for (block_nr-1),
413	* that is, for "block 0" which is our OACK pkt */
414	opcode = TFTP_OACK;
415	goto add_blksize_opt;
416	}
417	#endif
418	if (CMD_GET(option_mask32)) {
419	/* It's upload and we don't send OACK.
420	* We must ACK 1st packet (with filename)
421	* as if it is "block 0" */
422	block_nr = 0;
423	}
424	} else { /* tftp */
425	/* Open file (must be after changing user) */
426	local_fd = CMD_GET(option_mask32) ? STDOUT_FILENO : STDIN_FILENO;
427	if (NOT_LONE_DASH(local_file))
428	local_fd = xopen(local_file, open_mode);
429	/* Removing #if, or using if() statement instead of #if may lead to
430	* "warning: null argument where non-null required": */
431	#if ENABLE_TFTP
432	/* tftp */
433
434	/* We can't (and don't really need to) bind the socket:
435	* we don't know from which local IP datagrams will be sent,
436	* but kernel will pick the same IP every time (unless routing
437	* table is changed), thus peer will see dgrams consistently
438	* coming from the same IP.
439	* We would like to connect the socket, but since peer's
440	* UDP code can be less perfect than ours, _peer's_ IP:port
441	* in replies may differ from IP:port we used to send
442	* our first packet. We can connect() only when we get
443	* first reply. */
444
445	/* build opcode */
446	opcode = TFTP_WRQ;
447	if (CMD_GET(option_mask32)) {
448	opcode = TFTP_RRQ;
449	}
450	/* add filename and mode */
451	/* fill in packet if the filename fits into xbuf */
452	len = strlen(remote_file) + 1;
453	if (2 + len + sizeof("octet") >= io_bufsize) {
454	bb_error_msg("remote filename is too long");
455	goto ret;
456	}
457	strcpy(cp, remote_file);
458	cp += len;
459	/* add "mode" part of the packet */
460	strcpy(cp, "octet");
461	cp += sizeof("octet");
462
463	# if ENABLE_FEATURE_TFTP_BLOCKSIZE
464	if (blksize == TFTP_BLKSIZE_DEFAULT && !want_transfer_size)
465	goto send_pkt;
466
467	/* Need to add option to pkt */
468	if ((&xbuf[io_bufsize - 1] - cp) < sizeof("blksize NNNNN tsize ") + sizeof(off_t)*3) {
469	bb_error_msg("remote filename is too long");
470	goto ret;
471	}
472	expect_OACK = 1;
473	# endif
474	#endif /* ENABLE_TFTP */
475
476	#if ENABLE_FEATURE_TFTP_BLOCKSIZE
477	add_blksize_opt:
478	if (blksize != TFTP_BLKSIZE_DEFAULT) {
479	/* add "blksize", <nul>, blksize, <nul> */
480	strcpy(cp, "blksize");
481	cp += sizeof("blksize");
482	cp += snprintf(cp, 6, "%d", blksize) + 1;
483	}
484	if (want_transfer_size) {
485	/* add "tsize", <nul>, size, <nul> (see RFC2349) */
486	/* if tftp and downloading, we send "0" (since we opened local_fd with O_TRUNC)
487	* and this makes server to send "tsize" option with the size */
488	/* if tftp and uploading, we send file size (maybe dont, to not confuse old servers???) */
489	/* if tftpd and downloading, we are answering to client's request */
490	/* if tftpd and uploading: !want_transfer_size, this code is not executed */
491	struct stat st;
492	strcpy(cp, "tsize");
493	cp += sizeof("tsize");
494	st.st_size = 0;
495	fstat(local_fd, &st);
496	cp += sprintf(cp, "%"OFF_FMT"u", (off_t)st.st_size) + 1;
497	# if ENABLE_FEATURE_TFTP_PROGRESS_BAR
498	/* Save for progress bar. If 0 (tftp downloading),
499	* we look at server's reply later */
500	G.size = st.st_size;
501	if (remote_file && st.st_size)
502	tftp_progress_init();
503	# endif
504	}
505	#endif
506	/* First packet is built, so skip packet generation */
507	goto send_pkt;
508	}
509
510	/* Using mostly goto's - continue/break will be less clear
511	* in where we actually jump to */
512	while (1) {
513	/* Build ACK or DATA */
514	cp = xbuf + 2;
515	*((uint16_t*)cp) = htons(block_nr);
516	cp += 2;
517	block_nr++;
518	opcode = TFTP_ACK;
519	if (CMD_PUT(option_mask32)) {
520	opcode = TFTP_DATA;
521	len = full_read(local_fd, cp, blksize);
522	if (len < 0) {
523	goto send_read_err_pkt;
524	}
525	if (len != blksize) {
526	finished = 1;
527	}
528	cp += len;
529	IF_FEATURE_TFTP_PROGRESS_BAR(G.pos += len;)
530	}
531	send_pkt:
532	/* Send packet */
533	*((uint16_t*)xbuf) = htons(opcode); /* fill in opcode part */
534	send_len = cp - xbuf;
535	/* NB: send_len value is preserved in code below
536	* for potential resend */
537
538	retries = TFTP_NUM_RETRIES; /* re-initialize */
539	waittime_ms = TFTP_TIMEOUT_MS;
540
541	send_again:
542	#if ENABLE_TFTP_DEBUG
543	fprintf(stderr, "sending %u bytes\n", send_len);
544	for (cp = xbuf; cp < &xbuf[send_len]; cp++)
545	fprintf(stderr, "%02x ", (unsigned char) *cp);
546	fprintf(stderr, "\n");
547	#endif
548	xsendto(socket_fd, xbuf, send_len, &peer_lsa->u.sa, peer_lsa->len);
549
550	#if ENABLE_FEATURE_TFTP_PROGRESS_BAR
551	if (is_bb_progress_inited(&G.pmt))
552	tftp_progress_update();
553	#endif
554	/* Was it final ACK? then exit */
555	if (finished && (opcode == TFTP_ACK))
556	goto ret;
557
558	recv_again:
559	/* Receive packet */
560	/*pfd[0].fd = socket_fd;*/
561	pfd[0].events = POLLIN;
562	switch (safe_poll(pfd, 1, waittime_ms)) {
563	default:
564	/*bb_perror_msg("poll"); - done in safe_poll */
565	goto ret;
566	case 0:
567	retries--;
568	if (retries == 0) {
569	tftp_progress_done();
570	bb_error_msg("timeout");
571	goto ret; /* no err packet sent */
572	}
573
574	/* exponential backoff with limit */
575	waittime_ms += waittime_ms/2;
576	if (waittime_ms > TFTP_MAXTIMEOUT_MS) {
577	waittime_ms = TFTP_MAXTIMEOUT_MS;
578	}
579
580	goto send_again; /* resend last sent pkt */
581	case 1:
582	if (!our_lsa) {
583	/* tftp (not tftpd!) receiving 1st packet */
584	our_lsa = ((void*)(ptrdiff_t)-1); /* not NULL */
585	len = recvfrom(socket_fd, rbuf, io_bufsize, 0,
586	&peer_lsa->u.sa, &peer_lsa->len);
587	/* Our first dgram went to port 69
588	* but reply may come from different one.
589	* Remember and use this new port (and IP) */
590	if (len >= 0)
591	xconnect(socket_fd, &peer_lsa->u.sa, peer_lsa->len);
592	} else {
593	/* tftpd, or not the very first packet:
594	* socket is connect()ed, can just read from it. */
595	/* Don't full_read()!
596	* This is not TCP, one read == one pkt! */
597	len = safe_read(socket_fd, rbuf, io_bufsize);
598	}
599	if (len < 0) {
600	goto send_read_err_pkt;
601	}
602	if (len < 4) { /* too small? */
603	goto recv_again;
604	}
605	}
606
607	/* Process recv'ed packet */
608	opcode = ntohs( ((uint16_t*)rbuf)[0] );
609	recv_blk = ntohs( ((uint16_t*)rbuf)[1] );
610	#if ENABLE_TFTP_DEBUG
611	fprintf(stderr, "received %d bytes: %04x %04x\n", len, opcode, recv_blk);
612	#endif
613	if (opcode == TFTP_ERROR) {
614	static const char errcode_str[] ALIGN1 =
615	"\0"
616	"file not found\0"
617	"access violation\0"
618	"disk full\0"
619	"bad operation\0"
620	"unknown transfer id\0"
621	"file already exists\0"
622	"no such user\0"
623	"bad option";
624
625	const char *msg = "";
626
627	if (len > 4 && rbuf[4] != '\0') {
628	msg = &rbuf[4];
629	rbuf[io_bufsize - 1] = '\0'; /* paranoia */
630	} else if (recv_blk <= 8) {
631	msg = nth_string(errcode_str, recv_blk);
632	}
633	bb_error_msg("server error: (%u) %s", recv_blk, msg);
634	goto ret;
635	}
636
637	#if ENABLE_FEATURE_TFTP_BLOCKSIZE
638	if (expect_OACK) {
639	expect_OACK = 0;
640	if (opcode == TFTP_OACK) {
641	/* server seems to support options */
642	char *res;
643
644	res = tftp_get_option("blksize", &rbuf[2], len - 2);
645	if (res) {
646	blksize = tftp_blksize_check(res, blksize);
647	if (blksize < 0) {
648	G_error_pkt_reason = ERR_BAD_OPT;
649	goto send_err_pkt;
650	}
651	io_bufsize = blksize + 4;
652	}
653	# if ENABLE_FEATURE_TFTP_PROGRESS_BAR
654	if (remote_file && G.size == 0) { /* if we don't know it yet */
655	res = tftp_get_option("tsize", &rbuf[2], len - 2);
656	if (res) {
657	G.size = bb_strtoull(res, NULL, 10);
658	if (G.size)
659	tftp_progress_init();
660	}
661	}
662	# endif
663	if (CMD_GET(option_mask32)) {
664	/* We'll send ACK for OACK,
665	* such ACK has "block no" of 0 */
666	block_nr = 0;
667	}
668	continue;
669	}
670	/* rfc2347:
671	* "An option not acknowledged by the server
672	* must be ignored by the client and server
673	* as if it were never requested." */
674	if (blksize != TFTP_BLKSIZE_DEFAULT)
675	bb_error_msg("falling back to blocksize "TFTP_BLKSIZE_DEFAULT_STR);
676	blksize = TFTP_BLKSIZE_DEFAULT;
677	io_bufsize = TFTP_BLKSIZE_DEFAULT + 4;
678	}
679	#endif
680	/* block_nr is already advanced to next block# we expect
681	* to get / block# we are about to send next time */
682
683	if (CMD_GET(option_mask32) && (opcode == TFTP_DATA)) {
684	if (recv_blk == block_nr) {
685	int sz = full_write(local_fd, &rbuf[4], len - 4);
686	if (sz != len - 4) {
687	strcpy(G_error_pkt_str, bb_msg_write_error);
688	G_error_pkt_reason = ERR_WRITE;
689	goto send_err_pkt;
690	}
691	if (sz != blksize) {
692	finished = 1;
693	}
694	IF_FEATURE_TFTP_PROGRESS_BAR(G.pos += sz;)
695	continue; /* send ACK */
696	}
697	/* Disabled to cope with servers with Sorcerer's Apprentice Syndrome */
698	#if 0
699	if (recv_blk == (block_nr - 1)) {
700	/* Server lost our TFTP_ACK. Resend it */
701	block_nr = recv_blk;
702	continue;
703	}
704	#endif
705	}
706
707	if (CMD_PUT(option_mask32) && (opcode == TFTP_ACK)) {
708	/* did peer ACK our last DATA pkt? */
709	if (recv_blk == (uint16_t) (block_nr - 1)) {
710	if (finished)
711	goto ret;
712	continue; /* send next block */
713	}
714	}
715	/* Awww... recv'd packet is not recognized! */
716	goto recv_again;
717	/* why recv_again? - rfc1123 says:
718	* "The sender (i.e., the side originating the DATA packets)
719	* must never resend the current DATA packet on receipt
720	* of a duplicate ACK".
721	* DATA pkts are resent ONLY on timeout.
722	* Thus "goto send_again" will ba a bad mistake above.
723	* See:
724	* http://en.wikipedia.org/wiki/Sorcerer's_Apprentice_Syndrome
725	*/
726	} /* end of "while (1)" */
727	ret:
728	if (ENABLE_FEATURE_CLEAN_UP) {
729	close(local_fd);
730	close(socket_fd);
731	free(xbuf);
732	free(rbuf);
733	}
734	return finished == 0; /* returns 1 on failure */
735
736	send_read_err_pkt:
737	strcpy(G_error_pkt_str, bb_msg_read_error);
738	send_err_pkt:
739	if (G_error_pkt_str[0])
740	bb_error_msg("%s", G_error_pkt_str);
741	G.error_pkt[1] = TFTP_ERROR;
742	xsendto(socket_fd, G.error_pkt, 4 + 1 + strlen(G_error_pkt_str),
743	&peer_lsa->u.sa, peer_lsa->len);
744	return EXIT_FAILURE;
745	#undef remote_file
746	}
747
748	#if ENABLE_TFTP
749
750	int tftp_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
751	int tftp_main(int argc UNUSED_PARAM, char **argv)
752	{
753	len_and_sockaddr *peer_lsa;
754	const char *local_file = NULL;
755	const char *remote_file = NULL;
756	# if ENABLE_FEATURE_TFTP_BLOCKSIZE
757	const char *blksize_str = TFTP_BLKSIZE_DEFAULT_STR;
758	int blksize;
759	# endif
760	int result;
761	int port;
762	IF_GETPUT(int opt;)
763
764	INIT_G();
765
766	/* -p or -g is mandatory, and they are mutually exclusive */
767	opt_complementary = "" IF_FEATURE_TFTP_GET("g:") IF_FEATURE_TFTP_PUT("p:")
768	IF_GETPUT("g--p:p--g:");
769
770	IF_GETPUT(opt =) getopt32(argv,
771	IF_FEATURE_TFTP_GET("g") IF_FEATURE_TFTP_PUT("p")
772	"l:r:" IF_FEATURE_TFTP_BLOCKSIZE("b:"),
773	&local_file, &remote_file
774	IF_FEATURE_TFTP_BLOCKSIZE(, &blksize_str));
775	argv += optind;
776
777	# if ENABLE_FEATURE_TFTP_BLOCKSIZE
778	/* Check if the blksize is valid:
779	* RFC2348 says between 8 and 65464 */
780	blksize = tftp_blksize_check(blksize_str, 65564);
781	if (blksize < 0) {
782	//bb_error_msg("bad block size");
783	return EXIT_FAILURE;
784	}
785	# endif
786
787	if (remote_file) {
788	if (!local_file) {
789	const char *slash = strrchr(remote_file, '/');
790	local_file = slash ? slash + 1 : remote_file;
791	}
792	} else {
793	remote_file = local_file;
794	}
795
796	/* Error if filename or host is not known */
797	if (!remote_file || !argv[0])
798	bb_show_usage();
799
800	port = bb_lookup_port(argv[1], "udp", 69);
801	peer_lsa = xhost2sockaddr(argv[0], port);
802
803	# if ENABLE_TFTP_DEBUG
804	fprintf(stderr, "using server '%s', remote_file '%s', local_file '%s'\n",
805	xmalloc_sockaddr2dotted(&peer_lsa->u.sa),
806	remote_file, local_file);
807	# endif
808
809	# if ENABLE_FEATURE_TFTP_PROGRESS_BAR
810	G.file = remote_file;
811	# endif
812	result = tftp_protocol(
813	NULL /*our_lsa*/, peer_lsa,
814	local_file, remote_file
815	IF_FEATURE_TFTP_BLOCKSIZE(, 1 /* want_transfer_size */)
816	IF_FEATURE_TFTP_BLOCKSIZE(, blksize)
817	);
818	tftp_progress_done();
819
820	if (result != EXIT_SUCCESS && NOT_LONE_DASH(local_file) && CMD_GET(opt)) {
821	unlink(local_file);
822	}
823	return result;
824	}
825
826	#endif /* ENABLE_TFTP */
827
828	#if ENABLE_TFTPD
829	int tftpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
830	int tftpd_main(int argc UNUSED_PARAM, char **argv)
831	{
832	len_and_sockaddr *our_lsa;
833	len_and_sockaddr *peer_lsa;
834	char *mode, *user_opt;
835	char *local_file = local_file;
836	const char *error_msg;
837	int opt, result, opcode;
838	IF_FEATURE_TFTP_BLOCKSIZE(int blksize = TFTP_BLKSIZE_DEFAULT;)
839	IF_FEATURE_TFTP_BLOCKSIZE(int want_transfer_size = 0;)
840
841	INIT_G();
842
843	our_lsa = get_sock_lsa(STDIN_FILENO);
844	if (!our_lsa) {
845	/* This is confusing:
846	*bb_error_msg_and_die("stdin is not a socket");
847	* Better: */
848	bb_show_usage();
849	/* Help text says that tftpd must be used as inetd service,
850	* which is by far the most usual cause of get_sock_lsa
851	* failure */
852	}
853	peer_lsa = xzalloc(LSA_LEN_SIZE + our_lsa->len);
854	peer_lsa->len = our_lsa->len;
855
856	/* Shifting to not collide with TFTP_OPTs */
857	opt = option_mask32 = TFTPD_OPT | (getopt32(argv, "rcu:l", &user_opt) << 8);
858	argv += optind;
859	if (opt & TFTPD_OPT_l) {
860	openlog(applet_name, LOG_PID, LOG_DAEMON);
861	logmode = LOGMODE_SYSLOG;
862	}
863	if (opt & TFTPD_OPT_u) {
864	/* Must be before xchroot */
865	G.pw = xgetpwnam(user_opt);
866	}
867	if (argv[0]) {
868	xchroot(argv[0]);
869	}
870
871	result = recv_from_to(STDIN_FILENO,
872	G.block_buf, sizeof(G.block_buf) + 1,
873	/* ^^^ sizeof+1 to reliably detect oversized input */
874	0 /* flags */,
875	&peer_lsa->u.sa, &our_lsa->u.sa, our_lsa->len);
876
877	error_msg = "malformed packet";
878	opcode = ntohs(*(uint16_t*)G.block_buf);
879	if (result < 4 || result > sizeof(G.block_buf)
880	/*|| G.block_buf[result-1] != '\0' - bug compatibility, see below */
881	|| (IF_FEATURE_TFTP_PUT(opcode != TFTP_RRQ) /* not download */
882	IF_GETPUT(&&)
883	IF_FEATURE_TFTP_GET(opcode != TFTP_WRQ) /* not upload */
884	)
885	) {
886	goto err;
887	}
888	/* Some HP PA-RISC firmware always sends fixed 516-byte requests,
889	* with trailing garbage.
890	* Support that by not requiring NUL to be the last byte (see above).
891	* To make strXYZ() ops safe, force NUL termination:
892	*/
893	G.block_buf_tail[0] = '\0';
894
895	local_file = G.block_buf + 2;
896	if (local_file[0] == '.' || strstr(local_file, "/.")) {
897	error_msg = "dot in file name";
898	goto err;
899	}
900	mode = local_file + strlen(local_file) + 1;
901	/* RFC 1350 says mode string is case independent */
902	if (mode >= G.block_buf + result || strcasecmp(mode, "octet") != 0) {
903	goto err;
904	}
905	# if ENABLE_FEATURE_TFTP_BLOCKSIZE
906	{
907	char *res;
908	char *opt_str = mode + sizeof("octet");
909	int opt_len = G.block_buf + result - opt_str;
910	if (opt_len > 0) {
911	res = tftp_get_option("blksize", opt_str, opt_len);
912	if (res) {
913	blksize = tftp_blksize_check(res, 65564);
914	if (blksize < 0) {
915	G_error_pkt_reason = ERR_BAD_OPT;
916	/* will just send error pkt */
917	goto do_proto;
918	}
919	}
920	if (opcode != TFTP_WRQ /* download? */
921	/* did client ask us about file size? */
922	&& tftp_get_option("tsize", opt_str, opt_len)
923	) {
924	want_transfer_size = 1;
925	}
926	}
927	}
928	# endif
929
930	if (!ENABLE_FEATURE_TFTP_PUT || opcode == TFTP_WRQ) {
931	if (opt & TFTPD_OPT_r) {
932	/* This would mean "disk full" - not true */
933	/*G_error_pkt_reason = ERR_WRITE;*/
934	error_msg = bb_msg_write_error;
935	goto err;
936	}
937	IF_GETPUT(option_mask32 |= TFTP_OPT_GET;) /* will receive file's data */
938	} else {
939	IF_GETPUT(option_mask32 |= TFTP_OPT_PUT;) /* will send file's data */
940	}
941
942	/* NB: if G_error_pkt_str or G_error_pkt_reason is set up,
943	* tftp_protocol() just sends one error pkt and returns */
944
945	do_proto:
946	close(STDIN_FILENO); /* close old, possibly wildcard socket */
947	/* tftp_protocol() will create new one, bound to particular local IP */
948	result = tftp_protocol(
949	our_lsa, peer_lsa,
950	local_file IF_TFTP(, NULL /*remote_file*/)
951	IF_FEATURE_TFTP_BLOCKSIZE(, want_transfer_size)
952	IF_FEATURE_TFTP_BLOCKSIZE(, blksize)
953	);
954
955	return result;
956	err:
957	strcpy(G_error_pkt_str, error_msg);
958	goto do_proto;
959	}
960
961	#endif /* ENABLE_TFTPD */
962
963	#endif /* ENABLE_FEATURE_TFTP_GET || ENABLE_FEATURE_TFTP_PUT */
964