1 /* 2 * Copyright (c) 1985, 1989, 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "ftp_locl.h" 35 RCSID ("$Id$"); 36 37 struct sockaddr_storage hisctladdr_ss; 38 struct sockaddr *hisctladdr = (struct sockaddr *)&hisctladdr_ss; 39 struct sockaddr_storage data_addr_ss; 40 struct sockaddr *data_addr = (struct sockaddr *)&data_addr_ss; 41 struct sockaddr_storage myctladdr_ss; 42 struct sockaddr *myctladdr = (struct sockaddr *)&myctladdr_ss; 43 int data = -1; 44 int abrtflag = 0; 45 jmp_buf ptabort; 46 int ptabflg; 47 int ptflag = 0; 48 off_t restart_point = 0; 49 50 51 FILE *cin, *cout; 52 53 typedef void (*sighand) (int); 54 55 char * 56 hookup (const char *host, int port) 57 { 58 static char hostnamebuf[MaxHostNameLen]; 59 struct addrinfo *ai, *a; 60 struct addrinfo hints; 61 int error; 62 char portstr[NI_MAXSERV]; 63 socklen_t len; 64 int s; 65 66 memset (&hints, 0, sizeof(hints)); 67 hints.ai_socktype = SOCK_STREAM; 68 hints.ai_protocol = IPPROTO_TCP; 69 hints.ai_flags = AI_CANONNAME; 70 71 snprintf (portstr, sizeof(portstr), "%u", ntohs(port)); 72 73 error = getaddrinfo (host, portstr, &hints, &ai); 74 if (error) { 75 warnx ("%s: %s", host, gai_strerror(error)); 76 code = -1; 77 return NULL; 78 } 79 strlcpy (hostnamebuf, host, sizeof(hostnamebuf)); 80 hostname = hostnamebuf; 81 82 s = -1; 83 for (a = ai; a != NULL; a = a->ai_next) { 84 s = socket (a->ai_family, a->ai_socktype, a->ai_protocol); 85 if (s < 0) 86 continue; 87 88 if (a->ai_canonname != NULL) 89 strlcpy (hostnamebuf, a->ai_canonname, sizeof(hostnamebuf)); 90 91 memcpy (hisctladdr, a->ai_addr, a->ai_addrlen); 92 93 error = connect (s, a->ai_addr, a->ai_addrlen); 94 if (error < 0) { 95 char addrstr[256]; 96 97 if (getnameinfo (a->ai_addr, a->ai_addrlen, 98 addrstr, sizeof(addrstr), 99 NULL, 0, NI_NUMERICHOST) != 0) 100 strlcpy (addrstr, "unknown address", sizeof(addrstr)); 101 102 warn ("connect %s", addrstr); 103 close (s); 104 s = -1; 105 continue; 106 } 107 break; 108 } 109 freeaddrinfo (ai); 110 if (s < 0) { 111 warnx ("failed to contact %s", host); 112 code = -1; 113 return NULL; 114 } 115 116 len = sizeof(myctladdr_ss); 117 if (getsockname (s, myctladdr, &len) < 0) { 118 warn ("getsockname"); 119 code = -1; 120 close (s); 121 return NULL; 122 } 123 #ifdef IPTOS_LOWDELAY 124 socket_set_tos (s, IPTOS_LOWDELAY); 125 #endif 126 cin = fdopen (s, "r"); 127 cout = fdopen (s, "w"); 128 if (cin == NULL || cout == NULL) { 129 warnx ("fdopen failed."); 130 if (cin) 131 fclose (cin); 132 if (cout) 133 fclose (cout); 134 code = -1; 135 goto bad; 136 } 137 if (verbose) 138 printf ("Connected to %s.\n", hostname); 139 if (getreply (0) > 2) { /* read startup message from server */ 140 if (cin) 141 fclose (cin); 142 if (cout) 143 fclose (cout); 144 code = -1; 145 goto bad; 146 } 147 #if defined(SO_OOBINLINE) && defined(HAVE_SETSOCKOPT) 148 { 149 int on = 1; 150 151 if (setsockopt (s, SOL_SOCKET, SO_OOBINLINE, (char *) &on, sizeof (on)) 152 < 0 && debug) { 153 warn ("setsockopt"); 154 } 155 } 156 #endif /* SO_OOBINLINE */ 157 158 return (hostname); 159 bad: 160 close (s); 161 return NULL; 162 } 163 164 int 165 login (char *host) 166 { 167 char tmp[80]; 168 char defaultpass[128]; 169 char *userstr, *pass, *acctstr; 170 char *ruserstr, *rpass, *racctstr; 171 int n, aflag = 0; 172 173 char *myname = NULL; 174 struct passwd *pw = k_getpwuid(getuid()); 175 176 if (pw != NULL) 177 myname = pw->pw_name; 178 179 ruserstr = rpass = racctstr = NULL; 180 181 if(sec_login(host)) 182 printf("\n*** Using plaintext user and password ***\n\n"); 183 else{ 184 printf("Authentication successful.\n\n"); 185 } 186 187 if (ruserpassword (host, &ruserstr, &rpass, &racctstr) < 0) { 188 code = -1; 189 return (0); 190 } 191 userstr = ruserstr; 192 pass = rpass; 193 acctstr = racctstr; 194 195 while (userstr == NULL) { 196 if (myname) 197 printf ("Name (%s:%s): ", host, myname); 198 else 199 printf ("Name (%s): ", host); 200 *tmp = '\0'; 201 if (fgets (tmp, sizeof (tmp) - 1, stdin) != NULL) 202 tmp[strlen (tmp) - 1] = '\0'; 203 if (*tmp == '\0') 204 userstr = myname; 205 else 206 userstr = tmp; 207 } 208 strlcpy(username, userstr, sizeof(username)); 209 if (ruserstr) 210 free(ruserstr); 211 212 n = command("USER %s", userstr); 213 if (n == COMPLETE) 214 n = command("PASS dummy"); /* DK: Compatibility with gssftp daemon */ 215 else if(n == CONTINUE) { 216 if (pass == NULL) { 217 char prompt[128]; 218 if(myname && 219 (!strcmp(userstr, "ftp") || !strcmp(userstr, "anonymous"))) { 220 snprintf(defaultpass, sizeof(defaultpass), 221 "%s@%s", myname, mydomain); 222 snprintf(prompt, sizeof(prompt), 223 "Password (%s): ", defaultpass); 224 } else if (sec_complete) { 225 pass = myname; 226 } else { 227 *defaultpass = '\0'; 228 snprintf(prompt, sizeof(prompt), "Password: "); 229 } 230 if (pass == NULL) { 231 pass = defaultpass; 232 UI_UTIL_read_pw_string (tmp, sizeof (tmp), prompt, 0); 233 if (tmp[0]) 234 pass = tmp; 235 } 236 } 237 n = command ("PASS %s", pass); 238 if (rpass) 239 free(rpass); 240 } 241 if (n == CONTINUE) { 242 aflag++; 243 UI_UTIL_read_pw_string (tmp, sizeof(tmp), "Account:", 0); 244 acctstr = tmp; 245 n = command ("ACCT %s", acctstr); 246 } 247 if (n != COMPLETE) { 248 if (racctstr) 249 free(racctstr); 250 warnx ("Login failed."); 251 return (0); 252 } 253 if (!aflag && acctstr != NULL) 254 command ("ACCT %s", acctstr); 255 if (racctstr) 256 free(racctstr); 257 if (proxy) 258 return (1); 259 for (n = 0; n < macnum; ++n) { 260 if (!strcmp("init", macros[n].mac_name)) { 261 strlcpy (line, "$init", sizeof (line)); 262 makeargv(); 263 domacro(margc, margv); 264 break; 265 } 266 } 267 sec_set_protection_level (); 268 return (1); 269 } 270 271 void 272 cmdabort (int sig) 273 { 274 275 printf ("\n"); 276 fflush (stdout); 277 abrtflag++; 278 if (ptflag) 279 longjmp (ptabort, 1); 280 } 281 282 int 283 command (char *fmt,...) 284 { 285 va_list ap; 286 int r; 287 sighand oldintr; 288 289 abrtflag = 0; 290 if (cout == NULL) { 291 warn ("No control connection for command"); 292 code = -1; 293 return (0); 294 } 295 oldintr = signal(SIGINT, cmdabort); 296 if(debug){ 297 printf("---> "); 298 if (strncmp("PASS ", fmt, 5) == 0) 299 printf("PASS XXXX"); 300 else { 301 va_start(ap, fmt); 302 vfprintf(stdout, fmt, ap); 303 va_end(ap); 304 } 305 } 306 va_start(ap, fmt); 307 sec_vfprintf(cout, fmt, ap); 308 va_end(ap); 309 if(debug){ 310 printf("\n"); 311 fflush(stdout); 312 } 313 fprintf (cout, "\r\n"); 314 fflush (cout); 315 cpend = 1; 316 r = getreply (!strcmp (fmt, "QUIT")); 317 if (abrtflag && oldintr != SIG_IGN) 318 (*oldintr) (SIGINT); 319 signal (SIGINT, oldintr); 320 return (r); 321 } 322 323 char reply_string[BUFSIZ]; /* last line of previous reply */ 324 325 int 326 getreply (int expecteof) 327 { 328 char *p; 329 char *lead_string; 330 int c; 331 struct sigaction sa, osa; 332 char buf[8192]; 333 int reply_code; 334 int long_warn = 0; 335 336 sigemptyset (&sa.sa_mask); 337 sa.sa_flags = 0; 338 sa.sa_handler = cmdabort; 339 sigaction (SIGINT, &sa, &osa); 340 341 p = buf; 342 343 reply_code = 0; 344 while (1) { 345 c = getc (cin); 346 switch (c) { 347 case EOF: 348 if (expecteof) { 349 sigaction (SIGINT, &osa, NULL); 350 code = 221; 351 return 0; 352 } 353 lostpeer (0); 354 if (verbose) { 355 printf ("421 Service not available, " 356 "remote server has closed connection\n"); 357 fflush (stdout); 358 } 359 code = 421; 360 return (4); 361 case IAC: 362 c = getc (cin); 363 if (c == WILL || c == WONT) 364 fprintf (cout, "%c%c%c", IAC, DONT, getc (cin)); 365 if (c == DO || c == DONT) 366 fprintf (cout, "%c%c%c", IAC, WONT, getc (cin)); 367 continue; 368 case '\n': 369 *p++ = '\0'; 370 if(isdigit((unsigned char)buf[0])){ 371 sscanf(buf, "%d", &code); 372 if(code == 631){ 373 code = 0; 374 sec_read_msg(buf, prot_safe); 375 sscanf(buf, "%d", &code); 376 lead_string = "S:"; 377 } else if(code == 632){ 378 code = 0; 379 sec_read_msg(buf, prot_private); 380 sscanf(buf, "%d", &code); 381 lead_string = "P:"; 382 }else if(code == 633){ 383 code = 0; 384 sec_read_msg(buf, prot_confidential); 385 sscanf(buf, "%d", &code); 386 lead_string = "C:"; 387 }else if(sec_complete) 388 lead_string = "!!"; 389 else 390 lead_string = ""; 391 if(code != 0 && reply_code == 0) 392 reply_code = code; 393 if (verbose > 0 || (verbose > -1 && code > 499)) 394 fprintf (stdout, "%s%s\n", lead_string, buf); 395 if (code == reply_code && buf[3] == ' ') { 396 strlcpy (reply_string, buf, sizeof(reply_string)); 397 if (code >= 200) 398 cpend = 0; 399 sigaction (SIGINT, &osa, NULL); 400 if (code == 421) 401 lostpeer (0); 402 #if 1 403 if (abrtflag && 404 osa.sa_handler != cmdabort && 405 osa.sa_handler != SIG_IGN) 406 osa.sa_handler (SIGINT); 407 #endif 408 if (code == 227 || code == 229) { 409 char *q; 410 411 q = strchr (reply_string, '('); 412 if (q) { 413 q++; 414 strlcpy(pasv, q, sizeof(pasv)); 415 q = strrchr(pasv, ')'); 416 if (q) 417 *q = '\0'; 418 } 419 } 420 return code / 100; 421 } 422 }else{ 423 if(verbose > 0 || (verbose > -1 && code > 499)){ 424 if(sec_complete) 425 fprintf(stdout, "!!"); 426 fprintf(stdout, "%s\n", buf); 427 } 428 } 429 p = buf; 430 long_warn = 0; 431 continue; 432 default: 433 if(p < buf + sizeof(buf) - 1) 434 *p++ = c; 435 else if(long_warn == 0) { 436 fprintf(stderr, "WARNING: incredibly long line received\n"); 437 long_warn = 1; 438 } 439 } 440 } 441 442 } 443 444 445 #if 0 446 int 447 getreply (int expecteof) 448 { 449 int c, n; 450 int dig; 451 int originalcode = 0, continuation = 0; 452 sighand oldintr; 453 int pflag = 0; 454 char *cp, *pt = pasv; 455 456 oldintr = signal (SIGINT, cmdabort); 457 for (;;) { 458 dig = n = code = 0; 459 cp = reply_string; 460 while ((c = getc (cin)) != '\n') { 461 if (c == IAC) { /* handle telnet commands */ 462 switch (c = getc (cin)) { 463 case WILL: 464 case WONT: 465 c = getc (cin); 466 fprintf (cout, "%c%c%c", IAC, DONT, c); 467 fflush (cout); 468 break; 469 case DO: 470 case DONT: 471 c = getc (cin); 472 fprintf (cout, "%c%c%c", IAC, WONT, c); 473 fflush (cout); 474 break; 475 default: 476 break; 477 } 478 continue; 479 } 480 dig++; 481 if (c == EOF) { 482 if (expecteof) { 483 signal (SIGINT, oldintr); 484 code = 221; 485 return (0); 486 } 487 lostpeer (0); 488 if (verbose) { 489 printf ("421 Service not available, remote server has closed connection\n"); 490 fflush (stdout); 491 } 492 code = 421; 493 return (4); 494 } 495 if (c != '\r' && (verbose > 0 || 496 (verbose > -1 && n == '5' && dig > 4))) { 497 if (proxflag && 498 (dig == 1 || dig == 5 && verbose == 0)) 499 printf ("%s:", hostname); 500 putchar (c); 501 } 502 if (dig < 4 && isdigit (c)) 503 code = code * 10 + (c - '0'); 504 if (!pflag && code == 227) 505 pflag = 1; 506 if (dig > 4 && pflag == 1 && isdigit (c)) 507 pflag = 2; 508 if (pflag == 2) { 509 if (c != '\r' && c != ')') 510 *pt++ = c; 511 else { 512 *pt = '\0'; 513 pflag = 3; 514 } 515 } 516 if (dig == 4 && c == '-') { 517 if (continuation) 518 code = 0; 519 continuation++; 520 } 521 if (n == 0) 522 n = c; 523 if (cp < &reply_string[sizeof (reply_string) - 1]) 524 *cp++ = c; 525 } 526 if (verbose > 0 || verbose > -1 && n == '5') { 527 putchar (c); 528 fflush (stdout); 529 } 530 if (continuation && code != originalcode) { 531 if (originalcode == 0) 532 originalcode = code; 533 continue; 534 } 535 *cp = '\0'; 536 if(sec_complete){ 537 if(code == 631) 538 sec_read_msg(reply_string, prot_safe); 539 else if(code == 632) 540 sec_read_msg(reply_string, prot_private); 541 else if(code == 633) 542 sec_read_msg(reply_string, prot_confidential); 543 n = code / 100 + '0'; 544 } 545 if (n != '1') 546 cpend = 0; 547 signal (SIGINT, oldintr); 548 if (code == 421 || originalcode == 421) 549 lostpeer (0); 550 if (abrtflag && oldintr != cmdabort && oldintr != SIG_IGN) 551 (*oldintr) (SIGINT); 552 return (n - '0'); 553 } 554 } 555 556 #endif 557 558 int 559 empty (fd_set * mask, int sec) 560 { 561 struct timeval t; 562 563 t.tv_sec = sec; 564 t.tv_usec = 0; 565 return (select (FD_SETSIZE, mask, NULL, NULL, &t)); 566 } 567 568 jmp_buf sendabort; 569 570 static RETSIGTYPE 571 abortsend (int sig) 572 { 573 574 mflag = 0; 575 abrtflag = 0; 576 printf ("\nsend aborted\nwaiting for remote to finish abort\n"); 577 fflush (stdout); 578 longjmp (sendabort, 1); 579 } 580 581 #define HASHBYTES 1024 582 583 static int 584 copy_stream (FILE * from, FILE * to) 585 { 586 static size_t bufsize; 587 static char *buf; 588 int n; 589 int bytes = 0; 590 int werr = 0; 591 int hashbytes = HASHBYTES; 592 struct stat st; 593 594 #if defined(HAVE_MMAP) && !defined(NO_MMAP) 595 void *chunk; 596 size_t off; 597 598 #define BLOCKSIZE (1024 * 1024 * 10) 599 600 #ifndef MAP_FAILED 601 #define MAP_FAILED (-1) 602 #endif 603 604 if (fstat (fileno (from), &st) == 0 && S_ISREG (st.st_mode)) { 605 /* 606 * mmap zero bytes has potential of loosing, don't do it. 607 */ 608 if (st.st_size == 0) 609 return 0; 610 off = 0; 611 while (off != st.st_size) { 612 size_t len; 613 ssize_t res; 614 615 len = st.st_size - off; 616 if (len > BLOCKSIZE) 617 len = BLOCKSIZE; 618 619 chunk = mmap (0, len, PROT_READ, MAP_SHARED, fileno (from), off); 620 if (chunk == (void *) MAP_FAILED) { 621 if (off == 0) /* try read if mmap doesn't work */ 622 goto try_read; 623 break; 624 } 625 626 res = sec_write (fileno (to), chunk, len); 627 if (msync (chunk, len, MS_ASYNC)) 628 warn ("msync"); 629 if (munmap (chunk, len) < 0) 630 warn ("munmap"); 631 sec_fflush (to); 632 if (res != len) 633 return off; 634 off += len; 635 } 636 return off; 637 } 638 try_read: 639 #endif 640 641 buf = alloc_buffer (buf, &bufsize, 642 fstat (fileno (from), &st) >= 0 ? &st : NULL); 643 if (buf == NULL) 644 return -1; 645 646 while ((n = read (fileno (from), buf, bufsize)) > 0) { 647 werr = sec_write (fileno (to), buf, n); 648 if (werr < 0) 649 break; 650 bytes += werr; 651 while (hash && bytes > hashbytes) { 652 putchar ('#'); 653 hashbytes += HASHBYTES; 654 } 655 } 656 sec_fflush (to); 657 if (n < 0) 658 warn ("local"); 659 660 if (werr < 0) { 661 if (errno != EPIPE) 662 warn ("netout"); 663 bytes = -1; 664 } 665 return bytes; 666 } 667 668 void 669 sendrequest (char *cmd, char *local, char *remote, char *lmode, int printnames) 670 { 671 struct stat st; 672 struct timeval start, stop; 673 int c, d; 674 FILE *fin, *dout = 0; 675 int (*closefunc) (FILE *); 676 RETSIGTYPE (*oldintr)(int), (*oldintp)(int); 677 long bytes = 0, hashbytes = HASHBYTES; 678 char *rmode = "w"; 679 680 if (verbose && printnames) { 681 if (strcmp (local, "-") != 0) 682 printf ("local: %s ", local); 683 if (remote) 684 printf ("remote: %s\n", remote); 685 } 686 if (proxy) { 687 proxtrans (cmd, local, remote); 688 return; 689 } 690 if (curtype != type) 691 changetype (type, 0); 692 closefunc = NULL; 693 oldintr = NULL; 694 oldintp = NULL; 695 696 if (setjmp (sendabort)) { 697 while (cpend) { 698 getreply (0); 699 } 700 if (data >= 0) { 701 close (data); 702 data = -1; 703 } 704 if (oldintr) 705 signal (SIGINT, oldintr); 706 if (oldintp) 707 signal (SIGPIPE, oldintp); 708 code = -1; 709 return; 710 } 711 oldintr = signal (SIGINT, abortsend); 712 if (strcmp (local, "-") == 0) 713 fin = stdin; 714 else if (*local == '|') { 715 oldintp = signal (SIGPIPE, SIG_IGN); 716 fin = popen (local + 1, lmode); 717 if (fin == NULL) { 718 warn ("%s", local + 1); 719 signal (SIGINT, oldintr); 720 signal (SIGPIPE, oldintp); 721 code = -1; 722 return; 723 } 724 closefunc = pclose; 725 } else { 726 fin = fopen (local, lmode); 727 if (fin == NULL) { 728 warn ("local: %s", local); 729 signal (SIGINT, oldintr); 730 code = -1; 731 return; 732 } 733 closefunc = fclose; 734 if (fstat (fileno (fin), &st) < 0 || !S_ISREG(st.st_mode)) { 735 fprintf (stdout, "%s: not a plain file.\n", local); 736 signal (SIGINT, oldintr); 737 fclose (fin); 738 code = -1; 739 return; 740 } 741 } 742 if (initconn ()) { 743 signal (SIGINT, oldintr); 744 if (oldintp) 745 signal (SIGPIPE, oldintp); 746 code = -1; 747 if (closefunc != NULL) 748 (*closefunc) (fin); 749 return; 750 } 751 if (setjmp (sendabort)) 752 goto abort; 753 754 if (restart_point && 755 (strcmp (cmd, "STOR") == 0 || strcmp (cmd, "APPE") == 0)) { 756 int rc; 757 758 switch (curtype) { 759 case TYPE_A: 760 rc = fseek (fin, (long) restart_point, SEEK_SET); 761 break; 762 case TYPE_I: 763 case TYPE_L: 764 rc = lseek (fileno (fin), restart_point, SEEK_SET); 765 break; 766 default: 767 abort(); 768 } 769 if (rc < 0) { 770 warn ("local: %s", local); 771 restart_point = 0; 772 if (closefunc != NULL) 773 (*closefunc) (fin); 774 return; 775 } 776 if (command ("REST %ld", (long) restart_point) 777 != CONTINUE) { 778 restart_point = 0; 779 if (closefunc != NULL) 780 (*closefunc) (fin); 781 return; 782 } 783 restart_point = 0; 784 rmode = "r+w"; 785 } 786 if (remote) { 787 if (command ("%s %s", cmd, remote) != PRELIM) { 788 signal (SIGINT, oldintr); 789 if (oldintp) 790 signal (SIGPIPE, oldintp); 791 if (closefunc != NULL) 792 (*closefunc) (fin); 793 return; 794 } 795 } else if (command ("%s", cmd) != PRELIM) { 796 signal(SIGINT, oldintr); 797 if (oldintp) 798 signal(SIGPIPE, oldintp); 799 if (closefunc != NULL) 800 (*closefunc)(fin); 801 return; 802 } 803 dout = dataconn(rmode); 804 if (dout == NULL) 805 goto abort; 806 set_buffer_size (fileno (dout), 0); 807 gettimeofday (&start, (struct timezone *) 0); 808 oldintp = signal (SIGPIPE, SIG_IGN); 809 switch (curtype) { 810 811 case TYPE_I: 812 case TYPE_L: 813 errno = d = c = 0; 814 bytes = copy_stream (fin, dout); 815 break; 816 817 case TYPE_A: 818 while ((c = getc (fin)) != EOF) { 819 if (c == '\n') { 820 while (hash && (bytes >= hashbytes)) { 821 putchar ('#'); 822 fflush (stdout); 823 hashbytes += HASHBYTES; 824 } 825 if (ferror (dout)) 826 break; 827 sec_putc ('\r', dout); 828 bytes++; 829 } 830 sec_putc (c, dout); 831 bytes++; 832 } 833 sec_fflush (dout); 834 if (hash) { 835 if (bytes < hashbytes) 836 putchar ('#'); 837 putchar ('\n'); 838 fflush (stdout); 839 } 840 if (ferror (fin)) 841 warn ("local: %s", local); 842 if (ferror (dout)) { 843 if (errno != EPIPE) 844 warn ("netout"); 845 bytes = -1; 846 } 847 break; 848 } 849 if (closefunc != NULL) 850 (*closefunc) (fin); 851 fclose (dout); 852 gettimeofday (&stop, (struct timezone *) 0); 853 getreply (0); 854 signal (SIGINT, oldintr); 855 if (oldintp) 856 signal (SIGPIPE, oldintp); 857 if (bytes > 0) 858 ptransfer ("sent", bytes, &start, &stop); 859 return; 860 abort: 861 signal (SIGINT, oldintr); 862 if (oldintp) 863 signal (SIGPIPE, oldintp); 864 if (!cpend) { 865 code = -1; 866 return; 867 } 868 if (data >= 0) { 869 close (data); 870 data = -1; 871 } 872 if (dout) 873 fclose (dout); 874 getreply (0); 875 code = -1; 876 if (closefunc != NULL && fin != NULL) 877 (*closefunc) (fin); 878 gettimeofday (&stop, (struct timezone *) 0); 879 if (bytes > 0) 880 ptransfer ("sent", bytes, &start, &stop); 881 } 882 883 jmp_buf recvabort; 884 885 void 886 abortrecv (int sig) 887 { 888 889 mflag = 0; 890 abrtflag = 0; 891 printf ("\nreceive aborted\nwaiting for remote to finish abort\n"); 892 fflush (stdout); 893 longjmp (recvabort, 1); 894 } 895 896 void 897 recvrequest (char *cmd, char *local, char *remote, 898 char *lmode, int printnames, int local_given) 899 { 900 FILE *fout = NULL, *din = NULL; 901 int (*closefunc) (FILE *); 902 sighand oldintr, oldintp; 903 int c, d, is_retr, tcrflag, bare_lfs = 0; 904 static size_t bufsize; 905 static char *buf; 906 long bytes = 0, hashbytes = HASHBYTES; 907 struct timeval start, stop; 908 struct stat st; 909 910 is_retr = strcmp (cmd, "RETR") == 0; 911 if (is_retr && verbose && printnames) { 912 if (strcmp (local, "-") != 0) 913 printf ("local: %s ", local); 914 if (remote) 915 printf ("remote: %s\n", remote); 916 } 917 if (proxy && is_retr) { 918 proxtrans (cmd, local, remote); 919 return; 920 } 921 closefunc = NULL; 922 oldintr = NULL; 923 oldintp = NULL; 924 tcrflag = !crflag && is_retr; 925 if (setjmp (recvabort)) { 926 while (cpend) { 927 getreply (0); 928 } 929 if (data >= 0) { 930 close (data); 931 data = -1; 932 } 933 if (oldintr) 934 signal (SIGINT, oldintr); 935 code = -1; 936 return; 937 } 938 oldintr = signal (SIGINT, abortrecv); 939 if (!local_given || (strcmp(local, "-") && *local != '|')) { 940 if (access (local, 2) < 0) { 941 char *dir = strrchr (local, '/'); 942 943 if (errno != ENOENT && errno != EACCES) { 944 warn ("local: %s", local); 945 signal (SIGINT, oldintr); 946 code = -1; 947 return; 948 } 949 if (dir != NULL) 950 *dir = 0; 951 d = access (dir ? local : ".", 2); 952 if (dir != NULL) 953 *dir = '/'; 954 if (d < 0) { 955 warn ("local: %s", local); 956 signal (SIGINT, oldintr); 957 code = -1; 958 return; 959 } 960 if (!runique && errno == EACCES && 961 chmod (local, 0600) < 0) { 962 warn ("local: %s", local); 963 signal (SIGINT, oldintr); 964 signal (SIGINT, oldintr); 965 code = -1; 966 return; 967 } 968 if (runique && errno == EACCES && 969 (local = gunique (local)) == NULL) { 970 signal (SIGINT, oldintr); 971 code = -1; 972 return; 973 } 974 } else if (runique && (local = gunique (local)) == NULL) { 975 signal(SIGINT, oldintr); 976 code = -1; 977 return; 978 } 979 } 980 if (!is_retr) { 981 if (curtype != TYPE_A) 982 changetype (TYPE_A, 0); 983 } else if (curtype != type) 984 changetype (type, 0); 985 if (initconn ()) { 986 signal (SIGINT, oldintr); 987 code = -1; 988 return; 989 } 990 if (setjmp (recvabort)) 991 goto abort; 992 if (is_retr && restart_point && 993 command ("REST %ld", (long) restart_point) != CONTINUE) 994 return; 995 if (remote) { 996 if (command ("%s %s", cmd, remote) != PRELIM) { 997 signal (SIGINT, oldintr); 998 return; 999 } 1000 } else { 1001 if (command ("%s", cmd) != PRELIM) { 1002 signal (SIGINT, oldintr); 1003 return; 1004 } 1005 } 1006 din = dataconn ("r"); 1007 if (din == NULL) 1008 goto abort; 1009 set_buffer_size (fileno (din), 1); 1010 if (local_given && strcmp (local, "-") == 0) 1011 fout = stdout; 1012 else if (local_given && *local == '|') { 1013 oldintp = signal (SIGPIPE, SIG_IGN); 1014 fout = popen (local + 1, "w"); 1015 if (fout == NULL) { 1016 warn ("%s", local + 1); 1017 goto abort; 1018 } 1019 closefunc = pclose; 1020 } else { 1021 fout = fopen (local, lmode); 1022 if (fout == NULL) { 1023 warn ("local: %s", local); 1024 goto abort; 1025 } 1026 closefunc = fclose; 1027 } 1028 buf = alloc_buffer (buf, &bufsize, 1029 fstat (fileno (fout), &st) >= 0 ? &st : NULL); 1030 if (buf == NULL) 1031 goto abort; 1032 1033 gettimeofday (&start, (struct timezone *) 0); 1034 switch (curtype) { 1035 1036 case TYPE_I: 1037 case TYPE_L: 1038 if (restart_point && 1039 lseek (fileno (fout), restart_point, SEEK_SET) < 0) { 1040 warn ("local: %s", local); 1041 if (closefunc != NULL) 1042 (*closefunc) (fout); 1043 return; 1044 } 1045 errno = d = 0; 1046 while ((c = sec_read (fileno (din), buf, bufsize)) > 0) { 1047 if ((d = write (fileno (fout), buf, c)) != c) 1048 break; 1049 bytes += c; 1050 if (hash) { 1051 while (bytes >= hashbytes) { 1052 putchar ('#'); 1053 hashbytes += HASHBYTES; 1054 } 1055 fflush (stdout); 1056 } 1057 } 1058 if (hash && bytes > 0) { 1059 if (bytes < HASHBYTES) 1060 putchar ('#'); 1061 putchar ('\n'); 1062 fflush (stdout); 1063 } 1064 if (c < 0) { 1065 if (errno != EPIPE) 1066 warn ("netin"); 1067 bytes = -1; 1068 } 1069 if (d < c) { 1070 if (d < 0) 1071 warn ("local: %s", local); 1072 else 1073 warnx ("%s: short write", local); 1074 } 1075 break; 1076 1077 case TYPE_A: 1078 if (restart_point) { 1079 int i, n, ch; 1080 1081 if (fseek (fout, 0L, SEEK_SET) < 0) 1082 goto done; 1083 n = restart_point; 1084 for (i = 0; i++ < n;) { 1085 if ((ch = sec_getc (fout)) == EOF) 1086 goto done; 1087 if (ch == '\n') 1088 i++; 1089 } 1090 if (fseek (fout, 0L, SEEK_CUR) < 0) { 1091 done: 1092 warn ("local: %s", local); 1093 if (closefunc != NULL) 1094 (*closefunc) (fout); 1095 return; 1096 } 1097 } 1098 while ((c = sec_getc(din)) != EOF) { 1099 if (c == '\n') 1100 bare_lfs++; 1101 while (c == '\r') { 1102 while (hash && (bytes >= hashbytes)) { 1103 putchar ('#'); 1104 fflush (stdout); 1105 hashbytes += HASHBYTES; 1106 } 1107 bytes++; 1108 if ((c = sec_getc (din)) != '\n' || tcrflag) { 1109 if (ferror (fout)) 1110 goto break2; 1111 putc ('\r', fout); 1112 if (c == '\0') { 1113 bytes++; 1114 goto contin2; 1115 } 1116 if (c == EOF) 1117 goto contin2; 1118 } 1119 } 1120 putc (c, fout); 1121 bytes++; 1122 contin2:; 1123 } 1124 break2: 1125 if (bare_lfs) { 1126 printf ("WARNING! %d bare linefeeds received in ASCII mode\n", 1127 bare_lfs); 1128 printf ("File may not have transferred correctly.\n"); 1129 } 1130 if (hash) { 1131 if (bytes < hashbytes) 1132 putchar ('#'); 1133 putchar ('\n'); 1134 fflush (stdout); 1135 } 1136 if (ferror (din)) { 1137 if (errno != EPIPE) 1138 warn ("netin"); 1139 bytes = -1; 1140 } 1141 if (ferror (fout)) 1142 warn ("local: %s", local); 1143 break; 1144 } 1145 if (closefunc != NULL) 1146 (*closefunc) (fout); 1147 signal (SIGINT, oldintr); 1148 if (oldintp) 1149 signal (SIGPIPE, oldintp); 1150 fclose (din); 1151 gettimeofday (&stop, (struct timezone *) 0); 1152 getreply (0); 1153 if (bytes > 0 && is_retr) 1154 ptransfer ("received", bytes, &start, &stop); 1155 return; 1156 abort: 1157 1158 /* abort using RFC959 recommended IP,SYNC sequence */ 1159 1160 if (oldintp) 1161 signal (SIGPIPE, oldintr); 1162 signal (SIGINT, SIG_IGN); 1163 if (!cpend) { 1164 code = -1; 1165 signal (SIGINT, oldintr); 1166 return; 1167 } 1168 abort_remote(din); 1169 code = -1; 1170 if (data >= 0) { 1171 close (data); 1172 data = -1; 1173 } 1174 if (closefunc != NULL && fout != NULL) 1175 (*closefunc) (fout); 1176 if (din) 1177 fclose (din); 1178 gettimeofday (&stop, (struct timezone *) 0); 1179 if (bytes > 0) 1180 ptransfer ("received", bytes, &start, &stop); 1181 signal (SIGINT, oldintr); 1182 } 1183 1184 static int 1185 parse_epsv (const char *str) 1186 { 1187 char sep; 1188 char *end; 1189 int port; 1190 1191 if (*str == '\0') 1192 return -1; 1193 sep = *str++; 1194 if (sep != *str++) 1195 return -1; 1196 if (sep != *str++) 1197 return -1; 1198 port = strtol (str, &end, 0); 1199 if (str == end) 1200 return -1; 1201 if (end[0] != sep || end[1] != '\0') 1202 return -1; 1203 return htons(port); 1204 } 1205 1206 static int 1207 parse_pasv (struct sockaddr_in *sin4, const char *str) 1208 { 1209 int a0, a1, a2, a3, p0, p1; 1210 1211 /* 1212 * What we've got at this point is a string of comma separated 1213 * one-byte unsigned integer values. The first four are the an IP 1214 * address. The fifth is the MSB of the port number, the sixth is the 1215 * LSB. From that we'll prepare a sockaddr_in. 1216 */ 1217 1218 if (sscanf (str, "%d,%d,%d,%d,%d,%d", 1219 &a0, &a1, &a2, &a3, &p0, &p1) != 6) { 1220 printf ("Passive mode address scan failure. " 1221 "Shouldn't happen!\n"); 1222 return -1; 1223 } 1224 if (a0 < 0 || a0 > 255 || 1225 a1 < 0 || a1 > 255 || 1226 a2 < 0 || a2 > 255 || 1227 a3 < 0 || a3 > 255 || 1228 p0 < 0 || p0 > 255 || 1229 p1 < 0 || p1 > 255) { 1230 printf ("Can't parse passive mode string.\n"); 1231 return -1; 1232 } 1233 memset (sin4, 0, sizeof(*sin4)); 1234 sin4->sin_family = AF_INET; 1235 sin4->sin_addr.s_addr = htonl ((a0 << 24) | (a1 << 16) | 1236 (a2 << 8) | a3); 1237 sin4->sin_port = htons ((p0 << 8) | p1); 1238 return 0; 1239 } 1240 1241 static int 1242 passive_mode (void) 1243 { 1244 int port; 1245 1246 data = socket (myctladdr->sa_family, SOCK_STREAM, 0); 1247 if (data < 0) { 1248 warn ("socket"); 1249 return (1); 1250 } 1251 if (options & SO_DEBUG) 1252 socket_set_debug (data); 1253 if (command ("EPSV") != COMPLETE) { 1254 if (command ("PASV") != COMPLETE) { 1255 printf ("Passive mode refused.\n"); 1256 goto bad; 1257 } 1258 } 1259 1260 /* 1261 * Parse the reply to EPSV or PASV 1262 */ 1263 1264 port = parse_epsv (pasv); 1265 if (port > 0) { 1266 data_addr->sa_family = myctladdr->sa_family; 1267 socket_set_address_and_port (data_addr, 1268 socket_get_address (hisctladdr), 1269 port); 1270 } else { 1271 if (parse_pasv ((struct sockaddr_in *)data_addr, pasv) < 0) 1272 goto bad; 1273 } 1274 1275 if (connect (data, data_addr, socket_sockaddr_size (data_addr)) < 0) { 1276 warn ("connect"); 1277 goto bad; 1278 } 1279 #ifdef IPTOS_THROUGHPUT 1280 socket_set_tos (data, IPTOS_THROUGHPUT); 1281 #endif 1282 return (0); 1283 bad: 1284 close (data); 1285 data = -1; 1286 sendport = 1; 1287 return (1); 1288 } 1289 1290 1291 static int 1292 active_mode (void) 1293 { 1294 int tmpno = 0; 1295 socklen_t len; 1296 int result; 1297 1298 noport: 1299 data_addr->sa_family = myctladdr->sa_family; 1300 socket_set_address_and_port (data_addr, socket_get_address (myctladdr), 1301 sendport ? 0 : socket_get_port (myctladdr)); 1302 1303 if (data != -1) 1304 close (data); 1305 data = socket (data_addr->sa_family, SOCK_STREAM, 0); 1306 if (data < 0) { 1307 warn ("socket"); 1308 if (tmpno) 1309 sendport = 1; 1310 return (1); 1311 } 1312 if (!sendport) 1313 socket_set_reuseaddr (data, 1); 1314 if (bind (data, data_addr, socket_sockaddr_size (data_addr)) < 0) { 1315 warn ("bind"); 1316 goto bad; 1317 } 1318 if (options & SO_DEBUG) 1319 socket_set_debug (data); 1320 len = sizeof (data_addr_ss); 1321 if (getsockname (data, data_addr, &len) < 0) { 1322 warn ("getsockname"); 1323 goto bad; 1324 } 1325 if (listen (data, 1) < 0) 1326 warn ("listen"); 1327 if (sendport) { 1328 char addr_str[256]; 1329 int inet_af; 1330 int overbose; 1331 1332 if (inet_ntop (data_addr->sa_family, socket_get_address (data_addr), 1333 addr_str, sizeof(addr_str)) == NULL) 1334 errx (1, "inet_ntop failed"); 1335 switch (data_addr->sa_family) { 1336 case AF_INET : 1337 inet_af = 1; 1338 break; 1339 #ifdef HAVE_IPV6 1340 case AF_INET6 : 1341 inet_af = 2; 1342 break; 1343 #endif 1344 default : 1345 errx (1, "bad address family %d", data_addr->sa_family); 1346 } 1347 1348 1349 overbose = verbose; 1350 if (debug == 0) 1351 verbose = -1; 1352 1353 result = command ("EPRT |%d|%s|%d|", 1354 inet_af, addr_str, 1355 ntohs(socket_get_port (data_addr))); 1356 verbose = overbose; 1357 1358 if (result == ERROR) { 1359 struct sockaddr_in *sin4 = (struct sockaddr_in *)data_addr; 1360 1361 unsigned int a = ntohl(sin4->sin_addr.s_addr); 1362 unsigned int p = ntohs(sin4->sin_port); 1363 1364 if (data_addr->sa_family != AF_INET) { 1365 warnx ("remote server doesn't support EPRT"); 1366 goto bad; 1367 } 1368 1369 result = command("PORT %d,%d,%d,%d,%d,%d", 1370 (a >> 24) & 0xff, 1371 (a >> 16) & 0xff, 1372 (a >> 8) & 0xff, 1373 a & 0xff, 1374 (p >> 8) & 0xff, 1375 p & 0xff); 1376 if (result == ERROR && sendport == -1) { 1377 sendport = 0; 1378 tmpno = 1; 1379 goto noport; 1380 } 1381 return (result != COMPLETE); 1382 } 1383 return result != COMPLETE; 1384 } 1385 if (tmpno) 1386 sendport = 1; 1387 1388 1389 #ifdef IPTOS_THROUGHPUT 1390 socket_set_tos (data, IPTOS_THROUGHPUT); 1391 #endif 1392 return (0); 1393 bad: 1394 close (data); 1395 data = -1; 1396 if (tmpno) 1397 sendport = 1; 1398 return (1); 1399 } 1400 1401 /* 1402 * Need to start a listen on the data channel before we send the command, 1403 * otherwise the server's connect may fail. 1404 */ 1405 int 1406 initconn (void) 1407 { 1408 if (passivemode) 1409 return passive_mode (); 1410 else 1411 return active_mode (); 1412 } 1413 1414 FILE * 1415 dataconn (const char *lmode) 1416 { 1417 struct sockaddr_storage from_ss; 1418 struct sockaddr *from = (struct sockaddr *)&from_ss; 1419 socklen_t fromlen = sizeof(from_ss); 1420 int s; 1421 1422 if (passivemode) 1423 return (fdopen (data, lmode)); 1424 1425 s = accept (data, from, &fromlen); 1426 if (s < 0) { 1427 warn ("accept"); 1428 close (data), data = -1; 1429 return (NULL); 1430 } 1431 close (data); 1432 data = s; 1433 #ifdef IPTOS_THROUGHPUT 1434 socket_set_tos (s, IPTOS_THROUGHPUT); 1435 #endif 1436 return (fdopen (data, lmode)); 1437 } 1438 1439 void 1440 ptransfer (char *direction, long int bytes, 1441 struct timeval * t0, struct timeval * t1) 1442 { 1443 struct timeval td; 1444 float s; 1445 float bs; 1446 int prec; 1447 char *unit; 1448 1449 if (verbose) { 1450 td.tv_sec = t1->tv_sec - t0->tv_sec; 1451 td.tv_usec = t1->tv_usec - t0->tv_usec; 1452 if (td.tv_usec < 0) { 1453 td.tv_sec--; 1454 td.tv_usec += 1000000; 1455 } 1456 s = td.tv_sec + (td.tv_usec / 1000000.); 1457 bs = bytes / (s ? s : 1); 1458 if (bs >= 1048576) { 1459 bs /= 1048576; 1460 unit = "M"; 1461 prec = 2; 1462 } else if (bs >= 1024) { 1463 bs /= 1024; 1464 unit = "k"; 1465 prec = 1; 1466 } else { 1467 unit = ""; 1468 prec = 0; 1469 } 1470 1471 printf ("%ld bytes %s in %.3g seconds (%.*f %sbyte/s)\n", 1472 bytes, direction, s, prec, bs, unit); 1473 } 1474 } 1475 1476 void 1477 psabort (int sig) 1478 { 1479 1480 abrtflag++; 1481 } 1482 1483 void 1484 pswitch (int flag) 1485 { 1486 sighand oldintr; 1487 static struct comvars { 1488 int connect; 1489 char name[MaxHostNameLen]; 1490 struct sockaddr_storage mctl; 1491 struct sockaddr_storage hctl; 1492 FILE *in; 1493 FILE *out; 1494 int tpe; 1495 int curtpe; 1496 int cpnd; 1497 int sunqe; 1498 int runqe; 1499 int mcse; 1500 int ntflg; 1501 char nti[17]; 1502 char nto[17]; 1503 int mapflg; 1504 char mi[MaxPathLen]; 1505 char mo[MaxPathLen]; 1506 } proxstruct, tmpstruct; 1507 struct comvars *ip, *op; 1508 1509 abrtflag = 0; 1510 oldintr = signal (SIGINT, psabort); 1511 if (flag) { 1512 if (proxy) 1513 return; 1514 ip = &tmpstruct; 1515 op = &proxstruct; 1516 proxy++; 1517 } else { 1518 if (!proxy) 1519 return; 1520 ip = &proxstruct; 1521 op = &tmpstruct; 1522 proxy = 0; 1523 } 1524 ip->connect = connected; 1525 connected = op->connect; 1526 if (hostname) { 1527 strlcpy (ip->name, hostname, sizeof (ip->name)); 1528 } else 1529 ip->name[0] = 0; 1530 hostname = op->name; 1531 ip->hctl = hisctladdr_ss; 1532 hisctladdr_ss = op->hctl; 1533 ip->mctl = myctladdr_ss; 1534 myctladdr_ss = op->mctl; 1535 ip->in = cin; 1536 cin = op->in; 1537 ip->out = cout; 1538 cout = op->out; 1539 ip->tpe = type; 1540 type = op->tpe; 1541 ip->curtpe = curtype; 1542 curtype = op->curtpe; 1543 ip->cpnd = cpend; 1544 cpend = op->cpnd; 1545 ip->sunqe = sunique; 1546 sunique = op->sunqe; 1547 ip->runqe = runique; 1548 runique = op->runqe; 1549 ip->mcse = mcase; 1550 mcase = op->mcse; 1551 ip->ntflg = ntflag; 1552 ntflag = op->ntflg; 1553 strlcpy (ip->nti, ntin, sizeof (ip->nti)); 1554 strlcpy (ntin, op->nti, 17); 1555 strlcpy (ip->nto, ntout, sizeof (ip->nto)); 1556 strlcpy (ntout, op->nto, 17); 1557 ip->mapflg = mapflag; 1558 mapflag = op->mapflg; 1559 strlcpy (ip->mi, mapin, MaxPathLen); 1560 strlcpy (mapin, op->mi, MaxPathLen); 1561 strlcpy (ip->mo, mapout, MaxPathLen); 1562 strlcpy (mapout, op->mo, MaxPathLen); 1563 signal(SIGINT, oldintr); 1564 if (abrtflag) { 1565 abrtflag = 0; 1566 (*oldintr) (SIGINT); 1567 } 1568 } 1569 1570 void 1571 abortpt (int sig) 1572 { 1573 1574 printf ("\n"); 1575 fflush (stdout); 1576 ptabflg++; 1577 mflag = 0; 1578 abrtflag = 0; 1579 longjmp (ptabort, 1); 1580 } 1581 1582 void 1583 proxtrans (char *cmd, char *local, char *remote) 1584 { 1585 sighand oldintr = NULL; 1586 int secndflag = 0, prox_type, nfnd; 1587 char *cmd2; 1588 fd_set mask; 1589 1590 if (strcmp (cmd, "RETR")) 1591 cmd2 = "RETR"; 1592 else 1593 cmd2 = runique ? "STOU" : "STOR"; 1594 if ((prox_type = type) == 0) { 1595 if (unix_server && unix_proxy) 1596 prox_type = TYPE_I; 1597 else 1598 prox_type = TYPE_A; 1599 } 1600 if (curtype != prox_type) 1601 changetype (prox_type, 1); 1602 if (command ("PASV") != COMPLETE) { 1603 printf ("proxy server does not support third party transfers.\n"); 1604 return; 1605 } 1606 pswitch (0); 1607 if (!connected) { 1608 printf ("No primary connection\n"); 1609 pswitch (1); 1610 code = -1; 1611 return; 1612 } 1613 if (curtype != prox_type) 1614 changetype (prox_type, 1); 1615 if (command ("PORT %s", pasv) != COMPLETE) { 1616 pswitch (1); 1617 return; 1618 } 1619 if (setjmp (ptabort)) 1620 goto abort; 1621 oldintr = signal (SIGINT, abortpt); 1622 if (command ("%s %s", cmd, remote) != PRELIM) { 1623 signal (SIGINT, oldintr); 1624 pswitch (1); 1625 return; 1626 } 1627 sleep (2); 1628 pswitch (1); 1629 secndflag++; 1630 if (command ("%s %s", cmd2, local) != PRELIM) 1631 goto abort; 1632 ptflag++; 1633 getreply (0); 1634 pswitch (0); 1635 getreply (0); 1636 signal (SIGINT, oldintr); 1637 pswitch (1); 1638 ptflag = 0; 1639 printf ("local: %s remote: %s\n", local, remote); 1640 return; 1641 abort: 1642 signal (SIGINT, SIG_IGN); 1643 ptflag = 0; 1644 if (strcmp (cmd, "RETR") && !proxy) 1645 pswitch (1); 1646 else if (!strcmp (cmd, "RETR") && proxy) 1647 pswitch (0); 1648 if (!cpend && !secndflag) { /* only here if cmd = "STOR" (proxy=1) */ 1649 if (command ("%s %s", cmd2, local) != PRELIM) { 1650 pswitch (0); 1651 if (cpend) 1652 abort_remote ((FILE *) NULL); 1653 } 1654 pswitch (1); 1655 if (ptabflg) 1656 code = -1; 1657 if (oldintr) 1658 signal (SIGINT, oldintr); 1659 return; 1660 } 1661 if (cpend) 1662 abort_remote ((FILE *) NULL); 1663 pswitch (!proxy); 1664 if (!cpend && !secndflag) { /* only if cmd = "RETR" (proxy=1) */ 1665 if (command ("%s %s", cmd2, local) != PRELIM) { 1666 pswitch (0); 1667 if (cpend) 1668 abort_remote ((FILE *) NULL); 1669 pswitch (1); 1670 if (ptabflg) 1671 code = -1; 1672 signal (SIGINT, oldintr); 1673 return; 1674 } 1675 } 1676 if (cpend) 1677 abort_remote ((FILE *) NULL); 1678 pswitch (!proxy); 1679 if (cpend) { 1680 FD_ZERO (&mask); 1681 if (fileno(cin) >= FD_SETSIZE) 1682 errx (1, "fd too large"); 1683 FD_SET (fileno (cin), &mask); 1684 if ((nfnd = empty (&mask, 10)) <= 0) { 1685 if (nfnd < 0) { 1686 warn ("abort"); 1687 } 1688 if (ptabflg) 1689 code = -1; 1690 lostpeer (0); 1691 } 1692 getreply (0); 1693 getreply (0); 1694 } 1695 if (proxy) 1696 pswitch (0); 1697 pswitch (1); 1698 if (ptabflg) 1699 code = -1; 1700 signal (SIGINT, oldintr); 1701 } 1702 1703 void 1704 reset (int argc, char **argv) 1705 { 1706 fd_set mask; 1707 int nfnd = 1; 1708 1709 FD_ZERO (&mask); 1710 while (nfnd > 0) { 1711 if (fileno (cin) >= FD_SETSIZE) 1712 errx (1, "fd too large"); 1713 FD_SET (fileno (cin), &mask); 1714 if ((nfnd = empty (&mask, 0)) < 0) { 1715 warn ("reset"); 1716 code = -1; 1717 lostpeer(0); 1718 } else if (nfnd) { 1719 getreply(0); 1720 } 1721 } 1722 } 1723 1724 char * 1725 gunique (char *local) 1726 { 1727 static char new[MaxPathLen]; 1728 char *cp = strrchr (local, '/'); 1729 int d, count = 0; 1730 char ext = '1'; 1731 1732 if (cp) 1733 *cp = '\0'; 1734 d = access (cp ? local : ".", 2); 1735 if (cp) 1736 *cp = '/'; 1737 if (d < 0) { 1738 warn ("local: %s", local); 1739 return NULL; 1740 } 1741 strlcpy (new, local, sizeof(new)); 1742 cp = new + strlen(new); 1743 *cp++ = '.'; 1744 while (!d) { 1745 if (++count == 100) { 1746 printf ("runique: can't find unique file name.\n"); 1747 return NULL; 1748 } 1749 *cp++ = ext; 1750 *cp = '\0'; 1751 if (ext == '9') 1752 ext = '0'; 1753 else 1754 ext++; 1755 if ((d = access (new, 0)) < 0) 1756 break; 1757 if (ext != '0') 1758 cp--; 1759 else if (*(cp - 2) == '.') 1760 *(cp - 1) = '1'; 1761 else { 1762 *(cp - 2) = *(cp - 2) + 1; 1763 cp--; 1764 } 1765 } 1766 return (new); 1767 } 1768 1769 void 1770 abort_remote (FILE * din) 1771 { 1772 char buf[BUFSIZ]; 1773 int nfnd; 1774 fd_set mask; 1775 1776 /* 1777 * send IAC in urgent mode instead of DM because 4.3BSD places oob mark 1778 * after urgent byte rather than before as is protocol now 1779 */ 1780 snprintf (buf, sizeof (buf), "%c%c%c", IAC, IP, IAC); 1781 if (send (fileno (cout), buf, 3, MSG_OOB) != 3) 1782 warn ("abort"); 1783 fprintf (cout, "%c", DM); 1784 sec_fprintf(cout, "ABOR"); 1785 sec_fflush (cout); 1786 fprintf (cout, "\r\n"); 1787 fflush(cout); 1788 FD_ZERO (&mask); 1789 if (fileno (cin) >= FD_SETSIZE) 1790 errx (1, "fd too large"); 1791 FD_SET (fileno (cin), &mask); 1792 if (din) { 1793 if (fileno (din) >= FD_SETSIZE) 1794 errx (1, "fd too large"); 1795 FD_SET (fileno (din), &mask); 1796 } 1797 if ((nfnd = empty (&mask, 10)) <= 0) { 1798 if (nfnd < 0) { 1799 warn ("abort"); 1800 } 1801 if (ptabflg) 1802 code = -1; 1803 lostpeer (0); 1804 } 1805 if (din && FD_ISSET (fileno (din), &mask)) { 1806 while (read (fileno (din), buf, BUFSIZ) > 0) 1807 /* LOOP */ ; 1808 } 1809 if (getreply (0) == ERROR && code == 552) { 1810 /* 552 needed for nic style abort */ 1811 getreply (0); 1812 } 1813 getreply (0); 1814 } 1815