lib/libftpio/ftpio.c

   1 /*
   2  * ----------------------------------------------------------------------------
   3  * "THE BEER-WARE LICENSE" (Revision 42):
   4  * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
   5  * can do whatever you want with this stuff. If we meet some day, and you think
   6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
   7  * ----------------------------------------------------------------------------
   8  *
   9  * Major Changelog:
  10  *
  11  * Jordan K. Hubbard
  12  * 17 Jan 1996
  13  *
  14  * Turned inside out. Now returns xfers as new file ids, not as a special
  15  * `state' of FTP_t
  16  *
  17  * $FreeBSD: src/lib/libftpio/ftpio.c,v 1.33.2.4 2002/07/25 15:25:32 ume Exp $
  18  *
  19  */
  20
  21 #include <sys/types.h>
  22 #include <sys/socket.h>
  23
  24 #include <netinet/in.h>
  25
  26 #include <arpa/inet.h>
  27
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <ftpio.h>
  31 #include <netdb.h>
  32 #include <signal.h>
  33 #include <stdarg.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38
  39 #define SUCCESS          0
  40 #define FAILURE         -1
  41
  42 #ifndef TRUE
  43 #define TRUE    (1)
  44 #define FALSE   (0)
  45 #endif
  46
  47 /* How to see by a given code whether or not the connection has timed out */
  48 #define FTP_TIMEOUT(code)       (FtpTimedOut || code == FTP_TIMED_OUT)
  49
  50 /* Internal routines - deal only with internal FTP_t type */
  51 static FTP_t    ftp_new(void);
  52 static void     check_passive(FILE *fp);
  53 static int      ftp_read_method(void *n, char *buf, int nbytes);
  54 static int      ftp_write_method(void *n, const char *buf, int nbytes);
  55 static int      ftp_close_method(void *n);
  56 static int      writes(int fd, char *s);
  57 static __inline char *get_a_line(FTP_t ftp);
  58 static int      get_a_number(FTP_t ftp, char **q);
  59 static int      botch(char *func, char *botch_state);
  60 static int      cmd(FTP_t ftp, const char *fmt, ...);
  61 static int      ftp_login_session(FTP_t ftp, char *host, int af, char *user, char *passwd, int port, int verbose);
  62 static int      ftp_file_op(FTP_t ftp, char *operation, char *file, FILE **fp, char *mode, off_t *seekto);
  63 static int      ftp_close(FTP_t ftp);
  64 static int      get_url_info(char *url_in, char *host_ret, int *port_ret, char *name_ret);
  65 static void     ftp_timeout(int sig);
  66 static void     ftp_set_timeout(void);
  67 static void     ftp_clear_timeout(void);
  68 static void     ai_unmapped(struct addrinfo *);
  69
  70
  71 /* Global status variable - ick */
  72 int FtpTimedOut;
  73
  74 /* FTP happy status codes */
  75 #define FTP_GENERALLY_HAPPY     200
  76 #define FTP_ASCII_HAPPY         FTP_GENERALLY_HAPPY
  77 #define FTP_BINARY_HAPPY        FTP_GENERALLY_HAPPY
  78 #define FTP_PORT_HAPPY          FTP_GENERALLY_HAPPY
  79 #define FTP_HAPPY_COMMENT       220
  80 #define FTP_QUIT_HAPPY          221
  81 #define FTP_TRANSFER_HAPPY      226
  82 #define FTP_PASSIVE_HAPPY       227
  83 #define FTP_LPASSIVE_HAPPY      228
  84 #define FTP_EPASSIVE_HAPPY      229
  85 #define FTP_CHDIR_HAPPY         250
  86
  87 /* FTP unhappy status codes */
  88 #define FTP_TIMED_OUT           421
  89
  90 /*
  91  * XXX
  92  * gross!  evil!  bad!  We really need an access primitive for cookie in stdio itself.
  93  * it's too convenient a hook to bury and it's already exported through funopen as it is, so...
  94  * XXX
  95  */
  96 #define fcookie(fp)     ((fp)->_cookie)
  97
  98 /* Placeholder in case we want to do any pre-init stuff at some point */
  99 int
 100 networkInit()
 101 {
 102     return SUCCESS;     /* XXX dummy function for now XXX */
 103 }
 104
 105 /* Check a return code with some lenience for back-dated garbage that might be in the buffer */
 106 static int
 107 check_code(FTP_t ftp, int var, int preferred)
 108 {
 109     ftp->error = 0;
 110     while (1) {
 111         if (var == preferred)
 112             return 0;
 113         else if (var == FTP_TRANSFER_HAPPY)     /* last operation succeeded */
 114             var = get_a_number(ftp, NULL);
 115         else if (var == FTP_HAPPY_COMMENT)      /* chit-chat */
 116             var = get_a_number(ftp, NULL);
 117         else if (var == FTP_GENERALLY_HAPPY)    /* general success code */
 118             var = get_a_number(ftp, NULL);
 119         else {
 120             ftp->error = var;
 121             return 1;
 122         }
 123     }
 124 }
 125
 126 int
 127 ftpAscii(FILE *fp)
 128 {
 129     FTP_t ftp = fcookie(fp);
 130     int i;
 131
 132     if (!ftp->is_binary)
 133         return SUCCESS;
 134     i = cmd(ftp, "TYPE A");
 135     if (i < 0 || check_code(ftp, i, FTP_ASCII_HAPPY))
 136         return i;
 137     ftp->is_binary = FALSE;
 138     return SUCCESS;
 139 }
 140
 141 int
 142 ftpBinary(FILE *fp)
 143 {
 144     FTP_t ftp = fcookie(fp);
 145     int i;
 146
 147     if (ftp->is_binary)
 148         return SUCCESS;
 149     i = cmd(ftp, "TYPE I");
 150     if (i < 0 || check_code(ftp, i, FTP_BINARY_HAPPY))
 151         return i;
 152     ftp->is_binary = TRUE;
 153     return SUCCESS;
 154 }
 155 void
 156 ftpVerbose(FILE *fp, int status)
 157 {
 158     FTP_t ftp = fcookie(fp);
 159     ftp->is_verbose = status;
 160 }
 161
 162 int
 163 ftpChdir(FILE *fp, char *dir)
 164 {
 165     int i;
 166     FTP_t ftp = fcookie(fp);
 167
 168     i = cmd(ftp, "CWD %s", dir);
 169     if (i < 0 || check_code(ftp, i, FTP_CHDIR_HAPPY))
 170         return i;
 171     return SUCCESS;
 172 }
 173
 174 int
 175 ftpErrno(FILE *fp)
 176 {
 177     FTP_t ftp = fcookie(fp);
 178     return ftp->error;
 179 }
 180
 181 const char *
 182 ftpErrString(int error)
 183 {
 184     int k;
 185
 186     if (error == -1)
 187         return("connection in wrong state");
 188     if (error < 100)
 189         /* XXX soon UNIX errnos will catch up with FTP protocol errnos */
 190         return strerror(error);
 191     for (k = 0; k < ftpErrListLength; k++)
 192       if (ftpErrList[k].num == error)
 193         return(ftpErrList[k].string);
 194     return("Unknown error");
 195 }
 196
 197 off_t
 198 ftpGetSize(FILE *fp, char *name)
 199 {
 200     int i;
 201     char p[BUFSIZ], *cp, *ep;
 202     FTP_t ftp = fcookie(fp);
 203     off_t size;
 204
 205     check_passive(fp);
 206     sprintf(p, "SIZE %s\r\n", name);
 207     if (ftp->is_verbose)
 208         fprintf(stderr, "Sending %s", p);
 209     if (writes(ftp->fd_ctrl, p))
 210         return (off_t)-1;
 211     i = get_a_number(ftp, &cp);
 212     if (check_code(ftp, i, 213))
 213         return (off_t)-1;
 214
 215     errno = 0;                          /* to check for ERANGE */
 216     size = (off_t)strtoq(cp, &ep, 10);
 217     if (*ep != '\0' || errno == ERANGE)
 218         return (off_t)-1;
 219     return size;
 220 }
 221
 222 time_t
 223 ftpGetModtime(FILE *fp, char *name)
 224 {
 225     char p[BUFSIZ], *cp;
 226     struct tm t;
 227     time_t t0 = time (0);
 228     FTP_t ftp = fcookie(fp);
 229     int i;
 230
 231     check_passive(fp);
 232     sprintf(p, "MDTM %s\r\n", name);
 233     if (ftp->is_verbose)
 234         fprintf(stderr, "Sending %s", p);
 235     if (writes(ftp->fd_ctrl, p))
 236         return (time_t)0;
 237     i = get_a_number(ftp, &cp);
 238     if (check_code(ftp, i, 213))
 239         return (time_t)0;
 240     while (*cp && !isdigit(*cp))
 241         cp++;
 242     if (!*cp)
 243         return (time_t)0;
 244     t0 = localtime (&t0)->tm_gmtoff;
 245     sscanf(cp, "%04d%02d%02d%02d%02d%02d", &t.tm_year, &t.tm_mon, &t.tm_mday, &t.tm_hour, &t.tm_min, &t.tm_sec);
 246     t.tm_mon--;
 247     t.tm_year -= 1900;
 248     t.tm_isdst=-1;
 249     t.tm_gmtoff = 0;
 250     t0 += mktime (&t);
 251     return t0;
 252 }
 253
 254 FILE *
 255 ftpGet(FILE *fp, char *file, off_t *seekto)
 256 {
 257     FILE *fp2;
 258     FTP_t ftp = fcookie(fp);
 259
 260     check_passive(fp);
 261     if (ftpBinary(fp) != SUCCESS)
 262         return NULL;
 263
 264     if (ftp_file_op(ftp, "RETR", file, &fp2, "r", seekto) == SUCCESS)
 265         return fp2;
 266     return NULL;
 267 }
 268
 269 /* Returns a standard FILE pointer type representing an open control connection */
 270 FILE *
 271 ftpLogin(char *host, char *user, char *passwd, int port, int verbose, int *retcode)
 272 {
 273 #ifdef INET6
 274     return ftpLoginAf(host, AF_UNSPEC, user, passwd, port, verbose, retcode);
 275 #else
 276     return ftpLoginAf(host, AF_INET, user, passwd, port, verbose, retcode);
 277 #endif
 278 }
 279
 280 FILE *
 281 ftpLoginAf(char *host, int af, char *user, char *passwd, int port, int verbose, int *retcode)
 282 {
 283     FTP_t n;
 284     FILE *fp;
 285
 286     if (retcode)
 287         *retcode = 0;
 288     if (networkInit() != SUCCESS)
 289         return NULL;
 290
 291     n = ftp_new();
 292     fp = NULL;
 293     if (n && ftp_login_session(n, host, af, user, passwd, port, verbose) == SUCCESS) {
 294         fp = funopen(n, ftp_read_method, ftp_write_method, NULL, ftp_close_method);     /* BSD 4.4 function! */
 295         fp->_file = n->fd_ctrl;
 296     }
 297     if (retcode) {
 298         if (!n)
 299             *retcode = (FtpTimedOut ? FTP_TIMED_OUT : -1);
 300         /* Poor attempt at mapping real errnos to FTP error codes */
 301         else switch(n->error) {
 302             case EADDRNOTAVAIL:
 303                 *retcode = FTP_TIMED_OUT;       /* Actually no such host, but we have no way of saying that. :-( */
 304                 break;
 305
 306             case ETIMEDOUT:
 307                 *retcode = FTP_TIMED_OUT;
 308                 break;
 309
 310             default:
 311                 *retcode = n->error;
 312                 break;
 313         }
 314     }
 315     return fp;
 316 }
 317
 318 FILE *
 319 ftpPut(FILE *fp, char *file)
 320 {
 321     FILE *fp2;
 322     FTP_t ftp = fcookie(fp);
 323
 324     check_passive(fp);
 325     if (ftp_file_op(ftp, "STOR", file, &fp2, "w", NULL) == SUCCESS)
 326         return fp2;
 327     return NULL;
 328 }
 329
 330 int
 331 ftpPassive(FILE *fp, int st)
 332 {
 333     FTP_t ftp = fcookie(fp);
 334
 335     ftp->is_passive = !!st;     /* normalize "st" to zero or one */
 336     return SUCCESS;
 337 }
 338
 339 FILE *
 340 ftpGetURL(char *url, char *user, char *passwd, int *retcode)
 341 {
 342 #ifdef INET6
 343     return ftpGetURLAf(url, AF_UNSPEC, user, passwd, retcode);
 344 #else
 345     return ftpGetURLAf(url, AF_INET, user, passwd, retcode);
 346 #endif
 347 }
 348
 349 FILE *
 350 ftpGetURLAf(char *url, int af, char *user, char *passwd, int *retcode)
 351 {
 352     char host[255], name[255];
 353     int port;
 354     FILE *fp2;
 355     static FILE *fp = NULL;
 356     static char *prev_host;
 357
 358     if (retcode)
 359         *retcode = 0;
 360     if (get_url_info(url, host, &port, name) == SUCCESS) {
 361         if (fp && prev_host) {
 362             if (!strcmp(prev_host, host)) {
 363                 /* Try to use cached connection */
 364                 fp2 = ftpGet(fp, name, NULL);
 365                 if (!fp2) {
 366                     /* Connection timed out or was no longer valid */
 367                     fclose(fp);
 368                     free(prev_host);
 369                     prev_host = NULL;
 370                 }
 371                 else
 372                     return fp2;
 373             }
 374             else {
 375                 /* It's a different host now, flush old */
 376                 fclose(fp);
 377                 free(prev_host);
 378                 prev_host = NULL;
 379             }
 380         }
 381         fp = ftpLoginAf(host, af, user, passwd, port, 0, retcode);
 382         if (fp) {
 383             fp2 = ftpGet(fp, name, NULL);
 384             if (!fp2) {
 385                 /* Connection timed out or was no longer valid */
 386                 if (retcode)
 387                     *retcode = ftpErrno(fp);
 388                 fclose(fp);
 389                 fp = NULL;
 390             }
 391             else
 392                 prev_host = strdup(host);
 393             return fp2;
 394         }
 395     }
 396     return NULL;
 397 }
 398
 399 FILE *
 400 ftpPutURL(char *url, char *user, char *passwd, int *retcode)
 401 {
 402 #ifdef INET6
 403     return ftpPutURLAf(url, AF_UNSPEC, user, passwd, retcode);
 404 #else
 405     return ftpPutURLAf(url, AF_INET, user, passwd, retcode);
 406 #endif
 407
 408 }
 409
 410 FILE *
 411 ftpPutURLAf(char *url, int af, char *user, char *passwd, int *retcode)
 412 {
 413     char host[255], name[255];
 414     int port;
 415     static FILE *fp = NULL;
 416     FILE *fp2;
 417
 418     if (retcode)
 419         *retcode = 0;
 420     if (fp) {   /* Close previous managed connection */
 421         fclose(fp);
 422         fp = NULL;
 423     }
 424     if (get_url_info(url, host, &port, name) == SUCCESS) {
 425         fp = ftpLoginAf(host, af, user, passwd, port, 0, retcode);
 426         if (fp) {
 427             fp2 = ftpPut(fp, name);
 428             if (!fp2) {
 429                 if (retcode)
 430                     *retcode = ftpErrno(fp);
 431                 fclose(fp);
 432                 fp = NULL;
 433             }
 434             return fp2;
 435         }
 436     }
 437     return NULL;
 438 }
 439
 440 /* Internal workhorse function for dissecting URLs.  Takes a URL as the first argument and returns the
 441    result of such disection in the host, user, passwd, port and name variables. */
 442 static int
 443 get_url_info(char *url_in, char *host_ret, int *port_ret, char *name_ret)
 444 {
 445     char *name, *host, *cp, url[BUFSIZ];
 446     int port;
 447
 448     name = host = NULL;
 449     /* XXX add http:// here or somewhere reasonable at some point XXX */
 450     if (strncmp("ftp://", url_in, 6) != 0)
 451         return FAILURE;
 452     /* We like to stomp a lot on the URL string in dissecting it, so copy it first */
 453     strncpy(url, url_in, BUFSIZ);
 454     host = url + 6;
 455     if ((cp = index(host, ':')) != NULL) {
 456         *(cp++) = '\0';
 457         port = strtol(cp, 0, 0);
 458     }
 459     else
 460         port = 0;       /* use default */
 461     if (port_ret)
 462         *port_ret = port;
 463
 464     if ((name = index(cp ? cp : host, '/')) != NULL)
 465         *(name++) = '\0';
 466     if (host_ret)
 467         strcpy(host_ret, host);
 468     if (name && name_ret)
 469         strcpy(name_ret, name);
 470     return SUCCESS;
 471 }
 472
 473 static FTP_t
 474 ftp_new(void)
 475 {
 476     FTP_t ftp;
 477
 478     ftp = (FTP_t)malloc(sizeof *ftp);
 479     if (!ftp)
 480         return NULL;
 481     memset(ftp, 0, sizeof *ftp);
 482     ftp->fd_ctrl = -1;
 483     ftp->con_state = init;
 484     ftp->is_binary = FALSE;
 485     ftp->is_passive = FALSE;
 486     ftp->is_verbose = FALSE;
 487     ftp->error = 0;
 488     return ftp;
 489 }
 490
 491 static int
 492 ftp_read_method(void *vp, char *buf, int nbytes)
 493 {
 494     int i, fd;
 495     FTP_t n = (FTP_t)vp;
 496
 497     fd = n->fd_ctrl;
 498     i = (fd >= 0) ? read(fd, buf, nbytes) : EOF;
 499     return i;
 500 }
 501
 502 static int
 503 ftp_write_method(void *vp, const char *buf, int nbytes)
 504 {
 505     int i, fd;
 506     FTP_t n = (FTP_t)vp;
 507
 508     fd = n->fd_ctrl;
 509     i = (fd >= 0) ? write(fd, buf, nbytes) : EOF;
 510     return i;
 511 }
 512
 513 static int
 514 ftp_close_method(void *n)
 515 {
 516     int i;
 517
 518     i = ftp_close((FTP_t)n);
 519     free(n);
 520     return i;
 521 }
 522
 523 /*
 524  * This function checks whether the FTP_PASSIVE_MODE environment
 525  * variable is set, and, if so, enforces the desired mode.
 526  */
 527 static void
 528 check_passive(FILE *fp)
 529 {
 530     const char *cp = getenv("FTP_PASSIVE_MODE");
 531
 532     if (cp != NULL)
 533         ftpPassive(fp, strncasecmp(cp, "no", 2));
 534 }
 535
 536 static void
 537 ftp_timeout(int sig)
 538 {
 539     FtpTimedOut = TRUE;
 540     /* Debug("ftp_pkg: ftp_timeout called - operation timed out"); */
 541 }
 542
 543 static void
 544 ftp_set_timeout(void)
 545 {
 546     struct sigaction new;
 547     char *cp;
 548     int ival;
 549
 550     FtpTimedOut = FALSE;
 551     sigemptyset(&new.sa_mask);
 552     new.sa_flags = 0;
 553     new.sa_handler = ftp_timeout;
 554     sigaction(SIGALRM, &new, NULL);
 555     cp = getenv("FTP_TIMEOUT");
 556     if (!cp || !(ival = atoi(cp)))
 557         ival = 120;
 558     alarm(ival);
 559 }
 560
 561 static void
 562 ftp_clear_timeout(void)
 563 {
 564     struct sigaction new;
 565
 566     alarm(0);
 567     sigemptyset(&new.sa_mask);
 568     new.sa_flags = 0;
 569     new.sa_handler = SIG_DFL;
 570     sigaction(SIGALRM, &new, NULL);
 571 }
 572
 573 static int
 574 writes(int fd, char *s)
 575 {
 576     int n, i = strlen(s);
 577
 578     ftp_set_timeout();
 579     n = write(fd, s, i);
 580     ftp_clear_timeout();
 581     if (FtpTimedOut || i != n)
 582         return TRUE;
 583     return FALSE;
 584 }
 585
 586 static __inline char *
 587 get_a_line(FTP_t ftp)
 588 {
 589     static char buf[BUFSIZ];
 590     int i,j;
 591
 592     /* Debug("ftp_pkg: trying to read a line from %d", ftp->fd_ctrl); */
 593     for(i = 0; i < BUFSIZ;) {
 594         ftp_set_timeout();
 595         j = read(ftp->fd_ctrl, buf + i, 1);
 596         ftp_clear_timeout();
 597         if (FtpTimedOut || j != 1)
 598             return NULL;
 599         if (buf[i] == '\r' || buf[i] == '\n') {
 600             if (!i)
 601                 continue;
 602             buf[i] = '\0';
 603             if (ftp->is_verbose == TRUE)
 604                 fprintf(stderr, "%s\n",buf+4);
 605             return buf;
 606         }
 607         i++;
 608     }
 609     /* Debug("ftp_pkg: read string \"%s\" from %d", buf, ftp->fd_ctrl); */
 610     return buf;
 611 }
 612
 613 static int
 614 get_a_number(FTP_t ftp, char **q)
 615 {
 616     char *p;
 617     int i = -1, j;
 618
 619     while(1) {
 620         p = get_a_line(ftp);
 621         if (!p) {
 622             ftp_close(ftp);
 623             if (FtpTimedOut)
 624                 return FTP_TIMED_OUT;
 625             return FAILURE;
 626         }
 627         if (!(isdigit(p[0]) && isdigit(p[1]) && isdigit(p[2])))
 628             continue;
 629         if (i == -1 && p[3] == '-') {
 630             i = strtol(p, 0, 0);
 631             continue;
 632         }
 633         if (p[3] != ' ' && p[3] != '\t')
 634             continue;
 635         j = strtol(p, 0, 0);
 636         if (i == -1) {
 637             if (q) *q = p+4;
 638             /* Debug("ftp_pkg: read reply %d from server (%s)", j, p); */
 639             return j;
 640         } else if (j == i) {
 641             if (q) *q = p+4;
 642             /* Debug("ftp_pkg: read reply %d from server (%s)", j, p); */
 643             return j;
 644         }
 645     }
 646 }
 647
 648 static int
 649 ftp_close(FTP_t ftp)
 650 {
 651     int i, rcode;
 652
 653     rcode = FAILURE;
 654     if (ftp->con_state == isopen) {
 655         ftp->con_state = quit;
 656         /* If last operation timed out, don't try to quit - just close */
 657         if (ftp->error != FTP_TIMED_OUT)
 658             i = cmd(ftp, "QUIT");
 659         else
 660             i = FTP_QUIT_HAPPY;
 661         if (!check_code(ftp, i, FTP_QUIT_HAPPY))
 662             rcode = SUCCESS;
 663         close(ftp->fd_ctrl);
 664         ftp->fd_ctrl = -1;
 665     }
 666     else if (ftp->con_state == quit)
 667         rcode = SUCCESS;
 668     return rcode;
 669 }
 670
 671 static int
 672 botch(char *func, char *botch_state)
 673 {
 674     /* Debug("ftp_pkg: botch: %s(%s)", func, botch_state); */
 675     return FAILURE;
 676 }
 677
 678 static int
 679 cmd(FTP_t ftp, const char *fmt, ...)
 680 {
 681     char p[BUFSIZ];
 682     int i;
 683
 684     va_list ap;
 685     va_start(ap, fmt);
 686     (void)vsnprintf(p, sizeof p, fmt, ap);
 687     va_end(ap);
 688
 689     if (ftp->con_state == init)
 690         return botch("cmd", "open");
 691
 692     strcat(p, "\r\n");
 693     if (ftp->is_verbose)
 694         fprintf(stderr, "Sending: %s", p);
 695     if (writes(ftp->fd_ctrl, p)) {
 696         if (FtpTimedOut)
 697             return FTP_TIMED_OUT;
 698         return FAILURE;
 699     }
 700     while ((i = get_a_number(ftp, NULL)) == FTP_HAPPY_COMMENT);
 701     return i;
 702 }
 703
 704 static int
 705 ftp_login_session(FTP_t ftp, char *host, int af,
 706                   char *user, char *passwd, int port, int verbose)
 707 {
 708     char pbuf[10];
 709     struct addrinfo     hints, *res, *res0;
 710     int                 err;
 711     int                 s;
 712     int                 i;
 713
 714     if (networkInit() != SUCCESS)
 715         return FAILURE;
 716
 717     if (ftp->con_state != init) {
 718         ftp_close(ftp);
 719         ftp->error = -1;
 720         return FAILURE;
 721     }
 722
 723     if (!user)
 724         user = "ftp";
 725
 726     if (!passwd)
 727         passwd = "setup@";
 728
 729     if (!port)
 730         port = 21;
 731
 732     snprintf(pbuf, sizeof(pbuf), "%d", port);
 733     memset(&hints, 0, sizeof(hints));
 734     hints.ai_family = af;
 735     hints.ai_socktype = SOCK_STREAM;
 736     hints.ai_protocol = 0;
 737     err = getaddrinfo(host, pbuf, &hints, &res0);
 738     if (err) {
 739         ftp->error = 0;
 740         return FAILURE;
 741     }
 742
 743     s = -1;
 744     for (res = res0; res; res = res->ai_next) {
 745         ai_unmapped(res);
 746         ftp->addrtype = res->ai_family;
 747
 748         if ((s = socket(res->ai_family, res->ai_socktype,
 749                         res->ai_protocol)) < 0)
 750             continue;
 751
 752         if (connect(s, res->ai_addr, res->ai_addrlen) < 0) {
 753             (void)close(s);
 754             s = -1;
 755             continue;
 756         }
 757
 758         break;
 759     }
 760     freeaddrinfo(res0);
 761     if (s < 0) {
 762         ftp->error = errno;
 763         return FAILURE;
 764     }
 765
 766     ftp->fd_ctrl = s;
 767     ftp->con_state = isopen;
 768     ftp->is_verbose = verbose;
 769
 770     i = cmd(ftp, "USER %s", user);
 771     if (i >= 300 && i < 400)
 772         i = cmd(ftp, "PASS %s", passwd);
 773     if (i >= 299 || i < 0) {
 774         ftp_close(ftp);
 775         if (i > 0)
 776             ftp->error = i;
 777         return FAILURE;
 778     }
 779     return SUCCESS;
 780 }
 781
 782 static int
 783 ftp_file_op(FTP_t ftp, char *operation, char *file, FILE **fp, char *mode, off_t *seekto)
 784 {
 785     int i,l,s;
 786     char *q;
 787     unsigned char addr[64];
 788     union sockaddr_cmn {
 789         struct sockaddr_in sin4;
 790         struct sockaddr_in6 sin6;
 791     } sin;
 792     char *cmdstr;
 793
 794     if (!fp)
 795         return FAILURE;
 796     *fp = NULL;
 797
 798     if (ftp->con_state != isopen)
 799         return botch("ftp_file_op", "open");
 800
 801     if ((s = socket(ftp->addrtype, SOCK_STREAM, 0)) < 0) {
 802         ftp->error = errno;
 803         return FAILURE;
 804     }
 805
 806     if (ftp->is_passive) {
 807         if (ftp->addrtype == AF_INET) {
 808             if (ftp->is_verbose)
 809                 fprintf(stderr, "Sending PASV\n");
 810             if (writes(ftp->fd_ctrl, "PASV\r\n")) {
 811                 ftp_close(ftp);
 812                 if (FtpTimedOut)
 813                     ftp->error = FTP_TIMED_OUT;
 814                 return FTP_TIMED_OUT;
 815             }
 816             i = get_a_number(ftp, &q);
 817             if (check_code(ftp, i, FTP_PASSIVE_HAPPY)) {
 818                 ftp_close(ftp);
 819                 return i;
 820             }
 821             cmdstr = "PASV";
 822         } else {
 823             if (ftp->is_verbose)
 824                 fprintf(stderr, "Sending EPSV\n");
 825             if (writes(ftp->fd_ctrl, "EPSV\r\n")) {
 826                 ftp_close(ftp);
 827                 if (FtpTimedOut)
 828                     ftp->error = FTP_TIMED_OUT;
 829                 return FTP_TIMED_OUT;
 830             }
 831             i = get_a_number(ftp, &q);
 832             if (check_code(ftp, i, FTP_EPASSIVE_HAPPY)) {
 833                 if (ftp->is_verbose)
 834                     fprintf(stderr, "Sending LPSV\n");
 835                 if (writes(ftp->fd_ctrl, "LPSV\r\n")) {
 836                     ftp_close(ftp);
 837                     if (FtpTimedOut)
 838                         ftp->error = FTP_TIMED_OUT;
 839                     return FTP_TIMED_OUT;
 840                 }
 841                 i = get_a_number(ftp, &q);
 842                 if (check_code(ftp, i, FTP_LPASSIVE_HAPPY)) {
 843                     ftp_close(ftp);
 844                     return i;
 845                 }
 846                 cmdstr = "LPSV";
 847             } else
 848                 cmdstr = "EPSV";
 849         }
 850         if (strcmp(cmdstr, "PASV") == 0 || strcmp(cmdstr, "LPSV") == 0) {
 851             while (*q && !isdigit(*q))
 852                 q++;
 853             if (!*q) {
 854                 ftp_close(ftp);
 855                 return FAILURE;
 856             }
 857             q--;
 858             l = (ftp->addrtype == AF_INET ? 6 : 21);
 859             for (i = 0; i < l; i++) {
 860                 q++;
 861                 addr[i] = strtol(q, &q, 10);
 862             }
 863
 864             sin.sin4.sin_family = ftp->addrtype;
 865             if (ftp->addrtype == AF_INET6) {
 866                 sin.sin6.sin6_len = sizeof(struct sockaddr_in6);
 867                 bcopy(addr + 2, (char *)&sin.sin6.sin6_addr, 16);
 868                 bcopy(addr + 19, (char *)&sin.sin6.sin6_port, 2);
 869             } else {
 870                 sin.sin4.sin_len = sizeof(struct sockaddr_in);
 871                 bcopy(addr, (char *)&sin.sin4.sin_addr, 4);
 872                 bcopy(addr + 4, (char *)&sin.sin4.sin_port, 2);
 873             }
 874         } else if (strcmp(cmdstr, "EPSV") == 0) {
 875             int port;
 876             int sinlen;
 877             while (*q && *q != '(')             /* ) */
 878                 q++;
 879             if (!*q) {
 880                 ftp_close(ftp);
 881                 return FAILURE;
 882             }
 883             q++;
 884             if (sscanf(q, "%c%c%c%d%c", &addr[0], &addr[1], &addr[2],
 885                     &port, &addr[3]) != 5
 886              || addr[0] != addr[1] || addr[0] != addr[2] || addr[0] != addr[3]) {
 887                 ftp_close(ftp);
 888                 return FAILURE;
 889             }
 890             sinlen = sizeof(sin);
 891             if (getpeername(ftp->fd_ctrl, (struct sockaddr *)&sin, &sinlen) < 0) {
 892                 ftp_close(ftp);
 893                 return FAILURE;
 894             }
 895             switch (sin.sin4.sin_family) {
 896             case AF_INET:
 897                 sin.sin4.sin_port = htons(port);
 898                 break;
 899             case AF_INET6:
 900                 sin.sin6.sin6_port = htons(port);
 901                 break;
 902             default:
 903                 ftp_close(ftp);
 904                 return FAILURE;
 905             }
 906         }
 907
 908         if (connect(s, (struct sockaddr *)&sin, sin.sin4.sin_len) < 0) {
 909             (void)close(s);
 910             return FAILURE;
 911         }
 912
 913         if (seekto && *seekto) {
 914             i = cmd(ftp, "REST %d", *seekto);
 915             if (i < 0 || FTP_TIMEOUT(i)) {
 916                 close(s);
 917                 ftp->error = i;
 918                 *seekto = (off_t)0;
 919                 return i;
 920             }
 921         }
 922         i = cmd(ftp, "%s %s", operation, file);
 923         if (i < 0 || i > 299) {
 924             close(s);
 925             ftp->error = i;
 926             return i;
 927         }
 928         *fp = fdopen(s, mode);
 929     }
 930     else {
 931         int fd,portrange;
 932
 933 #ifdef IPV6_PORTRANGE
 934         if (ftp->addrtype == AF_INET6) {
 935                 portrange = IPV6_PORTRANGE_HIGH;
 936                 if (setsockopt(s, IPPROTO_IPV6, IPV6_PORTRANGE, (char *)
 937                                &portrange, sizeof(portrange)) < 0) {
 938                         close(s);
 939                         return FAILURE;
 940                 }
 941         }
 942 #endif
 943 #ifdef IP_PORTRANGE
 944         if (ftp->addrtype == AF_INET) {
 945                 portrange = IP_PORTRANGE_HIGH;
 946                 if (setsockopt(s, IPPROTO_IP, IP_PORTRANGE, (char *)
 947                                &portrange, sizeof(portrange)) < 0) {
 948                         close(s);
 949                         return FAILURE;
 950                 }
 951         }
 952 #endif
 953
 954         i = sizeof sin;
 955         getsockname(ftp->fd_ctrl, (struct sockaddr *)&sin, &i);
 956         sin.sin4.sin_port = 0;
 957         i = ((struct sockaddr *)&sin)->sa_len;
 958         if (bind(s, (struct sockaddr *)&sin, i) < 0) {
 959             close(s);
 960             return FAILURE;
 961         }
 962         i = sizeof sin;
 963         getsockname(s,(struct sockaddr *)&sin,&i);
 964         if (listen(s, 1) < 0) {
 965             close(s);
 966             return FAILURE;
 967         }
 968         if (sin.sin4.sin_family == AF_INET) {
 969             u_long a;
 970             a = ntohl(sin.sin4.sin_addr.s_addr);
 971             i = cmd(ftp, "PORT %d,%d,%d,%d,%d,%d",
 972                     (a                   >> 24) & 0xff,
 973                     (a                   >> 16) & 0xff,
 974                     (a                   >>  8) & 0xff,
 975                     a                           & 0xff,
 976                     (ntohs(sin.sin4.sin_port) >>  8) & 0xff,
 977                     ntohs(sin.sin4.sin_port)         & 0xff);
 978             if (check_code(ftp, i, FTP_PORT_HAPPY)) {
 979                 close(s);
 980                 return i;
 981             }
 982         } else {
 983 #define UC(b)   (((int)b)&0xff)
 984             char *a;
 985             char hname[INET6_ADDRSTRLEN];
 986
 987             sin.sin6.sin6_scope_id = 0;
 988             if (getnameinfo((struct sockaddr *)&sin, sin.sin6.sin6_len,
 989                             hname, sizeof(hname),
 990                             NULL, 0, NI_NUMERICHOST) != 0) {
 991                 goto try_lprt;
 992             }
 993             i = cmd(ftp, "EPRT |%d|%s|%d|", 2, hname,
 994                     htons(sin.sin6.sin6_port));
 995             if (check_code(ftp, i, FTP_PORT_HAPPY)) {
 996 try_lprt:
 997                 a = (char *)&sin.sin6.sin6_addr;
 998                 i = cmd(ftp,
 999 "LPRT %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
1000                         6, 16,
1001                         UC(a[0]),UC(a[1]),UC(a[2]),UC(a[3]),
1002                         UC(a[4]),UC(a[5]),UC(a[6]),UC(a[7]),
1003                         UC(a[8]),UC(a[9]),UC(a[10]),UC(a[11]),
1004                         UC(a[12]),UC(a[13]),UC(a[14]),UC(a[15]),
1005                         2,
1006                         (ntohs(sin.sin4.sin_port) >>  8) & 0xff,
1007                         ntohs(sin.sin4.sin_port)         & 0xff);
1008                 if (check_code(ftp, i, FTP_PORT_HAPPY)) {
1009                     close(s);
1010                     return i;
1011                 }
1012             }
1013         }
1014         if (seekto && *seekto) {
1015             i = cmd(ftp, "REST %d", *seekto);
1016             if (i < 0 || FTP_TIMEOUT(i)) {
1017                 close(s);
1018                 ftp->error = i;
1019                 return i;
1020             }
1021             else if (i != 350)
1022                 *seekto = (off_t)0;
1023         }
1024         i = cmd(ftp, "%s %s", operation, file);
1025         if (i < 0 || i > 299) {
1026             close(s);
1027             ftp->error = i;
1028             return FAILURE;
1029         }
1030         fd = accept(s, 0, 0);
1031         if (fd < 0) {
1032             close(s);
1033             ftp->error = 401;
1034             return FAILURE;
1035         }
1036         close(s);
1037         *fp = fdopen(fd, mode);
1038     }
1039     if (*fp)
1040         return SUCCESS;
1041     else
1042         return FAILURE;
1043 }
1044
1045 static void
1046 ai_unmapped(struct addrinfo *ai)
1047 {
1048         struct sockaddr_in6 *sin6;
1049         struct sockaddr_in sin;
1050
1051         if (ai->ai_family != AF_INET6)
1052                 return;
1053         if (ai->ai_addrlen != sizeof(struct sockaddr_in6) ||
1054             sizeof(sin) > ai->ai_addrlen)
1055                 return;
1056         sin6 = (struct sockaddr_in6 *)ai->ai_addr;
1057         if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
1058                 return;
1059
1060         memset(&sin, 0, sizeof(sin));
1061         sin.sin_family = AF_INET;
1062         sin.sin_len = sizeof(struct sockaddr_in);
1063         memcpy(&sin.sin_addr, &sin6->sin6_addr.s6_addr[12],
1064             sizeof(sin.sin_addr));
1065         sin.sin_port = sin6->sin6_port;
1066
1067         ai->ai_family = AF_INET;
1068         memcpy(ai->ai_addr, &sin, sin.sin_len);
1069         ai->ai_addrlen = sin.sin_len;
1070 }