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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
mod_xfer.c
资源名称：proftpd-1.2.0pre8.tar.gz　[点击查看]
上传用户：pycemail
上传日期：2007-01-04
资源大小：329k
文件大小：26k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

mod_xfer.c：源码内容
  1. /*
  2.  * ProFTPD - FTP server daemon
  3.  * Copyright (c) 1997, 1998 Public Flood Software
  4.  * Copyright (C) 1999, MacGyver aka Habeeb J. Dihu <macgyver@tos.net>
  5.  *  
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  19.  */
  21. /*
  22.  * Data transfer module for ProFTPD
  23.  * $Id: mod_xfer.c,v 1.15 1999/10/01 07:57:31 macgyver Exp $
  24.  */
  26. /* History Log:
  27.  *
  28.  * 8/15/99
  29.  *   - rate control <grin@tolna.net>
  30.  * 4/24/97 0.99.0pl1
  31.  *   _translate_ascii was returning a buffer larger than the max buffer
  32.  *   size causing memory overrun and all sorts of neat corruption.
  33.  *   Status: Stomped
  34.  *
  35.  */
  37. #include "conf.h"
  38. #ifdef HAVE_REGEX_H
  39. #include <regex.h>
  40. #endif
  42. extern module auth_module;
  43. extern pid_t mpid;
  45. /* From the auth module */
  46. char *auth_map_uid(int);
  47. char *auth_map_gid(int);
  49. void xfer_abort(IOFILE*,int);
  51. /* Variables for this module */
  52. static fsdir_t *retr_file = NULL;
  53. static fsdir_t *stor_file = NULL;
  54. static int stor_fd;
  55. static int retr_fd;
  57. module xfer_module;
  59. static void _log_transfer(char direction)
  60. {
  61.   struct timeval end_time;
  62.   char *fullpath;
  64.   gettimeofday(&end_time,NULL);
  66.   end_time.tv_sec -= session.xfer.start_time.tv_sec;
  67.   if(end_time.tv_usec >= session.xfer.start_time.tv_usec)
  68.     end_time.tv_usec -= session.xfer.start_time.tv_usec;
  69.   else {
  70.     end_time.tv_usec = 1000000L - (session.xfer.start_time.tv_usec -
  71.                        end_time.tv_usec);
  72.     end_time.tv_sec--;
  73.   }
  75.   fullpath = dir_abs_path(session.xfer.p,session.xfer.path,TRUE);
  77.   if((session.flags & SF_ANON) != 0) {
  78.     log_xfer(end_time.tv_sec,session.c->remote_name,session.xfer.total_bytes,
  79.              fullpath,(session.flags & SF_ASCII ? 'a' : 'b'),
  80.              direction,'a',session.anon_user);
  81.   } else
  82.     log_xfer(end_time.tv_sec,session.c->remote_name,session.xfer.total_bytes,
  83.              fullpath,(session.flags & SF_ASCII ? 'a' : 'b'),
  84.              direction,'r',session.user);
  86.   log_debug(DEBUG1,"Transfer completed: %d bytes in %d.%02d seconds.",
  87.                  session.xfer.total_bytes,end_time.tv_sec,
  88.                  (end_time.tv_usec / 10000));
  90.   data_cleanup();
  91. }
  93. /* This routine counts the difference in usec between timeval's
  94.  */
  95. static float _rate_diffusec(struct timeval tlast, struct timeval t) {
  96.     float diffsec, diffusec;
  98.     diffsec = t.tv_sec - tlast.tv_sec;
  99.     diffusec= t.tv_usec- tlast.tv_usec;
  100.     log_debug(DEBUG5,"_rate_diffusec: last=%ld %ld  now=%ld %ld  diff=%f %f  res=%f",
  101.       tlast.tv_sec,tlast.tv_usec,
  102.       t.tv_sec,t.tv_usec,
  103.       diffsec, diffusec,
  104.       ( diffsec * 10e5 + diffusec ) );
  105.     return( diffsec * 10e5 + diffusec );
  106. }
  108. /* Bandwidth Throttling. <grin@tolna.net>
  109.  *
  110.  * If the rate sent were too high usleeps the required amount (max 100 sec).
  111.  * No throttling for the first FreeBytes bytes (but this includes REST as well).
  112.  * If HardBPS then forces BPS throughout FreeBytes as well.
  113.  *
  114.  * input:  rate_pos: position in file
  115.  *              rate_bytes:     bytes xferred (same as rate_pos if !REST)
  116.  *              rate_tvlast:    when the transfer was started
  117.  *              rate_freebytes: no throttling unless that many xferred
  118.  *              rate_bps:       max byte / sec bandwidth allowed
  119.  *              rate_hardbps:   if FALSE then forces BPS only after FreeBytes
  120.  */
  121. static void _rate_throttle(unsigned long rate_pos, long rate_bytes,
  122.    struct timeval rate_tvlast,
  123.    long rate_freebytes, long rate_bps,
  124.    int rate_hardbps)
  125. {
  126.   /* rate_tv:        now (the diff of those gives the time spent)
  127.    */
  128.   struct timeval rate_tv;
  129.   float dtime, wtime;
  131.   gettimeofday(&rate_tv, NULL);
  132.   
  133.   /* no rate control unless more than free bytes DL'ed */
  134.   log_debug(DEBUG5,
  135.     "_rate_throttle: rate_bytes=%ld  rate_pos=%ld  rate_freebytes=%ld  rate_bps=%ld  rate_hardbps=%i",
  136.     rate_bytes, rate_pos,
  137.     rate_freebytes, rate_bps, rate_hardbps);
  139.   if(rate_pos < rate_freebytes)
  140.     return;
  141.   
  142.   if(!rate_hardbps)
  143.     rate_bytes -= rate_freebytes;
  144.   
  145.   dtime = _rate_diffusec(rate_tvlast, rate_tv);
  146.   wtime = 10e5 * rate_bytes / rate_bps;
  147.   
  148.   if(wtime>dtime) {
  149.     /* too fast, doze a little */
  150.     log_debug(DEBUG5,"_rate_throttle: wtime=%f  dtime=%f",wtime,dtime);
  152.     if(wtime-dtime > 10e7) {
  153.       /* >100sec, umm that'd timeout */
  154.       log_debug(DEBUG5, "Sleeping 100 seconds.");
  155.       usleep( 10e7 );
  156.       log_debug(DEBUG5, "Sleeping 100 seconds done!");
  157.     } else {
  158.       log_debug(DEBUG5, "Sleeping %f sec.", (wtime - dtime) / 10e5);
  159.       usleep(wtime-dtime);
  160.       log_debug(DEBUG5, "Sleeping %f sec done!", (wtime - dtime) / 10e5);
  161.     }
  162.   }
  163. }
  165. static
  166. void _stor_done()
  167. {
  168.   fs_close(stor_file,stor_fd);
  169.   stor_file = NULL;
  171.   if(session.fsgid && session.xfer.path) {
  172.     struct stat sbuf;
  174.     fs_stat(session.xfer.path,&sbuf);
  175.     if(chown(session.xfer.path,(uid_t)-1,(gid_t)session.fsgid) == -1)
  176.       log_pri(LOG_WARNING,"chown(%s) failed: %s",
  177.               session.xfer.path,strerror(errno));
  178.     else
  179.       fs_chmod(session.xfer.path,sbuf.st_mode);
  180.   }
  181. }
  183. static
  184. void _retr_done()
  185. {
  186.   fs_close(retr_file,retr_fd);
  187.   retr_file = NULL;
  188. }
  190. static void _stor_abort() {
  191.   fs_close(stor_file,stor_fd);
  192.   stor_file = NULL;
  194.   if(session.xfer.xfer_type == STOR_HIDDEN) {
  195.     /* If hidden stor aborted, remove only hidden file, not real one */
  196.     if(session.xfer.path_hidden)
  197.       unlink(session.xfer.path_hidden);
  198.   } else if(session.xfer.path) {
  199.     unlink(session.xfer.path);
  200.   }
  201. }
  203. static void _retr_abort() {
  204.   /* Isn't necessary to send anything here, just cleanup */
  205.   fs_close(retr_file,retr_fd);
  206.   retr_file = NULL;
  207. }
  209. /* cmd_pre_stor is a PRE_CMD handler which checks security, etc, and
  210.  * places the full filename to receive in cmd->private [note that we CANNOT
  211.  * use cmd->tmp_pool for this, as tmp_pool only lasts for the duration
  212.  * of this function.
  213.  */
  215. MODRET pre_cmd_stor(cmd_rec *cmd) {
  216.   char *dir;
  217.   mode_t fmode;
  218.   privdata_t *p, *p_hidden;
  220.   if(cmd->argc < 2) {
  221.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  222.     return ERROR(cmd);
  223.   }
  225.   dir = dir_best_path(cmd->tmp_pool,cmd->arg);
  227.   if(!dir || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL)) {
  228.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  229.     return ERROR(cmd);
  230.   }
  232.   fmode = file_mode(dir);
  234.   if(fmode && (session.xfer.xfer_type != STOR_APPEND) && 
  235.        get_param_int(CURRENT_CONF,"AllowOverwrite",FALSE) != 1) {
  236.     add_response_err(R_550,"%s: Overwrite permission denied",cmd->arg);
  237.     return ERROR(cmd);
  238.   }
  240.   if(fmode && !S_ISREG(fmode)) {
  241.     add_response_err(R_550,"%s: Not a regular file",cmd->arg);
  242.     return ERROR(cmd);
  243.   }
  245.   /* If restarting, check permissions on this directory, if
  246.    * AllowStoreRestart is set, permit it
  247.    */
  249.   if(fmode &&
  250.      (session.restart_pos || (session.xfer.xfer_type == STOR_APPEND)) &&
  251.      get_param_int(CURRENT_CONF,"AllowStoreRestart",FALSE) != TRUE) {
  252.     add_response_err(R_451,"%s: Append/Restart not permitted, try again.",
  253.                   cmd->arg);
  254.     session.restart_pos = 0L;
  255.     session.xfer.xfer_type = STOR_DEFAULT;
  256.     return ERROR(cmd);
  257.   }
  259.   /* otherwise everthing is good */
  260.   p = mod_privdata_alloc(cmd, "stor_filename", strlen(dir) + 1);
  261.   sstrncpy(p->value.str_val, dir, strlen(dir) + 1);
  263.   if(get_param_int(CURRENT_CONF,"HiddenStor",FALSE) == 1) {
  264.     /* We have to also figure out the temporary hidden file name for
  265.      * receiving this transfer.
  266.      * Length is +5 due to .in. prepended and "." at end.
  267.      */
  269.     char *c;
  270.     int dotcount, foundslash, basenamestart, maxlen;
  272.     dotcount = foundslash = basenamestart = 0;
  274.     /* Figure out where the basename starts */
  275.     for (c=dir; *c; ++c) {
  276.       if (*c == '/') {
  277. foundslash = 1;
  278. basenamestart = dotcount = 0;
  279.       } else if (*c == '.') {
  280. ++ dotcount;
  282. /* Keep track of leading dots, ... is normal, . and .. are special.
  283.  * So if we exceed ".." it becomes a normal file, retroactively consider
  284.  * this the possible start of the basename
  285.  */
  286. if ((dotcount > 2) && (!basenamestart))
  287.   basenamestart = ((unsigned long)c - (unsigned long)dir) - dotcount;
  288.       } else {
  289. /* We found a nonslash, nondot character; if this is the first time
  290.  * we found one since the last slash, remember this as the possible
  291.  * start of the basename.
  292.  */
  293. if (!basenamestart)
  294.   basenamestart = ((unsigned long)c - (unsigned long)dir) - dotcount;
  295.       }
  296.     }
  298.     if (! basenamestart) {
  299.       /* This probably shouldn't happen */
  300.       add_response_err(R_451,"%s: Bad file name.", dir);
  301.       return ERROR(cmd);
  302.     }
  304.     maxlen = strlen(dir) + 1 + 5;
  306.     if (maxlen > MAXPATHLEN) {
  307.       /* This probably shouldn't happen */
  308.       add_response_err(R_451,"%s: File name too long.", dir);
  309.       return ERROR(cmd);
  310.     }
  311.     
  312.     p_hidden = mod_privdata_alloc(cmd, "stor_hidden_filename", maxlen);
  314.     if (! foundslash) {
  315.       /* Simple local file name */
  316.       sstrncpy(p_hidden->value.str_val, ".in.", maxlen);
  317.       sstrcat(p_hidden->value.str_val, dir, maxlen);
  318.       sstrcat(p_hidden->value.str_val, ".", maxlen);
  319.       log_pri(LOG_DEBUG,"Local path, will rename %s to %s",
  320. p_hidden->value.str_val, p->value.str_val);
  321.     } else {
  322.       /* Complex relative path or absolute path */
  323.       sstrncpy(p_hidden->value.str_val, dir, maxlen);
  324.       p_hidden->value.str_val[basenamestart] = '';
  325.       sstrcat(p_hidden->value.str_val, ".in.", maxlen);
  326.       sstrcat(p_hidden->value.str_val, dir + basenamestart, maxlen);
  327.       sstrcat(p_hidden->value.str_val, ".", maxlen);
  328.       log_pri(LOG_DEBUG,"Complex path, will rename %s to %s",
  329. p_hidden->value.str_val, p->value.str_val);
  331.       if(file_mode(p_hidden->value.str_val)) {
  332.         add_response_err(R_550,"%s: Temporary hidden file %s already exists",
  333. cmd->arg, p_hidden->value.str_val);
  334.         return ERROR(cmd);
  335.       }
  336.     }
  338.     session.xfer.xfer_type = STOR_HIDDEN;
  339.   }
  343.   return HANDLED(cmd);
  344. }
  346. /* cmd_pre_appe is the PRE_CMD handler for the APPEnd command, which
  347.  * simply sets xfer_type to STOR_APPEND and calls pre_cmd_stor
  348.  */
  350. MODRET pre_cmd_appe(cmd_rec *cmd)
  351. {
  352.   session.xfer.xfer_type = STOR_APPEND;
  353.   session.restart_pos = 0L;
  354.   
  355.   return pre_cmd_stor(cmd);
  356. }
  358. MODRET cmd_stor(cmd_rec *cmd)
  359. {
  360.   char *dir;
  361.   char *lbuf;
  362.   int bufsize,len;
  363.   unsigned long respos = 0;
  364.   privdata_t *p, *p_hidden;
  366. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  367.   regex_t *preg;
  368.   int ret;
  369. #endif
  371.   long rate_pos=0, rate_bytes=0, rate_freebytes=0, rate_bps=0;
  372.   int rate_hardbps=0;
  373.   struct timeval rate_tvstart;
  375.   if( (rate_bps = get_param_int(CURRENT_CONF,"RateWriteBPS",FALSE)) == -1 ) { rate_bps=0; }
  376.   if( (rate_freebytes = get_param_int(CURRENT_CONF,"RateWriteFreeBytes",FALSE)) == -1 ) { rate_freebytes=0; }
  377.   rate_hardbps = get_param_int(CURRENT_CONF,"RateWriteHardBPS",FALSE) == 1;
  378.       
  379.   if( rate_bps != 0 ) {
  380.       /* I am not sure this _is_ allowed in ftp protocol... ideas, anyone?
  381.        add_response(R_211,"Allowed bandwidth is %ld bps (starting at %ld).",rate_bps,rate_freebytes);
  382.        */
  383.       log_debug(DEBUG2,"Allowed bandwidth is %ld bps (starting at %ld).",rate_bps,rate_freebytes);
  384.   }
  385.   
  386.   p_hidden = NULL;
  387.   p = mod_privdata_find(cmd,"stor_filename",NULL);
  389.   if(!p) {
  390.     add_response_err(R_550,"%s: internal error, stor_filename not set by cmd_pre_retr",cmd->arg);
  391.     return ERROR(cmd);
  392.   }
  394.   dir = p->value.str_val;
  396.   if(session.xfer.xfer_type == STOR_HIDDEN) {
  397.     p_hidden = mod_privdata_find(cmd,"stor_hidden_filename",NULL);
  398.     if(!p_hidden) {
  399.       add_response_err(R_550,"%s: internal error, stor_hidden_filename not set by cmd_pre_retr",cmd->arg);
  400.       return ERROR(cmd);
  401.     }
  402.   }
  404. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  405.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathAllowFilter",FALSE);
  407.   if(preg && ((ret = regexec(preg,cmd->arg,0,NULL,0)) != 0)) {
  408.     char errmsg[200];
  409.     regerror(ret,preg,errmsg,200);
  410.     log_debug(DEBUG2,"'%s' didn't pass regex: %s",cmd->arg,errmsg);
  411.     add_response_err(R_550,"%s: Forbidden filename", cmd->arg);
  412.     return ERROR(cmd);
  413.   }
  415.   preg = (regex_t*)get_param_ptr(TOPLEVEL_CONF,"PathDenyFilter",FALSE);
  417.   if(preg && ((ret = regexec(preg,cmd->arg,0,NULL,0)) == 0)) {
  418.     add_response_err(R_550,"%s: Forbidden filename", cmd->arg);
  419.     return ERROR(cmd);
  420.   }
  421. #endif
  423.   if(session.xfer.xfer_type == STOR_HIDDEN)
  424.     stor_file = fs_open(p_hidden->value.str_val,
  425. O_WRONLY|(session.restart_pos ? 0 : O_CREAT|O_EXCL),&stor_fd);
  427.   else if(session.xfer.xfer_type == STOR_APPEND)
  428.     stor_file = fs_open(dir, O_WRONLY|O_CREAT|O_APPEND,&stor_fd);
  430.   else /* Normal session */
  431.     stor_file = fs_open(dir,
  432. O_WRONLY|(session.restart_pos ? 0 : O_TRUNC|O_CREAT),&stor_fd);
  435.   if(stor_file && session.restart_pos) {
  436.     if(fs_lseek(stor_file,stor_fd,session.restart_pos,SEEK_SET) == -1) {
  437.       int _errno = errno;
  438.       fs_close(stor_file,stor_fd);
  439.       errno = _errno;
  440.       stor_file = NULL;
  441.     }
  443.     respos = session.restart_pos;
  444.     rate_pos = respos;
  445.     session.restart_pos = 0L;
  446.   }
  448.   if(!stor_file) {
  449.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  450.     return ERROR(cmd);
  451.   } else {
  452.     /* perform the actual transfer now */
  453.     data_init(cmd->arg,IO_READ);
  455.     session.xfer.path = pstrdup(session.xfer.p,dir);
  456.     if(session.xfer.xfer_type == STOR_HIDDEN)
  457.       session.xfer.path_hidden = pstrdup(session.xfer.p, p_hidden->value.str_val);
  458.     else
  459.       session.xfer.path_hidden = NULL;
  460.       
  461.     session.xfer.file_size = respos;
  463.     if(data_open(cmd->arg,NULL,IO_READ,0) < 0) {
  464.       data_abort(0,TRUE);
  465.       return HANDLED(cmd);
  466.     }
  468.     bufsize = (main_server->tcp_rwin > 0 ? main_server->tcp_rwin : 1024);
  469.     lbuf = (char*) palloc(cmd->tmp_pool, bufsize);
  470.     
  471.     gettimeofday(&rate_tvstart, NULL);
  472.     while((len = data_xfer(lbuf, bufsize)) > 0) {
  473.       if(XFER_ABORTED)
  474.         break;
  476.       len = fs_write(stor_file, stor_fd, lbuf, len);
  477.       if(len < 0) {
  478.         int s_errno = errno;
  479.         _stor_abort();
  480.         data_abort(s_errno, FALSE);
  481.         return ERROR(cmd);
  482.       }
  484.       if(rate_bps) {
  485.           rate_pos += len;
  486.           rate_bytes += len;
  487.   _rate_throttle(rate_pos, rate_bytes, rate_tvstart, rate_freebytes,
  488.  rate_bps, rate_hardbps);
  489.       }
  490.     }
  492.     if(XFER_ABORTED) {
  493.       _stor_abort();
  494.       data_abort(0,0);
  495.       return ERROR(cmd);
  496.     } else if(len < 0) {
  497.       _stor_abort();
  498.       data_abort(session.d->inf->xerrno,FALSE);
  499.       return ERROR(cmd);
  500.     } else {
  501.       if(session.xfer.path && session.xfer.path_hidden) {
  502.         if(fs_rename(session.xfer.path_hidden,session.xfer.path) != 0) {
  503.           /* This should only fail on a race condition with a chmod/chown
  504.            * or if STOR_APPEND is on and the permissions are squirrely.
  505.            * The poor user will have to re-upload, but we've got more important
  506.            * problems to worry about and this failure should be fairly rare.
  507.            */
  508.            log_pri(LOG_WARNING,"Rename of %s to %s failed: %s",
  509.              session.xfer.path_hidden, session.xfer.path, strerror(errno));
  510.            add_response_err(R_550,"%s: rename of hidden file %s failed: %s",
  511.              session.xfer.path, session.xfer.path_hidden, strerror(errno));
  512.            unlink(session.xfer.path_hidden);
  514.            return ERROR(cmd);
  515.          }
  516.       }
  517.       _stor_done();
  518.       data_close(FALSE);
  519.     }
  520.   }
  521.   return HANDLED(cmd);
  522. }
  524. MODRET cmd_rest(cmd_rec *cmd)
  525. {
  526.   long int pos;
  527.   char *endp;
  529.   if(cmd->argc != 2) {
  530.     add_response_err(R_500,"'%s': command not understood.",get_full_cmd(cmd));
  531.     return ERROR(cmd);
  532.   }
  534.   pos = strtol(cmd->argv[1],&endp,10);
  535.   if((endp && *endp) || pos < 0) {
  536.     add_response_err(R_501,"REST requires a value greater than or equal to 0.");
  537.     return ERROR(cmd);
  538.   }
  540.   session.restart_pos = pos;
  541.   add_response(R_350,"Restarting at %ld. Send STORE or RETRIEVE to initiate transfer.",
  542.                 pos);
  543.   return HANDLED(cmd);
  544. }
  546. /* cmd_pre_retr is a PRE_CMD handler which checks security, etc, and
  547.  * places the full filename to send in cmd->private [note that we CANNOT
  548.  * use cmd->tmp_pool for this, as tmp_pool only lasts for the duration
  549.  * of this function.
  550.  */
  552. MODRET pre_cmd_retr(cmd_rec *cmd)
  553. {
  554.   char *dir;
  555.   mode_t fmode;
  556.   privdata_t *p;
  558.   if(cmd->argc < 2) {
  559.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  560.     return ERROR(cmd);
  561.   }
  563.   dir = dir_realpath(cmd->tmp_pool,cmd->arg);
  565.   if(!dir || !dir_check(cmd->tmp_pool,cmd->argv[0],cmd->group,dir,NULL)) {
  566.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  567.     return ERROR(cmd);
  568.   }
  571.   fmode = file_mode(dir);
  573.   if(!S_ISREG(fmode)) {
  574.     if(!fmode)
  575.       add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  576.     else
  577.       add_response_err(R_550,"%s: Not a regular file",cmd->arg);
  578.     return ERROR(cmd);
  579.   }
  581.   /* If restart is on, check to see if AllowRestartRetrieve
  582.    * is off, in which case we disallow the transfer and
  583.    * clear restart_pos
  584.    */
  586.   if(session.restart_pos &&
  587.      get_param_int(CURRENT_CONF,"AllowRetrieveRestart",FALSE) == 0) {
  588.     add_response_err(R_451,"%s: Restart not permitted, try again.",
  589.                   cmd->arg);
  590.     session.restart_pos = 0L;
  591.     return ERROR(cmd);
  592.   }
  594.   /* otherwise everthing is good */
  595.   p = mod_privdata_alloc(cmd,"retr_filename",strlen(dir)+1);
  596.   sstrncpy(p->value.str_val, dir, strlen(dir) + 1);
  597.   return HANDLED(cmd);
  598. }
  600. MODRET cmd_retr(cmd_rec *cmd)
  601. {
  602.   char *dir, *lbuf;
  603.   struct stat sbuf;
  604.   struct timeval rate_tvstart;
  605.   privdata_t *p;
  606.   int bufsize, len = 0;
  607.   int rate_hardbps = 0;
  608.   unsigned long respos = 0,cnt = 0,cnt_steps = 0,cnt_next = 0;
  609.   long rate_bytes = 0, rate_freebytes = 0, rate_bps = 0;
  610.   off_t off;
  612.   if((rate_bps = get_param_int(CURRENT_CONF, "RateReadBPS", FALSE)) == -1)
  613.     rate_bps = 0;
  615.   if((rate_freebytes = get_param_int(CURRENT_CONF,
  616.      "RateReadFreeBytes", FALSE)) == -1)
  617.     rate_freebytes = 0;
  618.   
  619.   rate_hardbps = get_param_int(CURRENT_CONF,"RateReadHardBPS",FALSE) == 1;
  620.   
  621.   if(rate_bps != 0) {
  622.       /* I am not sure this _is_ allowed in ftp protocol... ideas, anyone?
  623.  add_response(R_211,"Allowed bandwidth is %ld bps (starting at %ld).",rate_bps,rate_freebytes);
  624.       */
  625.     log_debug(DEBUG2,"Allowed bandwidth is %ld bps (starting at %ld).",rate_bps,rate_freebytes);
  626.   }
  627.   
  628.   p = mod_privdata_find(cmd,"retr_filename",NULL);
  629.   
  630.   if(!p) {
  631.     add_response_err(R_550, "%s: internal error, what happened to "
  632.      "cmd_pre_retr?!?", cmd->arg);
  633.     return ERROR(cmd);
  634.   }
  635.   
  636.   dir = p->value.str_val;
  637.   retr_file = fs_open(dir,O_RDONLY,&retr_fd);
  639.   if(session.restart_pos) {
  640.     if(fs_lseek(retr_file,retr_fd,session.restart_pos,SEEK_SET) == -1) {
  641.       int _errno = errno;
  642.       fs_close(retr_file,retr_fd);
  643.       errno = _errno;
  644.       retr_file = NULL;
  645.     }
  647.     respos = session.restart_pos;
  648.     session.restart_pos = 0L;
  649.   }
  651.   if(!retr_file || fs_stat(dir,&sbuf) == -1) {
  652.     add_response_err(R_550,"%s: %s",cmd->arg,strerror(errno));
  653.     return ERROR(cmd);
  654.   } else {
  655.     /* send the data */
  656.     data_init(cmd->arg,IO_WRITE);
  658.     session.xfer.path = pstrdup(session.xfer.p,dir);
  659.     session.xfer.file_size = (unsigned long)sbuf.st_size;
  660.     cnt_steps = session.xfer.file_size / 100;
  661.     if(cnt_steps == 0)
  662.       cnt_steps = 1;
  664.     if(data_open(cmd->arg,NULL,IO_WRITE,sbuf.st_size - respos) < 0) {
  665.       data_abort(0,TRUE);
  666.       return ERROR(cmd);
  667.     }
  669.     bufsize = (main_server->tcp_swin > 0 ? main_server->tcp_swin : 1024);
  670.     lbuf = (char*)palloc(cmd->tmp_pool,bufsize);
  672.     cnt = respos;
  673.     log_add_run(mpid, NULL, session.user,
  674. (session.class && session.class->name) ? session.class->name :
  675. "",
  676. NULL, 0, session.xfer.file_size, 0, NULL);
  678.     gettimeofday(&rate_tvstart, NULL);
  679.     off = respos;
  680.     
  681.     while(cnt != session.xfer.file_size) {
  682.       if((len = fs_read(retr_file, retr_fd, lbuf, bufsize)) <= 0)
  683. break;
  684.       
  685.       if(XFER_ABORTED)
  686.         break;
  687.       
  688. #ifdef HAVE_SENDFILE
  689.       if(session.flags & (SF_ASCII | SF_ASCII_OVERRIDE)) {
  690. len = data_xfer(lbuf, len);
  691. goto done;
  692.       }
  693.       
  694.       len = data_sendfile(retr_fd, &off, session.xfer.file_size - cnt);
  695.       if(len == -1) {
  696. log_pri(LOG_ERR, "data_sendfile error: %d:%s",
  697. errno, strerror(errno));
  698. switch (errno) {
  699. case EAGAIN:
  700.   continue;
  701. default:
  702.   log_pri(LOG_ERR, "unknown data_sendfile() error %d: %s",
  703.   errno, strerror(errno));
  704. }
  705.       }
  707.     done:
  708. #else
  709.       len = data_xfer(lbuf, len);
  710. #endif /* HAVE_SENDFILE */
  712.       
  713.       if(len < 0) {
  714.         _retr_abort();
  715.         data_abort(session.d->outf->xerrno,FALSE);
  716.         return ERROR(cmd);
  717.       }
  719.       cnt += len;
  720.       rate_bytes += len;
  721.       
  722.       if((cnt / cnt_steps) != cnt_next) {
  723. cnt_next = cnt / cnt_steps;
  724. log_add_run(mpid, NULL, session.user,
  725.     (session.class && session.class->name) ?
  726.     session.class->name : "",
  727.     NULL, 0, session.xfer.file_size, cnt, NULL);
  728.       }
  729.       
  730.       if(rate_bps) {
  731. _rate_throttle(cnt, rate_bytes, rate_tvstart, rate_freebytes,
  732.        rate_bps, rate_hardbps);
  733.       }
  734.     }
  735.     
  736.     if(XFER_ABORTED) {
  737.       _retr_abort();
  738.       data_abort(0,0);
  739.       return ERROR(cmd);
  740.     } else if(len < 0) {
  741.       _retr_abort();
  742.       data_abort(errno,FALSE);
  743.       return ERROR(cmd);
  744.     } else {
  745.       _retr_done();
  746.       data_close(FALSE);
  747.     }
  748.   }
  749.   
  750.   return HANDLED(cmd);
  751. }
  753. MODRET cmd_abor(cmd_rec *cmd)
  754. {
  755.   if(cmd->argc != 1) {
  756.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  757.     return ERROR(cmd);
  758.   }
  760.   if(session.flags & (SF_POST_ABORT|SF_ABORT)) {
  761.     session.flags &= ~(SF_POST_ABORT|SF_ABORT);
  762.     add_response(R_226,"Abort successful");
  763.     return HANDLED(cmd);
  764.   }
  766.   add_response_err(R_500,"No command to abort.");
  767.   return ERROR(cmd);
  768. }
  770. MODRET cmd_type(cmd_rec *cmd)
  771. {
  772.   if(cmd->argc < 2 || cmd->argc > 3) {
  773.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  774.     return ERROR(cmd);
  775.   }
  777.   cmd->argv[1][0] = toupper(cmd->argv[1][0]);
  779.   if(!strcmp(cmd->argv[1],"A"))
  780.     session.flags |= SF_ASCII;
  781.   else if(!strcmp(cmd->argv[1],"I"))
  782.     session.flags &= (SF_ALL^SF_ASCII);
  783.   else {
  784.     add_response_err(R_500,"'%s' not understood.",get_full_cmd(cmd));
  785.     return ERROR(cmd);
  786.   }
  788.   add_response(R_200,"Type set to %s.",cmd->argv[1]);
  789.   return HANDLED(cmd);
  790. }
  792. MODRET log_stor(cmd_rec *cmd)
  793. {
  794.   _log_transfer('i');
  795.   return DECLINED(cmd);
  796. }
  798. MODRET log_retr(cmd_rec *cmd)
  799. {
  800.   _log_transfer('o');
  801.   return DECLINED(cmd);
  802. }
  804. static int _noxfer_timeout(CALLBACK_FRAME)
  805. {
  806.   if(session.flags & SF_XFER)
  807.     return TRUE; /* Transfer in progress, ignore timeout */
  809.   send_response_async(R_421,
  810.            "No Transfer Timeout (%d seconds): closing control connection.",
  811.            TimeoutNoXfer);
  813. #if 0 /* no longer needed */
  814.   schedule(main_exit,0,(void*)LOG_NOTICE,"FTP no transfer time out, disconnected.",
  815.            (void*)0,NULL);
  816. #endif
  817.   
  818.   remove_timer(TIMER_IDLE,ANY_MODULE);
  819.   remove_timer(TIMER_LOGIN,ANY_MODULE);
  821.   main_exit((void*)LOG_NOTICE,"FTP no transfer timeout, disconnected.",
  822.   (void*)0,NULL);
  823.   return 0;
  824. }
  826. int xfer_init_child()
  827. {
  828.   /* Setup TimeoutNoXfer timer */
  829.   if(TimeoutNoXfer)
  830.     add_timer(TimeoutNoXfer,TIMER_NOXFER,&xfer_module,_noxfer_timeout);
  831.   return 0;
  832. }
  834. MODRET add_ratenum(cmd_rec *cmd)
  835. {
  836.   config_rec *c;
  837.   long ratenum;
  838.   char *endp;
  840.   CHECK_ARGS(cmd,1);
  841.   CHECK_CONF(cmd, CONF_ROOT | CONF_VIRTUAL | CONF_ANON | CONF_DIR | CONF_GLOBAL);
  843.   if(cmd->argc != 2 )
  844.       CONF_ERROR(cmd,"invalid number of arguments");
  846.   if(!strcasecmp(cmd->argv[1],"none"))
  847.     ratenum = 0;
  848.   else {
  849.     ratenum = (int)strtol(cmd->argv[1],&endp,10);
  851.     if((endp && *endp) || ratenum < 0)
  852.       CONF_ERROR(cmd,"argument must be 'none' or a positive integer.");
  853.   }
  855.   log_debug(DEBUG5,"add_ratenum: %s %ld",cmd->argv[0],ratenum);
  857.   c = add_config_param( cmd->argv[0], 1, (void*)ratenum );
  858.   c->flags |= CF_MERGEDOWN;
  860.   return HANDLED(cmd);
  861. }
  863. MODRET add_ratebool(cmd_rec *cmd)
  864. {
  865.   config_rec *c;
  866.   int b;
  868.   CHECK_ARGS(cmd,1);
  869.   CHECK_CONF(cmd, CONF_ROOT | CONF_VIRTUAL | CONF_ANON | CONF_DIR | CONF_GLOBAL);
  871.   if((b = get_boolean(cmd,1)) == -1)
  872.     CONF_ERROR(cmd,"expected boolean argument.");
  874.   log_debug(DEBUG5,"add_ratebool: %s %d",cmd->argv[0],b);
  876.   c = add_config_param( cmd->argv[0], 1, (void*)b );
  877.   c->flags |= CF_MERGEDOWN;
  879.   return HANDLED(cmd);
  880. }
  882. conftable xfer_config[] = {
  883.   { "RateReadBPS", add_ratenum,                 },
  884.   { "RateReadFreeBytes", add_ratenum,              },
  885.   { "RateReadHardBPS", add_ratebool,                },
  886.   { "RateWriteBPS", add_ratenum,                 },
  887.   { "RateWriteFreeBytes", add_ratenum,              },
  888.   { "RateWriteHardBPS", add_ratebool,                },
  889.   { NULL }
  890. };
  892. cmdtable xfer_commands[] = {
  893.   { CMD,     C_TYPE, G_NONE,  cmd_type, TRUE, FALSE, CL_MISC },
  894.   { PRE_CMD, C_RETR, G_READ,  pre_cmd_retr, TRUE, FALSE },
  895.   { CMD,     C_RETR, G_READ,  cmd_retr, TRUE, FALSE, CL_READ },
  896.   { LOG_CMD, C_RETR, G_NONE,  log_retr, FALSE,  FALSE },
  897.   { PRE_CMD, C_STOR, G_WRITE, pre_cmd_stor, TRUE, FALSE },
  898.   { CMD,     C_STOR, G_WRITE, cmd_stor, TRUE, FALSE, CL_WRITE },
  899.   { LOG_CMD, C_STOR,    G_NONE,  log_stor, FALSE,  FALSE },
  900.   { PRE_CMD, C_APPE, G_WRITE, pre_cmd_appe, TRUE, FALSE },
  901.   { CMD,     C_APPE, G_WRITE, cmd_stor, TRUE, FALSE, CL_WRITE },
  902.   { LOG_CMD, C_APPE, G_NONE,  log_stor, FALSE,  FALSE },
  903.   { CMD,     C_ABOR, G_NONE,  cmd_abor, TRUE, TRUE,  CL_MISC  },
  904.   { CMD,     C_REST, G_NONE,  cmd_rest, TRUE, FALSE, CL_MISC  },
  905.   { 0,NULL }
  906. };
  908. module xfer_module = {
  909.   NULL,NULL, /* Always NULL */
  910.   0x20, /* API Version */
  911.   "xfer", /* Module name */
  912.   xfer_config,
  913.   xfer_commands,
  914.   NULL,
  915.   NULL,xfer_init_child
  916. };