contrib/tnftp/util.c

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