1 | /* vi: set sw=4 ts=4: */
|
---|
2 | /* -------------------------------------------------------------------------
|
---|
3 | * tftp.c
|
---|
4 | *
|
---|
5 | * A simple tftp client for busybox.
|
---|
6 | * Tries to follow RFC1350.
|
---|
7 | * Only "octet" mode supported.
|
---|
8 | * Optional blocksize negotiation (RFC2347 + RFC2348)
|
---|
9 | *
|
---|
10 | * Copyright (C) 2001 Magnus Damm <damm@opensource.se>
|
---|
11 | *
|
---|
12 | * Parts of the code based on:
|
---|
13 | *
|
---|
14 | * atftp: Copyright (C) 2000 Jean-Pierre Lefebvre <helix@step.polymtl.ca>
|
---|
15 | * and Remi Lefebvre <remi@debian.org>
|
---|
16 | *
|
---|
17 | * utftp: Copyright (C) 1999 Uwe Ohse <uwe@ohse.de>
|
---|
18 | *
|
---|
19 | * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
|
---|
20 | * ------------------------------------------------------------------------- */
|
---|
21 |
|
---|
22 | #include <stdio.h>
|
---|
23 | #include <stdlib.h>
|
---|
24 | #include <string.h>
|
---|
25 | #include <sys/types.h>
|
---|
26 | #include <sys/socket.h>
|
---|
27 | #include <sys/stat.h>
|
---|
28 | #include <netdb.h>
|
---|
29 | #include <netinet/in.h>
|
---|
30 | #include <arpa/inet.h>
|
---|
31 | #include <unistd.h>
|
---|
32 | #include <fcntl.h>
|
---|
33 |
|
---|
34 | #include "busybox.h"
|
---|
35 |
|
---|
36 |
|
---|
37 | #define TFTP_BLOCKSIZE_DEFAULT 512 /* according to RFC 1350, don't change */
|
---|
38 | #define TFTP_TIMEOUT 5 /* seconds */
|
---|
39 | #define TFTP_NUM_RETRIES 5 /* number of retries */
|
---|
40 |
|
---|
41 | static const char * const MODE_OCTET = "octet";
|
---|
42 | #define MODE_OCTET_LEN 6 /* sizeof(MODE_OCTET)*/
|
---|
43 |
|
---|
44 | static const char * const OPTION_BLOCKSIZE = "blksize";
|
---|
45 | #define OPTION_BLOCKSIZE_LEN 8 /* sizeof(OPTION_BLOCKSIZE) */
|
---|
46 |
|
---|
47 | /* opcodes we support */
|
---|
48 | #define TFTP_RRQ 1
|
---|
49 | #define TFTP_WRQ 2
|
---|
50 | #define TFTP_DATA 3
|
---|
51 | #define TFTP_ACK 4
|
---|
52 | #define TFTP_ERROR 5
|
---|
53 | #define TFTP_OACK 6
|
---|
54 |
|
---|
55 | static const char *const tftp_bb_error_msg[] = {
|
---|
56 | "Undefined error",
|
---|
57 | "File not found",
|
---|
58 | "Access violation",
|
---|
59 | "Disk full or allocation error",
|
---|
60 | "Illegal TFTP operation",
|
---|
61 | "Unknown transfer ID",
|
---|
62 | "File already exists",
|
---|
63 | "No such user"
|
---|
64 | };
|
---|
65 |
|
---|
66 | #define tftp_cmd_get ENABLE_FEATURE_TFTP_GET
|
---|
67 |
|
---|
68 | #if ENABLE_FEATURE_TFTP_PUT
|
---|
69 | # define tftp_cmd_put (tftp_cmd_get+ENABLE_FEATURE_TFTP_PUT)
|
---|
70 | #else
|
---|
71 | # define tftp_cmd_put 0
|
---|
72 | #endif
|
---|
73 |
|
---|
74 |
|
---|
75 | #ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
|
---|
76 |
|
---|
77 | static int tftp_blocksize_check(int blocksize, int bufsize)
|
---|
78 | {
|
---|
79 | /* Check if the blocksize is valid:
|
---|
80 | * RFC2348 says between 8 and 65464,
|
---|
81 | * but our implementation makes it impossible
|
---|
82 | * to use blocksizes smaller than 22 octets.
|
---|
83 | */
|
---|
84 |
|
---|
85 | if ((bufsize && (blocksize > bufsize)) ||
|
---|
86 | (blocksize < 8) || (blocksize > 65564)) {
|
---|
87 | bb_error_msg("bad blocksize");
|
---|
88 | return 0;
|
---|
89 | }
|
---|
90 |
|
---|
91 | return blocksize;
|
---|
92 | }
|
---|
93 |
|
---|
94 | static char *tftp_option_get(char *buf, int len, const char * const option)
|
---|
95 | {
|
---|
96 | int opt_val = 0;
|
---|
97 | int opt_found = 0;
|
---|
98 | int k;
|
---|
99 |
|
---|
100 | while (len > 0) {
|
---|
101 |
|
---|
102 | /* Make sure the options are terminated correctly */
|
---|
103 |
|
---|
104 | for (k = 0; k < len; k++) {
|
---|
105 | if (buf[k] == '\0') {
|
---|
106 | break;
|
---|
107 | }
|
---|
108 | }
|
---|
109 |
|
---|
110 | if (k >= len) {
|
---|
111 | break;
|
---|
112 | }
|
---|
113 |
|
---|
114 | if (opt_val == 0) {
|
---|
115 | if (strcasecmp(buf, option) == 0) {
|
---|
116 | opt_found = 1;
|
---|
117 | }
|
---|
118 | } else {
|
---|
119 | if (opt_found) {
|
---|
120 | return buf;
|
---|
121 | }
|
---|
122 | }
|
---|
123 |
|
---|
124 | k++;
|
---|
125 |
|
---|
126 | buf += k;
|
---|
127 | len -= k;
|
---|
128 |
|
---|
129 | opt_val ^= 1;
|
---|
130 | }
|
---|
131 |
|
---|
132 | return NULL;
|
---|
133 | }
|
---|
134 |
|
---|
135 | #endif
|
---|
136 |
|
---|
137 | static int tftp(const int cmd, const struct hostent *host,
|
---|
138 | const char *remotefile, const int localfd,
|
---|
139 | const unsigned short port, int tftp_bufsize)
|
---|
140 | {
|
---|
141 | struct sockaddr_in sa;
|
---|
142 | struct sockaddr_in from;
|
---|
143 | struct timeval tv;
|
---|
144 | socklen_t fromlen;
|
---|
145 | fd_set rfds;
|
---|
146 | int socketfd;
|
---|
147 | int len;
|
---|
148 | int opcode = 0;
|
---|
149 | int finished = 0;
|
---|
150 | int timeout = TFTP_NUM_RETRIES;
|
---|
151 | unsigned short block_nr = 1;
|
---|
152 | unsigned short tmp;
|
---|
153 | char *cp;
|
---|
154 |
|
---|
155 | USE_FEATURE_TFTP_BLOCKSIZE(int want_option_ack = 0;)
|
---|
156 |
|
---|
157 | /* Can't use RESERVE_CONFIG_BUFFER here since the allocation
|
---|
158 | * size varies meaning BUFFERS_GO_ON_STACK would fail */
|
---|
159 | char *buf=xmalloc(tftp_bufsize += 4);
|
---|
160 |
|
---|
161 | if ((socketfd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
|
---|
162 | /* need to unlink the localfile, so don't use bb_xsocket here. */
|
---|
163 | bb_perror_msg("socket");
|
---|
164 | return EXIT_FAILURE;
|
---|
165 | }
|
---|
166 |
|
---|
167 | len = sizeof(sa);
|
---|
168 |
|
---|
169 | memset(&sa, 0, len);
|
---|
170 | bb_xbind(socketfd, (struct sockaddr *)&sa, len);
|
---|
171 |
|
---|
172 | sa.sin_family = host->h_addrtype;
|
---|
173 | sa.sin_port = port;
|
---|
174 | memcpy(&sa.sin_addr, (struct in_addr *) host->h_addr,
|
---|
175 | sizeof(sa.sin_addr));
|
---|
176 |
|
---|
177 | /* build opcode */
|
---|
178 | if (cmd & tftp_cmd_get) {
|
---|
179 | opcode = TFTP_RRQ;
|
---|
180 | }
|
---|
181 | if (cmd & tftp_cmd_put) {
|
---|
182 | opcode = TFTP_WRQ;
|
---|
183 | }
|
---|
184 |
|
---|
185 | while (1) {
|
---|
186 |
|
---|
187 | cp = buf;
|
---|
188 |
|
---|
189 | /* first create the opcode part */
|
---|
190 | *((unsigned short *) cp) = htons(opcode);
|
---|
191 | cp += 2;
|
---|
192 |
|
---|
193 | /* add filename and mode */
|
---|
194 | if (((cmd & tftp_cmd_get) && (opcode == TFTP_RRQ)) ||
|
---|
195 | ((cmd & tftp_cmd_put) && (opcode == TFTP_WRQ)))
|
---|
196 | {
|
---|
197 | int too_long = 0;
|
---|
198 |
|
---|
199 | /* see if the filename fits into buf
|
---|
200 | * and fill in packet. */
|
---|
201 | len = strlen(remotefile) + 1;
|
---|
202 |
|
---|
203 | if ((cp + len) >= &buf[tftp_bufsize - 1]) {
|
---|
204 | too_long = 1;
|
---|
205 | } else {
|
---|
206 | safe_strncpy(cp, remotefile, len);
|
---|
207 | cp += len;
|
---|
208 | }
|
---|
209 |
|
---|
210 | if (too_long || ((&buf[tftp_bufsize - 1] - cp) < MODE_OCTET_LEN)) {
|
---|
211 | bb_error_msg("remote filename too long");
|
---|
212 | break;
|
---|
213 | }
|
---|
214 |
|
---|
215 | /* add "mode" part of the package */
|
---|
216 | memcpy(cp, MODE_OCTET, MODE_OCTET_LEN);
|
---|
217 | cp += MODE_OCTET_LEN;
|
---|
218 |
|
---|
219 | #ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
|
---|
220 |
|
---|
221 | len = tftp_bufsize - 4; /* data block size */
|
---|
222 |
|
---|
223 | if (len != TFTP_BLOCKSIZE_DEFAULT) {
|
---|
224 |
|
---|
225 | if ((&buf[tftp_bufsize - 1] - cp) < 15) {
|
---|
226 | bb_error_msg("remote filename too long");
|
---|
227 | break;
|
---|
228 | }
|
---|
229 |
|
---|
230 | /* add "blksize" + number of blocks */
|
---|
231 | memcpy(cp, OPTION_BLOCKSIZE, OPTION_BLOCKSIZE_LEN);
|
---|
232 | cp += OPTION_BLOCKSIZE_LEN;
|
---|
233 | cp += snprintf(cp, 6, "%d", len) + 1;
|
---|
234 |
|
---|
235 | want_option_ack = 1;
|
---|
236 | }
|
---|
237 | #endif
|
---|
238 | }
|
---|
239 |
|
---|
240 | /* add ack and data */
|
---|
241 |
|
---|
242 | if (((cmd & tftp_cmd_get) && (opcode == TFTP_ACK)) ||
|
---|
243 | ((cmd & tftp_cmd_put) && (opcode == TFTP_DATA))) {
|
---|
244 |
|
---|
245 | *((unsigned short *) cp) = htons(block_nr);
|
---|
246 |
|
---|
247 | cp += 2;
|
---|
248 |
|
---|
249 | block_nr++;
|
---|
250 |
|
---|
251 | if ((cmd & tftp_cmd_put) && (opcode == TFTP_DATA)) {
|
---|
252 | len = bb_full_read(localfd, cp, tftp_bufsize - 4);
|
---|
253 |
|
---|
254 | if (len < 0) {
|
---|
255 | bb_perror_msg(bb_msg_read_error);
|
---|
256 | break;
|
---|
257 | }
|
---|
258 |
|
---|
259 | if (len != (tftp_bufsize - 4)) {
|
---|
260 | finished++;
|
---|
261 | }
|
---|
262 |
|
---|
263 | cp += len;
|
---|
264 | }
|
---|
265 | }
|
---|
266 |
|
---|
267 |
|
---|
268 | /* send packet */
|
---|
269 |
|
---|
270 |
|
---|
271 | timeout = TFTP_NUM_RETRIES; /* re-initialize */
|
---|
272 | do {
|
---|
273 |
|
---|
274 | len = cp - buf;
|
---|
275 |
|
---|
276 | #ifdef CONFIG_DEBUG_TFTP
|
---|
277 | fprintf(stderr, "sending %u bytes\n", len);
|
---|
278 | for (cp = buf; cp < &buf[len]; cp++)
|
---|
279 | fprintf(stderr, "%02x ", (unsigned char) *cp);
|
---|
280 | fprintf(stderr, "\n");
|
---|
281 | #endif
|
---|
282 | if (sendto(socketfd, buf, len, 0,
|
---|
283 | (struct sockaddr *) &sa, sizeof(sa)) < 0) {
|
---|
284 | bb_perror_msg("send");
|
---|
285 | len = -1;
|
---|
286 | break;
|
---|
287 | }
|
---|
288 |
|
---|
289 |
|
---|
290 | if (finished && (opcode == TFTP_ACK)) {
|
---|
291 | break;
|
---|
292 | }
|
---|
293 |
|
---|
294 | /* receive packet */
|
---|
295 |
|
---|
296 | memset(&from, 0, sizeof(from));
|
---|
297 | fromlen = sizeof(from);
|
---|
298 |
|
---|
299 | tv.tv_sec = TFTP_TIMEOUT;
|
---|
300 | tv.tv_usec = 0;
|
---|
301 |
|
---|
302 | FD_ZERO(&rfds);
|
---|
303 | FD_SET(socketfd, &rfds);
|
---|
304 |
|
---|
305 | switch (select(socketfd + 1, &rfds, NULL, NULL, &tv)) {
|
---|
306 | case 1:
|
---|
307 | len = recvfrom(socketfd, buf, tftp_bufsize, 0,
|
---|
308 | (struct sockaddr *) &from, &fromlen);
|
---|
309 |
|
---|
310 | if (len < 0) {
|
---|
311 | bb_perror_msg("recvfrom");
|
---|
312 | break;
|
---|
313 | }
|
---|
314 |
|
---|
315 | timeout = 0;
|
---|
316 |
|
---|
317 | if (sa.sin_port == port) {
|
---|
318 | sa.sin_port = from.sin_port;
|
---|
319 | }
|
---|
320 | if (sa.sin_port == from.sin_port) {
|
---|
321 | break;
|
---|
322 | }
|
---|
323 |
|
---|
324 | /* fall-through for bad packets! */
|
---|
325 | /* discard the packet - treat as timeout */
|
---|
326 | timeout = TFTP_NUM_RETRIES;
|
---|
327 | case 0:
|
---|
328 | bb_error_msg("timeout");
|
---|
329 |
|
---|
330 | timeout--;
|
---|
331 | if (timeout == 0) {
|
---|
332 | len = -1;
|
---|
333 | bb_error_msg("last timeout");
|
---|
334 | }
|
---|
335 | break;
|
---|
336 | default:
|
---|
337 | bb_perror_msg("select");
|
---|
338 | len = -1;
|
---|
339 | }
|
---|
340 |
|
---|
341 | } while (timeout && (len >= 0));
|
---|
342 |
|
---|
343 | if ((finished) || (len < 0)) {
|
---|
344 | break;
|
---|
345 | }
|
---|
346 |
|
---|
347 | /* process received packet */
|
---|
348 |
|
---|
349 | opcode = ntohs(*((unsigned short *) buf));
|
---|
350 | tmp = ntohs(*((unsigned short *) &buf[2]));
|
---|
351 |
|
---|
352 | #ifdef CONFIG_DEBUG_TFTP
|
---|
353 | fprintf(stderr, "received %d bytes: %04x %04x\n", len, opcode, tmp);
|
---|
354 | #endif
|
---|
355 |
|
---|
356 | if (opcode == TFTP_ERROR) {
|
---|
357 | const char *msg = NULL;
|
---|
358 |
|
---|
359 | if (buf[4] != '\0') {
|
---|
360 | msg = &buf[4];
|
---|
361 | buf[tftp_bufsize - 1] = '\0';
|
---|
362 | } else if (tmp < (sizeof(tftp_bb_error_msg)
|
---|
363 | / sizeof(char *))) {
|
---|
364 |
|
---|
365 | msg = tftp_bb_error_msg[tmp];
|
---|
366 | }
|
---|
367 |
|
---|
368 | if (msg) {
|
---|
369 | bb_error_msg("server says: %s", msg);
|
---|
370 | }
|
---|
371 |
|
---|
372 | break;
|
---|
373 | }
|
---|
374 | #ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
|
---|
375 | if (want_option_ack) {
|
---|
376 |
|
---|
377 | want_option_ack = 0;
|
---|
378 |
|
---|
379 | if (opcode == TFTP_OACK) {
|
---|
380 |
|
---|
381 | /* server seems to support options */
|
---|
382 |
|
---|
383 | char *res;
|
---|
384 |
|
---|
385 | res = tftp_option_get(&buf[2], len - 2, OPTION_BLOCKSIZE);
|
---|
386 |
|
---|
387 | if (res) {
|
---|
388 | int blksize = atoi(res);
|
---|
389 |
|
---|
390 | if (tftp_blocksize_check(blksize, tftp_bufsize - 4)) {
|
---|
391 |
|
---|
392 | if (cmd & tftp_cmd_put) {
|
---|
393 | opcode = TFTP_DATA;
|
---|
394 | } else {
|
---|
395 | opcode = TFTP_ACK;
|
---|
396 | }
|
---|
397 | #ifdef CONFIG_DEBUG_TFTP
|
---|
398 | fprintf(stderr, "using %s %u\n", OPTION_BLOCKSIZE,
|
---|
399 | blksize);
|
---|
400 | #endif
|
---|
401 | tftp_bufsize = blksize + 4;
|
---|
402 | block_nr = 0;
|
---|
403 | continue;
|
---|
404 | }
|
---|
405 | }
|
---|
406 | /* FIXME:
|
---|
407 | * we should send ERROR 8 */
|
---|
408 | bb_error_msg("bad server option");
|
---|
409 | break;
|
---|
410 | }
|
---|
411 |
|
---|
412 | bb_error_msg("warning: blksize not supported by server"
|
---|
413 | " - reverting to 512");
|
---|
414 |
|
---|
415 | tftp_bufsize = TFTP_BLOCKSIZE_DEFAULT + 4;
|
---|
416 | }
|
---|
417 | #endif
|
---|
418 |
|
---|
419 | if ((cmd & tftp_cmd_get) && (opcode == TFTP_DATA)) {
|
---|
420 |
|
---|
421 | if (tmp == block_nr) {
|
---|
422 |
|
---|
423 | len = bb_full_write(localfd, &buf[4], len - 4);
|
---|
424 |
|
---|
425 | if (len < 0) {
|
---|
426 | bb_perror_msg(bb_msg_write_error);
|
---|
427 | break;
|
---|
428 | }
|
---|
429 |
|
---|
430 | if (len != (tftp_bufsize - 4)) {
|
---|
431 | finished++;
|
---|
432 | }
|
---|
433 |
|
---|
434 | opcode = TFTP_ACK;
|
---|
435 | continue;
|
---|
436 | }
|
---|
437 | /* in case the last ack disappeared into the ether */
|
---|
438 | if (tmp == (block_nr - 1)) {
|
---|
439 | --block_nr;
|
---|
440 | opcode = TFTP_ACK;
|
---|
441 | continue;
|
---|
442 | } else if (tmp + 1 == block_nr) {
|
---|
443 | /* Server lost our TFTP_ACK. Resend it */
|
---|
444 | block_nr = tmp;
|
---|
445 | opcode = TFTP_ACK;
|
---|
446 | continue;
|
---|
447 | }
|
---|
448 | }
|
---|
449 |
|
---|
450 | if ((cmd & tftp_cmd_put) && (opcode == TFTP_ACK)) {
|
---|
451 |
|
---|
452 | if (tmp == (unsigned short) (block_nr - 1)) {
|
---|
453 | if (finished) {
|
---|
454 | break;
|
---|
455 | }
|
---|
456 |
|
---|
457 | opcode = TFTP_DATA;
|
---|
458 | continue;
|
---|
459 | }
|
---|
460 | }
|
---|
461 | }
|
---|
462 |
|
---|
463 | #ifdef CONFIG_FEATURE_CLEAN_UP
|
---|
464 | close(socketfd);
|
---|
465 | free(buf);
|
---|
466 | #endif
|
---|
467 |
|
---|
468 | return finished ? EXIT_SUCCESS : EXIT_FAILURE;
|
---|
469 | }
|
---|
470 |
|
---|
471 | int tftp_main(int argc, char **argv)
|
---|
472 | {
|
---|
473 | struct hostent *host = NULL;
|
---|
474 | const char *localfile = NULL;
|
---|
475 | const char *remotefile = NULL;
|
---|
476 | int port;
|
---|
477 | int cmd = 0;
|
---|
478 | int fd = -1;
|
---|
479 | int flags = 0;
|
---|
480 | int result;
|
---|
481 | int blocksize = TFTP_BLOCKSIZE_DEFAULT;
|
---|
482 |
|
---|
483 | /* figure out what to pass to getopt */
|
---|
484 |
|
---|
485 | #ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
|
---|
486 | char *sblocksize = NULL;
|
---|
487 |
|
---|
488 | #define BS "b:"
|
---|
489 | #define BS_ARG , &sblocksize
|
---|
490 | #else
|
---|
491 | #define BS
|
---|
492 | #define BS_ARG
|
---|
493 | #endif
|
---|
494 |
|
---|
495 | #ifdef CONFIG_FEATURE_TFTP_GET
|
---|
496 | #define GET "g"
|
---|
497 | #define GET_COMPL ":g"
|
---|
498 | #else
|
---|
499 | #define GET
|
---|
500 | #define GET_COMPL
|
---|
501 | #endif
|
---|
502 |
|
---|
503 | #ifdef CONFIG_FEATURE_TFTP_PUT
|
---|
504 | #define PUT "p"
|
---|
505 | #define PUT_COMPL ":p"
|
---|
506 | #else
|
---|
507 | #define PUT
|
---|
508 | #define PUT_COMPL
|
---|
509 | #endif
|
---|
510 |
|
---|
511 | #if defined(CONFIG_FEATURE_TFTP_GET) && defined(CONFIG_FEATURE_TFTP_PUT)
|
---|
512 | bb_opt_complementally = GET_COMPL PUT_COMPL ":?g--p:p--g";
|
---|
513 | #elif defined(CONFIG_FEATURE_TFTP_GET) || defined(CONFIG_FEATURE_TFTP_PUT)
|
---|
514 | bb_opt_complementally = GET_COMPL PUT_COMPL;
|
---|
515 | #endif
|
---|
516 |
|
---|
517 |
|
---|
518 | cmd = bb_getopt_ulflags(argc, argv, GET PUT "l:r:" BS,
|
---|
519 | &localfile, &remotefile BS_ARG);
|
---|
520 |
|
---|
521 | cmd &= (tftp_cmd_get | tftp_cmd_put);
|
---|
522 | #ifdef CONFIG_FEATURE_TFTP_GET
|
---|
523 | if (cmd == tftp_cmd_get)
|
---|
524 | flags = O_WRONLY | O_CREAT | O_TRUNC;
|
---|
525 | #endif
|
---|
526 | #ifdef CONFIG_FEATURE_TFTP_PUT
|
---|
527 | if (cmd == tftp_cmd_put)
|
---|
528 | flags = O_RDONLY;
|
---|
529 | #endif
|
---|
530 |
|
---|
531 | #ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
|
---|
532 | if (sblocksize) {
|
---|
533 | blocksize = atoi(sblocksize);
|
---|
534 | if (!tftp_blocksize_check(blocksize, 0)) {
|
---|
535 | return EXIT_FAILURE;
|
---|
536 | }
|
---|
537 | }
|
---|
538 | #endif
|
---|
539 |
|
---|
540 | if (localfile == NULL)
|
---|
541 | localfile = remotefile;
|
---|
542 | if (remotefile == NULL)
|
---|
543 | remotefile = localfile;
|
---|
544 | if ((localfile == NULL && remotefile == NULL) || (argv[optind] == NULL))
|
---|
545 | bb_show_usage();
|
---|
546 |
|
---|
547 | if (localfile == NULL || strcmp(localfile, "-") == 0) {
|
---|
548 | fd = (cmd == tftp_cmd_get) ? STDOUT_FILENO : STDIN_FILENO;
|
---|
549 | } else {
|
---|
550 | fd = open(localfile, flags, 0644); /* fail below */
|
---|
551 | }
|
---|
552 | if (fd < 0) {
|
---|
553 | bb_perror_msg_and_die("local file");
|
---|
554 | }
|
---|
555 |
|
---|
556 | host = xgethostbyname(argv[optind]);
|
---|
557 | port = bb_lookup_port(argv[optind + 1], "udp", 69);
|
---|
558 |
|
---|
559 | #ifdef CONFIG_DEBUG_TFTP
|
---|
560 | fprintf(stderr, "using server \"%s\", remotefile \"%s\", "
|
---|
561 | "localfile \"%s\".\n",
|
---|
562 | inet_ntoa(*((struct in_addr *) host->h_addr)),
|
---|
563 | remotefile, localfile);
|
---|
564 | #endif
|
---|
565 |
|
---|
566 | result = tftp(cmd, host, remotefile, fd, port, blocksize);
|
---|
567 |
|
---|
568 | if (!(fd == STDOUT_FILENO || fd == STDIN_FILENO)) {
|
---|
569 | if (ENABLE_FEATURE_CLEAN_UP)
|
---|
570 | close(fd);
|
---|
571 | if (cmd == tftp_cmd_get && result != EXIT_SUCCESS)
|
---|
572 | unlink(localfile);
|
---|
573 | }
|
---|
574 | return (result);
|
---|
575 | }
|
---|