contrib/tnftp/src/util.c

   1 /*      $NetBSD: util.c,v 1.23 2013/05/05 11:51:43 lukem Exp $  */
   2 /*      from    NetBSD: util.c,v 1.158 2013/02/19 23:29:15 dsl Exp      */
   3
   4 /*-
   5  * Copyright (c) 1997-2009 The NetBSD Foundation, Inc.
   6  * All rights reserved.
   7  *
   8  * This code is derived from software contributed to The NetBSD Foundation
   9  * by Luke Mewburn.
  10  *
  11  * This code is derived from software contributed to The NetBSD Foundation
  12  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  13  * NASA Ames Research Center.
  14  *
  15  * Redistribution and use in source and binary forms, with or without
  16  * modification, are permitted provided that the following conditions
  17  * are met:
  18  * 1. Redistributions of source code must retain the above copyright
  19  *    notice, this list of conditions and the following disclaimer.
  20  * 2. Redistributions in binary form must reproduce the above copyright
  21  *    notice, this list of conditions and the following disclaimer in the
  22  *    documentation and/or other materials provided with the distribution.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  27  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  28  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 /*
  38  * Copyright (c) 1985, 1989, 1993, 1994
  39  *      The Regents of the University of California.  All rights reserved.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. Neither the name of the University nor the names of its contributors
  50  *    may be used to endorse or promote products derived from this software
  51  *    without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  56  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  57  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  58  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  59  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  63  * SUCH DAMAGE.
  64  */
  65
  66 #include "tnftp.h"
  67
  68 #if 0   /* tnftp */
  69
  70 #include <sys/cdefs.h>
  71 #ifndef lint
  72 __RCSID(" NetBSD: util.c,v 1.158 2013/02/19 23:29:15 dsl Exp  ");
  73 #endif /* not lint */
  74
  75 /*
  76  * FTP User Program -- Misc support routines
  77  */
  78 #include <sys/param.h>
  79 #include <sys/socket.h>
  80 #include <sys/ioctl.h>
  81 #include <sys/time.h>
  82 #include <netinet/in.h>
  83 #include <arpa/ftp.h>
  84
  85 #include <ctype.h>
  86 #include <err.h>
  87 #include <errno.h>
  88 #include <fcntl.h>
  89 #include <glob.h>
  90 #include <signal.h>
  91 #include <libgen.h>
  92 #include <limits.h>
  93 #include <locale.h>
  94 #include <netdb.h>
  95 #include <stdio.h>
  96 #include <stdlib.h>
  97 #include <string.h>
  98 #include <termios.h>
  99 #include <time.h>
 100 #include <tzfile.h>
 101 #include <unistd.h>
 102
 103 #endif  /* tnftp */
 104
 105 #include "ftp_var.h"
 106
 107 /*
 108  * Connect to peer server and auto-login, if possible.
 109  */
 110 void
 111 setpeer(int argc, char *argv[])
 112 {
 113         char *host;
 114         const char *port;
 115
 116         if (argc == 0)
 117                 goto usage;
 118         if (connected) {
 119                 fprintf(ttyout, "Already connected to %s, use close first.\n",
 120                     hostname);
 121                 code = -1;
 122                 return;
 123         }
 124         if (argc < 2)
 125                 (void)another(&argc, &argv, "to");
 126         if (argc < 2 || argc > 3) {
 127  usage:
 128                 UPRINTF("usage: %s host-name [port]\n", argv[0]);
 129                 code = -1;
 130                 return;
 131         }
 132         if (gatemode)
 133                 port = gateport;
 134         else
 135                 port = ftpport;
 136         if (argc > 2)
 137                 port = argv[2];
 138
 139         if (gatemode) {
 140                 if (gateserver == NULL || *gateserver == '\0')
 141                         errx(1, "main: gateserver not defined");
 142                 host = hookup(gateserver, port);
 143         } else
 144                 host = hookup(argv[1], port);
 145
 146         if (host) {
 147                 if (gatemode && verbose) {
 148                         fprintf(ttyout,
 149                             "Connecting via pass-through server %s\n",
 150                             gateserver);
 151                 }
 152
 153                 connected = 1;
 154                 /*
 155                  * Set up defaults for FTP.
 156                  */
 157                 (void)strlcpy(typename, "ascii", sizeof(typename));
 158                 type = TYPE_A;
 159                 curtype = TYPE_A;
 160                 (void)strlcpy(formname, "non-print", sizeof(formname));
 161                 form = FORM_N;
 162                 (void)strlcpy(modename, "stream", sizeof(modename));
 163                 mode = MODE_S;
 164                 (void)strlcpy(structname, "file", sizeof(structname));
 165                 stru = STRU_F;
 166                 (void)strlcpy(bytename, "8", sizeof(bytename));
 167                 bytesize = 8;
 168                 if (autologin)
 169                         (void)ftp_login(argv[1], NULL, NULL);
 170         }
 171 }
 172
 173 static void
 174 parse_feat(const char *fline)
 175 {
 176
 177                         /*
 178                          * work-around broken ProFTPd servers that can't
 179                          * even obey RFC 2389.
 180                          */
 181         while (*fline && isspace((int)*fline))
 182                 fline++;
 183
 184         if (strcasecmp(fline, "MDTM") == 0)
 185                 features[FEAT_MDTM] = 1;
 186         else if (strncasecmp(fline, "MLST", sizeof("MLST") - 1) == 0) {
 187                 features[FEAT_MLST] = 1;
 188         } else if (strcasecmp(fline, "REST STREAM") == 0)
 189                 features[FEAT_REST_STREAM] = 1;
 190         else if (strcasecmp(fline, "SIZE") == 0)
 191                 features[FEAT_SIZE] = 1;
 192         else if (strcasecmp(fline, "TVFS") == 0)
 193                 features[FEAT_TVFS] = 1;
 194 }
 195
 196 /*
 197  * Determine the remote system type (SYST) and features (FEAT).
 198  * Call after a successful login (i.e, connected = -1)
 199  */
 200 void
 201 getremoteinfo(void)
 202 {
 203         int overbose, i;
 204
 205         overbose = verbose;
 206         if (ftp_debug == 0)
 207                 verbose = -1;
 208
 209                         /* determine remote system type */
 210         if (command("SYST") == COMPLETE) {
 211                 if (overbose) {
 212                         int os_len = strcspn(reply_string + 4, " \r\n\t");
 213                         if (os_len > 1 && reply_string[4 + os_len - 1] == '.')
 214                                 os_len--;
 215                         fprintf(ttyout, "Remote system type is %.*s.\n",
 216                             os_len, reply_string + 4);
 217                 }
 218                 /*
 219                  * Decide whether we should default to bninary.
 220                  * Traditionally checked for "215 UNIX Type: L8", but
 221                  * some printers report "Linux" ! so be more forgiving.
 222                  * In reality we probably almost never want text any more.
 223                  */
 224                 if (!strncasecmp(reply_string + 4, "unix", 4) ||
 225                     !strncasecmp(reply_string + 4, "linux", 5)) {
 226                         if (proxy)
 227                                 unix_proxy = 1;
 228                         else
 229                                 unix_server = 1;
 230                         /*
 231                          * Set type to 0 (not specified by user),
 232                          * meaning binary by default, but don't bother
 233                          * telling server.  We can use binary
 234                          * for text files unless changed by the user.
 235                          */
 236                         type = 0;
 237                         (void)strlcpy(typename, "binary", sizeof(typename));
 238                         if (overbose)
 239                             fprintf(ttyout,
 240                                 "Using %s mode to transfer files.\n",
 241                                 typename);
 242                 } else {
 243                         if (proxy)
 244                                 unix_proxy = 0;
 245                         else
 246                                 unix_server = 0;
 247                         if (overbose &&
 248                             !strncmp(reply_string, "215 TOPS20", 10))
 249                                 fputs(
 250 "Remember to set tenex mode when transferring binary files from this machine.\n",
 251                                     ttyout);
 252                 }
 253         }
 254
 255                         /* determine features (if any) */
 256         for (i = 0; i < FEAT_max; i++)
 257                 features[i] = -1;
 258         reply_callback = parse_feat;
 259         if (command("FEAT") == COMPLETE) {
 260                 for (i = 0; i < FEAT_max; i++) {
 261                         if (features[i] == -1)
 262                                 features[i] = 0;
 263                 }
 264                 features[FEAT_FEAT] = 1;
 265         } else
 266                 features[FEAT_FEAT] = 0;
 267 #ifndef NO_DEBUG
 268         if (ftp_debug) {
 269 #define DEBUG_FEAT(x) fprintf(ttyout, "features[" #x "] = %d\n", features[(x)])
 270                 DEBUG_FEAT(FEAT_FEAT);
 271                 DEBUG_FEAT(FEAT_MDTM);
 272                 DEBUG_FEAT(FEAT_MLST);
 273                 DEBUG_FEAT(FEAT_REST_STREAM);
 274                 DEBUG_FEAT(FEAT_SIZE);
 275                 DEBUG_FEAT(FEAT_TVFS);
 276 #undef DEBUG_FEAT
 277         }
 278 #endif
 279         reply_callback = NULL;
 280
 281         verbose = overbose;
 282 }
 283
 284 /*
 285  * Reset the various variables that indicate connection state back to
 286  * disconnected settings.
 287  * The caller is responsible for issuing any commands to the remote server
 288  * to perform a clean shutdown before this is invoked.
 289  */
 290 void
 291 cleanuppeer(void)
 292 {
 293
 294         if (cout)
 295                 (void)fclose(cout);
 296         cout = NULL;
 297         connected = 0;
 298         unix_server = 0;
 299         unix_proxy = 0;
 300                         /*
 301                          * determine if anonftp was specifically set with -a
 302                          * (1), or implicitly set by auto_fetch() (2). in the
 303                          * latter case, disable after the current xfer
 304                          */
 305         if (anonftp == 2)
 306                 anonftp = 0;
 307         data = -1;
 308         epsv4bad = 0;
 309         epsv6bad = 0;
 310         if (username)
 311                 free(username);
 312         username = NULL;
 313         if (!proxy)
 314                 macnum = 0;
 315 }
 316
 317 /*
 318  * Top-level signal handler for interrupted commands.
 319  */
 320 void
 321 intr(int signo)
 322 {
 323
 324         sigint_raised = 1;
 325         alarmtimer(0);
 326         if (fromatty)
 327                 write(fileno(ttyout), "\n", 1);
 328         siglongjmp(toplevel, 1);
 329 }
 330
 331 /*
 332  * Signal handler for lost connections; cleanup various elements of
 333  * the connection state, and call cleanuppeer() to finish it off.
 334  */
 335 void
 336 lostpeer(int dummy)
 337 {
 338         int oerrno = errno;
 339
 340         alarmtimer(0);
 341         if (connected) {
 342                 if (cout != NULL) {
 343                         (void)shutdown(fileno(cout), 1+1);
 344                         (void)fclose(cout);
 345                         cout = NULL;
 346                 }
 347                 if (data >= 0) {
 348                         (void)shutdown(data, 1+1);
 349                         (void)close(data);
 350                         data = -1;
 351                 }
 352                 connected = 0;
 353         }
 354         pswitch(1);
 355         if (connected) {
 356                 if (cout != NULL) {
 357                         (void)shutdown(fileno(cout), 1+1);
 358                         (void)fclose(cout);
 359                         cout = NULL;
 360                 }
 361                 connected = 0;
 362         }
 363         proxflag = 0;
 364         pswitch(0);
 365         cleanuppeer();
 366         errno = oerrno;
 367 }
 368
 369
 370 /*
 371  * Login to remote host, using given username & password if supplied.
 372  * Return non-zero if successful.
 373  */
 374 int
 375 ftp_login(const char *host, const char *luser, const char *lpass)
 376 {
 377         char tmp[80];
 378         char *fuser, *pass, *facct, *p;
 379         char emptypass[] = "";
 380         const char *errormsg;
 381         int n, aflag, rval, nlen;
 382
 383         aflag = rval = 0;
 384         fuser = pass = facct = NULL;
 385         if (luser)
 386                 fuser = ftp_strdup(luser);
 387         if (lpass)
 388                 pass = ftp_strdup(lpass);
 389
 390         DPRINTF("ftp_login: user `%s' pass `%s' host `%s'\n",
 391             STRorNULL(fuser), STRorNULL(pass), STRorNULL(host));
 392
 393         /*
 394          * Set up arguments for an anonymous FTP session, if necessary.
 395          */
 396         if (anonftp) {
 397                 FREEPTR(fuser);
 398                 fuser = ftp_strdup("anonymous");        /* as per RFC 1635 */
 399                 FREEPTR(pass);
 400                 pass = ftp_strdup(getoptionvalue("anonpass"));
 401         }
 402
 403         if (ruserpass(host, &fuser, &pass, &facct) < 0) {
 404                 code = -1;
 405                 goto cleanup_ftp_login;
 406         }
 407
 408         while (fuser == NULL) {
 409                 if (localname)
 410                         fprintf(ttyout, "Name (%s:%s): ", host, localname);
 411                 else
 412                         fprintf(ttyout, "Name (%s): ", host);
 413                 errormsg = NULL;
 414                 nlen = get_line(stdin, tmp, sizeof(tmp), &errormsg);
 415                 if (nlen < 0) {
 416                         fprintf(ttyout, "%s; %s aborted.\n", errormsg, "login");
 417                         code = -1;
 418                         goto cleanup_ftp_login;
 419                 } else if (nlen == 0) {
 420                         fuser = ftp_strdup(localname);
 421                 } else {
 422                         fuser = ftp_strdup(tmp);
 423                 }
 424         }
 425
 426         if (gatemode) {
 427                 char *nuser;
 428                 size_t len;
 429
 430                 len = strlen(fuser) + 1 + strlen(host) + 1;
 431                 nuser = ftp_malloc(len);
 432                 (void)strlcpy(nuser, fuser, len);
 433                 (void)strlcat(nuser, "@",  len);
 434                 (void)strlcat(nuser, host, len);
 435                 FREEPTR(fuser);
 436                 fuser = nuser;
 437         }
 438
 439         n = command("USER %s", fuser);
 440         if (n == CONTINUE) {
 441                 if (pass == NULL) {
 442                         p = getpass("Password: ");
 443                         if (p == NULL)
 444                                 p = emptypass;
 445                         pass = ftp_strdup(p);
 446                         memset(p, 0, strlen(p));
 447                 }
 448                 n = command("PASS %s", pass);
 449                 memset(pass, 0, strlen(pass));
 450         }
 451         if (n == CONTINUE) {
 452                 aflag++;
 453                 if (facct == NULL) {
 454                         p = getpass("Account: ");
 455                         if (p == NULL)
 456                                 p = emptypass;
 457                         facct = ftp_strdup(p);
 458                         memset(p, 0, strlen(p));
 459                 }
 460                 if (facct[0] == '\0') {
 461                         warnx("Login failed");
 462                         goto cleanup_ftp_login;
 463                 }
 464                 n = command("ACCT %s", facct);
 465                 memset(facct, 0, strlen(facct));
 466         }
 467         if ((n != COMPLETE) ||
 468             (!aflag && facct != NULL && command("ACCT %s", facct) != COMPLETE)) {
 469                 warnx("Login failed");
 470                 goto cleanup_ftp_login;
 471         }
 472         rval = 1;
 473         username = ftp_strdup(fuser);
 474         if (proxy)
 475                 goto cleanup_ftp_login;
 476
 477         connected = -1;
 478         getremoteinfo();
 479         for (n = 0; n < macnum; ++n) {
 480                 if (!strcmp("init", macros[n].mac_name)) {
 481                         (void)strlcpy(line, "$init", sizeof(line));
 482                         makeargv();
 483                         domacro(margc, margv);
 484                         break;
 485                 }
 486         }
 487         updatelocalcwd();
 488         updateremotecwd();
 489
 490  cleanup_ftp_login:
 491         FREEPTR(fuser);
 492         if (pass != NULL)
 493                 memset(pass, 0, strlen(pass));
 494         FREEPTR(pass);
 495         if (facct != NULL)
 496                 memset(facct, 0, strlen(facct));
 497         FREEPTR(facct);
 498         return (rval);
 499 }
 500
 501 /*
 502  * `another' gets another argument, and stores the new argc and argv.
 503  * It reverts to the top level (via intr()) on EOF/error.
 504  *
 505  * Returns false if no new arguments have been added.
 506  */
 507 int
 508 another(int *pargc, char ***pargv, const char *aprompt)
 509 {
 510         const char      *errormsg;
 511         int             ret, nlen;
 512         size_t          len;
 513
 514         len = strlen(line);
 515         if (len >= sizeof(line) - 3) {
 516                 fputs("Sorry, arguments too long.\n", ttyout);
 517                 intr(0);
 518         }
 519         fprintf(ttyout, "(%s) ", aprompt);
 520         line[len++] = ' ';
 521         errormsg = NULL;
 522         nlen = get_line(stdin, line + len, sizeof(line)-len, &errormsg);
 523         if (nlen < 0) {
 524                 fprintf(ttyout, "%s; %s aborted.\n", errormsg, "operation");
 525                 intr(0);
 526         }
 527         len += nlen;
 528         makeargv();
 529         ret = margc > *pargc;
 530         *pargc = margc;
 531         *pargv = margv;
 532         return (ret);
 533 }
 534
 535 /*
 536  * glob files given in argv[] from the remote server.
 537  * if errbuf isn't NULL, store error messages there instead
 538  * of writing to the screen.
 539  */
 540 char *
 541 remglob(char *argv[], int doswitch, const char **errbuf)
 542 {
 543         static char buf[MAXPATHLEN];
 544         static FILE *ftemp = NULL;
 545         static char **args;
 546         char temp[MAXPATHLEN];
 547         int oldverbose, oldhash, oldprogress, fd;
 548         char *cp;
 549         const char *rmode;
 550         size_t len;
 551
 552         if (!mflag || !connected) {
 553                 if (!doglob)
 554                         args = NULL;
 555                 else {
 556                         if (ftemp) {
 557                                 (void)fclose(ftemp);
 558                                 ftemp = NULL;
 559                         }
 560                 }
 561                 return (NULL);
 562         }
 563         if (!doglob) {
 564                 if (args == NULL)
 565                         args = argv;
 566                 if ((cp = *++args) == NULL)
 567                         args = NULL;
 568                 return (cp);
 569         }
 570         if (ftemp == NULL) {
 571                 len = strlcpy(temp, tmpdir, sizeof(temp));
 572                 if (temp[len - 1] != '/')
 573                         (void)strlcat(temp, "/", sizeof(temp));
 574                 (void)strlcat(temp, TMPFILE, sizeof(temp));
 575                 if ((fd = mkstemp(temp)) < 0) {
 576                         warn("Unable to create temporary file `%s'", temp);
 577                         return (NULL);
 578                 }
 579                 close(fd);
 580                 oldverbose = verbose;
 581                 verbose = (errbuf != NULL) ? -1 : 0;
 582                 oldhash = hash;
 583                 oldprogress = progress;
 584                 hash = 0;
 585                 progress = 0;
 586                 if (doswitch)
 587                         pswitch(!proxy);
 588                 for (rmode = "w"; *++argv != NULL; rmode = "a")
 589                         recvrequest("NLST", temp, *argv, rmode, 0, 0);
 590                 if ((code / 100) != COMPLETE) {
 591                         if (errbuf != NULL)
 592                                 *errbuf = reply_string;
 593                 }
 594                 if (doswitch)
 595                         pswitch(!proxy);
 596                 verbose = oldverbose;
 597                 hash = oldhash;
 598                 progress = oldprogress;
 599                 ftemp = fopen(temp, "r");
 600                 (void)unlink(temp);
 601                 if (ftemp == NULL) {
 602                         if (errbuf == NULL)
 603                                 warnx("Can't find list of remote files");
 604                         else
 605                                 *errbuf =
 606                                     "Can't find list of remote files";
 607                         return (NULL);
 608                 }
 609         }
 610         if (fgets(buf, sizeof(buf), ftemp) == NULL) {
 611                 (void)fclose(ftemp);
 612                 ftemp = NULL;
 613                 return (NULL);
 614         }
 615         if ((cp = strchr(buf, '\n')) != NULL)
 616                 *cp = '\0';
 617         return (buf);
 618 }
 619
 620 /*
 621  * Glob a local file name specification with the expectation of a single
 622  * return value. Can't control multiple values being expanded from the
 623  * expression, we return only the first.
 624  * Returns NULL on error, or a pointer to a buffer containing the filename
 625  * that's the caller's responsiblity to free(3) when finished with.
 626  */
 627 char *
 628 globulize(const char *pattern)
 629 {
 630         glob_t gl;
 631         int flags;
 632         char *p;
 633
 634         if (!doglob)
 635                 return (ftp_strdup(pattern));
 636
 637         flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_TILDE;
 638         memset(&gl, 0, sizeof(gl));
 639         if (glob(pattern, flags, NULL, &gl) || gl.gl_pathc == 0) {
 640                 warnx("Glob pattern `%s' not found", pattern);
 641                 globfree(&gl);
 642                 return (NULL);
 643         }
 644         p = ftp_strdup(gl.gl_pathv[0]);
 645         globfree(&gl);
 646         return (p);
 647 }
 648
 649 /*
 650  * determine size of remote file
 651  */
 652 off_t
 653 remotesize(const char *file, int noisy)
 654 {
 655         int overbose, r;
 656         off_t size;
 657
 658         overbose = verbose;
 659         size = -1;
 660         if (ftp_debug == 0)
 661                 verbose = -1;
 662         if (! features[FEAT_SIZE]) {
 663                 if (noisy)
 664                         fprintf(ttyout,
 665                             "SIZE is not supported by remote server.\n");
 666                 goto cleanup_remotesize;
 667         }
 668         r = command("SIZE %s", file);
 669         if (r == COMPLETE) {
 670                 char *cp, *ep;
 671
 672                 cp = strchr(reply_string, ' ');
 673                 if (cp != NULL) {
 674                         cp++;
 675                         size = STRTOLL(cp, &ep, 10);
 676                         if (*ep != '\0' && !isspace((unsigned char)*ep))
 677                                 size = -1;
 678                 }
 679         } else {
 680                 if (r == ERROR && code == 500 && features[FEAT_SIZE] == -1)
 681                         features[FEAT_SIZE] = 0;
 682                 if (noisy && ftp_debug == 0) {
 683                         fputs(reply_string, ttyout);
 684                         putc('\n', ttyout);
 685                 }
 686         }
 687  cleanup_remotesize:
 688         verbose = overbose;
 689         return (size);
 690 }
 691
 692 /*
 693  * determine last modification time (in GMT) of remote file
 694  */
 695 time_t
 696 remotemodtime(const char *file, int noisy)
 697 {
 698         int     overbose, ocode, r;
 699         time_t  rtime;
 700
 701         overbose = verbose;
 702         ocode = code;
 703         rtime = -1;
 704         if (ftp_debug == 0)
 705                 verbose = -1;
 706         if (! features[FEAT_MDTM]) {
 707                 if (noisy)
 708                         fprintf(ttyout,
 709                             "MDTM is not supported by remote server.\n");
 710                 goto cleanup_parse_time;
 711         }
 712         r = command("MDTM %s", file);
 713         if (r == COMPLETE) {
 714                 struct tm timebuf;
 715                 char *timestr, *frac;
 716
 717                 /*
 718                  * time-val = 14DIGIT [ "." 1*DIGIT ]
 719                  *              YYYYMMDDHHMMSS[.sss]
 720                  * mdtm-response = "213" SP time-val CRLF / error-response
 721                  */
 722                 timestr = reply_string + 4;
 723
 724                                         /*
 725                                          * parse fraction.
 726                                          * XXX: ignored for now
 727                                          */
 728                 frac = strchr(timestr, '\r');
 729                 if (frac != NULL)
 730                         *frac = '\0';
 731                 frac = strchr(timestr, '.');
 732                 if (frac != NULL)
 733                         *frac++ = '\0';
 734                 if (strlen(timestr) == 15 && strncmp(timestr, "191", 3) == 0) {
 735                         /*
 736                          * XXX: Workaround for lame ftpd's that return
 737                          *      `19100' instead of `2000'
 738                          */
 739                         fprintf(ttyout,
 740             "Y2K warning! Incorrect time-val `%s' received from server.\n",
 741                             timestr);
 742                         timestr++;
 743                         timestr[0] = '2';
 744                         timestr[1] = '0';
 745                         fprintf(ttyout, "Converted to `%s'\n", timestr);
 746                 }
 747                 memset(&timebuf, 0, sizeof(timebuf));
 748                 if (strlen(timestr) != 14 ||
 749                     (strptime(timestr, "%Y%m%d%H%M%S", &timebuf) == NULL)) {
 750  bad_parse_time:
 751                         fprintf(ttyout, "Can't parse time `%s'.\n", timestr);
 752                         goto cleanup_parse_time;
 753                 }
 754                 timebuf.tm_isdst = -1;
 755                 rtime = timegm(&timebuf);
 756                 if (rtime == -1) {
 757                         if (noisy || ftp_debug != 0)
 758                                 goto bad_parse_time;
 759                         else
 760                                 goto cleanup_parse_time;
 761                 } else {
 762                         DPRINTF("remotemodtime: parsed time `%s' as " LLF
 763                             ", %s",
 764                             timestr, (LLT)rtime,
 765                             rfc2822time(localtime(&rtime)));
 766                 }
 767         } else {
 768                 if (r == ERROR && code == 500 && features[FEAT_MDTM] == -1)
 769                         features[FEAT_MDTM] = 0;
 770                 if (noisy && ftp_debug == 0) {
 771                         fputs(reply_string, ttyout);
 772                         putc('\n', ttyout);
 773                 }
 774         }
 775  cleanup_parse_time:
 776         verbose = overbose;
 777         if (rtime == -1)
 778                 code = ocode;
 779         return (rtime);
 780 }
 781
 782 /*
 783  * Format tm in an RFC 2822 compatible manner, with a trailing \n.
 784  * Returns a pointer to a static string containing the result.
 785  */
 786 const char *
 787 rfc2822time(const struct tm *tm)
 788 {
 789         static char result[50];
 790
 791         if (strftime(result, sizeof(result),
 792             "%a, %d %b %Y %H:%M:%S %z\n", tm) == 0)
 793                 errx(1, "Can't convert RFC 2822 time: buffer too small");
 794         return result;
 795 }
 796
 797 /*
 798  * Parse HTTP-date as per RFC 2616.
 799  * Return a pointer to the next character of the consumed date string,
 800  * or NULL if failed.
 801  */
 802 const char *
 803 parse_rfc2616time(struct tm *parsed, const char *httpdate)
 804 {
 805         const char *t;
 806 #if defined(HAVE_SETLOCALE)
 807         const char *curlocale;
 808
 809         /* The representation of %a depends on the current locale. */
 810         curlocale = setlocale(LC_TIME, NULL);
 811         (void)setlocale(LC_TIME, "C");
 812 #endif
 813                                                                 /* RFC 1123 */
 814         if ((t = strptime(httpdate, "%a, %d %b %Y %H:%M:%S GMT", parsed)) ||
 815                                                                 /* RFC 850 */
 816             (t = strptime(httpdate, "%a, %d-%b-%y %H:%M:%S GMT", parsed)) ||
 817                                                                 /* asctime */
 818             (t = strptime(httpdate, "%a, %b %d %H:%M:%S %Y", parsed))) {
 819                 ;                       /* do nothing */
 820         }
 821 #if defined(HAVE_SETLOCALE)
 822         (void)setlocale(LC_TIME, curlocale);
 823 #endif
 824         return t;
 825 }
 826
 827 /*
 828  * Update global `localcwd', which contains the state of the local cwd
 829  */
 830 void
 831 updatelocalcwd(void)
 832 {
 833
 834         if (getcwd(localcwd, sizeof(localcwd)) == NULL)
 835                 localcwd[0] = '\0';
 836         DPRINTF("updatelocalcwd: got `%s'\n", localcwd);
 837 }
 838
 839 /*
 840  * Update global `remotecwd', which contains the state of the remote cwd
 841  */
 842 void
 843 updateremotecwd(void)
 844 {
 845         int      overbose, ocode;
 846         size_t   i;
 847         char    *cp;
 848
 849         overbose = verbose;
 850         ocode = code;
 851         if (ftp_debug == 0)
 852                 verbose = -1;
 853         if (command("PWD") != COMPLETE)
 854                 goto badremotecwd;
 855         cp = strchr(reply_string, ' ');
 856         if (cp == NULL || cp[0] == '\0' || cp[1] != '"')
 857                 goto badremotecwd;
 858         cp += 2;
 859         for (i = 0; *cp && i < sizeof(remotecwd) - 1; i++, cp++) {
 860                 if (cp[0] == '"') {
 861                         if (cp[1] == '"')
 862                                 cp++;
 863                         else
 864                                 break;
 865                 }
 866                 remotecwd[i] = *cp;
 867         }
 868         remotecwd[i] = '\0';
 869         DPRINTF("updateremotecwd: got `%s'\n", remotecwd);
 870         goto cleanupremotecwd;
 871  badremotecwd:
 872         remotecwd[0]='\0';
 873  cleanupremotecwd:
 874         verbose = overbose;
 875         code = ocode;
 876 }
 877
 878 /*
 879  * Ensure file is in or under dir.
 880  * Returns 1 if so, 0 if not (or an error occurred).
 881  */
 882 int
 883 fileindir(const char *file, const char *dir)
 884 {
 885         char    parentdirbuf[PATH_MAX+1], *parentdir;
 886         char    realdir[PATH_MAX+1];
 887         size_t  dirlen;
 888
 889                                         /* determine parent directory of file */
 890         (void)strlcpy(parentdirbuf, file, sizeof(parentdirbuf));
 891         parentdir = dirname(parentdirbuf);
 892         if (strcmp(parentdir, ".") == 0)
 893                 return 1;               /* current directory is ok */
 894
 895                                         /* find the directory */
 896         if (realpath(parentdir, realdir) == NULL) {
 897                 warn("Unable to determine real path of `%s'", parentdir);
 898                 return 0;
 899         }
 900         if (realdir[0] != '/')          /* relative result is ok */
 901                 return 1;
 902         dirlen = strlen(dir);
 903         if (strncmp(realdir, dir, dirlen) == 0 &&
 904             (realdir[dirlen] == '/' || realdir[dirlen] == '\0'))
 905                 return 1;
 906         return 0;
 907 }
 908
 909 /*
 910  * List words in stringlist, vertically arranged
 911  */
 912 void
 913 list_vertical(StringList *sl)
 914 {
 915         size_t i, j;
 916         size_t columns, lines;
 917         char *p;
 918         size_t w, width;
 919
 920         width = 0;
 921
 922         for (i = 0 ; i < sl->sl_cur ; i++) {
 923                 w = strlen(sl->sl_str[i]);
 924                 if (w > width)
 925                         width = w;
 926         }
 927         width = (width + 8) &~ 7;
 928
 929         columns = ttywidth / width;
 930         if (columns == 0)
 931                 columns = 1;
 932         lines = (sl->sl_cur + columns - 1) / columns;
 933         for (i = 0; i < lines; i++) {
 934                 for (j = 0; j < columns; j++) {
 935                         p = sl->sl_str[j * lines + i];
 936                         if (p)
 937                                 fputs(p, ttyout);
 938                         if (j * lines + i + lines >= sl->sl_cur) {
 939                                 putc('\n', ttyout);
 940                                 break;
 941                         }
 942                         if (p) {
 943                                 w = strlen(p);
 944                                 while (w < width) {
 945                                         w = (w + 8) &~ 7;
 946                                         (void)putc('\t', ttyout);
 947                                 }
 948                         }
 949                 }
 950         }
 951 }
 952
 953 /*
 954  * Update the global ttywidth value, using TIOCGWINSZ.
 955  */
 956 void
 957 setttywidth(int a)
 958 {
 959         struct winsize winsize;
 960         int oerrno = errno;
 961
 962         if (ioctl(fileno(ttyout), TIOCGWINSZ, &winsize) != -1 &&
 963             winsize.ws_col != 0)
 964                 ttywidth = winsize.ws_col;
 965         else
 966                 ttywidth = 80;
 967         errno = oerrno;
 968 }
 969
 970 /*
 971  * Change the rate limit up (SIGUSR1) or down (SIGUSR2)
 972  */
 973 void
 974 crankrate(int sig)
 975 {
 976
 977         switch (sig) {
 978         case SIGUSR1:
 979                 if (rate_get)
 980                         rate_get += rate_get_incr;
 981                 if (rate_put)
 982                         rate_put += rate_put_incr;
 983                 break;
 984         case SIGUSR2:
 985                 if (rate_get && rate_get > rate_get_incr)
 986                         rate_get -= rate_get_incr;
 987                 if (rate_put && rate_put > rate_put_incr)
 988                         rate_put -= rate_put_incr;
 989                 break;
 990         default:
 991                 err(1, "crankrate invoked with unknown signal: %d", sig);
 992         }
 993 }
 994
 995
 996 /*
 997  * Setup or cleanup EditLine structures
 998  */
 999 #ifndef NO_EDITCOMPLETE
1000 void
1001 controlediting(void)
1002 {
1003         if (editing && el == NULL && hist == NULL) {
1004                 HistEvent ev;
1005                 int editmode;
1006
1007                 el = el_init(getprogname(), stdin, ttyout, stderr);
1008                 /* init editline */
1009                 hist = history_init();          /* init the builtin history */
1010                 history(hist, &ev, H_SETSIZE, 100);/* remember 100 events */
1011                 el_set(el, EL_HIST, history, hist);     /* use history */
1012
1013                 el_set(el, EL_EDITOR, "emacs"); /* default editor is emacs */
1014                 el_set(el, EL_PROMPT, prompt);  /* set the prompt functions */
1015                 el_set(el, EL_RPROMPT, rprompt);
1016
1017                 /* add local file completion, bind to TAB */
1018                 el_set(el, EL_ADDFN, "ftp-complete",
1019                     "Context sensitive argument completion",
1020                     complete);
1021                 el_set(el, EL_BIND, "^I", "ftp-complete", NULL);
1022                 el_source(el, NULL);    /* read ~/.editrc */
1023                 if ((el_get(el, EL_EDITMODE, &editmode) != -1) && editmode == 0)
1024                         editing = 0;    /* the user doesn't want editing,
1025                                          * so disable, and let statement
1026                                          * below cleanup */
1027                 else
1028                         el_set(el, EL_SIGNAL, 1);
1029         }
1030         if (!editing) {
1031                 if (hist) {
1032                         history_end(hist);
1033                         hist = NULL;
1034                 }
1035                 if (el) {
1036                         el_end(el);
1037                         el = NULL;
1038                 }
1039         }
1040 }
1041 #endif /* !NO_EDITCOMPLETE */
1042
1043 /*
1044  * Convert the string `arg' to an int, which may have an optional SI suffix
1045  * (`b', `k', `m', `g'). Returns the number for success, -1 otherwise.
1046  */
1047 int
1048 strsuftoi(const char *arg)
1049 {
1050         char *cp;
1051         long val;
1052
1053         if (!isdigit((unsigned char)arg[0]))
1054                 return (-1);
1055
1056         val = strtol(arg, &cp, 10);
1057         if (cp != NULL) {
1058                 if (cp[0] != '\0' && cp[1] != '\0')
1059                          return (-1);
1060                 switch (tolower((unsigned char)cp[0])) {
1061                 case '\0':
1062                 case 'b':
1063                         break;
1064                 case 'k':
1065                         val <<= 10;
1066                         break;
1067                 case 'm':
1068                         val <<= 20;
1069                         break;
1070                 case 'g':
1071                         val <<= 30;
1072                         break;
1073                 default:
1074                         return (-1);
1075                 }
1076         }
1077         if (val < 0 || val > INT_MAX)
1078                 return (-1);
1079
1080         return (val);
1081 }
1082
1083 /*
1084  * Set up socket buffer sizes before a connection is made.
1085  */
1086 void
1087 setupsockbufsize(int sock)
1088 {
1089         socklen_t slen;
1090
1091         if (0 == rcvbuf_size) {
1092                 slen = sizeof(rcvbuf_size);
1093                 if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF,
1094                     (void *)&rcvbuf_size, &slen) == -1)
1095                         err(1, "Unable to determine rcvbuf size");
1096                 if (rcvbuf_size <= 0)
1097                         rcvbuf_size = 8 * 1024;
1098                 if (rcvbuf_size > 8 * 1024 * 1024)
1099                         rcvbuf_size = 8 * 1024 * 1024;
1100                 DPRINTF("setupsockbufsize: rcvbuf_size determined as %d\n",
1101                     rcvbuf_size);
1102         }
1103         if (0 == sndbuf_size) {
1104                 slen = sizeof(sndbuf_size);
1105                 if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF,
1106                     (void *)&sndbuf_size, &slen) == -1)
1107                         err(1, "Unable to determine sndbuf size");
1108                 if (sndbuf_size <= 0)
1109                         sndbuf_size = 8 * 1024;
1110                 if (sndbuf_size > 8 * 1024 * 1024)
1111                         sndbuf_size = 8 * 1024 * 1024;
1112                 DPRINTF("setupsockbufsize: sndbuf_size determined as %d\n",
1113                     sndbuf_size);
1114         }
1115
1116         if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF,
1117             (void *)&sndbuf_size, sizeof(sndbuf_size)) == -1)
1118                 warn("Unable to set sndbuf size %d", sndbuf_size);
1119
1120         if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF,
1121             (void *)&rcvbuf_size, sizeof(rcvbuf_size)) == -1)
1122                 warn("Unable to set rcvbuf size %d", rcvbuf_size);
1123 }
1124
1125 /*
1126  * Copy characters from src into dst, \ quoting characters that require it
1127  */
1128 void
1129 ftpvis(char *dst, size_t dstlen, const char *src, size_t srclen)
1130 {
1131         size_t  di, si;
1132
1133         di = si = 0;
1134         while (src[si] != '\0' && di < dstlen && si < srclen) {
1135                 switch (src[si]) {
1136                 case '\\':
1137                 case ' ':
1138                 case '\t':
1139                 case '\r':
1140                 case '\n':
1141                 case '"':
1142                         /*
1143                          * Need room for two characters and NUL, avoiding
1144                          * incomplete escape sequences at end of dst.
1145                          */
1146                         if (di >= dstlen - 3)
1147                                 break;
1148                         dst[di++] = '\\';
1149                         /* FALLTHROUGH */
1150                 default:
1151                         dst[di] = src[si++];
1152                         if (di < dstlen)
1153                                 di++;
1154                 }
1155         }
1156         dst[di] = '\0';
1157 }
1158
1159 /*
1160  * Copy src into buf (which is len bytes long), expanding % sequences.
1161  */
1162 void
1163 formatbuf(char *buf, size_t len, const char *src)
1164 {
1165         const char      *p, *p2, *q;
1166         size_t           i;
1167         int              op, updirs, pdirs;
1168
1169 #define ADDBUF(x) do { \
1170                 if (i >= len - 1) \
1171                         goto endbuf; \
1172                 buf[i++] = (x); \
1173         } while (0)
1174
1175         p = src;
1176         for (i = 0; *p; p++) {
1177                 if (*p != '%') {
1178                         ADDBUF(*p);
1179                         continue;
1180                 }
1181                 p++;
1182
1183                 switch (op = *p) {
1184
1185                 case '/':
1186                 case '.':
1187                 case 'c':
1188                         p2 = connected ? remotecwd : "";
1189                         updirs = pdirs = 0;
1190
1191                         /* option to determine fixed # of dirs from path */
1192                         if (op == '.' || op == 'c') {
1193                                 int skip;
1194
1195                                 q = p2;
1196                                 while (*p2)             /* calc # of /'s */
1197                                         if (*p2++ == '/')
1198                                                 updirs++;
1199                                 if (p[1] == '0') {      /* print <x> or ... */
1200                                         pdirs = 1;
1201                                         p++;
1202                                 }
1203                                 if (p[1] >= '1' && p[1] <= '9') {
1204                                                         /* calc # to skip  */
1205                                         skip = p[1] - '0';
1206                                         p++;
1207                                 } else
1208                                         skip = 1;
1209
1210                                 updirs -= skip;
1211                                 while (skip-- > 0) {
1212                                         while ((p2 > q) && (*p2 != '/'))
1213                                                 p2--;   /* back up */
1214                                         if (skip && p2 > q)
1215                                                 p2--;
1216                                 }
1217                                 if (*p2 == '/' && p2 != q)
1218                                         p2++;
1219                         }
1220
1221                         if (updirs > 0 && pdirs) {
1222                                 if (i >= len - 5)
1223                                         break;
1224                                 if (op == '.') {
1225                                         ADDBUF('.');
1226                                         ADDBUF('.');
1227                                         ADDBUF('.');
1228                                 } else {
1229                                         ADDBUF('/');
1230                                         ADDBUF('<');
1231                                         if (updirs > 9) {
1232                                                 ADDBUF('9');
1233                                                 ADDBUF('+');
1234                                         } else
1235                                                 ADDBUF('0' + updirs);
1236                                         ADDBUF('>');
1237                                 }
1238                         }
1239                         for (; *p2; p2++)
1240                                 ADDBUF(*p2);
1241                         break;
1242
1243                 case 'M':
1244                 case 'm':
1245                         for (p2 = connected && hostname ? hostname : "-";
1246                             *p2 ; p2++) {
1247                                 if (op == 'm' && *p2 == '.')
1248                                         break;
1249                                 ADDBUF(*p2);
1250                         }
1251                         break;
1252
1253                 case 'n':
1254                         for (p2 = connected ? username : "-"; *p2 ; p2++)
1255                                 ADDBUF(*p2);
1256                         break;
1257
1258                 case '%':
1259                         ADDBUF('%');
1260                         break;
1261
1262                 default:                /* display unknown codes literally */
1263                         ADDBUF('%');
1264                         ADDBUF(op);
1265                         break;
1266
1267                 }
1268         }
1269  endbuf:
1270         buf[i] = '\0';
1271 }
1272
1273 /*
1274  * Determine if given string is an IPv6 address or not.
1275  * Return 1 for yes, 0 for no
1276  */
1277 int
1278 isipv6addr(const char *addr)
1279 {
1280         int rv = 0;
1281 #ifdef INET6
1282         struct addrinfo hints, *res;
1283
1284         memset(&hints, 0, sizeof(hints));
1285         hints.ai_family = AF_INET6;
1286         hints.ai_socktype = SOCK_DGRAM; /*dummy*/
1287         hints.ai_flags = AI_NUMERICHOST;
1288         if (getaddrinfo(addr, "0", &hints, &res) != 0)
1289                 rv = 0;
1290         else {
1291                 rv = 1;
1292                 freeaddrinfo(res);
1293         }
1294         DPRINTF("isipv6addr: got %d for %s\n", rv, addr);
1295 #endif
1296         return (rv == 1) ? 1 : 0;
1297 }
1298
1299 /*
1300  * Read a line from the FILE stream into buf/buflen using fgets(), so up
1301  * to buflen-1 chars will be read and the result will be NUL terminated.
1302  * If the line has a trailing newline it will be removed.
1303  * If the line is too long, excess characters will be read until
1304  * newline/EOF/error.
1305  * If EOF/error occurs or a too-long line is encountered and errormsg
1306  * isn't NULL, it will be changed to a description of the problem.
1307  * (The EOF message has a leading \n for cosmetic purposes).
1308  * Returns:
1309  *      >=0     length of line (excluding trailing newline) if all ok
1310  *      -1      error occurred
1311  *      -2      EOF encountered
1312  *      -3      line was too long
1313  */
1314 int
1315 get_line(FILE *stream, char *buf, size_t buflen, const char **errormsg)
1316 {
1317         int     rv, ch;
1318         size_t  len;
1319
1320         if (fgets(buf, buflen, stream) == NULL) {
1321                 if (feof(stream)) {     /* EOF */
1322                         rv = -2;
1323                         if (errormsg)
1324                                 *errormsg = "\nEOF received";
1325                 } else  {               /* error */
1326                         rv = -1;
1327                         if (errormsg)
1328                                 *errormsg = "Error encountered";
1329                 }
1330                 clearerr(stream);
1331                 return rv;
1332         }
1333         len = strlen(buf);
1334         if (buf[len-1] == '\n') {       /* clear any trailing newline */
1335                 buf[--len] = '\0';
1336         } else if (len == buflen-1) {   /* line too long */
1337                 while ((ch = getchar()) != '\n' && ch != EOF)
1338                         continue;
1339                 if (errormsg)
1340                         *errormsg = "Input line is too long";
1341                 clearerr(stream);
1342                 return -3;
1343         }
1344         if (errormsg)
1345                 *errormsg = NULL;
1346         return len;
1347 }
1348
1349 /*
1350  * Internal version of connect(2); sets socket buffer sizes,
1351  * binds to a specific local address (if set), and
1352  * supports a connection timeout using a non-blocking connect(2) with
1353  * a poll(2).
1354  * Socket fcntl flags are temporarily updated to include O_NONBLOCK;
1355  * these will not be reverted on connection failure.
1356  * Returns 0 on success, or -1 upon failure (with an appropriate
1357  * error message displayed.)
1358  */
1359 int
1360 ftp_connect(int sock, const struct sockaddr *name, socklen_t namelen, int pe)
1361 {
1362         int             flags, rv, timeout, error;
1363         socklen_t       slen;
1364         struct timeval  endtime, now, td;
1365         struct pollfd   pfd[1];
1366         char            hname[NI_MAXHOST];
1367         char            sname[NI_MAXSERV];
1368
1369         setupsockbufsize(sock);
1370         if (getnameinfo(name, namelen,
1371             hname, sizeof(hname), sname, sizeof(sname),
1372             NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
1373                 strlcpy(hname, "?", sizeof(hname));
1374                 strlcpy(sname, "?", sizeof(sname));
1375         }
1376
1377         if (bindai != NULL) {                   /* bind to specific addr */
1378                 struct addrinfo *ai;
1379
1380                 for (ai = bindai; ai != NULL; ai = ai->ai_next) {
1381                         if (ai->ai_family == name->sa_family)
1382                                 break;
1383                 }
1384                 if (ai == NULL)
1385                         ai = bindai;
1386                 if (bind(sock, ai->ai_addr, ai->ai_addrlen) == -1) {
1387                         char    bname[NI_MAXHOST];
1388                         int     saveerr;
1389
1390                         saveerr = errno;
1391                         if (getnameinfo(ai->ai_addr, ai->ai_addrlen,
1392                             bname, sizeof(bname), NULL, 0, NI_NUMERICHOST) != 0)
1393                                 strlcpy(bname, "?", sizeof(bname));
1394                         errno = saveerr;
1395                         warn("Can't bind to `%s'", bname);
1396                         return -1;
1397                 }
1398         }
1399
1400                                                 /* save current socket flags */
1401         if ((flags = fcntl(sock, F_GETFL, 0)) == -1) {
1402                 warn("Can't %s socket flags for connect to `%s:%s'",
1403                     "save", hname, sname);
1404                 return -1;
1405         }
1406                                                 /* set non-blocking connect */
1407         if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1) {
1408                 warn("Can't set socket non-blocking for connect to `%s:%s'",
1409                     hname, sname);
1410                 return -1;
1411         }
1412
1413         /* NOTE: we now must restore socket flags on successful exit */
1414
1415         pfd[0].fd = sock;
1416         pfd[0].events = POLLIN|POLLOUT;
1417
1418         if (quit_time > 0) {                    /* want a non default timeout */
1419                 (void)gettimeofday(&endtime, NULL);
1420                 endtime.tv_sec += quit_time;    /* determine end time */
1421         }
1422
1423         rv = connect(sock, name, namelen);      /* inititate the connection */
1424         if (rv == -1) {                         /* connection error */
1425                 if (errno != EINPROGRESS) {     /* error isn't "please wait" */
1426                         if (pe || (errno != EHOSTUNREACH))
1427  connecterror:
1428                                 warn("Can't connect to `%s:%s'", hname, sname);
1429                         return -1;
1430                 }
1431
1432                                                 /* connect EINPROGRESS; wait */
1433                 do {
1434                         if (quit_time > 0) {    /* determine timeout */
1435                                 (void)gettimeofday(&now, NULL);
1436                                 timersub(&endtime, &now, &td);
1437                                 timeout = td.tv_sec * 1000 + td.tv_usec/1000;
1438                                 if (timeout < 0)
1439                                         timeout = 0;
1440                         } else {
1441                                 timeout = INFTIM;
1442                         }
1443                         pfd[0].revents = 0;
1444                         rv = ftp_poll(pfd, 1, timeout);
1445                                                 /* loop until poll ! EINTR */
1446                 } while (rv == -1 && errno == EINTR);
1447
1448                 if (rv == 0) {                  /* poll (connect) timed out */
1449                         errno = ETIMEDOUT;
1450                         goto connecterror;
1451                 }
1452
1453                 if (rv == -1) {                 /* poll error */
1454                         goto connecterror;
1455                 } else if (pfd[0].revents & (POLLIN|POLLOUT)) {
1456                         slen = sizeof(error);   /* OK, or pending error */
1457                         if (getsockopt(sock, SOL_SOCKET, SO_ERROR,
1458                             &error, &slen) == -1) {
1459                                                 /* Solaris pending error */
1460                                 goto connecterror;
1461                         } else if (error != 0) {
1462                                 errno = error;  /* BSD pending error */
1463                                 goto connecterror;
1464                         }
1465                 } else {
1466                         errno = EBADF;          /* this shouldn't happen ... */
1467                         goto connecterror;
1468                 }
1469         }
1470
1471         if (fcntl(sock, F_SETFL, flags) == -1) {
1472                                                 /* restore socket flags */
1473                 warn("Can't %s socket flags for connect to `%s:%s'",
1474                     "restore", hname, sname);
1475                 return -1;
1476         }
1477         return 0;
1478 }
1479
1480 /*
1481  * Internal version of listen(2); sets socket buffer sizes first.
1482  */
1483 int
1484 ftp_listen(int sock, int backlog)
1485 {
1486
1487         setupsockbufsize(sock);
1488         return (listen(sock, backlog));
1489 }
1490
1491 /*
1492  * Internal version of poll(2), to allow reimplementation by select(2)
1493  * on platforms without the former.
1494  */
1495 int
1496 ftp_poll(struct pollfd *fds, int nfds, int timeout)
1497 {
1498 #if defined(HAVE_POLL)
1499         return poll(fds, nfds, timeout);
1500
1501 #elif defined(HAVE_SELECT)
1502                 /* implement poll(2) using select(2) */
1503         fd_set          rset, wset, xset;
1504         const int       rsetflags = POLLIN | POLLRDNORM;
1505         const int       wsetflags = POLLOUT | POLLWRNORM;
1506         const int       xsetflags = POLLRDBAND;
1507         struct timeval  tv, *ptv;
1508         int             i, max, rv;
1509
1510         FD_ZERO(&rset);                 /* build list of read & write events */
1511         FD_ZERO(&wset);
1512         FD_ZERO(&xset);
1513         max = 0;
1514         for (i = 0; i < nfds; i++) {
1515                 if (fds[i].fd > FD_SETSIZE) {
1516                         warnx("can't select fd %d", fds[i].fd);
1517                         errno = EINVAL;
1518                         return -1;
1519                 } else if (fds[i].fd > max)
1520                         max = fds[i].fd;
1521                 if (fds[i].events & rsetflags)
1522                         FD_SET(fds[i].fd, &rset);
1523                 if (fds[i].events & wsetflags)
1524                         FD_SET(fds[i].fd, &wset);
1525                 if (fds[i].events & xsetflags)
1526                         FD_SET(fds[i].fd, &xset);
1527         }
1528
1529         ptv = &tv;                      /* determine timeout */
1530         if (timeout == -1) {            /* wait forever */
1531                 ptv = NULL;
1532         } else if (timeout == 0) {      /* poll once */
1533                 ptv->tv_sec = 0;
1534                 ptv->tv_usec = 0;
1535         }
1536         else if (timeout != 0) {        /* wait timeout milliseconds */
1537                 ptv->tv_sec = timeout / 1000;
1538                 ptv->tv_usec = (timeout % 1000) * 1000;
1539         }
1540         rv = select(max + 1, &rset, &wset, &xset, ptv);
1541         if (rv <= 0)                    /* -1 == error, 0 == timeout */
1542                 return rv;
1543
1544         for (i = 0; i < nfds; i++) {    /* determine results */
1545                 if (FD_ISSET(fds[i].fd, &rset))
1546                         fds[i].revents |= (fds[i].events & rsetflags);
1547                 if (FD_ISSET(fds[i].fd, &wset))
1548                         fds[i].revents |= (fds[i].events & wsetflags);
1549                 if (FD_ISSET(fds[i].fd, &xset))
1550                         fds[i].revents |= (fds[i].events & xsetflags);
1551         }
1552         return rv;
1553
1554 #else
1555 # error no way to implement xpoll
1556 #endif
1557 }
1558
1559 /*
1560  * malloc() with inbuilt error checking
1561  */
1562 void *
1563 ftp_malloc(size_t size)
1564 {
1565         void *p;
1566
1567         p = malloc(size);
1568         if (p == NULL)
1569                 err(1, "Unable to allocate %ld bytes of memory", (long)size);
1570         return (p);
1571 }
1572
1573 /*
1574  * sl_init() with inbuilt error checking
1575  */
1576 StringList *
1577 ftp_sl_init(void)
1578 {
1579         StringList *p;
1580
1581         p = sl_init();
1582         if (p == NULL)
1583                 err(1, "Unable to allocate memory for stringlist");
1584         return (p);
1585 }
1586
1587 /*
1588  * sl_add() with inbuilt error checking
1589  */
1590 void
1591 ftp_sl_add(StringList *sl, char *i)
1592 {
1593
1594         sl_add(sl, i);
1595 }
1596
1597 /*
1598  * strdup() with inbuilt error checking
1599  */
1600 char *
1601 ftp_strdup(const char *str)
1602 {
1603         char *s;
1604
1605         if (str == NULL)
1606                 errx(1, "ftp_strdup: called with NULL argument");
1607         s = strdup(str);
1608         if (s == NULL)
1609                 err(1, "Unable to allocate memory for string copy");
1610         return (s);
1611 }