base/applications/network/ftp/main.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 char copyright[] =
  20 "@(#) Copyright (c) 1985, 1989 Regents of the University of California.\n\
  21  All rights reserved.\n";
  22 #endif /* not lint */
  23
  24 #ifndef lint
  25 static char sccsid[] = "@(#)main.c      based on 5.13 (Berkeley) 3/14/89";
  26 #endif /* not lint */
  27
  28 /*
  29  * FTP User Program -- Command Interface.
  30  */
  31 #ifndef _WIN32
  32 #include <netdb.h>
  33 #include <sys/socket.h>
  34 #include <sys/ioctl.h>
  35 #include <arpa/ftp.h>
  36 #include <errno.h>
  37 #include <pwd.h>
  38 #endif
  39 #include "ftp_var.h"
  40 #include "prototypes.h"
  41 #include <sys/types.h>
  42
  43 #include <io.h>
  44 #include <fcntl.h>
  45
  46 #include <signal.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <ctype.h>
  50
  51
  52 #if defined(sun) && !defined(FD_SET)
  53 typedef int uid_t;
  54 #endif
  55
  56 uid_t   getuid();
  57 void    intr();
  58 void    lostpeer();
  59 char    *getlogin();
  60
  61 short   portnum;
  62
  63 char    home[128];
  64 char    *globerr;
  65 int     autologin;
  66
  67
  68
  69 /* Lot's of options... */
  70 /*
  71  * Options and other state info.
  72  */
  73 int     trace;                  /* trace packets exchanged */
  74 int     hash;                   /* print # for each buffer transferred */
  75 //int   sendport;               /* use PORT cmd for each data connection */
  76 int     verbose;                /* print messages coming back from server */
  77 int     connected;              /* connected to server */
  78 int     fromatty;               /* input is from a terminal */
  79 int     interactive;            /* interactively prompt on m* cmds */
  80 int     debug;                  /* debugging level */
  81 int     bell;                   /* ring bell on cmd completion */
  82 int     doglob;                 /* glob local file names */
  83 int     proxy;                  /* proxy server connection active */
  84 int     passivemode;
  85 int     proxflag;               /* proxy connection exists */
  86 int     sunique;                /* store files on server with unique name */
  87 int     runique;                /* store local files with unique name */
  88 int     mcase;                  /* map upper to lower case for mget names */
  89 int     ntflag;                 /* use ntin ntout tables for name translation */
  90 int     mapflag;                /* use mapin mapout templates on file names */
  91 int     code;                   /* return/reply code for ftp command */
  92 int     crflag;                 /* if 1, strip car. rets. on ascii gets */
  93 char    pasv[64];               /* passive port for proxy data connection */
  94 char    *altarg;                /* argv[1] with no shell-like preprocessing  */
  95 char    ntin[17];               /* input translation table */
  96 char    ntout[17];              /* output translation table */
  97 // #include <sys/param.h>
  98 char    mapin[MAXPATHLEN];      /* input map template */
  99 char    mapout[MAXPATHLEN];     /* output map template */
 100 char    typename[32];           /* name of file transfer type */
 101 int     type;                   /* file transfer type */
 102 char    structname[32];         /* name of file transfer structure */
 103 int     stru;                   /* file transfer structure */
 104 char    formname[32];           /* name of file transfer format */
 105 int     form;                   /* file transfer format */
 106 char    modename[32];           /* name of file transfer mode */
 107 int     mode;                   /* file transfer mode */
 108 char    bytename[32];           /* local byte size in ascii */
 109 int     bytesize;               /* local byte size in binary */
 110
 111 jmp_buf toplevel;               /* non-local goto stuff for cmd scanner */
 112
 113 char    line[200];              /* input line buffer */
 114 char    *stringbase;            /* current scan point in line buffer */
 115 char    argbuf[200];            /* argument storage buffer */
 116 char    *argbase;               /* current storage point in arg buffer */
 117 int     margc;                  /* count of arguments on input line */
 118 const char      *margv[20];     /* args parsed from input line */
 119 int     cpend;                  /* flag: if != 0, then pending server reply */
 120 int     mflag;                  /* flag: if != 0, then active multi command */
 121
 122 int     options;                /* used during socket creation */
 123
 124 int     macnum;                 /* number of defined macros */
 125 struct  macel macros[16];
 126 char    macbuf[4096];
 127
 128 /*
 129  * Need to start a listen on the data channel
 130  * before we send the command, otherwise the
 131  * server's connect may fail.
 132  */
 133 int sendport = -1;
 134
 135 static const char *slurpstring();
 136
 137
 138 int main(int argc, const char *argv[])
 139 {
 140         const char *cp;
 141         int top;
 142 #if 0
 143         char homedir[MAXPATHLEN];
 144 #endif
 145
 146         int err;
 147         WORD wVerReq;
 148
 149         WSADATA WSAData;
 150         struct  servent *sp;            /* service spec for tcp/ftp */
 151
 152         /* Disable output buffering, for the benefit of Emacs.  */
 153         //setbuf(stdout, NULL);
 154
 155         _fmode = O_BINARY; // This causes an error somewhere.
 156
 157         wVerReq = MAKEWORD(1,1);
 158
 159         err = WSAStartup(wVerReq, &WSAData);
 160         if (err != 0)
 161         {
 162            fprintf(stderr, "Could not initialize Windows socket interface.");
 163            exit(1);
 164         }
 165
 166         sp = getservbyname("ftp", "tcp");
 167         if (sp == 0) {
 168                 fprintf(stderr, "ftp: ftp/tcp: unknown service\n");
 169                 exit(1);
 170         }
 171
 172         portnum = sp->s_port;
 173
 174
 175         doglob = 1;
 176         interactive = 1;
 177         autologin = 1;
 178         argc--, argv++;
 179         while (argc > 0 && **argv == '-') {
 180                 for (cp = *argv + 1; *cp; cp++)
 181                         switch (*cp) {
 182
 183                         case 'd':
 184                                 options |= SO_DEBUG;
 185                                 debug++;
 186                                 break;
 187
 188                         case 'v':
 189                                 verbose++;
 190                                 break;
 191
 192                         case 't':
 193                                 trace++;
 194                                 break;
 195
 196                         case 'i':
 197                                 interactive = 0;
 198                                 break;
 199
 200                         case 'n':
 201                                 autologin = 0;
 202                                 break;
 203
 204                         case 'g':
 205                                 doglob = 0;
 206                                 break;
 207
 208                         default:
 209                                 fprintf(stdout,
 210                                   "ftp: %c: unknown option\n", *cp);
 211                                 exit(1);
 212                         }
 213                 argc--, argv++;
 214         }
 215 //      fromatty = isatty(fileno(stdin));
 216         fromatty = 1; // Strengthen this test
 217         /*
 218          * Set up defaults for FTP.
 219          */
 220         (void) strcpy(typename, "ascii"), type = TYPE_A;
 221         (void) strcpy(formname, "non-print"), form = FORM_N;
 222         (void) strcpy(modename, "stream"), mode = MODE_S;
 223         (void) strcpy(structname, "file"), stru = STRU_F;
 224         (void) strcpy(bytename, "8"), bytesize = 8;
 225         if (fromatty)
 226                 verbose++;
 227         cpend = 0;           /* no pending replies */
 228         proxy = 0;      /* proxy not active */
 229     passivemode = 1; /* passive mode *is* active */
 230         crflag = 1;    /* strip c.r. on ascii gets */
 231         /*
 232          * Set up the home directory in case we're globbing.
 233          */
 234 #if 0
 235         cp = getlogin();
 236         if (cp != NULL) {
 237                 pw = getpwnam(cp);
 238         }
 239         if (pw == NULL)
 240                 pw = getpwuid(getuid());
 241         if (pw != NULL) {
 242                 home = homedir;
 243                 (void) strcpy(home, pw->pw_dir);
 244         }
 245 #endif
 246         strcpy(home, "C:/");
 247         if (argc > 0) {
 248                 if (setjmp(toplevel))
 249                         exit(0);
 250 //              (void) signal(SIGINT, intr);
 251 //              (void) signal(SIGPIPE, lostpeer);
 252                 setpeer(argc + 1, argv - 1);
 253         }
 254         top = setjmp(toplevel) == 0;
 255         if (top) {
 256 //              (void) signal(SIGINT, intr);
 257 //              (void) signal(SIGPIPE, lostpeer);
 258         }
 259         for (;;) {
 260                 cmdscanner(top);
 261                 top = 1;
 262         }
 263 }
 264
 265 void
 266 intr()
 267 {
 268
 269         longjmp(toplevel, 1);
 270 }
 271
 272 void lostpeer(void)
 273 {
 274    extern int cout;
 275    extern int data;
 276
 277    if (connected) {
 278       if (cout) {
 279          closesocket(cout);
 280          cout = 0;
 281       }
 282       if (data >= 0) {
 283          (void) shutdown(data, 1+1);
 284          (void) close(data);
 285          data = -1;
 286       }
 287       connected = 0;
 288    }
 289    pswitch(1);
 290    if (connected) {
 291       if (cout) {
 292                                                 closesocket(cout);
 293          cout = 0;
 294       }
 295       connected = 0;
 296    }
 297    proxflag = 0;
 298    pswitch(0);
 299 }
 300
 301 /*char *
 302 tail(filename)
 303         char *filename;
 304 {
 305         register char *s;
 306
 307         while (*filename) {
 308                 s = rindex(filename, '/');
 309                 if (s == NULL)
 310                         break;
 311                 if (s[1])
 312                         return (s + 1);
 313                 *s = '\0';
 314         }
 315         return (filename);
 316 }
 317 */
 318 /*
 319  * Command parser.
 320  */
 321 void cmdscanner(top)
 322         int top;
 323 {
 324         register struct cmd *c;
 325
 326         if (!top)
 327                 (void) putchar('\n');
 328         for (;;) {
 329                 (void) fflush(stdout);
 330                 if (fromatty) {
 331                         printf("ftp> ");
 332                         (void) fflush(stdout);
 333                 }
 334                 if (gets(line) == 0) {
 335                         if (feof(stdin) || ferror(stdin))
 336                                 quit();
 337                         break;
 338                 }
 339                 if (line[0] == 0)
 340                         break;
 341                 makeargv();
 342                 if (margc == 0) {
 343                         continue;
 344                 }
 345                 c = getcmd(margv[0]);
 346                 if (c == (struct cmd *)-1) {
 347                         printf("?Ambiguous command\n");
 348                         continue;
 349                 }
 350                 if (c == 0) {
 351                         printf("?Invalid command\n");
 352                         continue;
 353                 }
 354                 if (c->c_conn && !connected) {
 355                         printf ("Not connected.\n");
 356                         continue;
 357                 }
 358                 (*c->c_handler)(margc, margv);
 359                 if (bell && c->c_bell)
 360                         (void) putchar('\007');
 361                 if (c->c_handler != help)
 362                         break;
 363         }
 364         (void) fflush(stdout);
 365 //      (void) signal(SIGINT, intr);
 366 //      (void) signal(SIGPIPE, lostpeer);
 367 }
 368
 369 struct cmd *
 370 getcmd(name)
 371         const char *name;
 372 {
 373         extern struct cmd cmdtab[];
 374         const char *p, *q;
 375         struct cmd *c, *found;
 376         int nmatches, longest;
 377
 378         longest = 0;
 379         nmatches = 0;
 380         found = 0;
 381         for (c = cmdtab; (p = c->c_name); c++) {
 382                 for (q = name; *q == *p++; q++)
 383                         if (*q == 0)            /* exact match? */
 384                                 return (c);
 385                 if (!*q) {                      /* the name was a prefix */
 386                         if (q - name > longest) {
 387                                 longest = q - name;
 388                                 nmatches = 1;
 389                                 found = c;
 390                         } else if (q - name == longest)
 391                                 nmatches++;
 392                 }
 393         }
 394         if (nmatches > 1)
 395                 return ((struct cmd *)-1);
 396         return (found);
 397 }
 398
 399 /*
 400  * Slice a string up into argc/argv.
 401  */
 402
 403 int slrflag;
 404
 405 void makeargv()
 406 {
 407         const char **argp;
 408
 409         margc = 0;
 410         argp = margv;
 411         stringbase = line;              /* scan from first of buffer */
 412         argbase = argbuf;               /* store from first of buffer */
 413         slrflag = 0;
 414         while ((*argp++ = slurpstring()))
 415                 margc++;
 416 }
 417
 418 /*
 419  * Parse string into argbuf;
 420  * implemented with FSM to
 421  * handle quoting and strings
 422  */
 423 static const char *
 424 slurpstring()
 425 {
 426         int got_one = 0;
 427         register char *sb = stringbase;
 428         register char *ap = argbase;
 429         char *tmp = argbase;            /* will return this if token found */
 430
 431         if (*sb == '!' || *sb == '$') { /* recognize ! as a token for shell */
 432                 switch (slrflag) {      /* and $ as token for macro invoke */
 433                         case 0:
 434                                 slrflag++;
 435                                 stringbase++;
 436                                 return ((*sb == '!') ? "!" : "$");
 437                                 /* NOTREACHED */
 438                         case 1:
 439                                 slrflag++;
 440                                 altarg = stringbase;
 441                                 break;
 442                         default:
 443                                 break;
 444                 }
 445         }
 446
 447 S0:
 448         switch (*sb) {
 449
 450         case '\0':
 451                 goto OUT1;
 452
 453         case ' ':
 454         case '\t':
 455                 sb++; goto S0;
 456
 457         default:
 458                 switch (slrflag) {
 459                         case 0:
 460                                 slrflag++;
 461                                 break;
 462                         case 1:
 463                                 slrflag++;
 464                                 altarg = sb;
 465                                 break;
 466                         default:
 467                                 break;
 468                 }
 469                 goto S1;
 470         }
 471
 472 S1:
 473         switch (*sb) {
 474
 475         case ' ':
 476         case '\t':
 477         case '\0':
 478                 goto OUT1;      /* end of token */
 479
 480         case '\\':
 481                 sb++; goto S2;  /* slurp next character */
 482
 483         case '"':
 484                 sb++; goto S3;  /* slurp quoted string */
 485
 486         default:
 487                 *ap++ = *sb++;  /* add character to token */
 488                 got_one = 1;
 489                 goto S1;
 490         }
 491
 492 S2:
 493         switch (*sb) {
 494
 495         case '\0':
 496                 goto OUT1;
 497
 498         default:
 499                 *ap++ = *sb++;
 500                 got_one = 1;
 501                 goto S1;
 502         }
 503
 504 S3:
 505         switch (*sb) {
 506
 507         case '\0':
 508                 goto OUT1;
 509
 510         case '"':
 511                 sb++; goto S1;
 512
 513         default:
 514                 *ap++ = *sb++;
 515                 got_one = 1;
 516                 goto S3;
 517         }
 518
 519 OUT1:
 520         if (got_one)
 521                 *ap++ = '\0';
 522         argbase = ap;                   /* update storage pointer */
 523         stringbase = sb;                /* update scan pointer */
 524         if (got_one) {
 525                 return(tmp);
 526         }
 527         switch (slrflag) {
 528                 case 0:
 529                         slrflag++;
 530                         break;
 531                 case 1:
 532                         slrflag++;
 533                         altarg = (char *) 0;
 534                         break;
 535                 default:
 536                         break;
 537         }
 538         return((char *)0);
 539 }
 540
 541 #define HELPINDENT (sizeof ("directory"))
 542
 543 /*
 544  * Help command.
 545  * Call each command handler with argc == 0 and argv[0] == name.
 546  */
 547 void help(argc, argv)
 548         int argc;
 549         char *argv[];
 550 {
 551         extern struct cmd cmdtab[];
 552         struct cmd *c;
 553
 554         if (argc == 1) {
 555                 register int i, j, w, k;
 556                 int columns, width = 0, lines;
 557                 extern int NCMDS;
 558
 559                 printf("Commands may be abbreviated.  Commands are:\n\n");
 560                 for (c = cmdtab; c < &cmdtab[NCMDS]; c++) {
 561                         int len = strlen(c->c_name);
 562
 563                         if (len > width)
 564                                 width = len;
 565                 }
 566                 width = (width + 8) &~ 7;
 567                 columns = 80 / width;
 568                 if (columns == 0)
 569                         columns = 1;
 570                 lines = (NCMDS + columns - 1) / columns;
 571                 for (i = 0; i < lines; i++) {
 572                         for (j = 0; j < columns; j++) {
 573                                 c = cmdtab + j * lines + i;
 574                                 if (c->c_name && (!proxy || c->c_proxy)) {
 575                                         printf("%s", c->c_name);
 576                                 }
 577                                 else if (c->c_name) {
 578                                         for (k=0; k < (int) strlen(c->c_name); k++) {
 579                                                 (void) putchar(' ');
 580                                         }
 581                                 }
 582                                 if (c + lines >= &cmdtab[NCMDS]) {
 583                                         printf("\n");
 584                                         break;
 585                                 }
 586                                 w = strlen(c->c_name);
 587                                 while (w < width) {
 588                                         w = (w + 8) &~ 7;
 589                                         (void) putchar('\t');
 590                                 }
 591                         }
 592                 }
 593                 (void) fflush(stdout);
 594                 return;
 595         }
 596         while (--argc > 0) {
 597                 register char *arg;
 598                 arg = *++argv;
 599                 c = getcmd(arg);
 600                 if (c == (struct cmd *)-1)
 601                         printf("?Ambiguous help command %s\n", arg);
 602                 else if (c == (struct cmd *)0)
 603                         printf("?Invalid help command %s\n", arg);
 604                 else
 605                         printf("%-*s\t%s\n", (int)HELPINDENT,
 606                                 c->c_name, c->c_help);
 607         }
 608         (void) fflush(stdout);
 609 }