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