[BACK]Return to ftpcmd.y CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / libexec / ftpd

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/libexec/ftpd/ftpcmd.y between version 1.38 and 1.38.2.1

version 1.38, 1999/09/06 06:01:44 version 1.38.2.1, 1999/12/27 18:30:11
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
   /*-
    * Copyright (c) 1997-1999 The NetBSD Foundation, Inc.
    * All rights reserved.
    *
    * This code is derived from software contributed to The NetBSD Foundation
    * by Luke Mewburn.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the distribution.
    * 3. All advertising materials mentioning features or use of this software
    *    must display the following acknowledgement:
    *        This product includes software developed by the NetBSD
    *        Foundation, Inc. and its contributors.
    * 4. Neither the name of The NetBSD Foundation nor the names of its
    *    contributors may be used to endorse or promote products derived
    *    from this software without specific prior written permission.
    *
    * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
    * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
    * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
    * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
    * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    * POSSIBILITY OF SUCH DAMAGE.
    */
   
 /*  /*
  * Copyright (c) 1985, 1988, 1993, 1994   * Copyright (c) 1985, 1988, 1993, 1994
  *      The Regents of the University of California.  All rights reserved.   *      The Regents of the University of California.  All rights reserved.
Line 124  extern jmp_buf  errcatch;
Line 160  extern jmp_buf  errcatch;
         MAIL    MLFL    MRCP    MRSQ    MSAM    MSND          MAIL    MLFL    MRCP    MRSQ    MSAM    MSND
         MSOM          MSOM
   
         UMASK   IDLE    CHMOD          CHMOD   IDLE    RATEGET RATEPUT UMASK
   
         LEXERR          LEXERR
   
Line 132  extern jmp_buf  errcatch;
Line 168  extern jmp_buf  errcatch;
 %token  <s> ALL  %token  <s> ALL
 %token  <i> NUMBER  %token  <i> NUMBER
   
 %type   <i> check_login check_modify octal_number byte_size  %type   <i> check_login check_modify check_upload octal_number byte_size
 %type   <i> struct_code mode_code type_code form_code decimal_integer  %type   <i> struct_code mode_code type_code form_code decimal_integer
 %type   <s> pathstring pathname password username  %type   <s> pathstring pathname password username
 %type   <s> mechanism_name base64data prot_code  %type   <s> mechanism_name base64data prot_code
Line 165  cmd
Line 201  cmd
         | PASS SP password CRLF          | PASS SP password CRLF
                 {                  {
                         pass($3);                          pass($3);
                           memset($3, 0, strlen($3));
                         free($3);                          free($3);
                 }                  }
   
Line 245  cmd
Line 282  cmd
   
         | LPRT check_login SP host_long_port4 CRLF          | LPRT check_login SP host_long_port4 CRLF
                 {                  {
                           if ($2) {
   
                         /* reject invalid host_long_port4 */                          /* reject invalid host_long_port4 */
                         if (data_dest.su_family != AF_INET) {                          if (data_dest.su_family != AF_INET) {
                                 reply(500, "Illegal LPRT command rejected");                                  reply(500, "Illegal LPRT command rejected");
Line 269  cmd
Line 308  cmd
                                 }                                  }
                                 reply(200, "LPRT command successful.");                                  reply(200, "LPRT command successful.");
                         }                          }
   
                           }
                 }                  }
   
         | LPRT check_login SP host_long_port6 CRLF          | LPRT check_login SP host_long_port6 CRLF
                 {                  {
                           if ($2) {
   
                         /* reject invalid host_long_port6 */                          /* reject invalid host_long_port6 */
                         if (data_dest.su_family != AF_INET6) {                          if (data_dest.su_family != AF_INET6) {
                                 reply(500, "Illegal LPRT command rejected");                                  reply(500, "Illegal LPRT command rejected");
Line 297  cmd
Line 340  cmd
                                 }                                  }
                                 reply(200, "LPRT command successful.");                                  reply(200, "LPRT command successful.");
                         }                          }
   
                           }
                 }                  }
   
         | EPRT check_login SP STRING CRLF          | EPRT check_login SP STRING CRLF
Line 309  cmd
Line 354  cmd
                         struct addrinfo *res;                          struct addrinfo *res;
                         int i;                          int i;
   
                           if ($2) {
   
                         if (epsvall) {                          if (epsvall) {
                                 reply(501, "EPRT disallowed after EPSV ALL");                                  reply(501, "EPRT disallowed after EPSV ALL");
                                 goto eprt_done;                                  goto eprt_done;
Line 319  cmd
Line 366  cmd
                                 pdata = -1;                                  pdata = -1;
                         }                          }
   
                         /*XXX checks for login */                          tmp = xstrdup($4);
   
                         tmp = strdup($4);  
                         if (!tmp) {  
                                 fatal("not enough core.");  
                                 /*NOTREACHED*/  
                         }  
                         p = tmp;                          p = tmp;
                         delim = p[0];                          delim = p[0];
                         p++;                          p++;
Line 334  cmd
Line 375  cmd
                                 q = strchr(p, delim);                                  q = strchr(p, delim);
                                 if (!q || *q != delim) {                                  if (!q || *q != delim) {
                 parsefail:                  parsefail:
                                         reply(500, "Invalid argument, rejected.");                                          reply(500,
                                         if (tmp)                                              "Invalid argument, rejected.");
                                                 free(tmp);  
                                         usedefault = 1;                                          usedefault = 1;
                                         goto eprt_done;                                          goto eprt_done;
                                 }                                  }
Line 388  cmd
Line 428  cmd
                                         fail++;                                          fail++;
                                 switch (data_dest.su_family) {                                  switch (data_dest.su_family) {
                                 case AF_INET:                                  case AF_INET:
                                         fail += memcmp(&data_dest.su_sin.sin_addr,                                          fail += memcmp(
                                               &data_dest.su_sin.sin_addr,
                                             &his_addr.su_sin.sin_addr,                                              &his_addr.su_sin.sin_addr,
                                             sizeof(data_dest.su_sin.sin_addr));                                              sizeof(data_dest.su_sin.sin_addr));
                                         break;                                          break;
                                 case AF_INET6:                                  case AF_INET6:
                                         fail += memcmp(&data_dest.su_sin6.sin6_addr,                                          fail += memcmp(
                                               &data_dest.su_sin6.sin6_addr,
                                             &his_addr.su_sin6.sin6_addr,                                              &his_addr.su_sin6.sin6_addr,
                                             sizeof(data_dest.su_sin6.sin6_addr));                                              sizeof(data_dest.su_sin6.sin6_addr));
                                         break;                                          break;
Line 406  cmd
Line 448  cmd
                                         return (NULL);                                          return (NULL);
                                 }                                  }
                         }                          }
                         free(tmp);  
                         tmp = NULL;  
                         if (pdata >= 0) {                          if (pdata >= 0) {
                                 (void) close(pdata);                                  (void) close(pdata);
                                 pdata = -1;                                  pdata = -1;
                         }                          }
                         reply(200, "EPRT command successful.");                          reply(200, "EPRT command successful.");
                 eprt_done:;                  eprt_done:;
                           if (tmp != NULL)
                                   free(tmp);
   
                           }
                           free($4);
                 }                  }
   
         | PASV check_login CRLF          | PASV check_login CRLF
                 {                  {
                         if (curclass.passive) {                          if ($2) {
                                 passive();                                  if (curclass.passive)
                         } else {                                          passive();
                                 reply(500, "PASV mode not available.");                                  else
                                           reply(500, "PASV mode not available.");
                         }                          }
                 }                  }
   
         | LPSV CRLF          | LPSV check_login CRLF
                 {                  {
                         if (epsvall)                          if ($2) {
                                 reply(501, "LPSV disallowed after EPSV ALL");                                  if (epsvall)
                         else                                          reply(501,
                                 long_passive("LPSV", PF_UNSPEC);                                              "LPSV disallowed after EPSV ALL");
                                   else
                                           long_passive("LPSV", PF_UNSPEC);
                           }
                 }                  }
   
         | EPSV SP NUMBER CRLF          | EPSV check_login SP NUMBER CRLF
                 {                  {
                         int pf;                          if ($2) {
                         switch ($3) {                                  int pf;
                         case 1:  
                                 pf = PF_INET;                                  switch ($4) {
                                 break;                                  case 1:
                         case 2:                                          pf = PF_INET;
                                 pf = PF_INET6;                                          break;
                                 break;                                  case 2:
                         default:                                          pf = PF_INET6;
                                 pf = -1;        /*junk*/                                          break;
                                 break;                                  default:
                                           pf = -1;        /*junk*/
                                           break;
                                   }
                                   long_passive("EPSV", pf);
                         }                          }
                         long_passive("EPSV", pf);  
                 }                  }
   
         | EPSV SP ALL CRLF          | EPSV check_login SP ALL CRLF
                 {                  {
                         if (!logged_in) {                          if ($2) {
                                 syslog(LOG_NOTICE, "long passive but not logged in");  
                                 reply(503, "Login with USER first.");  
                         } else {  
                                 reply(200, "EPSV ALL command successful.");                                  reply(200, "EPSV ALL command successful.");
                                 epsvall++;                                  epsvall++;
                         }                          }
                 }                  }
   
         | EPSV CRLF          | EPSV check_login CRLF
                 {                  {
                         long_passive("EPSV", PF_UNSPEC);                          if ($2)
                                   long_passive("EPSV", PF_UNSPEC);
                 }                  }
   
         | TYPE SP type_code CRLF          | TYPE check_login SP type_code CRLF
                 {                  {
                           if ($2) {
   
                         switch (cmd_type) {                          switch (cmd_type) {
   
                         case TYPE_A:                          case TYPE_A:
Line 500  cmd
Line 552  cmd
                                 UNIMPLEMENTED for NBBY != 8                                  UNIMPLEMENTED for NBBY != 8
 #endif /* NBBY == 8 */  #endif /* NBBY == 8 */
                         }                          }
   
                           }
                 }                  }
   
         | STRU SP struct_code CRLF          | STRU check_login SP struct_code CRLF
                 {                  {
                         switch ($3) {                          if ($2) {
                                   switch ($4) {
   
                         case STRU_F:                                  case STRU_F:
                                 reply(200, "STRU F ok.");                                          reply(200, "STRU F ok.");
                                 break;                                          break;
   
                         default:                                  default:
                                 reply(504, "Unimplemented STRU type.");                                          reply(504, "Unimplemented STRU type.");
                                   }
                         }                          }
                 }                  }
   
         | MODE SP mode_code CRLF          | MODE check_login SP mode_code CRLF
                 {                  {
                         switch ($3) {                          if ($2) {
                                   switch ($4) {
   
                         case MODE_S:                                  case MODE_S:
                                 reply(200, "MODE S ok.");                                          reply(200, "MODE S ok.");
                                 break;                                          break;
   
                         default:                                  default:
                                 reply(502, "Unimplemented MODE type.");                                          reply(502, "Unimplemented MODE type.");
                                   }
                         }                          }
                 }                  }
   
Line 536  cmd
Line 594  cmd
                                 free($4);                                  free($4);
                 }                  }
   
         | STOR check_login SP pathname CRLF          | STOR check_upload SP pathname CRLF
                 {                  {
                         if ($2 && $4 != NULL)                          if ($2 && $4 != NULL)
                                 store($4, "w", 0);                                  store($4, "w", 0);
Line 544  cmd
Line 602  cmd
                                 free($4);                                  free($4);
                 }                  }
   
         | STOU check_login SP pathname CRLF          | STOU check_upload SP pathname CRLF
                 {                  {
                         if ($2 && $4 != NULL)                          if ($2 && $4 != NULL)
                                 store($4, "w", 1);                                  store($4, "w", 1);
Line 552  cmd
Line 610  cmd
                                 free($4);                                  free($4);
                 }                  }
   
         | APPE check_login SP pathname CRLF          | APPE check_upload SP pathname CRLF
                 {                  {
                         if ($2 && $4 != NULL)                          if ($2 && $4 != NULL)
                                 store($4, "a", 0);                                  store($4, "a", 0);
Line 560  cmd
Line 618  cmd
                                 free($4);                                  free($4);
                 }                  }
   
         | ALLO SP NUMBER CRLF          | ALLO check_login SP NUMBER CRLF
                 {                  {
                         reply(202, "ALLO command ignored.");                          if ($2)
                                   reply(202, "ALLO command ignored.");
                 }                  }
   
         | ALLO SP NUMBER SP R SP NUMBER CRLF          | ALLO check_login SP NUMBER SP R SP NUMBER CRLF
                 {                  {
                         reply(202, "ALLO command ignored.");                          if ($2)
                                   reply(202, "ALLO command ignored.");
                 }                  }
   
         | RNTO SP pathname CRLF          | RNTO check_login SP pathname CRLF
                 {                  {
                         if (fromname) {                          if ($2) {
                                 renamecmd(fromname, $3);                                  if (fromname) {
                                 free(fromname);                                          renamecmd(fromname, $4);
                                 fromname = NULL;                                          free(fromname);
                         } else {                                          fromname = NULL;
                                 reply(503, "Bad sequence of commands.");                                  } else {
                                           reply(503, "Bad sequence of commands.");
                                   }
                         }                          }
                         free($3);                          free($4);
                 }                  }
   
         | ABOR CRLF          | ABOR check_login CRLF
                 {                  {
                         reply(225, "ABOR command successful.");                          if ($2)
                                   reply(225, "ABOR command successful.");
                 }                  }
   
         | DELE check_modify SP pathname CRLF          | DELE check_modify SP pathname CRLF
Line 619  cmd
Line 682  cmd
   
         | LIST check_login CRLF          | LIST check_login CRLF
                 {                  {
                           char *argv[] = { INTERNAL_LS, "-lgA", NULL };
   
                         if ($2)                          if ($2)
                                 retrieve("/bin/ls -lgA", "");                                  retrieve(argv, "");
                 }                  }
   
         | LIST check_login SP pathname CRLF          | LIST check_login SP pathname CRLF
                 {                  {
                         if ($2 && $4 != NULL)                          char *argv[] = { INTERNAL_LS, "-lgA", NULL, NULL };
                                 retrieve("/bin/ls -lgA %s", $4);  
                           if ($2 && $4 != NULL) {
                                   argv[2] = $4;
                                   retrieve(argv, $4);
                           }
                         if ($4 != NULL)                          if ($4 != NULL)
                                 free($4);                                  free($4);
                 }                  }
Line 639  cmd
Line 708  cmd
   
         | NLST check_login SP STRING CRLF          | NLST check_login SP STRING CRLF
                 {                  {
                         if ($2 && $4 != NULL)                          if ($2)
                                 send_file_list($4);                                  send_file_list($4);
                         if ($4 != NULL)                          free($4);
                                 free($4);  
                 }                  }
   
         | SITE SP HELP CRLF          | SITE SP HELP CRLF
Line 650  cmd
Line 718  cmd
                         help(sitetab, NULL);                          help(sitetab, NULL);
                 }                  }
   
           | SITE SP CHMOD check_modify SP octal_number SP pathname CRLF
                   {
                           if ($4 && ($8 != NULL)) {
                                   if ($6 > 0777)
                                           reply(501,
                                   "CHMOD: Mode value must be between 0 and 0777");
                                   else if (chmod($8, $6) < 0)
                                           perror_reply(550, $8);
                                   else
                                           reply(200, "CHMOD command successful.");
                           }
                           if ($8 != NULL)
                                   free($8);
                   }
   
         | SITE SP HELP SP STRING CRLF          | SITE SP HELP SP STRING CRLF
                 {                  {
                         help(sitetab, $5);                          help(sitetab, $5);
                           free($5);
                   }
   
           | SITE SP IDLE check_login CRLF
                   {
                           if ($4) {
                                   reply(200,
                               "Current IDLE time limit is %d seconds; max %d",
                                       curclass.timeout, curclass.maxtimeout);
                           }
                   }
   
           | SITE SP IDLE check_login SP NUMBER CRLF
                   {
                           if ($4) {
                                   if ($6 < 30 || $6 > curclass.maxtimeout) {
                                           reply(501,
                               "IDLE time limit must be between 30 and %d seconds",
                                               curclass.maxtimeout);
                                   } else {
                                           curclass.timeout = $6;
                                           (void) alarm(curclass.timeout);
                                           reply(200,
                                               "IDLE time limit set to %d seconds",
                                               curclass.timeout);
                                   }
                           }
                   }
   
           | SITE SP RATEGET check_login CRLF
                   {
                           if ($4) {
                                   reply(200, "Current RATEGET is %d bytes/sec",
                                       curclass.rateget);
                           }
                   }
   
           | SITE SP RATEGET check_login SP STRING CRLF
                   {
                           char *p = $6;
                           int rate;
   
                           if ($4) {
                                   rate = strsuftoi(p);
                                   if (rate == -1)
                                           reply(501, "Invalid RATEGET %s", p);
                                   else if (curclass.maxrateget &&
                                       rate > curclass.maxrateget)
                                           reply(501,
                                   "RATEGET %d is larger than maximum RATEGET %d",
                                               rate, curclass.maxrateget);
                                   else {
                                           curclass.rateget = rate;
                                           reply(200,
                                               "RATEGET set to %d bytes/sec",
                                               curclass.rateget);
                                   }
                           }
                           free($6);
                   }
   
           | SITE SP RATEPUT check_login CRLF
                   {
                           if ($4) {
                                   reply(200, "Current RATEPUT is %d bytes/sec",
                                       curclass.rateput);
                           }
                   }
   
           | SITE SP RATEPUT check_login SP STRING CRLF
                   {
                           char *p = $6;
                           int rate;
   
                           if ($4) {
                                   rate = strsuftoi(p);
                                   if (rate == -1)
                                           reply(501, "Invalid RATEPUT %s", p);
                                   else if (curclass.maxrateput &&
                                       rate > curclass.maxrateput)
                                           reply(501,
                                   "RATEPUT %d is larger than maximum RATEPUT %d",
                                               rate, curclass.maxrateput);
                                   else {
                                           curclass.rateput = rate;
                                           reply(200,
                                               "RATEPUT set to %d bytes/sec",
                                               curclass.rateput);
                                   }
                           }
                           free($6);
                 }                  }
   
         | SITE SP UMASK check_login CRLF          | SITE SP UMASK check_login CRLF
Line 682  cmd
Line 856  cmd
                         }                          }
                 }                  }
   
         | SITE SP CHMOD check_modify SP octal_number SP pathname CRLF  
                 {  
                         if ($4 && ($8 != NULL)) {  
                                 if ($6 > 0777)  
                                         reply(501,  
                                 "CHMOD: Mode value must be between 0 and 0777");  
                                 else if (chmod($8, $6) < 0)  
                                         perror_reply(550, $8);  
                                 else  
                                         reply(200, "CHMOD command successful.");  
                         }  
                         if ($8 != NULL)  
                                 free($8);  
                 }  
   
         | SITE SP IDLE CRLF  
                 {  
                         reply(200,  
                             "Current IDLE time limit is %d seconds; max %d",  
                                 curclass.timeout, curclass.maxtimeout);  
                 }  
   
         | SITE SP IDLE SP NUMBER CRLF  
                 {  
                         if ($5 < 30 || $5 > curclass.maxtimeout) {  
                                 reply(501,  
                         "IDLE time limit must be between 30 and %d seconds",  
                                     curclass.maxtimeout);  
                         } else {  
                                 curclass.timeout = $5;  
                                 (void) alarm(curclass.timeout);  
                                 reply(200,  
                                     "IDLE time limit set to %d seconds",  
                                     curclass.timeout);  
                         }  
                 }  
   
         | SYST CRLF          | SYST CRLF
                 {                  {
                         reply(215, "UNIX Type: L%d %s", NBBY, version);                          reply(215, "UNIX Type: L%d %s", NBBY, version);
Line 756  cmd
Line 893  cmd
                                         help(sitetab, NULL);                                          help(sitetab, NULL);
                         } else                          } else
                                 help(cmdtab, $3);                                  help(cmdtab, $3);
                           free($3);
                 }                  }
   
         | NOOP CRLF          | NOOP CRLF
Line 767  cmd
Line 905  cmd
         | AUTH SP mechanism_name CRLF          | AUTH SP mechanism_name CRLF
                 {                  {
                         reply(502, "RFC 2228 authentication not implemented.");                          reply(502, "RFC 2228 authentication not implemented.");
                           free($3);
                 }                  }
   
         | ADAT SP base64data CRLF          | ADAT SP base64data CRLF
                 {                  {
                         reply(503,                          reply(503,
                             "Please set authentication state with AUTH.");                              "Please set authentication state with AUTH.");
                           free($3);
                 }                  }
   
         | PROT SP prot_code CRLF          | PROT SP prot_code CRLF
                 {                  {
                         reply(503,                          reply(503,
                             "Please set protection buffer size with PBSZ.");                              "Please set protection buffer size with PBSZ.");
                           free($3);
                 }                  }
   
         | PBSZ SP decimal_integer CRLF          | PBSZ SP decimal_integer CRLF
Line 795  cmd
Line 936  cmd
         | MIC SP base64data CRLF          | MIC SP base64data CRLF
                 {                  {
                         reply(502, "RFC 2228 authentication not implemented.");                          reply(502, "RFC 2228 authentication not implemented.");
                           free($3);
                 }                  }
   
         | CONF SP base64data CRLF          | CONF SP base64data CRLF
                 {                  {
                         reply(502, "RFC 2228 authentication not implemented.");                          reply(502, "RFC 2228 authentication not implemented.");
                           free($3);
                 }                  }
   
         | ENC SP base64data CRLF          | ENC SP base64data CRLF
                 {                  {
                         reply(502, "RFC 2228 authentication not implemented.");                          reply(502, "RFC 2228 authentication not implemented.");
                           free($3);
                 }                  }
   
                                                 /* RFC 2389 */                                                  /* RFC 2389 */
Line 821  cmd
Line 965  cmd
                 {                  {
   
                         opts($3);                          opts($3);
                           free($3);
                 }                  }
   
   
Line 879  cmd
Line 1024  cmd
         ;          ;
   
 rcmd  rcmd
         : REST SP byte_size CRLF          : REST check_login SP byte_size CRLF
                 {                  {
                         fromname = NULL;                          if ($2) {
                         restart_point = $3;     /* XXX $3 is only "int" */                                  fromname = NULL;
                         reply(350, "Restarting at %qd. %s",                                  restart_point = $4; /* XXX $3 is only "int" */
                             (qdfmt_t)restart_point,                                  reply(350, "Restarting at %qd. %s",
                                       (qdfmt_t)restart_point,
                             "Send STORE or RETRIEVE to initiate transfer.");                              "Send STORE or RETRIEVE to initiate transfer.");
                           }
                 }                  }
   
         | RNFR check_modify SP pathname CRLF          | RNFR check_modify SP pathname CRLF
                 {                  {
                         restart_point = (off_t) 0;                          restart_point = (off_t) 0;
                         if ($2 && $4) {                          if ($2 && $4) {
                                 fromname = renamefrom($4);                                  fromname = renamefrom($4);
                                 if (fromname == NULL && $4) {  
                                         free($4);  
                                 }  
                         }                          }
                           if ($4)
                                   free($4);
                 }                  }
         ;          ;
   
Line 1195  check_modify
Line 1342  check_modify
                         }                          }
                 }                  }
   
   check_upload
           : /* empty */
                   {
                           if (logged_in) {
                                   if (curclass.upload)
                                           $$ = 1;
                                   else {
                                           reply(502,
                                           "No permission to use this command.");
                                           $$ = 0;
                                           hasyyerrored = 1;
                                   }
                           } else {
                                   reply(530, "Please login with USER and PASS.");
                                   $$ = 0;
                                   hasyyerrored = 1;
                           }
                   }
   
   
 %%  %%
   
 #define CMD     0       /* beginning of command */  #define CMD     0       /* beginning of command */
Line 1294  struct tab cmdtab[] = {
Line 1461  struct tab cmdtab[] = {
 };  };
   
 struct tab sitetab[] = {  struct tab sitetab[] = {
         { "UMASK", UMASK, ARGS, 1, 0,   "[ <sp> umask ]" },  
         { "IDLE",  IDLE,  ARGS, 1, 0,   "[ <sp> maximum-idle-time ]" },  
         { "CHMOD", CHMOD, NSTR, 1, 0,   "<sp> mode <sp> file-name" },          { "CHMOD", CHMOD, NSTR, 1, 0,   "<sp> mode <sp> file-name" },
         { "HELP",  HELP,  OSTR, 1, 0,   "[ <sp> <string> ]" },          { "HELP",  HELP,  OSTR, 1, 0,   "[ <sp> <string> ]" },
           { "IDLE",  IDLE,  ARGS, 1, 0,   "[ <sp> maximum-idle-time ]" },
           { "RATEGET", RATEGET, OSTR, 1,0,"[ <sp> get-throttle-rate ]" },
           { "RATEPUT", RATEPUT, OSTR, 1,0,"[ <sp> put-throttle-rate ]" },
           { "UMASK", UMASK, ARGS, 1, 0,   "[ <sp> umask ]" },
         { NULL,    0,     0,    0, 0,   0 }          { NULL,    0,     0,    0, 0,   0 }
 };  };
   
Line 1396  getline(s, n, iop)
Line 1565  getline(s, n, iop)
                 return (NULL);                  return (NULL);
         *cs++ = '\0';          *cs++ = '\0';
         if (debug) {          if (debug) {
                 if (!guest && strncasecmp("pass ", s, 5) == 0) {                  if (curclass.type != CLASS_GUEST &&
                       strncasecmp("pass ", s, 5) == 0) {
                         /* Don't syslog passwords */                          /* Don't syslog passwords */
                         syslog(LOG_DEBUG, "command: %.5s ???", s);                          syslog(LOG_DEBUG, "command: %.5s ???", s);
                 } else {                  } else {
Line 1426  toolong(signo)
Line 1596  toolong(signo)
             curclass.timeout);              curclass.timeout);
         if (logging)          if (logging)
                 syslog(LOG_INFO, "User %s timed out after %d seconds",                  syslog(LOG_INFO, "User %s timed out after %d seconds",
                     (pw ? pw -> pw_name : "unknown"), curclass.timeout);                      (pw ? pw->pw_name : "unknown"), curclass.timeout);
         dologout(1);          dologout(1);
 }  }
   
Line 1450  yylex()
Line 1620  yylex()
                         dologout(0);                          dologout(0);
                 }                  }
                 (void) alarm(0);                  (void) alarm(0);
                   if ((cp = strchr(cbuf, '\r'))) {
                           *cp = '\0';
 #ifdef HASSETPROCTITLE  #ifdef HASSETPROCTITLE
                 if (strncasecmp(cbuf, "PASS", 4) != 0)                          if (strncasecmp(cbuf, "PASS", 4) != 0)
                         setproctitle("%s: %s", proctitle, cbuf);                                  setproctitle("%s: %s", proctitle, cbuf);
 #endif /* HASSETPROCTITLE */  #endif /* HASSETPROCTITLE */
                 if ((cp = strchr(cbuf, '\r'))) {  
                         *cp++ = '\n';                          *cp++ = '\n';
                         *cp = '\0';                          *cp = '\0';
                 }                  }
Line 1516  yylex()
Line 1687  yylex()
         dostr1:          dostr1:
                 if (cbuf[cpos] == ' ') {                  if (cbuf[cpos] == ' ') {
                         cpos++;                          cpos++;
                         state = state == OSTR ? STR2 : ++state;                          state = state == OSTR ? STR2 : state+1;
                         return (SP);                          return (SP);
                 }                  }
                 break;                  break;
Line 1832  opts(command)
Line 2003  opts(command)
                 return;                  return;
         }          }
   
         if (ep != NULL && *ep != '\0') {          if (ep != NULL && *ep != '\0')
                 if (c->options != NULL)                  REASSIGN(c->options, xstrdup(ep));
                         free(c->options);  
                 c->options = xstrdup(ep);  
         }  
         if (c->options != NULL)          if (c->options != NULL)
                 reply(200, "Options for %s are '%s'.", c->name, c->options);                  reply(200, "Options for %s are '%s'.", c->name, c->options);
         else          else

Legend:
Removed from v.1.38  
changed lines
  Added in v.1.38.2.1

CVSweb <webmaster@jp.NetBSD.org>