开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
cmds.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：49k
源码类别：

代理服务器

开发平台：

Unix_Linux

cmds.c：源码内容
  1. /* Copyright (c) 1985, 1989 Regents of the University of California.         */
  2. /* All rights reserved.                                                      */
  3. /*                                                                           */
  4. /* Redistribution and use in source and binary forms, with or without        */
  5. /* modification, are permitted provided that the following conditions        */
  6. /* are met:                                                                  */
  7. /*                                                                           */
  8. /* 1. Redistributions of source code must retain the above copyright         */
  9. /*    notice, this list of conditions and the following disclaimer.          */
  10. /* 2. Redistributions in binary form must reproduce the above copyright      */
  11. /*    notice, this list of conditions and the following disclaimer in the    */
  12. /*    documentation and/or other materials provided with the distribution.   */
  13. /* 3. All advertising materials mentioning features or use of this software  */
  14. /*    must display the following acknowledgement:                            */
  15. /*      This product includes software developed by the University of        */
  16. /*      California, Berkeley and its contributors.                           */
  17. /* 4. Neither the name of the University nor the names of its contributors   */
  18. /*    may be used to endorse or promote products derived from this software  */
  19. /*    without specific prior written permission.                             */
  20. /*                                                                           */
  21. /* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   */
  22. /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     */
  23. /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE*/
  24. /* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE  */
  25. /* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL*/
  26. /* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS   */
  27. /* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)     */
  28. /* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT*/
  29. /* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY */
  30. /* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF    */
  31. /* SUCH DAMAGE.                                                              */
  33. /* FTP User Program -- Command Routines.                                     */
  34. #include "ftp_var.h"
  36. #define DONT_NEED_SIGBLOCK
  37. #define DONT_NEED_SIGPAUSE
  38. #define DONT_NEED_SIGUNBLOCK
  39. #define DONT_NEED_SIGPENDING
  40. #include "sigfix.h"
  42. #include <arpa/ftp.h>
  43. #include <ctype.h>
  44. #include "pathnames.h"
  46. #ifndef HAVE_GETCWD
  47. extern char *getwd();
  48. #endif
  50. extern int command();
  52. extern char *home;
  53. extern char *globerr;
  54. extern char **ftpglob();
  55. extern char *remglob();
  56. extern int  errno;
  57. extern off_t restart_point;
  58. extern char reply_string[];
  60. char *mname;
  61. jmp_buf jabort;
  62. char *dotrans(), *domap();
  64. /*
  65.  * Options and other state info.
  66.  */
  67. int trace; /* trace packets exchanged */
  68. int hash; /* print # for each buffer transferred */
  69. int sendport; /* use PORT cmd for each data connection */
  70. int verbose; /* print messages coming back from server */
  71. int connected; /* connected to server */
  72. int fromatty; /* input is from a terminal */
  73. int interactive; /* interactively prompt on m* cmds */
  74. int debug; /* debugging level */
  75. int bell; /* ring bell on cmd completion */
  76. int doglob; /* glob local file names */
  77. int autologin; /* establish user account on connection */
  78. int proxy; /* proxy server connection active */
  79. int proxflag; /* proxy connection exists */
  80. int sunique; /* store files on server with unique name */
  81. int runique; /* store local files with unique name */
  82. int mcase; /* map upper to lower case for mget names */
  83. int ntflag; /* use ntin ntout tables for name translation */
  84. int mapflag; /* use mapin mapout templates on file names */
  85. int code; /* return/reply code for ftp command */
  86. int crflag; /* if 1, strip car. rets. on ascii gets */
  87. char pasv[64]; /* passive port for proxy data connection */
  88. char *altarg; /* argv[1] with no shell-like preprocessing  */
  89. char ntin[17]; /* input translation table */
  90. char ntout[17]; /* output translation table */
  92. char mapin[MAXPATHLEN]; /* input map template */
  93. char mapout[MAXPATHLEN]; /* output map template */
  94. char typename[32]; /* name of file transfer type */
  95. int type; /* requested file transfer type */
  96. int curtype; /* current file transfer type */
  97. char structname[32]; /* name of file transfer structure */
  98. int stru; /* file transfer structure */
  99. char formname[32]; /* name of file transfer format */
  100. int form; /* file transfer format */
  101. char modename[32]; /* name of file transfer mode */
  102. int mode; /* file transfer mode */
  103. char bytename[32]; /* local byte size in ascii */
  104. int bytesize; /* local byte size in binary */
  106. char *hostname; /* name of host connected to */
  107. int unix_server; /* server is unix, can use binary for ascii */
  108. int unix_proxy; /* proxy is unix, can use binary for ascii */
  110. struct servent *sp; /* service spec for tcp/ftp */
  111. int ftp_s_port;         /* save ftp's sp->s_port value here */
  112. char line[200]; /* input line buffer */
  113. char *stringbase; /* current scan point in line buffer */
  114. char argbuf[200]; /* argument storage buffer */
  115. char *argbase; /* current storage point in arg buffer */
  116. int margc; /* count of arguments on input line */
  117. char *margv[20]; /* args parsed from input line */
  118. int     cpend;                  /* flag: if != 0, then pending server reply */
  119. int mflag; /* flag: if != 0, then active multi command */
  120. int options; /* used during socket creation */
  122. jmp_buf toplevel; /* non-local goto stuff for cmd scanner */
  124. int macnum; /* number of defined macros */
  125. struct macel macros[16];
  126. char macbuf[4096];
  128. /* `Another' gets another argument, and stores the new argc and argv.        */
  129. /* It reverts to the top level (via main.c's intr()) on EOF/error.           */
  130. /* Returns false if no new arguments have been added.                        */
  131. int another(int *pargc, char ***pargv, char *prompt) {
  132.   int len = strlen(line), ret;
  133.   extern sig_t intr();
  135.   if (len >= sizeof(line) - 3) {
  136.     printf("sorry, arguments too longn");
  137.     intr();
  138.   }
  140.   printf("(%s) ", prompt);
  141.   line[len++] = ' ';
  143.   if (fgets(&line[len], sizeof(line) - len, stdin) == NULL) intr();
  145.   len += strlen(&line[len]);
  146.   if (len > 0 && line[len - 1] == 'n') line[len - 1] = '';
  148.   makeargv();
  149.   ret = margc > *pargc;
  151.   *pargc = margc;
  152.   *pargv = margv;
  154.   return ret;
  155. }
  157. /* Connect to peer server and auto-login, if possible.                       */
  158. void setpeer(int argc, char *argv[]) {
  159.   char *host, *hookup();
  160.   short port;
  162.   if (connected) {
  163.     printf("Already connected to %s, use close first.n", hostname);
  164.     code = -1;
  165.     return;
  166.   }
  167.   if (argc < 2)
  168.     another(&argc, &argv, "to");
  170.   if (argc < 2 || argc > 3) {
  171.     printf("usage: %s host-name [port]n", argv[0]);
  172.     code = -1;
  173.     return;
  174.   }
  176.   /* port = sp->s_port; */
  177.   port = ftp_s_port;
  179.   if (argc > 2) {
  180.     port = atoi(argv[2]);
  181.     if (port <= 0) {
  182.       printf("%s: bad port number-- %sn", argv[1], argv[2]);
  183.       printf ("usage: %s host-name [port]n", argv[0]);
  184.       code = -1;
  185.       return;
  186.     }
  187.     port = htons(port);
  188.   }
  190.   host = hookup(argv[1], port);
  191.   if (host) {
  192. #if NBBY == 8
  193.     int overbose;
  194. #endif
  196.     connected = 1;
  197.     /* Set up defaults for FTP.                                          */
  198.     strcpy(typename, "ascii"), type = TYPE_A;
  199.     curtype = TYPE_A;
  200.     strcpy(formname, "non-print"), form = FORM_N;
  201.     strcpy(modename, "stream"), mode = MODE_S;
  202.     strcpy(structname, "file"), stru = STRU_F;
  203.     strcpy(bytename, "8"), bytesize = 8;
  205.     if (autologin) 
  206.       login(argv[1]);
  208. #if NBBY == 8
  209.     /* this ifdef is to keep someone form "porting" this to an           */
  210.     /* incompatible system and not checking this out. This way they have */
  211.     /* to think about it.                                                */
  212.     overbose = verbose;
  214.     if (debug == 0)
  215.       verbose = -1;
  216.     if (command("SYST") == COMPLETE && overbose) {
  217.       register char *cp, c;
  218.       cp = index(reply_string+4, ' ');
  219.       if (cp == NULL) cp = index(reply_string+4, 'r');
  221.       if (cp) {
  222. if (cp[-1] == '.') cp--;
  223. c = *cp;
  224. *cp = '';
  225.       }
  226.     
  227.       printf("Remote system type is %s.n", reply_string+4);
  228.       if (cp) *cp = c;
  229.     }
  231.     if (!strncmp(reply_string, "215 UNIX Type: L8", 17)) {
  232.       if (proxy) unix_proxy = 1;
  233.       else       unix_server = 1;
  235.       /* Set type to 0 (not specified by user), meaning binary by      */
  236.       /* default, but don't bother telling server.  We can use binary  */
  237.       /* for text files unless changed by the user.                    */
  238.       type = 0;
  239.       strcpy(typename, "binary");
  240.       if (overbose)
  241. printf("Using %s mode to transfer files.n", typename);
  242.     } else {
  243.       if (proxy) unix_proxy = 0;
  244.       else       unix_server = 0;
  246.       if (overbose && !strncmp(reply_string, "215 TOPS20", 10))
  247. printf("Remember to set tenex mode when transfering binary files from this machine.n");
  248.     }
  250.     verbose = overbose;
  251. #endif 
  252.   }
  253. }
  255. struct types {
  256.   char *t_name;
  257.   char *t_mode;
  258.   int          t_type;
  259.   char *t_arg;
  260. } types[] = {
  261.   { "ascii", "A", TYPE_A, 0 },
  262.   { "binary", "I", TYPE_I, 0 },
  263.   { "image", "I", TYPE_I, 0 },
  264.   { "ebcdic", "E", TYPE_E, 0 },
  265.   { "tenex", "L", TYPE_L, bytename },
  266.   { NULL, NULL, 0, NULL }
  267. };
  269. /* Set transfer type.                                                        */
  270. void settype(int argc, char *argv[]) {
  271.   register struct types *p;
  272.   int comret;
  273.     
  274.   if (argc > 2) {
  275.     char *sep;
  277.     printf("usage: %s [", argv[0]);
  278.     sep = " ";
  279.     for (p = types; p->t_name; p++) {
  280.       printf("%s%s", sep, p->t_name);
  281.       sep = " | ";
  282.     }
  284.     printf(" ]n");
  285.     code = -1;
  286.     return;
  287.   }
  289.   if (argc < 2) {
  290.     printf("Using %s mode to transfer files.n", typename);
  291.     code = 0;
  292.     return;
  293.   }
  295.   for (p = types; p->t_name; p++)
  296.     if (strcmp(argv[1], p->t_name) == 0)
  297.       break;
  299.   if (p->t_name == 0) {
  300.     printf("%s: unknown moden", argv[1]);
  301.     code = -1;
  302.     return;
  303.   }
  305.   if ((p->t_arg != NULL) && (*(p->t_arg) != ''))
  306.     comret = command ("TYPE %s %s", p->t_mode, p->t_arg);
  307.   else
  308.     comret = command("TYPE %s", p->t_mode);
  310.   if (comret == COMPLETE) {
  311.     strcpy(typename, p->t_name);
  312.     curtype = type = p->t_type;
  313.   }
  314. }
  316. /* Internal form of settype; changes current type in use with server         */
  317. /* without changing our notion of the type for data transfers.               */
  318. /* Used to change to and from ascii for listings.                            */
  319. void changetype(int newtype, int show) {
  320.   register struct types *p;
  321.   int comret, oldverbose = verbose;
  322.     
  323.   if (newtype == 0)
  324.     newtype = TYPE_I;
  326.   if (newtype == curtype)
  327.     return;
  329.   if (debug == 0 && show == 0)
  330.     verbose = 0;
  332.   for (p = types; p->t_name; p++)
  333.     if (newtype == p->t_type)
  334.       break;
  336.   if (p->t_name == 0) {
  337.     printf("ftp: internal error: unknown type %dn", newtype);
  338.     return;
  339.   }
  341.   if (newtype == TYPE_L && bytename[0] != '')
  342.     comret = command("TYPE %s %s", p->t_mode, bytename);
  343.   else
  344.     comret = command("TYPE %s", p->t_mode);
  346.   if (comret == COMPLETE)
  347.     curtype = newtype;
  349.   verbose = oldverbose;
  350. }
  352. char *stype[] = {
  353.   "type",
  354.   "",
  355.   0
  356. };
  358. /* Set binary transfer type.                                                 */
  359. void setbinary() {
  360.   stype[1] = "binary";
  361.   settype(2, stype);
  362. }
  364. /* Set ascii transfer type.                                                  */
  365. void setascii() {
  366.   stype[1] = "ascii";
  367.   settype(2, stype);
  368. }
  370. /* Set tenex transfer type.                                                  */
  371. void settenex() {
  372.   stype[1] = "tenex";
  373.   settype(2, stype);
  374. }
  376. /* Set file transfer mode.                                                   */
  377. void setftpmode(int argc, char *argv[]) {
  378.   printf("We only support %s mode, sorry.n", modename);
  379.   code = -1;
  380. }
  382. /* Set file transfer format.                                                 */
  383. void setform(int argc, char *argv[]) {
  384.   printf("We only support %s format, sorry.n", formname);
  385.   code = -1;
  386. }
  388. /* Set file transfer structure.                                              */
  389. void setstruct(int argc, char *argv[]) {
  390.   printf("We only support %s structure, sorry.n", structname);
  391.   code = -1;
  392. }
  394. /* Glob a local file name specification with the expectation of a single     */
  395. /* return value.  Can't control multiple values being expanded from the      */
  396. /* expression, we return only the first.                                     */
  397. int globulize(char **cpp) {
  398.   char **globbed;
  400.   if (!doglob) return (1);
  401.   globbed = ftpglob(*cpp);
  403.     
  404.   if (globerr != NULL) {
  405.     printf("%s: %sn", *cpp, globerr);
  407.     if (globbed) {
  408.       blkfree(globbed);
  409.       free((char *)globbed);
  410.     }
  412.     return 0;
  413.   }
  415.   if (globbed) {
  416.     *cpp = *globbed++;
  418.     /* don't waste too much memory */
  420.     if (*globbed) {
  421.       blkfree(globbed);
  422.       free((char *)globbed);
  423.     }
  424.   }
  426.   return 1;
  427. }
  429. /* Send a single file.                                                       */
  430. void put(int argc, char *argv[]) {
  431.   char *cmd;
  432.   int loc = 0;
  433.   char *oldargv1, *oldargv2;
  435.   if (argc == 2) {
  436.     argc++;
  437.     argv[2] = argv[1];
  438.     loc++;
  439.   }
  441.   if (argc < 2 && !another(&argc, &argv, "local-file"))
  442.     goto usage;
  444.   if (argc < 3 && !another(&argc, &argv, "remote-file")) {
  445.   usage:
  446.     printf("usage: %s local-file remote-filen", argv[0]);
  447.     code = -1;
  448.     return;
  449.   }
  451.   oldargv1 = argv[1];
  452.   oldargv2 = argv[2];
  454.   if (!globulize(&argv[1])) {
  455.     code = -1;
  456.     return;
  457.   }
  459.   /* If "globulize" modifies argv[1], and argv[2] is a copy of             */
  460.   /* the old argv[1], make it a copy of the new argv[1].                   */
  461.   if (argv[1] != oldargv1 && argv[2] == oldargv1) 
  462.     argv[2] = argv[1];
  464.   cmd = (argv[0][0] == 'a') ? "APPE" : ((sunique) ? "STOU" : "STOR");
  466.   if (loc && ntflag) 
  467.     argv[2] = dotrans(argv[2]);
  469.   if (loc && mapflag) 
  470.     argv[2] = domap(argv[2]);
  472.   sendrequest(cmd, argv[1], argv[2], argv[1] != oldargv1 || argv[2] != oldargv2);
  473. }
  475. int confirm(char *cmd, char *file) {
  476.   char bline[BUFSIZ];
  478.   if (!interactive) return (1);
  479.   printf("%s %s? ", cmd, file);
  480.   fflush(stdout);
  482.   if (fgets(bline, sizeof(bline), stdin) == NULL) return (0);
  483.   return (*bline != 'n' && *bline != 'N');
  484. }
  486. /* Send multiple files.                                                      */
  487. void mabort() {
  488.   int ointer;
  489.   extern jmp_buf jabort;
  490.     
  491.   printf("n");
  492.   fflush(stdout);
  494.   if (mflag && fromatty) {
  495.     ointer = interactive;
  496.     interactive = 1;
  498.     if (confirm("Continue with", mname)) {
  499.       interactive = ointer;
  500.       longjmp(jabort,0);
  501.     }
  503.     interactive = ointer;
  504.   }
  506.   mflag = 0;
  507.   longjmp(jabort,0);
  508. }
  510. void mput(int argc, char **argv) {
  511.   extern jmp_buf jabort;
  512.   register int i;
  513.   sig_t oldintr;
  514.   int ointer;
  515.   char *tp;
  516.   void mabort();
  517.     
  518.   if (argc < 2 && !another(&argc, &argv, "local-files")) {
  519.     printf("usage: %s local-filesn", argv[0]);
  520.     code = -1;
  521.     return;
  522.   }
  524.   mname = argv[0];
  525.   mflag = 1;
  526.   oldintr = (sig_t)Signal(SIGINT, mabort);
  527.   setjmp(jabort);
  529.   if (proxy) {
  530.     char *cp, *tp2, tmpbuf[MAXPATHLEN];
  532.     while ((cp = remglob(argv,0)) != NULL) {
  533.       if (*cp == 0) {
  534. mflag = 0;
  535. continue;
  536.       }
  538.       if (mflag && confirm(argv[0], cp)) {
  539. tp = cp;
  540. if (mcase) {
  541.   while (*tp && !islower(*tp)) {
  542.     tp++;
  543.   }
  545.   if (!*tp) {
  546.     tp = cp;
  547.     tp2 = tmpbuf;
  549.     while ((*tp2 = *tp)) {
  550.       if (isupper(*tp2)) {
  551. *tp2 = 'a' + *tp2 - 'A';
  552.       }
  554.       tp++;
  555.       tp2++;
  556.     }
  557.   }
  558.   tp = tmpbuf;
  559. }
  561. if (ntflag) {
  562.   tp = dotrans(tp);
  563. }
  565. if (mapflag) {
  566.   tp = domap(tp);
  567. }
  569. sendrequest((sunique) ? "STOU" : "STOR", cp, tp, cp != tp || !interactive);
  571. if (!mflag && fromatty) {
  572.   ointer = interactive;
  573.   interactive = 1;
  575.   if (confirm("Continue with","mput")) {
  576.     mflag++;
  577.   }
  579.   interactive = ointer;
  580. }
  581.       }
  582.     }
  584.     Signal(SIGINT, oldintr);
  585.     mflag = 0;
  586.     return;
  587.   }
  589.   for (i = 1; i < argc; i++) {
  590.     register char **cpp, **gargs;
  592.     if (!doglob) {
  593.       if (mflag && confirm(argv[0], argv[i])) {
  594. tp = (ntflag) ? dotrans(argv[i]) : argv[i];
  595. tp = (mapflag) ? domap(tp) : tp;
  596. sendrequest((sunique) ? "STOU" : "STOR", argv[i], tp, tp != argv[i] || !interactive);
  597. if (!mflag && fromatty) {
  598.   ointer = interactive;
  599.   interactive = 1;
  601.   if (confirm("Continue with","mput")) {
  602.     mflag++;
  603.   }
  605.   interactive = ointer;
  606. }
  607.       }
  608.       continue;
  609.     }
  611.     gargs = ftpglob(argv[i]);
  613.     if (globerr != NULL) {
  614.       printf("%sn", globerr);
  615.       if (gargs) {
  616. blkfree(gargs);
  617. free((char *)gargs);
  618.       }
  619.       continue;
  620.     }
  622.     for (cpp = gargs; cpp && *cpp != NULL; cpp++) {
  623.       if (mflag && confirm(argv[0], *cpp)) {
  624. tp = (ntflag) ? dotrans(*cpp) : *cpp;
  625. tp = (mapflag) ? domap(tp) : tp;
  626. sendrequest((sunique) ? "STOU" : "STOR", *cpp, tp, *cpp != tp || !interactive);
  627. if (!mflag && fromatty) {
  628.   ointer = interactive;
  629.   interactive = 1;
  630.   if (confirm("Continue with","mput")) {
  631.     mflag++;
  632.   }
  633.   interactive = ointer;
  634. }
  635.       }
  636.     }
  638.     if (gargs != NULL) {
  639.       blkfree(gargs);
  640.       free((char *)gargs);
  641.     }
  642.   }
  644.   Signal(SIGINT, oldintr);
  645.   mflag = 0;
  646. }
  648. /* Receive one file.                                                         */
  649. int getit(int argc, char *argv[], int restartit, char *mode) {
  650.   int loc = 0;
  651.   char *oldargv1, *oldargv2;
  653.   if (argc == 2) {
  654.     argc++;
  655.     argv[2] = argv[1];
  656.     loc++;
  657.   }
  659.   if (argc < 2 && !another(&argc, &argv, "remote-file"))
  660.     goto usage;
  662.   if (argc < 3 && !another(&argc, &argv, "local-file")) {
  663.   usage:
  664.     printf("usage: %s remote-file [ local-file ]n", argv[0]);
  665.     code = -1;
  666.     return (0);
  667.   }
  669.   oldargv1 = argv[1];
  670.   oldargv2 = argv[2];
  672.   if (!globulize(&argv[2])) {
  673.     code = -1;
  674.     return (0);
  675.   }
  677.   if (loc && mcase) {
  678.     char *tp = argv[1], *tp2, tmpbuf[MAXPATHLEN];
  680.     while (*tp && !islower(*tp)) tp++;
  682.     if (!*tp) {
  683.       tp = argv[2];
  684.       tp2 = tmpbuf;
  686.       while ((*tp2 = *tp)) {
  687. if (isupper(*tp2)) *tp2 = tolower(*tp2);
  688. tp2++;
  689. tp++;
  690.       }
  692.       argv[2] = tmpbuf;
  693.     }
  694.   }
  696.   if (loc && ntflag)
  697.     argv[2] = dotrans(argv[2]);
  698.   if (loc && mapflag)
  699.     argv[2] = domap(argv[2]);
  701.   if (restartit) {
  702.     struct stat stbuf;
  703.     int ret;
  705.     ret = stat(argv[2], &stbuf);
  706.     if (restartit == 1) {
  707.       if (ret < 0) {
  708. fprintf(stderr, "local: %s: %sn", argv[2],
  709. strerror(errno));
  710. return (0);
  711.       }
  712.       restart_point = stbuf.st_size;
  713.     } else {
  714.       if (ret == 0) {
  715. int overbose;
  717. overbose = verbose;
  718. if (debug == 0)
  719.   verbose = -1;
  720. if (command("MDTM %s", argv[1]) == COMPLETE) {
  721.   int yy, mo, day, hour, min, sec;
  722.   struct tm *tm;
  723.   verbose = overbose;
  724.   sscanf(reply_string,
  725.  "%*s %04d%02d%02d%02d%02d%02d",
  726.  &yy, &mo, &day, &hour, &min, &sec);
  727.   tm = gmtime(&stbuf.st_mtime);
  728.   tm->tm_mon++;
  729.   if (tm->tm_year > yy%100)
  730.     return (1);
  731.   else if (tm->tm_year == yy%100) {
  732.     if (tm->tm_mon > mo)
  733.       return (1);
  734.   } else if (tm->tm_mon == mo) {
  735.     if (tm->tm_mday > day)
  736.       return (1);
  737.   } else if (tm->tm_mday == day) {
  738.     if (tm->tm_hour > hour)
  739.       return (1);
  740.   } else if (tm->tm_hour == hour) {
  741.     if (tm->tm_min > min)
  742.       return (1);
  743.   } else if (tm->tm_min == min) {
  744.     if (tm->tm_sec > sec)
  745.       return (1);
  746.   }
  747. } else {
  748.   printf("%sn", reply_string);
  749.   verbose = overbose;
  750.   return (0);
  751. }
  752.       }
  753.     }
  754.   }
  755.     
  756.   recvrequest("RETR", argv[2], argv[1], mode,
  757.       argv[1] != oldargv1 || argv[2] != oldargv2);
  758.   restart_point = 0;
  759.   return (0);
  760. }
  762. void reget(int argc, char *argv[]) {
  763.   getit(argc, argv, 1, "r+w");
  764. }
  766. void get(int argc, char *argv[]){
  767.   getit(argc, argv, 0, restart_point ? "r+w" : "w" );
  768. }
  770. /* Get multiple files.                                                       */
  771. void mget(int argc, char **argv) {
  772.   extern jmp_buf jabort;
  773.   sig_t oldintr;
  774.   int ointer;
  776.   char *cp, *tp, *tp2, tmpbuf[MAXPATHLEN];
  777.   void mabort();
  779.   if (argc < 2 && !another(&argc, &argv, "remote-files")) {
  780.     printf("usage: %s remote-filesn", argv[0]);
  781.     code = -1;
  782.     return;
  783.   }
  785.   mname = argv[0];
  786.   mflag = 1;
  787.   oldintr = (sig_t)Signal(SIGINT,mabort);
  788.   setjmp(jabort);
  790.   while ((cp = remglob(argv,proxy)) != NULL) {
  791.     if (*cp == '') {
  792.       mflag = 0;
  793.       continue;
  794.     }
  796.     if (mflag && confirm(argv[0], cp)) {
  797.       tp = cp;
  798.       if (mcase) {
  799. while (*tp && !islower(*tp)) {
  800.   tp++;
  801. }
  802. if (!*tp) {
  803.   tp = cp;
  804.   tp2 = tmpbuf;
  805.     
  806.   while ((*tp2 = *tp)) {
  807.     if (isupper(*tp2)) *tp2 = tolower(*tp2);
  808.     tp2++;
  809.     tp++;
  810.   }
  811. }
  812. tp = tmpbuf;
  813.       }
  815.       if (ntflag) {
  816. tp = dotrans(tp);
  817.       }
  819.       if (mapflag) {
  820. tp = domap(tp);
  821.       }
  823.       recvrequest("RETR", tp, cp, "w", tp != cp || !interactive);
  825.       if (!mflag && fromatty) {
  826. ointer = interactive;
  827. interactive = 1;
  829. if (confirm("Continue with","mget")) {
  830.   mflag++;
  831. }
  832. interactive = ointer;
  833.       }
  834.     }
  835.   }
  837.   Signal(SIGINT,oldintr);
  838.   mflag = 0;
  839. }
  841. char *remglob(char *argv[], int doswitch) {
  842.   char temp[16];
  843.   static char buf[MAXPATHLEN];
  844.   static FILE *ftemp = NULL;
  845.   static char **args;
  846.   int oldverbose, oldhash;
  847.   char *cp, *mode;
  849.   if (!mflag) {
  850.     if (!doglob) {
  851.       args = NULL;
  852.     }
  853.     else {
  854.       if (ftemp) {
  855. fclose(ftemp);
  856. ftemp = NULL;
  857.       }
  858.     }
  859.     return(NULL);
  860.   }
  861.   if (!doglob) {
  862.     if (args == NULL)
  863.       args = argv;
  864.     if ((cp = *++args) == NULL)
  865.       args = NULL;
  866.     return (cp);
  867.   }
  868.   if (ftemp == NULL) {
  869.     strcpy(temp, _PATH_TMP);
  870.     mktemp(temp);
  871.     oldverbose = verbose, verbose = 0;
  872.     oldhash = hash, hash = 0;
  873.     if (doswitch) {
  874.       pswitch(!proxy);
  875.     }
  876.     for (mode = "w"; *++argv != NULL; mode = "a")
  877.       recvrequest ("NLST", temp, *argv, mode, 0);
  878.     if (doswitch) {
  879.       pswitch(!proxy);
  880.     }
  881.     verbose = oldverbose; hash = oldhash;
  882.     ftemp = fopen(temp, "r");
  883.     unlink(temp);
  884.     if (ftemp == NULL) {
  885.       printf("can't find list of remote files, oopsn");
  886.       return (NULL);
  887.     }
  888.   }
  889.   if (fgets(buf, sizeof (buf), ftemp) == NULL) {
  890.     fclose(ftemp), ftemp = NULL;
  891.     return (NULL);
  892.   }
  893.   if ((cp = index(buf, 'n')) != NULL)
  894.     *cp = '';
  895.   return (buf);
  896. }
  898. char *onoff(int bool) {
  899.   return (bool ? "on" : "off");
  900. }
  902. /* Show status.                                                              */
  903. /*                                                                           */
  904. /* ARGSUSED                                                                  */
  905. void status(int argc, char *argv[]) {
  906.   int i;
  908.   if (connected) {
  909.     printf("Connected to %s.n", hostname);
  910.   } else {
  911.     printf("Not connected.n");
  912.   }
  914.   if (!proxy) {
  915.     pswitch(1);
  916.     if (connected) {
  917.       printf("Connected for proxy commands to %s.n", hostname);
  918.     } else {
  919.       printf("No proxy connection.n");
  920.     }
  921.     pswitch(0);
  922.   }
  924.   printf("Mode: %s; Type: %s; Form: %s; Structure: %sn",
  925.  modename, typename, formname, structname);
  926.   printf("Verbose: %s; Bell: %s; Prompting: %s; Globbing: %sn", 
  927.  onoff(verbose), onoff(bell), onoff(interactive),
  928.  onoff(doglob));
  929.   printf("Store unique: %s; Receive unique: %sn", onoff(sunique),
  930.  onoff(runique));
  931.   printf("Case: %s; CR stripping: %sn",onoff(mcase),onoff(crflag));
  933.   if (ntflag) {
  934.     printf("Ntrans: (in) %s (out) %sn", ntin,ntout);
  935.   } else {
  936.     printf("Ntrans: offn");
  937.   }
  939.   if (mapflag) {
  940.     printf("Nmap: (in) %s (out) %sn", mapin, mapout);
  941.   } else {
  942.     printf("Nmap: offn");
  943.   }
  944.     
  945.   printf("Hash mark printing: %s; Use of PORT cmds: %sn",
  946.  onoff(hash), onoff(sendport));
  948.   if (macnum > 0) {
  949.     printf("Macros:n");
  950.     for (i=0; i<macnum; i++) {
  951.       printf("t%sn",macros[i].mac_name);
  952.     }
  953.   }
  955.   code = 0;
  956. }
  958. /* Set beep on cmd completed mode.                                           */
  959. /*                                                                           */
  960. /* VARARGS                                                                   */
  961. void setbell() {
  962.   bell = !bell;
  963.   printf("Bell mode %s.n", onoff(bell));
  964.   code = bell;
  965. }
  967. /* Turn on packet tracing.                                                   */
  968. /*                                                                           */
  969. /* VARARGS                                                                   */
  970. void settrace() {
  971.   trace = !trace;
  972.   printf("Packet tracing %s.n", onoff(trace));
  973.   code = trace;
  974. }
  976. /* Toggle hash mark printing during transfers.                               */
  977. /*                                                                           */
  978. /* VARARGS                                                                   */
  979. void sethash() {
  980.   hash = !hash;
  981.   printf("Hash mark printing %s", onoff(hash));
  982.   code = hash;
  984.   if (hash)
  985.     printf(" (%d bytes/hash mark)", 1024);
  986.   printf(".n");
  987. }
  989. /* Turn on printing of server echo's.                                        */
  990. /*                                                                           */
  991. /* VARARGS                                                                   */
  992. void setverbose() {
  993.   verbose = !verbose;
  994.   printf("Verbose mode %s.n", onoff(verbose));
  995.   code = verbose;
  996. }
  998. /* Toggle PORT cmd use before each data connection.                          */
  999. /*                                                                           */
  1000. /* VARARGS                                                                   */
  1001. void setport() {
  1002.   sendport = !sendport;
  1003.   printf("Use of PORT cmds %s.n", onoff(sendport));
  1004.   code = sendport;
  1005. }
  1007. /* Turn on interactive prompting during mget, mput, and mdelete.             */
  1008. /*                                                                           */
  1009. /* VARARGS                                                                   */
  1010. void setprompt() {
  1011.   interactive = !interactive;
  1012.   printf("Interactive mode %s.n", onoff(interactive));
  1013.   code = interactive;
  1014. }
  1016. /* Toggle metacharacter interpretation on local file names.                  */
  1017. /*                                                                           */
  1018. /* VARARGS                                                                   */
  1019. void setglob() {
  1020.   doglob = !doglob;
  1021.   printf("Globbing %s.n", onoff(doglob));
  1022.   code = doglob;
  1023. }
  1025. /* Set debugging mode on/off and/or set level of debugging.                  */
  1026. /*                                                                           */
  1027. /* VARARGS                                                                   */
  1028. void setdebug(int argc, char *argv[]) {
  1029.   int val;
  1031.   if (argc > 1) {
  1032.     val = atoi(argv[1]);
  1033.     if (val < 0) {
  1034.       printf("%s: bad debugging value.n", argv[1]);
  1035.       code = -1;
  1036.       return;
  1037.     }
  1038.   } else
  1039.     val = !debug;
  1040.   debug = val;
  1041.   if (debug)
  1042.     options |= SO_DEBUG;
  1043.   else
  1044.     options &= ~SO_DEBUG;
  1046.   printf("Debugging %s (debug=%d).n", onoff(debug), debug);
  1047.   code = debug > 0;
  1048. }
  1050. /* Set current working directory on remote machine.                          */
  1051. void cd(int argc, char **argv) {
  1052.   if (argc < 2 && !another(&argc, &argv, "remote-directory")) {
  1053.     printf("usage: %s remote-directoryn", argv[0]);
  1054.     code = -1;
  1055.     return;
  1056.   }
  1058.   if (command("CWD %s", argv[1]) == ERROR && code == 500) {
  1059.     if (verbose) printf("CWD command not recognized, trying XCWDn");
  1060.     command("XCWD %s", argv[1]);
  1061.   }
  1062. }
  1064. /* Set current working directory on local machine.                           */
  1065. void lcd(int argc, char **argv) {
  1066.   char buf[MAXPATHLEN];
  1068.   if (argc < 2)
  1069.     argc++, argv[1] = home;
  1070.   if (argc != 2) {
  1071.     printf("usage: %s local-directoryn", argv[0]);
  1072.     code = -1;
  1073.     return;
  1074.   }
  1075.   if (!globulize(&argv[1])) {
  1076.     code = -1;
  1077.     return;
  1078.   }
  1079.   if (chdir(argv[1]) < 0) {
  1080.     fprintf(stderr, "local: %s: %sn", argv[1], strerror(errno));
  1081.     code = -1;
  1082.     return;
  1083.   }
  1084. #ifdef HAVE_GETCWD
  1085.   printf("Local directory now %sn", getcwd(buf, MAXPATHLEN-1));
  1086. #else
  1087.   printf("Local directory now %sn", getwd(buf));
  1088. #endif
  1089.   code = 0;
  1090. }
  1092. /* Delete a single file.                                                     */
  1093. void delete(int argc, char *argv[]) {
  1094.   if (argc < 2 && !another(&argc, &argv, "remote-file")) {
  1095.     printf("usage: %s remote-filen", argv[0]);
  1096.     code = -1;
  1097.     return;
  1098.   }
  1100.   command("DELE %s", argv[1]);
  1101. }
  1103. /* Delete multiple files.                                                    */
  1104. void mdelete(int argc, char *argv[]) {
  1105.   extern jmp_buf jabort;
  1106.   sig_t oldintr;
  1107.   int ointer;
  1108.   char *cp;
  1109.   void mabort();
  1110.     
  1111.   if (argc < 2 && !another(&argc, &argv, "remote-files")) {
  1112.     printf("usage: %s remote-filesn", argv[0]);
  1113.     code = -1;
  1114.     return;
  1115.   }
  1117.   mflag = 1;
  1118.   mname = argv[0];
  1119.   oldintr = (sig_t)Signal(SIGINT, mabort);
  1120.   setjmp(jabort);
  1122.   while ((cp = remglob(argv,0)) != NULL) {
  1123.     if (*cp == '') {
  1124.       mflag = 0;
  1125.       continue;
  1126.     }
  1128.     if (mflag && confirm(argv[0], cp)) {
  1129.       command("DELE %s", cp);
  1130.       if (!mflag && fromatty) {
  1131. ointer = interactive;
  1132. interactive = 1;
  1133. if (confirm("Continue with", "mdelete")) {
  1134.   mflag++;
  1135. }
  1136. interactive = ointer;
  1137.       }
  1138.     }
  1139.   }
  1141.   Signal(SIGINT, oldintr);
  1142.   mflag = 0;
  1143. }
  1145. /* Rename a remote file.                                                     */
  1146. void renamefile(int argc, char *argv[]) {
  1148.   if (argc < 2 && !another(&argc, &argv, "from-name"))
  1149.     goto usage;
  1150.   if (argc < 3 && !another(&argc, &argv, "to-name")) {
  1151.   usage:
  1152.     printf("%s from-name to-namen", argv[0]);
  1153.     code = -1;
  1154.     return;
  1155.   }
  1157.   if (command("RNFR %s", argv[1]) == CONTINUE)
  1158.     command("RNTO %s", argv[2]);
  1159. }
  1161. /* Get a directory listing                                                   */
  1162. /* of remote files.                                                          */
  1163. void ls(int argc, char *argv[]) {
  1164.   char *cmd;
  1166.   if (argc < 2) argc++, argv[1] = NULL;
  1167.   if (argc < 3) argc++, argv[2] = "-";
  1169.   if (argc > 3) {
  1170.     printf("usage: %s remote-directory local-filen", argv[0]);
  1171.     code = -1;
  1172.     return;
  1173.   }
  1175.   cmd = argv[0][0] == 'n' ? "NLST" : "LIST";
  1177.   if (strcmp(argv[2], "-") && !globulize(&argv[2])) {
  1178.     code = -1;
  1179.     return;
  1180.   }
  1182.   if (strcmp(argv[2], "-") && *argv[2] != '|')
  1183.     if (!globulize(&argv[2]) || !confirm("output to local-file:", argv[2])) {
  1184.       code = -1;
  1185.       return;
  1186.     }
  1188.   recvrequest(cmd, argv[2], argv[1], "w", 0);
  1189. }
  1191. /* Get a directory listing                                                   */
  1192. /* of multiple remote files.                                                 */
  1193. void mls(int argc, char **argv) {
  1194.   extern jmp_buf jabort;
  1195.   sig_t oldintr;
  1196.   int ointer, i;
  1197.   char *cmd, mode[1], *dest;
  1198.   void mabort();
  1200.   if (argc < 2 && !another(&argc, &argv, "remote-files"))
  1201.     goto usage;
  1202.   if (argc < 3 && !another(&argc, &argv, "local-file")) {
  1203.   usage:
  1204.     printf("usage: %s remote-files local-filen", argv[0]);
  1205.     code = -1;
  1206.     return;
  1207.   }
  1208.   dest = argv[argc - 1];
  1209.   argv[argc - 1] = NULL;
  1210.   if (strcmp(dest, "-") && *dest != '|')
  1211.     if (!globulize(&dest) ||
  1212. !confirm("output to local-file:", dest)) {
  1213.       code = -1;
  1214.       return;
  1215.     }
  1216.   cmd = argv[0][1] == 'l' ? "NLST" : "LIST";
  1217.   mname = argv[0];
  1218.   mflag = 1;
  1219.   oldintr = (sig_t)Signal(SIGINT, mabort);
  1220.   setjmp(jabort);
  1221.   for (i = 1; mflag && i < argc-1; ++i) {
  1222.     *mode = (i == 1) ? 'w' : 'a';
  1223.     recvrequest(cmd, dest, argv[i], mode, 0);
  1224.     if (!mflag && fromatty) {
  1225.       ointer = interactive;
  1226.       interactive = 1;
  1227.       if (confirm("Continue with", argv[0])) {
  1228. mflag ++;
  1229.       }
  1230.       interactive = ointer;
  1231.     }
  1232.   }
  1233.   Signal(SIGINT, oldintr);
  1234.   mflag = 0;
  1235. }
  1237. /* Do a shell escape                                                         */
  1238. /*                                                                           */
  1239. /* ARGSUSED                                                                  */
  1240. int shell(int argc, char **argv) {
  1241.   int pid;
  1242.   sig_t old1, old2;
  1243.   char shellnam[40], *shell, *namep; 
  1244.   int  status;
  1245.   old1 = (sig_t)Signal (SIGINT, SIG_IGN);
  1246.   old2 = (sig_t)Signal (SIGQUIT, SIG_IGN);
  1247.   if ((pid = fork()) == 0) {
  1248.     for (pid = 3; pid < 20; pid++)
  1249.       close(pid);
  1250.     Signal(SIGINT, SIG_DFL);
  1251.     Signal(SIGQUIT, SIG_DFL);
  1252.     shell = getenv("SHELL");
  1253.     if (shell == NULL)
  1254.       shell = _PATH_BSHELL;
  1255.     namep = rindex(shell,'/');
  1256.     if (namep == NULL)
  1257.       namep = shell;
  1258.     strcpy(shellnam,"-");
  1259.     strcat(shellnam, ++namep);
  1260.     if (strcmp(namep, "sh") != 0)
  1261.       shellnam[0] = '+';
  1262.     if (debug) {
  1263.       printf ("%sn", shell);
  1264.       fflush (stdout);
  1265.     }
  1266.     if (argc > 1) {
  1267.       execl(shell,shellnam,"-c",altarg,(char *)0);
  1268.     }
  1269.     else {
  1270.       execl(shell,shellnam,(char *)0);
  1271.     }
  1272.     perror(shell);
  1273.     code = -1;
  1274.     exit(1);
  1275.   }
  1276.   if (pid > 0)
  1277.     while (wait(&status) != pid) ;
  1278.   Signal(SIGINT, old1);
  1279.   Signal(SIGQUIT, old2);
  1280.   if (pid == -1) {
  1281.     perror("Try again later");
  1282.     code = -1;
  1283.   }
  1284.   else {
  1285.     code = 0;
  1286.   }
  1287.   return (0);
  1288. }
  1290. /* Send new user information (re-login)                                      */
  1291. int user(int argc, char **argv) {
  1292.   char acct[80], *getpass();
  1293.   int n, aflag = 0;
  1295.   if (argc < 2) {
  1296.     another(&argc, &argv, "username");
  1297.   }
  1299.   if (argc < 2 || argc > 4) {
  1300.     printf("usage: %s username [password] [account]n", argv[0]);
  1301.     code = -1;
  1302.     return (0);
  1303.   }
  1305.   if ((n = command("USER %s", argv[1])) == CONTINUE) {
  1306.     if (argc < 3 ){
  1307.       if (!strcmp(argv[1], "anonymous") || !strcmp(argv[1], "ftp")) {
  1308. printf("Password: "); fflush(stdout);
  1309. fgets(acct, sizeof(acct) - 1, stdin);
  1310. acct[strlen(acct) - 1] = '';
  1311. argv[2] = acct;
  1312.       } else
  1313. argv[2] = getpass("Password: ");
  1314.       argc++;
  1315.     }
  1316.     n = command("PASS %s", argv[2]);
  1317.   }
  1319.   if (n == CONTINUE) {
  1320.     if (argc < 4) {
  1321.       printf("Account: "); fflush(stdout);
  1322.       fgets(acct, sizeof(acct) - 1, stdin);
  1323.       acct[strlen(acct) - 1] = '';
  1324.       argv[3] = acct; argc++;
  1325.     }
  1326.     n = command("ACCT %s", argv[3]);
  1327.     aflag++;
  1328.   }
  1329.   if (n != COMPLETE) {
  1330.     fprintf(stdout, "Login failed.n");
  1331.     return (0);
  1332.   }
  1333.   if (!aflag && argc == 4) {
  1334.     command("ACCT %s", argv[3]);
  1335.   }
  1336.   return (1);
  1337. }
  1339. /* Print working directory.                                                  */
  1340. /*                                                                           */
  1341. /* VARARGS                                                                   */
  1342. void pwd() {
  1343.   int oldverbose = verbose;
  1345.   /* If we aren't verbose, this doesn't do anything!                         */
  1346.   verbose = 1;
  1347.   if (command("PWD") == ERROR && code == 500) {
  1348.     printf("PWD command not recognized, trying XPWDn");
  1349.     command("XPWD");
  1350.   }
  1351.   verbose = oldverbose;
  1352. }
  1354. /* Make a directory.                                                         */
  1355. void makedir(int argc, char *argv[]) {
  1356.   if (argc < 2 && !another(&argc, &argv, "directory-name")) {
  1357.     printf("usage: %s directory-namen", argv[0]);
  1358.     code = -1;
  1359.     return;
  1360.   }
  1361.   if (command("MKD %s", argv[1]) == ERROR && code == 500) {
  1362.     if (verbose)
  1363.       printf("MKD command not recognized, trying XMKDn");
  1364.     command("XMKD %s", argv[1]);
  1365.   }
  1366. }
  1368. /* Remove a directory.                                                       */
  1369. void removedir(int argc, char *argv[]) {
  1370.   if (argc < 2 && !another(&argc, &argv, "directory-name")) {
  1371.     printf("usage: %s directory-namen", argv[0]);
  1372.     code = -1;
  1373.     return;
  1374.   }
  1375.   if (command("RMD %s", argv[1]) == ERROR && code == 500) {
  1376.     if (verbose)
  1377.       printf("RMD command not recognized, trying XRMDn");
  1378.     command("XRMD %s", argv[1]);
  1379.   }
  1380. }
  1382. /* Turn argv[1..argc) into a space-separated string, then prepend initial    */
  1383. /* text.  Send the result as a one-line command and get response.            */
  1384. void quote1(char *initial, int argc, char **argv) {
  1385.   register int i, len;
  1386.   char buf[BUFSIZ]; /* must be >= sizeof(line) */
  1388.   strcpy(buf, initial);
  1389.   if (argc > 1) {
  1390.     len = strlen(buf);
  1391.     len += strlen(strcpy(&buf[len], argv[1]));
  1392.     for (i = 2; i < argc; i++) {
  1393.       buf[len++] = ' ';
  1394.       len += strlen(strcpy(&buf[len], argv[i]));
  1395.     }
  1396.   }
  1397.   if (command(buf) == PRELIM) {
  1398.     while (getreply(0) == PRELIM);
  1399.   }
  1400. }
  1402. /* Send a line, verbatim, to the remote machine.                             */
  1403. void quote(int argc, char *argv[]) { 
  1404.   if (argc < 2 && !another(&argc, &argv, "command line to send")) {
  1405.     printf("usage: %s line-to-sendn", argv[0]);
  1406.     code = -1;
  1407.     return;
  1408.   }
  1409.   quote1("", argc, argv);
  1410. }
  1412. /* Send a SITE command to the remote machine.  The line                      */
  1413. /* is sent verbatim to the remote machine, except that the                   */
  1414. /* word "SITE" is added at the front.                                        */
  1415. void site(int argc, char *argv[]) {
  1416.   if (argc < 2 && !another(&argc, &argv, "arguments to SITE command")) {
  1417.     printf("usage: %s line-to-sendn", argv[0]);
  1418.     code = -1;
  1419.     return;
  1420.   }
  1421.   quote1("SITE ", argc, argv);
  1422. }
  1424. void do_chmod(int argc, char *argv[]) {
  1425.   if (argc < 2 && !another(&argc, &argv, "mode"))
  1426.     goto usage;
  1427.   if (argc < 3 && !another(&argc, &argv, "file-name")) {
  1428.   usage:
  1429.     printf("usage: %s mode file-namen", argv[0]);
  1430.     code = -1;
  1431.     return;
  1432.   }
  1433.   command("SITE CHMOD %s %s", argv[1], argv[2]);
  1434. }
  1436. void do_umask(int argc, char *argv[]) {
  1437.   int oldverbose = verbose;
  1439.   verbose = 1;
  1440.   command(argc == 1 ? "SITE UMASK" : "SITE UMASK %s", argv[1]);
  1441.   verbose = oldverbose;
  1442. }
  1444. void idletime(int argc, char *argv[]) {
  1445.   int oldverbose = verbose;
  1447.   verbose = 1;
  1448.   command(argc == 1 ? "SITE IDLE" : "SITE IDLE %s", argv[1]);
  1449.   verbose = oldverbose;
  1450. }
  1452. /* Ask the other side for help.                                              */
  1453. void rmthelp(int argc, char *argv[]) {
  1454.   int oldverbose = verbose;
  1456.   verbose = 1;
  1457.   command(argc == 1 ? "HELP" : "HELP %s", argv[1]);
  1458.   verbose = oldverbose;
  1459. }
  1461. /* Terminate session, but don't exit.                                        */
  1462. void disconnect() {
  1463.   extern FILE *cout;
  1464.   extern int data;
  1466.   if (!connected)
  1467.     return;
  1468.   command("QUIT");
  1469.   if (cout) {
  1470.     fclose(cout);
  1471.   }
  1472.   cout = NULL;
  1473.   connected = 0;
  1474.   data = -1;
  1475.   if (!proxy) {
  1476.     macnum = 0;
  1477.   }
  1478. }
  1480. /* Terminate session and exit.                                               */
  1481. /*                                                                           */
  1482. /* VARARGS                                                                   */
  1483. int quit() {
  1484.   if (connected) disconnect();
  1485.   pswitch(1);
  1487.   if (connected) disconnect();
  1488.   exit(0);
  1490.   return -1;
  1491. }
  1493. void fatal(char *msg) {
  1494.   fprintf(stderr, "ftp: %sn", msg);
  1495.   exit(1);
  1496. }
  1498. void account(int argc, char **argv) {
  1499.   char acct[50], *getpass(), *ap;
  1501.   if (argc > 1) {
  1502.     ++argv;
  1503.     --argc;
  1504.     strncpy(acct,*argv,49);
  1505.     acct[49] = '';
  1506.     while (argc > 1) {
  1507.       --argc;
  1508.       ++argv;
  1509.       strncat(acct,*argv, 49-strlen(acct));
  1510.     }
  1511.     ap = acct;
  1512.   }
  1513.   else {
  1514.     ap = getpass("Account:");
  1515.   }
  1516.   command("ACCT %s", ap);
  1517. }
  1519. jmp_buf abortprox;
  1521. void proxabort() {
  1522.   extern int proxy;
  1524.   if (!proxy) {
  1525.     pswitch(1);
  1526.   }
  1527.   if (connected) {
  1528.     proxflag = 1;
  1529.   }
  1530.   else {
  1531.     proxflag = 0;
  1532.   }
  1533.   pswitch(0);
  1534.   longjmp(abortprox,1);
  1535. }
  1537. void doproxy(int argc, char *argv[]) {
  1538.   extern jmp_buf abortprox;
  1539.   register struct cmd *c;
  1540.   struct cmd *getcmd();
  1541.   sig_t oldintr;
  1542.   void proxabort();
  1543.     
  1544.   if (argc < 2 && !another(&argc, &argv, "command")) {
  1545.     printf("usage: %s commandn", argv[0]);
  1546.     code = -1;
  1547.     return;
  1548.   }
  1549.   c = getcmd(argv[1]);
  1550.   if (c == (struct cmd *) -1) {
  1551.     printf("?Ambiguous commandn");
  1552.     fflush(stdout);
  1553.     code = -1;
  1554.     return;
  1555.   }
  1556.   if (c == 0) {
  1557.     printf("?Invalid commandn");
  1558.     fflush(stdout);
  1559.     code = -1;
  1560.     return;
  1561.   }
  1562.   if (!c->c_proxy) {
  1563.     printf("?Invalid proxy commandn");
  1564.     fflush(stdout);
  1565.     code = -1;
  1566.     return;
  1567.   }
  1568.   if (setjmp(abortprox)) {
  1569.     code = -1;
  1570.     return;
  1571.   }
  1572.   oldintr = (sig_t)Signal(SIGINT, proxabort);
  1573.   pswitch(1);
  1574.   if (c->c_conn && !connected) {
  1575.     printf("Not connectedn");
  1576.     fflush(stdout);
  1577.     pswitch(0);
  1578.     Signal(SIGINT, oldintr);
  1579.     code = -1;
  1580.     return;
  1581.   }
  1582.   (*c->c_handler)(argc-1, argv+1);
  1583.   if (connected) {
  1584.     proxflag = 1;
  1585.   }
  1586.   else {
  1587.     proxflag = 0;
  1588.   }
  1589.   pswitch(0);
  1590.   Signal(SIGINT, oldintr);
  1591. }
  1593. void setcase() {
  1594.   mcase = !mcase;
  1595.   printf("Case mapping %s.n", onoff(mcase));
  1596.   code = mcase;
  1597. }
  1599. void setcr() {
  1600.   crflag = !crflag;
  1601.   printf("Carriage Return stripping %s.n", onoff(crflag));
  1602.   code = crflag;
  1603. }
  1605. void setntrans(int argc, char *argv[]) {
  1606.   if (argc == 1) {
  1607.     ntflag = 0;
  1608.     printf("Ntrans off.n");
  1609.     code = ntflag;
  1610.     return;
  1611.   }
  1612.   ntflag++;
  1613.   code = ntflag;
  1614.   strncpy(ntin, argv[1], 16);
  1615.   ntin[16] = '';
  1616.   if (argc == 2) {
  1617.     ntout[0] = '';
  1618.     return;
  1619.   }
  1620.   strncpy(ntout, argv[2], 16);
  1621.   ntout[16] = '';
  1622. }
  1624. char *
  1625. dotrans(char *name)
  1626. {
  1627.   static char new[MAXPATHLEN];
  1628.   char *cp1, *cp2 = new;
  1629.   register int i, ostop, found;
  1631.   for (ostop = 0; *(ntout + ostop) && ostop < 16; ostop++);
  1632.   for (cp1 = name; *cp1; cp1++) {
  1633.     found = 0;
  1634.     for (i = 0; *(ntin + i) && i < 16; i++) {
  1635.       if (*cp1 == *(ntin + i)) {
  1636. found++;
  1637. if (i < ostop) {
  1638.   *cp2++ = *(ntout + i);
  1639. }
  1640. break;
  1641.       }
  1642.     }
  1643.     if (!found) {
  1644.       *cp2++ = *cp1;
  1645.     }
  1646.   }
  1647.   *cp2 = '';
  1648.   return(new);
  1649. }
  1651. void setnmap(int argc, char *argv[]) {
  1652.   char *cp;
  1653.     
  1654.   if (argc == 1) {
  1655.     mapflag = 0;
  1656.     printf("Nmap off.n");
  1657.     code = mapflag;
  1658.     return;
  1659.   }
  1661.   if (argc < 3 && !another(&argc, &argv, "mapout")) {
  1662.     printf("Usage: %s [mapin mapout]n",argv[0]);
  1663.     code = -1;
  1664.     return;
  1665.   }
  1667.   mapflag = 1;
  1668.   code = 1;
  1669.   cp = index(altarg, ' ');
  1671.   if (proxy) {
  1672.     while(*++cp == ' ');
  1673.     altarg = cp;
  1674.     cp = index(altarg, ' ');
  1675.   }
  1677.   *cp = '';
  1678.   strncpy(mapin, altarg, MAXPATHLEN - 1);
  1679.   while (*++cp == ' ');
  1680.   strncpy(mapout, cp, MAXPATHLEN - 1);
  1681. }
  1683. char *domap(char *name) {
  1684.   static char new[MAXPATHLEN];
  1685.   register char *cp1 = name, *cp2 = mapin;
  1686.   char *tp[9], *te[9];
  1687.   int i, toks[9], toknum = 0, match = 1;
  1689.   for (i=0; i < 9; ++i) {
  1690.     toks[i] = 0;
  1691.   }
  1693.   while (match && *cp1 && *cp2) {
  1694.     switch (*cp2) {
  1695.       case '\':
  1696. if (*++cp2 != *cp1) {
  1697.   match = 0;
  1698. }
  1699. break;
  1700.       case '$':
  1701. if (*(cp2+1) >= '1' && (*cp2+1) <= '9') {
  1702.   if (*cp1 != *(++cp2+1)) {
  1703.     toks[toknum = *cp2 - '1']++;
  1704.     tp[toknum] = cp1;
  1705.     while (*++cp1 && *(cp2+1) != *cp1);
  1706.     te[toknum] = cp1;
  1707.   }
  1708.   cp2++;
  1709.   break;
  1710. }
  1711. /* FALLTHROUGH */
  1712.       default:
  1713. if (*cp2 != *cp1) {
  1714.   match = 0;
  1715. }
  1716. break;
  1717.     }
  1719.     if (match && *cp1) {
  1720.       cp1++;
  1721.     }
  1722.     if (match && *cp2) {
  1723.       cp2++;
  1724.     }
  1725.   }
  1727.   if (!match && *cp1) {
  1728.     /* last token mismatch */
  1729.     toks[toknum] = 0;
  1730.   }
  1732.   cp1  = new;
  1733.   *cp1 = '';
  1734.   cp2  = mapout;
  1736.   while (*cp2) {
  1737.     match = 0;
  1738.     switch (*cp2) {
  1739.       case '\':
  1740. if (*(cp2 + 1)) {
  1741.   *cp1++ = *++cp2;
  1742. }
  1743. break;
  1744.       case '[':
  1745.     LOOP:
  1746.       if (*++cp2 == '$' && isdigit(*(cp2+1))) { 
  1747. if (*++cp2 == '0') {
  1748.   char *cp3 = name;
  1750.   while (*cp3) {
  1751.     *cp1++ = *cp3++;
  1752.   }
  1753.   match = 1;
  1754. } else if (toks[toknum = *cp2 - '1']) {
  1755.   char *cp3 = tp[toknum];
  1757.   while (cp3 != te[toknum]) {
  1758.     *cp1++ = *cp3++;
  1759.   }
  1760.   match = 1;
  1761. }
  1762.       } else {
  1763. while (*cp2 && *cp2 != ',' && *cp2 != ']') {
  1764.   if (*cp2 == '\') {
  1765.     cp2++;
  1766.   } else if (*cp2 == '$' && isdigit(*(cp2+1))) {
  1767.     if (*++cp2 == '0') {
  1768.       char *cp3 = name;
  1770.       while (*cp3) {
  1771. *cp1++ = *cp3++;
  1772.       }
  1773.     } else if (toks[toknum = *cp2 - '1']) {
  1774.       char *cp3=tp[toknum];
  1776.       while (cp3 != te[toknum]) {
  1777. *cp1++ = *cp3++;
  1778.       }
  1779.     }
  1780.   } else if (*cp2) {
  1781.     *cp1++ = *cp2++;
  1782.   }
  1783. }
  1785. if (!*cp2) {
  1786.   printf("nmap: unbalanced bracketsn");
  1787.   return(name);
  1788. }
  1790. match = 1;
  1791. cp2--;
  1792.       }
  1794.       if (match) {
  1795. while (*++cp2 && *cp2 != ']') {
  1796.   if (*cp2 == '\' && *(cp2 + 1)) {
  1797.     cp2++;
  1798.   }
  1799. }
  1801. if (!*cp2) {
  1802.   printf("nmap: unbalanced bracketsn");
  1803.   return(name);
  1804. }
  1806. break;
  1807.       }
  1809.       switch (*++cp2) {
  1810. case ',':
  1811.   goto LOOP;
  1812. case ']':
  1813.   break;
  1814. default:
  1815.   cp2--;
  1816.   goto LOOP;
  1817.       }
  1820.       break;
  1821.       case '$':
  1822. if (isdigit(*(cp2 + 1))) {
  1823.   if (*++cp2 == '0') {
  1824.     char *cp3 = name;
  1826.     while (*cp3) {
  1827.       *cp1++ = *cp3++;
  1828.     }
  1829.   } else if (toks[toknum = *cp2 - '1']) {
  1830.     char *cp3 = tp[toknum];
  1832.     while (cp3 != te[toknum]) {
  1833.       *cp1++ = *cp3++;
  1834.     }
  1835.   }
  1836.   break;
  1837. }
  1839. /* intentional drop through */
  1840.       default:
  1841. *cp1++ = *cp2;
  1842. break;
  1843.     }
  1845.     cp2++;
  1846.   }
  1848.   *cp1 = '';
  1850.   if (!*new) {
  1851.     return(name);
  1852.   }
  1854.   return(new);
  1855. }
  1857. void setsunique() {
  1858.   sunique = !sunique;
  1859.   printf("Store unique %s.n", onoff(sunique));
  1860.   code = sunique;
  1861. }
  1863. void setrunique() {
  1864.   runique = !runique;
  1865.   printf("Receive unique %s.n", onoff(runique));
  1866.   code = runique;
  1867. }
  1869. /* change directory to perent directory                                      */
  1870. void cdup() {
  1871.   if (command("CDUP") == ERROR && code == 500) {
  1872.     if (verbose) printf("CDUP command not recognized, trying XCUPn");
  1873.     command("XCUP");
  1874.   }
  1875. }
  1877. /* restart transfer at specific point                                        */
  1878. void restart(int argc, char *argv[]) {
  1879.   extern long atol();
  1881.   if (argc != 2) {
  1882.     printf("restart: offset not specifiedn");
  1883.   } else {
  1884.     restart_point = atol(argv[1]);
  1885.     printf("restarting at %ld. execute get, put or append to initiate transfern", (long)restart_point);
  1886.   }
  1887. }
  1889. /* show remote system type                                                   */
  1890. void syst() {
  1891.   command("SYST");
  1892. }
  1894. void macdef(int argc, char *argv[]) {
  1895.   char *tmp;
  1896.   int c;
  1898.   if (macnum == 16) {
  1899.     printf("Limit of 16 macros have already been definedn");
  1900.     code = -1;
  1901.     return;
  1902.   }
  1904.   if (argc < 2 && !another(&argc, &argv, "macro name")) {
  1905.     printf("Usage: %s macro_namen",argv[0]);
  1906.     code = -1;
  1907.     return;
  1908.   }
  1910.   if (interactive) {
  1911.     printf("Enter macro line by line, terminating it with a null linen");
  1912.   }
  1914.   strncpy(macros[macnum].mac_name, argv[1], 8);
  1916.   if (macnum == 0) {
  1917.     macros[macnum].mac_start = macbuf;
  1918.   } else {
  1919.     macros[macnum].mac_start = macros[macnum - 1].mac_end + 1;
  1920.   }
  1922.   tmp = macros[macnum].mac_start;
  1924.   while (tmp != macbuf+4096) {
  1925.     if ((c = getchar()) == EOF) {
  1926.       printf("macdef:end of file encounteredn");
  1927.       code = -1;
  1928.       return;
  1929.     }
  1931.     if ((*tmp = c) == 'n') {
  1932.       if (tmp == macros[macnum].mac_start) {
  1933. macros[macnum++].mac_end = tmp;
  1934. code = 0;
  1935. return;
  1936.       }
  1938.       if (*(tmp-1) == '') {
  1939. macros[macnum++].mac_end = tmp - 1;
  1940. code = 0;
  1941. return;
  1942.       }
  1943.     
  1944.       *tmp = '';
  1945.     }
  1947.     tmp++;
  1948.   }
  1950.   while (1) {
  1951.     while ((c = getchar()) != 'n' && c != EOF) /* LOOP */;
  1953.     if (c == EOF || getchar() == 'n') {
  1954.       printf("Macro not defined - 4k buffer exceededn");
  1955.       code = -1;
  1956.       return;
  1957.     }
  1958.   }
  1959. }
  1961. /* get size of file on remote machine                                        */
  1962. void sizecmd(int argc, char *argv[]) {
  1963.   if (argc < 2 && !another(&argc, &argv, "filename")) {
  1964.     printf("usage: %s filenamen", argv[0]);
  1965.     code = -1;
  1966.     return;
  1967.   }
  1969.   command("SIZE %s", argv[1]);
  1970. }
  1972. /* get last modification time of file on remote machine                      */
  1973. void modtime(int argc, char *argv[]) {
  1974.   int overbose;
  1976.   if (argc < 2 && !another(&argc, &argv, "filename")) {
  1977.     printf("usage: %s filenamen", argv[0]);
  1978.     code = -1;
  1979.     return;
  1980.   }
  1982.   overbose = verbose;
  1983.     
  1984.   if (debug == 0) {
  1985.     verbose = -1;
  1986.   }
  1987.     
  1988.   if (command("MDTM %s", argv[1]) == COMPLETE) {
  1989.     int yy, mo, day, hour, min, sec;
  1991.     sscanf(reply_string, "%*s %04d%02d%02d%02d%02d%02d", &yy, &mo, &day, &hour, &min, &sec);
  1992.     /* might want to print this in local time */
  1993.     printf("%st%02d/%02d/%04d %02d:%02d:%02d GMTn", argv[1], mo, day, yy, hour, min, sec);
  1994.   } else {
  1995.     printf("%sn", reply_string);
  1996.   }
  1998.   verbose = overbose;
  1999. }
  2001. /* show status on reomte machine                                             */
  2002. void rmtstatus(int argc, char *argv[]) {
  2003.   command(argc > 1 ? "STAT %s" : "STAT" , argv[1]);
  2004. }
  2006. /* get file if modtime is more recent than current file                      */
  2007. void newer(int argc, char *argv[]) {
  2008.   if (!getit(argc, argv, -1, "w")) return;
  2009.   printf("Local file "%s" is newer than remote file "%s"n", argv[1], argv[2]);
  2010. }