usr.bin/ftp/util.c

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