[821] | 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 | }
|
---|