contrib/tnftp/cmds.c

   1 /*      $NetBSD: cmds.c,v 1.131 2010/01/12 06:50:04 lukem Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1996-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 /*
  66  * Copyright (C) 1997 and 1998 WIDE Project.
  67  * All rights reserved.
  68  *
  69  * Redistribution and use in source and binary forms, with or without
  70  * modification, are permitted provided that the following conditions
  71  * are met:
  72  * 1. Redistributions of source code must retain the above copyright
  73  *    notice, this list of conditions and the following disclaimer.
  74  * 2. Redistributions in binary form must reproduce the above copyright
  75  *    notice, this list of conditions and the following disclaimer in the
  76  *    documentation and/or other materials provided with the distribution.
  77  * 3. Neither the name of the project nor the names of its contributors
  78  *    may be used to endorse or promote products derived from this software
  79  *    without specific prior written permission.
  80  *
  81  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  82  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  83  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  84  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  85  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  86  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  87  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  88  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  89  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  90  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  91  * SUCH DAMAGE.
  92  */
  93
  94 #include <sys/cdefs.h>
  95 #ifndef lint
  96 #if 0
  97 static char sccsid[] = "@(#)cmds.c      8.6 (Berkeley) 10/9/94";
  98 #else
  99 __RCSID("$NetBSD: cmds.c,v 1.131 2010/01/12 06:50:04 lukem Exp $");
 100 #endif
 101 #endif /* not lint */
 102
 103 /*
 104  * FTP User Program -- Command Routines.
 105  */
 106 #include <sys/types.h>
 107 #include <sys/socket.h>
 108 #include <sys/stat.h>
 109 #include <sys/wait.h>
 110 #include <arpa/ftp.h>
 111
 112 #include <ctype.h>
 113 #include <err.h>
 114 #include <glob.h>
 115 #include <limits.h>
 116 #include <netdb.h>
 117 #include <paths.h>
 118 #include <stddef.h>
 119 #include <stdio.h>
 120 #include <libutil.h>
 121 #include <stdlib.h>
 122 #include <string.h>
 123 #include <time.h>
 124 #include <unistd.h>
 125
 126 #include "ftp_var.h"
 127 #include "version.h"
 128
 129 static struct types {
 130         const char      *t_name;
 131         const char      *t_mode;
 132         int             t_type;
 133         const char      *t_arg;
 134 } types[] = {
 135         { "ascii",      "A",    TYPE_A, 0 },
 136         { "binary",     "I",    TYPE_I, 0 },
 137         { "image",      "I",    TYPE_I, 0 },
 138         { "ebcdic",     "E",    TYPE_E, 0 },
 139         { "tenex",      "L",    TYPE_L, bytename },
 140         { NULL,         NULL,   0, NULL }
 141 };
 142
 143 static sigjmp_buf        jabort;
 144
 145 static int      confirm(const char *, const char *);
 146 static void     mintr(int);
 147 static void     mabort(const char *);
 148 static void     set_type(const char *);
 149
 150 static const char *doprocess(char *, size_t, const char *, int, int, int);
 151 static const char *domap(char *, size_t, const char *);
 152 static const char *docase(char *, size_t, const char *);
 153 static const char *dotrans(char *, size_t, const char *);
 154
 155 /*
 156  * Confirm if "cmd" is to be performed upon "file".
 157  * If "file" is NULL, generate a "Continue with" prompt instead.
 158  */
 159 static int
 160 confirm(const char *cmd, const char *file)
 161 {
 162         const char *errormsg;
 163         char cline[BUFSIZ];
 164         const char *promptleft, *promptright;
 165
 166         if (!interactive || confirmrest)
 167                 return (1);
 168         if (file == NULL) {
 169                 promptleft = "Continue with";
 170                 promptright = cmd;
 171         } else {
 172                 promptleft = cmd;
 173                 promptright = file;
 174         }
 175         while (1) {
 176                 fprintf(ttyout, "%s %s [anpqy?]? ", promptleft, promptright);
 177                 (void)fflush(ttyout);
 178                 if (get_line(stdin, cline, sizeof(cline), &errormsg) < 0) {
 179                         mflag = 0;
 180                         fprintf(ttyout, "%s; %s aborted\n", errormsg, cmd);
 181                         return (0);
 182                 }
 183                 switch (tolower((unsigned char)*cline)) {
 184                         case 'a':
 185                                 confirmrest = 1;
 186                                 fprintf(ttyout,
 187                                     "Prompting off for duration of %s.\n", cmd);
 188                                 break;
 189                         case 'p':
 190                                 interactive = 0;
 191                                 fputs("Interactive mode: off.\n", ttyout);
 192                                 break;
 193                         case 'q':
 194                                 mflag = 0;
 195                                 fprintf(ttyout, "%s aborted.\n", cmd);
 196                                 /* FALLTHROUGH */
 197                         case 'n':
 198                                 return (0);
 199                         case '?':
 200                                 fprintf(ttyout,
 201                                     "  confirmation options:\n"
 202                                     "\ta  answer `yes' for the duration of %s\n"
 203                                     "\tn  answer `no' for this file\n"
 204                                     "\tp  turn off `prompt' mode\n"
 205                                     "\tq  stop the current %s\n"
 206                                     "\ty  answer `yes' for this file\n"
 207                                     "\t?  this help list\n",
 208                                     cmd, cmd);
 209                                 continue;       /* back to while(1) */
 210                 }
 211                 return (1);
 212         }
 213         /* NOTREACHED */
 214 }
 215
 216 /*
 217  * Set transfer type.
 218  */
 219 void
 220 settype(int argc, char *argv[])
 221 {
 222         struct types *p;
 223
 224         if (argc == 0 || argc > 2) {
 225                 const char *sep;
 226
 227                 UPRINTF("usage: %s [", argv[0]);
 228                 sep = " ";
 229                 for (p = types; p->t_name; p++) {
 230                         fprintf(ttyout, "%s%s", sep, p->t_name);
 231                         sep = " | ";
 232                 }
 233                 fputs(" ]\n", ttyout);
 234                 code = -1;
 235                 return;
 236         }
 237         if (argc < 2) {
 238                 fprintf(ttyout, "Using %s mode to transfer files.\n", typename);
 239                 code = 0;
 240                 return;
 241         }
 242         set_type(argv[1]);
 243 }
 244
 245 void
 246 set_type(const char *ttype)
 247 {
 248         struct types *p;
 249         int comret;
 250
 251         for (p = types; p->t_name; p++)
 252                 if (strcmp(ttype, p->t_name) == 0)
 253                         break;
 254         if (p->t_name == 0) {
 255                 fprintf(ttyout, "%s: unknown mode.\n", ttype);
 256                 code = -1;
 257                 return;
 258         }
 259         if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
 260                 comret = command("TYPE %s %s", p->t_mode, p->t_arg);
 261         else
 262                 comret = command("TYPE %s", p->t_mode);
 263         if (comret == COMPLETE) {
 264                 (void)strlcpy(typename, p->t_name, sizeof(typename));
 265                 curtype = type = p->t_type;
 266         }
 267 }
 268
 269 /*
 270  * Internal form of settype; changes current type in use with server
 271  * without changing our notion of the type for data transfers.
 272  * Used to change to and from ascii for listings.
 273  */
 274 void
 275 changetype(int newtype, int show)
 276 {
 277         struct types *p;
 278         int comret, oldverbose = verbose;
 279
 280         if (newtype == 0)
 281                 newtype = TYPE_I;
 282         if (newtype == curtype)
 283                 return;
 284         if (ftp_debug == 0 && show == 0)
 285                 verbose = 0;
 286         for (p = types; p->t_name; p++)
 287                 if (newtype == p->t_type)
 288                         break;
 289         if (p->t_name == 0) {
 290                 errx(1, "changetype: unknown type %d", newtype);
 291         }
 292         if (newtype == TYPE_L && bytename[0] != '\0')
 293                 comret = command("TYPE %s %s", p->t_mode, bytename);
 294         else
 295                 comret = command("TYPE %s", p->t_mode);
 296         if (comret == COMPLETE)
 297                 curtype = newtype;
 298         verbose = oldverbose;
 299 }
 300
 301 /*
 302  * Set binary transfer type.
 303  */
 304 /*VARARGS*/
 305 void
 306 setbinary(int argc, char *argv[])
 307 {
 308
 309         if (argc == 0) {
 310                 UPRINTF("usage: %s\n", argv[0]);
 311                 code = -1;
 312                 return;
 313         }
 314         set_type("binary");
 315 }
 316
 317 /*
 318  * Set ascii transfer type.
 319  */
 320 /*VARARGS*/
 321 void
 322 setascii(int argc, char *argv[])
 323 {
 324
 325         if (argc == 0) {
 326                 UPRINTF("usage: %s\n", argv[0]);
 327                 code = -1;
 328                 return;
 329         }
 330         set_type("ascii");
 331 }
 332
 333 /*
 334  * Set tenex transfer type.
 335  */
 336 /*VARARGS*/
 337 void
 338 settenex(int argc, char *argv[])
 339 {
 340
 341         if (argc == 0) {
 342                 UPRINTF("usage: %s\n", argv[0]);
 343                 code = -1;
 344                 return;
 345         }
 346         set_type("tenex");
 347 }
 348
 349 /*
 350  * Set file transfer mode.
 351  */
 352 /*ARGSUSED*/
 353 void
 354 setftmode(int argc, char *argv[])
 355 {
 356
 357         if (argc != 2) {
 358                 UPRINTF("usage: %s mode-name\n", argv[0]);
 359                 code = -1;
 360                 return;
 361         }
 362         fprintf(ttyout, "We only support %s mode, sorry.\n", modename);
 363         code = -1;
 364 }
 365
 366 /*
 367  * Set file transfer format.
 368  */
 369 /*ARGSUSED*/
 370 void
 371 setform(int argc, char *argv[])
 372 {
 373
 374         if (argc != 2) {
 375                 UPRINTF("usage: %s format\n", argv[0]);
 376                 code = -1;
 377                 return;
 378         }
 379         fprintf(ttyout, "We only support %s format, sorry.\n", formname);
 380         code = -1;
 381 }
 382
 383 /*
 384  * Set file transfer structure.
 385  */
 386 /*ARGSUSED*/
 387 void
 388 setstruct(int argc, char *argv[])
 389 {
 390
 391         if (argc != 2) {
 392                 UPRINTF("usage: %s struct-mode\n", argv[0]);
 393                 code = -1;
 394                 return;
 395         }
 396         fprintf(ttyout, "We only support %s structure, sorry.\n", structname);
 397         code = -1;
 398 }
 399
 400 /*
 401  * Send a single file.
 402  */
 403 void
 404 put(int argc, char *argv[])
 405 {
 406         char buf[MAXPATHLEN];
 407         const char *cmd;
 408         int loc = 0;
 409         char *locfile;
 410         const char *remfile;
 411
 412         if (argc == 2) {
 413                 argc++;
 414                 argv[2] = argv[1];
 415                 loc++;
 416         }
 417         if (argc == 0 || (argc == 1 && !another(&argc, &argv, "local-file")))
 418                 goto usage;
 419         if ((argc < 3 && !another(&argc, &argv, "remote-file")) || argc > 3) {
 420  usage:
 421                 UPRINTF("usage: %s local-file [remote-file]\n", argv[0]);
 422                 code = -1;
 423                 return;
 424         }
 425         if ((locfile = globulize(argv[1])) == NULL) {
 426                 code = -1;
 427                 return;
 428         }
 429         remfile = argv[2];
 430         if (loc)        /* If argv[2] is a copy of the old argv[1], update it */
 431                 remfile = locfile;
 432         cmd = (argv[0][0] == 'a') ? "APPE" : ((sunique) ? "STOU" : "STOR");
 433         remfile = doprocess(buf, sizeof(buf), remfile,
 434                 0, loc && ntflag, loc && mapflag);
 435         sendrequest(cmd, locfile, remfile,
 436             locfile != argv[1] || remfile != argv[2]);
 437         free(locfile);
 438 }
 439
 440 static const char *
 441 doprocess(char *dst, size_t dlen, const char *src,
 442     int casef, int transf, int mapf)
 443 {
 444         if (casef)
 445                 src = docase(dst, dlen, src);
 446         if (transf)
 447                 src = dotrans(dst, dlen, src);
 448         if (mapf)
 449                 src = domap(dst, dlen, src);
 450         return src;
 451 }
 452
 453 /*
 454  * Send multiple files.
 455  */
 456 void
 457 mput(int argc, char *argv[])
 458 {
 459         int i;
 460         sigfunc oldintr;
 461         int ointer;
 462         const char *tp;
 463
 464         if (argc == 0 || (argc == 1 && !another(&argc, &argv, "local-files"))) {
 465                 UPRINTF("usage: %s local-files\n", argv[0]);
 466                 code = -1;
 467                 return;
 468         }
 469         mflag = 1;
 470         oldintr = xsignal(SIGINT, mintr);
 471         if (sigsetjmp(jabort, 1))
 472                 mabort(argv[0]);
 473         if (proxy) {
 474                 char *cp;
 475
 476                 while ((cp = remglob(argv, 0, NULL)) != NULL) {
 477                         if (*cp == '\0' || !connected) {
 478                                 mflag = 0;
 479                                 continue;
 480                         }
 481                         if (mflag && confirm(argv[0], cp)) {
 482                                 char buf[MAXPATHLEN];
 483                                 tp = doprocess(buf, sizeof(buf), cp,
 484                                     mcase, ntflag, mapflag);
 485                                 sendrequest((sunique) ? "STOU" : "STOR",
 486                                     cp, tp, cp != tp || !interactive);
 487                                 if (!mflag && fromatty) {
 488                                         ointer = interactive;
 489                                         interactive = 1;
 490                                         if (confirm(argv[0], NULL)) {
 491                                                 mflag++;
 492                                         }
 493                                         interactive = ointer;
 494                                 }
 495                         }
 496                 }
 497                 goto cleanupmput;
 498         }
 499         for (i = 1; i < argc && connected; i++) {
 500                 char **cpp;
 501                 glob_t gl;
 502                 int flags;
 503
 504                 if (!doglob) {
 505                         if (mflag && confirm(argv[0], argv[i])) {
 506                                 char buf[MAXPATHLEN];
 507                                 tp = doprocess(buf, sizeof(buf), argv[i],
 508                                         0, ntflag, mapflag);
 509                                 sendrequest((sunique) ? "STOU" : "STOR",
 510                                     argv[i], tp, tp != argv[i] || !interactive);
 511                                 if (!mflag && fromatty) {
 512                                         ointer = interactive;
 513                                         interactive = 1;
 514                                         if (confirm(argv[0], NULL)) {
 515                                                 mflag++;
 516                                         }
 517                                         interactive = ointer;
 518                                 }
 519                         }
 520                         continue;
 521                 }
 522
 523                 memset(&gl, 0, sizeof(gl));
 524                 flags = GLOB_BRACE|GLOB_NOCHECK|GLOB_TILDE;
 525                 if (glob(argv[i], flags, NULL, &gl) || gl.gl_pathc == 0) {
 526                         warnx("Glob pattern `%s' not found", argv[i]);
 527                         globfree(&gl);
 528                         continue;
 529                 }
 530                 for (cpp = gl.gl_pathv; cpp && *cpp != NULL && connected;
 531                     cpp++) {
 532                         if (mflag && confirm(argv[0], *cpp)) {
 533                                 char buf[MAXPATHLEN];
 534                                 tp = *cpp;
 535                                 tp = doprocess(buf, sizeof(buf), *cpp,
 536                                     0, ntflag, mapflag);
 537                                 sendrequest((sunique) ? "STOU" : "STOR",
 538                                     *cpp, tp, *cpp != tp || !interactive);
 539                                 if (!mflag && fromatty) {
 540                                         ointer = interactive;
 541                                         interactive = 1;
 542                                         if (confirm(argv[0], NULL)) {
 543                                                 mflag++;
 544                                         }
 545                                         interactive = ointer;
 546                                 }
 547                         }
 548                 }
 549                 globfree(&gl);
 550         }
 551  cleanupmput:
 552         (void)xsignal(SIGINT, oldintr);
 553         mflag = 0;
 554 }
 555
 556 void
 557 reget(int argc, char *argv[])
 558 {
 559
 560         (void)getit(argc, argv, 1, "r+");
 561 }
 562
 563 void
 564 get(int argc, char *argv[])
 565 {
 566
 567         (void)getit(argc, argv, 0, restart_point ? "r+" : "w" );
 568 }
 569
 570 /*
 571  * Receive one file.
 572  * If restartit is  1, restart the xfer always.
 573  * If restartit is -1, restart the xfer only if the remote file is newer.
 574  */
 575 int
 576 getit(int argc, char *argv[], int restartit, const char *gmode)
 577 {
 578         int     loc, rval;
 579         char    *remfile, *olocfile;
 580         const char *locfile;
 581         char    buf[MAXPATHLEN];
 582
 583         loc = rval = 0;
 584         if (argc == 2) {
 585                 argc++;
 586                 argv[2] = argv[1];
 587                 loc++;
 588         }
 589         if (argc == 0 || (argc == 1 && !another(&argc, &argv, "remote-file")))
 590                 goto usage;
 591         if ((argc < 3 && !another(&argc, &argv, "local-file")) || argc > 3) {
 592  usage:
 593                 UPRINTF("usage: %s remote-file [local-file]\n", argv[0]);
 594                 code = -1;
 595                 return (0);
 596         }
 597         remfile = argv[1];
 598         if ((olocfile = globulize(argv[2])) == NULL) {
 599                 code = -1;
 600                 return (0);
 601         }
 602         locfile = doprocess(buf, sizeof(buf), olocfile,
 603                 loc && mcase, loc && ntflag, loc && mapflag);
 604         if (restartit) {
 605                 struct stat stbuf;
 606                 int ret;
 607
 608                 if (! features[FEAT_REST_STREAM]) {
 609                         fprintf(ttyout,
 610                             "Restart is not supported by the remote server.\n");
 611                         return (0);
 612                 }
 613                 ret = stat(locfile, &stbuf);
 614                 if (restartit == 1) {
 615                         if (ret < 0) {
 616                                 warn("Can't stat `%s'", locfile);
 617                                 goto freegetit;
 618                         }
 619                         restart_point = stbuf.st_size;
 620                 } else {
 621                         if (ret == 0) {
 622                                 time_t mtime;
 623
 624                                 mtime = remotemodtime(argv[1], 0);
 625                                 if (mtime == -1)
 626                                         goto freegetit;
 627                                 if (stbuf.st_mtime >= mtime) {
 628                                         rval = 1;
 629                                         goto freegetit;
 630                                 }
 631                         }
 632                 }
 633         }
 634
 635         recvrequest("RETR", locfile, remfile, gmode,
 636             remfile != argv[1] || locfile != argv[2], loc);
 637         restart_point = 0;
 638  freegetit:
 639         (void)free(olocfile);
 640         return (rval);
 641 }
 642
 643 /* ARGSUSED */
 644 static void
 645 mintr(int signo)
 646 {
 647
 648         alarmtimer(0);
 649         if (fromatty)
 650                 write(fileno(ttyout), "\n", 1);
 651         siglongjmp(jabort, 1);
 652 }
 653
 654 static void
 655 mabort(const char *cmd)
 656 {
 657         int ointer, oconf;
 658
 659         if (mflag && fromatty) {
 660                 ointer = interactive;
 661                 oconf = confirmrest;
 662                 interactive = 1;
 663                 confirmrest = 0;
 664                 if (confirm(cmd, NULL)) {
 665                         interactive = ointer;
 666                         confirmrest = oconf;
 667                         return;
 668                 }
 669                 interactive = ointer;
 670                 confirmrest = oconf;
 671         }
 672         mflag = 0;
 673 }
 674
 675 /*
 676  * Get multiple files.
 677  */
 678 void
 679 mget(int argc, char *argv[])
 680 {
 681         sigfunc oldintr;
 682         int ointer;
 683         char *cp;
 684         const char *tp;
 685         int volatile restartit;
 686
 687         if (argc == 0 ||
 688             (argc == 1 && !another(&argc, &argv, "remote-files"))) {
 689                 UPRINTF("usage: %s remote-files\n", argv[0]);
 690                 code = -1;
 691                 return;
 692         }
 693         mflag = 1;
 694         restart_point = 0;
 695         restartit = 0;
 696         if (strcmp(argv[0], "mreget") == 0) {
 697                 if (! features[FEAT_REST_STREAM]) {
 698                         fprintf(ttyout,
 699                     "Restart is not supported by the remote server.\n");
 700                         return;
 701                 }
 702                 restartit = 1;
 703         }
 704         oldintr = xsignal(SIGINT, mintr);
 705         if (sigsetjmp(jabort, 1))
 706                 mabort(argv[0]);
 707         while ((cp = remglob(argv, proxy, NULL)) != NULL) {
 708                 char buf[MAXPATHLEN];
 709                 if (*cp == '\0' || !connected) {
 710                         mflag = 0;
 711                         continue;
 712                 }
 713                 if (! mflag)
 714                         continue;
 715                 if (! fileindir(cp, localcwd)) {
 716                         fprintf(ttyout, "Skipping non-relative filename `%s'\n",
 717                             cp);
 718                         continue;
 719                 }
 720                 if (!confirm(argv[0], cp))
 721                         continue;
 722                 tp = doprocess(buf, sizeof(buf), cp, mcase, ntflag, mapflag);
 723                 if (restartit) {
 724                         struct stat stbuf;
 725
 726                         if (stat(tp, &stbuf) == 0)
 727                                 restart_point = stbuf.st_size;
 728                         else
 729                                 warn("Can't stat `%s'", tp);
 730                 }
 731                 recvrequest("RETR", tp, cp, restart_point ? "r+" : "w",
 732                     tp != cp || !interactive, 1);
 733                 restart_point = 0;
 734                 if (!mflag && fromatty) {
 735                         ointer = interactive;
 736                         interactive = 1;
 737                         if (confirm(argv[0], NULL))
 738                                 mflag++;
 739                         interactive = ointer;
 740                 }
 741         }
 742         (void)xsignal(SIGINT, oldintr);
 743         mflag = 0;
 744 }
 745
 746 /*
 747  * Read list of filenames from a local file and get those
 748  */
 749 void
 750 fget(int argc, char *argv[])
 751 {
 752         const char *gmode;
 753         FILE    *fp;
 754         char    buf[MAXPATHLEN], cmdbuf[MAX_C_NAME];
 755
 756         if (argc != 2) {
 757                 UPRINTF("usage: %s localfile\n", argv[0]);
 758                 code = -1;
 759                 return;
 760         }
 761
 762         fp = fopen(argv[1], "r");
 763         if (fp == NULL) {
 764                 fprintf(ttyout, "Can't open source file %s\n", argv[1]);
 765                 code = -1;
 766                 return;
 767         }
 768
 769         (void)strlcpy(cmdbuf, "get", sizeof(cmdbuf));
 770         argv[0] = cmdbuf;
 771         gmode = restart_point ? "r+" : "w";
 772
 773         while (get_line(fp, buf, sizeof(buf), NULL) >= 0) {
 774                 if (buf[0] == '\0')
 775                         continue;
 776                 argv[1] = buf;
 777                 (void)getit(argc, argv, 0, gmode);
 778         }
 779         fclose(fp);
 780 }
 781
 782 const char *
 783 onoff(int val)
 784 {
 785
 786         return (val ? "on" : "off");
 787 }
 788
 789 /*
 790  * Show status.
 791  */
 792 /*ARGSUSED*/
 793 void
 794 status(int argc, char *argv[])
 795 {
 796
 797         if (argc == 0) {
 798                 UPRINTF("usage: %s\n", argv[0]);
 799                 code = -1;
 800                 return;
 801         }
 802 #ifndef NO_STATUS
 803         if (connected)
 804                 fprintf(ttyout, "Connected %sto %s.\n",
 805                     connected == -1 ? "and logged in" : "", hostname);
 806         else
 807                 fputs("Not connected.\n", ttyout);
 808         if (!proxy) {
 809                 pswitch(1);
 810                 if (connected) {
 811                         fprintf(ttyout, "Connected for proxy commands to %s.\n",
 812                             hostname);
 813                 }
 814                 else {
 815                         fputs("No proxy connection.\n", ttyout);
 816                 }
 817                 pswitch(0);
 818         }
 819         fprintf(ttyout, "Gate ftp: %s, server %s, port %s.\n", onoff(gatemode),
 820             *gateserver ? gateserver : "(none)", gateport);
 821         fprintf(ttyout, "Passive mode: %s; fallback to active mode: %s.\n",
 822             onoff(passivemode), onoff(activefallback));
 823         fprintf(ttyout, "Mode: %s; Type: %s; Form: %s; Structure: %s.\n",
 824             modename, typename, formname, structname);
 825         fprintf(ttyout, "Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s.\n",
 826             onoff(verbose), onoff(bell), onoff(interactive), onoff(doglob));
 827         fprintf(ttyout, "Store unique: %s; Receive unique: %s.\n",
 828             onoff(sunique), onoff(runique));
 829         fprintf(ttyout, "Preserve modification times: %s.\n", onoff(preserve));
 830         fprintf(ttyout, "Case: %s; CR stripping: %s.\n", onoff(mcase),
 831             onoff(crflag));
 832         if (ntflag) {
 833                 fprintf(ttyout, "Ntrans: (in) %s (out) %s\n", ntin, ntout);
 834         }
 835         else {
 836                 fputs("Ntrans: off.\n", ttyout);
 837         }
 838         if (mapflag) {
 839                 fprintf(ttyout, "Nmap: (in) %s (out) %s\n", mapin, mapout);
 840         }
 841         else {
 842                 fputs("Nmap: off.\n", ttyout);
 843         }
 844         fprintf(ttyout,
 845             "Hash mark printing: %s; Mark count: %d; Progress bar: %s.\n",
 846             onoff(hash), mark, onoff(progress));
 847         fprintf(ttyout,
 848             "Get transfer rate throttle: %s; maximum: %d; increment %d.\n",
 849             onoff(rate_get), rate_get, rate_get_incr);
 850         fprintf(ttyout,
 851             "Put transfer rate throttle: %s; maximum: %d; increment %d.\n",
 852             onoff(rate_put), rate_put, rate_put_incr);
 853         fprintf(ttyout,
 854             "Socket buffer sizes: send %d, receive %d.\n",
 855             sndbuf_size, rcvbuf_size);
 856         fprintf(ttyout, "Use of PORT cmds: %s.\n", onoff(sendport));
 857         fprintf(ttyout, "Use of EPSV/EPRT cmds for IPv4: %s%s.\n", onoff(epsv4),
 858             epsv4bad ? " (disabled for this connection)" : "");
 859         fprintf(ttyout, "Use of EPSV/EPRT cmds for IPv6: %s%s.\n", onoff(epsv6),
 860             epsv6bad ? " (disabled for this connection)" : "");
 861         fprintf(ttyout, "Command line editing: %s.\n",
 862 #ifdef NO_EDITCOMPLETE
 863             "support not compiled in"
 864 #else   /* !def NO_EDITCOMPLETE */
 865             onoff(editing)
 866 #endif  /* !def NO_EDITCOMPLETE */
 867             );
 868         if (macnum > 0) {
 869                 int i;
 870
 871                 fputs("Macros:\n", ttyout);
 872                 for (i=0; i<macnum; i++) {
 873                         fprintf(ttyout, "\t%s\n", macros[i].mac_name);
 874                 }
 875         }
 876 #endif /* !def NO_STATUS */
 877         fprintf(ttyout, "Version: %s %s\n", FTP_PRODUCT, FTP_VERSION);
 878         code = 0;
 879 }
 880
 881 /*
 882  * Toggle a variable
 883  */
 884 int
 885 togglevar(int argc, char *argv[], int *var, const char *mesg)
 886 {
 887         if (argc == 1) {
 888                 *var = !*var;
 889         } else if (argc == 2 && strcasecmp(argv[1], "on") == 0) {
 890                 *var = 1;
 891         } else if (argc == 2 && strcasecmp(argv[1], "off") == 0) {
 892                 *var = 0;
 893         } else {
 894                 UPRINTF("usage: %s [ on | off ]\n", argv[0]);
 895                 return (-1);
 896         }
 897         if (mesg)
 898                 fprintf(ttyout, "%s %s.\n", mesg, onoff(*var));
 899         return (*var);
 900 }
 901
 902 /*
 903  * Set beep on cmd completed mode.
 904  */
 905 /*VARARGS*/
 906 void
 907 setbell(int argc, char *argv[])
 908 {
 909
 910         code = togglevar(argc, argv, &bell, "Bell mode");
 911 }
 912
 913 /*
 914  * Set command line editing
 915  */
 916 /*VARARGS*/
 917 void
 918 setedit(int argc, char *argv[])
 919 {
 920
 921 #ifdef NO_EDITCOMPLETE
 922         if (argc == 0) {
 923                 UPRINTF("usage: %s\n", argv[0]);
 924                 code = -1;
 925                 return;
 926         }
 927         if (verbose)
 928                 fputs("Editing support not compiled in; ignoring command.\n",
 929                     ttyout);
 930 #else   /* !def NO_EDITCOMPLETE */
 931         code = togglevar(argc, argv, &editing, "Editing mode");
 932         controlediting();
 933 #endif  /* !def NO_EDITCOMPLETE */
 934 }
 935
 936 /*
 937  * Turn on packet tracing.
 938  */
 939 /*VARARGS*/
 940 void
 941 settrace(int argc, char *argv[])
 942 {
 943
 944         code = togglevar(argc, argv, &trace, "Packet tracing");
 945 }
 946
 947 /*
 948  * Toggle hash mark printing during transfers, or set hash mark bytecount.
 949  */
 950 /*VARARGS*/
 951 void
 952 sethash(int argc, char *argv[])
 953 {
 954         if (argc == 1)
 955                 hash = !hash;
 956         else if (argc != 2) {
 957                 UPRINTF("usage: %s [ on | off | bytecount ]\n",
 958                     argv[0]);
 959                 code = -1;
 960                 return;
 961         } else if (strcasecmp(argv[1], "on") == 0)
 962                 hash = 1;
 963         else if (strcasecmp(argv[1], "off") == 0)
 964                 hash = 0;
 965         else {
 966                 int nmark;
 967
 968                 nmark = strsuftoi(argv[1]);
 969                 if (nmark < 1) {
 970                         fprintf(ttyout, "mark: bad bytecount value `%s'.\n",
 971                             argv[1]);
 972                         code = -1;
 973                         return;
 974                 }
 975                 mark = nmark;
 976                 hash = 1;
 977         }
 978         fprintf(ttyout, "Hash mark printing %s", onoff(hash));
 979         if (hash)
 980                 fprintf(ttyout, " (%d bytes/hash mark)", mark);
 981         fputs(".\n", ttyout);
 982         if (hash)
 983                 progress = 0;
 984         code = hash;
 985 }
 986
 987 /*
 988  * Turn on printing of server echo's.
 989  */
 990 /*VARARGS*/
 991 void
 992 setverbose(int argc, char *argv[])
 993 {
 994
 995         code = togglevar(argc, argv, &verbose, "Verbose mode");
 996 }
 997
 998 /*
 999  * Toggle PORT/LPRT cmd use before each data connection.
1000  */
1001 /*VARARGS*/
1002 void
1003 setport(int argc, char *argv[])
1004 {
1005
1006         code = togglevar(argc, argv, &sendport, "Use of PORT/LPRT cmds");
1007 }
1008
1009 /*
1010  * Toggle transfer progress bar.
1011  */
1012 /*VARARGS*/
1013 void
1014 setprogress(int argc, char *argv[])
1015 {
1016
1017         code = togglevar(argc, argv, &progress, "Progress bar");
1018         if (progress)
1019                 hash = 0;
1020 }
1021
1022 /*
1023  * Turn on interactive prompting during mget, mput, and mdelete.
1024  */
1025 /*VARARGS*/
1026 void
1027 setprompt(int argc, char *argv[])
1028 {
1029
1030         code = togglevar(argc, argv, &interactive, "Interactive mode");
1031 }
1032
1033 /*
1034  * Toggle gate-ftp mode, or set gate-ftp server
1035  */
1036 /*VARARGS*/
1037 void
1038 setgate(int argc, char *argv[])
1039 {
1040         static char gsbuf[MAXHOSTNAMELEN];
1041
1042         if (argc == 0 || argc > 3) {
1043                 UPRINTF(
1044                     "usage: %s [ on | off | gateserver [port] ]\n", argv[0]);
1045                 code = -1;
1046                 return;
1047         } else if (argc < 2) {
1048                 gatemode = !gatemode;
1049         } else {
1050                 if (argc == 2 && strcasecmp(argv[1], "on") == 0)
1051                         gatemode = 1;
1052                 else if (argc == 2 && strcasecmp(argv[1], "off") == 0)
1053                         gatemode = 0;
1054                 else {
1055                         if (argc == 3)
1056                                 gateport = ftp_strdup(argv[2]);
1057                         (void)strlcpy(gsbuf, argv[1], sizeof(gsbuf));
1058                         gateserver = gsbuf;
1059                         gatemode = 1;
1060                 }
1061         }
1062         if (gatemode && (gateserver == NULL || *gateserver == '\0')) {
1063                 fprintf(ttyout,
1064                     "Disabling gate-ftp mode - no gate-ftp server defined.\n");
1065                 gatemode = 0;
1066         } else {
1067                 fprintf(ttyout, "Gate ftp: %s, server %s, port %s.\n",
1068                     onoff(gatemode), *gateserver ? gateserver : "(none)",
1069                     gateport);
1070         }
1071         code = gatemode;
1072 }
1073
1074 /*
1075  * Toggle metacharacter interpretation on local file names.
1076  */
1077 /*VARARGS*/
1078 void
1079 setglob(int argc, char *argv[])
1080 {
1081
1082         code = togglevar(argc, argv, &doglob, "Globbing");
1083 }
1084
1085 /*
1086  * Toggle preserving modification times on retrieved files.
1087  */
1088 /*VARARGS*/
1089 void
1090 setpreserve(int argc, char *argv[])
1091 {
1092
1093         code = togglevar(argc, argv, &preserve, "Preserve modification times");
1094 }
1095
1096 /*
1097  * Set debugging mode on/off and/or set level of debugging.
1098  */
1099 /*VARARGS*/
1100 void
1101 setdebug(int argc, char *argv[])
1102 {
1103         if (argc == 0 || argc > 2) {
1104                 UPRINTF("usage: %s [ on | off | debuglevel ]\n", argv[0]);
1105                 code = -1;
1106                 return;
1107         } else if (argc == 2) {
1108                 if (strcasecmp(argv[1], "on") == 0)
1109                         ftp_debug = 1;
1110                 else if (strcasecmp(argv[1], "off") == 0)
1111                         ftp_debug = 0;
1112                 else {
1113                         int val;
1114
1115                         val = strsuftoi(argv[1]);
1116                         if (val < 0) {
1117                                 fprintf(ttyout, "%s: bad debugging value.\n",
1118                                     argv[1]);
1119                                 code = -1;
1120                                 return;
1121                         }
1122                         ftp_debug = val;
1123                 }
1124         } else
1125                 ftp_debug = !ftp_debug;
1126         if (ftp_debug)
1127                 options |= SO_DEBUG;
1128         else
1129                 options &= ~SO_DEBUG;
1130         fprintf(ttyout, "Debugging %s (ftp_debug=%d).\n", onoff(ftp_debug), ftp_debug);
1131         code = ftp_debug > 0;
1132 }
1133
1134 /*
1135  * Set current working directory on remote machine.
1136  */
1137 void
1138 cd(int argc, char *argv[])
1139 {
1140         int r;
1141
1142         if (argc == 0 || argc > 2 ||
1143             (argc == 1 && !another(&argc, &argv, "remote-directory"))) {
1144                 UPRINTF("usage: %s remote-directory\n", argv[0]);
1145                 code = -1;
1146                 return;
1147         }
1148         r = command("CWD %s", argv[1]);
1149         if (r == ERROR && code == 500) {
1150                 if (verbose)
1151                         fputs("CWD command not recognized, trying XCWD.\n",
1152                             ttyout);
1153                 r = command("XCWD %s", argv[1]);
1154         }
1155         if (r == COMPLETE) {
1156                 dirchange = 1;
1157                 updateremotecwd();
1158         }
1159 }
1160
1161 /*
1162  * Set current working directory on local machine.
1163  */
1164 void
1165 lcd(int argc, char *argv[])
1166 {
1167         char *locdir;
1168
1169         code = -1;
1170         if (argc == 1) {
1171                 argc++;
1172                 argv[1] = localhome;
1173         }
1174         if (argc != 2) {
1175                 UPRINTF("usage: %s [local-directory]\n", argv[0]);
1176                 return;
1177         }
1178         if ((locdir = globulize(argv[1])) == NULL)
1179                 return;
1180         if (chdir(locdir) == -1)
1181                 warn("Can't chdir `%s'", locdir);
1182         else {
1183                 updatelocalcwd();
1184                 if (localcwd[0]) {
1185                         fprintf(ttyout, "Local directory now: %s\n", localcwd);
1186                         code = 0;
1187                 } else {
1188                         fprintf(ttyout, "Unable to determine local directory\n");
1189                 }
1190         }
1191         (void)free(locdir);
1192 }
1193
1194 /*
1195  * Delete a single file.
1196  */
1197 void
1198 delete(int argc, char *argv[])
1199 {
1200
1201         if (argc == 0 || argc > 2 ||
1202             (argc == 1 && !another(&argc, &argv, "remote-file"))) {
1203                 UPRINTF("usage: %s remote-file\n", argv[0]);
1204                 code = -1;
1205                 return;
1206         }
1207         if (command("DELE %s", argv[1]) == COMPLETE)
1208                 dirchange = 1;
1209 }
1210
1211 /*
1212  * Delete multiple files.
1213  */
1214 void
1215 mdelete(int argc, char *argv[])
1216 {
1217         sigfunc oldintr;
1218         int ointer;
1219         char *cp;
1220
1221         if (argc == 0 ||
1222             (argc == 1 && !another(&argc, &argv, "remote-files"))) {
1223                 UPRINTF("usage: %s [remote-files]\n", argv[0]);
1224                 code = -1;
1225                 return;
1226         }
1227         mflag = 1;
1228         oldintr = xsignal(SIGINT, mintr);
1229         if (sigsetjmp(jabort, 1))
1230                 mabort(argv[0]);
1231         while ((cp = remglob(argv, 0, NULL)) != NULL) {
1232                 if (*cp == '\0') {
1233                         mflag = 0;
1234                         continue;
1235                 }
1236                 if (mflag && confirm(argv[0], cp)) {
1237                         if (command("DELE %s", cp) == COMPLETE)
1238                                 dirchange = 1;
1239                         if (!mflag && fromatty) {
1240                                 ointer = interactive;
1241                                 interactive = 1;
1242                                 if (confirm(argv[0], NULL)) {
1243                                         mflag++;
1244                                 }
1245                                 interactive = ointer;
1246                         }
1247                 }
1248         }
1249         (void)xsignal(SIGINT, oldintr);
1250         mflag = 0;
1251 }
1252
1253 /*
1254  * Rename a remote file.
1255  */
1256 void
1257 renamefile(int argc, char *argv[])
1258 {
1259
1260         if (argc == 0 || (argc == 1 && !another(&argc, &argv, "from-name")))
1261                 goto usage;
1262         if ((argc < 3 && !another(&argc, &argv, "to-name")) || argc > 3) {
1263  usage:
1264                 UPRINTF("usage: %s from-name to-name\n", argv[0]);
1265                 code = -1;
1266                 return;
1267         }
1268         if (command("RNFR %s", argv[1]) == CONTINUE &&
1269             command("RNTO %s", argv[2]) == COMPLETE)
1270                 dirchange = 1;
1271 }
1272
1273 /*
1274  * Get a directory listing of remote files.
1275  * Supports being invoked as:
1276  *      cmd             runs
1277  *      ---             ----
1278  *      dir, ls         LIST
1279  *      mlsd            MLSD
1280  *      nlist           NLST
1281  *      pdir, pls       LIST |$PAGER
1282  *      pmlsd           MLSD |$PAGER
1283  */
1284 void
1285 ls(int argc, char *argv[])
1286 {
1287         const char *cmd;
1288         char *remdir, *locbuf;
1289         const char *locfile;
1290         int pagecmd, mlsdcmd;
1291
1292         remdir = NULL;
1293         locbuf = NULL;
1294         locfile = "-";
1295         pagecmd = mlsdcmd = 0;
1296                         /*
1297                          * the only commands that start with `p' are
1298                          * the `pager' versions.
1299                          */
1300         if (argv[0][0] == 'p')
1301                 pagecmd = 1;
1302         if (strcmp(argv[0] + pagecmd , "mlsd") == 0) {
1303                 if (! features[FEAT_MLST]) {
1304                         fprintf(ttyout,
1305                            "MLSD is not supported by the remote server.\n");
1306                         return;
1307                 }
1308                 mlsdcmd = 1;
1309         }
1310         if (argc == 0)
1311                 goto usage;
1312
1313         if (mlsdcmd)
1314                 cmd = "MLSD";
1315         else if (strcmp(argv[0] + pagecmd, "nlist") == 0)
1316                 cmd = "NLST";
1317         else
1318                 cmd = "LIST";
1319
1320         if (argc > 1)
1321                 remdir = argv[1];
1322         if (argc > 2)
1323                 locfile = argv[2];
1324         if (argc > 3 || ((pagecmd | mlsdcmd) && argc > 2)) {
1325  usage:
1326                 if (pagecmd || mlsdcmd)
1327                         UPRINTF("usage: %s [remote-path]\n", argv[0]);
1328                 else
1329                         UPRINTF("usage: %s [remote-path [local-file]]\n",
1330                             argv[0]);
1331                 code = -1;
1332                 goto freels;
1333         }
1334
1335         if (pagecmd) {
1336                 const char *p;
1337                 size_t len;
1338
1339                 p = getoptionvalue("pager");
1340                 if (EMPTYSTRING(p))
1341                         p = DEFAULTPAGER;
1342                 len = strlen(p) + 2;
1343                 locbuf = ftp_malloc(len);
1344                 locbuf[0] = '|';
1345                 (void)strlcpy(locbuf + 1, p, len - 1);
1346                 locfile = locbuf;
1347         } else if ((strcmp(locfile, "-") != 0) && *locfile != '|') {
1348                 if ((locbuf = globulize(locfile)) == NULL ||
1349                     !confirm("output to local-file:", locbuf)) {
1350                         code = -1;
1351                         goto freels;
1352                 }
1353                 locfile = locbuf;
1354         }
1355         recvrequest(cmd, locfile, remdir, "w", 0, 0);
1356  freels:
1357         if (locbuf)
1358                 (void)free(locbuf);
1359 }
1360
1361 /*
1362  * Get a directory listing of multiple remote files.
1363  */
1364 void
1365 mls(int argc, char *argv[])
1366 {
1367         sigfunc oldintr;
1368         int ointer, i;
1369         int volatile dolist;
1370         char * volatile dest, *odest;
1371         const char *lmode;
1372
1373         if (argc == 0)
1374                 goto usage;
1375         if (argc < 2 && !another(&argc, &argv, "remote-files"))
1376                 goto usage;
1377         if (argc < 3 && !another(&argc, &argv, "local-file")) {
1378  usage:
1379                 UPRINTF("usage: %s remote-files local-file\n", argv[0]);
1380                 code = -1;
1381                 return;
1382         }
1383         odest = dest = argv[argc - 1];
1384         argv[argc - 1] = NULL;
1385         if (strcmp(dest, "-") && *dest != '|')
1386                 if (((dest = globulize(dest)) == NULL) ||
1387                     !confirm("output to local-file:", dest)) {
1388                         code = -1;
1389                         return;
1390         }
1391         dolist = strcmp(argv[0], "mls");
1392         mflag = 1;
1393         oldintr = xsignal(SIGINT, mintr);
1394         if (sigsetjmp(jabort, 1))
1395                 mabort(argv[0]);
1396         for (i = 1; mflag && i < argc-1 && connected; i++) {
1397                 lmode = (i == 1) ? "w" : "a";
1398                 recvrequest(dolist ? "LIST" : "NLST", dest, argv[i], lmode,
1399                     0, 0);
1400                 if (!mflag && fromatty) {
1401                         ointer = interactive;
1402                         interactive = 1;
1403                         if (confirm(argv[0], NULL)) {
1404                                 mflag++;
1405                         }
1406                         interactive = ointer;
1407                 }
1408         }
1409         (void)xsignal(SIGINT, oldintr);
1410         mflag = 0;
1411         if (dest != odest)                      /* free up after globulize() */
1412                 free(dest);
1413 }
1414
1415 /*
1416  * Do a shell escape
1417  */
1418 /*ARGSUSED*/
1419 void
1420 shell(int argc, char *argv[])
1421 {
1422         pid_t pid;
1423         sigfunc oldintr;
1424         char shellnam[MAXPATHLEN];
1425         const char *shellp, *namep;
1426         int wait_status;
1427
1428         if (argc == 0) {
1429                 UPRINTF("usage: %s [command [args]]\n", argv[0]);
1430                 code = -1;
1431                 return;
1432         }
1433         oldintr = xsignal(SIGINT, SIG_IGN);
1434         if ((pid = fork()) == 0) {
1435                 for (pid = 3; pid < 20; pid++)
1436                         (void)close(pid);
1437                 (void)xsignal(SIGINT, SIG_DFL);
1438                 shellp = getenv("SHELL");
1439                 if (shellp == NULL)
1440                         shellp = _PATH_BSHELL;
1441                 namep = strrchr(shellp, '/');
1442                 if (namep == NULL)
1443                         namep = shellp;
1444                 else
1445                         namep++;
1446                 (void)strlcpy(shellnam, namep, sizeof(shellnam));
1447                 if (ftp_debug) {
1448                         fputs(shellp, ttyout);
1449                         putc('\n', ttyout);
1450                 }
1451                 if (argc > 1) {
1452                         execl(shellp, shellnam, "-c", altarg, (char *)0);
1453                 }
1454                 else {
1455                         execl(shellp, shellnam, (char *)0);
1456                 }
1457                 warn("Can't execute `%s'", shellp);
1458                 code = -1;
1459                 exit(1);
1460         }
1461         if (pid > 0)
1462                 while (wait(&wait_status) != pid)
1463                         ;
1464         (void)xsignal(SIGINT, oldintr);
1465         if (pid == -1) {
1466                 warn("Can't fork a subshell; try again later");
1467                 code = -1;
1468         } else
1469                 code = 0;
1470 }
1471
1472 /*
1473  * Send new user information (re-login)
1474  */
1475 void
1476 user(int argc, char *argv[])
1477 {
1478         char *password;
1479         char emptypass[] = "";
1480         int n, aflag = 0;
1481
1482         if (argc == 0)
1483                 goto usage;
1484         if (argc < 2)
1485                 (void)another(&argc, &argv, "username");
1486         if (argc < 2 || argc > 4) {
1487  usage:
1488                 UPRINTF("usage: %s username [password [account]]\n",
1489                     argv[0]);
1490                 code = -1;
1491                 return;
1492         }
1493         n = command("USER %s", argv[1]);
1494         if (n == CONTINUE) {
1495                 if (argc < 3) {
1496                         password = getpass("Password: ");
1497                         if (password == NULL)
1498                                 password = emptypass;
1499                 } else {
1500                         password = argv[2];
1501                 }
1502                 n = command("PASS %s", password);
1503                 memset(password, 0, strlen(password));
1504         }
1505         if (n == CONTINUE) {
1506                 aflag++;
1507                 if (argc < 4) {
1508                         password = getpass("Account: ");
1509                         if (password == NULL)
1510                                 password = emptypass;
1511                 } else {
1512                         password = argv[3];
1513                 }
1514                 n = command("ACCT %s", password);
1515                 memset(password, 0, strlen(password));
1516         }
1517         if (n != COMPLETE) {
1518                 fputs("Login failed.\n", ttyout);
1519                 return;
1520         }
1521         if (!aflag && argc == 4) {
1522                 password = argv[3];
1523                 (void)command("ACCT %s", password);
1524                 memset(password, 0, strlen(password));
1525         }
1526         connected = -1;
1527         getremoteinfo();
1528 }
1529
1530 /*
1531  * Print working directory on remote machine.
1532  */
1533 /*VARARGS*/
1534 void
1535 pwd(int argc, char *argv[])
1536 {
1537
1538         code = -1;
1539         if (argc != 1) {
1540                 UPRINTF("usage: %s\n", argv[0]);
1541                 return;
1542         }
1543         if (! remotecwd[0])
1544                 updateremotecwd();
1545         if (! remotecwd[0])
1546                 fprintf(ttyout, "Unable to determine remote directory\n");
1547         else {
1548                 fprintf(ttyout, "Remote directory: %s\n", remotecwd);
1549                 code = 0;
1550         }
1551 }
1552
1553 /*
1554  * Print working directory on local machine.
1555  */
1556 void
1557 lpwd(int argc, char *argv[])
1558 {
1559
1560         code = -1;
1561         if (argc != 1) {
1562                 UPRINTF("usage: %s\n", argv[0]);
1563                 return;
1564         }
1565         if (! localcwd[0])
1566                 updatelocalcwd();
1567         if (! localcwd[0])
1568                 fprintf(ttyout, "Unable to determine local directory\n");
1569         else {
1570                 fprintf(ttyout, "Local directory: %s\n", localcwd);
1571                 code = 0;
1572         }
1573 }
1574
1575 /*
1576  * Make a directory.
1577  */
1578 void
1579 makedir(int argc, char *argv[])
1580 {
1581         int r;
1582
1583         if (argc == 0 || argc > 2 ||
1584             (argc == 1 && !another(&argc, &argv, "directory-name"))) {
1585                 UPRINTF("usage: %s directory-name\n", argv[0]);
1586                 code = -1;
1587                 return;
1588         }
1589         r = command("MKD %s", argv[1]);
1590         if (r == ERROR && code == 500) {
1591                 if (verbose)
1592                         fputs("MKD command not recognized, trying XMKD.\n",
1593                             ttyout);
1594                 r = command("XMKD %s", argv[1]);
1595         }
1596         if (r == COMPLETE)
1597                 dirchange = 1;
1598 }
1599
1600 /*
1601  * Remove a directory.
1602  */
1603 void
1604 removedir(int argc, char *argv[])
1605 {
1606         int r;
1607
1608         if (argc == 0 || argc > 2 ||
1609             (argc == 1 && !another(&argc, &argv, "directory-name"))) {
1610                 UPRINTF("usage: %s directory-name\n", argv[0]);
1611                 code = -1;
1612                 return;
1613         }
1614         r = command("RMD %s", argv[1]);
1615         if (r == ERROR && code == 500) {
1616                 if (verbose)
1617                         fputs("RMD command not recognized, trying XRMD.\n",
1618                             ttyout);
1619                 r = command("XRMD %s", argv[1]);
1620         }
1621         if (r == COMPLETE)
1622                 dirchange = 1;
1623 }
1624
1625 /*
1626  * Send a line, verbatim, to the remote machine.
1627  */
1628 void
1629 quote(int argc, char *argv[])
1630 {
1631
1632         if (argc == 0 ||
1633             (argc == 1 && !another(&argc, &argv, "command line to send"))) {
1634                 UPRINTF("usage: %s line-to-send\n", argv[0]);
1635                 code = -1;
1636                 return;
1637         }
1638         quote1("", argc, argv);
1639 }
1640
1641 /*
1642  * Send a SITE command to the remote machine.  The line
1643  * is sent verbatim to the remote machine, except that the
1644  * word "SITE" is added at the front.
1645  */
1646 void
1647 site(int argc, char *argv[])
1648 {
1649
1650         if (argc == 0 ||
1651             (argc == 1 && !another(&argc, &argv, "arguments to SITE command"))){
1652                 UPRINTF("usage: %s line-to-send\n", argv[0]);
1653                 code = -1;
1654                 return;
1655         }
1656         quote1("SITE ", argc, argv);
1657 }
1658
1659 /*
1660  * Turn argv[1..argc) into a space-separated string, then prepend initial text.
1661  * Send the result as a one-line command and get response.
1662  */
1663 void
1664 quote1(const char *initial, int argc, char *argv[])
1665 {
1666         int i;
1667         char buf[BUFSIZ];               /* must be >= sizeof(line) */
1668
1669         (void)strlcpy(buf, initial, sizeof(buf));
1670         for (i = 1; i < argc; i++) {
1671                 (void)strlcat(buf, argv[i], sizeof(buf));
1672                 if (i < (argc - 1))
1673                         (void)strlcat(buf, " ", sizeof(buf));
1674         }
1675         if (command("%s", buf) == PRELIM) {
1676                 while (getreply(0) == PRELIM)
1677                         continue;
1678         }
1679         dirchange = 1;
1680 }
1681
1682 void
1683 do_chmod(int argc, char *argv[])
1684 {
1685
1686         if (argc == 0 || (argc == 1 && !another(&argc, &argv, "mode")))
1687                 goto usage;
1688         if ((argc < 3 && !another(&argc, &argv, "remote-file")) || argc > 3) {
1689  usage:
1690                 UPRINTF("usage: %s mode remote-file\n", argv[0]);
1691                 code = -1;
1692                 return;
1693         }
1694         (void)command("SITE CHMOD %s %s", argv[1], argv[2]);
1695 }
1696
1697 #define COMMAND_1ARG(argc, argv, cmd)                   \
1698         if (argc == 1)                                  \
1699                 command(cmd);                           \
1700         else                                            \
1701                 command(cmd " %s", argv[1])
1702
1703 void
1704 do_umask(int argc, char *argv[])
1705 {
1706         int oldverbose = verbose;
1707
1708         if (argc == 0) {
1709                 UPRINTF("usage: %s [umask]\n", argv[0]);
1710                 code = -1;
1711                 return;
1712         }
1713         verbose = 1;
1714         COMMAND_1ARG(argc, argv, "SITE UMASK");
1715         verbose = oldverbose;
1716 }
1717
1718 void
1719 idlecmd(int argc, char *argv[])
1720 {
1721         int oldverbose = verbose;
1722
1723         if (argc < 1 || argc > 2) {
1724                 UPRINTF("usage: %s [seconds]\n", argv[0]);
1725                 code = -1;
1726                 return;
1727         }
1728         verbose = 1;
1729         COMMAND_1ARG(argc, argv, "SITE IDLE");
1730         verbose = oldverbose;
1731 }
1732
1733 /*
1734  * Ask the other side for help.
1735  */
1736 void
1737 rmthelp(int argc, char *argv[])
1738 {
1739         int oldverbose = verbose;
1740
1741         if (argc == 0) {
1742                 UPRINTF("usage: %s\n", argv[0]);
1743                 code = -1;
1744                 return;
1745         }
1746         verbose = 1;
1747         COMMAND_1ARG(argc, argv, "HELP");
1748         verbose = oldverbose;
1749 }
1750
1751 /*
1752  * Terminate session and exit.
1753  * May be called with 0, NULL.
1754  */
1755 /*VARARGS*/
1756 void
1757 quit(int argc, char *argv[])
1758 {
1759
1760                         /* this may be called with argc == 0, argv == NULL */
1761         if (argc == 0 && argv != NULL) {
1762                 UPRINTF("usage: %s\n", argv[0]);
1763                 code = -1;
1764                 return;
1765         }
1766         if (connected)
1767                 disconnect(0, NULL);
1768         pswitch(1);
1769         if (connected)
1770                 disconnect(0, NULL);
1771         exit(0);
1772 }
1773
1774 /*
1775  * Terminate session, but don't exit.
1776  * May be called with 0, NULL.
1777  */
1778 void
1779 disconnect(int argc, char *argv[])
1780 {
1781
1782                         /* this may be called with argc == 0, argv == NULL */
1783         if (argc == 0 && argv != NULL) {
1784                 UPRINTF("usage: %s\n", argv[0]);
1785                 code = -1;
1786                 return;
1787         }
1788         if (!connected)
1789                 return;
1790         (void)command("QUIT");
1791         cleanuppeer();
1792 }
1793
1794 void
1795 account(int argc, char *argv[])
1796 {
1797         char *ap;
1798         char emptypass[] = "";
1799
1800         if (argc == 0 || argc > 2) {
1801                 UPRINTF("usage: %s [password]\n", argv[0]);
1802                 code = -1;
1803                 return;
1804         }
1805         else if (argc == 2)
1806                 ap = argv[1];
1807         else {
1808                 ap = getpass("Account:");
1809                 if (ap == NULL)
1810                         ap = emptypass;
1811         }
1812         (void)command("ACCT %s", ap);
1813         memset(ap, 0, strlen(ap));
1814 }
1815
1816 sigjmp_buf abortprox;
1817
1818 void
1819 proxabort(int notused)
1820 {
1821
1822         sigint_raised = 1;
1823         alarmtimer(0);
1824         if (!proxy) {
1825                 pswitch(1);
1826         }
1827         if (connected) {
1828                 proxflag = 1;
1829         }
1830         else {
1831                 proxflag = 0;
1832         }
1833         pswitch(0);
1834         siglongjmp(abortprox, 1);
1835 }
1836
1837 void
1838 doproxy(int argc, char *argv[])
1839 {
1840         struct cmd *c;
1841         int cmdpos;
1842         sigfunc oldintr;
1843         char cmdbuf[MAX_C_NAME];
1844
1845         if (argc == 0 || (argc == 1 && !another(&argc, &argv, "command"))) {
1846                 UPRINTF("usage: %s command\n", argv[0]);
1847                 code = -1;
1848                 return;
1849         }
1850         c = getcmd(argv[1]);
1851         if (c == (struct cmd *) -1) {
1852                 fputs("?Ambiguous command.\n", ttyout);
1853                 code = -1;
1854                 return;
1855         }
1856         if (c == 0) {
1857                 fputs("?Invalid command.\n", ttyout);
1858                 code = -1;
1859                 return;
1860         }
1861         if (!c->c_proxy) {
1862                 fputs("?Invalid proxy command.\n", ttyout);
1863                 code = -1;
1864                 return;
1865         }
1866         if (sigsetjmp(abortprox, 1)) {
1867                 code = -1;
1868                 return;
1869         }
1870         oldintr = xsignal(SIGINT, proxabort);
1871         pswitch(1);
1872         if (c->c_conn && !connected) {
1873                 fputs("Not connected.\n", ttyout);
1874                 pswitch(0);
1875                 (void)xsignal(SIGINT, oldintr);
1876                 code = -1;
1877                 return;
1878         }
1879         cmdpos = strcspn(line, " \t");
1880         if (cmdpos > 0)         /* remove leading "proxy " from input buffer */
1881                 memmove(line, line + cmdpos + 1, strlen(line) - cmdpos + 1);
1882         (void)strlcpy(cmdbuf, c->c_name, sizeof(cmdbuf));
1883         argv[1] = cmdbuf;
1884         (*c->c_handler)(argc-1, argv+1);
1885         if (connected) {
1886                 proxflag = 1;
1887         }
1888         else {
1889                 proxflag = 0;
1890         }
1891         pswitch(0);
1892         (void)xsignal(SIGINT, oldintr);
1893 }
1894
1895 void
1896 setcase(int argc, char *argv[])
1897 {
1898
1899         code = togglevar(argc, argv, &mcase, "Case mapping");
1900 }
1901
1902 /*
1903  * convert the given name to lower case if it's all upper case, into
1904  * a static buffer which is returned to the caller
1905  */
1906 static const char *
1907 docase(char *dst, size_t dlen, const char *src)
1908 {
1909         size_t i;
1910         int dochange = 1;
1911
1912         for (i = 0; src[i] != '\0' && i < dlen - 1; i++) {
1913                 dst[i] = src[i];
1914                 if (islower((unsigned char)dst[i]))
1915                         dochange = 0;
1916         }
1917         dst[i] = '\0';
1918
1919         if (dochange) {
1920                 for (i = 0; dst[i] != '\0'; i++)
1921                         if (isupper((unsigned char)dst[i]))
1922                                 dst[i] = tolower((unsigned char)dst[i]);
1923         }
1924         return dst;
1925 }
1926
1927 void
1928 setcr(int argc, char *argv[])
1929 {
1930
1931         code = togglevar(argc, argv, &crflag, "Carriage Return stripping");
1932 }
1933
1934 void
1935 setntrans(int argc, char *argv[])
1936 {
1937
1938         if (argc == 0 || argc > 3) {
1939                 UPRINTF("usage: %s [inchars [outchars]]\n", argv[0]);
1940                 code = -1;
1941                 return;
1942         }
1943         if (argc == 1) {
1944                 ntflag = 0;
1945                 fputs("Ntrans off.\n", ttyout);
1946                 code = ntflag;
1947                 return;
1948         }
1949         ntflag++;
1950         code = ntflag;
1951         (void)strlcpy(ntin, argv[1], sizeof(ntin));
1952         if (argc == 2) {
1953                 ntout[0] = '\0';
1954                 return;
1955         }
1956         (void)strlcpy(ntout, argv[2], sizeof(ntout));
1957 }
1958
1959 static const char *
1960 dotrans(char *dst, size_t dlen, const char *src)
1961 {
1962         const char *cp1;
1963         char *cp2 = dst;
1964         size_t i, ostop;
1965
1966         for (ostop = 0; *(ntout + ostop) && ostop < 16; ostop++)
1967                 continue;
1968         for (cp1 = src; *cp1; cp1++) {
1969                 int found = 0;
1970                 for (i = 0; *(ntin + i) && i < 16; i++) {
1971                         if (*cp1 == *(ntin + i)) {
1972                                 found++;
1973                                 if (i < ostop) {
1974                                         *cp2++ = *(ntout + i);
1975                                         if (cp2 - dst >= (ptrdiff_t)(dlen - 1))
1976                                                 goto out;
1977                                 }
1978                                 break;
1979                         }
1980                 }
1981                 if (!found) {
1982                         *cp2++ = *cp1;
1983                 }
1984         }
1985 out:
1986         *cp2 = '\0';
1987         return dst;
1988 }
1989
1990 void
1991 setnmap(int argc, char *argv[])
1992 {
1993         char *cp;
1994
1995         if (argc == 1) {
1996                 mapflag = 0;
1997                 fputs("Nmap off.\n", ttyout);
1998                 code = mapflag;
1999                 return;
2000         }
2001         if (argc == 0 ||
2002             (argc < 3 && !another(&argc, &argv, "mapout")) || argc > 3) {
2003                 UPRINTF("usage: %s [mapin mapout]\n", argv[0]);
2004                 code = -1;
2005                 return;
2006         }
2007         mapflag = 1;
2008         code = 1;
2009         cp = strchr(altarg, ' ');
2010         if (proxy) {
2011                 while(*++cp == ' ')
2012                         continue;
2013                 altarg = cp;
2014                 cp = strchr(altarg, ' ');
2015         }
2016         *cp = '\0';
2017         (void)strlcpy(mapin, altarg, MAXPATHLEN);
2018         while (*++cp == ' ')
2019                 continue;
2020         (void)strlcpy(mapout, cp, MAXPATHLEN);
2021 }
2022
2023 static const char *
2024 domap(char *dst, size_t dlen, const char *src)
2025 {
2026         const char *cp1 = src;
2027         char *cp2 = mapin;
2028         const char *tp[9], *te[9];
2029         int i, toks[9], toknum = 0, match = 1;
2030
2031         for (i=0; i < 9; ++i) {
2032                 toks[i] = 0;
2033         }
2034         while (match && *cp1 && *cp2) {
2035                 switch (*cp2) {
2036                         case '\\':
2037                                 if (*++cp2 != *cp1) {
2038                                         match = 0;
2039                                 }
2040                                 break;
2041                         case '$':
2042                                 if (*(cp2+1) >= '1' && (*cp2+1) <= '9') {
2043                                         if (*cp1 != *(++cp2+1)) {
2044                                                 toks[toknum = *cp2 - '1']++;
2045                                                 tp[toknum] = cp1;
2046                                                 while (*++cp1 && *(cp2+1)
2047                                                         != *cp1);
2048                                                 te[toknum] = cp1;
2049                                         }
2050                                         cp2++;
2051                                         break;
2052                                 }
2053                                 /* FALLTHROUGH */
2054                         default:
2055                                 if (*cp2 != *cp1) {
2056                                         match = 0;
2057                                 }
2058                                 break;
2059                 }
2060                 if (match && *cp1) {
2061                         cp1++;
2062                 }
2063                 if (match && *cp2) {
2064                         cp2++;
2065                 }
2066         }
2067         if (!match && *cp1) /* last token mismatch */
2068         {
2069                 toks[toknum] = 0;
2070         }
2071         cp2 = dst;
2072         *cp2 = '\0';
2073         cp1 = mapout;
2074         while (*cp1) {
2075                 match = 0;
2076                 switch (*cp1) {
2077                         case '\\':
2078                                 if (*(cp1 + 1)) {
2079                                         *cp2++ = *++cp1;
2080                                 }
2081                                 break;
2082                         case '[':
2083 LOOP:
2084                                 if (*++cp1 == '$' &&
2085                                     isdigit((unsigned char)*(cp1+1))) {
2086                                         if (*++cp1 == '0') {
2087                                                 const char *cp3 = src;
2088
2089                                                 while (*cp3) {
2090                                                         *cp2++ = *cp3++;
2091                                                 }
2092                                                 match = 1;
2093                                         }
2094                                         else if (toks[toknum = *cp1 - '1']) {
2095                                                 const char *cp3 = tp[toknum];
2096
2097                                                 while (cp3 != te[toknum]) {
2098                                                         *cp2++ = *cp3++;
2099                                                 }
2100                                                 match = 1;
2101                                         }
2102                                 }
2103                                 else {
2104                                         while (*cp1 && *cp1 != ',' &&
2105                                             *cp1 != ']') {
2106                                                 if (*cp1 == '\\') {
2107                                                         cp1++;
2108                                                 }
2109                                                 else if (*cp1 == '$' &&
2110                                                     isdigit((unsigned char)*(cp1+1))) {
2111                                                         if (*++cp1 == '0') {
2112                                                            const char *cp3 = src;
2113
2114                                                            while (*cp3) {
2115                                                                 *cp2++ = *cp3++;
2116                                                            }
2117                                                         }
2118                                                         else if (toks[toknum =
2119                                                             *cp1 - '1']) {
2120                                                            const char *cp3=tp[toknum];
2121
2122                                                            while (cp3 !=
2123                                                                   te[toknum]) {
2124                                                                 *cp2++ = *cp3++;
2125                                                            }
2126                                                         }
2127                                                 }
2128                                                 else if (*cp1) {
2129                                                         *cp2++ = *cp1++;
2130                                                 }
2131                                         }
2132                                         if (!*cp1) {
2133                                                 fputs(
2134                                                 "nmap: unbalanced brackets.\n",
2135                                                     ttyout);
2136                                                 return (src);
2137                                         }
2138                                         match = 1;
2139                                         cp1--;
2140                                 }
2141                                 if (match) {
2142                                         while (*++cp1 && *cp1 != ']') {
2143                                               if (*cp1 == '\\' && *(cp1 + 1)) {
2144                                                         cp1++;
2145                                               }
2146                                         }
2147                                         if (!*cp1) {
2148                                                 fputs(
2149                                                 "nmap: unbalanced brackets.\n",
2150                                                     ttyout);
2151                                                 return (src);
2152                                         }
2153                                         break;
2154                                 }
2155                                 switch (*++cp1) {
2156                                         case ',':
2157                                                 goto LOOP;
2158                                         case ']':
2159                                                 break;
2160                                         default:
2161                                                 cp1--;
2162                                                 goto LOOP;
2163                                 }
2164                                 break;
2165                         case '$':
2166                                 if (isdigit((unsigned char)*(cp1 + 1))) {
2167                                         if (*++cp1 == '0') {
2168                                                 const char *cp3 = src;
2169
2170                                                 while (*cp3) {
2171                                                         *cp2++ = *cp3++;
2172                                                 }
2173                                         }
2174                                         else if (toks[toknum = *cp1 - '1']) {
2175                                                 const char *cp3 = tp[toknum];
2176
2177                                                 while (cp3 != te[toknum]) {
2178                                                         *cp2++ = *cp3++;
2179                                                 }
2180                                         }
2181                                         break;
2182                                 }
2183                                 /* intentional drop through */
2184                         default:
2185                                 *cp2++ = *cp1;
2186                                 break;
2187                 }
2188                 cp1++;
2189         }
2190         *cp2 = '\0';
2191         return *dst ? dst : src;
2192 }
2193
2194 void
2195 setpassive(int argc, char *argv[])
2196 {
2197
2198         if (argc == 1) {
2199                 passivemode = !passivemode;
2200                 activefallback = passivemode;
2201         } else if (argc != 2) {
2202  passiveusage:
2203                 UPRINTF("usage: %s [ on | off | auto ]\n", argv[0]);
2204                 code = -1;
2205                 return;
2206         } else if (strcasecmp(argv[1], "on") == 0) {
2207                 passivemode = 1;
2208                 activefallback = 0;
2209         } else if (strcasecmp(argv[1], "off") == 0) {
2210                 passivemode = 0;
2211                 activefallback = 0;
2212         } else if (strcasecmp(argv[1], "auto") == 0) {
2213                 passivemode = 1;
2214                 activefallback = 1;
2215         } else
2216                 goto passiveusage;
2217         fprintf(ttyout, "Passive mode: %s; fallback to active mode: %s.\n",
2218             onoff(passivemode), onoff(activefallback));
2219         code = passivemode;
2220 }
2221
2222
2223 void
2224 setepsv4(int argc, char *argv[])
2225 {
2226         code = togglevar(argc, argv, &epsv4,
2227             verbose ? "EPSV/EPRT on IPv4" : NULL);
2228         epsv4bad = 0;
2229 }
2230
2231 void
2232 setepsv6(int argc, char *argv[])
2233 {
2234         code = togglevar(argc, argv, &epsv6,
2235             verbose ? "EPSV/EPRT on IPv6" : NULL);
2236         epsv6bad = 0;
2237 }
2238
2239 void
2240 setepsv(int argc, char*argv[])
2241 {
2242         setepsv4(argc,argv);
2243         setepsv6(argc,argv);
2244 }
2245
2246 void
2247 setsunique(int argc, char *argv[])
2248 {
2249
2250         code = togglevar(argc, argv, &sunique, "Store unique");
2251 }
2252
2253 void
2254 setrunique(int argc, char *argv[])
2255 {
2256
2257         code = togglevar(argc, argv, &runique, "Receive unique");
2258 }
2259
2260 int
2261 parserate(int argc, char *argv[], int cmdlineopt)
2262 {
2263         int dir, max, incr, showonly;
2264         sigfunc oldusr1, oldusr2;
2265
2266         if (argc > 4 || (argc < (cmdlineopt ? 3 : 2))) {
2267  usage:
2268                 if (cmdlineopt)
2269                         UPRINTF(
2270         "usage: %s (all|get|put),maximum-bytes[,increment-bytes]]\n",
2271                             argv[0]);
2272                 else
2273                         UPRINTF(
2274         "usage: %s (all|get|put) [maximum-bytes [increment-bytes]]\n",
2275                             argv[0]);
2276                 return -1;
2277         }
2278         dir = max = incr = showonly = 0;
2279 #define RATE_GET        1
2280 #define RATE_PUT        2
2281 #define RATE_ALL        (RATE_GET | RATE_PUT)
2282
2283         if (strcasecmp(argv[1], "all") == 0)
2284                 dir = RATE_ALL;
2285         else if (strcasecmp(argv[1], "get") == 0)
2286                 dir = RATE_GET;
2287         else if (strcasecmp(argv[1], "put") == 0)
2288                 dir = RATE_PUT;
2289         else
2290                 goto usage;
2291
2292         if (argc >= 3) {
2293                 if ((max = strsuftoi(argv[2])) < 0)
2294                         goto usage;
2295         } else
2296                 showonly = 1;
2297
2298         if (argc == 4) {
2299                 if ((incr = strsuftoi(argv[3])) <= 0)
2300                         goto usage;
2301         } else
2302                 incr = DEFAULTINCR;
2303
2304         oldusr1 = xsignal(SIGUSR1, SIG_IGN);
2305         oldusr2 = xsignal(SIGUSR2, SIG_IGN);
2306         if (dir & RATE_GET) {
2307                 if (!showonly) {
2308                         rate_get = max;
2309                         rate_get_incr = incr;
2310                 }
2311                 if (!cmdlineopt || verbose)
2312                         fprintf(ttyout,
2313                 "Get transfer rate throttle: %s; maximum: %d; increment %d.\n",
2314                             onoff(rate_get), rate_get, rate_get_incr);
2315         }
2316         if (dir & RATE_PUT) {
2317                 if (!showonly) {
2318                         rate_put = max;
2319                         rate_put_incr = incr;
2320                 }
2321                 if (!cmdlineopt || verbose)
2322                         fprintf(ttyout,
2323                 "Put transfer rate throttle: %s; maximum: %d; increment %d.\n",
2324                             onoff(rate_put), rate_put, rate_put_incr);
2325         }
2326         (void)xsignal(SIGUSR1, oldusr1);
2327         (void)xsignal(SIGUSR2, oldusr2);
2328         return 0;
2329 }
2330
2331 void
2332 setrate(int argc, char *argv[])
2333 {
2334
2335         code = parserate(argc, argv, 0);
2336 }
2337
2338 /* change directory to parent directory */
2339 void
2340 cdup(int argc, char *argv[])
2341 {
2342         int r;
2343
2344         if (argc == 0) {
2345                 UPRINTF("usage: %s\n", argv[0]);
2346                 code = -1;
2347                 return;
2348         }
2349         r = command("CDUP");
2350         if (r == ERROR && code == 500) {
2351                 if (verbose)
2352                         fputs("CDUP command not recognized, trying XCUP.\n",
2353                             ttyout);
2354                 r = command("XCUP");
2355         }
2356         if (r == COMPLETE) {
2357                 dirchange = 1;
2358                 updateremotecwd();
2359         }
2360 }
2361
2362 /*
2363  * Restart transfer at specific point
2364  */
2365 void
2366 restart(int argc, char *argv[])
2367 {
2368
2369         if (argc == 0 || argc > 2) {
2370                 UPRINTF("usage: %s [restart-point]\n", argv[0]);
2371                 code = -1;
2372                 return;
2373         }
2374         if (! features[FEAT_REST_STREAM]) {
2375                 fprintf(ttyout,
2376                     "Restart is not supported by the remote server.\n");
2377                 return;
2378         }
2379         if (argc == 2) {
2380                 off_t rp;
2381                 char *ep;
2382
2383                 rp = STRTOLL(argv[1], &ep, 10);
2384                 if (rp < 0 || *ep != '\0')
2385                         fprintf(ttyout, "restart: Invalid offset `%s'\n",
2386                             argv[1]);
2387                 else
2388                         restart_point = rp;
2389         }
2390         if (restart_point == 0)
2391                 fputs("No restart point defined.\n", ttyout);
2392         else
2393                 fprintf(ttyout,
2394                     "Restarting at " LLF " for next get, put or append\n",
2395                     (LLT)restart_point);
2396 }
2397
2398 /*
2399  * Show remote system type
2400  */
2401 void
2402 syst(int argc, char *argv[])
2403 {
2404         int oldverbose = verbose;
2405
2406         if (argc == 0) {
2407                 UPRINTF("usage: %s\n", argv[0]);
2408                 code = -1;
2409                 return;
2410         }
2411         verbose = 1;    /* If we aren't verbose, this doesn't do anything! */
2412         (void)command("SYST");
2413         verbose = oldverbose;
2414 }
2415
2416 void
2417 macdef(int argc, char *argv[])
2418 {
2419         char *tmp;
2420         int c;
2421
2422         if (argc == 0)
2423                 goto usage;
2424         if (macnum == 16) {
2425                 fputs("Limit of 16 macros have already been defined.\n",
2426                     ttyout);
2427                 code = -1;
2428                 return;
2429         }
2430         if ((argc < 2 && !another(&argc, &argv, "macro name")) || argc > 2) {
2431  usage:
2432                 UPRINTF("usage: %s macro_name\n", argv[0]);
2433                 code = -1;
2434                 return;
2435         }
2436         if (interactive)
2437                 fputs(
2438                 "Enter macro line by line, terminating it with a null line.\n",
2439                     ttyout);
2440         (void)strlcpy(macros[macnum].mac_name, argv[1],
2441             sizeof(macros[macnum].mac_name));
2442         if (macnum == 0)
2443                 macros[macnum].mac_start = macbuf;
2444         else
2445                 macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
2446         tmp = macros[macnum].mac_start;
2447         while (tmp != macbuf+4096) {
2448                 if ((c = getchar()) == EOF) {
2449                         fputs("macdef: end of file encountered.\n", ttyout);
2450                         code = -1;
2451                         return;
2452                 }
2453                 if ((*tmp = c) == '\n') {
2454                         if (tmp == macros[macnum].mac_start) {
2455                                 macros[macnum++].mac_end = tmp;
2456                                 code = 0;
2457                                 return;
2458                         }
2459                         if (*(tmp-1) == '\0') {
2460                                 macros[macnum++].mac_end = tmp - 1;
2461                                 code = 0;
2462                                 return;
2463                         }
2464                         *tmp = '\0';
2465                 }
2466                 tmp++;
2467         }
2468         while (1) {
2469                 while ((c = getchar()) != '\n' && c != EOF)
2470                         /* LOOP */;
2471                 if (c == EOF || getchar() == '\n') {
2472                         fputs("Macro not defined - 4K buffer exceeded.\n",
2473                             ttyout);
2474                         code = -1;
2475                         return;
2476                 }
2477         }
2478 }
2479
2480 /*
2481  * Get size of file on remote machine
2482  */
2483 void
2484 sizecmd(int argc, char *argv[])
2485 {
2486         off_t size;
2487
2488         if (argc == 0 || argc > 2 ||
2489             (argc == 1 && !another(&argc, &argv, "remote-file"))) {
2490                 UPRINTF("usage: %s remote-file\n", argv[0]);
2491                 code = -1;
2492                 return;
2493         }
2494         size = remotesize(argv[1], 1);
2495         if (size != -1)
2496                 fprintf(ttyout,
2497                     "%s\t" LLF "\n", argv[1], (LLT)size);
2498         code = (size > 0);
2499 }
2500
2501 /*
2502  * Get last modification time of file on remote machine
2503  */
2504 void
2505 modtime(int argc, char *argv[])
2506 {
2507         time_t mtime;
2508
2509         if (argc == 0 || argc > 2 ||
2510             (argc == 1 && !another(&argc, &argv, "remote-file"))) {
2511                 UPRINTF("usage: %s remote-file\n", argv[0]);
2512                 code = -1;
2513                 return;
2514         }
2515         mtime = remotemodtime(argv[1], 1);
2516         if (mtime != -1)
2517                 fprintf(ttyout, "%s\t%s", argv[1],
2518                     rfc2822time(localtime(&mtime)));
2519         code = (mtime > 0);
2520 }
2521
2522 /*
2523  * Show status on remote machine
2524  */
2525 void
2526 rmtstatus(int argc, char *argv[])
2527 {
2528
2529         if (argc == 0) {
2530                 UPRINTF("usage: %s [remote-file]\n", argv[0]);
2531                 code = -1;
2532                 return;
2533         }
2534         COMMAND_1ARG(argc, argv, "STAT");
2535 }
2536
2537 /*
2538  * Get file if modtime is more recent than current file
2539  */
2540 void
2541 newer(int argc, char *argv[])
2542 {
2543
2544         if (getit(argc, argv, -1, "w"))
2545                 fprintf(ttyout,
2546                     "Local file \"%s\" is newer than remote file \"%s\".\n",
2547                     argv[2], argv[1]);
2548 }
2549
2550 /*
2551  * Display one local file through $PAGER.
2552  */
2553 void
2554 lpage(int argc, char *argv[])
2555 {
2556         size_t len;
2557         const char *p;
2558         char *pager, *locfile;
2559
2560         if (argc == 0 || argc > 2 ||
2561             (argc == 1 && !another(&argc, &argv, "local-file"))) {
2562                 UPRINTF("usage: %s local-file\n", argv[0]);
2563                 code = -1;
2564                 return;
2565         }
2566         if ((locfile = globulize(argv[1])) == NULL) {
2567                 code = -1;
2568                 return;
2569         }
2570         p = getoptionvalue("pager");
2571         if (EMPTYSTRING(p))
2572                 p = DEFAULTPAGER;
2573         len = strlen(p) + strlen(locfile) + 2;
2574         pager = ftp_malloc(len);
2575         (void)strlcpy(pager, p,         len);
2576         (void)strlcat(pager, " ",       len);
2577         (void)strlcat(pager, locfile,   len);
2578         system(pager);
2579         code = 0;
2580         (void)free(pager);
2581         (void)free(locfile);
2582 }
2583
2584 /*
2585  * Display one remote file through $PAGER.
2586  */
2587 void
2588 page(int argc, char *argv[])
2589 {
2590         int ohash, orestart_point, overbose;
2591         size_t len;
2592         const char *p;
2593         char *pager;
2594
2595         if (argc == 0 || argc > 2 ||
2596             (argc == 1 && !another(&argc, &argv, "remote-file"))) {
2597                 UPRINTF("usage: %s remote-file\n", argv[0]);
2598                 code = -1;
2599                 return;
2600         }
2601         p = getoptionvalue("pager");
2602         if (EMPTYSTRING(p))
2603                 p = DEFAULTPAGER;
2604         len = strlen(p) + 2;
2605         pager = ftp_malloc(len);
2606         pager[0] = '|';
2607         (void)strlcpy(pager + 1, p, len - 1);
2608
2609         ohash = hash;
2610         orestart_point = restart_point;
2611         overbose = verbose;
2612         hash = restart_point = verbose = 0;
2613         recvrequest("RETR", pager, argv[1], "r+", 1, 0);
2614         hash = ohash;
2615         restart_point = orestart_point;
2616         verbose = overbose;
2617         (void)free(pager);
2618 }
2619
2620 /*
2621  * Set the socket send or receive buffer size.
2622  */
2623 void
2624 setxferbuf(int argc, char *argv[])
2625 {
2626         int size, dir;
2627
2628         if (argc != 2) {
2629  usage:
2630                 UPRINTF("usage: %s size\n", argv[0]);
2631                 code = -1;
2632                 return;
2633         }
2634         if (strcasecmp(argv[0], "sndbuf") == 0)
2635                 dir = RATE_PUT;
2636         else if (strcasecmp(argv[0], "rcvbuf") == 0)
2637                 dir = RATE_GET;
2638         else if (strcasecmp(argv[0], "xferbuf") == 0)
2639                 dir = RATE_ALL;
2640         else
2641                 goto usage;
2642
2643         if ((size = strsuftoi(argv[1])) == -1)
2644                 goto usage;
2645
2646         if (size == 0) {
2647                 fprintf(ttyout, "%s: size must be positive.\n", argv[0]);
2648                 goto usage;
2649         }
2650
2651         if (dir & RATE_PUT)
2652                 sndbuf_size = size;
2653         if (dir & RATE_GET)
2654                 rcvbuf_size = size;
2655         fprintf(ttyout, "Socket buffer sizes: send %d, receive %d.\n",
2656             sndbuf_size, rcvbuf_size);
2657         code = 0;
2658 }
2659
2660 /*
2661  * Set or display options (defaults are provided by various env vars)
2662  */
2663 void
2664 setoption(int argc, char *argv[])
2665 {
2666         struct option *o;
2667
2668         code = -1;
2669         if (argc == 0 || (argc != 1 && argc != 3)) {
2670                 UPRINTF("usage: %s [option value]\n", argv[0]);
2671                 return;
2672         }
2673
2674 #define OPTIONINDENT ((int) sizeof("http_proxy"))
2675         if (argc == 1) {
2676                 for (o = optiontab; o->name != NULL; o++) {
2677                         fprintf(ttyout, "%-*s\t%s\n", OPTIONINDENT,
2678                             o->name, o->value ? o->value : "");
2679                 }
2680         } else {
2681                 set_option(argv[1], argv[2], 1);
2682         }
2683         code = 0;
2684 }
2685
2686 void
2687 set_option(const char * option, const char * value, int doverbose)
2688 {
2689         struct option *o;
2690
2691         o = getoption(option);
2692         if (o == NULL) {
2693                 fprintf(ttyout, "No such option `%s'.\n", option);
2694                 return;
2695         }
2696         FREEPTR(o->value);
2697         o->value = ftp_strdup(value);
2698         if (verbose && doverbose)
2699                 fprintf(ttyout, "Setting `%s' to `%s'.\n",
2700                     o->name, o->value);
2701 }
2702
2703 /*
2704  * Unset an option
2705  */
2706 void
2707 unsetoption(int argc, char *argv[])
2708 {
2709         struct option *o;
2710
2711         code = -1;
2712         if (argc == 0 || argc != 2) {
2713                 UPRINTF("usage: %s option\n", argv[0]);
2714                 return;
2715         }
2716
2717         o = getoption(argv[1]);
2718         if (o == NULL) {
2719                 fprintf(ttyout, "No such option `%s'.\n", argv[1]);
2720                 return;
2721         }
2722         FREEPTR(o->value);
2723         fprintf(ttyout, "Unsetting `%s'.\n", o->name);
2724         code = 0;
2725 }
2726
2727 /*
2728  * Display features supported by the remote host.
2729  */
2730 void
2731 feat(int argc, char *argv[])
2732 {
2733         int oldverbose = verbose;
2734
2735         if (argc == 0) {
2736                 UPRINTF("usage: %s\n", argv[0]);
2737                 code = -1;
2738                 return;
2739         }
2740         if (! features[FEAT_FEAT]) {
2741                 fprintf(ttyout,
2742                     "FEAT is not supported by the remote server.\n");
2743                 return;
2744         }
2745         verbose = 1;    /* If we aren't verbose, this doesn't do anything! */
2746         (void)command("FEAT");
2747         verbose = oldverbose;
2748 }
2749
2750 void
2751 mlst(int argc, char *argv[])
2752 {
2753         int oldverbose = verbose;
2754
2755         if (argc < 1 || argc > 2) {
2756                 UPRINTF("usage: %s [remote-path]\n", argv[0]);
2757                 code = -1;
2758                 return;
2759         }
2760         if (! features[FEAT_MLST]) {
2761                 fprintf(ttyout,
2762                     "MLST is not supported by the remote server.\n");
2763                 return;
2764         }
2765         verbose = 1;    /* If we aren't verbose, this doesn't do anything! */
2766         COMMAND_1ARG(argc, argv, "MLST");
2767         verbose = oldverbose;
2768 }
2769
2770 void
2771 opts(int argc, char *argv[])
2772 {
2773         int oldverbose = verbose;
2774
2775         if (argc < 2 || argc > 3) {
2776                 UPRINTF("usage: %s command [options]\n", argv[0]);
2777                 code = -1;
2778                 return;
2779         }
2780         if (! features[FEAT_FEAT]) {
2781                 fprintf(ttyout,
2782                     "OPTS is not supported by the remote server.\n");
2783                 return;
2784         }
2785         verbose = 1;    /* If we aren't verbose, this doesn't do anything! */
2786         if (argc == 2)
2787                 command("OPTS %s", argv[1]);
2788         else
2789                 command("OPTS %s %s", argv[1], argv[2]);
2790         verbose = oldverbose;
2791 }