reactos/base/applications/network/ftp/cmds.c

   1 /*
   2  * Copyright (c) 1985, 1989 Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that the above copyright notice and this paragraph are
   7  * duplicated in all such forms and that any documentation,
   8  * advertising materials, and other materials related to such
   9  * distribution and use acknowledge that the software was developed
  10  * by the University of California, Berkeley.  The name of the
  11  * University may not be used to endorse or promote products derived
  12  * from this software without specific prior written permission.
  13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 #ifndef lint
  19 static char sccsid[] = "@(#)cmds.c      5.18 (Berkeley) 4/20/89";
  20 #endif /* not lint */
  21
  22 /*
  23  * FTP User Program -- Command Routines.
  24  */
  25 //#include <sys/param.h>
  26 //#include <sys/wait.h>
  27 #include <sys/stat.h>
  28 #ifndef _WIN32
  29 #include <sys/socket.h>
  30 #include <arpa/ftp.h>
  31 #include <netinet/in.h>
  32 #include <netdb.h>
  33 #else
  34 #include <winsock.h>
  35 #endif
  36
  37 #include <signal.h>
  38 #include <direct.h>
  39 #include <stdio.h>
  40 #include <errno.h>
  41 #include <ctype.h>
  42 #include <time.h>
  43
  44 #include "ftp_var.h"
  45 #include "pathnames.h"
  46 #include "prototypes.h"
  47
  48 extern  char *globerr;
  49 extern  char home[];
  50 extern  char *remglob();
  51 extern  char *getenv();
  52 extern  int allbinary;
  53 extern off_t restart_point;
  54 extern char reply_string[];
  55
  56 const char *mname;
  57 jmp_buf jabort;
  58 const char *dotrans(), *domap();
  59
  60 extern short portnum;
  61 extern char *hostname;
  62 extern int autologin;
  63 /*
  64  * Connect to peer server and
  65  * auto-login, if possible.
  66  */
  67 void setpeer(int argc, const char *argv[])
  68 {
  69         char *host;
  70
  71         if (connected) {
  72                 printf("Already connected to %s, use close first.\n",
  73                         hostname);
  74                 (void) fflush(stdout);
  75                 code = -1;
  76                 return;
  77         }
  78         if (argc < 2) {
  79                 (void) strcat(line, " ");
  80                 printf("(to) ");
  81                 (void) fflush(stdout);
  82                 (void) gets(&line[strlen(line)]);
  83                 makeargv();
  84                 argc = margc;
  85                 argv = margv;
  86         }
  87         if (argc > 3) {
  88                 printf("usage: %s host-name [port]\n", argv[0]);
  89                 (void) fflush(stdout);
  90                 code = -1;
  91                 return;
  92         }
  93         if (argc > 2) {
  94                 portnum = atoi(argv[2]);
  95                 if (portnum <= 0) {
  96                         printf("%s: bad port number-- %s\n", argv[1], argv[2]);
  97                         printf ("usage: %s host-name [port]\n", argv[0]);
  98                         (void) fflush(stdout);
  99                         code = -1;
 100                         return;
 101                 }
 102                 portnum = htons(portnum);
 103         }
 104         host = hookup(argv[1], portnum);
 105         if (host) {
 106 #if defined(unix) && NBBY == 8
 107                 int overbose;
 108 #endif
 109                 connected = 1;
 110                 if (autologin)
 111                         (void) login(argv[1]);
 112
 113 #if defined(unix) && NBBY == 8
 114 /*
 115  * this ifdef is to keep someone form "porting" this to an incompatible
 116  * system and not checking this out. This way they have to think about it.
 117  */
 118                 overbose = verbose;
 119                 if (debug == 0)
 120                         verbose = -1;
 121                 allbinary = 0;
 122                 if (command("SYST") == COMPLETE && overbose) {
 123                         register char *cp, c;
 124                         cp = index(reply_string+4, ' ');
 125                         if (cp == NULL)
 126                                 cp = index(reply_string+4, '\r');
 127                         if (cp) {
 128                                 if (cp[-1] == '.')
 129                                         cp--;
 130                                 c = *cp;
 131                                 *cp = '\0';
 132                         }
 133
 134                         printf("Remote system type is %s.\n",
 135                                 reply_string+4);
 136                         if (cp)
 137                                 *cp = c;
 138                 }
 139                 if (!strncmp(reply_string, "215 UNIX Type: L8", 17)) {
 140                         setbinary();
 141                         /* allbinary = 1; this violates the RFC */
 142                         if (overbose)
 143                             printf("Using %s mode to transfer files.\n",
 144                                 typename);
 145                 } else if (overbose &&
 146                     !strncmp(reply_string, "215 TOPS20", 10)) {
 147                         printf(
 148 "Remember to set tenex mode when transfering binary files from this machine.\n");
 149                 }
 150                 verbose = overbose;
 151 #endif /* unix */
 152         }
 153         (void) fflush(stdout);
 154 }
 155
 156 struct  types {
 157         const char      *t_name;
 158         const char      *t_mode;
 159         int     t_type;
 160         char    *t_arg;
 161 } types[] = {
 162         { "ascii",      "A",    TYPE_A, 0 },
 163         { "binary",     "I",    TYPE_I, 0 },
 164         { "image",      "I",    TYPE_I, 0 },
 165         { "ebcdic",     "E",    TYPE_E, 0 },
 166         { "tenex",      "L",    TYPE_L, bytename },
 167         {0 }
 168 };
 169
 170 /*
 171  * Set transfer type.
 172  */
 173 void settype(argc, argv)
 174         const char *argv[];
 175 {
 176         register struct types *p;
 177         int comret;
 178
 179         if (argc > 2) {
 180                 const char *sep;
 181
 182                 printf("usage: %s [", argv[0]);
 183                 sep = " ";
 184                 for (p = types; p->t_name; p++) {
 185                         printf("%s%s", sep, p->t_name);
 186                         if (*sep == ' ')
 187                                 sep = " | ";
 188                 }
 189                 printf(" ]\n");
 190                 (void) fflush(stdout);
 191                 code = -1;
 192                 return;
 193         }
 194         if (argc < 2) {
 195                 printf("Using %s mode to transfer files.\n", typename);
 196                 (void) fflush(stdout);
 197                 code = 0;
 198                 return;
 199         }
 200         for (p = types; p->t_name; p++)
 201                 if (strcmp(argv[1], p->t_name) == 0)
 202                         break;
 203         if (p->t_name == 0) {
 204                 printf("%s: unknown mode\n", argv[1]);
 205                 (void) fflush(stdout);
 206                 code = -1;
 207                 return;
 208         }
 209         if ((p->t_arg != NULL) && (*(p->t_arg) != '\0'))
 210                 comret = command ("TYPE %s %s", p->t_mode, p->t_arg);
 211         else
 212                 comret = command("TYPE %s", p->t_mode);
 213         if (comret == COMPLETE) {
 214                 (void) strcpy(typename, p->t_name);
 215                 type = p->t_type;
 216         }
 217 }
 218
 219 const char *stype[] = {
 220         "type",
 221         "",
 222         0
 223 };
 224
 225 /*
 226  * Set binary transfer type.
 227  */
 228 /*VARARGS*/
 229 void setbinary()
 230 {
 231         stype[1] = "binary";
 232         settype(2, stype);
 233 }
 234
 235 /*
 236  * Set ascii transfer type.
 237  */
 238 /*VARARGS*/
 239 void setascii()
 240 {
 241         stype[1] = "ascii";
 242         settype(2, stype);
 243 }
 244
 245 /*
 246  * Set tenex transfer type.
 247  */
 248 /*VARARGS*/
 249 void settenex()
 250 {
 251         stype[1] = "tenex";
 252         settype(2, stype);
 253 }
 254
 255 /*
 256  * Set ebcdic transfer type.
 257  */
 258 /*VARARGS*/
 259 void setebcdic()
 260 {
 261         stype[1] = "ebcdic";
 262         settype(2, stype);
 263 }
 264
 265 /*
 266  * Set file transfer mode.
 267  */
 268
 269 /*ARGSUSED*/
 270 void fsetmode(argc, argv)
 271         char *argv[];
 272 {
 273
 274         printf("We only support %s mode, sorry.\n", modename);
 275         (void) fflush(stdout);
 276         code = -1;
 277 }
 278
 279
 280 /*
 281  * Set file transfer format.
 282  */
 283 /*ARGSUSED*/
 284 void setform(argc, argv)
 285         char *argv[];
 286 {
 287
 288         printf("We only support %s format, sorry.\n", formname);
 289         (void) fflush(stdout);
 290         code = -1;
 291 }
 292
 293 /*
 294  * Set file transfer structure.
 295  */
 296 /*ARGSUSED*/
 297 void setstruct(argc, argv)
 298         char *argv[];
 299 {
 300
 301         printf("We only support %s structure, sorry.\n", structname);
 302         (void) fflush(stdout);
 303         code = -1;
 304 }
 305
 306 /*
 307  * Send a single file.
 308  */
 309 void put(argc, argv)
 310         int argc;
 311         const char *argv[];
 312 {
 313         const char *cmd;
 314         int loc = 0;
 315         const char *oldargv1, *oldargv2;
 316
 317         if (argc == 2) {
 318                 argc++;
 319                 argv[2] = argv[1];
 320                 loc++;
 321         }
 322         if (argc < 2) {
 323                 (void) strcat(line, " ");
 324                 printf("(local-file) ");
 325                 (void) fflush(stdout);
 326                 (void) gets(&line[strlen(line)]);
 327                 makeargv();
 328                 argc = margc;
 329                 argv = margv;
 330         }
 331         if (argc < 2) {
 332 usage:
 333                 printf("usage:%s local-file remote-file\n", argv[0]);
 334                 (void) fflush(stdout);
 335                 code = -1;
 336                 return;
 337         }
 338         if (argc < 3) {
 339                 (void) strcat(line, " ");
 340                 printf("(remote-file) ");
 341                 (void) fflush(stdout);
 342                 (void) gets(&line[strlen(line)]);
 343                 makeargv();
 344                 argc = margc;
 345                 argv = margv;
 346         }
 347         if (argc < 3)
 348                 goto usage;
 349         oldargv1 = argv[1];
 350         oldargv2 = argv[2];
 351         if (!globulize(&argv[1])) {
 352                 code = -1;
 353                 return;
 354         }
 355         /*
 356          * If "globulize" modifies argv[1], and argv[2] is a copy of
 357          * the old argv[1], make it a copy of the new argv[1].
 358          */
 359         if (argv[1] != oldargv1 && argv[2] == oldargv1) {
 360                 argv[2] = argv[1];
 361         }
 362         cmd = (argv[0][0] == 'a') ? "APPE" : ((sunique) ? "STOU" : "STOR");
 363         if (loc && ntflag) {
 364                 argv[2] = dotrans(argv[2]);
 365         }
 366         if (loc && mapflag) {
 367                 argv[2] = domap(argv[2]);
 368         }
 369         sendrequest(cmd, argv[1], argv[2],
 370             argv[1] != oldargv1 || argv[2] != oldargv2);
 371 }
 372
 373 /*
 374  * Send multiple files.
 375  */
 376 void mput(argc, argv)
 377         const char *argv[];
 378 {
 379         register int i;
 380         int ointer;
 381         extern jmp_buf jabort;
 382         const char *tp;
 383
 384         if (argc < 2) {
 385                 (void) strcat(line, " ");
 386                 printf("(local-files) ");
 387                 (void) fflush(stdout);
 388                 (void) gets(&line[strlen(line)]);
 389                 makeargv();
 390                 argc = margc;
 391                 argv = margv;
 392         }
 393         if (argc < 2) {
 394                 printf("usage:%s local-files\n", argv[0]);
 395                 (void) fflush(stdout);
 396                 code = -1;
 397                 return;
 398         }
 399         mname = argv[0];
 400         mflag = 1;
 401 //      oldintr = signal(SIGINT, mabort);
 402         (void) setjmp(jabort);
 403         if (proxy) {
 404                 char *cp, *tp2, tmpbuf[MAXPATHLEN];
 405
 406                 while ((cp = remglob(argv,0)) != NULL) {
 407                         if (*cp == 0) {
 408                                 mflag = 0;
 409                                 continue;
 410                         }
 411                         if (mflag && confirm(argv[0], cp)) {
 412                                 tp = cp;
 413                                 if (mcase) {
 414                                         while (*tp && !islower(*tp)) {
 415                                                 tp++;
 416                                         }
 417                                         if (!*tp) {
 418                                                 tp = cp;
 419                                                 tp2 = tmpbuf;
 420                                                 while ((*tp2 = *tp)) {
 421                                                      if (isupper(*tp2)) {
 422                                                         *tp2 = 'a' + *tp2 - 'A';
 423                                                      }
 424                                                      tp++;
 425                                                      tp2++;
 426                                                 }
 427                                         }
 428                                         tp = tmpbuf;
 429                                 }
 430                                 if (ntflag) {
 431                                         tp = dotrans(tp);
 432                                 }
 433                                 if (mapflag) {
 434                                         tp = domap(tp);
 435                                 }
 436                                 sendrequest((sunique) ? "STOU" : "STOR",
 437                                     cp, tp, cp != tp || !interactive);
 438                                 if (!mflag && fromatty) {
 439                                         ointer = interactive;
 440                                         interactive = 1;
 441                                         if (confirm("Continue with","mput")) {
 442                                                 mflag++;
 443                                         }
 444                                         interactive = ointer;
 445                                 }
 446                         }
 447                 }
 448 //              (void) signal(SIGINT, oldintr);
 449                 mflag = 0;
 450                 return;
 451         }
 452         for (i = 1; i < argc; i++) {
 453                 register char **cpp, **gargs;
 454
 455                 if (!doglob) {
 456                         if (mflag && confirm(argv[0], argv[i])) {
 457                                 tp = (ntflag) ? dotrans(argv[i]) : argv[i];
 458                                 tp = (mapflag) ? domap(tp) : tp;
 459                                 sendrequest((sunique) ? "STOU" : "STOR",
 460                                     argv[i], tp, tp != argv[i] || !interactive);
 461                                 if (!mflag && fromatty) {
 462                                         ointer = interactive;
 463                                         interactive = 1;
 464                                         if (confirm("Continue with","mput")) {
 465                                                 mflag++;
 466                                         }
 467                                         interactive = ointer;
 468                                 }
 469                         }
 470                         continue;
 471                 }
 472                 gargs = glob(argv[i]);
 473                 if (globerr != NULL) {
 474                         printf("%s\n", globerr);
 475                         (void) fflush(stdout);
 476                         if (gargs) {
 477                                 blkfree(gargs);
 478                                 free((char *)gargs);
 479                         }
 480                         continue;
 481                 }
 482                 for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
 483                         if (mflag && confirm(argv[0], *cpp)) {
 484                                 tp = (ntflag) ? dotrans(*cpp) : *cpp;
 485                                 tp = (mapflag) ? domap(tp) : tp;
 486                                 sendrequest((sunique) ? "STOU" : "STOR",
 487                                     *cpp, tp, *cpp != tp || !interactive);
 488                                 if (!mflag && fromatty) {
 489                                         ointer = interactive;
 490                                         interactive = 1;
 491                                         if (confirm("Continue with","mput")) {
 492                                                 mflag++;
 493                                         }
 494                                         interactive = ointer;
 495                                 }
 496                         }
 497                 }
 498                 if (gargs != NULL) {
 499                         blkfree(gargs);
 500                         free((char *)gargs);
 501                 }
 502         }
 503 //      (void) signal(SIGINT, oldintr);
 504         mflag = 0;
 505 }
 506
 507 void reget(argc, argv)
 508         const char *argv[];
 509 {
 510         (void) getit(argc, argv, 1, "r+w");
 511 }
 512
 513 void get(argc, argv)
 514         const char *argv[];
 515 {
 516         (void) getit(argc, argv, 0, restart_point ? "r+w" : "w" );
 517 }
 518
 519 /*
 520  * Receive one file.
 521  */
 522 int getit(argc, argv, restartit, mode)
 523         const char *argv[];
 524         const char *mode;
 525 {
 526         int loc = 0;
 527         const char *oldargv1, *oldargv2;
 528
 529         if (argc == 2) {
 530                 argc++;
 531                 argv[2] = argv[1];
 532                 loc++;
 533         }
 534         if (argc < 2) {
 535                 (void) strcat(line, " ");
 536                 printf("(remote-file) ");
 537                 (void) fflush(stdout);
 538                 (void) gets(&line[strlen(line)]);
 539                 makeargv();
 540                 argc = margc;
 541                 argv = margv;
 542         }
 543         if (argc < 2) {
 544 usage:
 545                 printf("usage: %s remote-file [ local-file ]\n", argv[0]);
 546                 (void) fflush(stdout);
 547                 code = -1;
 548                 return (0);
 549         }
 550         if (argc < 3) {
 551                 (void) strcat(line, " ");
 552                 printf("(local-file) ");
 553                 (void) fflush(stdout);
 554                 (void) gets(&line[strlen(line)]);
 555                 makeargv();
 556                 argc = margc;
 557                 argv = margv;
 558         }
 559         if (argc < 3)
 560                 goto usage;
 561         oldargv1 = argv[1];
 562         oldargv2 = argv[2];
 563         if (!globulize(&argv[2])) {
 564                 code = -1;
 565                 return (0);
 566         }
 567         if (loc && mcase) {
 568                 const char *tp = argv[1];
 569         char *tp2, tmpbuf[MAXPATHLEN];
 570
 571                 while (*tp && !islower(*tp)) {
 572                         tp++;
 573                 }
 574                 if (!*tp) {
 575                         tp = argv[2];
 576                         tp2 = tmpbuf;
 577                         while ((*tp2 = *tp)) {
 578                                 if (isupper(*tp2)) {
 579                                         *tp2 = 'a' + *tp2 - 'A';
 580                                 }
 581                                 tp++;
 582                                 tp2++;
 583                         }
 584                         argv[2] = tmpbuf;
 585                 }
 586         }
 587         if (loc && ntflag)
 588                 argv[2] = dotrans(argv[2]);
 589         if (loc && mapflag)
 590                 argv[2] = domap(argv[2]);
 591         if (restartit) {
 592                 struct stat stbuf;
 593                 int ret;
 594
 595                 ret = stat(argv[2], &stbuf);
 596                 if (restartit == 1) {
 597                         if (ret < 0) {
 598                                 perror(argv[2]);
 599                                 return (0);
 600                         }
 601                         restart_point = stbuf.st_size;
 602                 } else {
 603                         if (ret == 0) {
 604                                 int overbose;
 605
 606                                 overbose = verbose;
 607                                 if (debug == 0)
 608                                         verbose = -1;
 609                                 if (command("MDTM %s", argv[1]) == COMPLETE) {
 610                                         int yy, mo, day, hour, min, sec;
 611                                         struct tm *tm;
 612                                         verbose = overbose;
 613                                         sscanf(reply_string,
 614                                             "%*s %04d%02d%02d%02d%02d%02d",
 615                                             &yy, &mo, &day, &hour, &min, &sec);
 616                                         tm = gmtime(&stbuf.st_mtime);
 617                                         tm->tm_mon++;
 618                                         if (tm->tm_year > yy%100)
 619                                                 return (1);
 620                                         else if (tm->tm_year == yy%100) {
 621                                                 if (tm->tm_mon > mo)
 622                                                         return (1);
 623                                         } else if (tm->tm_mon == mo) {
 624                                                 if (tm->tm_mday > day)
 625                                                         return (1);
 626                                         } else if (tm->tm_mday == day) {
 627                                                 if (tm->tm_hour > hour)
 628                                                         return (1);
 629                                         } else if (tm->tm_hour == hour) {
 630                                                 if (tm->tm_min > min)
 631                                                         return (1);
 632                                         } else if (tm->tm_min == min) {
 633                                                 if (tm->tm_sec > sec)
 634                                                         return (1);
 635                                         }
 636                                 } else {
 637                                         printf("%s\n", reply_string);
 638                                         (void) fflush(stdout);
 639                                         verbose = overbose;
 640                                         return (0);
 641                                 }
 642                         }
 643                 }
 644         }
 645
 646         recvrequest("RETR", argv[2], argv[1], mode,
 647             argv[1] != oldargv1 || argv[2] != oldargv2);
 648         restart_point = 0;
 649         return (0);
 650 }
 651
 652 #if 0
 653 static void
 654 mabort()
 655 {
 656         int ointer;
 657         extern jmp_buf jabort;
 658
 659         printf("\n");
 660         (void) fflush(stdout);
 661         if (mflag && fromatty) {
 662                 ointer = interactive;
 663                 interactive = 1;
 664                 if (confirm("Continue with", mname)) {
 665                         interactive = ointer;
 666                         longjmp(jabort,0);
 667                 }
 668                 interactive = ointer;
 669         }
 670         mflag = 0;
 671         longjmp(jabort,0);
 672 }
 673 #endif
 674
 675 /*
 676  * Get multiple files.
 677  */
 678 void mget(argc, argv)
 679         const char *argv[];
 680 {
 681         const char *cp, *tp;
 682     char *tp2, tmpbuf[MAXPATHLEN];
 683         int ointer;
 684         extern jmp_buf jabort;
 685
 686         if (argc < 2) {
 687                 (void) strcat(line, " ");
 688                 printf("(remote-files) ");
 689                 (void) fflush(stdout);
 690                 (void) gets(&line[strlen(line)]);
 691                 makeargv();
 692                 argc = margc;
 693                 argv = margv;
 694         }
 695         if (argc < 2) {
 696                 printf("usage:%s remote-files\n", argv[0]);
 697                 (void) fflush(stdout);
 698                 code = -1;
 699                 return;
 700         }
 701         mname = argv[0];
 702         mflag = 1;
 703 //      oldintr = signal(SIGINT,mabort);
 704         (void) setjmp(jabort);
 705         while ((cp = remglob(argv,proxy)) != NULL) {
 706                 if (*cp == '\0') {
 707                         mflag = 0;
 708                         continue;
 709                 }
 710                 if (mflag && confirm(argv[0], cp)) {
 711                         tp = cp;
 712                         if (mcase) {
 713                                 while (*tp && !islower(*tp)) {
 714                                         tp++;
 715                                 }
 716                                 if (!*tp) {
 717                                         tp = cp;
 718                                         tp2 = tmpbuf;
 719                                         while ((*tp2 = *tp)) {
 720                                                 if (isupper(*tp2)) {
 721                                                         *tp2 = 'a' + *tp2 - 'A';
 722                                                 }
 723                                                 tp++;
 724                                                 tp2++;
 725                                         }
 726                                 }
 727                                 tp = tmpbuf;
 728                         }
 729                         if (ntflag) {
 730                                 tp = dotrans(tp);
 731                         }
 732                         if (mapflag) {
 733                                 tp = domap(tp);
 734                         }
 735                         recvrequest("RETR", tp, cp, "w",
 736                             tp != cp || !interactive);
 737                         if (!mflag && fromatty) {
 738                                 ointer = interactive;
 739                                 interactive = 1;
 740                                 if (confirm("Continue with","mget")) {
 741                                         mflag++;
 742                                 }
 743                                 interactive = ointer;
 744                         }
 745                 }
 746         }
 747 //      (void) signal(SIGINT,oldintr);
 748         mflag = 0;
 749 }
 750
 751 char *
 752 remglob(argv,doswitch)
 753         char *argv[];
 754         int doswitch;
 755 {
 756         char temp[16];
 757         static char buf[MAXPATHLEN];
 758         static FILE *ftemp = NULL;
 759         static char **args;
 760         int oldverbose, oldhash;
 761         char *cp;
 762     const char *mode;
 763
 764         if (!mflag) {
 765                 if (!doglob) {
 766                         args = NULL;
 767                 }
 768                 else {
 769                         if (ftemp) {
 770                                 (void) fclose(ftemp);
 771                                 ftemp = NULL;
 772                         }
 773                 }
 774                 return(NULL);
 775         }
 776         if (!doglob) {
 777                 if (args == NULL)
 778                         args = argv;
 779                 if ((cp = *++args) == NULL)
 780                         args = NULL;
 781                 return (cp);
 782         }
 783         if (ftemp == NULL) {
 784                 (void) strcpy(temp, _PATH_TMP);
 785                 (void) mktemp(temp);
 786                 oldverbose = verbose, verbose = 0;
 787                 oldhash = hash, hash = 0;
 788                 if (doswitch) {
 789                         pswitch(!proxy);
 790                 }
 791                 for (mode = "w"; *++argv != NULL; mode = "a")
 792                         recvrequest ("NLST", temp, *argv, mode, 0);
 793                 if (doswitch) {
 794                         pswitch(!proxy);
 795                 }
 796                 verbose = oldverbose; hash = oldhash;
 797                 ftemp = fopen(temp, "r");
 798                 (void) unlink(temp);
 799                 if (ftemp == NULL) {
 800                         printf("can't find list of remote files, oops\n");
 801                         (void) fflush(stdout);
 802                         return (NULL);
 803                 }
 804         }
 805         if (fgets(buf, sizeof (buf), ftemp) == NULL) {
 806                 (void) fclose(ftemp), ftemp = NULL;
 807                 return (NULL);
 808         }
 809         if ((cp = index(buf, '\n')) != NULL)
 810                 *cp = '\0';
 811         return (buf);
 812 }
 813
 814 static const char *
 815 onoff(bool)
 816         int bool;
 817 {
 818
 819         return (bool ? "on" : "off");
 820 }
 821
 822 /*
 823  * Show status.
 824  */
 825 /*ARGSUSED*/
 826 void status(argc, argv)
 827         char *argv[];
 828 {
 829         int i;
 830
 831         if (connected)
 832                 printf("Connected to %s.\n", hostname);
 833         else
 834                 printf("Not connected.\n");
 835         if (!proxy) {
 836                 pswitch(1);
 837                 if (connected) {
 838                         printf("Connected for proxy commands to %s.\n", hostname);
 839                 }
 840                 else {
 841                         printf("No proxy connection.\n");
 842                 }
 843                 pswitch(0);
 844         }
 845         printf("Mode: %s; Type: %s; Form: %s; Structure: %s\n",
 846                 modename, typename, formname, structname);
 847         printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %s\n",
 848                 onoff(verbose), onoff(bell), onoff(interactive),
 849                 onoff(doglob));
 850         printf("Store unique: %s; Receive unique: %s\n", onoff(sunique),
 851                 onoff(runique));
 852         printf("Case: %s; CR stripping: %s\n",onoff(mcase),onoff(crflag));
 853         if (ntflag) {
 854                 printf("Ntrans: (in) %s (out) %s\n", ntin,ntout);
 855         }
 856         else {
 857                 printf("Ntrans: off\n");
 858         }
 859         if (mapflag) {
 860                 printf("Nmap: (in) %s (out) %s\n", mapin, mapout);
 861         }
 862         else {
 863                 printf("Nmap: off\n");
 864         }
 865         printf("Hash mark printing: %s; Use of PORT cmds: %s\n",
 866                 onoff(hash), onoff(sendport));
 867         if (macnum > 0) {
 868                 printf("Macros:\n");
 869                 for (i=0; i<macnum; i++) {
 870                         printf("\t%s\n",macros[i].mac_name);
 871                 }
 872         }
 873         (void) fflush(stdout);
 874         code = 0;
 875 }
 876
 877 /*
 878  * Set beep on cmd completed mode.
 879  */
 880 /*VARARGS*/
 881 void setbell()
 882 {
 883
 884         bell = !bell;
 885         printf("Bell mode %s.\n", onoff(bell));
 886         (void) fflush(stdout);
 887         code = bell;
 888 }
 889
 890 /*
 891  * Turn on packet tracing.
 892  */
 893 /*VARARGS*/
 894 void settrace()
 895 {
 896
 897         trace = !trace;
 898         printf("Packet tracing %s.\n", onoff(trace));
 899         (void) fflush(stdout);
 900         code = trace;
 901 }
 902
 903 /*
 904  * Toggle hash mark printing during transfers.
 905  */
 906 /*VARARGS*/
 907 void sethash()
 908 {
 909
 910         hash = !hash;
 911         printf("Hash mark printing %s", onoff(hash));
 912         code = hash;
 913         if (hash)
 914                 printf(" (%d bytes/hash mark)", 1024);
 915         printf(".\n");
 916         (void) fflush(stdout);
 917 }
 918
 919 /*
 920  * Turn on printing of server echo's.
 921  */
 922 /*VARARGS*/
 923 void setverbose()
 924 {
 925
 926         verbose = !verbose;
 927         printf("Verbose mode %s.\n", onoff(verbose));
 928         (void) fflush(stdout);
 929         code = verbose;
 930 }
 931
 932 /*
 933  * Toggle PORT cmd use before each data connection.
 934  */
 935 /*VARARGS*/
 936 void setport()
 937 {
 938
 939         sendport = !sendport;
 940         printf("Use of PORT cmds %s.\n", onoff(sendport));
 941         (void) fflush(stdout);
 942         code = sendport;
 943 }
 944
 945 /*
 946  * Turn on interactive prompting
 947  * during mget, mput, and mdelete.
 948  */
 949 /*VARARGS*/
 950 void setprompt()
 951 {
 952
 953         interactive = !interactive;
 954         printf("Interactive mode %s.\n", onoff(interactive));
 955         (void) fflush(stdout);
 956         code = interactive;
 957 }
 958
 959 /*
 960  * Toggle metacharacter interpretation
 961  * on local file names.
 962  */
 963 /*VARARGS*/
 964 void setglob()
 965 {
 966
 967         doglob = !doglob;
 968         printf("Globbing %s.\n", onoff(doglob));
 969         (void) fflush(stdout);
 970         code = doglob;
 971 }
 972
 973 /*
 974  * Set debugging mode on/off and/or
 975  * set level of debugging.
 976  */
 977 /*VARARGS*/
 978 void setdebug(argc, argv)
 979         char *argv[];
 980 {
 981         int val;
 982
 983         if (argc > 1) {
 984                 val = atoi(argv[1]);
 985                 if (val < 0) {
 986                         printf("%s: bad debugging value.\n", argv[1]);
 987                         (void) fflush(stdout);
 988                         code = -1;
 989                         return;
 990                 }
 991         } else
 992                 val = !debug;
 993         debug = val;
 994         if (debug)
 995                 options |= SO_DEBUG;
 996         else
 997                 options &= ~SO_DEBUG;
 998         printf("Debugging %s (debug=%d).\n", onoff(debug), debug);
 999         (void) fflush(stdout);
1000         code = debug > 0;
1001 }
1002
1003 /*
1004  * Set current working directory
1005  * on remote machine.
1006  */
1007 void cd(argc, argv)
1008         const char *argv[];
1009 {
1010
1011         if (argc < 2) {
1012                 (void) strcat(line, " ");
1013                 printf("(remote-directory) ");
1014                 (void) fflush(stdout);
1015                 (void) gets(&line[strlen(line)]);
1016                 makeargv();
1017                 argc = margc;
1018                 argv = margv;
1019         }
1020         if (argc < 2) {
1021                 printf("usage:%s remote-directory\n", argv[0]);
1022                 (void) fflush(stdout);
1023                 code = -1;
1024                 return;
1025         }
1026         if (command("CWD %s", argv[1]) == ERROR && code == 500) {
1027                 if (verbose) {
1028                         printf("CWD command not recognized, trying XCWD\n");
1029                         (void) fflush(stdout);
1030                 }
1031                 (void) command("XCWD %s", argv[1]);
1032         }
1033 }
1034
1035 /*
1036  * Set current working directory
1037  * on local machine.
1038  */
1039 void lcd(argc, argv)
1040         const char *argv[];
1041 {
1042         char buf[MAXPATHLEN];
1043
1044         if (argc < 2)
1045                 argc++, argv[1] = home;
1046         if (argc != 2) {
1047                 printf("usage:%s local-directory\n", argv[0]);
1048                 (void) fflush(stdout);
1049                 code = -1;
1050                 return;
1051         }
1052         if (!globulize(&argv[1])) {
1053                 code = -1;
1054                 return;
1055         }
1056         if (chdir(argv[1]) < 0) {
1057                 perror(argv[1]);
1058                 code = -1;
1059                 return;
1060         }
1061         printf("Local directory now %s\n", getcwd(buf,sizeof(buf)));
1062         (void) fflush(stdout);
1063         code = 0;
1064 }
1065
1066 /*
1067  * Delete a single file.
1068  */
1069 void delete(argc, argv)
1070         const char *argv[];
1071 {
1072
1073         if (argc < 2) {
1074                 (void) strcat(line, " ");
1075                 printf("(remote-file) ");
1076                 (void) fflush(stdout);
1077                 (void) gets(&line[strlen(line)]);
1078                 makeargv();
1079                 argc = margc;
1080                 argv = margv;
1081         }
1082         if (argc < 2) {
1083                 printf("usage:%s remote-file\n", argv[0]);
1084                 (void) fflush(stdout);
1085                 code = -1;
1086                 return;
1087         }
1088         (void) command("DELE %s", argv[1]);
1089 }
1090
1091 /*
1092  * Delete multiple files.
1093  */
1094 void mdelete(argc, argv)
1095         const char *argv[];
1096 {
1097         char *cp;
1098         int ointer;
1099         extern jmp_buf jabort;
1100
1101         if (argc < 2) {
1102                 (void) strcat(line, " ");
1103                 printf("(remote-files) ");
1104                 (void) fflush(stdout);
1105                 (void) gets(&line[strlen(line)]);
1106                 makeargv();
1107                 argc = margc;
1108                 argv = margv;
1109         }
1110         if (argc < 2) {
1111                 printf("usage:%s remote-files\n", argv[0]);
1112                 (void) fflush(stdout);
1113                 code = -1;
1114                 return;
1115         }
1116         mname = argv[0];
1117         mflag = 1;
1118 //      oldintr = signal(SIGINT, mabort);
1119         (void) setjmp(jabort);
1120         while ((cp = remglob(argv,0)) != NULL) {
1121                 if (*cp == '\0') {
1122                         mflag = 0;
1123                         continue;
1124                 }
1125                 if (mflag && confirm(argv[0], cp)) {
1126                         (void) command("DELE %s", cp);
1127                         if (!mflag && fromatty) {
1128                                 ointer = interactive;
1129                                 interactive = 1;
1130                                 if (confirm("Continue with", "mdelete")) {
1131                                         mflag++;
1132                                 }
1133                                 interactive = ointer;
1134                         }
1135                 }
1136         }
1137 //      (void) signal(SIGINT, oldintr);
1138         mflag = 0;
1139 }
1140
1141 /*
1142  * Rename a remote file.
1143  */
1144 void renamefile(argc, argv)
1145         const char *argv[];
1146 {
1147
1148         if (argc < 2) {
1149                 (void) strcat(line, " ");
1150                 printf("(from-name) ");
1151                 (void) fflush(stdout);
1152                 (void) gets(&line[strlen(line)]);
1153                 makeargv();
1154                 argc = margc;
1155                 argv = margv;
1156         }
1157         if (argc < 2) {
1158 usage:
1159                 printf("%s from-name to-name\n", argv[0]);
1160                 (void) fflush(stdout);
1161                 code = -1;
1162                 return;
1163         }
1164         if (argc < 3) {
1165                 (void) strcat(line, " ");
1166                 printf("(to-name) ");
1167                 (void) fflush(stdout);
1168                 (void) gets(&line[strlen(line)]);
1169                 makeargv();
1170                 argc = margc;
1171                 argv = margv;
1172         }
1173         if (argc < 3)
1174                 goto usage;
1175         if (command("RNFR %s", argv[1]) == CONTINUE)
1176                 (void) command("RNTO %s", argv[2]);
1177 }
1178
1179 /*
1180  * Get a directory listing
1181  * of remote files.
1182  */
1183 void ls(argc, argv)
1184         const char *argv[];
1185 {
1186         const char *cmd;
1187
1188         if (argc < 2)
1189                 argc++, argv[1] = NULL;
1190         if (argc < 3)
1191                 argc++, argv[2] = "-";
1192         if (argc > 3) {
1193                 printf("usage: %s remote-directory local-file\n", argv[0]);
1194                 (void) fflush(stdout);
1195                 code = -1;
1196                 return;
1197         }
1198         cmd = argv[0][0] == 'n' ? "NLST" : "LIST";
1199 //      cmd = argv[0][0] == 'n' ? "NLST -CF" : "NLST -CF";
1200         if (strcmp(argv[2], "-") && !globulize(&argv[2])) {
1201                 code = -1;
1202                 return;
1203         }
1204         if (strcmp(argv[2], "-") && *argv[2] != '|')
1205                 if (!globulize(&argv[2]) || !confirm("output to local-file:", argv[2])) {
1206                         code = -1;
1207                         return;
1208         }
1209         recvrequest(cmd, argv[2], argv[1], "w", 0);
1210 }
1211
1212 /*
1213  * Get a directory listing
1214  * of multiple remote files.
1215  */
1216 void mls(argc, argv)
1217         const char *argv[];
1218 {
1219         const char *cmd, *dest;
1220         char mode[1];
1221         int ointer, i;
1222         extern jmp_buf jabort;
1223
1224         if (argc < 2) {
1225                 (void) strcat(line, " ");
1226                 printf("(remote-files) ");
1227                 (void) fflush(stdout);
1228                 (void) gets(&line[strlen(line)]);
1229                 makeargv();
1230                 argc = margc;
1231                 argv = margv;
1232         }
1233         if (argc < 3) {
1234                 (void) strcat(line, " ");
1235                 printf("(local-file) ");
1236                 (void) fflush(stdout);
1237                 (void) gets(&line[strlen(line)]);
1238                 makeargv();
1239                 argc = margc;
1240                 argv = margv;
1241         }
1242         if (argc < 3) {
1243                 printf("usage:%s remote-files local-file\n", argv[0]);
1244                 (void) fflush(stdout);
1245                 code = -1;
1246                 return;
1247         }
1248         dest = argv[argc - 1];
1249         argv[argc - 1] = NULL;
1250         if (strcmp(dest, "-") && *dest != '|')
1251                 if (!globulize(&dest) || !confirm("output to local-file:", dest)) {
1252                         code = -1;
1253                         return;
1254         }
1255         cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
1256         mname = argv[0];
1257         mflag = 1;
1258 //      oldintr = signal(SIGINT, mabort);
1259         (void) setjmp(jabort);
1260         for (i = 1; mflag && i < argc-1; ++i) {
1261                 *mode = (i == 1) ? 'w' : 'a';
1262                 recvrequest(cmd, dest, argv[i], mode, 0);
1263                 if (!mflag && fromatty) {
1264                         ointer = interactive;
1265                         interactive = 1;
1266                         if (confirm("Continue with", argv[0])) {
1267                                 mflag ++;
1268                         }
1269                         interactive = ointer;
1270                 }
1271         }
1272 //      (void) signal(SIGINT, oldintr);
1273         mflag = 0;
1274 }
1275
1276 /*
1277  * Do a shell escape
1278  */
1279 /*ARGSUSED*/
1280 void shell(argc, argv)
1281         char *argv[];
1282 {
1283 #if 0
1284         int pid;
1285         sig_t (*old1)(), (*old2)();
1286         char shellnam[40], *shell, *namep;
1287         union wait status;
1288
1289         old1 = signal (SIGINT, SIG_IGN);
1290         old2 = signal (SIGQUIT, SIG_IGN);
1291         if ((pid = fork()) == 0) {
1292                 for (pid = 3; pid < 20; pid++)
1293                         (void) close(pid);
1294                 (void) signal(SIGINT, SIG_DFL);
1295                 (void) signal(SIGQUIT, SIG_DFL);
1296                 shell = getenv("SHELL");
1297                 if (shell == NULL)
1298                         shell = _PATH_BSHELL;
1299                 namep = rindex(shell,'/');
1300                 if (namep == NULL)
1301                         namep = shell;
1302                 (void) strcpy(shellnam,"-");
1303                 (void) strcat(shellnam, ++namep);
1304                 if (strcmp(namep, "sh") != 0)
1305                         shellnam[0] = '+';
1306                 if (debug) {
1307                         printf ("%s\n", shell);
1308                         (void) fflush (stdout);
1309                 }
1310                 if (argc > 1) {
1311                         execl(shell,shellnam,"-c",altarg,(char *)0);
1312                 }
1313                 else {
1314                         execl(shell,shellnam,(char *)0);
1315                 }
1316                 perror(shell);
1317                 code = -1;
1318                 exit(1);
1319                 }
1320         if (pid > 0)
1321                 while (wait(&status) != pid)
1322                         ;
1323         (void) signal(SIGINT, old1);
1324         (void) signal(SIGQUIT, old2);
1325         if (pid == -1) {
1326                 perror("Try again later");
1327                 code = -1;
1328         }
1329         else {
1330                 code = 0;
1331         }
1332 #endif
1333
1334     char *              AppName;
1335     char                ShellCmd[MAX_PATH];
1336     char                CmdLine[MAX_PATH];
1337     int                 i;
1338     PROCESS_INFORMATION ProcessInformation;
1339     BOOL                Result;
1340     STARTUPINFO         StartupInfo;
1341     char                ShellName[] = "COMSPEC";
1342     int                 NumBytes;
1343
1344     NumBytes = GetEnvironmentVariable( ShellName, ShellCmd, MAX_PATH);
1345
1346     if (NumBytes == 0)
1347     {
1348         return;
1349     }
1350
1351     AppName = ShellCmd;
1352     strcpy( CmdLine, ShellCmd );
1353
1354     if (argc > 1)
1355     {
1356         strncat(CmdLine, " /C", MAX_PATH);
1357     }
1358
1359     for (i=1; i<argc; i++)
1360     {
1361         strncat(CmdLine, " ", MAX_PATH);
1362         strncat(CmdLine, argv[i], MAX_PATH);
1363     }
1364
1365     StartupInfo.cb          = sizeof( StartupInfo );
1366     StartupInfo.lpReserved  = NULL;
1367     StartupInfo.lpDesktop   = NULL;
1368     StartupInfo.lpTitle     = NULL;
1369     StartupInfo.dwX         = 0;
1370     StartupInfo.dwY         = 0;
1371     StartupInfo.dwXSize     = 0;
1372     StartupInfo.dwYSize     = 0;
1373     StartupInfo.dwFlags     = 0;
1374     StartupInfo.wShowWindow = 0;
1375     StartupInfo.cbReserved2 = 0;
1376     StartupInfo.lpReserved2 = NULL;
1377
1378     Result = CreateProcess( AppName,                // cmd name
1379                             CmdLine,                // cmd line arguments
1380                             NULL,
1381                             NULL,                   // security attributes
1382                             FALSE,                  // inherit flags
1383                             0,                      // Creation flags
1384                             NULL,                   // Environment
1385                             NULL,                   // Current directory
1386                             &StartupInfo,           // Startup info structure
1387                             &ProcessInformation);   // processInfo structure
1388
1389     if (Result)
1390     {
1391         WaitForSingleObject( ProcessInformation.hProcess, 0xffffffff);
1392
1393         CloseHandle( ProcessInformation.hProcess);
1394     }
1395 }
1396
1397 /*
1398  * Send new user information (re-login)
1399  */
1400 void user(argc, argv)
1401         int argc;
1402         const char **argv;
1403 {
1404         char acct[80], *getpass();
1405         int n, aflag = 0;
1406
1407         if (argc < 2) {
1408                 (void) strcat(line, " ");
1409                 printf("(username) ");
1410                 (void) fflush(stdout);
1411                 (void) gets(&line[strlen(line)]);
1412                 makeargv();
1413                 argc = margc;
1414                 argv = margv;
1415         }
1416         if (argc > 4) {
1417                 printf("usage: %s username [password] [account]\n", argv[0]);
1418                 (void) fflush(stdout);
1419                 code = -1;
1420                 return;
1421         }
1422         n = command("USER %s", argv[1]);
1423         if (n == CONTINUE) {
1424                 if (argc < 3 )
1425                         argv[2] = getpass("Password: "), argc++;
1426                 n = command("PASS %s", argv[2]);
1427         }
1428         if (n == CONTINUE) {
1429                 if (argc < 4) {
1430                         printf("Account: "); (void) fflush(stdout);
1431                         (void) fflush(stdout);
1432                         (void) fgets(acct, sizeof(acct) - 1, stdin);
1433                         acct[strlen(acct) - 1] = '\0';
1434                         argv[3] = acct; argc++;
1435                 }
1436                 n = command("ACCT %s", argv[3]);
1437                 aflag++;
1438         }
1439         if (n != COMPLETE) {
1440                 fprintf(stdout, "Login failed.\n");
1441                 (void) fflush(stdout);
1442                 return;
1443         }
1444         if (!aflag && argc == 4) {
1445                 (void) command("ACCT %s", argv[3]);
1446         }
1447 }
1448
1449 /*
1450  * Print working directory.
1451  */
1452 /*VARARGS*/
1453 void pwd()
1454 {
1455         int oldverbose = verbose;
1456
1457         /*
1458          * If we aren't verbose, this doesn't do anything!
1459          */
1460         verbose = 1;
1461         if (command("PWD") == ERROR && code == 500) {
1462                 printf("PWD command not recognized, trying XPWD\n");
1463                 (void) fflush(stdout);
1464                 (void) command("XPWD");
1465         }
1466         verbose = oldverbose;
1467 }
1468
1469 /*
1470  * Make a directory.
1471  */
1472 void makedir(argc, argv)
1473         const char *argv[];
1474 {
1475
1476         if (argc < 2) {
1477                 (void) strcat(line, " ");
1478                 printf("(directory-name) ");
1479                 (void) fflush(stdout);
1480                 (void) gets(&line[strlen(line)]);
1481                 makeargv();
1482                 argc = margc;
1483                 argv = margv;
1484         }
1485         if (argc < 2) {
1486                 printf("usage: %s directory-name\n", argv[0]);
1487                 (void) fflush(stdout);
1488                 code = -1;
1489                 return;
1490         }
1491         if (command("MKD %s", argv[1]) == ERROR && code == 500) {
1492                 if (verbose) {
1493                         printf("MKD command not recognized, trying XMKD\n");
1494                         (void) fflush(stdout);
1495                 }
1496                 (void) command("XMKD %s", argv[1]);
1497         }
1498 }
1499
1500 /*
1501  * Remove a directory.
1502  */
1503 void removedir(argc, argv)
1504         const char *argv[];
1505 {
1506
1507         if (argc < 2) {
1508                 (void) strcat(line, " ");
1509                 printf("(directory-name) ");
1510                 (void) fflush(stdout);
1511                 (void) gets(&line[strlen(line)]);
1512                 makeargv();
1513                 argc = margc;
1514                 argv = margv;
1515         }
1516         if (argc < 2) {
1517                 printf("usage: %s directory-name\n", argv[0]);
1518                 (void) fflush(stdout);
1519                 code = -1;
1520                 return;
1521         }
1522         if (command("RMD %s", argv[1]) == ERROR && code == 500) {
1523                 if (verbose) {
1524                         printf("RMD command not recognized, trying XRMD\n");
1525                         (void) fflush(stdout);
1526                 }
1527                 (void) command("XRMD %s", argv[1]);
1528         }
1529 }
1530
1531 /*
1532  * Send a line, verbatim, to the remote machine.
1533  */
1534 void quote(argc, argv)
1535         const char *argv[];
1536 {
1537         int i;
1538         char buf[BUFSIZ];
1539
1540         if (argc < 2) {
1541                 (void) strcat(line, " ");
1542                 printf("(command line to send) ");
1543                 (void) fflush(stdout);
1544                 (void) gets(&line[strlen(line)]);
1545                 makeargv();
1546                 argc = margc;
1547                 argv = margv;
1548         }
1549         if (argc < 2) {
1550                 printf("usage: %s line-to-send\n", argv[0]);
1551                 (void) fflush(stdout);
1552                 code = -1;
1553                 return;
1554         }
1555         (void) strcpy(buf, argv[1]);
1556         for (i = 2; i < argc; i++) {
1557                 (void) strcat(buf, " ");
1558                 (void) strcat(buf, argv[i]);
1559         }
1560         if (command(buf) == PRELIM) {
1561                 while (getreply(0) == PRELIM);
1562         }
1563 }
1564
1565 /*
1566  * Send a SITE command to the remote machine.  The line
1567  * is sent almost verbatim to the remote machine, the
1568  * first argument is changed to SITE.
1569  */
1570
1571 void site(argc, argv)
1572         const char *argv[];
1573 {
1574         int i;
1575         char buf[BUFSIZ];
1576
1577         if (argc < 2) {
1578                 (void) strcat(line, " ");
1579                 printf("(arguments to SITE command) ");
1580                 (void) fflush(stdout);
1581                 (void) gets(&line[strlen(line)]);
1582                 makeargv();
1583                 argc = margc;
1584                 argv = margv;
1585         }
1586         if (argc < 2) {
1587                 printf("usage: %s line-to-send\n", argv[0]);
1588                 (void) fflush(stdout);
1589                 code = -1;
1590                 return;
1591         }
1592         (void) strcpy(buf, "SITE ");
1593         (void) strcat(buf, argv[1]);
1594         for (i = 2; i < argc; i++) {
1595                 (void) strcat(buf, " ");
1596                 (void) strcat(buf, argv[i]);
1597         }
1598         if (command(buf) == PRELIM) {
1599                 while (getreply(0) == PRELIM);
1600         }
1601 }
1602
1603 void do_chmod(argc, argv)
1604         const char *argv[];
1605 {
1606         if (argc == 2) {
1607                 printf("usage: %s mode file-name\n", argv[0]);
1608                 (void) fflush(stdout);
1609                 code = -1;
1610                 return;
1611         }
1612         if (argc < 3) {
1613                 (void) strcat(line, " ");
1614                 printf("(mode and file-name) ");
1615                 (void) fflush(stdout);
1616                 (void) gets(&line[strlen(line)]);
1617                 makeargv();
1618                 argc = margc;
1619                 argv = margv;
1620         }
1621         if (argc != 3) {
1622                 printf("usage: %s mode file-name\n", argv[0]);
1623                 (void) fflush(stdout);
1624                 code = -1;
1625                 return;
1626         }
1627         (void)command("SITE CHMOD %s %s", argv[1], argv[2]);
1628 }
1629
1630 void do_umask(argc, argv)
1631         char *argv[];
1632 {
1633         int oldverbose = verbose;
1634
1635         verbose = 1;
1636         (void) command(argc == 1 ? "SITE UMASK" : "SITE UMASK %s", argv[1]);
1637         verbose = oldverbose;
1638 }
1639
1640 void idle(argc, argv)
1641         char *argv[];
1642 {
1643         int oldverbose = verbose;
1644
1645         verbose = 1;
1646         (void) command(argc == 1 ? "SITE IDLE" : "SITE IDLE %s", argv[1]);
1647         verbose = oldverbose;
1648 }
1649
1650 /*
1651  * Ask the other side for help.
1652  */
1653 void rmthelp(argc, argv)
1654         char *argv[];
1655 {
1656         int oldverbose = verbose;
1657
1658         verbose = 1;
1659         (void) command(argc == 1 ? "HELP" : "HELP %s", argv[1]);
1660         verbose = oldverbose;
1661 }
1662
1663 /*
1664  * Terminate session and exit.
1665  */
1666 /*VARARGS*/
1667 void quit()
1668 {
1669
1670         if (connected)
1671                 disconnect();
1672         pswitch(1);
1673         if (connected) {
1674                 disconnect();
1675         }
1676         exit(0);
1677 }
1678
1679 /*
1680  * Terminate session, but don't exit.
1681  */
1682 void disconnect()
1683 {
1684         extern int cout;
1685         extern int data;
1686
1687         if (!connected)
1688                 return;
1689         (void) command("QUIT");
1690         cout = 0;
1691         connected = 0;
1692         data = -1;
1693         if (!proxy) {
1694                 macnum = 0;
1695         }
1696 }
1697
1698 int confirm(cmd, file)
1699         const char *cmd, *file;
1700 {
1701         char line[BUFSIZ];
1702
1703         if (!interactive)
1704                 return (1);
1705         printf("%s %s? ", cmd, file);
1706         (void) fflush(stdout);
1707         (void) gets(line);
1708         return (*line != 'n' && *line != 'N');
1709 }
1710
1711 #if 0
1712 static void fatal(msg)
1713         char *msg;
1714 {
1715
1716         fprintf(stderr, "ftp: %s\n", msg);
1717         exit(1);
1718 }
1719 #endif
1720
1721 /*
1722  * Glob a local file name specification with
1723  * the expectation of a single return value.
1724  * Can't control multiple values being expanded
1725  * from the expression, we return only the first.
1726  */
1727 int globulize(cpp)
1728         const char **cpp;
1729 {
1730         char **globbed;
1731
1732         if (!doglob)
1733                 return (1);
1734         globbed = glob(*cpp);
1735         if (globerr != NULL) {
1736                 printf("%s: %s\n", *cpp, globerr);
1737                 (void) fflush(stdout);
1738                 if (globbed) {
1739                         blkfree(globbed);
1740                         free((char *)globbed);
1741                 }
1742                 return (0);
1743         }
1744         if (globbed) {
1745                 *cpp = *globbed++;
1746                 /* don't waste too much memory */
1747                 if (*globbed) {
1748                         blkfree(globbed);
1749                         free((char *)globbed);
1750                 }
1751         }
1752         return (1);
1753 }
1754
1755 void account(argc,argv)
1756         int argc;
1757         char **argv;
1758 {
1759         char acct[50], *getpass(), *ap;
1760
1761         if (argc > 1) {
1762                 ++argv;
1763                 --argc;
1764                 (void) strncpy(acct,*argv,49);
1765                 acct[49] = '\0';
1766                 while (argc > 1) {
1767                         --argc;
1768                         ++argv;
1769                         (void) strncat(acct,*argv, 49-strlen(acct));
1770                 }
1771                 ap = acct;
1772         }
1773         else {
1774                 ap = getpass("Account:");
1775         }
1776         (void) command("ACCT %s", ap);
1777 }
1778
1779 jmp_buf abortprox;
1780
1781 #if 0
1782 static void
1783 proxabort()
1784 {
1785         extern int proxy;
1786
1787         if (!proxy) {
1788                 pswitch(1);
1789         }
1790         if (connected) {
1791                 proxflag = 1;
1792         }
1793         else {
1794                 proxflag = 0;
1795         }
1796         pswitch(0);
1797         longjmp(abortprox,1);
1798 }
1799 #endif
1800
1801 void doproxy(argc,argv)
1802         int argc;
1803         const char *argv[];
1804 {
1805         register struct cmd *c;
1806         struct cmd *getcmd();
1807 //      extern struct cmd cmdtab[];
1808         extern jmp_buf abortprox;
1809
1810         if (argc < 2) {
1811                 (void) strcat(line, " ");
1812                 printf("(command) ");
1813                 (void) fflush(stdout);
1814                 (void) gets(&line[strlen(line)]);
1815                 makeargv();
1816                 argc = margc;
1817                 argv = margv;
1818         }
1819         if (argc < 2) {
1820                 printf("usage:%s command\n", argv[0]);
1821                 (void) fflush(stdout);
1822                 code = -1;
1823                 return;
1824         }
1825         c = getcmd(argv[1]);
1826         if (c == (struct cmd *) -1) {
1827                 printf("?Ambiguous command\n");
1828                 (void) fflush(stdout);
1829                 code = -1;
1830                 return;
1831         }
1832         if (c == 0) {
1833                 printf("?Invalid command\n");
1834                 (void) fflush(stdout);
1835                 code = -1;
1836                 return;
1837         }
1838         if (!c->c_proxy) {
1839                 printf("?Invalid proxy command\n");
1840                 (void) fflush(stdout);
1841                 code = -1;
1842                 return;
1843         }
1844         if (setjmp(abortprox)) {
1845                 code = -1;
1846                 return;
1847         }
1848 //      oldintr = signal(SIGINT, proxabort);
1849         pswitch(1);
1850         if (c->c_conn && !connected) {
1851                 printf("Not connected\n");
1852                 (void) fflush(stdout);
1853                 pswitch(0);
1854 //              (void) signal(SIGINT, oldintr);
1855                 code = -1;
1856                 return;
1857         }
1858         (*c->c_handler)(argc-1, argv+1);
1859         if (connected) {
1860                 proxflag = 1;
1861         }
1862         else {
1863                 proxflag = 0;
1864         }
1865         pswitch(0);
1866 //      (void) signal(SIGINT, oldintr);
1867 }
1868
1869 void setcase()
1870 {
1871         mcase = !mcase;
1872         printf("Case mapping %s.\n", onoff(mcase));
1873         (void) fflush(stdout);
1874         code = mcase;
1875 }
1876
1877 void setcr()
1878 {
1879         crflag = !crflag;
1880         printf("Carriage Return stripping %s.\n", onoff(crflag));
1881         (void) fflush(stdout);
1882         code = crflag;
1883 }
1884
1885 void setntrans(argc,argv)
1886         int argc;
1887         char *argv[];
1888 {
1889         if (argc == 1) {
1890                 ntflag = 0;
1891                 printf("Ntrans off.\n");
1892                 (void) fflush(stdout);
1893                 code = ntflag;
1894                 return;
1895         }
1896         ntflag++;
1897         code = ntflag;
1898         (void) strncpy(ntin, argv[1], 16);
1899         ntin[16] = '\0';
1900         if (argc == 2) {
1901                 ntout[0] = '\0';
1902                 return;
1903         }
1904         (void) strncpy(ntout, argv[2], 16);
1905         ntout[16] = '\0';
1906 }
1907
1908 const char *
1909 dotrans(name)
1910         const char *name;
1911 {
1912         static char new[MAXPATHLEN];
1913         const char *cp1;
1914     char *cp2 = new;
1915         register int i, ostop, found;
1916
1917         for (ostop = 0; *(ntout + ostop) && ostop < 16; ostop++);
1918         for (cp1 = name; *cp1; cp1++) {
1919                 found = 0;
1920                 for (i = 0; *(ntin + i) && i < 16; i++) {
1921                         if (*cp1 == *(ntin + i)) {
1922                                 found++;
1923                                 if (i < ostop) {
1924                                         *cp2++ = *(ntout + i);
1925                                 }
1926                                 break;
1927                         }
1928                 }
1929                 if (!found) {
1930                         *cp2++ = *cp1;
1931                 }
1932         }
1933         *cp2 = '\0';
1934         return(new);
1935 }
1936
1937
1938 void
1939 setpassive(argc, argv)
1940   int argc;
1941   char *argv[];
1942 {
1943         passivemode = !passivemode;
1944         printf("Passive mode %s.\n", onoff(passivemode));
1945         (void) fflush(stdout);
1946         code = passivemode;
1947 }
1948
1949 void setnmap(argc, argv)
1950         int argc;
1951         const char *argv[];
1952 {
1953         char *cp;
1954
1955         if (argc == 1) {
1956                 mapflag = 0;
1957                 printf("Nmap off.\n");
1958                 (void) fflush(stdout);
1959                 code = mapflag;
1960                 return;
1961         }
1962         if (argc < 3) {
1963                 (void) strcat(line, " ");
1964                 printf("(mapout) ");
1965                 (void) fflush(stdout);
1966                 (void) gets(&line[strlen(line)]);
1967                 makeargv();
1968                 argc = margc;
1969                 argv = margv;
1970         }
1971         if (argc < 3) {
1972                 printf("Usage: %s [mapin mapout]\n",argv[0]);
1973                 (void) fflush(stdout);
1974                 code = -1;
1975                 return;
1976         }
1977         mapflag = 1;
1978         code = 1;
1979         cp = index(altarg, ' ');
1980         if (proxy) {
1981                 while(*++cp == ' ');
1982                 altarg = cp;
1983                 cp = index(altarg, ' ');
1984         }
1985         *cp = '\0';
1986         (void) strncpy(mapin, altarg, MAXPATHLEN - 1);
1987         while (*++cp == ' ');
1988         (void) strncpy(mapout, cp, MAXPATHLEN - 1);
1989 }
1990
1991 const char *
1992 domap(name)
1993         const char *name;
1994 {
1995         static char new[MAXPATHLEN];
1996         const char *cp1 = name;
1997     char *cpn, *cp2 = mapin;
1998         const char *tp[9], *te[9];
1999         int i, toks[9], toknum = 0, match = 1;
2000
2001         for (i=0; i < 9; ++i) {
2002                 toks[i] = 0;
2003         }
2004         while (match && *cp1 && *cp2) {
2005                 switch (*cp2) {
2006                         case '\\':
2007                                 if (*++cp2 != *cp1) {
2008                                         match = 0;
2009                                 }
2010                                 break;
2011                         case '$':
2012                                 if (*(cp2+1) >= '1' && (*cp2+1) <= '9') {
2013                                         if (*cp1 != *(++cp2+1)) {
2014                                                 toks[toknum = *cp2 - '1']++;
2015                                                 tp[toknum] = cp1;
2016                                                 while (*++cp1 && *(cp2+1)
2017                                                         != *cp1);
2018                                                 te[toknum] = cp1;
2019                                         }
2020                                         cp2++;
2021                                         break;
2022                                 }
2023                                 /* FALLTHROUGH */
2024                         default:
2025                                 if (*cp2 != *cp1) {
2026                                         match = 0;
2027                                 }
2028                                 break;
2029                 }
2030                 if (match && *cp1) {
2031                         cp1++;
2032                 }
2033                 if (match && *cp2) {
2034                         cp2++;
2035                 }
2036         }
2037         if (!match && *cp1) /* last token mismatch */
2038         {
2039                 toks[toknum] = 0;
2040         }
2041
2042         cpn = new;
2043         *cpn = '\0';
2044         cp2 = mapout;
2045         while (*cp2) {
2046                 match = 0;
2047                 switch (*cp2) {
2048                         case '\\':
2049                                 if (*(cp2 + 1)) {
2050                                         *cpn++ = *++cp2;
2051                                 }
2052                                 break;
2053                         case '[':
2054 LOOP:
2055                                 if (*++cp2 == '$' && isdigit(*(cp2+1))) {
2056                                         if (*++cp2 == '0') {
2057                                                 const char *cp3 = name;
2058
2059                                                 while (*cp3) {
2060                                                         *cpn++ = *cp3++;
2061                                                 }
2062                                                 match = 1;
2063                                         }
2064                                         else if (toks[toknum = *cp2 - '1']) {
2065                                                 const char *cp3 = tp[toknum];
2066
2067                                                 while (cp3 != te[toknum]) {
2068                                                         *cpn++ = *cp3++;
2069                                                 }
2070                                                 match = 1;
2071                                         }
2072                                 }
2073                                 else {
2074                                         while (*cp2 && *cp2 != ',' &&
2075                                             *cp2 != ']') {
2076                                                 if (*cp2 == '\\') {
2077                                                         cp2++;
2078                                                 }
2079                                                 else if (*cp2 == '$' &&
2080                                                         isdigit(*(cp2+1))) {
2081                                                         if (*++cp2 == '0') {
2082                                                            const char *cp3 = name;
2083
2084                                                            while (*cp3) {
2085                                                                 *cpn++ = *cp3++;
2086                                                            }
2087                                                         }
2088                                                         else if (toks[toknum =
2089                                                             *cp2 - '1']) {
2090                                                            const char *cp3=tp[toknum];
2091
2092                                                            while (cp3 !=
2093                                                                   te[toknum]) {
2094                                                                 *cpn++ = *cp3++;
2095                                                            }
2096                                                         }
2097                                                 }
2098                                                 else if (*cp2) {
2099                                                         *cpn++ = *cp2++;
2100                                                 }
2101                                         }
2102                                         if (!*cp2) {
2103                                                 printf("nmap: unbalanced brackets\n");
2104                                                 (void) fflush(stdout);
2105                                                 return(name);
2106                                         }
2107                                         match = 1;
2108                                         cp2--;
2109                                 }
2110                                 if (match) {
2111                                         while (*++cp2 && *cp2 != ']') {
2112                                               if (*cp2 == '\\' && *(cp2 + 1)) {
2113                                                         cp2++;
2114                                               }
2115                                         }
2116                                         if (!*cp2) {
2117                                                 printf("nmap: unbalanced brackets\n");
2118                                                 (void) fflush(stdout);
2119                                                 return(name);
2120                                         }
2121                                         break;
2122                                 }
2123                                 switch (*++cp2) {
2124                                         case ',':
2125                                                 goto LOOP;
2126                                         case ']':
2127                                                 break;
2128                                         default:
2129                                                 cp2--;
2130                                                 goto LOOP;
2131                                 }
2132                                 break;
2133                         case '$':
2134                                 if (isdigit(*(cp2 + 1))) {
2135                                         if (*++cp2 == '0') {
2136                                                 const char *cp3 = name;
2137
2138                                                 while (*cp3) {
2139                                                         *cpn++ = *cp3++;
2140                                                 }
2141                                         }
2142                                         else if (toks[toknum = *cp2 - '1']) {
2143                                                 const char *cp3 = tp[toknum];
2144
2145                                                 while (cp3 != te[toknum]) {
2146                                                         *cpn++ = *cp3++;
2147                                                 }
2148                                         }
2149                                         break;
2150                                 }
2151                                 /* intentional drop through */
2152                         default:
2153                                 *cpn++ = *cp2;
2154                                 break;
2155                 }
2156                 cp2++;
2157         }
2158         *cpn = '\0';
2159         if (!*new) {
2160                 return(name);
2161         }
2162         return(new);
2163 }
2164
2165 void setsunique()
2166 {
2167         sunique = !sunique;
2168         printf("Store unique %s.\n", onoff(sunique));
2169         (void) fflush(stdout);
2170         code = sunique;
2171 }
2172
2173 void setrunique()
2174 {
2175         runique = !runique;
2176         printf("Receive unique %s.\n", onoff(runique));
2177         (void) fflush(stdout);
2178         code = runique;
2179 }
2180
2181 /* change directory to perent directory */
2182 void cdup()
2183 {
2184         if (command("CDUP") == ERROR && code == 500) {
2185                 if (verbose) {
2186                         printf("CDUP command not recognized, trying XCUP\n");
2187                         (void) fflush(stdout);
2188                 }
2189                 (void) command("XCUP");
2190         }
2191 }
2192
2193 /* restart transfer at specific point */
2194 void restart(argc, argv)
2195         int argc;
2196         char *argv[];
2197 {
2198         extern long atol();
2199         if (argc != 2)
2200                 printf("restart: offset not specified\n");
2201         else {
2202                 restart_point = atol(argv[1]);
2203                 printf("restarting at %ld. %s\n", restart_point,
2204                     "execute get, put or append to initiate transfer");
2205         }
2206         (void) fflush(stdout);
2207 }
2208
2209 /* show remote system type */
2210 void syst()
2211 {
2212         (void) command("SYST");
2213 }
2214
2215 void macdef(argc, argv)
2216         int argc;
2217         const char *argv[];
2218 {
2219         char *tmp;
2220         int c;
2221
2222         if (macnum == 16) {
2223                 printf("Limit of 16 macros have already been defined\n");
2224                 (void) fflush(stdout);
2225                 code = -1;
2226                 return;
2227         }
2228         if (argc < 2) {
2229                 (void) strcat(line, " ");
2230                 printf("(macro name) ");
2231                 (void) fflush(stdout);
2232                 (void) gets(&line[strlen(line)]);
2233                 makeargv();
2234                 argc = margc;
2235                 argv = margv;
2236         }
2237         if (argc != 2) {
2238                 printf("Usage: %s macro_name\n",argv[0]);
2239                 (void) fflush(stdout);
2240                 code = -1;
2241                 return;
2242         }
2243         if (interactive) {
2244                 printf("Enter macro line by line, terminating it with a null line\n");
2245                 (void) fflush(stdout);
2246         }
2247         (void) strncpy(macros[macnum].mac_name, argv[1], 8);
2248         if (macnum == 0) {
2249                 macros[macnum].mac_start = macbuf;
2250         }
2251         else {
2252                 macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
2253         }
2254         tmp = macros[macnum].mac_start;
2255         while (tmp != macbuf+4096) {
2256                 if ((c = getchar()) == EOF) {
2257                         printf("macdef:end of file encountered\n");
2258                         (void) fflush(stdout);
2259                         code = -1;
2260                         return;
2261                 }
2262                 if ((*tmp = c) == '\n') {
2263                         if (tmp == macros[macnum].mac_start) {
2264                                 macros[macnum++].mac_end = tmp;
2265                                 code = 0;
2266                                 return;
2267                         }
2268                         if (*(tmp-1) == '\0') {
2269                                 macros[macnum++].mac_end = tmp - 1;
2270                                 code = 0;
2271                                 return;
2272                         }
2273                         *tmp = '\0';
2274                 }
2275                 tmp++;
2276         }
2277         while (1) {
2278                 while ((c = getchar()) != '\n' && c != EOF)
2279                         /* LOOP */;
2280                 if (c == EOF || getchar() == '\n') {
2281                         printf("Macro not defined - 4k buffer exceeded\n");
2282                         (void) fflush(stdout);
2283                         code = -1;
2284                         return;
2285                 }
2286         }
2287 }
2288
2289 /*
2290  * get size of file on remote machine
2291  */
2292 void sizecmd(argc, argv)
2293         const char *argv[];
2294 {
2295
2296         if (argc < 2) {
2297                 (void) strcat(line, " ");
2298                 printf("(filename) ");
2299                 (void) fflush(stdout);
2300                 (void) gets(&line[strlen(line)]);
2301                 makeargv();
2302                 argc = margc;
2303                 argv = margv;
2304         }
2305         if (argc < 2) {
2306                 printf("usage:%s filename\n", argv[0]);
2307                 (void) fflush(stdout);
2308                 code = -1;
2309                 return;
2310         }
2311         (void) command("SIZE %s", argv[1]);
2312 }
2313
2314 /*
2315  * get last modification time of file on remote machine
2316  */
2317 void modtime(argc, argv)
2318         const char *argv[];
2319 {
2320         int overbose;
2321
2322         if (argc < 2) {
2323                 (void) strcat(line, " ");
2324                 printf("(filename) ");
2325                 (void) fflush(stdout);
2326                 (void) gets(&line[strlen(line)]);
2327                 makeargv();
2328                 argc = margc;
2329                 argv = margv;
2330         }
2331         if (argc < 2) {
2332                 printf("usage:%s filename\n", argv[0]);
2333                 (void) fflush(stdout);
2334                 code = -1;
2335                 return;
2336         }
2337         overbose = verbose;
2338         if (debug == 0)
2339                 verbose = -1;
2340         if (command("MDTM %s", argv[1]) == COMPLETE) {
2341                 int yy, mo, day, hour, min, sec;
2342                 sscanf(reply_string, "%*s %04d%02d%02d%02d%02d%02d", &yy, &mo,
2343                         &day, &hour, &min, &sec);
2344                 /* might want to print this in local time */
2345                 printf("%s\t%02d/%02d/%04d %02d:%02d:%02d GMT\n", argv[1],
2346                         mo, day, yy, hour, min, sec);
2347         } else
2348                 printf("%s\n", reply_string);
2349         verbose = overbose;
2350         (void) fflush(stdout);
2351 }
2352
2353 /*
2354  * show status on reomte machine
2355  */
2356 void rmtstatus(argc, argv)
2357         const char *argv[];
2358 {
2359         (void) command(argc > 1 ? "STAT %s" : "STAT" , argv[1]);
2360 }
2361
2362 /*
2363  * get file if modtime is more recent than current file
2364  */
2365 void newer(argc, argv)
2366         const char *argv[];
2367 {
2368         if (getit(argc, argv, -1, "w")) {
2369                 printf("Local file \"%s\" is newer than remote file \"%s\"\n",
2370                         argv[1], argv[2]);
2371                 (void) fflush(stdout);
2372         }
2373 }